Event Replay: Crosschain Payments with CCTP

Welcome and intro: Trails + CCTP Fast Transfer

And welcome. Welcome. Welcome. Welcome, everybody. This is our, man. I can’t believe it’s already halfway through the month.

Oh, man. What a year it’s been. It’s flying, isn’t it? Yeah. But, yeah, super excited, James, man. I’m glad to connect live here with you. You’ve been doing a lot of incredible work.

Not just, I mean, I’ve been going through here, and I’ll kinda give a little intro here. I have to write it down. You know? So, you’ve been working at Trails, leading DevRel, which is incredible.

And for those who don’t know, Trails is a cross-chain payment infrastructure that’s built to make USDC payments universal across networks. So that’s very exciting stuff. And today, we’re gonna jump into how you’re leveraging CCTP, Fast Transfer, and some really innovative ways. So, welcome to the show, and thanks for joining.

Awesome. Thank you so much for inviting me, Sam. Super excited to be here to showcase what Trails is, how we integrated with CCTP, how easy it was, of course, and then the really cool stuff that you can enable—and the cool stuff that we enable through USDC. Really excited to talk more about it, get hands-on technical. There’s a lot of good stuff coming.

James’s background and what Trails is building

I love it. I love it. So let’s start off. First of all, shout out to everyone joining in, Smart and everybody else.

Tell us a little bit about your background and how we ended up to this point here at Trails.

Yeah. That’s a great question. So I’ve been in crypto for eight years or so now, working as an engineer, solutions architect, leading integrations. I worked a lot with different cross-chain infrastructure, worked a lot with different interoperability protocols. And really, Trails is the culmination of not just the work that I’ve done personally, but from the entire team.

So Trails is really produced by an organization called Sequence. We’ve been in the web3 space since around 2017, and we’ve done a lot of work on account abstraction. If you’re familiar with that, we do multichain deployments on the infrastructure level. And now we are laser focused on: how can we make cross-chain payments very simple in reducing this fragmentation problem that exists between chains, tokens, and wallets. And that’s really what Trails is all about—how can we make it very simple just like tapping a credit card but with blockchain.

Building with Circle, ARC, and CCTP

Very exciting. And I know we started working closely together because you and your team have been working pretty closely with Circle to ensure that it integrates seamlessly with ARC as well. How has that experience been?

So it’s been—I mean, ARC was very easy to deploy on. I think one of the easiest networks. We have a lot of experience. Sequence as an infrastructure has over fifty different blockchain networks that are integrated now.

Amazing.

Amazing. We’ve done a lot, and I’ve seen other networks are sometimes not so easy. But we’ve also deployed on ARC, and so that’s really exciting. Looking forward to ARC mainnet as well—would love to showcase there.

But in general, it’s been a pleasure not only to build on ARC and deploy all of our infrastructure there, but also leveraging CCTP. That was actually very easy to get started and to have a production-ready implementation, which we have now with Trails.

Use cases: universal intents + account abstraction

What are some of the key use cases that you’ve been seeing folks leveraging Trails with?

Yeah. I think, just to start with a little bit about the background behind Trails: this is a culmination between all the work we’ve done on account abstraction while fusing it with kind of this next-gen intents network setup. So we call Trails kind of the universal intents SDK.

And what this allows you to do—typically, building with intents is really cumbersome, very difficult, but they use a lot of innovative infrastructure to make it very seamless to have cross-chain interactions.

And we build on this with account abstraction in order to make the entire flow entirely seamless, as well as enable verifiable on-chain execution.

So what do all these buzzwords mean? Ultimately, it means you can pay much easier from any wallet, any token, any chain within one click. So that’s really the magic. You simplify everything down, and all these different use cases—even though there’s complexity under the hood, we simplify this in an SDK, so users can pay, they can fund, and they can swap extremely easily.

So whether you’re doing on-ramping, whether you’re doing a typical swapping widget, or you just wanna pay in a marketplace or make cross-chain payments—Trails makes it very easy. And obviously, of course, it’s underpinned by CCTP, which makes it a real pleasure whenever you’re doing high volume. You can have low slippage. It’s really a pleasure.

Why CCTP Fast Transfer: “everything is fast”

And I remember I was asking, I said, are you all using Fast Transfer? And you were like, yes. Everything is Fast Transfer. Talk a little bit about that.

Everything is fast. Trails is optimized to be fast. That’s why we went specifically with Fast Transfer, because we saw this new version coming out. And so we were really excited to put it through its paces.

And I’ll say, I was testing in preparation for the demo today, and end-to-end with Trails with CCTP was three seconds from Base to Arbitrum. So it was super fast. It does kinda change a little bit, but three seconds—I was blown away. So, yeah, very excited.

Screen share: how Trails integrates CCTP under the hood

