Deploy and Transfer a New Token from Stellar to EVM

This guide demonstrates, step by step, how to use Axelar’s Interchain Token Service (ITS) to create and transfer tokens between Stellar and other blockchains.

By the end, you will be able to:

Deploy a new token on Stellar using Axelar ITS.
Deploy that token representation on an EVM chain (Avalanche Fuji testnet).
Transfer tokens seamlessly between Stellar and the EVM chain.

Prerequisites

Before starting, make sure you have the following ready:

Rust with wasm32 target.
Stellar CLI.
A Stellar testnet account with funds.
A browser wallet like MetaMask configured to connect to the Avalanche Fuji testnet, or a similar wallet like Rabby
Some Avalanche Fuji testnet AVAX (from the Avalanche faucet).

Part 1: Understanding the Interchain Token Service

The Interchain Token Service (ITS) is a protocol that allows tokens to move freely between different blockchains. It provides functionality to:

Create tokens that exist on multiple blockchains simultaneously.
Connect existing tokens on one blockchain to other blockchains.
Transfer tokens securely between blockchains.

Unlike the single message-passing pattern of GMP, the ITS involves several components:

Interchain Token Service: The main contract that coordinates token operations.
Token Manager: Handles token operations (minting, burning, locking) on a specific chain.
Interchain Token: The actual token contract that implements the Stellar token interface.
Gateway: Routes messages between blockchains.
Gas Service: Handles payments for cross-chain execution.

💡

A token created through ITS will have the same token ID across all blockchains

Part 2: Set up your Stellar ITS project

Let’s build a Stellar smart contract project that integrates with ITS to create and transfer new tokens.

Step 1. Initialize a new project

Start by creating a new Stellar contract project and the directory:

stellar contract init axelar-its-app
cd axelar-its-app

This command scaffolds a basic Stellar contract project for you.

Tip: We’ll simplify the default structure as we progress, focusing on the files needed for the ITS integration.

Step 2: Simplify your project structure

To keep things neat, remove unnecessary folders and consolidate your source files.

Move the src folder to the root of your project directory if it isn’t there already Delete any example or template contract folders, such as contracts/hello-world

After cleanup, your folder should look like this:

axelar-its-app
├── src
│   ├── lib.rs
├── .gitignore
├── Cargo.toml
├── README.md

Step 3. Configure your dependencies in Cargo.toml

Open Cargo.toml in your project root and update it to include dependencies needed for Axelar ITS and Stellar development.

Here’s a sample you can copy:

[package]
name = "axelar-its-app"
version = "0.0.0"
edition = "2021"
publish = false

[lib]
crate-type = ["cdylib"]
doctest = false

[dependencies]
soroban-sdk = "22.0.0"
soroban-token-sdk = "22.0.0"
stellar-axelar-gateway = { git = "https://github.com/axelarnetwork/axelar-amplifier-stellar", branch = "main", features = ["library"] }
stellar-axelar-gas-service = { git = "https://github.com/axelarnetwork/axelar-amplifier-stellar", branch = "main", features = ["library"] }
stellar-interchain-token-service = { git = "https://github.com/axelarnetwork/axelar-amplifier-stellar", branch = "main", features = ["library"] }
stellar-interchain-token = { git = "https://github.com/axelarnetwork/axelar-amplifier-stellar", branch = "main", features = ["library"] }
stellar-token-manager = { git = "https://github.com/axelarnetwork/axelar-amplifier-stellar", branch = "main", features = ["library"] }
stellar-axelar-std = { git = "https://github.com/axelarnetwork/axelar-amplifier-stellar", branch = "main" }

[dev-dependencies]
soroban-sdk = { version = "22.0.0", features = ["testutils"] }

[profile.release]
opt-level = "z"
overflow-checks = true
debug = 0
strip = "symbols"
debug-assertions = false
panic = "abort"
codegen-units = 1
lto = true

[profile.release-with-logs]
inherits = "release"
debug-assertions = true

This configuration pulls in Axelar’s Stellar libraries from GitHub and sets up your Rust build profiles for optimal WASM compilation.

