Supported Tokens

​

Overview

​

Token Support Configuration

​

Environment-Based Configuration

// Localnet: Allow all SPL tokens (for testing)
#[cfg(any(feature = "localnet", test))]
pub const ALLOW_ALL_SPL_TOKENS: bool = true;

// Production/Devnet: Use allowlist
#[cfg(not(any(feature = "localnet", test)))]
pub const ALLOW_ALL_SPL_TOKENS: bool = false;

​

Token Allowlist

​

Supported SPL Tokens

​

Mainnet Tokens

​

Devnet Tokens

​

Native SOL Support

pub const SOL_ADDRESS: Pubkey = pubkey!("11111111111111111111111111111112");

​

Token Validation

​

During Tree Initialization

require!(
    ALLOW_ALL_SPL_TOKENS || ALLOWED_TOKENS.contains(&ctx.accounts.mint.key()),
    ErrorCode::InvalidMintAddress
);

​

During Transactions

require!(
    ALLOW_ALL_SPL_TOKENS || ALLOWED_TOKENS.contains(&ext_data.mint_address),
    ErrorCode::InvalidMintAddress
);

“Invalid mint address: mint address is not allowed”

​

Adding Support for New Tokens

​

Mainnet Token Addition

1. Update the ALLOWED_TOKENS constant in lib.rs:

#[cfg(not(feature = "devnet"))]
pub const ALLOWED_TOKENS: &[Pubkey] = &[
    pubkey!("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"), // USDC
    // ... existing tokens ...
    pubkey!("YOUR_NEW_TOKEN_MINT_ADDRESS"), // New Token
];

2. Initialize a tree for the token using the initialize_tree_account_for_spl_token instruction
3. Deploy the updated program with the new token list

​

Devnet Token Addition

#[cfg(feature = "devnet")]
pub const ALLOWED_TOKENS: &[Pubkey] = &[
    pubkey!("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"), // USDC
    // ... existing tokens ...
    pubkey!("YOUR_NEW_TOKEN_MINT_ADDRESS"), // New Token
];

​

Initializing Token Trees

​

Function Signature

pub fn initialize_tree_account_for_spl_token(
    ctx: Context<InitializeTreeAccountForSplToken>,
    max_deposit_amount: u64
) -> Result<()>

​

Requirements

• Only the protocol authority can initialize token trees
• Token mint must be in ALLOWED_TOKENS (unless ALLOW_ALL_SPL_TOKENS is enabled)
• Each token gets a separate Merkle tree with seed: [b"merkle_tree", mint.key().as_ref()]

​

Tree Properties

• Height: 26 (supports 67,108,864 commitments)
• Root History Size: 100 previous roots
• Deposit Limit: Configurable per token (specified during initialization)

​

Token Account Management

​

Associated Token Accounts (ATAs)

1. Tree ATA: The protocol’s token account that holds deposited tokens
   • Authority: global_config PDA
   • Created automatically on first deposit
2. Fee Recipient ATA: Where protocol fees are collected
   • Must exist for supported tokens
   • Validated during transactions

​

Token Transfer Operations

​

Deposits

token::transfer(
    CpiContext::new(
        ctx.accounts.token_program.to_account_info(),
        SplTransfer {
            from: ctx.accounts.signer_token_account.to_account_info(),
            to: ctx.accounts.tree_ata.to_account_info(),
            authority: ctx.accounts.signer.to_account_info(),
        },
    ),
    ext_amount as u64,
)?;

​

Withdrawals

token::transfer(
    CpiContext::new_with_signer(
        ctx.accounts.token_program.to_account_info(),
        SplTransfer {
            from: ctx.accounts.tree_ata.to_account_info(),
            to: ctx.accounts.recipient_token_account.to_account_info(),
            authority: ctx.accounts.global_config.to_account_info(),
        },
        signer_seeds,
    ),
    ext_amount_abs,
)?;

​

Testing on Localnet

#[cfg(any(feature = "localnet", test))]
pub const ALLOW_ALL_SPL_TOKENS: bool = true;

​

Token Metadata

​

USDC (USD Coin)

• Decimals: 6
• Use Case: Stablecoin pegged to US Dollar
• Privacy Use: Private payments, remittances

​

USDT (Tether USD)

• Decimals: 6
• Use Case: Stablecoin pegged to US Dollar
• Privacy Use: Private transfers, trading

​

ORE (Ore)

• Use Case: Mining token on Solana
• Privacy Use: Private mining rewards, transfers

​

ZEC (Zcash)

• Use Case: Privacy-focused cryptocurrency bridge
• Privacy Use: Cross-chain privacy transactions

​

stORE (Staked Ore)

• Use Case: Liquid staking derivative of ORE
• Privacy Use: Private staking positions

​

jlUSDC (Jupiter USDC)

• Use Case: Jupiter DEX liquidity token
• Privacy Use: Private liquidity provision

​

jlWSOL (Jupiter Wrapped SOL)

• Use Case: Jupiter DEX liquidity token
• Privacy Use: Private SOL positions

​

Security Considerations

​

Token Validation

1. Allowlist enforcement: Only approved tokens can be used in production
2. Mint verification: Every transaction validates the token mint address
3. Authority control: Only protocol authority can add new token trees

​

Account Validation

// Signer owns the token account
require!(
    ctx.accounts.signer_token_account.owner == ctx.accounts.signer.key(),
    ErrorCode::InvalidTokenAccount
);

// Token account matches the expected mint
require!(
    ctx.accounts.signer_token_account.mint == ctx.accounts.mint.key(),
    ErrorCode::InvalidTokenAccountMintAddress
);

​

Error Codes

​

InvalidMintAddress

“Invalid mint address: mint address is not allowed”

​

InvalidTokenAccount

“Invalid token account: account is not owned by the token program”

​

InvalidTokenAccountMintAddress

“Invalid token account mint address”

​

Code References

• Mainnet token list: lib.rs:52-60
• Devnet token list: lib.rs:41-49
• Token validation (initialization): lib.rs:161-163
• Token validation (transactions): lib.rs:395-397
• SOL address constant: utils.rs:14
• Tree initialization: lib.rs:151-185
• SPL token transactions: lib.rs:371-520