Wrap & Unwrap SPL/Token-22 <> Light Token

Move tokens between SPL/Token-22 token and light-token accounts. Use to interact with applications that only support SPL/Token-22.

---

• Wrap: Move tokens from SPL/T22 account → light-token ATA (hot balance)
• Unwrap: Move tokens from light-token ATA (hot balance) → SPL/T22 account

Find the source code: wrap.ts | unwrap.ts

Get Started

Wrap

1. Wrap SPL Tokens to Light Token ATA

   Installation

   npm

   Install packages in your working directory:

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

   Install the CLI globally:

   npm install -g @lightprotocol/zk-compression-cli@alpha
   

   yarn

   Install packages in your working directory:

   yarn add @lightprotocol/stateless.js@alpha \
            @lightprotocol/compressed-token@alpha
   

   Install the CLI globally:

   yarn global add @lightprotocol/zk-compression-cli@alpha
   

   pnpm

   Install packages in your working directory:

   pnpm add @lightprotocol/stateless.js@alpha \
            @lightprotocol/compressed-token@alpha
   

   Install the CLI globally:

   pnpm add -g @lightprotocol/zk-compression-cli@alpha
   

   Localnet

   # start local test-validator in a separate terminal
   light test-validator
   

   In the code examples, use createRpc() without arguments for localnet.

   Devnet

   Get an API key from Helius and add to .env:

   .env

   API_KEY=<your-helius-api-key>
   

   In the code examples, use createRpc(RPC_URL) with the devnet URL.

   Action

   import "dotenv/config";
   import { Keypair } from "@solana/web3.js";
   import { createRpc, bn } from "@lightprotocol/stateless.js";
   import {
       createMint,
       mintTo,
       decompress,
       wrap,
       getAssociatedTokenAddressInterface,
       createAtaInterfaceIdempotent,
   } from "@lightprotocol/compressed-token";
   import { createAssociatedTokenAccount } from "@solana/spl-token";
   import { homedir } from "os";
   import { readFileSync } from "fs";
   
   // devnet:
   const RPC_URL = `https://devnet.helius-rpc.com?api-key=${process.env.API_KEY!}`;
   // localnet:
   // const RPC_URL = undefined;
   const payer = Keypair.fromSecretKey(
       new Uint8Array(
           JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8"))
       )
   );
   
   (async function () {
       // devnet:
       const rpc = createRpc(RPC_URL);
       // localnet:
       // const rpc = createRpc();
   
       // Setup: Get SPL tokens (needed to wrap)
       const { mint } = await createMint(rpc, payer, payer.publicKey, 9);
       const splAta = await createAssociatedTokenAccount(
           rpc,
           payer,
           mint,
           payer.publicKey
       );
       await mintTo(rpc, payer, mint, payer.publicKey, payer, bn(1000));
       await decompress(rpc, payer, mint, bn(1000), payer, splAta);
   
       // Wrap SPL tokens to rent-free token ATA
       const ctokenAta = getAssociatedTokenAddressInterface(mint, payer.publicKey);
       await createAtaInterfaceIdempotent(rpc, payer, mint, payer.publicKey);
   
       const tx = await wrap(rpc, payer, splAta, ctokenAta, payer, mint, bn(500));
   
       console.log("Tx:", tx);
   })();
   

   Instruction

   import "dotenv/config";
   import { Keypair, ComputeBudgetProgram, Transaction, sendAndConfirmTransaction } from "@solana/web3.js";
   import { createRpc, bn } from "@lightprotocol/stateless.js";
   import {
       createMint,
       mintTo,
       decompress,
       createWrapInstruction,
       getAssociatedTokenAddressInterface,
       createAtaInterfaceIdempotent,
       getSplInterfaceInfos,
   } from "@lightprotocol/compressed-token";
   import { createAssociatedTokenAccount } from "@solana/spl-token";
   import { homedir } from "os";
   import { readFileSync } from "fs";
   
   // devnet:
   const RPC_URL = `https://devnet.helius-rpc.com?api-key=${process.env.API_KEY!}`;
   const rpc = createRpc(RPC_URL);
   // localnet:
   // const rpc = createRpc();
   
   const payer = Keypair.fromSecretKey(
       new Uint8Array(
           JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8"))
       )
   );
   
   (async function () {
   
       // Setup: Get SPL tokens (needed to wrap)
       const { mint } = await createMint(rpc, payer, payer.publicKey, 9);
       const splAta = await createAssociatedTokenAccount(
           rpc,
           payer,
           mint,
           payer.publicKey
       );
       await mintTo(rpc, payer, mint, payer.publicKey, payer, bn(1000));
       await decompress(rpc, payer, mint, bn(1000), payer, splAta);
   
       // Create wrap instruction
       const ctokenAta = getAssociatedTokenAddressInterface(mint, payer.publicKey);
       await createAtaInterfaceIdempotent(rpc, payer, mint, payer.publicKey);
   
       const splInterfaceInfos = await getSplInterfaceInfos(rpc, mint);
       const splInterfaceInfo = splInterfaceInfos.find(
           (info) => info.isInitialized
       );
   
       if (!splInterfaceInfo) throw new Error("No SPL interface found");
   
       const ix = createWrapInstruction(
           splAta,
           ctokenAta,
           payer.publicKey,
           mint,
           bn(500),
           splInterfaceInfo,
           payer.publicKey
       );
   
       const tx = new Transaction().add(
           ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }),
           ix
       );
       const signature = await sendAndConfirmTransaction(rpc, tx, [payer]);
   
       console.log("Tx:", signature);
   })();
   

