light-token Toolkit for Stablecoin Payments

light-token follows the same API patterns like ATA
Your users receives the same stablecoin, just stored more efficiently.

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

Get an overview to light-token’s 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/c-token-toolkit.

Setup

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

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

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

const rpc = createRpc(RPC_ENDPOINT);

Receive Payments

Action
Instruction

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

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/unified";
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/unified";

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/unified";
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/unified";

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/unified";

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

const result = await rpc.getSignaturesForOwnerInterface(owner);

console.log(result.signatures); // Merged + deduplicated
console.log(result.solana); // On-chain txs only
console.log(result.compressed); // Compressed txs only

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 vanilla 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/unified";
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

light-token Toolkit for Stablecoin Payments

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