# Cross-Chain Token Setup: BurnMint with Production Multisig Governance
Source: https://docs.chain.link/ccip/tutorials/svm/cross-chain-tokens/production-multisig-tutorial
Last Updated: 2025-08-13

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

This tutorial implements **production-grade cross-chain tokens** using Chainlink CCIP with **dual-layer multisig governance** between Solana Devnet and Ethereum Sepolia. You'll build a **production-ready governance architecture** following **Path A** from the [CCIP Cross-Chain Token Integration Guide](/ccip/concepts/cross-chain-token/svm/integration-guide#path-a-full-self-service-mint-authority-controlled).

## What You Will Build

This tutorial implements the **production multisig governance** 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 **production environments** with enterprise-grade dual-layer governance.

### 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 with **dual-layer multisig governance**. You'll deploy **two BurnMint pools** (one on each chain) that work together to maintain consistent token supply across chains while providing enterprise-grade security controls.

**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

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

### Component Overview

| Component                | Implementation                       | Authority Model           |
| ------------------------ | ------------------------------------ | ------------------------- |
| **Ethereum Sepolia**     | ERC20 token with CCIP BurnMint pool  | EOA-controlled (tutorial) |
| **Solana Devnet**        | SPL token with dual-layer governance | Squads + SPL multisig     |
| **Cross-Chain Transfer** | Bidirectional token transfers        | Autonomous operations     |

### Dual-Layer Governance Architecture

This tutorial implements **dual-layer multisig governance** that separates concerns:

- **Layer 1 (Squads)**: Controls CCIP administration, pool ownership, protocol configuration
- **Layer 2 (SPL Multisig)**: Controls mint authority with Pool Signer PDA for autonomous operations

**Production Benefits:**

- **Comprehensive Security**: Two independent governance layers
- **Operational Autonomy**: Pool Signer PDA enables autonomous cross-chain transfers
- **Administrative Control**: Squads provides enterprise-grade governance

> **CAUTION: SPL Token Multisig Limitations**
>
> **Critical Understanding**: The SPL token multisig demonstrated in this tutorial can **ONLY execute SPL token
> instructions** (mint, burn, transfer, etc.). It **cannot execute arbitrary transactions** or general governance
> operations like transferring CCIP admin roles or pool ownership. This is why we implement dual-layer governance:
> Squads handles arbitrary governance operations while SPL multisig handles only token-specific operations.

## Prerequisites

### System Requirements

Install these tools before starting:

**Package Managers:**

- **Node.js v20+**: Required for all repositories
- **pnpm**: Required for base58 Generator (`npm install -g pnpm`)
- **yarn**: Required for Solana Starter Kit (`npm install -g yarn`)

**Solana Development:**

