Mint To creates new tokens of a mint and deposits them to a specified token account.
Before we can mint any tokens, we need an initialized mint account (SPL, Token 2022 or Light) for which we hold the mint authority.

Agent skill

npx skills add Lightprotocol/skills

Install orchestrator agent skill or view skill.md:

npx skills add https://zkcompression.com

TypeScript Client
Rust Client
Program

mintToInterface mints tokens to token accounts in a single call.The function auto-detects the token program (SPL, Token 2022, or Light) from the mint address.Compare to SPL:

Find the source code here.

Guide
AI Prompt

Mint Tokens to Light Token Account

Installation

npm
yarn
pnpm
SDK 2.0 (token-interface)

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

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

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

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
Devnet

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

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

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
Instruction
SDK 2.0 (token-interface)

import "dotenv/config";
import { Keypair } from "@solana/web3.js";
import { createRpc } from "@lightprotocol/stateless.js";
import {
    createMintInterface,
    createAtaInterface,
    mintToInterface,
    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 recipient = Keypair.generate();
    await createAtaInterface(rpc, payer, mint, recipient.publicKey);

    const destination = getAssociatedTokenAddressInterface(
        mint,
        recipient.publicKey
    );
    const tx = await mintToInterface(
        rpc,
        payer,
        mint,
        destination,
        payer,
        1_000_000_000
    );

    console.log("Tx:", tx);
})();

import "dotenv/config";
import {
    Keypair,
    ComputeBudgetProgram,
    Transaction,
    sendAndConfirmTransaction,
} from "@solana/web3.js";
import { createRpc, bn, DerivationMode } from "@lightprotocol/stateless.js";
import {
    createMintInterface,
    createAtaInterface,
    createMintToInterfaceInstruction,
    getMintInterface,
    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 recipient = Keypair.generate();
    await createAtaInterface(rpc, payer, mint, recipient.publicKey);
    const destination = getAssociatedTokenAddressInterface(
        mint,
        recipient.publicKey
    );

    const mintInterface = await getMintInterface(rpc, mint);

    let validityProof;
    if (mintInterface.merkleContext) {
        validityProof = await rpc.getValidityProofV2(
            [
                {
                    hash: bn(mintInterface.merkleContext.hash),
                    leafIndex: mintInterface.merkleContext.leafIndex,
                    treeInfo: mintInterface.merkleContext.treeInfo,
                    proveByIndex: mintInterface.merkleContext.proveByIndex,
                },
            ],
            [],
            DerivationMode.compressible
        );
    }

    const ix = createMintToInterfaceInstruction(
        mintInterface,
        destination,
        payer.publicKey,
        payer.publicKey,
        1_000_000_000,
        validityProof
    );

    const tx = new Transaction().add(
        ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 }),
        ix
    );
    const signature = await sendAndConfirmTransaction(rpc, tx, [payer]);

    console.log("Tx:", signature);
})();

import { Keypair, Transaction, sendAndConfirmTransaction } from "@solana/web3.js";
import { createRpc, LIGHT_TOKEN_PROGRAM_ID } from "@lightprotocol/stateless.js";
import {
  createAtaInstruction,
  createMintToInstruction,
  getAtaAddress,
} from "@lightprotocol/token-interface";

const rpc = createRpc();
const payer = Keypair.fromSecretKey(/* ... */);

const mint = /* existing mint public key */;
const recipient = Keypair.generate();
const destination = getAtaAddress({ mint, owner: recipient.publicKey });

const createAtaIx = createAtaInstruction({
  payer: payer.publicKey,
  owner: recipient.publicKey,
  mint,
  programId: LIGHT_TOKEN_PROGRAM_ID,
});

const mintToIx = createMintToInstruction({
  mint,
  destination,
  authority: payer.publicKey,
  payer: payer.publicKey,
  amount: 1_000_000_000n,
  tokenProgramId: LIGHT_TOKEN_PROGRAM_ID,
});

const tx = new Transaction().add(createAtaIx, mintToIx);
const signature = await sendAndConfirmTransaction(rpc, tx, [payer]);
console.log("Tx:", signature);

Mint tokens to Light Token account

Open in Cursor

---
description: Mint tokens to Light Token account
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---

