Build On Arc With The Circle Platform I Hui Jing Chen

Hello everyone. I'm HJ from the Circle Devril team and today I'm going to run through a quick overview of Arc and the suite of Circle developer tools that you can use to build on it. Now we announced ARC back in August last year and it is an economic operating system for the internet. What this means, and I'll go into more detail later, is that ARC has native capabilities that applications can rely on as building blocks like stable value assets, interoperability, and financial infrastructure. You can use these to build out powerful multi-chain flows with our developer tooling.

ARC is a fully EVM compatible layer 1 blockchain, so you don't have to change much of your existing workflows. All the smart contracts that work on other EVM chains can be deployed to ARC without changes and they will work out of the box. All the innovation that is acred in the solidity ecosystem can be carried over to ARC with the added benefit of what ARC can offer at the primitive level now. We've been helping builders build programmable money flows on chain for quite some time and we've taken our learnings and incorporated them into the design decisions for ARC. Now for ARC USDC is the native gas token which is a pretty big UX enhancement especially if your application flows use USDC as token of choice that your end user interacts with.

Now, one thing to note is that on ARC, the native gas token USDC is in 18 decimal, kind of like ETH on Ethereum, but we also have an ERC20 interface, which is six decimals, and that's the interface that you would interact with using the same AI functions like the ones you use on any other EVM compatible blockchain. Crosschain interop is very key for ARC as well. So, we have two primitives for that, CCTP and gateway. So CCTP lets you execute secure native USDC transfer across 20 blockchains using native burn and mint with no wrap tokens. Now gateway lets you as the developer take USDC from balances across multiple different chains and unify them as if it was one balance and then transact on wherever you need the USDC to go.

Once you've consolidated the gateway balance, transferring out from it is subsecond. So anything that needs frequent instant access to USDC across chains, gateway is pretty good for that. Now because ARC uses Malikite, which is a tender style BFT consensus algorithm implemented in Rust, finality is deterministic and under a second. So once twothirds of the validator set commit a block, that's it. No reors, no rollbacks.

But that's the consensus layer which orders transactions and finalizes blocks. The execution layer is RE which applies those transactions to the ledger and processes them. And something the team is actively work working on right now is privacy. ARC will provide opt-in configurable privacy enabling selective shielding of balances and transactions while maintaining auditability which is a requirement for quite a few financial institutions. Now this is circle's full stack platform with ARC as the underlying infrastructure layer or you know operating group.

Now we have stable coins tokenized assets that on top of ARC and they're supported by services that manage and move these assets. Developers can build with tools like Circle Wallets, CCTP gateway and then on top is a growing ecosystem of applications. So from first-party products like CPN, the partner integration and thirdparty apps built by developers like you who can leverage these layers to solve real world problems with onchain innovation. I mean that's what this hackathon is for, right? There are trillions of dollars in today's financial system that are not yet onchain.

We believe art can be the foundation that brings much of this value onto blockchain rails. There's potential for building credit systems that use stable coins and trusted data sources. Or you could modernize capital markets with stable coinbased settlement. ARC can also support emerging use cases like agentic commerce where autonomous systems and IoT devices make payments directly on chain. And this list nowhere near exhausted.

I'm sure there's plenty more ideas that you all can develop with the building blocks available. But let's talk about the interop building blocks. So I mentioned CCTP earlier which is short for crosschain transfer protocol. Now while you can use it directly we have an SDK for you as well. PCTP transfers USDC using an issuer managed burn-in mint model instead of locking tokens minting wrapped assets.

So you burn USDC on the source chain and then you use the transaction hash to request an attestation from circle which is then used to mint USDC on the destination chain. The team released Bridgekit to abstract a lot of the complexities of building with CCTP. It is a TypeScript SDK that is highly configurable. In addition to the main function of Bridging, there's also a lot of supporting features like retry and custom feed. So, I highly encourage you to check it out, especially if you tried integrating CCTP before and gave up because, you know, it was kind of complicated.

