Bump to beta.12, fix all examples, add CI for toolkits

tilo-14 · tilo-14 · commit 1381378a6b29 · 2026-03-21T02:25:13.000Z
- Bump @lightprotocol/compressed-token and stateless.js to ^0.23.0-beta.12
- Fix wrap/unwrap examples: replace removed decompressInterface, use TOKEN_PROGRAM_ID
- Fix delegate-transfer: use SPL mint + wrap pattern for hot balance
- Fix load-ata instruction: import from /unified, fix batching
- Fix gasless-transfer: pass recipient owner, not ATA address
- Fix gasless-transactions Cargo.toml: update binary path after rename
- Add CI jobs for payments toolkit and gasless-transactions TypeScript
- Remove dead script entries from typescript-client package.json
- Rename send examples to basic-send-action/instruction
- Add batch-send-instruction with createLightTokenTransferInstruction
- Update READMEs with renamed files and new examples

Entire-Checkpoint: 4afa49be1970
diff --git a/.github/workflows/typescript-tests.yml b/.github/workflows/typescript-tests.yml
@@ -50,3 +50,61 @@ jobs:
       - name: Run instructions
         working-directory: typescript-client
         run: npm run test:instructions
+
+  payments-toolkit:
+    name: Payments Toolkit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup environment
+        uses: ./.github/actions/setup
+        with:
+          example: toolkits/payments
+          solana-cli-version: ${{ env.SOLANA_CLI_VERSION }}
+          photon-indexer: "true"
+
+      - name: Install dependencies
+        working-directory: toolkits/payments
+        run: npm install
+
+      - name: Start test validator
+        run: |
+          light test-validator &
+          for i in $(seq 1 60); do
+            curl -s http://127.0.0.1:8784/health && break
+            sleep 2
+          done
+
+      - name: Run tests
+        working-directory: toolkits/payments
+        run: npm run test:all
+
+  gasless-transactions-ts:
+    name: Gasless Transactions (TypeScript)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup environment
+        uses: ./.github/actions/setup
+        with:
+          example: toolkits/gasless-transactions/typescript
+          solana-cli-version: ${{ env.SOLANA_CLI_VERSION }}
+          photon-indexer: "true"
+
+      - name: Install dependencies
+        working-directory: toolkits/gasless-transactions/typescript
+        run: npm install
+
+      - name: Start test validator
+        run: |
+          light test-validator &
+          for i in $(seq 1 60); do
+            curl -s http://127.0.0.1:8784/health && break
+            sleep 2
+          done
+
+      - name: Run tests
+        working-directory: toolkits/gasless-transactions/typescript
+        run: npm run test:all
diff --git a/toolkits/README.md b/toolkits/README.md
@@ -8,9 +8,10 @@ Stablecoin payment examples using the Light Token interface APIs. Same stablecoi
 See the [payments README](payments/README.md) for API comparison and setup.
 
 **Send payments**
-- **[send-action](payments/send/send-action.ts)** — Send tokens. One call handles loading and recipient account creation.
-- **[send-instruction](payments/send/send-instruction.ts)** — Same transfer, but returns raw instructions for custom transaction building.
-- **[batch-send](payments/send/batch-send.ts)** — Pay multiple recipients in one transaction
+- **[basic-send-action](payments/send/basic-send-action.ts)** — Send tokens. One call handles loading and recipient account creation.
+- **[basic-send-instruction](payments/send/basic-send-instruction.ts)** — Same transfer, but returns raw instructions for custom transaction building.
+- **[batch-send-action](payments/send/batch-send-action.ts)** — Pay multiple recipients sequentially
+- **[batch-send-instruction](payments/send/batch-send-instruction.ts)** — Pay multiple recipients in one transaction
 - **[payment-with-memo](payments/send/payment-with-memo.ts)** — Attach an invoice ID or payment reference to a transfer
 - **[sign-all-transactions](payments/send/sign-all-transactions.ts)** — Sign all transactions with one wallet approval. Shows parallel load optimization.
 
