Toolkit for Wallet Applications

light-token follows the same API patterns like ATA
Your users hold and receive the same tokens, just stored more efficiently.

Creation Cost	SPL	light-token
Token Account	~2,000,000 lamports	~17,000 lamports

Get an overview to the light-token standard here.

What you will implement

	light-token	SPL Token
Get/Create ATA	getOrCreateAtaInterface()	getOrCreateAssociatedTokenAccount()
Derive ATA	getAssociatedTokenAddressInterface()	getAssociatedTokenAddress()
Transfer	transferInterface()	transferChecked()
Get Balance	getAtaInterface()	getAccount()
Tx History	rpc.getSignaturesForOwnerInterface()	getSignaturesForAddress()
Exit to SPL	unwrap()	N/A

Find devnet examples here https://github.com/Lightprotocol/light-token-toolkit.

Setup

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

import { createRpc } from "@lightprotocol/stateless.js";

import {
  getOrCreateAtaInterface,
  getAtaInterface,
  getAssociatedTokenAddressInterface,
  transferInterface,
  unwrap,
} from "@lightprotocol/compressed-token";

const rpc = createRpc(RPC_ENDPOINT);

Receive Payments

Action
Instruction

import { getOrCreateAtaInterface } from "@lightprotocol/compressed-token";

const ata = await getOrCreateAtaInterface(
  rpc,
  payer,
  mint,
  recipient
);
// Share ata.parsed.address with sender

console.log(ata.parsed.amount);

Compare to SPL

import { getOrCreateAssociatedTokenAccount } from "@solana/spl-token";

const ata = await getOrCreateAssociatedTokenAccount(
  connection,
  payer,
  mint,
  recipient
);
// Share ata.address with sender

console.log(ata.amount);

import {
  createAssociatedTokenAccountInterfaceIdempotentInstruction,
  createLoadAtaInstructions,
  getAssociatedTokenAddressInterface,
} from "@lightprotocol/compressed-token";
import { CTOKEN_PROGRAM_ID } from "@lightprotocol/stateless.js";

const ata = getAssociatedTokenAddressInterface(mint, recipient);

const tx = new Transaction().add(
  createAssociatedTokenAccountInterfaceIdempotentInstruction(
    payer.publicKey,
    ata,
    recipient,
    mint,
    CTOKEN_PROGRAM_ID
  ),
  ...(await createLoadAtaInstructions(
    rpc,
    ata,
    recipient,
    mint,
    payer.publicKey
  ))
);

Compare to SPL

import {
  createAssociatedTokenAccountInstruction,
  getAssociatedTokenAddressSync,
} from "@solana/spl-token";

const ata = getAssociatedTokenAddressSync(mint, recipient);

const tx = new Transaction().add(
  createAssociatedTokenAccountInstruction(
    payer.publicKey,
    ata,
    recipient,
    mint
  )
);

Send Payments

Action
Instruction

import {
  getAssociatedTokenAddressInterface,
  transferInterface,
} from "@lightprotocol/compressed-token";

const sourceAta = getAssociatedTokenAddressInterface(mint, owner.publicKey);
const destinationAta = getAssociatedTokenAddressInterface(mint, recipient);

await transferInterface(
  rpc,
  payer,
  sourceAta,
  mint,
  destinationAta,
  owner,
  amount
);

To ensure your recipient’s ATA exists you can prepend an idempotent creation instruction in the same atomic transaction:

import {
  getAssociatedTokenAddressInterface,
  createAssociatedTokenAccountInterfaceIdempotentInstruction,
} from "@lightprotocol/compressed-token";
import { CTOKEN_PROGRAM_ID } from "@lightprotocol/stateless.js";

const destinationAta = getAssociatedTokenAddressInterface(mint, recipient);
const createAtaIx = createAssociatedTokenAccountInterfaceIdempotentInstruction(
  payer.publicKey,
  destinationAta,
  recipient,
  mint,
  CTOKEN_PROGRAM_ID
);

new Transaction().add(createAtaIx, transferIx);

Compare to SPL

import { transfer } from "@solana/spl-token";

const sourceAta = getAssociatedTokenAddressSync(mint, owner.publicKey);
const destinationAta = getAssociatedTokenAddressSync(mint, recipient);

await transfer(
  connection,
  payer,
  sourceAta,
  destinationAta,
  owner,
  amount,
  decimals
);

With idempotent ATA creation:

import {
  getAssociatedTokenAddressSync,
  createAssociatedTokenAccountIdempotentInstruction,
} from "@solana/spl-token";

const destinationAta = getAssociatedTokenAddressSync(mint, recipient);
const createAtaIx = createAssociatedTokenAccountIdempotentInstruction(
  payer.publicKey,
  destinationAta,
  recipient,
  mint
);

new Transaction().add(createAtaIx, transferIx);

import {
  createLoadAtaInstructions,
  createTransferInterfaceInstruction,
  getAssociatedTokenAddressInterface,
} from "@lightprotocol/compressed-token";

const sourceAta = getAssociatedTokenAddressInterface(mint, owner.publicKey);
const destinationAta = getAssociatedTokenAddressInterface(mint, recipient);

const tx = new Transaction().add(
  ...(await createLoadAtaInstructions(
    rpc,
    sourceAta,
    owner.publicKey,
    mint,
    payer.publicKey
  )),
  createTransferInterfaceInstruction(
    sourceAta,
    destinationAta,
    owner.publicKey,
    amount
  )
);

Compare to SPL

import {
  getAssociatedTokenAddressSync,
  createTransferInstruction,
} from "@solana/spl-token";

const sourceAta = getAssociatedTokenAddressSync(mint, owner.publicKey);
const destinationAta = getAssociatedTokenAddressSync(mint, recipient);

const tx = new Transaction().add(
  createTransferInstruction(sourceAta, destinationAta, owner.publicKey, amount)
);

Show Balance

import {
  getAssociatedTokenAddressInterface,
  getAtaInterface,
} from "@lightprotocol/compressed-token";

const ata = getAssociatedTokenAddressInterface(mint, owner);
const account = await getAtaInterface(
  rpc,
  ata,
  owner,
  mint
);

console.log(account.parsed.amount);

Compare to SPL

import { getAccount } from "@solana/spl-token";

const account = await getAccount(connection, ata);

console.log(account.amount);

Transaction History

Token accounts are compressed when inactive

const result = await rpc.getSignaturesForOwnerInterface(owner);

console.log(result.signatures);
console.log(result.solana);
console.log(result.compressed);

Use getSignaturesForAddressInterface(address) if you want address-specific rather than owner-wide history.

Compare to SPL

const signatures = await connection.getSignaturesForAddress(ata);

Unwrap to SPL

When users need SPL tokens (CEX withdrawal, legacy integration):

Action
Instruction

import { getAssociatedTokenAddressSync } from "@solana/spl-token";

// SPL ATA must exist
const splAta = getAssociatedTokenAddressSync(mint, owner.publicKey);

await unwrap(
  rpc,
  payer,
  owner,
  mint,
  splAta,
  amount
);

import { getAssociatedTokenAddressSync } from "@solana/spl-token";
import {
  createLoadAtaInstructions,
  createUnwrapInstruction,
  getAssociatedTokenAddressInterface,
} from "@lightprotocol/compressed-token";
import { getSplInterfaceInfos } from "@lightprotocol/compressed-token";

const ctokenAta = getAssociatedTokenAddressInterface(mint, owner.publicKey);
const splAta = getAssociatedTokenAddressSync(mint, owner.publicKey);

const splInterfaceInfos = await getSplInterfaceInfos(rpc, mint);
const splInterfaceInfo = splInterfaceInfos.find((i) => i.isInitialized);

const tx = new Transaction().add(
  ...(await createLoadAtaInstructions(
    rpc,
    ctokenAta,
    owner.publicKey,
    mint,
    payer.publicKey
  )),
  createUnwrapInstruction(
    ctokenAta,
    splAta,
    owner.publicKey,
    mint,
    amount,
    splInterfaceInfo
  )
);

Light-Token Standard (Beta)

Get Started with ZK Compression

Compressed Tokens

Compressed PDAs

JSON RPC Methods

Learn

Resources

References

SDK Reference

Toolkit for Wallet Applications

What you will implement

Setup

Receive Payments

Send Payments

Show Balance

Transaction History

Unwrap to SPL

Light-Token Standard (Beta)

Get Started with ZK Compression

Compressed Tokens

Compressed PDAs

JSON RPC Methods

Learn

Resources

References

SDK Reference

​What you will implement

​Setup

​Receive Payments

​Send Payments

​Show Balance

​Transaction History

​Unwrap to SPL

What you will implement

Setup

Receive Payments

Send Payments

Show Balance

Transaction History

Unwrap to SPL