Now, Gateway is our solution for establishing a unified USDC ballot. Now we don't yet have an SDK. So do check out our documentation for some example implementation scripts for guidance. Uh gateway currently supports 12 mainet chains and nine testn net chains. The most recent one being Salana.

So this is how the flow of gateway works. You'll have to deposit USDC into a gateway wallet contract. Now the time to finality will vary depending on the chain. Like for Arc or Avalanche, it's usually a matter of seconds, but Ethereum or base will take a little longer. Once finalized though, your deposits can be transferred near instantly to any of the supported destination chains.

Now, to initiate a transfer, you must submit a signed burn intent via the gateway API and then you use the signed attestation to mint USDC on the destination chain. Then we have Circle Wallets, which is our wallets as a service. So if you think about it, wallets are the entry point to doing anything on a blockchain. So for circle wallets, we have three wallet model. Developer controlled wallets lets applications manage keys and execute transactions on behalf of users.

So more for embedded wallets within your app. User controlled wallets give your end users full control of their keys and then makes use of circle's secure client SDKs for O and recovery. Now the teams that need deeper customization, there is modular wallets that will allow developers to kind of combine circles wallet orchestration with their own node infrastructure, key management systems or pay master services. So now it's time to walk through some code. Uh I'm not going to, you know, show you full applications, but I want to highlight specific parts of our SDKs, especially if you've never used them before to show you like which are the most powerful bits of it and how they fit together.

Okay, code time. Uh if you've never used Circle Developer Services before, the first thing you want to do is go sign up for a Circle Developer account. This is going to give you access to the Circle Console. Looks like this. And we want to go to keys to generate an API key.

Pretty typical for most services. Create your key and you know copy it. It's only going to show up once I believe. Now this API key is going to be used to generate an entity secret which is a 32 byt random private key and this is used to secure your developer wallets. So you grab that API key and then we'll come here.

Oh, the dependencies for all the code that I'm going to talk about is here. Developer control. Well, it's SDK. Then there's also Bridgekit and adapter. We'll cover that later.

So, let's go to setup. And so, import the SDK. And you can run generate entity secret. So, let's run this and see what it does. So, you will generate this entity secret, right?

And you can plug this entity secret into this function called register entity secret cipher text. And what when you run it, it will register your entity secret and then give you a recovery file. This process can happen on the console via GUI as well. I'm not going to run it because it's a one-off setup thing. I've already done mine.

Um, so yeah. So now we are ready to do wallets. So first thing we want to do is to create a wallet set which is the source from which individual wallet keys are derived. Now your developer account can only support up to a thousand wallet sets. So when you're architecting your app, you'd want to do not assign each user a unique wallet set because come on, your your app's going to have more than thousand users, right?

So what you would do is you would use ref ID. I'll talk about that later because it's relevant, but basically a wallet set can support up to 10 million wallets. So we want to go that route like user to wallets rather than user to wallet set. So the create wallet set function takes in one parameter which is the wallet set name. And you can change the name later if you want to.

Now for me, I already have wallet set so I'm plugging that in here. create wallets. The required fields are essentially you got to tell the SDK what blockchain you want, how many wallets you want, and then the wallet set that the wallet needs to belong to. So, I'm going to run this. So, after you run it, let's pull this up.

We will have two wallets with all the information about the wallet and these wallets can also be seen on the circle console. Now what we want to do is let's these are new so there's nothing on them. So let's copy the address head over to the faucet to get some testnet tokens. So yeah, you can grab USDC or URC. I'm not a robot.

Oh boy. Let's see. I'm going to cut this out of the video. Right. So I should have 20 USDC sent over.

Back to the code. So once we have So now we have a funded wallet and a wallet that has nothing. So now we can do stuff. So first thing we want to do, let's do a transfer because we have two wallets and we want to transfer some money to the other one. What you want to use for USDC transfers is create transaction.

