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 can hold token balances of light, SPL, or Token 2022 mints.
2. Light-ATAs are on-chain accounts like SPL ATA’s, but the light token program sponsors the rent-exemption cost for you.

Light Rent Config Explained

1. A rent sponsor PDA by Light Protocol pays the rent-exemption cost for the account.
2. Transaction fee payers bump a virtual rent balance when writing to the account, which keeps the account “hot”.
3. “Cold” accounts virtual rent balance below threshold (eg 24h without write bump) get auto-compressed.
4. The cold account’s state is cryptographically preserved on the Solana ledger. Users can load a cold account into hot state in-flight when using the account again.

Agent skill

Install or view dedicated agent skills.

npx skills add Lightprotocol/skills

Install orchestrator agent skill or view skill.md:

npx skills add https://zkcompression.com

TypeScript Client

The createAtaInterface function creates an associated Light Token account in a single call.

Compare to SPL:

Find the source code here.

Guide

1. Create Associated Token Account

   Installation

   npm

   Install packages in your working directory:

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

   Install the CLI globally:

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

   yarn

   Install packages in your working directory:

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

   Install the CLI globally:

   yarn global add @lightprotocol/zk-compression-cli
   

   pnpm

   Install packages in your working directory:

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

   Install the CLI globally:

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

   SDK 2.0 (token-interface)

   Install packages in your working directory:

   # npm
   npm install @lightprotocol/stateless.js@^0.23.0 \
               @lightprotocol/token-interface@^0.1.2
   
   # yarn
   yarn add @lightprotocol/stateless.js@^0.23.0 \
            @lightprotocol/token-interface@^0.1.2
   
   # pnpm
   pnpm add @lightprotocol/stateless.js@^0.23.0 \
            @lightprotocol/token-interface@^0.1.2
   

   Install the CLI globally:

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

   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!}`;
   // 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 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, LIGHT_TOKEN_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,
           LIGHT_TOKEN_PROGRAM_ID
       );
   
       const tx = new Transaction().add(ix);
       const signature = await sendAndConfirmTransaction(rpc, tx, [payer]);
   
       console.log("ATA:", associatedToken.toBase58());
       console.log("Tx:", signature);
   })();
   

   SDK 2.0 (token-interface)

   import { Keypair, Transaction, sendAndConfirmTransaction } from "@solana/web3.js";
   import { createRpc, LIGHT_TOKEN_PROGRAM_ID } from "@lightprotocol/stateless.js";
   import { createAtaInstruction, getAtaAddress } from "@lightprotocol/token-interface";
   
   const rpc = createRpc();
   const payer = Keypair.fromSecretKey(/* ... */);
   
   const mint = /* existing mint public key */;
   const owner = Keypair.generate();
   const associatedToken = getAtaAddress({ mint, owner: owner.publicKey });
   
   const ix = createAtaInstruction({
     payer: payer.publicKey,
     owner: owner.publicKey,
     mint,
     programId: LIGHT_TOKEN_PROGRAM_ID,
   });
   
   const tx = new Transaction().add(ix);
   const signature = await sendAndConfirmTransaction(rpc, tx, [payer]);
   console.log("ATA:", associatedToken.toBase58());
   console.log("Tx:", signature);
   

AI Prompt

Create rent-free associated token account

CopiedCopy promptOpen in Cursor

---
description: Create rent-free associated token account
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---

## Create rent-free associated token account

Context:
- Guide: https://zkcompression.com/light-token/cookbook/create-ata
- Skills and resources index: https://zkcompression.com/skill.md
- SPL to Light reference: https://zkcompression.com/api-reference/solana-to-light-comparison
- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js

SPL equivalent: createAssociatedTokenAccount() → Light Token: createAtaInterface()

### 1. Index project
- Grep `@solana/spl-token|Connection|Keypair|createAssociatedTokenAccount|createAtaInterface` across src/
- Glob `**/*.ts` for project structure
- Identify: RPC setup, existing ATA logic, entry point for ATA creation
- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel

### 2. Read references
- WebFetch the guide above — follow the TypeScript Client tab
- WebFetch skill.md — check for a dedicated skill and resources matching this task
- TaskCreate one todo per phase below to track progress

### 3. Clarify intention
- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing)
- AskUserQuestion: does the project already have ATA operations to extend, or is this greenfield?
- Summarize findings and wait for user confirmation before implementing

### 4. Create plan
- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes
- Verify existing connection/signer setup is compatible with the cookbook prerequisites
- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion)
- Present the plan to the user for approval before proceeding

### 5. Implement
- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js`
- Follow the cookbook guide and the approved plan
- Write/Edit to create or modify files
- TaskUpdate to mark each step done

### 6. Verify
- Bash `tsc --noEmit`
- Bash run existing test suite if present
- TaskUpdate to mark complete

### Tools
- mcp__zkcompression__SearchLightProtocol("<query>") for API details
- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "<q>") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work

Rust Client

CreateAssociatedTokenAccount creates an on-chain ATA to store token balances of light, SPL, or Token 2022 mints.

Compare to SPL:

Guide

1. Prerequisites

   Dependencies

   Cargo.toml

   [dependencies]
   light-token = "0.23.0"
   light-client = { version = "0.23.0", features = ["v2"] }
   solana-sdk = "2"
   borsh = "0.10.4"
   tokio = { version = "1", features = ["full"] }
   

   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
   

   yarn

   yarn global add @lightprotocol/zk-compression-cli
   

   pnpm

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

   # 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

   Find the source code here.

   Action

   use light_token_client::actions::{CreateAta, CreateMint};
   use rust_client::setup_rpc_and_payer;
   use solana_sdk::signer::Signer;
   
   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       let (mut rpc, payer) = setup_rpc_and_payer().await;
   
       // Create mint
       let (_signature, mint) = CreateMint {
           decimals: 9,
           freeze_authority: None,
           token_metadata: None,
           seed: None,
       }
       .execute(&mut rpc, &payer, &payer)
       .await?;
   
       // Create associated token account
       let (_signature, associated_token_account) = CreateAta {
           mint,
           owner: payer.pubkey(),
           idempotent: true,
       }
       .execute(&mut rpc, &payer)
       .await?;
   
       println!("Associated token account: {associated_token_account}");
   
       Ok(())
   }
   

   Instruction

   use light_client::rpc::Rpc;
   use light_token::instruction::{get_associated_token_address, CreateAssociatedTokenAccount};
   use rust_client::{setup_spl_mint_context, SplMintContext};
   use solana_sdk::{signature::Keypair, signer::Signer};
   
   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       // You can use Light, SPL, or Token-2022 mints to create a Light associated token account.
       let SplMintContext {
           mut rpc,
           payer,
           mint,
       } = setup_spl_mint_context().await;
   
       let owner = Keypair::new();
   
       let create_associated_token_account_instruction =
           CreateAssociatedTokenAccount::new(payer.pubkey(), owner.pubkey(), mint).instruction()?;
   
       let sig = rpc
           .create_and_send_transaction(&[create_associated_token_account_instruction], &payer.pubkey(), &[&payer])
           .await?;
   
       let associated_token_account = get_associated_token_address(&owner.pubkey(), &mint);
       let data = rpc.get_account(associated_token_account).await?;
       println!("Associated token account: {associated_token_account} exists: {} Tx: {sig}", data.is_some());
   
       Ok(())
   }
   

AI Prompt

Create rent-free associated token account

CopiedCopy promptOpen in Cursor

---
description: Create rent-free associated token account
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---

## Create rent-free associated token account

Context:
- Guide: https://zkcompression.com/light-token/cookbook/create-ata
- Skills and resources index: https://zkcompression.com/skill.md
- SPL to Light reference: https://zkcompression.com/api-reference/solana-to-light-comparison
- Crates: light-token-client (actions), light-token (instructions), light-client (RPC)

SPL equivalent: spl_associated_token_account::create → Light Token: CreateAta

### 1. Index project
- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|CreateAta|create_associated_token_account` across src/
- Glob `**/*.rs` for project structure
- Identify: RPC setup, existing token ops, entry point for ATA creation
- Check Cargo.toml for existing light-* dependencies and solana-sdk version
- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel

### 2. Read references
- WebFetch the guide above — follow the Rust Client tab
- WebFetch skill.md — check for a dedicated skill and resources matching this task
- TaskCreate one todo per phase below to track progress

### 3. Clarify intention
- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing)
- AskUserQuestion: does the project already have ATA operations to extend, or is this greenfield?
- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)?
- Summarize findings and wait for user confirmation before implementing

### 4. Create plan
- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes
- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair)
- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion)
- Present the plan to the user for approval before proceeding

### 5. Implement
- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2`
- Follow the cookbook guide and the approved plan
- Write/Edit to create or modify files
- TaskUpdate to mark each step done