@@ -29,7 +30,7 @@ See the [payments README](payments/README.md) for API comparison and setup.
 - **[delegate-approve](payments/spend-permissions/delegate-approve.ts)** — Let a delegate spend tokens on your behalf
 - **[delegate-revoke](payments/spend-permissions/delegate-revoke.ts)** — Revoke delegate access
 - **[delegate-check](payments/spend-permissions/delegate-check.ts)** — Check current delegation status and remaining allowance
-- **[delegate-full-flow](payments/spend-permissions/delegate-full-flow.ts)** — Approve, check, and revoke in one script
+- **[delegate-transfer](payments/spend-permissions/delegate-transfer.ts)** — Delegate transfers tokens on behalf of owner
 
 ### Sign with Privy
 
@@ -53,6 +54,13 @@ Abstract SOL fees so users never hold SOL. Set your application as the fee payer
 - **[TypeScript](gasless-transactions/typescript/)** — Gasless transfer with separate fee payer
 - **[Rust](gasless-transactions/rust/)** — Gasless transfer with separate fee payer
 
+### [Nullifier Program](nullifier-program/)
+
+For some use cases, such as sending payments, you might want to prevent your onchain instruction from being executed more than once. The nullifier program utility solves this for you. We also deployed a reference implementation to public networks so you can get started quickly.
+- **[TypeScript example](nullifier-program/examples/action-create-nullifier.ts)**
+- **[Rust example](nullifier-program/examples/rust/src/main.rs)**
+- **[Documentation](https://www.zkcompression.com/compressed-pdas/guides/how-to-create-nullifier-pdas)**
+
 ## Documentation
 
 - [Light Token overview](https://www.zkcompression.com/light-token/welcome)
diff --git a/toolkits/gasless-transactions/typescript/gasless-transfer.ts b/toolkits/gasless-transactions/typescript/gasless-transfer.ts
@@ -54,7 +54,7 @@ console.log("Recipient Address:", recipient.publicKey.toBase58());
         mint,
         500_000,
         sender.publicKey,
-        recipientAta,
+        recipient.publicKey,
     );
 
     // Send — sponsor pays fees, sender authorizes transfer
diff --git a/toolkits/gasless-transactions/typescript/package.json b/toolkits/gasless-transactions/typescript/package.json
@@ -4,10 +4,11 @@
     "description": "Gasless transactions — abstract SOL fees so users never hold SOL",
     "type": "module",
     "scripts": {
+        "test:all": "tsx gasless-transfer.ts",
         "gasless-transfer": "tsx gasless-transfer.ts"
     },
     "dependencies": {
-        "@lightprotocol/compressed-token": "^0.23.0-beta.10",
-        "@lightprotocol/stateless.js": "^0.23.0-beta.10"
+        "@lightprotocol/compressed-token": "^0.23.0-beta.12",
+        "@lightprotocol/stateless.js": "^0.23.0-beta.12"
     }
 }
diff --git a/toolkits/payments/README.md b/toolkits/payments/README.md
@@ -27,13 +27,12 @@ Light Token reduces account creation cost by 200x compared to SPL. Transfer cost
 
 ### Send payments
 
