# Cross-Chain Token Setup: BurnMint with Direct Mint Authority Transfer
Source: https://docs.chain.link/ccip/tutorials/svm/cross-chain-tokens/direct-mint-authority
Last Updated: 2025-08-13

> For the complete documentation index, see [llms.txt](/llms.txt).

This comprehensive tutorial demonstrates how to create and configure cross-chain tokens using Chainlink's Cross-Chain Interoperability Protocol (CCIP) between Solana Devnet and Ethereum Sepolia. You will implement the **direct mint authority transfer** approach within **Path A** from the [CCIP Cross-Chain Token Integration Guide](/ccip/concepts/cross-chain-token/svm/integration-guide).

## What You Will Build

This tutorial implements the **direct mint authority transfer** variant of **Path A** from the [CCIP Cross-Chain Token Integration Guide](/ccip/concepts/cross-chain-token/svm/integration-guide). This approach is designed for development and testing environments where you transfer complete mint authority to the Pool Signer PDA for simplified setup.

### Cross-Chain Token Architecture

This tutorial implements the **[Burn and Mint](/ccip/concepts/cross-chain-token/overview#burn-and-mint)** token handling mechanism between Solana Devnet and Ethereum Sepolia. You'll deploy **two BurnMint pools** (one on each chain) that work together to maintain consistent token supply across chains.

**How Burn and Mint Works:**

1. **Source Chain**: Burns tokens from sender's account
2. **CCIP Protocol**: Transmits message cross-chain
3. **Destination Chain**: Mints equivalent tokens to the receiver

### Component Overview

| Component            | Implementation                      | Authority Model                        |
| -------------------- | ----------------------------------- | -------------------------------------- |
| **Ethereum Sepolia** | ERC20 token with CCIP BurnMint pool | Multiple minters: EOA + Pool           |
| **Solana Devnet**    | SPL token with CCIP BurnMint pool   | Single mint authority: Pool Signer PDA |

### Authority Model Differences

- **Ethereum**: Your EOA + Pool both have mint privileges (multiple minters supported)
- **Solana**: Pool Signer PDA has exclusive mint authority (single authority constraint)

For complete details on token handling mechanisms, see [Token Handling Mechanisms](/ccip/concepts/cross-chain-token/overview#token-handling-mechanisms).

> **CAUTION: Development Environment Approach**
>
> **Important**: This tutorial transfers mint authority directly to the Pool Signer PDA for simplicity. This approach is
> designed for **development and testing environments only**.

**Key Authority Model Differences:**

- **Ethereum**: Your EOA retains mint privileges while the pool gets additional mint/burn roles

- **Solana**: Complete mint authority
  transfer to Pool Signer PDA (SPL tokens allow only one mint authority) **For production deployments**:
  - Learn more about [Production Multisig Tutorial](/ccip/tutorials/svm/cross-chain-tokens/production-multisig-tutorial) - Enterprise-grade dual-layer governance
  - Learn more about [Mint Authority Management](/ccip/concepts/cross-chain-token/svm/token-pools#mint-authority-management) for detailed security considerations.

## Prerequisites

This tutorial requires setting up two different repositories in separate terminal windows. Follow the setup instructions for both environments before proceeding.

### Development Environment Requirements

**System Requirements:**

- **Anchor and Solana CLI Tools**: Install following the [installation guide](https://www.anchor-lang.com/docs/installation). Requires Rust to be installed.
- **Node.js v20 or higher**: Use the [nvm package](https://www.npmjs.com/package/nvm) to install and manage versions. Verify with `node -v`
- **Yarn**: For dependency management
- **Git**: For cloning repositories

### Terminal 1: Solana Starter Kit Setup

**Clone and setup the Solana Starter Kit:**

```bash
git clone https://github.com/smartcontractkit/solana-starter-kit.git && cd solana-starter-kit
```

**Install dependencies:**

```bash
yarn install
```

**Configure your Solana environment:**

```bash
# Set Solana CLI to use devnet
solana config set --url https://api.devnet.solana.com

# Set your keypair (create one if needed)
solana config set --keypair ~/.config/solana/id.json

# If you do not have a keypair, create one:
solana-keygen new --outfile ~/.config/solana/id.json
```

**Fund your Solana wallet:**

```bash
# Get your wallet address
solana address

# Request SOL from the devnet faucet
solana airdrop 2
```

**Verify your setup:**

```bash
# Check your SOL balance
solana balance

# Verify you are on devnet
solana config get
```

### Terminal 2: Smart Contract Examples Setup

**Clone the repository and navigate to the Hardhat project:**

```bash
git clone https://github.com/smartcontractkit/smart-contract-examples.git
cd smart-contract-examples/ccip/cct/hardhat
```

**Install and compile dependencies:**

```bash
npm install
npm run compile
```

**Set up encrypted environment variables:**

```bash
# Set encryption password
npx env-enc set-pw

# Configure environment variables
npx env-enc set
```

**Required environment variables for Ethereum Sepolia:**

- `ETHEREUM_SEPOLIA_RPC_URL`: RPC endpoint from [Alchemy](https://www.alchemy.com/) or [Infura](https://www.infura.io/)
- `PRIVATE_KEY`: Your testnet wallet private key ([MetaMask export guide](https://support.metamask.io/managing-my-wallet/secret-recovery-phrase-and-private-keys/how-to-export-an-accounts-private-key/))
- `ETHERSCAN_API_KEY`: API key from [Etherscan](https://docs.etherscan.io/getting-started/viewing-api-usage-statistics)

**Fund your wallet:**

- Acquire LINK and ETH on Ethereum Sepolia using [Chainlink faucets](https://faucets.chain.link/)

> **NOTE: Two-Terminal Workflow**
>
> Keep both terminal windows open throughout the tutorial. You will switch between the Solana Starter Kit (Terminal 1)
> and Hardhat project (Terminal 2) as you progress through the phases.

## Tutorial Approach

This tutorial provides step-by-step instructions with detailed explanations of what each command does and why. You'll work primarily in Terminal 1 (Solana) with occasional switches to Terminal 2 (EVM).

**Environment Variable Management**: This tutorial uses phase-based variable files (e.g., `~/.phase1_vars`, `~/.ccip_complete_vars`) to eliminate manual variable re-entry when switching between terminals. Each phase saves its variables to files that subsequent phases can load automatically.

For deeper technical implementation details, refer to:

- **[Solana Starter Kit README](https://github.com/smartcontractkit/solana-starter-kit/blob/main/README.md)**: SVM command details
- **[Smart Contract Examples README](https://github.com/smartcontractkit/smart-contract-examples/blob/main/ccip/cct/hardhat/README.md)**: EVM implementation guide

## Phase 1: Ethereum Sepolia Token Setup

In this phase, you'll deploy and configure your ERC20 token with CCIP BurnMint pools on Ethereum Sepolia.

> **NOTE: Terminal Context**
>
> **Current Terminal: Terminal 2** (Smart Contract Examples - Hardhat) Verify your location:

```bash
pwd
# Should show: .../smart-contract-examples/ccip/cct/hardhat
```

### Step 1: Deploy ERC20 Token

Deploy a burnable and mintable ERC20 token that will serve as your cross-chain asset:

Set the token address variable:

### Step 2: Deploy BurnMint Token Pool

Deploy a CCIP token pool that will manage burning and minting operations:

Set the pool address variable:

### Step 3: Mint Initial Token Supply

Mint tokens to your wallet for testing cross-chain transfers:

### Step 4: Register as CCIP Administrator

Register yourself as the CCIP administrator for your token. This two-step process (claim + accept) ensures secure ownership transfer:

#### Claim Admin Role

#### Accept Admin Role

### Step 5: Save Phase 1 Variables

Save your EVM configuration for use in later phases:

## Phase 2: Solana Devnet Token Setup

Now we'll create and configure the Solana side of your cross-chain token system.

> **NOTE: Terminal Context**
>
> **Switch to Terminal 1** (Solana Starter Kit) Verify your location:

```bash
pwd
# Should show: .../solana-starter-kit
```

### Step 1: Create SPL Token

Create an SPL token with metadata support:

Set the token mint variable:

### Step 2: Initialize CCIP Token Pool

Initialize the token pool configuration on Solana:

Save the Pool Signer PDA and Pool Config PDA from the output:

### Step 3: Create Pool Token Account

In this step, you will create an Associated Token Account (ATA) for the Pool Signer PDA. This ATA is required for the pool to hold and manage tokens during cross-chain transfer operations.

### Step 4: Register as CCIP Administrator

#### Propose Admin

In this step, you will propose yourself as the CCIP administrator for the Solana token.

#### Accept Admin

In this step, you will accept the administrator role for the Solana token. This process establishes your control over the token's CCIP configuration on Solana.

### Step 5: Transfer Mint Authority to Pool Signer PDA

> **CAUTION: Critical Step: Mint Authority Transfer**
>
> **This is the defining step** of the direct mint authority approach. You're transferring complete mint authority to the Pool Signer PDA, which:

- **Enables**: Autonomous cross-chain minting for incoming transfers
- **Removes**: Your ability to mint additional tokens directly
- **Is Irreversible**: Cannot be undone in this tutorial setup

**Important**: Ensure you have sufficient tokens for testing before proceeding. The SPL token creation in Step 1 already minted tokens to your wallet, so you're ready to continue.

### Step 6: Save Phase 2 Variables

Save your Solana configuration for use in cross-chain setup:

## Phase 3: Cross-Chain Configuration

Configure bidirectional connectivity between your token pools on both chains.

### Step 1: Configure Solana Pool

**Stay in Terminal 1 (Solana Starter Kit)**

Load the Ethereum addresses from Phase 1:

#### Configure Remote Chain

In this step, you will initialize the configuration for Ethereum Sepolia as a remote chain. This creates the basic chain configuration with token information but without pool addresses (those will be added in the next step).

#### Add Remote Pool Address

In this step, you will use update the previously created chain configuration with the Ethereum pool address. This completes the configuration by telling the Solana pool which Ethereum pool it should interact with for cross-chain transfers.

### Step 2: Configure Ethereum Pool

**Switch to Terminal 2 (Smart Contract Examples)**

```bash
pwd
# Should output: ../smart-contract-examples/ccip/cct/hardhat
```

#### Load Variables from Previous Phases

Load all variables needed for EVM cross-chain configuration:

#### Configure Remote Chain

In this step, you will configure the Ethereum pool to recognize the Solana token and pool. This tells the Ethereum pool which Solana pool (via its Pool Config PDA) and token it should interact with for cross-chain transfers.

## Phase 4: Pool Registration

Register your token pools with their respective Token Admin Registries to enable cross-chain operations.

### Step 1: Register Ethereum Pool

**Stay in Terminal 2 (Smart Contract Examples)**

```bash
pwd
# Should output: ../smart-contract-examples/ccip/cct/hardhat
```

Register the BurnMint token pool with your token in the TokenAdminRegistry:

### Step 2: Register Solana Pool

**Switch to Terminal 1 (Solana Starter Kit)**

```bash
pwd
# Should show ../solana-starter-kit
```

#### Create Address Lookup Table

Address Lookup Tables (ALT) optimize Solana transactions by compressing addresses.

Save the ALT address:

#### Register Solana Pool

In this step, you will register the token pool with Solana's Router TokenAdminRegistry. This instruction sets the Address Lookup Table as the pool definition for the token, enabling it for CCIP cross-chain transfers. The `writable_indices` parameter specifies which accounts in the ALT need write access during transactions.

### Step 3: Save Complete Configuration

Save all variables for the testing phase:

## Phase 5: Pre-Transfer Setup

Before testing transfers, complete final setup steps.

### Step 1: Get Pool Signer PDA

Extract the Pool Signer PDA for reference:

Confirm this matches your previously saved PDA:

```bash
echo "Saved Pool Signer PDA: $SOL_POOL_SIGNER_PDA"
echo "Current Pool Signer PDA: BwzTc3R77vf1dS4kj3JX8YGpCvjsg91vBDgyKJfeBkue"
```

### Step 2: Delegate Token Authority

In this step, you will delegate token approval to the fee-billing signer PDA, which is what enables CCIP to transfer tokens on your behalf when sending cross-chain messages.

### Step 3: Verify Delegate

Check the previous step to verify the token is delegated to the Pool Signer PDA:

## Phase 6: Testing Cross-Chain Transfers

In this step, you will test bidirectional token transfers to verify your setup.

Confirm you are in the correct directory (Terminal 1):

```bash
pwd
# Should output: ../solana-starter-kit
```

### Step 1: Load Complete Configuration

Before testing, ensure all variables are available in your current terminal:

### Step 2: Transfer Solana → Ethereum

**In Terminal 1 (Solana Starter Kit)**

### Step 3: Transfer Ethereum → Solana

> **NOTE: EVM Credentials Required**
>
> For this direction, ensure your `.env` file in Terminal 1 contains your EVM credentials as set up in the
> prerequisites.

## Reference: Verification Commands

Use these commands to verify your setup at any point during the tutorial. Each section focuses on a specific component of your cross-chain configuration.

### Solana Pool Verification

**Terminal 1 (Solana Starter Kit)**

```bash
# Verify pool configuration and status
yarn svm:pool:get-info \
  --token-mint $SOL_TOKEN_MINT \
  --burn-mint-pool-program $CCIP_POOL_PROGRAM
```

**What this shows:**

- Pool configuration details
- Pool signer PDA information
- Token account balances
- Pool operational status

### Solana Chain Configuration

**Terminal 1 (Solana Starter Kit)**

```bash
# Verify cross-chain configuration with Ethereum
yarn svm:pool:get-chain-config \
  --token-mint $SOL_TOKEN_MINT \
  --burn-mint-pool-program $CCIP_POOL_PROGRAM \
  --remote-chain ethereum-sepolia
```

**What this shows:**

- Remote chain configuration
- Token address mappings
- Pool address mappings
- Cross-chain connectivity status

### Solana Token Balance

**Terminal 1 (Solana Starter Kit)**

```bash
# Check your token balance
spl-token balance $SOL_TOKEN_MINT
```

**What this shows:**

- Current token balance in your wallet
- Token account details
- Delegation status

### Ethereum Pool Verification

**Terminal 2 (Smart Contract Examples)**

```bash
# Verify Ethereum pool configuration
npx hardhat getPoolConfig \
  --pooladdress $ETH_POOL_ADDRESS \
  --network sepolia
```

**What this shows:**

- Pool contract configuration
- Remote chain settings
- Rate limiting parameters
- Pool operational status

### Cross-Chain Transfer Status

**Both Terminals**

```bash
# Monitor CCIP message status (replace with your message ID)
# From the transfer output, look for: "Message ID: 0x..."
# Then visit: https://ccip.chain.link/msg/0x...
```

**What this shows:**

- Transfer execution status
- Cross-chain message progress
- Completion confirmation
- Error details (if any)

> **CAUTION: Educational Example Disclaimer**
>
> This page includes an educational example to use a Chainlink system, product, or service and is provided to
> demonstrate how to interact with Chainlink's systems, products, and services to integrate them into your own. This
> template is provided "AS IS" and "AS AVAILABLE" without warranties of any kind, it has not been audited, and it may be
> missing key checks or error handling to make the usage of the system, product or service more clear. Do not use the
> code in this example in a production environment without completing your own audits and application of best practices.
> Neither Chainlink Labs, the Chainlink Foundation, nor Chainlink node operators are responsible for unintended outputs
> that are generated due to errors in code.