Create Associated Light Token Accounts

Client and program guide to create associated light-token accounts. Includes step-by-step implementation and full code examples.

---

1. Associated light-token accounts are Solana accounts that hold token balances of light, SPL, or Token 2022 mints.
2. The address for light-ATAs is deterministically derived with the owner’s address, compressed token program ID, and mint address.
3. Associated light-token accounts implement a default rent config:
   1. At account creation, you pay ~17,208 lamports for 24h of rent
      and compression incentive (the rent-exemption is sponsored by the protocol)
   2. Transfers keep the account funded with rent for 3h via top-ups. The transaction payer tops up 776 lamports when the account’s rent is below 3h.

Light Rent Config Explained

1. The rent-exemption for light account creation is sponsored by the Light Token Program.
2. Transaction payer’s pay rent per rent-epoch (388 lamports for 1.5h)
   to keep accounts “active”.
3. “Inactive” accounts (rent below one epoch) get automatically compressed.
4. The account’s state is cryptographically preserved and will be loaded into hot account state in-flight, when the account is used again.
   

The hot state fee is paid for by the transaction payer when writing to the respective account.

Get Started

TypeScript Client

The createAtaInterface function creates an associated light-token account in a single call.

Compare to SPL:

Find the source code here.

1. Create Associated Token Account

   Installation

   npm

   Install packages in your working directory:

   npm install @lightprotocol/stateless.js@alpha \
               @lightprotocol/compressed-token@alpha
   

   Install the CLI globally:

   npm install -g @lightprotocol/zk-compression-cli@alpha
   

   yarn

   Install packages in your working directory:

   yarn add @lightprotocol/stateless.js@alpha \
            @lightprotocol/compressed-token@alpha
   

   Install the CLI globally:

   yarn global add @lightprotocol/zk-compression-cli@alpha
   

   pnpm

   Install packages in your working directory:

   pnpm add @lightprotocol/stateless.js@alpha \
            @lightprotocol/compressed-token@alpha
   

   Install the CLI globally:

   pnpm add -g @lightprotocol/zk-compression-cli@alpha
   

   Localnet

   # start local test-validator in a separate terminal
   light test-validator
   

   In the code examples, use createRpc() without arguments for localnet.

   Devnet

   Get an API key from Helius and add to .env:

   .env

   API_KEY=<your-helius-api-key>
   

   In the code examples, use createRpc(RPC_URL) with the devnet URL.

   Action

   import "dotenv/config";
   import { Keypair } from "@solana/web3.js";
   import { createRpc } from "@lightprotocol/stateless.js";
   import {
       createMintInterface,
       createAtaInterface,
   } from "@lightprotocol/compressed-token";
   import { homedir } from "os";
   import { readFileSync } from "fs";
   
   // devnet:
   const RPC_URL = `https://devnet.helius-rpc.com?api-key=${process.env.API_KEY!}`;
   // localnet:
   // const RPC_URL = undefined;
   const payer = Keypair.fromSecretKey(
       new Uint8Array(
           JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8"))
       )
   );
   
   (async function () {
       // devnet:
       const rpc = createRpc(RPC_URL);
       // localnet:
       // const rpc = createRpc();
   
       const { mint } = await createMintInterface(rpc, payer, payer, null, 9);
   
       const owner = Keypair.generate();
       const ata = await createAtaInterface(rpc, payer, mint, owner.publicKey);
   
       console.log("ATA:", ata.toBase58());
   })();
   

   Instruction

   import "dotenv/config";
   import {
       Keypair,
       Transaction,
       sendAndConfirmTransaction,
   } from "@solana/web3.js";
   import { createRpc, CTOKEN_PROGRAM_ID } from "@lightprotocol/stateless.js";
   import {
       createMintInterface,
       createAssociatedTokenAccountInterfaceInstruction,
       getAssociatedTokenAddressInterface,
   } from "@lightprotocol/compressed-token";
   import { homedir } from "os";
   import { readFileSync } from "fs";
   
   // devnet:
   const RPC_URL = `https://devnet.helius-rpc.com?api-key=${process.env.API_KEY!}`;
   const rpc = createRpc(RPC_URL);
   // localnet:
   // const rpc = createRpc();
   
   const payer = Keypair.fromSecretKey(
       new Uint8Array(
           JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8"))
       )
   );
   
   (async function () {
       const { mint } = await createMintInterface(rpc, payer, payer, null, 9);
   
       const owner = Keypair.generate();
       const associatedToken = getAssociatedTokenAddressInterface(
           mint,
           owner.publicKey
       );
   
       const ix = createAssociatedTokenAccountInterfaceInstruction(
           payer.publicKey,
           associatedToken,
           owner.publicKey,
           mint,
           CTOKEN_PROGRAM_ID
       );
   
       const tx = new Transaction().add(ix);
       const signature = await sendAndConfirmTransaction(rpc, tx, [payer]);
   
       console.log("ATA:", associatedToken.toBase58());
       console.log("Tx:", signature);
   })();
   