-| File | Description | Key function |
-|:-----|:------------|:-------------|
-| [send-action.ts](send/send-action.ts) | Send tokens. One call handles loading and recipient account creation. | `transferInterface` |
-| [send-instruction.ts](send/send-instruction.ts) | Same transfer, but returns raw instructions for custom transaction building. | `createTransferInterfaceInstructions` |
-| [payment-with-memo.ts](send/payment-with-memo.ts) | Attach an invoice ID or payment reference. Reads it back from transaction logs. | `createTransferInterfaceInstructions`, `sliceLast` |
-| [batch-send.ts](send/batch-send.ts) | Pay multiple recipients in one transaction. | `createTransferInterfaceInstructions`, `createAtaInterfaceIdempotent` |
-| [sign-all-transactions.ts](send/sign-all-transactions.ts) | Sign all transactions with one wallet approval. Shows parallel load optimization. | `signAllTransactions`, `sliceLast` |
+| Example | Description | Action | Instruction |
+|:--------|:------------|:-------|:------------|
+| Basic send | Send tokens to a recipient. | [action](send/basic-send-action.ts) | [instruction](send/basic-send-instruction.ts) |
+| Batch send | Pay multiple recipients in one transaction. | [action](send/batch-send-action.ts) | [instruction](send/batch-send-instruction.ts) |
+| Payment with memo | Attach an invoice ID or payment reference. | | [instruction](send/payment-with-memo.ts) |
+| Sign all transactions | Sign all transactions with one wallet approval. | | [instruction](send/sign-all-transactions.ts) |
 | [verify-address.ts](verify/verify-address.ts) | Confirm a recipient account exists before sending. | `getAssociatedTokenAddressInterface`, `getAtaInterface` |
 
 > For gasless transfers (separate fee payer / sponsor), see the [gasless-transactions](../gasless-transactions/) toolkit.
@@ -81,9 +80,9 @@ light test-validator
 Run any script:
 
 ```bash
-npx tsx send/send-action.ts
+npx tsx send/basic-send-action.ts
 npx tsx send/payment-with-memo.ts
-npx tsx send/batch-send.ts
+npx tsx send/batch-send-action.ts
 npx tsx spend-permissions/delegate-approve.ts
 ```
 
