Skip to main content
The createTokenPool() function registers an existing SPL mint with the compressed token program and creates a token pool PDA. createTokenPool() requires only fee_payer and has no mint authority constraint.
The token pool account itself requires rent, but individual compressed token accounts are rent-free.
Before we create a token pool, we need an existing SPL mint account. 
// Creates token pool account for existing SPL mint
const transactionSignature = await createTokenPool(
    rpc,
    payer,
    mint,
);
Best Practice: Each mint supports a maximum of 4 token pools total. During compression/decompression operations, token pools get write-locked. Use addTokenPools() to create additional pools that increase per-block write-lock capacity.

​
Full Code Example

​
Prerequisites

Make sure you have dependencies and developer environment set up!
DependenciesMake sure you have dependencies and developer environment set up!Prerequisites & Setup

​
Dependencies

npm install --save-dev typescript tsx @types/node && \
npm install --save \
    @lightprotocol/stateless.js \
    @lightprotocol/compressed-token \
    @solana/web3.js \
    @solana/spl-token
Alternatives:
yarn add --dev typescript tsx @types/node && \
yarn add \
    @lightprotocol/stateless.js \
    @lightprotocol/compressed-token \
    @solana/web3.js \
    @solana/spl-token

pnpm add --save-dev typescript tsx @types/node && \
pnpm add \
    @lightprotocol/stateless.js \
    @lightprotocol/compressed-token \
    @solana/web3.js \
    @solana/spl-token
Developer EnvironmentBy default, this guide uses Localnet.
# Install the development CLI
npm install @lightprotocol/zk-compression-cli

# Start a local test validator
light test-validator

## ensure you have the Solana CLI accessible in your system PATH

// createRpc() defaults to local test validator endpoints
import {
  Rpc,
  createRpc,
} from "@lightprotocol/stateless.js";

const connection: Rpc = createRpc();

async function main() {
  let slot = await connection.getSlot();
  console.log(slot);

  let health = await connection.getIndexerHealth(slot);
  console.log(health);
  // "Ok"
}

main();
Alternative: Using DevnetFollow these steps to create an RPC Connection. Replace <your_api_key> with your API key before running.
Get your API key here, if you don’t have one yet.
import { createRpc } from "@lightprotocol/stateless.js";

// Helius exposes Solana and Photon RPC endpoints through a single URL
const RPC_ENDPOINT = "https://devnet.helius-rpc.com?api-key=<your_api_key>";
const connection = createRpc(RPC_ENDPOINT, RPC_ENDPOINT, RPC_ENDPOINT);

console.log("Connection created!");
console.log("RPC Endpoint:", RPC_ENDPOINT);

​
Create Token Pool

Run this script to create token pools for an SPL mint!
create-token-pools.ts
// 1. Setup funded payer and connect to local validator
// 2. Create SPL mint
// 3. Call createTokenPool() to register mint with compressed token program
// 4. Add additional pools to increase write-lock capacity (optional)

import { Keypair, PublicKey } from '@solana/web3.js';
import { createRpc } from '@lightprotocol/stateless.js';
import { createTokenPool, addTokenPools } from '@lightprotocol/compressed-token';
import { createMint } from '@solana/spl-token';

async function createTokenPools() {

    // Step 1: Setup funded payer and connect to local validator
    const rpc = createRpc(); // defaults to localhost:8899
    const payer = Keypair.generate();
    const airdropSignature = await rpc.requestAirdrop(payer.publicKey, 1000000000); // 1 SOL
    await rpc.confirmTransaction(airdropSignature);

    // Step 2: Create SPL mint
    const mint = await createMint(
        rpc,
        payer,
        payer.publicKey, // mint authority
        payer.publicKey, // freeze authority
        9
    );

    console.log("SPL mint created");
    console.log("Mint address:", mint.toBase58());

    // Step 3: Call createTokenPool() to register SPL mint with compressed token program
    // Creates token pool PDA (omnibus account) that holds SPL tokens for compressed tokens
    const poolTx = await createTokenPool(
        rpc,
        payer,
        mint // existing SPL mint to register
    );

    console.log("\nToken pool created!");
    console.log("SPL mint registered with compressed token program:", mint.toBase58());
    console.log("Pool transaction:", poolTx);

    // Step 4: Add up to 3 additional pools - increase write-lock capacity for higher throughput
    const additionalPoolsCount = 2;
    const additionalPoolsTx = await addTokenPools(
        rpc,
        payer,
        mint, // SPL mint with existing token pool
        additionalPoolsCount, // number of additional pools (max 3 more)
    );

    console.log(`\nAdded ${additionalPoolsCount} additional token pools!`);
    console.log("Additional pools transaction:", additionalPoolsTx);


    return {
        mint,
        poolTransaction: poolTx,
        additionalPoolsTransaction: additionalPoolsTx
    };
}

createTokenPools().catch(console.error);

​
Troubleshooting

You’re trying to access a token pool that doesn’t exist.
// Create the missing token pool
const poolTx = await createTokenPool(rpc, payer, mint);
console.log("Token pool created:", poolTx);

​
Advanced Configuration

Create pools for multiple mints:
const mints = [
    new PublicKey("MINT_1_ADDRESS"),
    new PublicKey("MINT_2_ADDRESS"),
    new PublicKey("MINT_3_ADDRESS"),
];

for (const mint of mints) {
    try {
        const poolTx = await createTokenPool(rpc, payer, mint);
        console.log(`Pool created for ${mint.toBase58()}:`, poolTx);
    } catch (error) {
        console.log(`Failed for ${mint.toBase58()}:`, error.message);
    }
}
Create token pools for Token-2022 mints:
import { TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';

const poolTx = await createTokenPool(
    rpc,
    payer,
    mint, // Token-2022 mint
    undefined,
    TOKEN_2022_PROGRAM_ID,
);

​
Next Steps

Learn how to merge multiple compressed token accounts into one to simplify state management.