Chainlink Cross-Chain Interoperability Protocol (CCIP) provides developers with a seamless and secure tool to transfer tokens and send arbitrary messages across blockchains.

In this tutorial, Chainlink Labs Developer Advocate Richard Gottleber provides a step-by-step tutorial on how to send a testnet token, as well as an arbitrary message, from Ethereum Sepolia to Polygon Mumbai.

Chainlink is the industry-standard Web3 services platform. It has enabled trillions of dollars in transaction volume across DeFi, on-chain finance, gaming, NFTs, and other major industries. As the leading decentralized oracle network, Chainlink empowers developers to build feature-rich Web3 applications with seamless access to real-world data and off-chain computation across any blockchain and provides global enterprises with a universal gateway to all blockchains.

Learn more about Chainlink:

Website: https://chain.link
Docs: https://docs.chain.link
Twitter: https://twitter.com/chainlink

#Chainlink #blockchain #web3 #crypto #defi #smartcontracts

Hi, I'm Richard, 1 of the developer advocates here at Chainlink Labs.

And today, we're going to be taking a look at Chainlink Cross-Chain Interoperability Protocol, or CCIP.

In this video, you'll learn more about what CCIP is, what it's capable of,

use CCIP to transfer tokens cross-chain as well as how to use CCIP to send arbitrary data between smart contracts on different blockchains.

CCIP is a seamless protocol that allows you to create cross-chain interoperability in your smart contracts.

With CCIP, you can transfer assets and information across different blockchains.

CCIP lets you leverage the strengths and benefits of different chains and collaborate with developers from different blockchain ecosystems, enabling you to provide additional features or products to those ecosystems.

And its core CCIP supports 3 main capabilities.

It just means that you can send any message you want as long as it's encoded in bytes.

This allows you to call smart contract functions across chains.

With these, you can transfer tokens between smart contracts or EOAs, think wallets, on different blockchains.

And finally, programmable token transfers.

These combine both messages and token transfers into a single transaction.

Think of it like providing a note along with the tokens on what you want to do with them.

Let's dive into the documentation and see how to use Chainlink CCIP.

It's the place to start for any Chainlink tutorial.

Anything you really need to know about Chainlink, this is the best place to start.

If we scroll down just a little bit we have CCIP right here that's right Chainlink cross-chain interoperability protocol is in the documentation we'll head to the introduction and take a look around we can see here an explanation of what CCIP is how to get started and what we need So we'll need some ETH on Sepolia, SEMATIC on Mumbai, and some LINK tokens on Sepolia as well.

If we head to faucets.chain.link, you'll be able to get those.

Now you'll need both Polygon Mumbai as well as Ethereum Sepolia and get those tokens from here.

From here we're going to go into the transfer token example as well and the send arbitrary data example.

So in this example, we'll be transferring tokens from a contract on Sepulia into our EOA or wallet on Mumbai.

We need to check and make sure that we have our funds, We have our wallet set up and we understand remix again.

We also need to acquire some test tokens for CCIP.

We'll be using the B and M tokens, which are the burn and mint tokens.

These are ERC 20 tokens that are available on the test networks that we have CCIP available on.

When you transfer these tokens between testnet blockchains CCIP burns the tokens on the source chain and mints them on the destination chain.

So let's take a look at that first and see how to do that.

The contracts for CCIP, BNM, and LNM both have a DRIP function.

So if we go to the support networks page here, and we scroll down, we will see that we are using Ethereum testnets.

In Sepolia, we're going to use the CCIP BNM token.

So we'll need to go to this address here.

From here, we'll click on Contract and we'll click on Write Contract.

So this is when you'll see the DRIP function.

Once it's connected, we'll run the DRIP function.

So we'll copy our wallet address and paste it in here.

Confirm this transaction and we should see that transaction come through momentarily.

So how do we get this token into our MetaMask wallet?

Well, if we copy this token address and we click on MetaMask, you may be on the activity tab.

If you click on tokens, you can then import a token here.

If you paste in the contract address, it'll probably populate this information for you.

We have the token symbol as well as the decimals.

We'll add this custom token and you probably have a balance of 0.

Import those tokens and now once they're imported, we can see that our token balance is here.

So we look at our activity, the drip should be done and we should have a token balance of the CCIP BNM token.

That's 1 that we'll be using to transfer.

All right, so we have our tokens added to Metamask.

Let's go back and continue with this tutorial.

So in this tutorial, we'll be using this massive contract here.

And the reason this contract is so big is because it basically does everything for us that we need for both the examples that we'll be looking at.

From transferring tokens, so we scroll down all the way down, we should see an open in Remix button.

So this is a big contract that we use to send tokens from 1 blockchain to another.

This contract is set up in a generic manner that we can use on any of our supported networks.

It's a pretty long contract like I mentioned before, but it's very well documented.

We've got our contract, we have our event for transfer tokens that we can emit.

We have a constructor and again, I mentioned that this is set up in a generic manner.