### 6. Verify
- Bash `cargo check`
- Bash `cargo test` if tests exist
- TaskUpdate to mark complete

### Tools
- mcp__zkcompression__SearchLightProtocol("<query>") for API details
- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "<q>") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work

Program

CPI

Guide

Compare to SPL:

Find a full code example at the end.

1. Build Account Infos and CPI the Light Token Program

   1. Pass ATA accounts and call .rent_free() with rent config accounts.
   2. Use invoke or invoke_signed:
      • When the payer is an external wallet, use invoke.
      • When the payer is a PDA, use invoke_signed with its seeds.

   The light-ATA address is derived from [owner, light_token_program_id, mint]. Unlike Light Token accounts, owner and mint are passed as accounts, not in instruction data.

   invoke (External signer)

   use light_token::instruction::CreateAssociatedAccountCpi;
   
   CreateAssociatedAccountCpi {
       payer: payer.clone(),
       owner: owner.clone(),
       mint: mint.clone(),
       ata: associated_token_account.clone(),
       bump,
   }
   .rent_free(
       compressible_config.clone(),
       rent_sponsor.clone(),
       system_program.clone(),
   )
   .invoke()
   

   invoke_signed (PDA signer)

   use light_token::instruction::CreateAssociatedAccountCpi;
   
   let signer_seeds: &[&[u8]] = &[ATA_SEED, &[authority_bump]];
   
   CreateAssociatedAccountCpi {
       payer: payer.clone(),
       owner: owner.clone(),
       mint: mint.clone(),
       ata: associated_token_account.clone(),
       bump,
   }
   .rent_free(
       compressible_config.clone(),
       rent_sponsor.clone(),
       system_program.clone(),
   )
   .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 (paid by the light token program, rent_sponsor).
   light-ATA Account	mutable	The light-ATA being created. Address is derived from [owner, light_token_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

View the source code and full example with shared test utilities.

lib.rs

#![allow(unexpected_cfgs, deprecated)]

use anchor_lang::prelude::*;
use light_token::instruction::CreateAssociatedAccountCpi;

declare_id!("35MukgdfpNUbPMhTmEk63ECV8vjgpNVFRH9nP8ovMN58");

#[program]
pub mod light_token_anchor_create_associated_token_account {
    use super::*;

    pub fn create_associated_token_account(ctx: Context<CreateAssociatedTokenAccountAccounts>, idempotent: bool) -> Result<()> {
        let cpi = CreateAssociatedAccountCpi {
            payer: ctx.accounts.payer.to_account_info(),
            owner: ctx.accounts.owner.to_account_info(),
            mint: ctx.accounts.mint.to_account_info(),
            ata: ctx.accounts.associated_token_account.to_account_info(),
        };

        if idempotent {
            cpi.idempotent().rent_free(
                ctx.accounts.compressible_config.to_account_info(),
                ctx.accounts.rent_sponsor.to_account_info(),
                ctx.accounts.system_program.to_account_info(),
            )
        } else {
            cpi.rent_free(
                ctx.accounts.compressible_config.to_account_info(),
                ctx.accounts.rent_sponsor.to_account_info(),
                ctx.accounts.system_program.to_account_info(),
            )
        }
        .invoke()?;
        Ok(())
    }
}

#[derive(Accounts)]
pub struct CreateAssociatedTokenAccountAccounts<'info> {
    /// CHECK: Light token program for CPI
    pub light_token_program: AccountInfo<'info>,
    /// CHECK: Validated by light-token CPI
    pub owner: AccountInfo<'info>,
    /// CHECK: Validated by light-token CPI
    pub mint: AccountInfo<'info>,
    #[account(mut)]
    pub payer: Signer<'info>,
    /// CHECK: Validated by light-token CPI
    #[account(mut)]
    pub associated_token_account: AccountInfo<'info>,
    pub system_program: Program<'info, System>,
    /// CHECK: Validated by light-token CPI
    pub compressible_config: AccountInfo<'info>,
    /// CHECK: Validated by light-token CPI
    #[account(mut)]
    pub rent_sponsor: AccountInfo<'info>,
}