Rust Client

1. The example creates a test light-mint. You can use existing light-mints, SPL or Token 2022 mints as well.
2. Derive the address from mint and owner pubkey.
3. Build the instruction with CreateAssociatedCTokenAccount. It automatically includes the default rent config:

use light_ctoken_sdk::ctoken::CreateAssociatedCTokenAccount;

let instruction = CreateAssociatedCTokenAccount::new(
    payer.pubkey(),
    owner,
    mint,
)
.instruction()?;

4. Send transaction & verify light-ATA creation with get_account.

1. Prerequisites

   Dependencies

   Cargo.toml

   [dependencies]
   light-compressed-token-sdk = "0.1"
   light-client = "0.1"
   light-ctoken-types = "0.1"
   solana-sdk = "2.2"
   borsh = "0.10"
   tokio = { version = "1.36", features = ["full"] }
   
   [dev-dependencies]
   light-program-test = "0.1"  # For in-memory tests with LiteSVM
   

   Developer Environment

   In-Memory (LightProgramTest)

   Test with Lite-SVM (…)

   # Initialize project
   cargo init my-light-project
   cd my-light-project
   
   # Run tests
   cargo test
   

   use light_program_test::{LightProgramTest, ProgramTestConfig};
   use solana_sdk::signer::Signer;
   
   #[tokio::test]
   async fn test_example() {
       // In-memory test environment 
       let mut rpc = LightProgramTest::new(ProgramTestConfig::default())
           .await
           .unwrap();
   
       let payer = rpc.get_payer().insecure_clone();
       println!("Payer: {}", payer.pubkey());
   }
   

   Localnet (LightClient)

   Connects to a local test validator.

   npm

   npm install -g @lightprotocol/zk-compression-cli@alpha
   

   yarn

   yarn global add @lightprotocol/zk-compression-cli@alpha
   

   pnpm

   pnpm add -g @lightprotocol/zk-compression-cli@alpha
   

   # Initialize project
   cargo init my-light-project
   cd my-light-project
   
   # Start local test validator (in separate terminal)
   light test-validator
   

   use light_client::rpc::{LightClient, LightClientConfig, Rpc};
   
   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       // Connects to http://localhost:8899
       let rpc = LightClient::new(LightClientConfig::local()).await?;
   
       let slot = rpc.get_slot().await?;
       println!("Current slot: {}", slot);
   
       Ok(())
   }
   

   Devnet (LightClient)

   Replace <your-api-key> with your actual API key. Get your API key here.

   use light_client::rpc::{LightClient, LightClientConfig, Rpc};
   
   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       let rpc_url = "https://devnet.helius-rpc.com?api-key=<your_api_key>";
       let rpc = LightClient::new(
           LightClientConfig::new(rpc_url.to_string(), None, None)
       ).await?;
   
       println!("Connected to Devnet");
       Ok(())
   }
   