So we have our router and our link token address.

We do have modifiers for whitelisted chains, so you will need to whitelist a chain before you can send tokens to it.

And then we have our first function that we want to look at.

This is the transfer tokens paying with link function.

Now, 1 thing to keep in mind is that CCIP supports fee payments in link and in alternative assets, which currently takes the form of native blockchain gas coins and their ERC20 wrapped version.

An automated on-chain conversion mechanism is being worked on where fee payments and alternative assets are converted into link.

The transfer token function here will take the destination chain, the receiver address, what's a token address is the amount of that token.

And That's basically all that we need for this.

When we look at the transfer tokens paying with the native fee, we see this in a very similar manner.

Again, I'm being very brief in my explanation here because these are such well-documented examples.

If you need to know what any of these lines are doing, they're documented for you, and they explain all that information.

So let's head back to the documentation and look at how to actually use this contract.

So we need to open this contract up in Remix.

If we head back to Remix, if you're not familiar this is the compile tab.

If you don't see that checked and a green check mark next to it you can either turn it on or click that compile button and it'll do the compiling for you.

You should have a screen check right here which means you're good to go.

Now to do this we need to make sure first of all that we are on Ethereum Cipollia.

This is something that is probably the trickiest part of dealing with CCIP is managing what network you're on when.

So now before we go too far, we need to make sure that we have both Spolia and Mumbai set up.

So let's go ahead and take a look at Mumbai real quick and see that we have our tokens.

If you don't have that done, again it's the same basic process as we did on Spolia.

You can go to the supported networks page here and you can scroll down to Polycon Mumbai and you can add the supported tokens.

Remember the way to do that is you go into Metamask tokens, import tokens, you put the contract address symbol and decimals and add that token.

You'll want to do that before you go any further because that way you can see when those tokens actually get transferred into your wallet.

All right Let's head back to the documentation.

Again, like I said, that's the hardest part about CCIP, in my opinion, is just keeping track of what network you're on.

We'll need to open Remix and go to Deploy and Run.

From there, we'll need to interact with our injected provider for MetaMask, and we'll need to add the router.

We can go and copy that now, and by clicking on the Copy button, we'll head to Remix, we'll go to our Deploy tab, I'll change the injected provider to Metamask.

That takes our Metamask wallet and puts it into Remix.

We'll expand by clicking the dropdown here.

And then We'll also need to add the link token address.

Now remember these are specific to Zapolia.

So we've got our link token address and we've got our router address.

We'll go ahead and click transact, confirm this transaction, and once that's confirmed we should see our deployed contract down here.

We've got our deployed contract with all of our functions in it here.

We need to fund our contract with CCIP BNM tokens.

In this case we're doing 0.002 of the tokens, but you can do whatever you like.

We'll change this to be the CCIP BNM tokens, and we'll send 0.002 tokens to our contract.

Confirm this transaction, and we'll wait for this to complete.

Our contract has a balance of tokens now to transfer.

We'll need to enable our contract to transfer those tokens to Polygon Mobile.

We'll copy the chain selector address here.

If you wanted to use a different chain you could also go to the supported networks page and you can see the selector addresses here.

For example, for Ethereum mainnet, so we'll copy our chain selector though for Sepolia, but back to Remix, we'll need to whitelist the destination chain.

Paste that chain selector in here and then we'll click transact and confirm this transaction as well.

Once this transaction is complete we should be able to transfer tokens and pay in LINK.

In order to pay in LINK we'll need to fund our contract though with some LINK tokens.

So in the same basic process that we did with funding it for the CCIP BNM tokens, we'll get our contract address 1 more time.

We'll go to Metamask, go to send, put in our contract address here.

This time we'll be sending link, give it 0.01 link, click next, confirm this transaction.

That should be enough for this transaction.

We'll wait for this transaction to be confirmed.

And now our contract has both link tokens and CCIP BNM tokens.

So we can pay for and transfer those tokens.

We'll open up the transfer token pay in link function and we've got some arguments here.

So the first thing is it will copy this first argument for the destination chain selector.

This is gonna be a bit of back and forth between the docs and this page.

So we want to transfer tokens and pay in link.

Put our destination chain selector in here.

Get the receiver which is going to be my wallet address.

It's going to be the same wallet address on both Polygon and Sepolia.

So we're telling it the polygon chain, we're telling it that it's my wallet address or EOA.

We'll need the token that we want to transfer.

That's going to be the address of the CCIP BNM token.

We'll get that from the documentation and the amount that we want to transfer.

Remember, we gave it 0.002 BNM tokens and we'll be sending 0.001 along.

So paste that in here and we'll click transact and confirm this transaction.

Now once this is confirmed we can switch our wallet over to Polygon Mumbai.

You'll notice I already have 0.001 CCIP BNM in here.

This is from previous time that I ran this example.

So we're looking to change that 1 to a 2.

If we go back to our Supolia wallet, we can see our activity and we can see our contract that we interacted with here.