use anchor_lang::{InstructionData, ToAccountMetas};
use light_client::indexer::AddressWithTree;
use light_program_test::{Indexer, LightProgramTest, ProgramTestConfig, Rpc};
use light_token_anchor_create_associated_token_account::{accounts, instruction::CreateAssociatedTokenAccount, ID};
use light_token::instruction::{
    CreateMint, CreateMintParams, config_pda, derive_mint_compressed_address, derive_token_ata,
    find_mint_address, rent_sponsor_pda, LIGHT_TOKEN_PROGRAM_ID,
    DEFAULT_RENT_PAYMENT, DEFAULT_WRITE_TOP_UP,
};
use anchor_lang::system_program;
use solana_sdk::{
    instruction::Instruction,
    signature::Keypair,
    signer::Signer,
};

#[tokio::test]
async fn test_create_associated_token_account() {
    let config =
        ProgramTestConfig::new_v2(true, Some(vec![("light_token_anchor_create_associated_token_account", ID)]));
    let mut rpc = LightProgramTest::new(config).await.unwrap();
    let payer = rpc.get_payer().insecure_clone();

    let mint_seed = Keypair::new();
    let mint_authority = payer.pubkey();
    let decimals = 9u8;

    let address_tree = rpc.get_address_tree_v2();
    let output_queue = rpc.get_random_state_tree_info().unwrap().queue;

    let compression_address =
        derive_mint_compressed_address(&mint_seed.pubkey(), &address_tree.tree);
    let (mint_pda, bump) = find_mint_address(&mint_seed.pubkey());

    let rpc_result = rpc
        .get_validity_proof(
            vec![],
            vec![AddressWithTree {
                address: compression_address,
                tree: address_tree.tree,
            }],
            None,
        )
        .await
        .unwrap()
        .value;

    let params = CreateMintParams {
        decimals,
        address_merkle_tree_root_index: rpc_result.addresses[0].root_index,
        mint_authority,
        proof: rpc_result.proof.0.unwrap(),
        compression_address,
        mint: mint_pda,
        bump,
        freeze_authority: None,
        extensions: None,
        rent_payment: DEFAULT_RENT_PAYMENT,
        write_top_up: DEFAULT_WRITE_TOP_UP,
    };

    let create_mint_ix = CreateMint::new(
        params,
        mint_seed.pubkey(),
        payer.pubkey(),
        address_tree.tree,
        output_queue,
    )
    .instruction()
    .unwrap();

    rpc.create_and_send_transaction(&[create_mint_ix], &payer.pubkey(), &[&payer, &mint_seed])
        .await
        .unwrap();

    // You can use light, spl, t22 mints to create a light token associated token account.
    // Derive associated token account address and bump
    let associated_token_account = derive_token_ata(&payer.pubkey(), &mint_pda);

    // Call the anchor program to create associated token account
    let compressible_config = config_pda();
    let rent_sponsor = rent_sponsor_pda();

    let ix = Instruction {
        program_id: ID,
        accounts: accounts::CreateAssociatedTokenAccountAccounts {
            light_token_program: LIGHT_TOKEN_PROGRAM_ID,
            owner: payer.pubkey(),
            mint: mint_pda,
            payer: payer.pubkey(),
            associated_token_account: associated_token_account,
            system_program: system_program::ID,
            compressible_config,
            rent_sponsor,
        }
        .to_account_metas(Some(true)),
        data: CreateAssociatedTokenAccount {
            idempotent: false,
        }
        .data(),
    };

    let sig = rpc.create_and_send_transaction(&[ix], &payer.pubkey(), &[&payer])
        .await
        .unwrap();

    println!("Tx: {}", sig);
}