So again from the client instantiate and then let's transfer say to USDC over to the recipient wallet. So earlier we funded the other wallet. Going to grab the address from here. You're going to be my recipient. And then the wallet with the funds is going to be the sender.

So this is just a USDC contract on our test net. Okay. Blockchain arc test net. All is well. Let us run this transfer script.

You'll see that it's initiated. And then I plugged the ID to check the status of the transaction. So that's the information about the transaction transfer net, you know, transaction hash and all of that. So let's let's go see this. Let's go see this in the console wallet.

wallet. Okay, so these two are the ones that I just created and I think 687 was the one with funds. So now there's only 18 left. I transferred two. So that's great.

And so you F60 should have two. So that's that's what happened. You can check it on the console, but we'll be just messing around with the code. But the wallets SDK is not just for transfers, right? So there is, let me comment this out.

There's a very powerful feature function, let's call it, that allows you to call any function on any contract that you like. It's called create contract execution transaction. So I have this kind of like a hello world equivalent contract that I deployed on art testn net earlier. It just lets it doesn't do much. It just lets you set what your favorite number would be.

Let's go look at the contract uh on the block explorer looks. So right here it had you can get your number. So right now it says you know 23 and then let's just set your favorite number. So let's do that. Let's do that with create contract execution transaction.

Uh I got to plug my wallet ID with actually both both the wallets will work because they all got funds. Now I'm just going to grab my Hang on. Where's my wallet ID? Grab this wallet ID. Plug it in here.

And I'm I'm going to set it to 42 because why not? So let's run this again. And you know, initiated. Nice. And cool.

It got it went through. You can see all the gas fees, everything. And if you want to check it, let's go there and read it again. 42. So, you can call pretty much anything.

And you'll see that in the following examples where I'm doing other things, I'm just going to be using this and you know calling depending on the AI signature calling different things. So that's transfer. Let's go into bridge. Oh, this is fun. I I love Bridgekit.

I love Bridgekit. I had tried to do bridging with just pure CCTP and uh it worked, but it was a lot of work. And today we have bridgekit. So for developer control wallets you also have to install the uh circle wallets adapter. And so instantiate the adapter instantiate a new bridge kit and we are good to go.

So right now let's create a salana wallet. I I Salana is very tricky to to do it by hand honestly. So I'm just going to do this. Salana definitely right. Right.

Create one new wallet. Get that going. Grab my new wallet address. So for bridging your recipient wallet, if you're going to bridge over to Salana, you're minting on Salana, so you're going to need some gas. Salana faucet's great though.

Let's get some. Everyone's a bot. Come on. Come on. Excellent.

So, I now have some soul on my wallet, but I got nothing else. So, we're going to bridge. Oh, dear. Let's go back here. Look at my wallet.

That's my new wallet. So, I I got five soul. Love it. And head over to bridge. So, let's grab that same wallet address.

Just going to plug that in here. My Arc wallet address. This guy. How much do we want to uh I'm stingy. Let's just do one.

So what why we're able to see the steps is because there britkit has event listeners. So I'm listening to all of them but you can target each of the individual steps if you want to. It's just easier as a demonstration to show. So right now it's it's pretty fast art to Salana. So just now we approved and then we burned and then we got the attestation from circle and then boom success.

And so a lot of useful information for you to to build into your app if you need to. And uh let's refresh this. We're just successful. Excellent. Now, this is the part that might get a little bit tricky.

Uh, but I mean, hey, got to go through it. So, earlier I talked about how you should be doing wallets instead of wallet sets. And so, there's this property when you create wallets called a ref ID. And this is a pretty nifty feature from the wallets API because there is something called unified wallet addressing for EVM chains. So when you create a wallet with a ref ID, all the EVM wallets sharing that ref ID will have the same address.

So the ref ID would be used to associate each wallet back to your user ID in your system. Um, so I'm I'm I'm putting it I'm hard coding this here, but like it wouldn't Uh so let's let's see how this works. So I can do I'm doing these these four because these are the gateway supported chains, right? So let's do run this. So I created four new wallets.