## Mint tokens to Light Token account

Context:
- Guide: https://zkcompression.com/light-token/cookbook/mint-to
- 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: mintTo() → Light Token: mintToInterface()

### 1. Index project
- Grep `@solana/spl-token|Connection|Keypair|mintTo|mintToInterface` across src/
- Glob `**/*.ts` for project structure
- Identify: RPC setup, existing mint logic, entry point for minting
- 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 mint 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

Use MintTo to mint tokens to a Light Token account.Compare to SPL:

Guide
AI Prompt

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)
Localnet (LightClient)
Devnet (LightClient)

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());
}

Connects to a local test validator.

npm
yarn
pnpm

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

yarn global add @lightprotocol/zk-compression-cli

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(())
}

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(())
}

Mint to Light Token Accounts

Find the source code here.

Action
Instruction

use borsh::BorshDeserialize;
use light_client::rpc::Rpc;
use light_token_client::actions::{CreateAta, CreateMint, MintTo};
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 (payer is also mint authority)
    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?;

    // Mint tokens (payer is mint authority)
    let sig = MintTo {
        mint,
        destination: associated_token_account,
        amount: 1_000_000,
    }
    .execute(&mut rpc, &payer, &payer)
    .await?;

    let data = rpc.get_account(associated_token_account).await?.ok_or("Account not found")?;
    let token = light_token_interface::state::Token::deserialize(&mut &data.data[..])?;
    println!("Balance: {} Tx: {sig}", token.amount);

    Ok(())
}

use borsh::BorshDeserialize;
use light_client::rpc::Rpc;
use light_token::instruction::MintTo;
use rust_client::{setup_empty_associated_token_account, SetupContext};
use solana_sdk::signer::Signer;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Setup creates mint and empty associated token account
    let SetupContext {
        mut rpc,
        payer,
        mint,
        associated_token_account,
        ..
    } = setup_empty_associated_token_account().await;

    let mint_amount = 1_000_000_000u64;

    let mint_to_instruction = MintTo {
        mint,
        destination: associated_token_account,
        amount: mint_amount,
        authority: payer.pubkey(),
        fee_payer: payer.pubkey(),
    }
    .instruction()?;

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

    let data = rpc.get_account(associated_token_account).await?.ok_or("Account not found")?;
    let token = light_token_interface::state::Token::deserialize(&mut &data.data[..])?;
    println!("Balance: {} Tx: {sig}", token.amount);

    Ok(())
}

Mint tokens to Light Token account

Open in Cursor

---
description: Mint tokens to Light Token account
allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression
---

## Mint tokens to Light Token account

Context:
- Guide: https://zkcompression.com/light-token/cookbook/mint-to
- 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_token::instruction::mint_to → Light Token: MintTo