Part 3: Implementing the Interchain Token Service (ITS)

Now that the project structure and dependencies are ready, it’s time to implement the contract. This contract will interact with the Interchain Token Service (ITS) to create new tokens and enable cross-chain transfers.

We’ll build this step by step by creating the core source files inside the src folder.

Step 1: Define the contract entry point (`lib.rs`)

The lib.rs file is your contract’s main entry point. Here, you declare the modules your contract uses.

Update src/lib.rs with:

#![no_std]

pub mod contract;
pub mod error;
mod storage_types;

contract will contain the main contract implementation
error defines error types your contract can return
storage_types holds data structures used for contract storage

Step 2: Define contract errors (`error.rs`)

A clear list of error codes helps you handle edge cases and report issues properly.

Create src/error.rs with the following content:

use stellar_axelar_std::{contracterror, soroban_sdk};

#[contracterror]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum ContractError {
 TrustedChainAlreadySet = 1,
 TrustedChainNotSet = 2,
 InvalidMessageType = 3,
 UntrustedChain = 4,
 InvalidAmount = 5,
 InvalidDestinationAddress = 6,
 NotHubChain = 7,
 NotHubAddress = 8,
 InvalidTokenId = 9,
 TokenAlreadyRegistered = 10,
 FlowLimitExceeded = 11,
 InvalidDestinationChain = 12,
 InvalidData = 13,
 InvalidTokenName = 14,
 InvalidTokenSymbol = 15,
 InvalidTokenDecimals = 16,
 InvalidInitialSupply = 17,
 InvalidTokenConfig = 18,
}

Each error has a unique numeric code and a named variant. This helps both you and users understand why a transaction might fail.

Step 3: Define storage keys (`storage_types.rs`)

The contract needs to store some key data onchain. Let’s define storage keys in src/storage_types.rs:

use soroban_sdk::{contracttype, String};

#[contracttype]
#[derive(Clone, Debug)]
pub enum DataKey {
 InterchainTokenService,
 TokenId,
 Salt,
 TrustedChain(String),
}

This storage structure includes:

InterchainTokenService: Stores the address of the deployed ITS contract.
TokenId: Stores the ID of the token we deploy.
Salt: Stores the salt used for token deployment (needed for remote deployment).
TrustedChain: Tracks which chains we’ve marked as trusted.

Step 4: Implement the contract logic (`contract.rs`)

1. Setup and Initialization

First, let’s create the contract.rs file inside the src folder with a basic setup and initialization functions:

use soroban_sdk::{contract, contractimpl, Address, Bytes, BytesN, Env, String};
use soroban_token_sdk::metadata::TokenMetadata;
use stellar_axelar_std::types::Token;
use stellar_interchain_token_service::InterchainTokenServiceClient;

use crate::storage_types::DataKey;

#[contract]
pub struct ItsApp;

#[contractimpl]
impl ItsApp {
    /// Initialize the contract with the ITS service address
    pub fn initialize(env: &Env, its_address: Address) {
 env.storage()
 .instance()
 .set(&DataKey::InterchainTokenService, &its_address);
 }

    /// Get the ITS client
    fn its_client(env: &Env) -> InterchainTokenServiceClient {
        let its_address = env
 .storage()
 .instance()
 .get(&DataKey::InterchainTokenService)
 .unwrap();
 InterchainTokenServiceClient::new(env, &its_address)
 }

    /// Check if a chain is trusted
    pub fn is_trusted_chain(env: &Env, chain: String) -> bool {
        let its = Self::its_client(env);
 its.is_trusted_chain(&chain)
 }
}

These functions:

initialize: Sets up the contract with the address of the ITS service
its_client: Creates an instance of the InterchainTokenServiceClient
is_trusted_chain: Checks if a chain is trusted by the ITS

2. Token Creation Functions

