Token Transfer

SPL token operations and delegation in Ephemeral Rollups

Token Transfer

The Token Transfer example demonstrates how to work with custom token accounts in Ephemeral Rollups. While this example uses a simple balance account for clarity, the same patterns apply to SPL tokens, allowing you to build high-frequency token operations with ultra-low latency.

Overview

This example shows:

• Creating and delegating balance accounts
• Transferring tokens between accounts in ERs
• Configurable delegation parameters
• Committing and undelegating accounts

While this example uses a simple Balance account, the same delegation patterns work with SPL Token Accounts for real token transfers.

How It Works

Program Annotations

The program uses the #[ephemeral] macro to enable ER support:

programs/dummy-transfer/src/lib.rs

use ephemeral_rollups_sdk::anchor::{commit, delegate, ephemeral};
use ephemeral_rollups_sdk::cpi::DelegateConfig;
use ephemeral_rollups_sdk::ephem::commit_and_undelegate_accounts;

#[ephemeral]
#[program]
pub mod dummy_transfer {
    use super::*;
    // ... program code
}

Delegation Configuration

Commit Frequency

DelegateConfig {
    commit_frequency_ms: 30000, // Commit every 30 seconds
    validator: None,
}

Set commit_frequency_ms based on your use case:

• Gaming: 10-30 seconds for responsive state updates
• Trading: 5-10 seconds for more frequent commits
• High-value operations: Lower values for more frequent base layer syncs

Complete Flow Example

import { Program } from "@coral-xyz/anchor";
import { PublicKey } from "@solana/web3.js";

// 1. Initialize balance account on base layer
const initTx = await program.methods
  .initialize()
  .accounts({
    user: wallet.publicKey,
  })
  .rpc();

// 2. Delegate to ER with custom config
const delegateTx = await program.methods
  .delegate({
    commitFrequencyMs: 30000,
    validator: null,
  })
  .accounts({
    payer: wallet.publicKey,
  })
  .rpc();

// 3. Perform rapid transfers in ER
for (let i = 0; i < 100; i++) {
  await program.methods
    .transfer(new BN(1))
    .accounts({
      payer: wallet.publicKey,
      receiver: recipientPublicKey,
    })
    .rpc(); // Ultra-low latency in ER!
}

// 4. Undelegate and commit final state
const undelegateTx = await program.methods
  .undelegate()
  .accounts({
    payer: wallet.publicKey,
  })
  .rpc();

SPL Token Integration

To use this pattern with real SPL tokens:

What Makes This Advanced?

This example demonstrates:

1. Custom Delegation Parameters: Fine-grained control over commit frequency and validator selection
2. Multi-Account Operations: Transferring between multiple delegated accounts
3. Init-If-Needed Pattern: Automatically creating receiver accounts during transfers
4. Error Handling: Proper balance validation with custom errors
5. PDA Management: Using PDAs for user-specific balance accounts

Use Cases

Gaming

• In-game currency transfers
• Rapid item trading between players
• Reward distributions
• Marketplace transactions

DeFi

• High-frequency trading
• Liquidity pool interactions
• Automated market makers
• Flash loan operations

Social

• Tipping and microtransactions
• Content creator payments
• Social token transfers
• Community rewards

Performance Benefits

Compared to base layer token transfers:

• Latency: ~400ms → ~10ms (40x faster)
• Cost: ~0.000005 SOL → negligible in ER
• Throughput: Thousands of transfers per second
• Batching: Execute 100s of transfers before committing

Testing Locally

Testing on Devnet

To run tests on devnet:

anchor test --skip-local-validator --skip-build --skip-deploy

Make sure you have devnet SOL in your wallet before running devnet tests.

Security Considerations

Important:

• Always validate account ownership before transfers
• Check sufficient balance before debiting
• Use proper PDA derivation for user accounts
• Set appropriate commit frequencies for your use case
• Monitor delegated account states

Adapting for Real Tokens

The key differences when using SPL tokens:

1. Account Type: TokenAccount instead of custom Balance
2. Authority: Token account authority, not PDA seeds
3. Transfer Logic: Use SPL token CPI instead of direct balance updates
4. Mint Validation: Ensure all accounts use the same mint

Example SPL transfer in ER:

use anchor_spl::token;

pub fn transfer_tokens(ctx: Context<TransferTokens>, amount: u64) -> Result<()> {
    token::transfer(
        CpiContext::new(
            ctx.accounts.token_program.to_account_info(),
            token::Transfer {
                from: ctx.accounts.from.to_account_info(),
                to: ctx.accounts.to.to_account_info(),
                authority: ctx.accounts.authority.to_account_info(),
            },
        ),
        amount,
    )?;
    Ok()
}

This transfer executes in the ER with the same ultra-low latency as the balance example!

Next Steps

• Explore Session Keys for gasless token transfers
• Learn about Magic Actions to trigger base layer logic on commit
• Check out SPL Token documentation for working with real tokens
• Review the full source code