Unwrap

1. Unwrap Light Tokens to SPL Account

   Action

   import "dotenv/config";
   import { Keypair } from "@solana/web3.js";
   import { createRpc, bn } from "@lightprotocol/stateless.js";
   import { createMint, mintTo } from "@lightprotocol/compressed-token";
   import { unwrap } from "@lightprotocol/compressed-token/unified";
   import { createAssociatedTokenAccount } from "@solana/spl-token";
   import { homedir } from "os";
   import { readFileSync } from "fs";
   
   // devnet:
   const RPC_URL = `https://devnet.helius-rpc.com?api-key=${process.env.API_KEY!}`;
   // localnet:
   // const RPC_URL = undefined;
   const payer = Keypair.fromSecretKey(
       new Uint8Array(
           JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8"))
       )
   );
   
   (async function () {
       // devnet:
       const rpc = createRpc(RPC_URL);
       // localnet:
       // const rpc = createRpc();
   
       // Setup: Get compressed tokens (cold storage)
       const { mint } = await createMint(rpc, payer, payer.publicKey, 9);
       await mintTo(rpc, payer, mint, payer.publicKey, payer, bn(1000));
   
       // Unwrap rent-free tokens to SPL ATA
       const splAta = await createAssociatedTokenAccount(
           rpc,
           payer,
           mint,
           payer.publicKey
       );
       const tx = await unwrap(rpc, payer, splAta, payer, mint, bn(500));
   
       console.log("Tx:", tx);
   })();
   

   Instruction

   import "dotenv/config";
   import { Keypair, ComputeBudgetProgram, Transaction, sendAndConfirmTransaction } from "@solana/web3.js";
   import { createRpc, bn } from "@lightprotocol/stateless.js";
   import {
       createMint,
       mintTo,
       loadAta,
       getAssociatedTokenAddressInterface,
       getSplInterfaceInfos,
   } from "@lightprotocol/compressed-token";
   import { createUnwrapInstruction } from "@lightprotocol/compressed-token/unified";
   import { createAssociatedTokenAccount } from "@solana/spl-token";
   import { homedir } from "os";
   import { readFileSync } from "fs";
   
   // devnet:
   const RPC_URL = `https://devnet.helius-rpc.com?api-key=${process.env.API_KEY!}`;
   const rpc = createRpc(RPC_URL);
   // localnet:
   // const rpc = createRpc();
   
   const payer = Keypair.fromSecretKey(
       new Uint8Array(
           JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8"))
       )
   );
   
   (async function () {
   
       // Setup: Get compressed tokens (cold storage)
       const { mint } = await createMint(rpc, payer, payer.publicKey, 9);
       await mintTo(rpc, payer, mint, payer.publicKey, payer, bn(1000));
   
       // Load compressed tokens to hot balance, then create unwrap instruction
       const ctokenAta = getAssociatedTokenAddressInterface(mint, payer.publicKey);
       await loadAta(rpc, ctokenAta, payer, mint, payer);
   
       const splAta = await createAssociatedTokenAccount(
           rpc,
           payer,
           mint,
           payer.publicKey
       );
   
       const splInterfaceInfos = await getSplInterfaceInfos(rpc, mint);
       const splInterfaceInfo = splInterfaceInfos.find(
           (info) => info.isInitialized
       );
   
       if (!splInterfaceInfo) throw new Error("No SPL interface found");
   
       const ix = createUnwrapInstruction(
           ctokenAta,
           splAta,
           payer.publicKey,
           mint,
           bn(500),
           splInterfaceInfo,
           payer.publicKey
       );
   
       const tx = new Transaction().add(
           ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }),
           ix
       );
       const signature = await sendAndConfirmTransaction(rpc, tx, [payer]);
   
       console.log("Tx:", signature);
   })();