2. Create ATA

   use borsh::BorshDeserialize;
   use light_client::indexer::{AddressWithTree, Indexer};
   use light_client::rpc::{LightClient, LightClientConfig, Rpc};
   use light_ctoken_sdk::ctoken::{
       derive_ctoken_ata, CreateAssociatedCTokenAccount, CreateCMint,
       CreateCMintParams,
   };
   use light_ctoken_interface::state::CToken;
   use serde_json;
   use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer};
   use std::convert::TryFrom;
   use std::env;
   use std::fs;
   
   #[tokio::test(flavor = "multi_thread")]
   async fn test_create_associated_token_account() {
       dotenvy::dotenv().ok();
   
       let keypair_path = env::var("KEYPAIR_PATH")
           .unwrap_or_else(|_| format!("{}/.config/solana/id.json", env::var("HOME").unwrap()));
       let payer = load_keypair(&keypair_path).expect("Failed to load keypair");
   
       let api_key = env::var("api_key")
           .expect("api_key environment variable must be set");
   
       let config = LightClientConfig::devnet(
           Some("https://devnet.helius-rpc.com".to_string()),
           Some(api_key),
       );
       let mut rpc = LightClient::new_with_retry(config, None)
           .await
           .expect("Failed to initialize LightClient");
   
       // Step 1: Create compressed mint (prerequisite)
       let (mint, _compression_address) = create_compressed_mint(&mut rpc, &payer, 9).await;
   
       // Step 2: Define owner and derive ATA address
       let owner = payer.pubkey();
       let (ata_address, _bump) = derive_ctoken_ata(&owner, &mint);
   
       // Step 3: Build instruction using SDK builder
       let instruction = CreateAssociatedCTokenAccount::new(
           payer.pubkey(),
           owner,
           mint,
       )
       .instruction()
       .unwrap();
   
       // Step 4: Send transaction (only payer signs, no account keypair needed)
       rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
           .await
           .unwrap();
   
       // Step 5: Verify light-ATA creation
       let account_data = rpc.get_account(ata_address).await.unwrap().unwrap();
       let ctoken_state = CToken::deserialize(&mut &account_data.data[..]).unwrap();
   
       assert_eq!(ctoken_state.mint, mint.to_bytes(), "Mint should match");
       assert_eq!(ctoken_state.owner, owner.to_bytes(), "Owner should match");
       assert_eq!(ctoken_state.amount, 0, "Initial amount should be 0");
   }
   
   pub async fn create_compressed_mint<R: Rpc + Indexer>(
       rpc: &mut R,
       payer: &Keypair,
       decimals: u8,
   ) -> (Pubkey, [u8; 32]) {
       let mint_signer = Keypair::new();
       let address_tree = rpc.get_address_tree_v2();
   
       let _ = rpc.get_latest_active_state_trees().await;
       let output_pubkey = match rpc
           .get_random_state_tree_info()
           .ok()
           .or_else(|| rpc.get_random_state_tree_info_v1().ok())
       {
           Some(info) => info
               .get_output_pubkey()
               .expect("Invalid state tree type for output"),
           None => {
               let queues = rpc
                   .indexer_mut()
                   .expect("IndexerNotInitialized")
                   .get_queue_info(None)
                   .await
                   .expect("Failed to fetch queue info")
                   .value
                   .queues;
               queues
                   .get(0)
                   .map(|q| q.queue)
                   .expect("NoStateTreesAvailable")
           }
       };
   
       // Derive compression address
       let compression_address = light_ctoken_sdk::ctoken::derive_cmint_compressed_address(
           &mint_signer.pubkey(),
           &address_tree.tree,
       );
   
       let mint_pda =
           light_ctoken_sdk::ctoken::find_cmint_address(&mint_signer.pubkey()).0;
   
       // Get validity proof for the address
       let rpc_result = rpc
           .get_validity_proof(
               vec![],
               vec![AddressWithTree {
                   address: compression_address,
                   tree: address_tree.tree,
               }],
               None,
           )
           .await
           .unwrap()
           .value;
   
       // Build params
       let params = CreateCMintParams {
           decimals,
           address_merkle_tree_root_index: rpc_result.addresses[0].root_index,
           mint_authority: payer.pubkey(),
           proof: rpc_result.proof.0.unwrap(),
           compression_address,
           mint: mint_pda,
           freeze_authority: None,
           extensions: None,
       };
   
       // Create instruction
       let create_cmint = CreateCMint::new(
           params,
           mint_signer.pubkey(),
           payer.pubkey(),
           address_tree.tree,
           output_pubkey,
       );
       let instruction = create_cmint.instruction().unwrap();
   
       // Send transaction
       rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer, &mint_signer])
           .await
           .unwrap();
   
       (mint_pda, compression_address)
   }
   
   fn load_keypair(path: &str) -> Result<Keypair, Box<dyn std::error::Error>> {
       let path = if path.starts_with("~") {
           path.replace("~", &env::var("HOME").unwrap_or_default())
       } else {
           path.to_string()
       };
       let file = fs::read_to_string(&path)?;
       let bytes: Vec<u8> = serde_json::from_str(&file)?;
       Ok(Keypair::try_from(&bytes[..])?)
   }
   

Program Guide

Find a full code example at the end.

1. Define Rent Config Accounts

   use light_compressed_token_sdk::ctoken::CompressibleParamsInfos;
   
   let compressible_params = CompressibleParamsInfos::new(
       compressible_config.clone(),
       rent_sponsor.clone(),
       system_program.clone(),
   );
   

   	Protocol PDA that stores account rent config.
   	light token program PDA that fronts rent exemption at creation. - Claims rent when account compresses.
   	Solana System Program to create the on-chain account.