AI Prompt

Add create-ATA CPI to an Anchor program

CopiedCopy promptOpen in Cursor

---
description: Add create-ATA CPI to an Anchor program
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---

## Add create-ATA CPI to an Anchor program

Context:
- Guide: https://zkcompression.com/light-token/cookbook/create-ata
- Skills and resources index: https://zkcompression.com/skill.md
- SPL to Light reference: https://zkcompression.com/api-reference/solana-to-light-comparison
- Crate: light-token (CreateAssociatedAccountCpi)
- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-associated-token-account

Key CPI struct: `light_token::instruction::CreateAssociatedAccountCpi`

### 1. Index project
- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|ata|associated|owner|mint` across src/
- Glob `**/*.rs` and `**/Cargo.toml` for project structure
- Identify: program ID, existing instructions, account structs, ATA derivation
- Read Cargo.toml — note existing dependencies and framework version
- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel

### 2. Read references
- WebFetch the guide above — review the CPI tab under Program: ATA creation with .rent_free() chain
- WebFetch skill.md — check for a dedicated skill and resources matching this task
- TaskCreate one todo per phase below to track progress

### 3. Clarify intention
- AskUserQuestion: what is the goal? (add create-ATA to existing program, new program from scratch, migrate from SPL create_associated_token_account)
- AskUserQuestion: should the payer be an external signer or a PDA? (determines invoke vs invoke_signed)
- Summarize findings and wait for user confirmation before implementing

### 4. Create plan
- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes
- Follow the guide's step order: Build CreateAssociatedAccountCpi → .rent_free() → .invoke() or .invoke_signed()
- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion)
- Present the plan to the user for approval before proceeding

### 5. Implement
- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31`
- Follow the guide and the approved plan
- Write/Edit to create or modify files
- TaskUpdate to mark each step done