Next, let’s add functions to deploy a new token and retrieve token information:

    //...

   /// Deploy a new interchain token on Stellar
    pub fn deploy_token(
 env: &Env,
 caller: Address,
 salt: BytesN<32>,
 name: String,
 symbol: String,
 decimals: u32,
 initial_supply: i128,
 ) -> BytesN<32> {
 caller.require_auth();

        let its = Self::its_client(env);

        // Create token metadata
        let token_metadata = TokenMetadata {
 name,
 symbol,
 decimal: decimals,
 };

        // Deploy the token - direct call
        let token_id = its.deploy_interchain_token(
 &caller,
 &salt,
 &token_metadata,
 &initial_supply,
 &None, // No additional minter
 );

        // Store the token ID and salt for reference
 env.storage().instance().set(&DataKey::TokenId, &token_id);
 env.storage().instance().set(&DataKey::Salt, &salt);

 token_id
 }

    /// Get the currently stored token ID
    pub fn get_token_id(env: &Env) -> BytesN<32> {
 env.storage().instance().get(&DataKey::TokenId).unwrap()
 }

The deploy_token function:

Authenticates the caller to ensure they have permission
Creates token metadata with the provided name, symbol, and decimals
Deploys a new interchain token with the specified initial supply
Stores both the generated token_id and salt for future operations
Returns the token_id for reference

The getter function allows us to retrieve the stored token information:

get_token_id: Returns the ITS token_id

3. Implement the Cross-Chain Functions

Finally, let’s add functions for cross-chain token deployment and transfers:

    //...

   /// Deploy the token to another blockchain
    pub fn deploy_remote_token(
 env: &Env,
 caller: Address,
 destination_chain: String,
 gas_token_address: Address,
 gas_amount: i128,
 ) -> BytesN<32> {
 caller.require_auth();

        let its = Self::its_client(env);

        // Get stored salt
        let salt = env.storage().instance().get(&DataKey::Salt).unwrap_or_else(|| {
 BytesN::from_array(env, &[0; 32])
 });

        // Prepare gas token
        let gas_token = Some(Token {
 address: gas_token_address,
 amount: gas_amount,
 });

        // Deploy to remote chain - direct call
        let token_id = its.deploy_remote_interchain_token(
 &caller,
 &salt,
 &destination_chain,
 &gas_token,
 );

 token_id
 }

    /// Transfer interchain tokens to another blockchain
    pub fn transfer_tokens(
 env: &Env,
 caller: Address,
 token_id: BytesN<32>,
 destination_chain: String,
 destination_address: Bytes,
 amount: i128,
 gas_token_address: Address,
 gas_amount: i128,
 ) {
 caller.require_auth();

        let its = Self::its_client(env);

        // Basic validation
        if amount <= 0 {
            panic!("Invalid amount");
 }

        if destination_address.len() == 0 {
            panic!("Invalid destination address");
 }

        // Prepare gas token
        let gas_token = Some(Token {
 address: gas_token_address,
 amount: gas_amount,
 });

        // Send the tokens cross-chain - direct call
 its.interchain_transfer(
 &caller,
 &token_id,
 &destination_chain,
 &destination_address,
 &amount,
 &None, // No additional data
 &gas_token,
 );
 }

The deploy_remote_token function:

Deploys the token to another blockchain using the stored salt
Configures gas payment for cross-chain operations
Returns the token_id, which remains consistent across chains

The transfer_tokens function:

Validates the transfer amount and destination address
Initiates the cross-chain transfer with appropriate gas payment

With these functions implemented, our contract provides a complete interface for creating new tokens and enabling cross-chain transfers.

Part 4: Build and Deploy the Contract

Once your contract code is complete, follow these steps to compile and deploy it on the Stellar testnet.

Step 1: Build your contract

stellar contract build

You should see output confirming the build succeeded and showing the location of the .wasm file:

ℹ️  CARGO_BUILD_RUSTFLAGS=--remap-path-prefix=/path/to/registry/src= cargo rustc --manifest-path=Cargo.toml --crate-type=cdylib --target=wasm32-unknown-unknown --release
 Compiling axelar-its-app v0.0.0 (/path/to/axelar-its-example)
 Finished `release` profile [optimized] target(s) in 1.04s