diff --git a/toolkits/payments/package.json b/toolkits/payments/package.json
@@ -4,11 +4,12 @@
     "description": "Light Token Payments Toolkit Examples",
     "type": "module",
     "scripts": {
-        "test:all": "tsx send/send-action.ts && tsx send/send-instruction.ts && tsx send/payment-with-memo.ts && tsx send/batch-send.ts && tsx send/sign-all-transactions.ts && tsx receive/receive.ts && tsx spend-permissions/delegate-approve.ts && tsx spend-permissions/delegate-revoke.ts && tsx spend-permissions/delegate-check.ts && tsx spend-permissions/delegate-transfer.ts",
-        "send-action": "tsx send/send-action.ts",
-        "send-instruction": "tsx send/send-instruction.ts",
+        "test:all": "tsx send/basic-send-action.ts && tsx send/basic-send-instruction.ts && tsx send/payment-with-memo.ts && tsx send/batch-send-action.ts && tsx send/batch-send-instruction.ts && tsx send/sign-all-transactions.ts && tsx receive/receive.ts && tsx spend-permissions/delegate-approve.ts && tsx spend-permissions/delegate-revoke.ts && tsx spend-permissions/delegate-check.ts && tsx spend-permissions/delegate-transfer.ts",
+        "basic-send-action": "tsx send/basic-send-action.ts",
+        "basic-send-instruction": "tsx send/basic-send-instruction.ts",
         "payment-with-memo": "tsx send/payment-with-memo.ts",
-        "batch-send": "tsx send/batch-send.ts",
+        "batch-send-action": "tsx send/batch-send-action.ts",
+        "batch-send-instruction": "tsx send/batch-send-instruction.ts",
         "sign-all-transactions": "tsx send/sign-all-transactions.ts",
         "receive": "tsx receive/receive.ts",
         "get-balance": "tsx verify/get-balance.ts",
diff --git a/typescript-client/actions/delegate-transfer.ts b/typescript-client/actions/delegate-transfer.ts
@@ -3,13 +3,19 @@ import { Keypair } from "@solana/web3.js";
 import { createRpc } from "@lightprotocol/stateless.js";
 import {
     createMintInterface,
-    mintToCompressed,
+    createAtaInterface,
     getAssociatedTokenAddressInterface,
 } from "@lightprotocol/compressed-token";
 import {
     approveInterface,
     transferInterface,
+    wrap,
 } from "@lightprotocol/compressed-token/unified";
+import {
+    TOKEN_PROGRAM_ID,
+    createAssociatedTokenAccount,
+    mintTo,
+} from "@solana/spl-token";
 import { homedir } from "os";
 import { readFileSync } from "fs";
 
@@ -26,12 +32,41 @@ const payer = Keypair.fromSecretKey(
 );
 
 (async function () {
-    const { mint } = await createMintInterface(rpc, payer, payer, null, 9);
-    await mintToCompressed(rpc, payer, mint, payer, [
-        { recipient: payer.publicKey, amount: 1_000_000_000n },
-    ]);
+    // Setup: Create SPL mint, fund, wrap into Light ATA (hot balance)
+    const { mint } = await createMintInterface(
+        rpc,
+        payer,
+        payer,
+        null,
+        9,
+        undefined,
+        undefined,
+        TOKEN_PROGRAM_ID
+    );
+    const splAta = await createAssociatedTokenAccount(
+        rpc,
+        payer,
+        mint,
+        payer.publicKey,
+        undefined,
+        TOKEN_PROGRAM_ID
+    );
+    await mintTo(rpc, payer, mint, splAta, payer, 1_000_000_000);
+    await createAtaInterface(rpc, payer, mint, payer.publicKey);
+    const senderAta = getAssociatedTokenAddressInterface(
+        mint,
+        payer.publicKey
+    );
+    await wrap(
+        rpc,
+        payer,
+        splAta,
+        senderAta,
+        payer,
+        mint,
+        BigInt(1_000_000_000)
+    );
 
-    const senderAta = getAssociatedTokenAddressInterface(mint, payer.publicKey);
     const delegate = Keypair.generate();
     const recipient = Keypair.generate();
 
@@ -57,7 +92,6 @@ const payer = Keypair.fromSecretKey(
         delegate,
         200_000_000,
         undefined,
-        undefined,
         { owner: payer.publicKey }
     );
 
diff --git a/typescript-client/actions/unwrap.ts b/typescript-client/actions/unwrap.ts
@@ -4,13 +4,13 @@ import { createRpc } from "@lightprotocol/stateless.js";
 import {
     createMintInterface,
     createAtaInterface,
-    mintToInterface,
     getAssociatedTokenAddressInterface,
 } from "@lightprotocol/compressed-token";
-import { unwrap } from "@lightprotocol/compressed-token/unified";
+import { wrap, unwrap } from "@lightprotocol/compressed-token/unified";
 import {
+    TOKEN_PROGRAM_ID,
     createAssociatedTokenAccount,
-    TOKEN_2022_PROGRAM_ID,
+    mintTo,
 } from "@solana/spl-token";
 import { homedir } from "os";
 import { readFileSync } from "fs";
@@ -28,24 +28,35 @@ const payer = Keypair.fromSecretKey(
 );
 
 (async function () {
-    // Setup: Create and mint tokens to light-token associated token account
-    const { mint } = await createMintInterface(rpc, payer, payer, null, 9);
-    await createAtaInterface(rpc, payer, mint, payer.publicKey);
-    const destination = getAssociatedTokenAddressInterface(
-        mint,
-        payer.publicKey
+    // Setup: Create SPL mint, fund SPL ATA, wrap into Light ATA
+    const { mint } = await createMintInterface(
+        rpc,
+        payer,
+        payer,
+        null,
+        9,
+        undefined,
+        undefined,
+        TOKEN_PROGRAM_ID
     );
-    await mintToInterface(rpc, payer, mint, destination, payer, 1000);
-
-    // Unwrap light-token to SPL associated token account
     const splAta = await createAssociatedTokenAccount(
         rpc,
         payer,
         mint,
         payer.publicKey,
         undefined,
-        TOKEN_2022_PROGRAM_ID
+        TOKEN_PROGRAM_ID
     );
+    await mintTo(rpc, payer, mint, splAta, payer, 1000);
+
+    await createAtaInterface(rpc, payer, mint, payer.publicKey);
+    const lightTokenAta = getAssociatedTokenAddressInterface(
+        mint,
+        payer.publicKey
+    );
+    await wrap(rpc, payer, splAta, lightTokenAta, payer, mint, BigInt(1000));
+
+    // Unwrap: move tokens back from light-token to SPL ATA
     const tx = await unwrap(rpc, payer, splAta, payer, mint, 500);
 
     console.log("Tx:", tx);
diff --git a/typescript-client/actions/wrap.ts b/typescript-client/actions/wrap.ts
@@ -4,15 +4,13 @@ import { createRpc } from "@lightprotocol/stateless.js";
 import {
     createMintInterface,
     createAtaInterface,
-    mintToInterface,
-    decompressInterface,
-    wrap,
     getAssociatedTokenAddressInterface,
-    createAtaInterfaceIdempotent,
 } from "@lightprotocol/compressed-token";
+import { wrap } from "@lightprotocol/compressed-token/unified";
 import {
+    TOKEN_PROGRAM_ID,
     createAssociatedTokenAccount,
-    TOKEN_2022_PROGRAM_ID,
+    mintTo,
 } from "@solana/spl-token";
 import { homedir } from "os";
 import { readFileSync } from "fs";
@@ -30,30 +28,33 @@ const payer = Keypair.fromSecretKey(
 );
 
 (async function () {
-    // Setup: Get SPL tokens (needed to wrap)
-    const { mint } = await createMintInterface(rpc, payer, payer, null, 9);
-    await createAtaInterface(rpc, payer, mint, payer.publicKey);
-    const destination = getAssociatedTokenAddressInterface(
-        mint,
-        payer.publicKey
+    // Setup: Create SPL mint and fund an SPL ATA
+    const { mint } = await createMintInterface(
+        rpc,
+        payer,
+        payer,
+        null,
+        9,
+        undefined,
+        undefined,
+        TOKEN_PROGRAM_ID
     );
-    await mintToInterface(rpc, payer, mint, destination, payer, 1000);
     const splAta = await createAssociatedTokenAccount(
         rpc,
         payer,
         mint,
         payer.publicKey,
         undefined,
-        TOKEN_2022_PROGRAM_ID
+        TOKEN_PROGRAM_ID
     );
-    await decompressInterface(rpc, payer, payer, mint, 1000);
+    await mintTo(rpc, payer, mint, splAta, payer, 1000);
 
-    // Wrap SPL tokens to light-token associated token account
+    // Create light-token ATA and wrap SPL tokens into it
+    await createAtaInterface(rpc, payer, mint, payer.publicKey);
     const lightTokenAta = getAssociatedTokenAddressInterface(
         mint,
         payer.publicKey
     );
-    await createAtaInterfaceIdempotent(rpc, payer, mint, payer.publicKey);
 
     const tx = await wrap(rpc, payer, splAta, lightTokenAta, payer, mint, 500);
 
diff --git a/typescript-client/instructions/load-ata.ts b/typescript-client/instructions/load-ata.ts
diff --git a/typescript-client/instructions/unwrap.ts b/typescript-client/instructions/unwrap.ts
diff --git a/typescript-client/instructions/wrap.ts b/typescript-client/instructions/wrap.ts
diff --git a/typescript-client/package.json b/typescript-client/package.json

Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,11 @@`
`4`	`4`	`"description": "Gasless transactions — abstract SOL fees so users never hold SOL",`
`5`	`5`	`"type": "module",`
`6`	`6`	`"scripts": {`
	`7`	`+ "test:all": "tsx gasless-transfer.ts",`
`7`	`8`	`"gasless-transfer": "tsx gasless-transfer.ts"`
`8`	`9`	`},`
`9`	`10`	`"dependencies": {`
`10`		`- "@lightprotocol/compressed-token": "^0.23.0-beta.10",`
`11`		`- "@lightprotocol/stateless.js": "^0.23.0-beta.10"`
	`11`	`+ "@lightprotocol/compressed-token": "^0.23.0-beta.12",`
	`12`	`+ "@lightprotocol/stateless.js": "^0.23.0-beta.12"`
`12`	`13`	`}`
`13`	`14`	`}`