### 6. Verify
- Bash `anchor build`
- Bash `anchor test` if tests exist
- TaskUpdate to mark complete

### Tools
- mcp__zkcompression__SearchLightProtocol("<query>") for API details
- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "<q>") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work

Anchor Macros

Guide

Compare to SPL:

Find a full code example at the end.

1. Dependencies

   [dependencies]
   light-sdk = { version = "0.23.0", features = ["anchor", "v2", "cpi-context"] }
   light-sdk-macros = "0.23.0"
   light-compressible = "0.6.0"
   anchor-lang = "0.31"
   
2. Program

   Add #[light_program] above #[program]:

   use light_sdk_macros::light_program;
   
   #[light_program]
   #[program]
   pub mod light_token_macro_create_ata {
       use super::*;
   
       pub fn create_ata<'info>(
           ctx: Context<'_, '_, '_, 'info, CreateAta<'info>>,
           params: CreateAtaParams,
       ) -> Result<()> {
           Ok(())
       }
   }
   
3. Accounts struct

   Derive LightAccounts on your Accounts struct and add #[light_account(...)] next to #[account(...)].

   /// CHECK: Validated by light-token CPI
   #[account(mut)]
   #[light_account(
       init,
       associated_token::authority = ata_owner,
       associated_token::mint = ata_mint,
       associated_token::bump = params.ata_bump
   )]
   pub ata: UncheckedAccount<'info>,
   

Full code example

View the source code and full example with shared test utilities.

lib.rs

#![allow(deprecated)]

use anchor_lang::prelude::*;
use light_account::{
    derive_light_cpi_signer, light_program, CreateAccountsProof, CpiSigner, LightAccounts,
    LIGHT_TOKEN_PROGRAM_ID,
};
use light_token::instruction::{LIGHT_TOKEN_CONFIG, LIGHT_TOKEN_RENT_SPONSOR};

declare_id!("CLsn9MTFv97oMTsujRoQAw1u2rSm2HnKtGuWUbbc8Jfn");

pub const LIGHT_CPI_SIGNER: CpiSigner =
    derive_light_cpi_signer!("CLsn9MTFv97oMTsujRoQAw1u2rSm2HnKtGuWUbbc8Jfn");

#[light_program]
#[program]
pub mod light_token_macro_create_associated_token_account {
    use super::*;

