# Cross-Chain Token Setup: LockRelease Pool with Squads Governance
Source: https://docs.chain.link/ccip/tutorials/svm/cross-chain-tokens/lock-release-multisig
Last Updated: 2025-09-17

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

This tutorial demonstrates how to implement cross-chain tokens using the **[Lock and Mint](/ccip/concepts/cross-chain-token/overview#lock-and-mint)** mechanism with production-grade governance.

## What You Will Build

You'll create a cross-chain token system with two key components:

- **LockRelease Pool on Solana Devnet**: Locks tokens when sending from Solana, releases tokens when receiving to Solana
- **BurnMint Pool on Ethereum Sepolia**: Mints tokens when receiving from Solana, burns tokens when sending to Solana

**Cross-Chain Transfer Flow:**

**Solana → Ethereum (Lock and Mint):**

1. **Lock**: LockRelease pool locks tokens in the token pool on Solana
2. **Mint**: BurnMint pool mints tokens on Ethereum

**Ethereum → Solana (Burn and Unlock):**

1. **Burn**: BurnMint pool burns tokens on Ethereum
2. **Unlock**: LockRelease pool releases tokens from the token pool on Solana

## Governance Architecture

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

This tutorial demonstrates **LockRelease pool governance** using Squads multisig for production-grade security:

**Key Governance Roles:**

- **Pool Owner** (Squads): Controls pool configuration, rate limits, and operational parameters
- **Rebalancer** (Squads): Manages liquidity provisioning across chains
- **Token Mint Authority**: Remains with original token creator (no transfer required)

**Production Benefits:**

- **No mint authority complexity**: LockRelease pools don't need token minting permissions
- **Focused governance**: Squads handles pool operations and liquidity management only
- **Production security**: Multi-signature approval for all critical pool operations

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

## 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 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 LockRelease Token Pool

> **CAUTION: Why Initialize Pool Before Mint Authority Transfer**
>
> Since your Squad multisig currently holds the mint authority, you can initialize the pool without Chainlink Labs intervention.

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 programmatically derived - 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 your Squad vault as the pool owner while referencing existing global infrastructure.

Generate the pool initialization transaction:

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

| Account | Address                                        | Purpose                                                     |
| ------- | ---------------------------------------------- | ----------------------------------------------------------- |
| **#1**  | `9VnLxEtwJgnGALzhhXJTtRr4GF83z95aCypPiRFGi9d1` | **Pool State PDA** - Your main pool configuration           |
| **#2**  | `FVJeMAQSH9dJvVmhe8NHC2DHTEEqT5cgVXTL5CYYmKu1` | Token Mint (your token)                                     |
| **#3**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | Authority (your Squad vault)                                |
| **#4**  | `11111111111111111111111111111111`             | System Program                                              |
| **#5**  | `8eqh8wppT9c5rw4ERqNCffvU6cNFJWff9WmkcYtmGiqC` | CCIP Pool Program                                           |
| **#6**  | `AeMEQshfd7w72oGt5cMn8196zod6gQPWskbf5BY83W1B` | Program Data PDA                                            |
| **#7**  | `6Nh9CWRGW69VJ7mnD9ELjm6BMkbvoGvVse2HuNuaHPqm` | **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="9VnLxEtwJgnGALzhhXJTtRr4GF83z95aCypPiRFGi9d1"
```

### 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**  | `89Jy2ZEz6LcvBPVQgR2YxPYVoF1sLugNRs3havQP8SvF` | **🎯 Token Admin Registry PDA** - Gets created/updated for your token |
| **#3**  | `FVJeMAQSH9dJvVmhe8NHC2DHTEEqT5cgVXTL5CYYmKu1` | 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**  | `89Jy2ZEz6LcvBPVQgR2YxPYVoF1sLugNRs3havQP8SvF` | **🎯 Token Admin Registry PDA** - Updates status to "active" |
| **#3**  | `FVJeMAQSH9dJvVmhe8NHC2DHTEEqT5cgVXTL5CYYmKu1` | 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 Squad Vault Token Account

Create the Associated Token Account (ATA) for the Squad vault. This account will receive the minted tokens that will later be used for pool liquidity.

**Transaction Details:**

- **Squad Vault ATA**: `G7yVJJKDRBQDdbFttmA3G3oytFKBcsZH8VMdJWBXJKJB` (example)
- **Owner**: Squad vault PDA

### Step 7: Mint Tokens for Pool Liquidity

Mint tokens to your Squad vault to prepare for LockRelease pool liquidity provisioning. Since LockRelease pools require liquidity management, we'll mint tokens that the Squad vault (acting as rebalancer) can later provide to the pool.

**Purpose:**

- **Liquidity Preparation**: Create tokens that will be used for pool liquidity management
- **Rebalancer Setup**: Squad vault will serve as the rebalancer role for the LockRelease pool
- **Pool Operations**: LockRelease pools need liquidity to fulfill cross-chain transfer requests

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

| Account | Address                                        | Description                                        |
| ------- | ---------------------------------------------- | -------------------------------------------------- |
| **#1**  | `FVJeMAQSH9dJvVmhe8NHC2DHTEEqT5cgVXTL5CYYmKu1` | **Token Mint** (writable - supply updated)         |
| **#2**  | `G7yVJJKDRBQDdbFttmA3G3oytFKBcsZH8VMdJWBXJKJB` | **Squad vault's ATA** (writable - receives tokens) |
| **#3**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Squad Vault** (signer)                           |

**What This Transaction Does:**
This is a standard SPL token mint operation that mints tokens for the Squad vault to use as liquidity for the LockRelease pool. Since the Squad vault retains mint authority, it can directly mint tokens without requiring multisig operations.

**Key Details:**

- **Amount**: 100,000,000,000 smallest units = 100 tokens (with 9 decimals)
- **Recipient**: Squad vault address (will serve as rebalancer for pool liquidity)
- **Mint Authority**: Squad vault (retains original mint authority)
- **Token Program**: SPL Token v1 (`TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`)

**Transaction Flow:**

1. **Authority Verification**: SPL Token program verifies Squad vault has mint authority
2. **Token Creation**: 100 tokens are minted and added to total supply
3. **Token Transfer**: New tokens are deposited into Squad vault's ATA
4. **Liquidity Preparation**: Tokens are now available for pool liquidity 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

### Step 8: Set Rebalancer Role

Configure the Squad vault as the rebalancer for the LockRelease pool. The rebalancer role is required before any liquidity operations can be performed.

**What This Command Does:**

- **Rebalancer Assignment**: Designates the Squad vault as the authorized liquidity manager
- **Pool Configuration**: Updates the pool state to allow liquidity operations
- **Governance Setup**: Establishes who can provide and withdraw pool liquidity

**Account Breakdown:**

| Account | Address                                        | Description                                  |
| ------- | ---------------------------------------------- | -------------------------------------------- |
| **#1**  | `9VnLxEtwJgnGALzhhXJTtRr4GF83z95aCypPiRFGi9d1` | **Pool state PDA** (writable)                |
| **#2**  | `FVJeMAQSH9dJvVmhe8NHC2DHTEEqT5cgVXTL5CYYmKu1` | **Token Mint** (read-only - your token mint) |
| **#3**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Squad Vault** (signer)                     |

> **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 rebalancer address matches your Squad vault
- **Simulate**: Simulate the transaction to ensure it will succeed
- **Approve**: Obtain required threshold signatures
- **Execute**: Complete the transaction execution

### Step 9: Create Pool Token Account

Create the Associated Token Account (ATA) for the Pool Signer PDA. This account will hold the pool's token reserves for cross-chain operations.

**Transaction Details:**

- **Pool ATA**: `A57bH91QkGuARh37JTN41fd3Vwcmf2bLzVHAVPB8Gaeg` (example)
- **Owner**: Pool Signer PDA

### Step 10: Set Can Accept Liquidity

Configure the LockRelease pool to accept liquidity from the rebalancer. This setting must be enabled before the pool can receive liquidity provisions.

**What This Command Does:**

- **Liquidity Configuration**: Enables the pool to accept liquidity from the authorized rebalancer
- **Pool Setting**: Updates the `can_accept_liquidity` flag to `true`
- **Required Setup**: Must be completed before providing liquidity to the pool

**Account Breakdown:**

| Account | Address                                        | Description                                           |
| ------- | ---------------------------------------------- | ----------------------------------------------------- |
| **#1**  | `9VnLxEtwJgnGALzhhXJTtRr4GF83z95aCypPiRFGi9d1` | **Pool State PDA** (writable - configuration updated) |
| **#2**  | `FVJeMAQSH9dJvVmhe8NHC2DHTEEqT5cgVXTL5CYYmKu1` | **Token Mint** (read-only)                            |
| **#3**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Squad Vault** (signer - pool owner authority)       |

**Transaction Flow:**

1. **Authority Verification**: Confirms Squad vault is the pool owner
2. **Configuration Update**: Sets `can_accept_liquidity` flag to `true`
3. **Pool Preparation**: Enables the pool to accept liquidity from the rebalancer

> **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 the liquidity acceptance setting is enabled
- **Simulate**: Simulate the transaction to ensure it will succeed
- **Approve**: Obtain required threshold signatures
- **Execute**: Complete the transaction execution

### Step 11: Approve Pool Signer as Delegate

Approve the Pool Signer PDA to spend tokens from the Squad vault's ATA. This delegation is required for the pool to transfer tokens during liquidity operations.

**What This Command Does:**

- **Token Delegation**: Authorizes Pool Signer PDA to spend tokens from Squad vault's ATA
- **Liquidity Permission**: Enables the pool to access Squad vault's tokens for liquidity operations
- **Required Setup**: Must be completed before the pool can provide liquidity

**Account Breakdown:**

| Account | Address                                        | Description                                         |
| ------- | ---------------------------------------------- | --------------------------------------------------- |
| **#1**  | `G7yVJJKDRBQDdbFttmA3G3oytFKBcsZH8VMdJWBXJKJB` | **Squad Vault ATA** (writable - delegation updated) |
| **#2**  | `E8odUv4V4DXy3RWvkNYF7H33X9J56RtsFp4ExVXB86UA` | **Pool Signer PDA** (read-only - delegate)          |
| **#3**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Squad Vault** (signer - token account owner)      |

**Transaction Flow:**

1. **Authority Verification**: Confirms Squad vault owns the token account
2. **Delegation Setup**: Authorizes Pool Signer PDA to spend up to 50 tokens

> **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 delegate address is the Pool Signer PDA
- **Simulate**: Simulate the transaction to ensure it will succeed
- **Approve**: Obtain required threshold signatures
- **Execute**: Complete the transaction execution

### Step 12: Provide Liquidity to Pool

Provide initial liquidity to the LockRelease pool using the tokens minted in Step 7. Liquidity management is essential to ensure that for inbound token transfers (when Solana is the destination chain), the pool has sufficient token balance in its reserves to transfer tokens to receivers.

**What This Command Does:**

- **Liquidity Transfer**: Moves tokens from Squad vault's ATA to the pool's ATA
- **Pool Funding**: Provides the pool with tokens needed for cross-chain operations
- **Rebalancer Operation**: Uses the rebalancer role set in Step 7

**Account Breakdown:**

| Account | Address                                        | Description                                         |
| ------- | ---------------------------------------------- | --------------------------------------------------- |
| **#1**  | `9VnLxEtwJgnGALzhhXJTtRr4GF83z95aCypPiRFGi9d1` | **Pool State PDA** (read-only)                      |
| **#2**  | `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`  | **Token Program** (read-only)                       |
| **#3**  | `FVJeMAQSH9dJvVmhe8NHC2DHTEEqT5cgVXTL5CYYmKu1` | **Token Mint** (writable)                           |
| **#4**  | `E8odUv4V4DXy3RWvkNYF7H33X9J56RtsFp4ExVXB86UA` | **Pool Signer PDA** (read-only)                     |
| **#5**  | `A57bH91QkGuARh37JTN41fd3Vwcmf2bLzVHAVPB8Gaeg` | **Pool Token ATA** (writable - receives liquidity)  |
| **#6**  | `G7yVJJKDRBQDdbFttmA3G3oytFKBcsZH8VMdJWBXJKJB` | **Squad Vault ATA** (writable - provides liquidity) |
| **#7**  | `59eNrRrxrZMdqJxS7J3WGaV4MLLog2er14kePiWVjXtY` | **Squad Vault** (signer - rebalancer authority)     |

**Transaction Flow:**

1. **Authority Verification**: Confirms Squad vault has rebalancer permissions
2. **Token Transfer**: Moves 50 tokens from Squad vault ATA to pool ATA
3. **Pool Update**: Updates pool's available liquidity balance
4. **Ready for Operations**: Pool can now fulfill cross-chain transfer requests

> **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 liquidity amount and token addresses
- **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:

## 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**  | `9VnLxEtwJgnGALzhhXJTtRr4GF83z95aCypPiRFGi9d1` | **Pool State PDA** (read-only - validation)         |
| **#2**  | `DzPjdCvEgJq6tyTvQtuh6i8WtPn6gWGmhaRM3DnCvwq9` | **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 `0x563eb47F0D8bE95CAF70ec2b7bB9Cdca6f045715`
- **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**  | `9VnLxEtwJgnGALzhhXJTtRr4GF83z95aCypPiRFGi9d1` | **Pool State PDA** (read-only - authority validation)          |
| **#2**  | `DzPjdCvEgJq6tyTvQtuh6i8WtPn6gWGmhaRM3DnCvwq9` | **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**  | `9VnLxEtwJgnGALzhhXJTtRr4GF83z95aCypPiRFGi9d1` | **Read-only**        | **Pool State PDA** - Main pool configuration account              |
| **#2**  | `DzPjdCvEgJq6tyTvQtuh6i8WtPn6gWGmhaRM3DnCvwq9` | **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**  | `C3a5U5C4Sn8fywXmV4ZX6JAfYoQrEhAqF5daL39ScKSy` | **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 `C3a5U...` with Squad Vault as authority
2. **Core Address Addition**: Adds essential CCIP accounts (programs, PDAs) to the table
3. **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** | `C3a5U5C4Sn8fywXmV4ZX6JAfYoQrEhAqF5daL39ScKSy` | **ALT Address (Self-Reference)**           |
| **1** | `89Jy2ZEz6LcvBPVQgR2YxPYVoF1sLugNRs3havQP8SvF` | **Token Admin Registry PDA**               |
| **2** | `8eqh8wppT9c5rw4ERqNCffvU6cNFJWff9WmkcYtmGiqC` | **Pool Program ID**                        |
| **3** | `9VnLxEtwJgnGALzhhXJTtRr4GF83z95aCypPiRFGi9d1` | **Pool State PDA**                         |
| **4** | `A57bH91QkGuARh37JTN41fd3Vwcmf2bLzVHAVPB8Gaeg` | **Pool Signer's Associated Token Account** |
| **5** | `E8odUv4V4DXy3RWvkNYF7H33X9J56RtsFp4ExVXB86UA` | **Pool Signer PDA**                        |
| **6** | `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`  | **Token Program ID (SPL Token v1)**        |
| **7** | `FVJeMAQSH9dJvVmhe8NHC2DHTEEqT5cgVXTL5CYYmKu1` | **Token Mint**                             |
| **8** | `84grjTssjNyuDsaxJGkpJB8t17Y9sQt1G81R5AQyZ1Rr` | **Fee Quoter Token Config PDA**            |
| **9** | `DPyeT76APQQVQD7EJRVw8Y6gLYjGkC5CdbdHQTQkpoN2` | **Router External Token Pools Signer PDA** |

**Transaction Efficiency Impact:**

- **Before ALT**: Each account = 32 bytes (9 accounts = 288 bytes)
- **After ALT**: Each account = 1 byte index (9 accounts = 9 bytes)
- **Savings**: \~279 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**  | `89Jy2ZEz6LcvBPVQgR2YxPYVoF1sLugNRs3havQP8SvF` | **Token Admin Registry PDA** (writable - pool registration) |
| **#3**  | `FVJeMAQSH9dJvVmhe8NHC2DHTEEqT5cgVXTL5CYYmKu1` | **Token Mint** (read-only - token identification)           |
| **#4**  | `C3a5U5C4Sn8fywXmV4ZX6JAfYoQrEhAqF5daL39ScKSy` | **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 `C3a5U...` 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

##### 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**: `4w81mpUozjJsEvHrkukCejbA9byMjkHacwtqM5cJD19XQu8MvXzoJ4YTqqkoEvBfP7HPvdivMA3Q1MePA16PdCXM`
- **CCIP Message ID**: `0xd92433fea1fab2b9b2efa8d6091df0b5156bb159c883b94dada725539e5edace`

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

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

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/4w81mpUozjJsEvHrkukCejbA9byMjkHacwtqM5cJD19XQu8MvXzoJ4YTqqkoEvBfP7HPvdivMA3Q1MePA16PdCXM?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**: `0xcacca1de44800d4e88544597b1b9f8190db93ae2f2144bb3b92aafd73b626c3d`
- **CCIP Message ID**: `0xb8327a54fcf042f6fa9ca236372ea68835204802ca13ebfc34c7f839631ee567`

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

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

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/0xcacca1de44800d4e88544597b1b9f8190db93ae2f2144bb3b92aafd73b626c3d
```