Yeah. So I would like to first start out kind of—I already talked a little bit really high level what Trails is—and I would love to start out. I’ll go ahead and share my screen, and we can talk a little bit about how we integrated CCTP, why we decided to focus on that specifically, and also how easy it was to actually enable Trails.

Like I said, our core value prop is: we want it fast, we want low fees, and CCTP met basically all these requirements. And we also wanted long-tail chain support and high reliability. So this is a crucial reason why we wanted to build on CCTP in the first place.

And what Trails enables through CCTP, by building on top, is some really unique things.

So to kinda go through the flow of how Trails works in combination with CCTP: the user can initiate any kind of cross-chain transfer using any token from any wallet within one click.

What’s happening under the hood is we’re swapping on the origin chain for USDC, obviously. And then we’re going through the traditional mint-and-burn process that CCTP enables with all that security.

So we integrated Circle’s API. And in the back end, we’re doing the typical deposit on the origin chain. It goes to the CCTP validation process and verification process to make sure it’s secure, reliable, it’s effectively burned on the origin and then minted on the destination.

And we combine this with some of our own technology. We’re basically reading this CCTP monitor to make sure that the transaction has happened on the destination chain.

And then ultimately, once it goes through all those validation checks, we have a relayer on the destination side.

And what’s really unique about Trails—and what differentiates it from other intent infrastructure—is we combine it with account abstraction. So all the actions that a user wants to take actually get encoded on-chain into an account abstraction wallet that the user has self-custody over. And so this means that our relayer simply looks at that wallet, looks at the actions that the user signed off on, and then will only do those corresponding actions.

So the user gets the best UX possible while also having end-to-end control over their assets across the swapping process, across the minting process, and so on and so forth.

Trust model: user retains control

And one of the things you said was the user—say that again—you said the user maintains control?

Exactly. Yep. So that’s very unique to Trails. It is trustless infrastructure. And so we call it Intents 3.0.

So again, the user will sign a transaction like a normal blockchain transaction from their wallet, right? But this can be from an EOA. It can be from a smart contract wallet. It can be from a Privy embedded wallet—whatever they wanna use.

Doesn’t matter. It’s still all one click. And they just send a transfer to what we call an intent address, and that intent address has all the instructions on-chain, and that’s only what the relayer can operate on.

But the user still retains control over that address, so they can always withdraw those funds at any point in time. It’s a seamless experience. And they still get to use their traditional MetaMask wallet or Rabby wallet—whatever their favorite EOA is or whatever wallet the developer implemented.

Live demo: swap + bridge with CCTP

So enough with the jargon. Seeing is believing. What does it look like? Let’s play with it.

Yeah. I think that’s what everybody wants to know. So here, I’m gonna show a little bit about our demo application.

I like to start with swap because that’s generally what everyone is familiar with.

What’s really cool here is that we have a bunch of different settings. So if you want a gasless implementation, you can also add a 4337 Paymaster. But what we’re gonna do down here is we’re gonna specify the bridge provider as CCTP.

So let’s just do kind of a simple—twenty cents. You’ll notice that all I did was choose USDC Base on the origin side, and it’s just going to transfer to USDC on Arbitrum. So you’ll notice I just signed one time with my wallet.

And what’s happening is I’m depositing into this intent address that I talked about earlier. That’s where everything’s verified on-chain. I’m doing a swap and a bridge.

You’ll see end-to-end within seconds. And just to verify we’re using CCTP: we have Basescan loaded up, and you’ll see that what’s happening under the hood is—in this case there’s no swap—so this intent address is just calling that Circle CCTP token minter. It’s burning this USDC. You can see that contract is sending it to the burn address.

And then on the destination side, the user—in this case myself—is just getting USDC on the other side end-to-end within seconds.

Demo: swap from native ETH on Base, then bridge via CCTP

That’s actually the least exciting of all the use cases. We’re just warming up.

So let’s try something more interesting. I’ll try the native token on Base.

One thing I wanna point out is Trails is powered by Sequence, which has multichain infrastructure. So we’re reading a high-performance indexer, and I’m getting my entire wallet balance that I can choose from. So I can choose any of these tokens to make a payment, make a swap, or deposit into a DeFi vault across my entire wallet.

So again, now I’m going to choose ETH on Base. It’ll show the total output along with all the gas costs and everything.

Even though there’s added complexity—on the origin chain I’m doing a swap, and then I’m using CCTP—Trails hides all this underneath.

And you can see a swap was performed previously, so that’s using on-chain liquidity pools, and then the bridge happened.

Previously, I swapped my wrapped Ethereum for USDC, then deposited USDC into CCTP, and then did the bridge transaction.

Embedding: widget, headless, hooks, API

This is smooth.

And if you’ve ever worked with chain abstraction infrastructure or cross-chain interoperability infrastructure, you’ll quickly realize it’s a nightmare to implement or it takes weeks to have a very smooth experience. We are hyper optimized around getting more volume into your application, getting more liquidity into your application, and enhancing conversion rate.