    #[allow(unused_variables)]
    pub fn create_associated_token_account<'info>(
        ctx: Context<'_, '_, '_, 'info, CreateAssociatedTokenAccount<'info>>,
        params: CreateAssociatedTokenAccountParams,
    ) -> Result<()> {
        Ok(())
    }
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct CreateAssociatedTokenAccountParams {
    pub create_accounts_proof: CreateAccountsProof,
}

#[derive(Accounts, LightAccounts)]
#[instruction(params: CreateAssociatedTokenAccountParams)]
pub struct CreateAssociatedTokenAccount<'info> {
    #[account(mut)]
    pub fee_payer: Signer<'info>,

    /// CHECK: Token mint for the associated token account
    pub associated_token_account_mint: AccountInfo<'info>,

    /// CHECK: Owner of the associated token account
    pub associated_token_account_owner: AccountInfo<'info>,

    /// CHECK: Validated by light_account macro
    #[account(mut)]
    #[light_account(init, associated_token::authority = associated_token_account_owner, associated_token::mint = associated_token_account_mint)]
    pub associated_token_account: UncheckedAccount<'info>,

    /// CHECK: Validated by address constraint
    #[account(address = LIGHT_TOKEN_CONFIG)]
    pub light_token_config: AccountInfo<'info>,

    /// CHECK: Validated by address constraint
    #[account(mut, address = LIGHT_TOKEN_RENT_SPONSOR)]
    pub light_token_rent_sponsor: AccountInfo<'info>,

    /// CHECK: Light Token program for CPI
    #[account(address = LIGHT_TOKEN_PROGRAM_ID.into())]
    pub light_token_program: AccountInfo<'info>,

    pub system_program: Program<'info, System>,
}

use anchor_lang::{InstructionData, ToAccountMetas};
use light_client::interface::{get_create_accounts_proof, InitializeRentFreeConfig};
use light_program_test::{
    program_test::{setup_mock_program_data, LightProgramTest},
    ProgramTestConfig, Rpc,
};
use light_account::{derive_rent_sponsor_pda, LIGHT_TOKEN_PROGRAM_ID};
use light_token::instruction::{LIGHT_TOKEN_CONFIG, LIGHT_TOKEN_RENT_SPONSOR};
use solana_instruction::Instruction;
use solana_signer::Signer;
use test_utils::create_mint;

/// Test creating a Light Protocol associated token account using the macro.
#[tokio::test]
async fn test_create_associated_token_account() {
    use light_token_macro_create_associated_token_account::CreateAssociatedTokenAccountParams;

    let program_id = light_token_macro_create_associated_token_account::ID;
    let mut config =
        ProgramTestConfig::new_v2(true, Some(vec![("light_token_macro_create_associated_token_account", program_id)]));
    config = config.with_light_protocol_events();

    let mut rpc = LightProgramTest::new(config).await.unwrap();
    let payer = rpc.get_payer().insecure_clone();

    let program_data_pda = setup_mock_program_data(&mut rpc, &payer, &program_id);

    let (rent_sponsor, _) = derive_rent_sponsor_pda(&program_id);

    let (init_config_ix, _config_pda) = InitializeRentFreeConfig::new(
        &program_id,
        &payer.pubkey(),
        &program_data_pda,
        rent_sponsor,
        payer.pubkey(),
    )
    .build();

    rpc.create_and_send_transaction(&[init_config_ix], &payer.pubkey(), &[&payer])
        .await
        .expect("Initialize config should succeed");

    let (mint, _mint_seed) = create_mint(&mut rpc, &payer, None).await;

    // The associated token account owner will be the payer
    let associated_token_account_owner = payer.pubkey();

    // Derive the associated token account address using Light Token SDK's derivation
    let associated_token_account = light_token::instruction::derive_token_ata(&associated_token_account_owner, &mint);

    // Get proof (no PDA accounts for associated token account-only instruction)
    let proof_result = get_create_accounts_proof(&rpc, &program_id, vec![])
        .await
        .unwrap();

    // Build instruction
    let accounts = light_token_macro_create_associated_token_account::accounts::CreateAssociatedTokenAccount {
        fee_payer: payer.pubkey(),
        associated_token_account_mint: mint,
        associated_token_account_owner,
        associated_token_account,
        light_token_config: LIGHT_TOKEN_CONFIG,
        light_token_rent_sponsor: LIGHT_TOKEN_RENT_SPONSOR,
        light_token_program: LIGHT_TOKEN_PROGRAM_ID.into(),
        system_program: solana_sdk::system_program::ID,
    };

    let instruction_data = light_token_macro_create_associated_token_account::instruction::CreateAssociatedTokenAccount {
        params: CreateAssociatedTokenAccountParams {
            create_accounts_proof: proof_result.create_accounts_proof,
        },
    };

    let instruction = Instruction {
        program_id,
        accounts: [
            accounts.to_account_metas(None),
            proof_result.remaining_accounts,
        ]
        .concat(),
        data: instruction_data.data(),
    };

    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
        .await
        .expect("CreateAssociatedTokenAccount instruction should succeed");

    // Verify associated token account exists on-chain
    let associated_token_account_data = rpc
        .get_account(associated_token_account)
        .await
        .unwrap()
        .expect("Associated token account should exist on-chain");

    // Parse and verify token data
    use light_token_interface::state::Token;
    let token: Token = borsh::BorshDeserialize::deserialize(&mut &associated_token_account_data.data[..])
        .expect("Failed to deserialize Token");

    // Verify owner
    assert_eq!(token.owner, associated_token_account_owner.to_bytes(), "Associated token account owner should match");

    // Verify mint
    assert_eq!(token.mint, mint.to_bytes(), "Associated token account mint should match");

    // Verify initial amount is 0
    assert_eq!(token.amount, 0, "Associated token account amount should be 0 initially");
}