Wallets are almost free. And you can see that they all have the same address, right? 48137. So, that's pretty useful when when we're we're dealing with with gateway because it's multiple chains, but they all have the same address. Very similar to if you're using a non-custodial wallet.

So, the first thing you want to do is you got to deposit to the gateway balance. So I I have a set of wallets already prepared and loaded up with uh test net USDC and native tokens just to make life easier. Now the gateway code does look a little long uh but the bulk of it is constants and helper functions. Now for deposit the main logic I'm going to scroll down to it. You want to approve the gateway wallet to move the specified amount by calling approve.

And so here right again create contract execution transaction. So I'm calling approve plug in the parameters and then the next step is to deposit right same thing but now I'm calling deposit. It's very important that you call deposit on the gateway wallet contract and not a standard transfer on the USDC contract. must use deposit. So the AI parameters in this case are you know USDC contract address and then the amount.

So right now I have set it up such that we are going to deposit two and my depositor address that's that's what I have in my end variables that is the unifi EVM address wallet set that I set up earlier. So okay hopefully this works. run gateway to pause it. The reason why this script is so long is simply because I'm looping across four chains, right? So, let me pull this up so you can see what's going on.

It's the approve and the deposit. Technically, it would be simpler if I didn't loop through all the chains. So then that would be one less helper. But hey, so what you notice is that for ARC, it's really fast. For Sapolia, it's a little bit slower.

So these block confirmations are really dependent on which chain you're working with. So this is going to take a while. Um that is why I have already prerun this because if you look at our documentation like for example for Ethereum or even base it may take up I don't know 8 to 20 minutes. So I'm going to let it run but we can go check our gateway balance and uh gateway balance very straightforward. You're essentially just calling the API, this balances API, and you tell it what domain and what depositor address you want to check.

So, my depositor address is the same one that I used to deposit. I'm just going to run this way balances. So it checks my balances and yeah, you know, I pre So the one for AR is really fast. 26 is ARC and the one that I just deposited showed up already. The one for the the the rest are not up yet.

And that's the reason why I pre predeposited this before the work trap. Um so now that we've got see the deposit step takes time but the transfer step does not. So, I pretty much have about like 12 USDC in here. So, let's go to go to the transfer script. And the transfer script, I will admit again, it looks long, but it's a lot of config, right?

So, it it's chain config. I got the contract names, domains, chains. So, let me go down to the meat and bones of the transfer function because to transfer you need to construct and sign a burn intent. And it's very important that you understand what these transfer specs are asking for so that it works. The destin so source domain is you know wherever you have the balances.

So right now I have four of them. Source domain destination domain is where I want to deposit to the source contract is the gateway wallet. Source and destination contract because you're calling the gateway contract. So that those are the gateway addresses. Now token USDC because that's what we're using.

The source depositor, this is usually the source assigner. So whoever owns the balances, which is the depositor address, you're usually the one signing it as well. And then destination recipient is just whoever you want to send it to. So, for this example, I'm going to set the recipient address back to the original Circle Wallet address that did the deposit because your gateway balances are actually held in the gateway contract. So, this could be anybody.

I just chose this. It could be an external address as well. So, we're going to mint on the into the Avalanche wallet. And uh let's do one gateway transfer. So just now I demonstrated that the deposit could take time but minting out is like instant.

So the script loops through builds up the burn intense for all four chains and then submits it in one atestation the circle. And so 0.5 * 4 is 2. So this minting time is just avalanches confirmation time. But like snap snap.

So that was a lot. That was a lot. Let's go back to the slides real quick. Bounties. Right.

So this these are our bounties for the hackathon. They're also on the website. All the tools I mentioned they're suggestions right the only requirement uh is that you build on got a lot of developer resources we have you know documentation SDKs blog and sample apps reach out to us on discord we are also in the east global discord uh lots of interesting things going on there as well and uh my name's HJ from the circle defell team Really can't wait to see what y'all build.