Now, if we click on the copy transaction ID, we'll need this in just a moment.

If we go back to the documentation, it'll let you know that there is a CCIP Explorer.

Basically, this is an explorer, but for cross-chain interactions.

If we paste our transaction ID in here and press return, we'll see our transaction details.

And I'll tell you, this can take a little bit.

So we'll come back in a few moments once this is completed.

We'll watch the status here and that's where we'll see the progress being made in this transaction.

That means our transaction has gone through.

We've been able to transfer our tokens from Ethereum Sepolia to Polygon Mumbai.

If we take a look at our wallet now, and we take a look at the tokens, we'll notice that I'm still connected to Sepolia.

Here we can see the CCIP BNM token amount and it's changed from 0.001 to

We have successfully sent tokens across chains.

Let's take a look at how we can do the same process, but pay with a native token.

So again, this process is going to be basically the same.

We'll need to change our network back to Sepolia.

This time we'll need to fund it with ETH though.

We'll copy the address of our transfer or contract.

And confirm, wait for this transaction to be finalized.

Our contract now has some ETH that has been sent to it.

We'll open up the transfer and pay native.

We'll take a look at the documentation 1 more time.

Again, our destination chain is going to be the same.

We can just copy that information from the send it with link token above.

So we'll copy these values in here, we'll click on transact, and we'll confirm this transaction.

We can either use our wallet or down here in Remix, I'll open up this menu.

In the debug menu, we can see the transaction hash here.

We'll copy this and we'll head back to the Explorer.

We'll paste in our transaction here, press return, and we'll see once again waiting for finality on this transaction as well.

So if we go to our wallet, change to Mumbai, and take a look at our tokens, you can go to remember that we have 0.002 CCIP BNM.

That should increase to 0.003 once this transaction has finalized.

Alright, so you can see that we have success now on our transaction.

If we take a look at our wallet, we can also see that our CCIP BNM has increased to

We've been able to transfer tokens from Sepolia to Mumbai using CCIP, paying in both native token and link.

We've been able to do cross-chain token transfers with CCIP.

Let's take a look at the documentation and 1 more example here.

This time though, we'll be deploying it on both Sepolia and Mumbai.

And we'll be doing the example of paying with link tokens, not both examples, because as we've seen, using native gas is a very similar process as using LINK tokens.

This 1 again, we'll have the added challenge of needing to deploy your contract in 2 different places and keeping track of where they're deployed and which wallet you're on is kind of a challenge.

So let's scroll through this contract and at the bottom we will once again see our open and remix button.

We'll click on that and I'm gonna close the Explorer, Mint functionality for our CCIP BNM token, and the other remix that we were using just to keep things simple.

All right, so here we have our contract again.

And once again, this contract is documented amazingly well.

This contract is both the sender and receiver of messages.

So you can see here we have 2 events, 1 for the message being sent, 1 for the message being received.

Now this contract is set up so that it's basically agnostic when it comes to what chain you're deploying on and whether you're the sender or receiver.

You could reduce the amount of code in here if you wanted 1 that was specifically just a sender and another contract that was specifically just a receiver.

So back to the documentation, what you need to do is you need to compile it again, just like we did with the other 1, and we'll need to make sure that we are on Sepulia.

And this is where things start to get a little bit tricky when it comes to managing both networks, because we need to deploy this on Mumbai as well.

I'll do that by opening a separate window in a private browser mode, just to keep things separate there.

So in Remix, we'll need to add Zepolia's router address and the link contract address.

So we'll head back to Remix, we'll go to the deploy tab, we'll make sure that we have our injected provider selected, and we will deploy.

So we have our router address here, and I'm heading back to the documentation.

We'll go ahead and grab the link token address as well, Paste that in here, and we'll click Transact.

This will deploy our smart contract for us on Sepolia.

So now that we have this contract deployed on Sepolia, what's next?

Well, we'll need to enable our contract to send messages to Mumbai.

So we'll whitelist the destination chain.

We'll copy our destination chain selector here.

We'll head back to remix in our deployed contract here.

We'll need to whitelist the destination chain.

We'll paste in our chain selector, click Transact, confirm this.

And after that, we will need to deploy our contract on Mumbai.

So wait for this transaction to be confirmed.

We've got our messenger sender contract deployed on Sepolia and we whitelisted the destination chain of Mumbai.

Easiest way I've found to do this and keep track of things is we'll copy this link here and open a Remix link in a new browser window.

Again, I'm doing a private window here in Brave.

In my mind this makes things really easy because in Brave it makes it purple and that just kind of keeps me in the mindset of purple polygon and we're good to go.

Put the link to the remix in here, we'll load all of this up.

This time we'll need to go to the compiler, turn on the auto compile or click the compile button, and then we'll need to deploy this.

With the injected MetaMask provider, we need to remember to change our network to Mumbai.

Like I said, that's probably the hardest part.

See all Chainlink transcripts on Youtube

How To Transfer Tokens and Send Data Cross-Chain With Chainlink CCIP