One thing I wanna point out: even though I’m using the widget right now, this is completely headless. You can either have this widget design, or you can use all the Trails infrastructure and build your own UX and UI. You can also do this on your backend via API. This is the fastest, to be honest. But if you do wanna go custom, that’s an option as well.

Demo scenario: deposit USDC into Aave (bridge + execute)

I talked a little bit about how you can chain different actions. Because Trails enables verifiable on-chain execution, it also means it’s a completely trustless system.

So what’s really cool is you can actually—we have a few of these scenarios within this playground.

For instance, I’m selecting this one scenario: I want to deposit USDC into an Aave lending pool.

And this will automatically pass in the contract address of the Aave lending pool, the token that’s expected for it, and it will also do the calldata that’s necessary.

And I think for devs, typically, this would take a long time to integrate and take quite a lot of permutations where you gotta find the contract address and the calldata and bundle it all together. Trails does a lot of this for you.

Here, I’m going to use USDC on Arbitrum. Again, this will just do a deposit to the intent address. It will also do a bridge—so I’m using USDC, no swap is necessary. Then it’ll also automatically deposit into a DeFi vault on Base as well. So it orchestrates end-to-end.

And you can see we got an Aave pool token back into our wallet address.

Q&A: can the widget be embedded into any app?

I see a question out here: this widget, can it be embedded into any app?

No, that’s exactly right. We have a React package. If you do want a completely headless integration, you can do that as well. You can do it via hooks functionality. And lastly, if you’re integrating or you prefer the API, you can do a Trails integration just with the API.

It’s super simple: you request a quote, you commit that quote, you execute that quote, and then you just watch the blockchain to get a response. And you’re done.

Using USDC for gas: “universal gas token” experience

What I also wanted to show is how we enable USDC as this universal gas token across any chain that’s supported.

I think everyone in crypto—if you’ve ever bridged to a new chain—has had this problem: you bridge over, maybe bridge USDC, and you realize you didn’t bridge any of the native token for that chain. So you either gotta go back, bridge again, go back and forth, sign new transactions, and so on.

So this is really cool where you can use Trails, and you can use USDC as the gas payment across any chain that’s supported. Literally, you’re just signing a permit-compatible flow. And you can use USDC for any smart contract interaction. So you don’t need the native token for the chain—that’s handled on the backend. You can just have your stablecoin, use it end-to-end across any chain in a chain-abstracted way.

Getting started: early access, dashboard, starter kit

What I recommend is: go to the main site, grab early access, enter your email. On the next wave, we’ll send you API keys. It’ll be this week, and you can start building right away.

You’ll come to our Trails dashboard. Set up a project. Install the package in your application. Grab your API key. And then we have examples for each different mode.

If you’re building from scratch or you’re just wanting to play around with Trails, you can run our minimal starter kit. Literally, this is one line of code, and it will install everything for you.

Local dev: forcing CCTP as the bridge provider

And you can see, really, the integration for Trails is literally this block of code here—and it can be much more minimal than this.

You’re going to want to add the bridge provider as CCTP, and that’ll force using CCTP for the bridge. You just pass in your API key, and you’re off to the races.

Vibe coding: Mintlify + MCP + Cursor integration

The last thing since I just promised the LLM integration: we have an LLM integration right here under resources.

If you wanna plug in your MCP server—if you’re using Cursor and the Model Context Protocol—you can plug this right in. It will query our documentation anytime you’re running Trails and build you entire components. It pulls exactly from our documentation and APIs.

Roadmap: fiat on-ramp flow + any chain/token via CCTP

On the roadmap, we’ll be launching—if not today, then later on this week—our funding flow.

You can use a multitude of different fiat on-ramp options like credit, debit card, PayPal, Revolut, Apple Pay, Google Pay, connect to exchange accounts, pay with a QR code, etcetera.

What makes this different: on-ramp providers only support so many chains and only have so much liquidity. Trails enables you to on-ramp to any token to any chain—even if that on-ramp provider doesn’t support it—by using USDC as the hub and then orchestrating through CCTP.

Q&A: early access, Circle account, fees

Early access: sign up, and literally tomorrow or the day after, you’ll get your API key and access to the demo link.

Do you need a Circle developer account? We’re not doing KYB. We’re just using CCTP under the hood.

Can developers build in dev fees? We will have a fee-sharing model so you can build in your own dev fees. That’s not live right now, but it’s something we will have in the future.

Wrap-up: support channels and closing

Any questions, we have a Telegram group set up. All our engineers are there. Customer support is there. We’re really active support around the world.

And maybe we can combine and do a Trails developer builder update and spotlight top builds.

Thank you everybody for hanging out. Really appreciated it. Had a lot of fun.

What was the cat’s name? That was Mia. I got Mia and Leah.

Awesome. Thank you again. We’ll see everybody on Discord. Come hang out with us. Take care.

Perfect. Ciao. Ciao.