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

Prerequisites

Make sure you have dependencies and developer environment set up!

Prerequisites & Setup

Dependencies

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

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.