2. Build Account Infos and CPI the Compressed Token Program

   1. Pass the required accounts that include the rent config.
   2. Use invoke or invoke_signed, when a CPI requires a PDA signer.
      The light-ATA address is derived from [owner, ctoken_program_id, mint]. Unlike light-token accounts, owner and mint are passed as accounts, not in instruction data.

   invoke (External signer)

   use light_ctoken_sdk::ctoken::CreateAssociatedCTokenAccountCpi;
   
   CreateAssociatedCTokenAccountCpi {
       owner: owner.clone(),
       mint: mint.clone(),
       payer: payer.clone(),
       associated_token_account: associated_token_account.clone(),
       system_program: system_program.clone(),
       bump: data.bump,
       compressible: Some(compressible_params),
       idempotent: false,
   }
   .invoke()?;
   

   invoke_signed (PDA is signer)

   use light_ctoken_sdk::ctoken::CreateAssociatedCTokenAccountCpi;
   
   let signer_seeds: &[&[u8]] = &[ATA_SEED, &[bump]];
   CreateAssociatedCTokenAccountCpi {
       owner: owner.clone(),
       mint: mint.clone(),
       payer: payer.clone(),
       associated_token_account: associated_token_account.clone(),
       system_program: system_program.clone(),
       bump: data.bump,
       compressible: Some(compressible_params),
       idempotent: false,
   }
   .invoke_signed(&[signer_seeds])?;
   

   Owner	-	The wallet that will own this light-ATA. Used to derive the light-ATA address deterministically.
   Mint	-	The SPL or light-mint token mint. Used to derive the light-ATA address deterministically.
   Payer	signer, mutable	Pays initial rent per epoch, transaction fee and compression incentive. Does NOT pay rent exemption (fronted by rent_sponsor).
   light-ATA Account	mutable	The light-ATA being created. Address is derived from [owner, ctoken_program_id, mint].
   System Program	-	Solana System Program. Required for CPI to create the on-chain account.
   Bump	u8	The PDA bump seed for the light-ATA address derivation.
   Idempotent	bool	When true, silently succeeds if account already exists. When false, fails if account already exists.

Full Code Example

Find the source code here.

use borsh::{BorshDeserialize, BorshSerialize};
use light_ctoken_sdk::ctoken::{CompressibleParamsCpi, CreateAssociatedCTokenAccountCpi};
use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};

use crate::{ATA_SEED, ID};

/// Instruction data for create ATA V2 (owner/mint as accounts)
#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct CreateAta2Data {
    pub bump: u8,
    pub pre_pay_num_epochs: u8,
    pub lamports_per_write: u32,
}

/// Handler for creating ATA using V2 variant (invoke)
///
/// Account order:
/// - accounts[0]: owner (readonly)
/// - accounts[1]: mint (readonly)
/// - accounts[2]: payer (signer, writable)
/// - accounts[3]: associated_token_account (writable)
/// - accounts[4]: system_program
/// - accounts[5]: compressible_config
/// - accounts[6]: rent_sponsor (writable)
pub fn process_create_ata2_invoke(
    accounts: &[AccountInfo],
    data: CreateAta2Data,
) -> Result<(), ProgramError> {
    if accounts.len() < 7 {
        return Err(ProgramError::NotEnoughAccountKeys);
    }

    let compressible_params = CompressibleParamsCpi::new(
        accounts[5].clone(),
        accounts[6].clone(),
        accounts[4].clone(),
    );

    CreateAssociatedCTokenAccountCpi {
        owner: accounts[0].clone(),
        mint: accounts[1].clone(),
        payer: accounts[2].clone(),
        associated_token_account: accounts[3].clone(),
        system_program: accounts[4].clone(),
        bump: data.bump,
        compressible: Some(compressible_params),
        idempotent: false,
    }
    .invoke()?;

    Ok(())
}

/// Handler for creating ATA using V2 variant with PDA ownership (invoke_signed)
///
/// Account order:
/// - accounts[0]: owner (PDA, readonly)
/// - accounts[1]: mint (readonly)
/// - accounts[2]: payer (PDA, writable, not signer - program signs)
/// - accounts[3]: associated_token_account (writable)
/// - accounts[4]: system_program
/// - accounts[5]: compressible_config
/// - accounts[6]: rent_sponsor (writable)
pub fn process_create_ata2_invoke_signed(
    accounts: &[AccountInfo],
    data: CreateAta2Data,
) -> Result<(), ProgramError> {
    if accounts.len() < 7 {
        return Err(ProgramError::NotEnoughAccountKeys);
    }

    // Derive the PDA that will act as payer
    let (pda, bump) = Pubkey::find_program_address(&[ATA_SEED], &ID);

    // Verify the payer is the PDA
    if &pda != accounts[2].key {
        return Err(ProgramError::InvalidSeeds);
    }

    let compressible_params = CompressibleParamsCpi::new(
        accounts[5].clone(),
        accounts[6].clone(),
        accounts[4].clone(),
    );

    let signer_seeds: &[&[u8]] = &[ATA_SEED, &[bump]];
    CreateAssociatedCTokenAccountCpi {
        owner: accounts[0].clone(),
        mint: accounts[1].clone(),
        payer: accounts[2].clone(), // PDA
        associated_token_account: accounts[3].clone(),
        system_program: accounts[4].clone(),
        bump: data.bump,
        compressible: Some(compressible_params),
        idempotent: false,
    }
    .invoke_signed(&[signer_seeds])?;

    Ok(())
}

Next Steps

Learn how to mint light-tokens