ℹ️  Build Summary:
 Wasm File: target/wasm32-unknown-unknown/release/axelar_its_app.wasm
 Wasm Hash: 6ec10215f2b47323e143289842bdf274b00929b5632f60e56ef39fd2caa066eb
 Exported Functions: 8 found
 •••
✅ Build Complete

Step 2. Optimize the WASM file:

stellar contract optimize --wasm target/wasm32-unknown-unknown/release/axelar_its_app.wasm

This creates an optimized .wasm file you will deploy.

Step 3. Deploy the contract to the Stellar testnet:

stellar contract deploy \
 --wasm target/wasm32-unknown-unknown/release/axelar_its_app.optimized.wasm \
 --source YOUR_ACCOUNT_NAME \
 --network testnet

When the deployment succeeds, you’ll receive the address of your new contract. Save this address for future interactions.

You should see something similar to what is shown below on your terminal.

ℹ️  Simulating install transaction…
ℹ️  Signing transaction: ee3941979c516e4953b65d14704d1c9b9ec0c1646be5295f877f0ea6ae042504
🌎 Submitting install transaction…
ℹ️  Using wasm hash 8a09dd41239d938d23546dfd56e935d3e19f0784bd96757990858a78453e913e
ℹ️  Simulating deploy transaction…
ℹ️  Transaction hash is c98523481cfecfdb96ae19d19cdb766b18394b711b614ef79a2e924cc15a8461
🔗 https://stellar.expert/explorer/testnet/tx/c98523481cfecfdb96ae19d19cdb766b18394b711b614ef79a2e924cc15a8461
ℹ️  Signing transaction: c98523481cfecfdb96ae19d19cdb766b18394b711b614ef79a2e924cc15a8461
🌎 Submitting deploy transaction…
🔗 https://stellar.expert/explorer/testnet/contract/CCQBX3AFKB2A43RA6GVY53MFBGK3KSXROUAXZSRV3CG63FXFG7QXNKLT
✅ Deployed!
CCQBX3AFKB2A43RA6GVY53MFBGK3KSXROUAXZSRV3CG63FXFG7QXNKLT

Part 5: Interacting with your contract on the Stellar testnet

Now that our contract is deployed, let’s interact with it to create and transfer tokens across the cross-chain.

Now that your contract is deployed on the Stellar testnet, you’ll use the Stellar CLI to:

Initialize your contract by connecting it to the Axelar Interchain Token Service (ITS)
Create a new token on Stellar using the ITS
Deploy your new token on the Avalanche Fuji testnet
Transfer tokens from Stellar to Avalanche Fuji

Step 1: Initialize your contract with the ITS address

Before creating tokens or transferring, your contract must know where the ITS service lives on Stellar. Run this command, replacing YOUR_CONTRACT_ADDRESS and YOUR_ACCOUNT_NAME accordingly:

stellar contract invoke \
 --network testnet \
 --id YOUR_CONTRACT_ADDRESS \
 --source-account YOUR_ACCOUNT_NAME \
 -- \
 initialize \
 --its_address CCXT3EAQ7GPQTJWENU62SIFBQ3D4JMNQSB77KRPTGBJ7ZWBYESZQBZRK

Note: CCXT3EAQ7GPQTJWENU62SIFBQ3D4JMNQSB77KRPTGBJ7ZWBYESZQBZRK is the address of the Axelar Interchain Token Service contract on the Stellar testnet. You should confirm this address from the official Axelar documentation for testnet here.

You should see something like:

ℹ️  Signing transaction: f90f7d67180f00e77b0de0b96b6cc801a68093c41ed6544cc82d327b2c1c4837

Step 2: Check if Avalanche is a trusted chain

It’s a good practice to verify that ITS trusts the destination chain (Avalanche) before sending tokens.

A trusted chain is one that the ITS recognizes and allows transfers to and from. To check if Avalanche is trusted, you can use the is_trusted_chain function in your contract. Replace YOUR_CONTRACT_ADDRESS and YOUR_ACCOUNT_NAME with your contract address and Stellar account name.

Run the command below:

stellar contract invoke \
 --network testnet \
 --id YOUR_CONTRACT_ADDRESS \
 --source-account YOUR_ACCOUNT_NAME \
 -- \
 is_trusted_chain \
 --chain '"Avalanche"'

Note: The quotes around the chain name are required due to how the Stellar CLI handles string parameters.

You will get this:

ℹ️  Simulation identified as read-only. Send by rerunning with `--send=yes`.
true

If it returns false, the chain is not yet trusted, and transfers to it won’t work until it’s added.

Step 3: Deploy a new Interchain Token on Stellar

Create your own token that can exist across multiple blockchains:

stellar contract invoke \
 --network testnet \
 --id YOUR_CONTRACT_ADDRESS \
 --source-account YOUR_ACCOUNT_NAME \
 -- \
 deploy_token \
 --caller YOUR_ACCOUNT_NAME \
 --salt 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef \
 --name '"Axelar Test Token"' \
 --symbol '"ATT"' \
 --decimals 7 \
 --initial_supply 1000000000

Make sure to replace the salt with a proper 32-byte hexadecimal string. For convenience, you can use the example value shown above. After executing this command, you should receive a token_id. The contract will also internally store both the token_id and the salt for future operations.

You will see something like this:

ℹ️  Signing transaction: d6a4cb711a78b681324b9ef8d0ad57ab99bb465261d294daee7f5fbbae242a47
📅 CCXT3EAQ7GPQTJWENU62SIFBQ3D4JMNQSB77KRPTGBJ7ZWBYESZQBZRK - Event: [{"symbol":"interchain_token_deployed"},{"bytes":"76e302e75743a189b908c691e481cbc86f7635ae7d56667ebaf44555d8803e0b"},{"address":"CCNZ2XJUC3IHIJIB77NOWKHEHQHNYCNQHMZLNLQSAH5YQS7VWVBYBCKX"},{"string":"Axelar Test Token"},{"string":"ATT"},{"u32":7},"void"] = {"vec":[]}
📅 CCXT3EAQ7GPQTJWENU62SIFBQ3D4JMNQSB77KRPTGBJ7ZWBYESZQBZRK - Event: [{"symbol":"token_manager_deployed"},{"bytes":"76e302e75743a189b908c691e481cbc86f7635ae7d56667ebaf44555d8803e0b"},{"address":"CCNZ2XJUC3IHIJIB77NOWKHEHQHNYCNQHMZLNLQSAH5YQS7VWVBYBCKX"},{"address":"CAFKSZAAUJ6KVPC43ZOKXSYSEE6FMTLIPWUUZDHBYFZPVRR6THVOBDBG"},{"u32":0}] = {"vec":[]}
📅 CCNZ2XJUC3IHIJIB77NOWKHEHQHNYCNQHMZLNLQSAH5YQS7VWVBYBCKX - Event: [{"symbol":"minter_added"},{"address":"CAFKSZAAUJ6KVPC43ZOKXSYSEE6FMTLIPWUUZDHBYFZPVRR6THVOBDBG"}] = {"vec":[]}
📅 CCNZ2XJUC3IHIJIB77NOWKHEHQHNYCNQHMZLNLQSAH5YQS7VWVBYBCKX - Event: [{"symbol":"mint"},{"address":"CCXT3EAQ7GPQTJWENU62SIFBQ3D4JMNQSB77KRPTGBJ7ZWBYESZQBZRK"},{"address":"GAGZ5NZJMXKCORPFQMXYZJZTYDSZ5OPTYEPD2HSVNWU3MCV5JIL6IQDP"}] = {"i128":{"hi":0,"lo":1000000000}}
"76e302e75743a189b908c691e481cbc86f7635ae7d56667ebaf44555d8803e0b"

This deployment returns your token ID, which is 76e302e75743a189b908c691e481cbc86f7635ae7d56667ebaf44555d8803e0b in this example. Save it somewhere, as you will need it to do interchain token transfers.

Step 4: Deploy your token to the Avalanche Fuji testnet

With your token created, deploy its representation on the Avalanche Fuji testnet. Run the command below, replacing values as needed:

stellar contract invoke \
 --network testnet \
 --id YOUR_CONTRACT_ADDRESS \
 --source-account YOUR_ACCOUNT_NAME \
 -- \
 deploy_remote_token \
 --caller YOUR_ACCOUNT_NAME \
 --destination_chain '"Avalanche"' \
 --gas_token_address CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC \
 --gas_amount 10000000

Notes:

CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC is the address of the native XLM token on Stellar testnet.

The gas amount is 10 XLM (10,000,000,000 stroops).

We don’t need to specify the token_id as our contract stores this from the token deployment.

You should see:

ℹ️  Signing transaction: 41a6d7c068fb82c777008f8da95c1d285d3b99ca07594b7e2c71eb4ed569018f
📅 CCXT3EAQ7GPQTJWENU62SIFBQ3D4JMNQSB77KRPTGBJ7ZWBYESZQBZRK - Event: [{"symbol":"token_deployment_started"},{"bytes":"76e302e75743a189b908c691e481cbc86f7635ae7d56667ebaf44555d8803e0b"},{"address":"CCNZ2XJUC3IHIJIB77NOWKHEHQHNYCNQHMZLNLQSAH5YQS7VWVBYBCKX"},{"string":"Avalanche"},{"string":"Axelar Test Token"},{"string":"ATT"},{"u32":7},"void"] = {"vec":[]}
📅 CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC - Event: [{"symbol":"transfer"},{"address":"GAGZ5NZJMXKCORPFQMXYZJZTYDSZ5OPTYEPD2HSVNWU3MCV5JIL6IQDP"},{"address":"CAZUKAFB5XHZKFZR7B5HIKB6BBMYSZIV3V2VWFTQWKYEMONWK2ZLTZCT"},{"string":"native"}] = {"i128":{"hi":0,"lo":10000000000}}
📅 CAZUKAFB5XHZKFZR7B5HIKB6BBMYSZIV3V2VWFTQWKYEMONWK2ZLTZCT - Event: [{"symbol":"gas_paid"},{"address":"CCXT3EAQ7GPQTJWENU62SIFBQ3D4JMNQSB77KRPTGBJ7ZWBYESZQBZRK"},{"string":"axelar"},{"string":"axelar1aqcj54lzz0rk22gvqgcn8fr5tx4rzwdv5wv5j9dmnacgefvd7wzsy2j2mr"},{"bytes":"acd9ec020c801c7d6e5e9c15a5fa5b7e7944a0d5cdb027e2bdf4e70892d7ab54"},{"address":"GAGZ5NZJMXKCORPFQMXYZJZTYDSZ5OPTYEPD2HSVNWU3MCV5JIL6IQDP"},{"map":[{"key":{"symbol":"address"},"val":{"address":"CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC"}},{"key":{"symbol":"amount"},"val":{"i128":{"hi":0,"lo":10000000000}}}]}] = {...}
"76e302e75743a189b908c691e481cbc86f7635ae7d56667ebaf44555d8803e0b"

This is a cross-chain transaction. You can check its status on Axelarscan testnet explorer by pasting this transaction hash: 41a6d7c068fb82c777008f8da95c1d285d3b99ca07594b7e2c71eb4ed569018f. You can check here.

Step 5: Transfer tokens cross-chain from Stellar to Avalanche

Finally, send some tokens to your Avalanche wallet.

Prepare your Avalanche address (without the 0x prefix), and run:

stellar contract invoke \
 --network testnet \
 --id YOUR_CONTRACT_ADDRESS \
 --source-account YOUR_ACCOUNT_NAME \
 -- \
 transfer_tokens \
 --caller YOUR_ACCOUNT_NAME \
 --token_id YOUR_TOKEN_ID \
 --destination_chain '"Avalanche"' \
 --destination_address '"YOUR_AVALANCHE_ADDRESS"' \
 --amount 100000000 \
 --gas_token_address CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC \
 --gas_amount 10000000

Notes:

Replace YOUR_TOKEN_ID with the token ID you received from the deployment (e.g., 76e302e75743a189b908c691e481cbc86f7635ae7d56667ebaf44555d8803e0b).

Replace YOUR_AVALANCHE_ADDRESS with the InterchainToken Service on Avalanche Fuji tesnet (e.g., B5FB4BE02232B1bBA4dC8f81dc24C26980dE9e3C - without 0x prefix). The address is the same for all EVM chains.

The amount is 10 tokens with seven decimal places (100,000,000 base units).

You will get something like this:

ℹ️  Signing transaction: 6b8cf06327115b803aa465ebc9a12b9682753d89c391cca396bf767c31642fb2
📅 CCNZ2XJUC3IHIJIB77NOWKHEHQHNYCNQHMZLNLQSAH5YQS7VWVBYBCKX - Event: [{"symbol":"burn"},{"address":"GAGZ5NZJMXKCORPFQMXYZJZTYDSZ5OPTYEPD2HSVNWU3MCV5JIL6IQDP"}] = {"i128":{"hi":0,"lo":100000000}}
📅 CCXT3EAQ7GPQTJWENU62SIFBQ3D4JMNQSB77KRPTGBJ7ZWBYESZQBZRK - Event: [{"symbol":"interchain_transfer_sent"},{"bytes":"76e302e75743a189b908c691e481cbc86f7635ae7d56667ebaf44555d8803e0b"},{"address":"GAGZ5NZJMXKCORPFQMXYZJZTYDSZ5OPTYEPD2HSVNWU3MCV5JIL6IQDP"},{"string":"Avalanche"},{"bytes":"b5fb4be02232b1bba4dc8f81dc24c26980de9e3c"},{"i128":{"hi":0,"lo":100000000}}] = {"vec":["void"]}
📅 CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC - Event: [{"symbol":"transfer"},{"address":"GAGZ5NZJMXKCORPFQMXYZJZTYDSZ5OPTYEPD2HSVNWU3MCV5JIL6IQDP"},{"address":"CAZUKAFB5XHZKFZR7B5HIKB6BBMYSZIV3V2VWFTQWKYEMONWK2ZLTZCT"},{"string":"native"}] = {"i128":{"hi":0,"lo":10000000000}}
📅 CAZUKAFB5XHZKFZR7B5HIKB6BBMYSZIV3V2VWFTQWKYEMONWK2ZLTZCT - Event: [{"symbol":"gas_paid"},{"address":"CCXT3EAQ7GPQTJWENU62SIFBQ3D4JMNQSB77KRPTGBJ7ZWBYESZQBZRK"},{"string":"axelar"},{"string":"axelar1aqcj54lzz0rk22gvqgcn8fr5tx4rzwdv5wv5j9dmnacgefvd7wzsy2j2mr"},{"bytes":"4924e9eeae33b5800cb9418f98a473d14899b034034a9462cd72524697814b69"},{"address":"GAGZ5NZJMXKCORPFQMXYZJZTYDSZ5OPTYEPD2HSVNWU3MCV5JIL6IQDP"},{"map":[{"key":{"symbol":"address"},"val":{"address":"CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC"}},{"key":{"symbol":"amount"},"val":{"i128":{"hi":0,"lo":10000000000}}}]}] = {...}

Looking at axelarsscan with the hash: 6b8cf06327115b803aa465ebc9a12b9682753d89c391cca396bf767c31642fb2, you will have https://testnet.axelarscan.io/gmp/6b8cf06327115b803aa465ebc9a12b9682753d89c391cca396bf767c31642fb2.

You can register an existing token to make it an interchain token; however, we will cover that in a different guide.

Part 6: Receiving Tokens on Avalanche Fuji Testnet

After the cross-chain transfer is completed, you can find the address of your token on Avalanche by checking the Axelarscan explorer for your cross-chain transaction or your address on Avalanche Fuji testnet. Now you should be able to see your token balance in your wallet.

You can find the complete code example here.

Conclusion

You’ve now learned how to:

Deploy a new token on Stellar.
Make it available on an EVM chain.
Transfer tokens between blockchains.