### 1. Index project
- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|MintTo|mint_to` across src/
- Glob `**/*.rs` for project structure
- Identify: RPC setup, existing token ops, entry point for minting
- 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 mint 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

Guide
AI Prompt

Find a full code example at the end.

Build Account Infos and CPI the Light Token Program

Use invoke for external signers or invoke_signed when the authority is a PDA.

invoke (External signer)
invoke_signed (PDA authority)

use light_token::instruction::MintToCpi;

MintToCpi {
    mint: mint.clone(),
    destination: destination.clone(),
    amount,
    authority: authority.clone(),
    system_program: system_program.clone(),
    fee_payer: None,
    max_top_up: None,
}
.invoke()

use light_token::instruction::MintToCpi;

let signer_seeds: &[&[u8]] = &[MINT_AUTHORITY_SEED, &[bump]];

MintToCpi {
    mint: mint.clone(),
    destination: destination.clone(),
    amount,
    authority: authority.clone(),
    system_program: system_program.clone(),
    fee_payer: None,
    max_top_up: None,
}
.invoke_signed(&[signer_seeds])

fee_payer and max_top_up are optional fields to customize rent top-ups. Set to None to use defaults.

Full Code Example

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

#![allow(unexpected_cfgs, deprecated)]

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

declare_id!("8bXEVmHLtAVqDLJp1dYWAZ61WQmqQKoTQ8LpPbRoUDCp");

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

    pub fn mint_to(ctx: Context<MintToAccounts>, amount: u64) -> Result<()> {
        MintToCpi {
            mint: ctx.accounts.mint.to_account_info(),
            destination: ctx.accounts.destination.to_account_info(),
            amount,
            authority: ctx.accounts.authority.to_account_info(),
            system_program: ctx.accounts.system_program.to_account_info(),
            fee_payer: ctx.accounts.fee_payer.to_account_info(),
        }
        .invoke()?;
        Ok(())
    }
}

#[derive(Accounts)]
pub struct MintToAccounts<'info> {
    /// CHECK: Light token program for CPI
    pub light_token_program: AccountInfo<'info>,
    /// CHECK: Validated by light-token CPI
    #[account(mut)]
    pub mint: AccountInfo<'info>,
    /// CHECK: Validated by light-token CPI
    #[account(mut)]
    pub destination: AccountInfo<'info>,
    pub authority: Signer<'info>,
    #[account(mut)]
    pub fee_payer: Signer<'info>,
    pub system_program: Program<'info, System>,
}

use anchor_lang::{InstructionData, ToAccountMetas};
use light_program_test::Rpc;
use light_token::instruction::LIGHT_TOKEN_PROGRAM_ID;
use light_token_anchor_mint_to::{accounts, instruction::MintTo, ID};
use anchor_lang::system_program;
use solana_sdk::{instruction::Instruction, signer::Signer};
use test_utils::setup_test_env;

#[tokio::test(flavor = "multi_thread")]
async fn test_mint_to() {
    let mut env = setup_test_env("light_token_anchor_mint_to", ID).await;

    // No mint_tokens call - the test IS minting tokens via CPI.
    let amount = 1_000_000u64;
    let ix = Instruction {
        program_id: ID,
        accounts: accounts::MintToAccounts {
            light_token_program: LIGHT_TOKEN_PROGRAM_ID,
            mint: env.mint_pda,
            destination: env.associated_token_account,
            authority: env.payer.pubkey(),
            fee_payer: env.payer.pubkey(),
            system_program: system_program::ID,
        }
        .to_account_metas(Some(true)),
        data: MintTo { amount }.data(),
    };

    env.rpc
        .create_and_send_transaction(&[ix], &env.payer.pubkey(), &[&env.payer])
        .await
        .unwrap();

    // Verify the account exists and has data
    let associated_token_account_data = env.rpc.get_account(env.associated_token_account).await.unwrap().unwrap();
    assert!(!associated_token_account_data.data.is_empty(), "Associated token account should have data");
}

Add mint-to CPI to an Anchor program

Open in Cursor

---
description: Add mint-to 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 mint-to CPI to an Anchor program

Context:
- Guide: https://zkcompression.com/light-token/cookbook/mint-to
- 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 (MintToCpi)
- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/mint-to

Key CPI struct: `light_token::instruction::MintToCpi`

### 1. Index project
- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|mint|supply|amount` across src/
- Glob `**/*.rs` and `**/Cargo.toml` for project structure
- Identify: program ID, existing instructions, account structs, mint accounts
- 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 Program tab CPI code samples
- 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 mint-to to existing program, new program from scratch, migrate from SPL mint_to)
- AskUserQuestion: should the authority 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 MintToCpi struct → call .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

Transfer interface

Approve and revoke

Didn’t find what you were looking for?

Reach out! Telegram | email | Discord

Introduction

Light Token APIs

PDA Accounts

For Other Use Cases

Learn

Resources

Mint to Light Token Accounts

Mint Tokens to Light Token Account

Prerequisites

Mint to Light Token Accounts

Build Account Infos and CPI the Light Token Program

Full Code Example

Transfer interface

Approve and revoke

Didn’t find what you were looking for?

​Mint Tokens to Light Token Account

​Prerequisites

​Mint to Light Token Accounts

​Build Account Infos and CPI the Light Token Program

​Full Code Example

​Related Guides

Transfer interface

Approve and revoke

​Didn’t find what you were looking for?

Mint Tokens to Light Token Account

Prerequisites

Mint to Light Token Accounts

Build Account Infos and CPI the Light Token Program

Full Code Example

Related Guides

Didn’t find what you were looking for?