AI Prompt

Create a rent-free ATA with Anchor macros

CopiedCopy promptOpen in Cursor

---
description: Create a rent-free ATA with Anchor macros
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---

## Create a rent-free ATA with Anchor macros

Context:
- Guide: https://zkcompression.com/light-token/cookbook/create-ata
- Skills and resources index: https://zkcompression.com/skill.md
- SPL to Light reference: https://zkcompression.com/api-reference/solana-to-light-comparison
- Crates: light-sdk, light-sdk-macros, light-compressible, anchor-lang
- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-associated-token-account

Key macros: `#[light_program]`, `LightAccounts`, `#[light_account(init, associated_token::...)]`

### 1. Index project
- Grep `#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|ata|associated` across src/
- Glob `**/*.rs` and `**/Cargo.toml` for project structure
- Identify: existing program module, account structs, ATA patterns
- Read Cargo.toml — note existing dependencies and framework version
- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel

### 2. Read references
- WebFetch the guide above — review the Anchor Macros tab under Program
- WebFetch skill.md — check for a dedicated skill and resources matching this task
- TaskCreate one todo per phase below to track progress

### 3. Clarify intention
- AskUserQuestion: what is the goal? (new program from scratch, add rent-free ATA to existing program, migrate from SPL create_associated_token_account)
- Summarize findings and wait for user confirmation before implementing

### 4. Create plan
- Based on steps 1–3, draft an implementation plan
- Follow the guide's step order: Dependencies → Program Module (#[light_program]) → Accounts Struct (#[light_account(init, associated_token::...)])
- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion)
- Present the plan to the user for approval before proceeding

### 5. Implement
- Add deps if missing: Bash `cargo add light-sdk@0.23 --features anchor,v2,cpi-context` and `cargo add light-sdk-macros@0.23 light-compressible@0.6 anchor-lang@0.31`
- Follow the guide and the approved plan
- Write/Edit to create or modify files
- TaskUpdate to mark each step done

### 6. Verify
- Bash `anchor build`
- Bash `anchor test` if tests exist
- TaskUpdate to mark complete

### Tools
- mcp__zkcompression__SearchLightProtocol("<query>") for API details
- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "<q>") for architecture
- Task subagent with Grep/Read/WebFetch for parallel lookups
- TaskList to check remaining work

Related Guides

Transfer interface

Wrap and unwrap

---

Didn’t find what you were looking for?

Reach out! Telegram | email | Discord