Create Compressed Token Pools for Mint Accounts

Complete guide to create and manage token pools for compressed tokens for SPL mints with `createTokenPool()`, troubleshooting and advanced configurations.

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.

function-create-token-pool.ts

// 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

1

Prerequisites

Make 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 Environment

By 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 Devnet

Follow 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);

2

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

"TokenPool not found"

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

Batch Pool Creation

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 Pool with Token-2022

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.

Merge Compressed Token Accounts