Solana Compress

ZK Compressed Token Launcher

Build with ZK Compression on Solana using Light Protocol to reduce on-chain storage costs by 99%. The Light Token SDK drops Solana Associated Token Account fees to $0.001 for all SPL tokens, with Token-2022 extension support.

Why this matters now

Light Token SDK is live on mainnet. Any operation that creates many token accounts — airdrops, loyalty programs, gaming assets, agent micropayments — goes from economically impossible to trivially cheap. Token-2022 extensions (transfer hooks, permanent delegation, transfer fees) now work with compression.

When to use this skill

• "Airdrop tokens to 100k wallets cheaply"
• "Compressed token mint"
• "Reduce token account costs"
• "ZK compression on Solana"
• "Mass NFT distribution"
• "Gaming assets at scale"
• Any project creating many token accounts

Core concept

Standard Solana token accounts cost ~$0.002 each in rent. At scale:

• 10k accounts = ~$20
• 100k accounts = ~$200
• 1M accounts = ~$2,000

With ZK Compression:

• 10k accounts = ~$0.20
• 100k accounts = ~$2
• 1M accounts = ~$20

The compression works by storing account data in a Merkle tree and posting only the root hash on-chain. ZK proofs verify state transitions without storing full account data.

Build mode workflow

Step 1 — Define the use case

Ask the founder:

1. What tokens? (fungible SPL, Token-2022 with extensions, NFTs/cNFTs)
2. Scale? (hundreds, thousands, millions of accounts)
3. Token-2022 extensions needed? (transfer hooks, transfer fees, permanent delegation, confidential transfers)
4. Distribution method? (airdrop, claim page, in-app earning, game rewards)
5. Composability needs? (do compressed tokens need to interact with existing DeFi protocols?)

Step 2 — Scaffold the project

solana-compress/
├── src/
│   ├── token/
│   │   ├── create.ts          # Create compressed token mint
│   │   ├── mint.ts            # Mint compressed tokens
│   │   └── transfer.ts        # Transfer compressed tokens
│   ├── airdrop/
│   │   ├── distribute.ts      # Batch distribution script
│   │   └── merkle.ts          # Merkle tree management
│   ├── utils/
│   │   └── cost-calculator.ts # Compare compressed vs uncompressed costs
│   └── index.ts
├── .env.example
└── package.json

Step 3 — Set up Light Protocol SDK

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

Dependencies:

• @lightprotocol/stateless.js — Core compression primitives
• @lightprotocol/compressed-token — SPL token compression
• A compatible RPC (Helius supports ZK Compression natively)

Step 4 — Implement compressed token operations

Create a compressed token mint:

import { createMint } from "@lightprotocol/compressed-token";
import { buildAndSignTx, Rpc } from "@lightprotocol/stateless.js";

const rpc = createRpc(HELIUS_RPC_URL);
const mint = await createMint(rpc, payer, authority, decimals);

Mint compressed tokens:

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

await mintTo(rpc, payer, mint, destination, authority, amount);

Batch airdrop:

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

// Distribute to thousands of wallets in a single transaction
await compressedAirdrop(rpc, payer, mint, recipients, amountPerRecipient);

Step 5 — Cost comparison

Before deploying, run the cost calculator to show the founder the savings:

| Operation | Standard | Compressed | Savings | |-----------|----------|------------|---------| | 1 token account | ~$0.002 | ~$0.00002 | 99% | | 10k airdrop | ~$20 | ~$0.20 | 99% | | 100k airdrop | ~$200 | ~$2 | 99% | | 1M accounts | ~$2,000 | ~$20 | 99% |

Step 6 — Token-2022 extensions (if needed)

Compressed tokens support Token-2022 extensions:

• Transfer hooks — Execute custom logic on every transfer (royalties, compliance checks)
• Transfer fees — Automatic fee collection on transfers
• Permanent delegation — Allow a delegate to transfer tokens at any time (escrow, vesting)
• Confidential transfers — Hide transfer amounts using ZK proofs

Hard rules

1. Use a compression-compatible RPC. Not all RPCs support ZK Compression. Helius has native support. Check provider compatibility before starting.
2. Understand the composability tradeoff. Compressed tokens can't directly interact with standard DeFi protocols (AMMs, lending) that expect regular token accounts. Decompress first if needed.
3. Merkle tree sizing matters. Choose tree depth based on expected account count. Too small = runs out of leaves. Too large = higher creation cost.
4. Test decompression flows. Users may need to decompress tokens to use them in existing DeFi. Make sure this path works smoothly.
5. Monitor tree utilization. When a Merkle tree fills up, you need a new one. Build monitoring for tree capacity.

Reference links

• ZK Compression documentation
• Light Protocol GitHub
• Light Token SDK examples
• Helius ZK Compression support
• Token-2022 extensions

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: SuperteamCanada
• Source: SuperteamCanada/STCA-skills
• License: MIT

Install and usage instructions live in the source repository linked above.