- **Solana CLI**: [Installation guide](https://docs.solana.com/cli/install-solana-cli-tools)

**Wallets:**

- **Solana wallet**: [Phantom](https://phantom.app/) or [Backpack](https://backpack.app/) for Devnet operations
- **Ethereum wallet**: [MetaMask](https://metamask.io/) for Sepolia testnet operations

### Repository Setup

Clone and install dependencies for all three repositories:

**Terminal 1: base58 Generator**

```bash
git clone https://github.com/smartcontractkit/ccip-solana-bs58-generator.git
cd ccip-solana-bs58-generator
pnpm install
```

**Terminal 2: EVM Hardhat**

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

**Terminal 3: Solana Starter Kit**

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

**Create and configure the .env file:**

```bash
# Create .env file in the project root
cat > .env << 'EOF'
EVM_PRIVATE_KEY=your_private_key_here
EVM_RPC_URL=your_rpc_url_here
EOF
```

Replace the placeholder values with:

- `EVM_PRIVATE_KEY`: Your Ethereum wallet private key (for Sepolia testnet operations)
- `EVM_RPC_URL`: Your Ethereum RPC URL (from [Alchemy](https://www.alchemy.com/), [Infura](https://www.infura.io/), or another provider)

### Environment Configuration

**Solana Configuration:**

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

# Create keypair (ONLY IF NEEDED)
solana-keygen new --outfile ~/.config/solana/id.json

# Check Config
solana config get

# Fund wallet
solana airdrop 3
```

**Ethereum Sepolia Configuration:**

```bash
# In Terminal 2 (Hardhat directory)
npx env-enc set-pw
npx env-enc set
```

Required environment variables:

- `ETHEREUM_SEPOLIA_RPC_URL`: RPC endpoint ([Alchemy](https://www.alchemy.com/) or [Infura](https://www.infura.io/))
- `PRIVATE_KEY`: Testnet wallet private key
- `ETHERSCAN_API_KEY`: API key from [Etherscan](https://etherscan.io/apis)

**Testnet Tokens:**

- **Solana Devnet**: Use `solana airdrop 3` for SOL
- **Ethereum Sepolia**: Use [Chainlink faucets](https://faucets.chain.link/) for LINK and ETH

### Squads Multisig Setup

> **CAUTION: Required: Create Squads Multisig**
>
> **Before starting this tutorial**, you must create a Squads multisig on Solana Devnet. This will serve as your
> governance mechanism for all CCIP administrative operations.

**Step 1: Prepare Signers**

Create multiple wallet addresses for your multisig signers:

```bash
# Create additional signers using Solana CLI
solana-keygen new --outfile ~/.config/solana/signer2.json
solana-keygen new --outfile ~/.config/solana/signer3.json

# Get signer addresses
solana address --keypair ~/.config/solana/id.json
solana address --keypair ~/.config/solana/signer2.json
solana address --keypair ~/.config/solana/signer3.json

# Fund signers (minimum 0.1 SOL each for transaction fees)
solana transfer <SIGNER2_ADDRESS> 0.1 --allow-unfunded-recipient
solana transfer <SIGNER3_ADDRESS> 0.1 --allow-unfunded-recipient
```

Alternatively, create signers in Phantom wallet and fund them:

```bash
# Transfer SOL to Phantom-created addresses
solana transfer <PHANTOM_SIGNER_ADDRESS> 0.5 --allow-unfunded-recipient
```

**Step 2: Create Your Squad**

1. Visit [devnet.squads.so](https://devnet.squads.so)
2. Connect your Solana wallet (e.g., Phantom/Backpack)
3. Click "Create New Squad"
4. Configure your multisig:
   - **Squad Name**: Choose a descriptive name (e.g., "CCIP Token Governance")
   - **Members**: Add wallet addresses of all signers
   - **Threshold**: Set approval threshold (recommended: 2/3 or 3/5)

> **NOTE: Threshold Best Practices**
>
> - **Avoid 1/n thresholds** (single point of failure)

- **Avoid maximum thresholds** (e.g., 3/3 prevents recovery if one key is lost)

**Step 3: Record Critical Addresses**

After Squad creation, navigate to Settings tab and record these addresses.

**In Terminal 1 (base58 Generator), export the vault address:**

```bash
# CRITICAL: Use the VAULT address, NOT the multisig address
export SOL_SQUAD_VAULT_MULTISIG="YOUR_VAULT_ADDRESS_HERE"
```

Verify the export:

```bash
echo "Squads Vault Address: $SOL_SQUAD_VAULT_MULTISIG"
```

> **CAUTION: Vault vs Multisig Address**
>
> **IMPORTANT**: Only use the **Vault address** for setting authorities and receiving funds. The **Multisig address** is
> used only for CLI detection - sending assets to it causes **irreversible loss**.

**Step 4: Test Your Squad**

Perform a small test transaction to verify setup:

1. Send a small amount of SOL to your Squad vault
2. Create a test transaction in Squads UI (e.g., SOL transfer to your wallet)
3. Confirm all signers can approve transactions
4. Execute the transaction

For detailed setup guidance, see the [Squads Documentation](https://docs.squads.so/).

### Token Creation Option

> **NOTE: Existing Token Requirements**
>
> **Important**: You can only skip token creation if you have an existing SPL token where the **mint authority is already controlled by your Squad vault**.

**Two scenarios:**

1. **Mint authority = Squad vault**: Skip to Step 3 (pool initialization) and export your existing mint address
2. **Mint authority ≠ Squad vault**: You must first transfer mint authority to your Squad vault, OR create a fresh token in Step 2

**For fresh start**: Proceed with Step 2 to create a new token with Squad vault as mint authority from the beginning.

## Tutorial Approach

This tutorial implements production-grade cross-chain tokens using a three-terminal workflow across specialized repositories:

| Terminal       | Repository                                                                                                                  | Purpose                          | Commands      |
| -------------- | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ------------- |
| **Terminal 1** | [CCIP Solana base58 Generator](https://github.com/smartcontractkit/ccip-solana-bs58-generator)                              | Generate governance transactions | `pnpm bs58`   |
| **Terminal 2** | [Smart Contract Examples (Hardhat)](https://github.com/smartcontractkit/smart-contract-examples/tree/main/ccip/cct/hardhat) | Deploy EVM components            | `npx hardhat` |
| **Terminal 3** | [Solana Starter Kit](https://github.com/smartcontractkit/solana-starter-kit)                                                | Test cross-chain transfers       | `yarn`        |

**Note**: Each repository contains comprehensive READMEs with detailed technical explanations and troubleshooting guides.

### Key Implementation Notes

- **Terminal 1** generates base58-encoded transactions for Squads multisig governance
- **Terminal 2** uses EOA for tutorial simplicity; production deployments should use multisig wallets (e.g., Safe)
- **Terminal 3** validates end-to-end cross-chain functionality

### base58 Transaction Execution Workflow

**Transaction Generation and Validation:**

1. **CLI Simulation**: Each base58 transaction is automatically simulated during generation
2. **Error Handling**: If simulation fails, error logs appear in terminal - do not upload failed transactions to Squads
3. **Success Indicator**: Successful simulation shows transaction preview and base58 output

**Squads Multisig Execution Process:**

1. **Propose**: A signer imports the base58 transaction into Squads UI → "Add instruction" → "Import base58 encoded tx" → **Initiate Transaction**
2. **Approve**: Required threshold (M) of signers review and approve the transaction
3. **Simulate** (Recommended): Before execution, signers can simulate through Squads interface to preview onchain effects
4. **Execute**: After threshold approval, any signer can execute the transaction

> **NOTE: Security Best Practice**
>
> Always simulate before execution using Squads' built-in simulation feature. This shows exactly what will happen
> onchain and is critical for validating complex governance operations before commitment.

### Environment Variables

Variables use prefixes to prevent confusion across repositories:

| Prefix   | Usage              | Examples                                   |
| -------- | ------------------ | ------------------------------------------ |
| `ETH_*`  | Ethereum addresses | `ETH_TOKEN_ADDRESS`, `ETH_POOL_ADDRESS`    |
| `SOL_*`  | Solana addresses   | `SOL_TOKEN_MINT`, `SOL_POOL_ADDRESS`       |
| `CCIP_*` | Protocol constants | `CCIP_POOL_PROGRAM`, `CCIP_ROUTER_PROGRAM` |

## Phase 1: EVM Chain Setup (Ethereum Sepolia)

In this phase, you will deploy ERC20 tokens and configure CCIP BurnMint pools on Ethereum Sepolia. This setup is identical across all Path A variants and provides the foundation for cross-chain operations.

> **NOTE: Terminal Context Check**
>
> **Current Focus: Terminal 2 (EVM Hardhat)** You'll be working exclusively in the Hardhat repository for this phase.
> Other terminals remain idle. Note: This tutorial uses EOA for simplicity; production deployments should use multisig
> wallets.

### Step 1: Prepare EVM Environment

First, set up your terminal and verify your environment:

### Step 2: Deploy ERC20 Token

Deploy your cross-chain token on Ethereum Sepolia:

Set the token address variable:

### Step 3: Deploy and Configure CCIP BurnMint Pool

Deploy the BurnMint token pool:

Set the pool address and configure:

### Step 4: Mint Initial Token Supply

Mint tokens for testing:

### Step 5: Claim CCIP Admin Role

In this step, you will use the `claimAdmin` task to register your EOA as the administrator for the deployed token on Ethereum Sepolia. This process involves calling the `RegistryModuleOwnerCustom` contract, which will fetch the CCIP admin of the token and set it up as the admin in the registry.

### Step 6: Accept CCIP Admin Role

In this step, you will use the `acceptAdminRole` task to accept the admin role for the deployed token on Ethereum Sepolia. Once you have claimed the role, accepting the role finalizes your control over the token administration.

### Step 7: Register Pool with Token

In this step, you will use the `setPool` task to register the BurnMint token pool with the token in Ethereum's TokenAdminRegistry contract. This function sets the pool contract address for the token, enabling it for CCIP cross-chain transfers. Only the token administrator can call this function.

**Phase 1 Complete**: Save your variables:

> **NOTE: Phase 1 Complete**
>
> **EVM Setup Complete**: You have successfully deployed and configured the EVM side. Next, you'll implement the
> production-grade Solana side with dual-layer multisig governance.

## Phase 2: Solana Setup with Production Dual Multisig Governance

In this phase, you will implement the **production-grade dual-layer multisig governance** architecture on Solana Devnet.

> **NOTE: Terminal Context Check**
>
> **Current Focus: Terminal 1 (base58 Generator)** Switch to the base58 generator repository for transaction generation.
> This tool creates Base58-encoded transactions that will be executed through Squads UI.

### Step 1: Prepare base58 Environment

### Step 2: Create SPL Token (Layer 2 Foundation)

This command generates a transaction that creates a new SPL token mint with the following features:

- **Mint Authority**: Set to your Squad vault multisig for governance control
- **Metaplex Metadata**: Includes token name, symbol, and URI for cross-platform compatibility
- **Initial Supply**: Automatically mints 5,000 tokens (5,000,000,000,000 smallest units) to your wallet
- **Deterministic Address**: Uses a seed-based approach for predictable mint addresses

> **TIP: Customize Your Token**
>
> **Recommended**: Create your own token metadata! Upload your token's JSON metadata to IPFS (using services like Pinata, NFT.Storage, or Arweave), then update the command parameters:

- `--name "Your Token Name"` (max 32 characters)
- `--symbol "YOUR-SYMBOL"` (max 10 characters)
- `--uri "https://your-ipfs-gateway/ipfs/your-hash"`
- `--initial-supply "your-amount"` (in smallest units)

This ensures your token has unique branding and proper metadata for cross-platform compatibility.

Generate the SPL token creation transaction (customize parameters or reuse the example):

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add
  instruction" → "Import base58 encoded tx"

- **Review**: Verify transaction details, check authority and mint

- **Simulate**: Simulate the transaction to ensure it will succeed

- **Approve**: Obtain required threshold signatures

- **Execute**: Complete the transaction execution

After execution, set the token mint:

### Step 3: Initialize BurnMint Token Pool (Before Multisig Setup)

> **CAUTION: Why Initialize Pool Before Mint Authority Transfer**
>
> **Critical**: Since your Squad multisig currently holds the mint authority, you can follow [**PATH A**
> (self-service)](/ccip/concepts/cross-chain-token/svm/integration-guide#path-a-full-self-service-mint-authority-controlled)
> and initialize the pool without Chainlink Labs intervention. However, once you transfer mint authority to an SPL token
> multisig, you would lose this capability - SPL token multisigs can only execute SPL token instructions, not CCIP pool
> initialization instructions. Initialize the pool now while you still have direct control.

**Alternative Options**: If you have an existing token where the mint authority is held by a wallet or another multisig under your control, you can transfer the mint authority to your Squad vault first to follow the self-service path. Otherwise, if you cannot control the mint authority, you can submit a [registration request](https://chain.link/ccip-contact?v=Tokens:%20Token%20admin%20registration) to have Chainlink Labs initialize the pool for you.

This command creates only one new account and establishes references to existing infrastructure:

**What Gets Created:**

- **Pool State PDA**: Creates the onchain Pool State account that stores your token's CCIP configuration

**What Gets Referenced (Not Created):**

- **Authority Assignment**: Sets your Squad vault as the pool owner with full configuration control
- **Router Integration**: References the existing global CCIP router and RMN (Risk Management Network)
- **Pool Signer PDA**: The Pool Signer PDA is mathematically derived but not created - it will be used on-demand during cross-chain operations

The `initialize-pool` instruction creates only the Pool State account for your SPL token mint, establishing you as the pool owner while referencing existing global infrastructure.

Generate the pool initialization transaction:

**Account Breakdown from the Transaction (Example):**

| Account | Address                                        | Purpose                                                     |
| ------- | ---------------------------------------------- | ----------------------------------------------------------- |
| **#1**  | `2pGY9WAjanpR3RnY5hQ1a23uDNomzFCAD5HMBgo8nH6M` | **Pool State PDA** - Your main pool configuration           |
| **#2**  | `3T1wVJporm2JpGojRV831TTQ1nexkBqFWhKnE5Lwedci` | Token Mint (your token)                                     |
| **#3**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | Authority (your Squad vault)                                |
| **#4**  | `11111111111111111111111111111111`             | System Program                                              |
| **#5**  | `41FGToCmdaWa1dgZLKFAjvmx6e6AjVTX7SVRibvsMGVB` | CCIP Pool Program                                           |
| **#6**  | `4sVSCJqG9ZKEvnpN38qTzb7Kc8QdHakBgB87HN3FYRaz` | Program Data PDA                                            |
| **#7**  | `E4Bsi43kX3iwXAFia2ebm1mS5Xkmmdv3minZDnfo7Zzf` | **Global Config PDA** - Program-wide configuration settings |

**Key Addresses You Need:**

- **Account #1** → `SOL_POOL_ADDRESS` (writable account = pool state)
- **Pool Signer PDA** → Must be derived separately (NOT in transaction accounts)

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add
  instruction" → "Import base58 encoded tx"

- **Review**: Verify pool initialization parameters

- **Simulate**: Simulate the transaction to ensure it will succeed

- **Approve**: Obtain required threshold signatures

- **Execute**: Complete the transaction execution

After execution, set the pool state address from the transaction:

```bash
# Set the pool state address from Account #1 in the transaction above
export SOL_POOL_ADDRESS="2pGY9WAjanpR3RnY5hQ1a23uDNomzFCAD5HMBgo8nH6M"
```

### Step 4: Derive Pool Signer PDA

The Pool Signer PDA is the critical address that will serve as the autonomous signing authority for cross-chain mint and burn operations.

Set the Pool Signer PDA address for use in subsequent steps:

### Step 5: Register CCIP Administrator

This two-step process establishes your Squad vault as the CCIP token administrator, enabling you to enable your token in CCIP. Since your Squad vault currently holds the mint authority, you can complete this registration using the [self-service registration flow](/ccip/concepts/cross-chain-token/svm/registration-administration#self-service-registration-flow) without external assistance.

**Why This Works**: The Router's [owner\_propose\_administrator](/ccip/concepts/cross-chain-token/svm/registration-administration#self-service-registration-flow) instruction verifies onchain that the caller matches the token's `mint_authority` field. Your Squad vault has this authority, enabling [PATH A self-service registration](/ccip/concepts/cross-chain-token/svm/integration-guide#path-a-full-self-service-mint-authority-controlled).

#### Sub-step 5a: Propose Administrator

The [owner\_propose\_administrator](/ccip/concepts/cross-chain-token/svm/registration-administration#self-service-registration-flow) instruction creates a TokenAdminRegistry PDA for your token and sets your Squad vault as the [pending administrator](/ccip/concepts/cross-chain-token/svm/registration-administration#self-service-registration-flow):

**Account Breakdown from the Transaction (Example):**

| Account | Address                                        | Description                                                           |
| ------- | ---------------------------------------------- | --------------------------------------------------------------------- |
| **#1**  | `3Yrg9E4ySAeRezgQY99NNarAmFLtixapga9MZb6y2dt3` | Router Config PDA (read-only)                                         |
| **#2**  | `4maPuX2fcDmCkQv1Qa6RmQa2yGpeZLxiqKy9ybwazGft` | **🎯 Token Admin Registry PDA** - Gets created/updated for your token |
| **#3**  | `3T1wVJporm2JpGojRV831TTQ1nexkBqFWhKnE5Lwedci` | Token Mint (your token)                                               |
| **#4**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | Authority/Payer (your Squad vault)                                    |
| **#5**  | `11111111111111111111111111111111`             | System Program                                                        |

**What This Transaction Does:**
This transaction proposes your Squad vault as the administrator for your token in the Router's Token Admin Registry. **Account #2** is the Token Admin Registry PDA that stores who has administrative control over your token's cross-chain operations.

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add
  instruction" → "Import base58 encoded tx"

- **Review**: Verify transaction details and parameters

- **Simulate**: Simulate the transaction to ensure it will succeed

- **Approve**: Obtain required threshold signatures

- **Execute**: Complete the transaction execution

#### Sub-step 5b: Accept Administrator Role

The [accept\_admin\_role](/ccip/concepts/cross-chain-token/svm/registration-administration#self-service-registration-flow) instruction completes the [registration process](/ccip/concepts/cross-chain-token/svm/registration-administration#self-service-registration-flow) by having the pending administrator (your Squad vault) explicitly accept the CCIP token administrator role:

**Account Breakdown from the Transaction (Example):**

| Account | Address                                        | Description                                                  |
| ------- | ---------------------------------------------- | ------------------------------------------------------------ |
| **#1**  | `3Yrg9E4ySAeRezgQY99NNarAmFLtixapga9MZb6y2dt3` | Router Config PDA (read-only)                                |
| **#2**  | `4maPuX2fcDmCkQv1Qa6RmQa2yGpeZLxiqKy9ybwazGft` | **🎯 Token Admin Registry PDA** - Updates status to "active" |
| **#3**  | `3T1wVJporm2JpGojRV831TTQ1nexkBqFWhKnE5Lwedci` | Token Mint (your token)                                      |
| **#4**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | Authority (your Squad vault - must be pending admin)         |

**What This Transaction Does:**
This is the **acceptance step** of the two-phase administrator registration. It updates the Token Admin Registry PDA (Account #2) from "pending administrator" to "active administrator" status. Your Squad vault explicitly accepts the administrator role, completing the secure registration process.

**Key Difference**: Only 4 accounts (vs. 5 in the propose step) because we're updating an existing registry entry, not creating a new one.

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add
  instruction" → "Import base58 encoded tx"

- **Review**: Verify transaction details and parameters

- **Simulate**: Simulate the transaction to ensure it will succeed

- **Approve**: Obtain required threshold signatures

- **Execute**: Complete the transaction execution

After both transactions are executed, your Squad vault will be the CCIP token administrator. See [Registration & Administration](/ccip/concepts/cross-chain-token/svm/registration-administration) for more details.

### Step 6: Create SPL Token Multisig (Layer 2 Mint Authority)

This command creates the second layer of your dual-multisig architecture by establishing an SPL token multisig that will control mint authority. The `create-multisig` instruction creates a deterministic multisig account that includes both your Pool Signer PDA and Squad vault as authorized signers.

**What This Accomplishes**:

- **SPL Token Multisig Creation**: Establishes a new multisig account
- **Dual Authority Setup**: Includes both Pool Signer PDA (for autonomous CCIP operations) and Squad vault (for governance control)
- **Threshold Configuration**: Sets threshold to 1, allowing either signer to authorize mint operations
- **Layer 2 Foundation**: Creates the mint authority that will be transferred from your Squad vault in the next step

**Token Program Detection**: The CLI automatically detects whether your mint uses SPL Token v1 or Token-2022 and creates the appropriate multisig type.

**Account Breakdown from the Transaction (Example):**

| Account | Address                                        | Description                               |
| ------- | ---------------------------------------------- | ----------------------------------------- |
| **#1**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Payer/Authority** (your Squad vault)    |
| **#2**  | `6c5UGRRQzPvZY4ZJZJiPGRYMw5e32uX8GfFzvm35k3jK` | **🎯 SPL Token Multisig** (newly created) |

**What This Transaction Does:**
This creates an **SPL Token Multisig** account that will control your token's mint authority. The CLI automatically detected SPL Token v1 and created the appropriate multisig type.

**Key Details:**

- **Generated Multisig Address**: `6c5UGRRQzPvZY4ZJZJiPGRYMw5e32uX8GfFzvm35k3jK`
- **Multisig Signers**: Pool Signer PDA + Squad vault
- **Threshold**: 1 (either signer can authorize mint operations)
- **Hybrid Control**: Enables both automated CCIP operations and human governance

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add instruction" → "Import base58 encoded tx"
- **Review**: Verify transaction details and parameters
- **Simulate**: Simulate the transaction to ensure it will succeed
- **Approve**: Obtain required threshold signatures
- **Execute**: Complete the transaction execution

**After execution, set the variable for the next step:**

### Step 7: Transfer Mint Authority (Layer 2 Mint Authority)

Transfer mint authority from your Squad vault to the SPL Token Multisig, completing the dual-layer governance architecture. This enables both automated CCIP operations and human governance control.

**What This Command Does:**

- **Authority Transfer**: Moves mint control from Squad vault to SPL Token Multisig
- **SPL Token Operation**: Uses the native `SetAuthority` instruction for mint authority
- **Governance Architecture**: Establishes the final production-ready control structure
- **Dual Control Setup**: Enables both Pool Signer PDA (autonomous) and Squad vault (governance) control
- **Irreversible Change**: Once executed, only the SPL Token Multisig can mint tokens

**Account Breakdown from the Transaction (Example):**

| Account | Address                                        | Description                                   |
| ------- | ---------------------------------------------- | --------------------------------------------- |
| **#1**  | `3T1wVJporm2JpGojRV831TTQ1nexkBqFWhKnE5Lwedci` | **Token Mint** (writable - authority updated) |
| **#2**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Current Authority** (signer - Squad vault)  |

**Key Details:**

- **Current Authority**: `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` (Squad vault)
- **New Authority**: `6c5UGRRQzPvZY4ZJZJiPGRYMw5e32uX8GfFzvm35k3jK` (SPL Token Multisig)
- **Token Mint**: `3T1wVJporm2JpGojRV831TTQ1nexkBqFWhKnE5Lwedci` (authority field updated)

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add
  instruction" → "Import base58 encoded tx"

- **Review**: Verify transaction details and parameters

- **Simulate**: Simulate the transaction to ensure it will succeed

- **Approve**: Obtain required threshold signatures

- **Execute**: Complete the transaction execution

### Step 8: Test Token Minting (Verify Dual-Layer Control)

Verify that your Squad vault can still mint tokens after the authority transfer. This proves the dual-layer governance is working correctly: Squad vault → SPL Token Multisig → Token minting.

**Purpose of This Test:**

- **Verify Authority Transfer**: Confirm the SPL Token Multisig now controls mint authority
- **Prove Squad Control**: Demonstrate that Squad vault can still mint through the multisig
- **Validate Architecture**: Test the dual-layer governance model works as designed

> **NOTE: Multisig Minting Process**
>
> **Important**: Since mint authority now belongs to the SPL Token Multisig, you must use multisig mode. The Squad vault
> acts as one of the multisig signers, proving it retains operational control through the new governance structure.

**Account Breakdown from the Transaction (Example):**

| Account | Address                                        | Description                                         |
| ------- | ---------------------------------------------- | --------------------------------------------------- |
| **#1**  | `3T1wVJporm2JpGojRV831TTQ1nexkBqFWhKnE5Lwedci` | **Token Mint** (writable - supply updated)          |
| **#2**  | `84FvKxAQpHtSaFLguFygoPPEaRorZpTjs8rmMCxuwqUF` | **Recipient's ATA** (writable - receives tokens)    |
| **#3**  | `6c5UGRRQzPvZY4ZJZJiPGRYMw5e32uX8GfFzvm35k3jK` | **SPL Token Multisig** (read-only - mint authority) |
| **#4**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Squad Vault** (signer - multisig member)          |

**What This Transaction Does:**
This is an **SPL Token Multisig Mint** operation that proves your dual-layer governance is working correctly. The Squad vault acts as a signer for the SPL Token Multisig that now controls mint authority.

**Key Details:**

- **Amount**: 1,000,000,000 smallest units = 1 token (with 9 decimals)
- **Recipient**: Your wallet address (`EPUjBP3Xf76K1VKsDSc6GupBWE8uykNksCLJgXZn87CB`)
- **Mint Authority**: SPL Token Multisig (`6c5UGRRQzPvZY4ZJZJiPGRYMw5e32uX8GfFzvm35k3jK`)
- **Multisig Signer**: Squad vault (`59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY`)
- **Token Program**: SPL Token v1 (`TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`)

**Transaction Flow:**

1. **Authority Verification**: SPL Token program verifies the multisig has mint authority
2. **Signature Validation**: Program confirms Squad vault is an authorized multisig signer
3. **Token Creation**: 1 token is minted and added to total supply
4. **Token Transfer**: New tokens are deposited into your wallet's ATA

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add instruction" → "Import base58 encoded tx"
- **Review**: Verify transaction details and parameters
- **Simulate**: Simulate the transaction to ensure it will succeed
- **Approve**: Obtain required threshold signatures
- **Execute**: Complete the transaction execution

**Phase 2 Complete**: Save your variables:

> **NOTE: Dual-Layer Architecture Established**
>
> **Production Governance Complete**: You have successfully established dual-layer multisig governance:

- **Layer 1**: Squads multisig controls CCIP administration
- **Layer 2**: SPL token multisig (Pool Signer PDA + Squads Vault) controls mint authority This provides comprehensive governance while maintaining autonomous CCIP operations.

## Phase 3: Solana Cross-Chain Setup

In this phase, you will configure the cross-chain connection and complete the CCIP setup.

> **NOTE: Terminal Context Check**
>
> **Current Focus: Terminal 1 (base58 Generator)** Continue using the base58 generator repository for cross-chain
> configuration.

### Step 1: Load Phase 1 Variables

Load Phase 1 variables and set the Ethereum Sepolia chain selector for cross-chain configuration.

**What This Step Does:**

- **Terminal Verification**: Confirms you're in the correct base58 generator repository
- **Variable Loading**: Imports EVM token and pool addresses from Phase 1
- **Chain Selector Setup**: Establishes Ethereum Sepolia chain selector for cross-chain configuration

### Step 2: Configure Cross-Chain Pool Settings

Configure your token pool for cross-chain transfers to Ethereum Sepolia. This process involves two sequential operations:

1. **Initialize Chain Remote Config**: Create the basic cross-chain configuration using [init\_chain\_remote\_config](/ccip/api-reference/svm/v1.6.0/burn-mint-token-pool#init_chain_remote_config)
2. **Edit Chain Remote Config**: Add the remote pool address using [edit\_chain\_remote\_config](/ccip/api-reference/svm/v1.6.0/burn-mint-token-pool#edit_chain_remote_config)

#### Step 2A: Initialize Chain Remote Config

Initialize the basic remote chain configuration for Ethereum Sepolia. Pool addresses must be empty at initialization and rate limits are not configured at this stage.

**Account Breakdown from the Transaction (Example):**

| Account | Address                                        | Description                                         |
| ------- | ---------------------------------------------- | --------------------------------------------------- |
| **#1**  | `2pGY9WAjanpR3RnY5hQ1a23uDNomzFCAD5HMBgo8nH6M` | **Pool State PDA** (read-only - validation)         |
| **#2**  | `8zdWLvsAgLQkRmBDATR3j8xVQzcdwrRNZtPZH5kU37jg` | **Chain Remote Config PDA** (writable - created)    |
| **#3**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Squad Vault** (signer, writable - pool authority) |
| **#4**  | `11111111111111111111111111111111`             | **System Program** (read-only - account creation)   |

**What This Command Does:**
This initializes the **cross-chain configuration** for your Solana token to enable CCIP bridging to Ethereum Sepolia. This creates the foundational connection without rate limits or pool addresses.

**Key Details:**

- **Remote Chain**: Ethereum Sepolia (chain selector: `16015286601757825753`)
- **Token Mapping**: Links to ERC20 token `0x7c57A9d966c3E6e344621C512d510f76575640ED`
- **Decimal Precision**: 18 decimals (standard EVM token format)
- **Basic Setup**: No rate limits or pool addresses configured at this stage
- **Account Creation**: Creates a new Chain Remote Config PDA for this cross-chain relationship

**Transaction Flow:**

1. **Authority Verification**: Confirms Squad vault owns the pool state
2. **PDA Derivation**: Calculates Chain Remote Config PDA using pool state + chain selector
3. **Account Creation**: Creates new account with rent-exempt balance
4. **Basic Configuration**: Stores minimal cross-chain parameters (no rate limits, no pool addresses)

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add instruction" → "Import base58 encoded tx"
- **Review**: Verify transaction details and parameters
- **Simulate**: Simulate the transaction to ensure it will succeed
- **Approve**: Obtain required threshold signatures
- **Execute**: Complete the transaction execution

#### Step 2B: Edit Chain Remote Config (Add Remote Pool Address)

After initializing the chain remote config, add the remote pool address to enable bidirectional cross-chain transfers. This uses [`edit_chain_remote_config`](/ccip/api-reference/svm/v1.6.0/burn-mint-token-pool#edit_chain_remote_config) to specify the Ethereum pool address.

**Account Breakdown from the Transaction:**

| Account | Address                                        | Description                                                    |
| ------- | ---------------------------------------------- | -------------------------------------------------------------- |
| **#1**  | `2pGY9WAjanpR3RnY5hQ1a23uDNomzFCAD5HMBgo8nH6M` | **Pool State PDA** (read-only - authority validation)          |
| **#2**  | `8zdWLvsAgLQkRmBDATR3j8xVQzcdwrRNZtPZH5kU37jg` | **Chain Remote Config PDA** (writable - configuration updated) |
| **#3**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Squad Vault Authority** (signer, writable - fee payer)       |
| **#4**  | `11111111111111111111111111111111`             | **System Program** (read-only - account operations)            |

**Transaction Flow:**

1. **Authority Verification**: Confirms Squad vault owns the pool state
2. **PDA Access**: Updates the existing Chain Remote Config PDA
3. **Pool Address Addition**: Adds the remote pool to the the remote pool list for Ethereum Sepolia

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add instruction" → "Import base58 encoded tx"
- **Review**: Verify transaction details and parameters
- **Simulate**: Simulate the transaction to ensure it will succeed
- **Approve**: Obtain required threshold signatures
- **Execute**: Complete the transaction execution

### Step 3: Configure Rate Limits (Optional)

This command configures inbound and outbound rate limiting for token transfers between your Solana token and Ethereum Sepolia. Rate limits act as "token buckets" that control the flow of tokens across chains.

> **NOTE: CCIP Rate Limit Best Practices**
>
> **Recommendations for rate limits:**

- **Outbound = 90% of Inbound**: Prevents in-flight congestion during high-volume periods
- **Conservative Values**: The example uses 20 tokens inbound capacity with 0.1 tokens/second refill rate
- **9-Decimal Tokens**: All values are in smallest token units (Solana uses 9 decimals)

**Configuration Controls:**

- **Pause lane**: Set `capacity=1`, `rate=1` for both directions
- **Remove limits**: Set `enabled=false`, `capacity=0`, `rate=0` for both directions

**Value Calculations:**

- 20 tokens = `20000000000` (20 × 10^9)
- 18 tokens = `18000000000` (18 × 10^9)
- 0.1 tokens/sec = `100000000` (0.1 × 10^9)

**Transaction Accounts (3 total):**

| Account | Address                                        | Type                 | Purpose                                                           |
| ------- | ---------------------------------------------- | -------------------- | ----------------------------------------------------------------- |
| **#1**  | `2pGY9WAjanpR3RnY5hQ1a23uDNomzFCAD5HMBgo8nH6M` | **Read-only**        | **Pool State PDA** - Main pool configuration account              |
| **#2**  | `8zdWLvsAgLQkRmBDATR3j8xVQzcdwrRNZtPZH5kU37jg` | **Writable**         | **Chain Config PDA** - Chain-specific config (stores rate limits) |
| **#3**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Signer, Writable** | **Authority** - Your Squad vault that can modify rate limits      |

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add instruction" → "Import base58 encoded tx"
- **Review**: Verify transaction details and parameters
- **Simulate**: Simulate the transaction to ensure it will succeed
- **Approve**: Obtain required threshold signatures
- **Execute**: Complete the transaction execution

### Step 4: Create Address Lookup Table

Create an Address Lookup Table (ALT) containing all accounts needed for CCIP router operations.

**What This Command Does:**

This command creates an **Address Lookup Table (ALT)** that stores frequently used accounts for CCIP operations. ALTs are a Solana optimization that reduces transaction size and costs by replacing full 32-byte addresses with small 1-byte indices.

**Account Breakdown from the Transaction:**

| Account | Address                                        | Description                                               |
| ------- | ---------------------------------------------- | --------------------------------------------------------- |
| **#1**  | `2s6yx6xCBgEQBrv5h4dF7TQvvKUWTJBEsueqTnZZHLwY` | **ALT Account** (writable - being created)                |
| **#2**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **ALT Authority** (signer - will own the table)           |
| **#3**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Fee Payer** (signer, writable - pays creation costs)    |
| **#4**  | `11111111111111111111111111111111`             | **System Program** (read-only - handles account creation) |

**What This Command Does:**

This command creates the ALT infrastructure needed for efficient CCIP operations by storing frequently used account addresses in a lookup table.

**Transaction Flow:**

1. **ALT Creation**: Creates lookup table account `2s6yx6x...` with Squad Vault as authority
2. **Core Address Addition**: Adds essential CCIP accounts (programs, PDAs) to the table
3. **SPL Multisig Addition**: Adds your SPL multisig `$SOL_SPL_MULTISIG` via `--additional-addresses`
4. **Index Assignment**: Each address gets a unique 1-byte index for future reference

**ALT Contents (What Gets Stored):**
The created lookup table will contain indices for these accounts in this exact order:

> **NOTE: Example-Specific Values**
>
> The addresses shown below are from our specific tutorial example. Your actual addresses will be different based on
> your token mint, multisig addresses, and derived PDAs.

| Index  | Account Address                                | Purpose                                               |
| ------ | ---------------------------------------------- | ----------------------------------------------------- |
| **0**  | `2s6yx6xCBgEQBrv5h4dF7TQvvKUWTJBEsueqTnZZHLwY` | **ALT Address (Self-Reference)**                      |
| **1**  | `4maPuX2fcDmCkQv1Qa6RmQa2yGpeZLxiqKy9ybwazGft` | **Token Admin Registry PDA**                          |
| **2**  | `41FGToCmdaWa1dgZLKFAjvmx6e6AjVTX7SVRibvsMGVB` | **Pool Program ID**                                   |
| **3**  | `2pGY9WAjanpR3RnY5hQ1a23uDNomzFCAD5HMBgo8nH6M` | **Pool State PDA**                                    |
| **4**  | `BKkeydRQWKDc5dR7euwhYi47TDLV99o8pD83ncGA2LdZ` | **Pool Signer's Associated Token Account**            |
| **5**  | `8NTqDH8dFj7aU5FBWeNMJwjsR1gZMR7criaEaDMEE24r` | **Pool Signer PDA**                                   |
| **6**  | `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`  | **Token Program ID (SPL Token v1)**                   |
| **7**  | `3T1wVJporm2JpGojRV831TTQ1nexkBqFWhKnE5Lwedci` | **Token Mint**                                        |
| **8**  | `GTz54AfhMRkKzFVse8jX8rjAx21fA86ZmVBF1v5VUC3u` | **Fee Quoter Token Config PDA**                       |
| **9**  | `H6ZviaabTYZqUPgiSoMDbeVthcNW9ULcAuUu3zRLFqDR` | **Router External Token Pools Signer PDA**            |
| **10** | `6c5UGRRQzPvZY4ZJZJiPGRYMw5e32uX8GfFzvm35k3jK` | **SPL Token Multisig** ← **Your Additional Address!** |

**Transaction Efficiency Impact:**

- **Before ALT**: Each account = 32 bytes (10 accounts = 320 bytes)
- **After ALT**: Each account = 1 byte index (10 accounts = 10 bytes)
- **Savings**: \~310 bytes per future CCIP transaction!

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add instruction" → "Import base58 encoded tx"
- **Review**: Verify transaction details and parameters
- **Simulate**: Simulate the transaction to ensure it will succeed
- **Approve**: Obtain required threshold signatures
- **Execute**: Complete the transaction execution

**Set Variables:**

Copy the ALT address from the transaction output and set the environment variable:

### Step 5: Register Pool with Router

Register your token pool with the CCIP Router using [set\_pool](/ccip/api-reference/svm/v1.6.0/router#set_pool). This enables the router to route cross-chain transfers through your token pool.

**What This Command Does:**

- **Pool Registration**: Connects your token pool to the CCIP Router for cross-chain operations
- **Lookup Table Integration**: Uses the ALT created in the previous step for efficient account management
- **Router Configuration**: Enables the router to call your pool's token operations

**Account Breakdown from the Transaction:**

| Account | Address                                        | Description                                                 |
| ------- | ---------------------------------------------- | ----------------------------------------------------------- |
| **#1**  | `3Yrg9E4ySAeRezgQY99NNarAmFLtixapga9MZb6y2dt3` | **Router Config PDA** (read-only - configuration reference) |
| **#2**  | `4maPuX2fcDmCkQv1Qa6RmQa2yGpeZLxiqKy9ybwazGft` | **Token Admin Registry PDA** (writable - pool registration) |
| **#3**  | `3T1wVJporm2JpGojRV831TTQ1nexkBqFWhKnE5Lwedci` | **Token Mint** (read-only - token identification)           |
| **#4**  | `2s6yx6xCBgEQBrv5h4dF7TQvvKUWTJBEsueqTnZZHLwY` | **Address Lookup Table** (read-only - ALT registration)     |
| **#5**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Squad Vault Authority** (signer, writable - admin & fees) |

**What This Command Does:**

This command **registers your token pool** with the CCIP Router. It configures the router to use your Address Lookup Table and specifies which accounts need write access during CCIP operations.

**Key Configuration:**

- **ALT Integration**: Uses the lookup table `2s6yx6x...` you just created
- **Writable Indexes**: `[3,4,7]` - Specific accounts from the ALTthat need write access during CCIP operations

**Transaction Flow:**

1. **Authority Verification**: Confirms Squad Vault has CCIP token admin permissions
2. **Pool Registration**: Updates Token Admin Registry with pool configuration
3. **ALT Association**: Links your token with the specific lookup table
4. **Permission Setup**: Defines which accounts can be modified during cross-chain operations

**Writable Indexes Analysis: `[3,4,7]`**

Based on the ALT order established earlier:

| **Index** | **ALT Account** | **Why Writable**                                 |
| --------- | --------------- | ------------------------------------------------ |
| **3**     | Pool State PDA  | Gets updated during cross-chain operations       |
| **4**     | Pool Token ATA  | Tokens get minted/burned during transfers        |
| **7**     | Token Mint      | Supply gets modified during mint/burn operations |

> **NOTE: Squads Execution Required**
>
> **Execute this base58 transaction in Squads UI:**

- **Import**: Copy the base58 output → Squads UI → "Add instruction" → "Import base58 encoded tx"
- **Review**: Verify transaction details and parameters
- **Simulate**: Simulate the transaction to ensure it will succeed
- **Approve**: Obtain required threshold signatures
- **Execute**: Complete the transaction execution

**Phase 3 Complete**: Save all variables:

## Phase 4: EVM Cross-Chain Setup

Configure the Ethereum pool to recognize the Solana chain and set production rate limits.

> **NOTE: Terminal Context Check**
>
> **Current Focus: Terminal 2 (EVM Hardhat)** - Ensure you're in the Hardhat repository for EVM configuration.

### Step 1: Load Phase 3 Variables

Ensure you're in Terminal 2 (Hardhat) and load all the variables from Phase 3.

### Step 2: Configure Cross-Chain Settings

Configure the Ethereum pool to recognize the Solana chain and set production rate limits using [`applyChainUpdates`](/ccip/api-reference/evm/v1.6.1/token-pool#applychainupdates).

> **TIP: CCIP Rate Limit Best Practices**
>
> **Recommendations for rate limits**:

- **Outbound = 90% of Inbound**: Prevents in-flight congestion during high-volume periods
- **Conservative Values**: The example uses 20 tokens inbound capacity with 0.1 tokens/second refill rate
- **18-Decimal Tokens**: All values are in wei (smallest token unit)
- **Configuration Controls**:
  - **Pause lane**: Set capacity=1, rate=1 for both directions
  - **Remove limits**: Set enabled=false, capacity=0, rate=0 for both directions
- **Value Calculations**:
  - 20 tokens = `20000000000000000000` wei (20 × 10^18)
  - 18 tokens = `18000000000000000000` wei (18 × 10^18)
  - 0.1 tokens/sec = `100000000000000000` wei (0.1 × 10^18)

## Phase 5: Testing and Validation

> **NOTE: Terminal Context Check**
>
> **Current Focus: Terminal 3 (Solana Testing)** Switch to the Solana Starter Kit repository for comprehensive testing.

### Step 1: Load Phase 4 Variables

Before testing cross-chain transfers, ensure your terminal environment is properly configured:

### Transfer Direction 1: Solana → Ethereum

Test the production multisig setup with a cross-chain transfer from Solana Devnet to Ethereum Sepolia:

#### Prepare for Testing

Before testing cross-chain transfers, you need to create the pool's Associated Token Account (ATA) and prepare your tokens:

##### Check Token Balance

##### Create Pool Associated Token Account

##### Delegate Token Authority

#### Transfer tokens from Solana Devnet to Ethereum Sepolia

#### Monitor and Verify Transaction

Upon successful execution, the system generates critical tracking identifiers for transaction monitoring and verification.

**Transaction Identifiers:**

- **Transaction Signature**: `4T6coWNspJ7TDhsUFVZ7S1huzVxy6dSjbPfrFw4THGRBEt8X9UYfFggrxYLD4Hnm11Hqdnzg9vJTbrNSjp7ycRvf`
- **CCIP Message ID**: `0x21d6ca53d5ab59caa9d5a1d58a5f8040f9695043dcad5ddc0059710dff0113c3`

**CCIP Explorer** (Primary monitoring interface):

```
https://ccip.chain.link/msg/0x21d6ca53d5ab59caa9d5a1d58a5f8040f9695043dcad5ddc0059710dff0113c3
```

The CCIP Explorer provides comprehensive transaction visibility:

- Source chain (Solana) transaction confirmation
- CCIP message processing and routing
- Destination chain (Ethereum) message delivery
- Token minting completion on Ethereum

**Solana Explorer** (Source chain verification):

```
https://explorer.solana.com/tx/4T6coWNspJ7TDhsUFVZ7S1huzVxy6dSjbPfrFw4THGRBEt8X9UYfFggrxYLD4Hnm11Hqdnzg9vJTbrNSjp7ycRvf?cluster=devnet
```

### Transfer Direction 2: Ethereum → Solana

> **NOTE: Terminal Environment**
>
> **Continue in Terminal 3** (Solana Starter Kit directory). No need to switch terminals - the Solana Starter Kit
> handles Ethereum → Solana transfers as well.

#### Transfer tokens from Ethereum Sepolia to Solana Devnet

#### Monitor and Verify Transaction

Upon successful execution, the system generates distinct tracking identifiers for comprehensive monitoring across both blockchain networks.

**Transaction Identifiers:**

- **Ethereum Transaction Hash**: `0x55e6e9c295c7d32bc0d708f3363e42aad37298f9f30b4db0889e06bfac761157`
- **CCIP Message ID**: `0x11ef3640d8030bae75c2e4ca863a122bbf28fbbcd1dc83be0f77a25091442c72`

**CCIP Explorer** (Primary monitoring interface):

```
https://ccip.chain.link/msg/0x11ef3640d8030bae75c2e4ca863a122bbf28fbbcd1dc83be0f77a25091442c72
```

The CCIP Explorer provides comprehensive transaction visibility:

- Source chain (Ethereum) transaction confirmation
- CCIP message processing and routing
- Destination chain (Solana) message delivery
- Token minting completion on Solana network

**Ethereum Sepolia Explorer** (Source chain verification):

```
https://sepolia.etherscan.io/tx/0x55e6e9c295c7d32bc0d708f3363e42aad37298f9f30b4db0889e06bfac761157
```

### Test Solana Rate Limit Enforcement (Optional)

> **NOTE: Rate Limit Configuration Reminder**
>
> **Current Rate Limits**: If you followed Phase 3 with rate limits enabled:

- **Solana Outbound**: 18 tokens capacity, 0.1 tokens/second rate
- **Solana Inbound**: 20 tokens capacity, 0.1 tokens/second rate
- **Ethereum**: Similar limits (18-decimal equivalent: 18/20 ETH tokens)

**Testing Strategy**: Attempt to transfer 25 tokens (exceeds 20-token inbound capacity).

The transaction correctly failed with `RLMaxCapacityExceeded` error because:

- **Attempted**: 25 tokens (`25000000000` in smallest units)
- **Limit**: 20 tokens maximum capacity (`20000000000`)
- **Result**: Rate limiter blocked the excessive transfer

**Key Error Details:**

- **Error Code**: `RLMaxCapacityExceeded` (Error Number: 6015)
- **Source**: `programs/base-token-pool/src/rate_limiter.rs:48`
- **Meaning**: The token bucket capacity was exceeded

This demonstrates that your rate limits are properly configured and actively protecting against transfers that exceed the configured limits.

### Test EVM Rate Limit Enforcement (Optional)

Test rate limits from the EVM side (Ethereum to Solana) using the same 25-token limit.

The transaction correctly failed because:

- **Attempted**: 25 tokens (`25000000000000000000` wei - 18 decimals)
- **Limit**: 18 tokens maximum capacity
- **Error Selector**: [`0x1a76572a` (TokenMaxCapacityExceeded)](/ccip/api-reference/evm/v1.6.1/errors#rate-limiter-errors)
- **Decoded Values**: Capacity: `18000000000000000000`, Attempted: `25000000000000000000`, Token: `0x9cE471d0a7bE21ee32276dde49104fe02c812906`

This demonstrates that rate limits are enforced on both chains, protecting the cross-chain bridge from excessive transfers. The EVM error selector corresponds to the `TokenMaxCapacityExceeded` error in the [CCIP EVM v1.6.0 errors reference](/ccip/api-reference/evm/v1.6.1/errors).