privacycash 1.1.19 → 1.1.20

package/dist/deposit.d.ts

@@ -1,5 +1,5 @@
-import { Connection, PublicKey, VersionedTransaction } from '@solana/web3.js';
 import * as hasher from '@lightprotocol/hasher.rs';
+import { Connection, PublicKey, VersionedTransaction } from '@solana/web3.js';
 import { EncryptionService } from './utils/encryption.js';
 type DepositParams = {
     publicKey: PublicKey;

package/dist/deposit.js

@@ -1,15 +1,15 @@
-import { PublicKey, TransactionInstruction, SystemProgram, ComputeBudgetProgram, VersionedTransaction, TransactionMessage, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { ComputeBudgetProgram, LAMPORTS_PER_SOL, PublicKey, SystemProgram, TransactionInstruction, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
 import BN from 'bn.js';
-import { Utxo } from './models/utxo.js';
-import { fetchMerkleProof, findNullifierPDAs, getExtDataHash, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs } from './utils/utils.js';
-import { prove, parseProofToBytesArray, parseToBytesArray } from './utils/prover.js';
-import { MerkleTree } from './utils/merkle_tree.js';
-import { serializeProofAndExtData } from './utils/encryption.js';
-import { Keypair as UtxoKeypair } from './models/keypair.js';
 import { getUtxos } from './getUtxos.js';
-import { FIELD_SIZE, FEE_RECIPIENT, MERKLE_TREE_DEPTH, RELAYER_API_URL, PROGRAM_ID, ALT_ADDRESS } from './utils/constants.js';
+import { Keypair as UtxoKeypair } from './models/keypair.js';
+import { Utxo } from './models/utxo.js';
 import { useExistingALT } from './utils/address_lookup_table.js';
+import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, MERKLE_TREE_DEPTH, PROGRAM_ID, RELAYER_API_URL } from './utils/constants.js';
+import { serializeProofAndExtData } from './utils/encryption.js';
 import { logger } from './utils/logger.js';
+import { MerkleTree } from './utils/merkle_tree.js';
+import { parseProofToBytesArray, parseToBytesArray, prove } from './utils/prover.js';
+import { fetchMerkleProof, findCrossCheckNullifierPDAs, findNullifierPDAs, getExtDataHash, getProgramAccounts, queryRemoteTreeState } from './utils/utils.js';
 // Function to relay pre-signed deposit transaction to indexer backend
 async function relayDepositToIndexer(signedTransaction, publicKey, referrer) {
     try {
@@ -68,10 +68,6 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
     const { treeAccount, treeTokenAccount, globalConfigAccount } = getProgramAccounts();
     // Create the merkle tree with the pre-initialized poseidon hash
     const tree = new MerkleTree(MERKLE_TREE_DEPTH, lightWasm);
-    // Initialize root and nextIndex variables
-    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState();
-    logger.debug(`Using tree root: ${root}`);
-    logger.debug(`New UTXOs will be inserted at indices: ${currentNextIndex} and ${currentNextIndex + 1}`);
     // Generate a deterministic private key derived from the wallet keypair
     // const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();
     const utxoPrivateKey = encryptionService.getUtxoPrivateKeyV2();
@@ -88,7 +84,12 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
     let inputs;
     let inputMerklePathIndices;
     let inputMerklePathElements;
+    let root;
+    let nextIndex;
     if (existingUnspentUtxos.length === 0) {
+        const treeState = await queryRemoteTreeState();
+        root = treeState.root;
+        nextIndex = treeState.nextIndex;
         // Scenario 1: Fresh deposit with dummy inputs - add new funds to the system
         extAmount = amount_in_lamports;
         outputAmount = new BN(amount_in_lamports).sub(new BN(fee_amount_in_lamports)).toString();
@@ -144,15 +145,18 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
         ];
         // Fetch Merkle proofs for real UTXOs
         const firstUtxoCommitment = await firstUtxo.getCommitment();
-        const firstUtxoMerkleProof = await fetchMerkleProof(firstUtxoCommitment);
-        let secondUtxoMerkleProof;
+        let commitmentsToFetch = [firstUtxoCommitment];
         if (secondUtxo.amount.gt(new BN(0))) {
             // Second UTXO is real, fetch its proof
             const secondUtxoCommitment = await secondUtxo.getCommitment();
-            secondUtxoMerkleProof = await fetchMerkleProof(secondUtxoCommitment);
+            commitmentsToFetch.push(secondUtxoCommitment);
             logger.debug('\nSecond UTXO to be consolidated:');
             await secondUtxo.log();
         }
+        let data = await fetchMerkleProof(commitmentsToFetch);
+        root = data.root;
+        nextIndex = data.nextIndex;
+        let [firstUtxoMerkleProof, secondUtxoMerkleProof] = data.proofs;
         // Use the real pathIndices from API for real inputs, mock index for dummy input
         inputMerklePathIndices = [
             firstUtxo.index || 0, // Use the real UTXO's index  
@@ -178,13 +182,13 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
             lightWasm,
             amount: outputAmount,
             keypair: utxoKeypair,
-            index: currentNextIndex // This UTXO will be inserted at currentNextIndex
+            index: nextIndex // This UTXO will be inserted at currentNextIndex
         }), // Output with value (either deposit amount minus fee, or input amount minus fee)
         new Utxo({
             lightWasm,
             amount: '0',
             keypair: utxoKeypair,
-            index: currentNextIndex + 1 // This UTXO will be inserted at currentNextIndex + 1
+            index: nextIndex + 1 // This UTXO will be inserted at currentNextIndex + 1
         }) // Empty UTXO
     ];
     // Verify this matches the circuit balance equation: sumIns + publicAmount = sumOuts

package/dist/depositSPL.d.ts

@@ -1,5 +1,5 @@
-import { Connection, PublicKey, VersionedTransaction } from '@solana/web3.js';
 import * as hasher from '@lightprotocol/hasher.rs';
+import { Connection, PublicKey, VersionedTransaction } from '@solana/web3.js';
 import { EncryptionService } from './utils/encryption.js';
 type DepositParams = {
     mintAddress: PublicKey | string;

package/dist/depositSPL.js

@@ -1,16 +1,16 @@
-import { PublicKey, TransactionInstruction, SystemProgram, ComputeBudgetProgram, VersionedTransaction, TransactionMessage } from '@solana/web3.js';
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAccount, getAssociatedTokenAddressSync } from '@solana/spl-token';
+import { ComputeBudgetProgram, PublicKey, SystemProgram, TransactionInstruction, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
 import BN from 'bn.js';
-import { Utxo } from './models/utxo.js';
-import { fetchMerkleProof, findNullifierPDAs, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs, getExtDataHash, getMintAddressField } from './utils/utils.js';
-import { prove, parseProofToBytesArray, parseToBytesArray } from './utils/prover.js';
-import { MerkleTree } from './utils/merkle_tree.js';
-import { serializeProofAndExtData } from './utils/encryption.js';
-import { Keypair as UtxoKeypair } from './models/keypair.js';
 import { getUtxosSPL } from './getUtxosSPL.js';
-import { FIELD_SIZE, FEE_RECIPIENT, MERKLE_TREE_DEPTH, RELAYER_API_URL, PROGRAM_ID, ALT_ADDRESS, tokens } from './utils/constants.js';
+import { Keypair as UtxoKeypair } from './models/keypair.js';
+import { Utxo } from './models/utxo.js';
 import { useExistingALT } from './utils/address_lookup_table.js';
+import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, MERKLE_TREE_DEPTH, PROGRAM_ID, RELAYER_API_URL, tokens } from './utils/constants.js';
+import { serializeProofAndExtData } from './utils/encryption.js';
 import { logger } from './utils/logger.js';
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, getAccount } from '@solana/spl-token';
+import { MerkleTree } from './utils/merkle_tree.js';
+import { parseProofToBytesArray, parseToBytesArray, prove } from './utils/prover.js';
+import { fetchMerkleProof, findCrossCheckNullifierPDAs, findNullifierPDAs, getExtDataHash, getMintAddressField, getProgramAccounts, queryRemoteTreeState } from './utils/utils.js';
 // Function to relay pre-signed deposit transaction to indexer backend
 async function relayDepositToIndexer({ signedTransaction, publicKey, referrer, mintAddress }) {
     try {
@@ -106,10 +106,6 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     const { globalConfigAccount } = getProgramAccounts();
     // Create the merkle tree with the pre-initialized poseidon hash
     const tree = new MerkleTree(MERKLE_TREE_DEPTH, lightWasm);
-    // Initialize root and nextIndex variables
-    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState(token.name);
-    logger.debug(`Using tree root: ${root}`);
-    logger.debug(`New UTXOs will be inserted at indices: ${currentNextIndex} and ${currentNextIndex + 1}`);
     // Generate a deterministic private key derived from the wallet keypair
     // const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();
     const utxoPrivateKey = encryptionService.getUtxoPrivateKeyV2();
@@ -126,7 +122,12 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     let inputs;
     let inputMerklePathIndices;
     let inputMerklePathElements;
+    let root;
+    let nextIndex;
     if (mintUtxos.length === 0) {
+        const treeState = await queryRemoteTreeState(token.name);
+        root = treeState.root;
+        nextIndex = treeState.nextIndex;
         // Scenario 1: Fresh deposit with dummy inputs - add new funds to the system
         extAmount = base_units;
         outputAmount = new BN(base_units).sub(new BN(fee_base_units)).toString();
@@ -184,15 +185,18 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
         ];
         // Fetch Merkle proofs for real UTXOs
         const firstUtxoCommitment = await firstUtxo.getCommitment();
-        const firstUtxoMerkleProof = await fetchMerkleProof(firstUtxoCommitment, token.name);
-        let secondUtxoMerkleProof;
+        let commitmentsToFetch = [firstUtxoCommitment];
         if (secondUtxo.amount.gt(new BN(0))) {
             // Second UTXO is real, fetch its proof
             const secondUtxoCommitment = await secondUtxo.getCommitment();
-            secondUtxoMerkleProof = await fetchMerkleProof(secondUtxoCommitment, token.name);
+            commitmentsToFetch.push(secondUtxoCommitment);
             logger.debug('\nSecond UTXO to be consolidated:');
             await secondUtxo.log();
         }
+        let data = await fetchMerkleProof(commitmentsToFetch, token.name);
+        root = data.root;
+        nextIndex = data.nextIndex;
+        let [firstUtxoMerkleProof, secondUtxoMerkleProof] = data.proofs;
         // Use the real pathIndices from API for real inputs, mock index for dummy input
         inputMerklePathIndices = [
             firstUtxo.index || 0, // Use the real UTXO's index  
@@ -218,14 +222,14 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
             lightWasm,
             amount: outputAmount,
             keypair: utxoKeypair,
-            index: currentNextIndex, // This UTXO will be inserted at currentNextIndex
+            index: nextIndex, // This UTXO will be inserted at currentNextIndex
             mintAddress: token.pubkey.toString()
         }), // Output with value (either deposit amount minus fee, or input amount minus fee)
         new Utxo({
             lightWasm,
             amount: '0',
             keypair: utxoKeypair,
-            index: currentNextIndex + 1, // This UTXO will be inserted at currentNextIndex
+            index: nextIndex + 1, // This UTXO will be inserted at currentNextIndex
             mintAddress: token.pubkey.toString()
         }) // Empty UTXO
     ];

package/dist/models/utxo.d.ts

@@ -4,9 +4,9 @@
  * Provides UTXO functionality for the ZK Cash system
  * Based on: https://github.com/tornadocash/tornado-nova
  */
+import * as hasher from '@lightprotocol/hasher.rs';
 import BN from 'bn.js';
 import { Keypair } from './keypair.js';
-import * as hasher from '@lightprotocol/hasher.rs';
 /**
  * Simplified Utxo class inspired by Tornado Cash Nova
  * Based on: https://github.com/tornadocash/tornado-nova/blob/f9264eeffe48bf5e04e19d8086ee6ec58cdf0d9e/src/utxo.js
@@ -39,7 +39,7 @@ export declare class Utxo {
         mintAddress?: string;
         version?: 'v1' | 'v2';
     });
-    getCommitment(): Promise<string>;
+    getCommitment(): string;
     getNullifier(): Promise<string>;
     /**
      * Log all the UTXO's public properties and derived values in JSON format

package/dist/models/utxo.js

@@ -4,11 +4,11 @@
  * Provides UTXO functionality for the ZK Cash system
  * Based on: https://github.com/tornadocash/tornado-nova
  */
+import { PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
-import { Keypair } from './keypair.js';
 import { ethers } from 'ethers';
 import { getMintAddressField } from '../utils/utils.js';
-import { PublicKey } from '@solana/web3.js';
+import { Keypair } from './keypair.js';
 /**
  * Simplified Utxo class inspired by Tornado Cash Nova
  * Based on: https://github.com/tornadocash/tornado-nova/blob/f9264eeffe48bf5e04e19d8086ee6ec58cdf0d9e/src/utxo.js
@@ -41,7 +41,7 @@ export class Utxo {
         this.mintAddress = mintAddress;
         this.version = version;
     }
-    async getCommitment() {
+    getCommitment() {
         // return this.lightWasm.poseidonHashString([this.amount.toString(), this.keypair.pubkey.toString(), this.blinding.toString(), this.mintAddress]);
         const mintAddressField = getMintAddressField(new PublicKey(this.mintAddress));
         return this.lightWasm.poseidonHashString([

package/dist/utils/utils.d.ts

@@ -4,9 +4,9 @@
  * Provides common utility functions for the ZK Cash system
  * Based on: https://github.com/tornadocash/tornado-nova
  */
+import { PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 import { Utxo } from '../models/utxo.js';
-import { PublicKey } from '@solana/web3.js';
 /**
  * Calculate deposit fee based on deposit amount and fee rate
  * @param depositAmount Amount being deposited in lamports
@@ -40,9 +40,14 @@ export declare function getExtDataHash(extData: {
     feeRecipient: string | PublicKey;
     mintAddress: string | PublicKey;
 }): Uint8Array;
-export declare function fetchMerkleProof(commitment: string, tokenName?: string): Promise<{
+type Proof = {
     pathElements: string[];
     pathIndices: number[];
+};
+export declare function fetchMerkleProof(commitments: string[], tokenName?: string): Promise<{
+    proofs: Proof[];
+    root: string;
+    nextIndex: number;
 }>;
 export declare function findNullifierPDAs(proof: any): {
     nullifier0PDA: PublicKey;
@@ -62,3 +67,4 @@ export declare function findCrossCheckNullifierPDAs(proof: any): {
     nullifier3PDA: PublicKey;
 };
 export declare function getMintAddressField(mint: PublicKey): string;
+export {};

package/dist/utils/utils.js

@@ -4,13 +4,13 @@
  * Provides common utility functions for the ZK Cash system
  * Based on: https://github.com/tornadocash/tornado-nova
  */
-import BN from 'bn.js';
-import * as borsh from 'borsh';
 import { sha256 } from '@ethersproject/sha2';
 import { PublicKey } from '@solana/web3.js';
-import { RELAYER_API_URL, PROGRAM_ID } from './constants.js';
-import { logger } from './logger.js';
+import BN from 'bn.js';
+import * as borsh from 'borsh';
 import { getConfig } from '../config.js';
+import { PROGRAM_ID, RELAYER_API_URL } from './constants.js';
+import { logger } from './logger.js';
 /**
  * Calculate deposit fee based on deposit amount and fee rate
  * @param depositAmount Amount being deposited in lamports
@@ -91,23 +91,23 @@ export function getExtDataHash(extData) {
     return Buffer.from(hashHex.slice(2), 'hex');
 }
 // Function to fetch Merkle proof from API for a given commitment
-export async function fetchMerkleProof(commitment, tokenName) {
+export async function fetchMerkleProof(commitments, tokenName) {
     try {
-        logger.debug(`Fetching Merkle proof for commitment: ${commitment}`);
-        let url = `${RELAYER_API_URL}/merkle/proof/${commitment}`;
+        logger.debug(`Fetching Merkle proof for commitment: ${commitments.join(', ')} with token: ${tokenName || 'N/A'}`);
+        let url = `${RELAYER_API_URL}/merkle/proofv2/?commitments=${commitments.join(',')}`;
         if (tokenName) {
-            url += '?token=' + tokenName;
+            url += '&token=' + tokenName;
         }
+        logger.debug(`Fetching Merkle proof from URL: ${url}`);
         const response = await fetch(url);
         if (!response.ok) {
             throw new Error(`Failed to fetch Merkle proof: ${url}`);
         }
         const data = await response.json();
-        logger.debug(`✓ Fetched Merkle proof with ${data.pathElements.length} elements`);
         return data;
     }
     catch (error) {
-        console.error(`Failed to fetch Merkle proof for commitment ${commitment}:`, error);
+        console.error(`Failed to fetch Merkle proof for commitments ${commitments.join(', ')}:`, error);
         throw error;
     }
 }

package/dist/withdraw.d.ts

@@ -1,5 +1,5 @@
-import { Connection, PublicKey } from '@solana/web3.js';
 import * as hasher from '@lightprotocol/hasher.rs';
+import { Connection, PublicKey } from '@solana/web3.js';
 import { EncryptionService } from './utils/encryption.js';
 type WithdrawParams = {
     publicKey: PublicKey;

package/dist/withdraw.js

@@ -4,12 +4,12 @@ import { Buffer } from 'buffer';
 import { Keypair as UtxoKeypair } from './models/keypair.js';
 import { Utxo } from './models/utxo.js';
 import { parseProofToBytesArray, parseToBytesArray, prove } from './utils/prover.js';
-import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, RELAYER_API_URL, MERKLE_TREE_DEPTH } from './utils/constants.js';
+import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, RELAYER_API_URL } from './utils/constants.js';
 import { serializeProofAndExtData } from './utils/encryption.js';
-import { fetchMerkleProof, findNullifierPDAs, getExtDataHash, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs } from './utils/utils.js';
+import { fetchMerkleProof, findCrossCheckNullifierPDAs, findNullifierPDAs, getExtDataHash, getProgramAccounts } from './utils/utils.js';
+import { getConfig } from './config.js';
 import { getUtxos } from './getUtxos.js';
 import { logger } from './utils/logger.js';
-import { getConfig } from './config.js';
 // Indexer API endpoint
 // Function to submit withdraw request to indexer backend
 async function submitWithdrawToIndexer(params) {
@@ -41,10 +41,6 @@ export async function withdraw({ recipient, lightWasm, storage, publicKey, conne
     let isPartial = false;
     logger.debug('Encryption key generated from user keypair');
     const { treeAccount, treeTokenAccount, globalConfigAccount } = getProgramAccounts();
-    // Get current tree state
-    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState();
-    logger.debug(`Using tree root: ${root}`);
-    logger.debug(`New UTXOs will be inserted at indices: ${currentNextIndex} and ${currentNextIndex + 1}`);
     // Generate a deterministic private key derived from the wallet keypair
     const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();
     // Create a UTXO keypair that will be used for all inputs and outputs
@@ -89,20 +85,25 @@ export async function withdraw({ recipient, lightWasm, storage, publicKey, conne
     const changeAmount = totalInputAmount.sub(new BN(amount_in_lamports)).sub(new BN(fee_in_lamports));
     logger.debug(`Withdrawing ${amount_in_lamports} lamports with ${fee_in_lamports} fee, ${changeAmount.toString()} as change`);
     // Get Merkle proofs for both input UTXOs
-    const inputMerkleProofs = await Promise.all(inputs.map(async (utxo, index) => {
-        // For dummy UTXO (amount is 0), use a zero-filled proof
-        if (utxo.amount.eq(new BN(0))) {
-            return {
-                pathElements: [...new Array(MERKLE_TREE_DEPTH).fill("0")],
-                pathIndices: Array(MERKLE_TREE_DEPTH).fill(0)
-            };
-        }
-        // For real UTXOs, fetch the proof from API
-        const commitment = await utxo.getCommitment();
-        return fetchMerkleProof(commitment);
-    }));
+    let commitmentsToFetch = inputs.map(utxo => utxo.getCommitment());
+    console.log('commitmentsToFetch', commitmentsToFetch);
+    const { root, nextIndex, proofs } = await fetchMerkleProof(commitmentsToFetch);
+    // const inputMerkleProofs = await Promise.all(
+    //     inputs.map(async (utxo, index) => {
+    //         // For dummy UTXO (amount is 0), use a zero-filled proof
+    //         if (utxo.amount.eq(new BN(0))) {
+    //             return {
+    //                 pathElements: [...new Array(MERKLE_TREE_DEPTH).fill("0")],
+    //                 pathIndices: Array(MERKLE_TREE_DEPTH).fill(0)
+    //             };
+    //         }
+    //         // For real UTXOs, fetch the proof from API
+    //         const commitment = await utxo.getCommitment();
+    //         return fetchMerkleProof(commitment);
+    //     })
+    // );
     // Extract path elements and indices
-    const inputMerklePathElements = inputMerkleProofs.map(proof => proof.pathElements);
+    const inputMerklePathElements = proofs.map(proof => proof.pathElements);
     const inputMerklePathIndices = inputs.map(utxo => utxo.index || 0);
     // Create outputs: first output is change, second is dummy (required by protocol)
     const outputs = [
@@ -110,13 +111,13 @@ export async function withdraw({ recipient, lightWasm, storage, publicKey, conne
             lightWasm,
             amount: changeAmount.toString(),
             keypair: utxoKeypairV2,
-            index: currentNextIndex
+            index: nextIndex
         }), // Change output
         new Utxo({
             lightWasm,
             amount: '0',
             keypair: utxoKeypairV2,
-            index: currentNextIndex + 1
+            index: nextIndex + 1
         }) // Empty UTXO
     ];
     // For withdrawals, extAmount is negative (funds leaving the system)

package/dist/withdrawSPL.d.ts

@@ -1,5 +1,5 @@
-import { Connection, PublicKey } from '@solana/web3.js';
 import * as hasher from '@lightprotocol/hasher.rs';
+import { Connection, PublicKey } from '@solana/web3.js';
 import { EncryptionService } from './utils/encryption.js';
 type WithdrawParams = {
     publicKey: PublicKey;

package/dist/withdrawSPL.js

@@ -4,13 +4,13 @@ import { Buffer } from 'buffer';
 import { Keypair as UtxoKeypair } from './models/keypair.js';
 import { Utxo } from './models/utxo.js';
 import { parseProofToBytesArray, parseToBytesArray, prove } from './utils/prover.js';
-import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, RELAYER_API_URL, MERKLE_TREE_DEPTH, PROGRAM_ID, tokens } from './utils/constants.js';
+import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, PROGRAM_ID, RELAYER_API_URL, tokens } from './utils/constants.js';
 import { serializeProofAndExtData } from './utils/encryption.js';
-import { fetchMerkleProof, findNullifierPDAs, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs, getMintAddressField, getExtDataHash } from './utils/utils.js';
+import { fetchMerkleProof, findCrossCheckNullifierPDAs, findNullifierPDAs, getExtDataHash, getMintAddressField, getProgramAccounts } from './utils/utils.js';
+import { getAssociatedTokenAddressSync, getMint } from '@solana/spl-token';
+import { getConfig } from './config.js';
 import { getUtxosSPL } from './getUtxosSPL.js';
 import { logger } from './utils/logger.js';
-import { getConfig } from './config.js';
-import { getAssociatedTokenAddressSync, getMint } from '@solana/spl-token';
 // Indexer API endpoint
 // Function to submit withdraw request to indexer backend
 async function submitWithdrawToIndexer(params) {
@@ -71,10 +71,6 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
     // Derive tree account PDA with mint address for SPL (different from SOL version)
     const [treeAccount] = PublicKey.findProgramAddressSync([Buffer.from('merkle_tree'), token.pubkey.toBuffer()], PROGRAM_ID);
     const { globalConfigAccount, treeTokenAccount } = getProgramAccounts();
-    // Get current tree state
-    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState(token.name);
-    logger.debug(`Using tree root: ${root}`);
-    logger.debug(`New UTXOs will be inserted at indices: ${currentNextIndex} and ${currentNextIndex + 1}`);
     // Generate a deterministic private key derived from the wallet keypair
     const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();
     // Create a UTXO keypair that will be used for all inputs and outputs
@@ -119,21 +115,10 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
     // Calculate the change amount (what's left after withdrawal and fee)
     const changeAmount = totalInputAmount.sub(new BN(base_units)).sub(new BN(fee_base_units));
     logger.debug(`Withdrawing ${base_units} lamports with ${fee_base_units} fee, ${changeAmount.toString()} as change`);
-    // Get Merkle proofs for both input UTXOs
-    const inputMerkleProofs = await Promise.all(inputs.map(async (utxo, index) => {
-        // For dummy UTXO (amount is 0), use a zero-filled proof
-        if (utxo.amount.eq(new BN(0))) {
-            return {
-                pathElements: [...new Array(MERKLE_TREE_DEPTH).fill("0")],
-                pathIndices: Array(MERKLE_TREE_DEPTH).fill(0)
-            };
-        }
-        // For real UTXOs, fetch the proof from API
-        const commitment = await utxo.getCommitment();
-        return fetchMerkleProof(commitment, token.name);
-    }));
+    let commitmentsToFetch = inputs.map(utxo => utxo.getCommitment());
+    const { root, nextIndex, proofs } = await fetchMerkleProof(commitmentsToFetch, token.name);
     // Extract path elements and indices
-    const inputMerklePathElements = inputMerkleProofs.map(proof => proof.pathElements);
+    const inputMerklePathElements = proofs.map(proof => proof.pathElements);
     const inputMerklePathIndices = inputs.map(utxo => utxo.index || 0);
     // Create outputs: first output is change, second is dummy (required by protocol)
     const outputs = [
@@ -141,14 +126,14 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
             lightWasm,
             amount: changeAmount.toString(),
             keypair: utxoKeypairV2,
-            index: currentNextIndex,
+            index: nextIndex,
             mintAddress: token.pubkey.toString()
         }), // Change output
         new Utxo({
             lightWasm,
             amount: '0',
             keypair: utxoKeypairV2,
-            index: currentNextIndex + 1,
+            index: nextIndex + 1,
             mintAddress: token.pubkey.toString()
         }) // Empty UTXO
     ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "privacycash",
-  "version": "1.1.19",
+  "version": "1.1.20",
   "description": "",
   "main": "dist/index.js",
   "repository": "https://github.com/Privacy-Cash/privacy-cash-sdk",

package/src/deposit.ts

@@ -1,16 +1,16 @@
-import { Connection, Keypair, PublicKey, TransactionInstruction, SystemProgram, ComputeBudgetProgram, VersionedTransaction, TransactionMessage, LAMPORTS_PER_SOL } from '@solana/web3.js';
-import BN from 'bn.js';
-import { Utxo } from './models/utxo.js';
-import { fetchMerkleProof, findNullifierPDAs, getExtDataHash, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs } from './utils/utils.js';
-import { prove, parseProofToBytesArray, parseToBytesArray } from './utils/prover.js';
 import * as hasher from '@lightprotocol/hasher.rs';
-import { MerkleTree } from './utils/merkle_tree.js';
-import { EncryptionService, serializeProofAndExtData } from './utils/encryption.js';
+import { ComputeBudgetProgram, Connection, LAMPORTS_PER_SOL, PublicKey, SystemProgram, TransactionInstruction, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
+import BN from 'bn.js';
+import { getUtxos } from './getUtxos.js';
 import { Keypair as UtxoKeypair } from './models/keypair.js';
-import { getUtxos, isUtxoSpent } from './getUtxos.js';
-import { FIELD_SIZE, FEE_RECIPIENT, MERKLE_TREE_DEPTH, RELAYER_API_URL, PROGRAM_ID, ALT_ADDRESS } from './utils/constants.js';
+import { Utxo } from './models/utxo.js';
 import { useExistingALT } from './utils/address_lookup_table.js';
+import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, MERKLE_TREE_DEPTH, PROGRAM_ID, RELAYER_API_URL } from './utils/constants.js';
+import { EncryptionService, serializeProofAndExtData } from './utils/encryption.js';
 import { logger } from './utils/logger.js';
+import { MerkleTree } from './utils/merkle_tree.js';
+import { parseProofToBytesArray, parseToBytesArray, prove } from './utils/prover.js';
+import { fetchMerkleProof, findCrossCheckNullifierPDAs, findNullifierPDAs, getExtDataHash, getProgramAccounts, queryRemoteTreeState } from './utils/utils.js';
 
 
 // Function to relay pre-signed deposit transaction to indexer backend
@@ -97,12 +97,6 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
     // Create the merkle tree with the pre-initialized poseidon hash
     const tree = new MerkleTree(MERKLE_TREE_DEPTH, lightWasm);
 
-    // Initialize root and nextIndex variables
-    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState();
-
-    logger.debug(`Using tree root: ${root}`);
-    logger.debug(`New UTXOs will be inserted at indices: ${currentNextIndex} and ${currentNextIndex + 1}`);
-
     // Generate a deterministic private key derived from the wallet keypair
     // const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();
     const utxoPrivateKey = encryptionService.getUtxoPrivateKeyV2();
@@ -123,8 +117,12 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
     let inputs: Utxo[];
     let inputMerklePathIndices: number[];
     let inputMerklePathElements: string[][];
-
+    let root: string;
+    let nextIndex: number;
     if (existingUnspentUtxos.length === 0) {
+        const treeState = await queryRemoteTreeState();
+        root = treeState.root;
+        nextIndex = treeState.nextIndex;
         // Scenario 1: Fresh deposit with dummy inputs - add new funds to the system
         extAmount = amount_in_lamports;
         outputAmount = new BN(amount_in_lamports).sub(new BN(fee_amount_in_lamports)).toString();
@@ -188,16 +186,18 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
 
         // Fetch Merkle proofs for real UTXOs
         const firstUtxoCommitment = await firstUtxo.getCommitment();
-        const firstUtxoMerkleProof = await fetchMerkleProof(firstUtxoCommitment);
-
-        let secondUtxoMerkleProof;
+        let commitmentsToFetch = [firstUtxoCommitment];
         if (secondUtxo.amount.gt(new BN(0))) {
             // Second UTXO is real, fetch its proof
             const secondUtxoCommitment = await secondUtxo.getCommitment();
-            secondUtxoMerkleProof = await fetchMerkleProof(secondUtxoCommitment);
+            commitmentsToFetch.push(secondUtxoCommitment);
             logger.debug('\nSecond UTXO to be consolidated:');
             await secondUtxo.log();
         }
+        let data = await fetchMerkleProof(commitmentsToFetch)
+        root = data.root
+        nextIndex = data.nextIndex
+        let [firstUtxoMerkleProof, secondUtxoMerkleProof] = data.proofs
 
         // Use the real pathIndices from API for real inputs, mock index for dummy input
         inputMerklePathIndices = [
@@ -228,13 +228,13 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
             lightWasm,
             amount: outputAmount,
             keypair: utxoKeypair,
-            index: currentNextIndex // This UTXO will be inserted at currentNextIndex
+            index: nextIndex // This UTXO will be inserted at currentNextIndex
         }), // Output with value (either deposit amount minus fee, or input amount minus fee)
         new Utxo({
             lightWasm,
             amount: '0',
             keypair: utxoKeypair,
-            index: currentNextIndex + 1 // This UTXO will be inserted at currentNextIndex + 1
+            index: nextIndex + 1 // This UTXO will be inserted at currentNextIndex + 1
         }) // Empty UTXO
     ];
 

package/src/depositSPL.ts

@@ -1,17 +1,17 @@
-import { Connection, Keypair, PublicKey, TransactionInstruction, SystemProgram, ComputeBudgetProgram, VersionedTransaction, TransactionMessage, AddressLookupTableProgram } from '@solana/web3.js';
+import * as hasher from '@lightprotocol/hasher.rs';
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAccount, getAssociatedTokenAddressSync } from '@solana/spl-token';
+import { ComputeBudgetProgram, Connection, PublicKey, SystemProgram, TransactionInstruction, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
 import BN from 'bn.js';
+import { getUtxosSPL } from './getUtxosSPL.js';
+import { Keypair as UtxoKeypair } from './models/keypair.js';
 import { Utxo } from './models/utxo.js';
-import { fetchMerkleProof, findNullifierPDAs, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs, getExtDataHash, getMintAddressField } from './utils/utils.js';
-import { prove, parseProofToBytesArray, parseToBytesArray } from './utils/prover.js';
-import * as hasher from '@lightprotocol/hasher.rs';
-import { MerkleTree } from './utils/merkle_tree.js';
+import { useExistingALT } from './utils/address_lookup_table.js';
+import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, MERKLE_TREE_DEPTH, PROGRAM_ID, RELAYER_API_URL, Token, tokens } from './utils/constants.js';
 import { EncryptionService, serializeProofAndExtData } from './utils/encryption.js';
-import { Keypair as UtxoKeypair } from './models/keypair.js';
-import { getUtxosSPL, isUtxoSpent } from './getUtxosSPL.js';
-import { FIELD_SIZE, FEE_RECIPIENT, MERKLE_TREE_DEPTH, RELAYER_API_URL, PROGRAM_ID, ALT_ADDRESS, tokens, SplList, Token } from './utils/constants.js';
-import { getProtocolAddressesWithMint, useExistingALT } from './utils/address_lookup_table.js';
 import { logger } from './utils/logger.js';
-import { getAssociatedTokenAddress, ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, getMint, getAccount } from '@solana/spl-token';
+import { MerkleTree } from './utils/merkle_tree.js';
+import { parseProofToBytesArray, parseToBytesArray, prove } from './utils/prover.js';
+import { fetchMerkleProof, findCrossCheckNullifierPDAs, findNullifierPDAs, getExtDataHash, getMintAddressField, getProgramAccounts, queryRemoteTreeState } from './utils/utils.js';
 
 
 // Function to relay pre-signed deposit transaction to indexer backend
@@ -162,12 +162,6 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     // Create the merkle tree with the pre-initialized poseidon hash
     const tree = new MerkleTree(MERKLE_TREE_DEPTH, lightWasm);
 
-    // Initialize root and nextIndex variables
-    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState(token.name);
-
-    logger.debug(`Using tree root: ${root}`);
-    logger.debug(`New UTXOs will be inserted at indices: ${currentNextIndex} and ${currentNextIndex + 1}`);
-
     // Generate a deterministic private key derived from the wallet keypair
     // const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();
     const utxoPrivateKey = encryptionService.getUtxoPrivateKeyV2();
@@ -188,8 +182,12 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     let inputs: Utxo[];
     let inputMerklePathIndices: number[];
     let inputMerklePathElements: string[][];
-
+    let root: string;
+    let nextIndex: number;
     if (mintUtxos.length === 0) {
+        const treeState = await queryRemoteTreeState(token.name);
+        root = treeState.root
+        nextIndex = treeState.nextIndex
         // Scenario 1: Fresh deposit with dummy inputs - add new funds to the system
         extAmount = base_units;
         outputAmount = new BN(base_units).sub(new BN(fee_base_units)).toString();
@@ -241,6 +239,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
         logger.debug('\nFirst UTXO to be consolidated:');
 
         // Use first existing UTXO as first input, and either second UTXO or dummy UTXO as second input
+
         const secondUtxo = mintUtxos.length > 1 ? mintUtxos[1] : new Utxo({
             lightWasm,
             keypair: utxoKeypair,
@@ -255,17 +254,22 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
 
         // Fetch Merkle proofs for real UTXOs
         const firstUtxoCommitment = await firstUtxo.getCommitment();
-        const firstUtxoMerkleProof = await fetchMerkleProof(firstUtxoCommitment, token.name);
 
-        let secondUtxoMerkleProof;
+        let commitmentsToFetch = [firstUtxoCommitment];
         if (secondUtxo.amount.gt(new BN(0))) {
             // Second UTXO is real, fetch its proof
             const secondUtxoCommitment = await secondUtxo.getCommitment();
-            secondUtxoMerkleProof = await fetchMerkleProof(secondUtxoCommitment, token.name);
+            commitmentsToFetch.push(secondUtxoCommitment);
             logger.debug('\nSecond UTXO to be consolidated:');
             await secondUtxo.log();
         }
 
+        let data = await fetchMerkleProof(commitmentsToFetch, token.name)
+        root = data.root
+        nextIndex = data.nextIndex
+        let [firstUtxoMerkleProof, secondUtxoMerkleProof] = data.proofs
+
+
         // Use the real pathIndices from API for real inputs, mock index for dummy input
         inputMerklePathIndices = [
             firstUtxo.index || 0, // Use the real UTXO's index  
@@ -295,14 +299,14 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
             lightWasm,
             amount: outputAmount,
             keypair: utxoKeypair,
-            index: currentNextIndex, // This UTXO will be inserted at currentNextIndex
+            index: nextIndex, // This UTXO will be inserted at currentNextIndex
             mintAddress: token.pubkey.toString()
         }), // Output with value (either deposit amount minus fee, or input amount minus fee)
         new Utxo({
             lightWasm,
             amount: '0',
             keypair: utxoKeypair,
-            index: currentNextIndex + 1, // This UTXO will be inserted at currentNextIndex
+            index: nextIndex + 1, // This UTXO will be inserted at currentNextIndex
             mintAddress: token.pubkey.toString()
         }) // Empty UTXO
     ];

package/src/models/utxo.ts

@@ -5,12 +5,12 @@
  * Based on: https://github.com/tornadocash/tornado-nova
  */
 
-import BN from 'bn.js';
-import { Keypair } from './keypair.js';
 import * as hasher from '@lightprotocol/hasher.rs';
+import { PublicKey } from '@solana/web3.js';
+import BN from 'bn.js';
 import { ethers } from 'ethers';
 import { getMintAddressField } from '../utils/utils.js';
-import { PublicKey } from '@solana/web3.js';
+import { Keypair } from './keypair.js';
 /**
  * Simplified Utxo class inspired by Tornado Cash Nova
  * Based on: https://github.com/tornadocash/tornado-nova/blob/f9264eeffe48bf5e04e19d8086ee6ec58cdf0d9e/src/utxo.js
@@ -58,7 +58,7 @@ export class Utxo {
         this.version = version;
     }
 
-    async getCommitment(): Promise<string> {
+    getCommitment(): string {
         // return this.lightWasm.poseidonHashString([this.amount.toString(), this.keypair.pubkey.toString(), this.blinding.toString(), this.mintAddress]);
         const mintAddressField = getMintAddressField(new PublicKey(this.mintAddress));
         return this.lightWasm.poseidonHashString([

package/src/utils/utils.ts

@@ -5,14 +5,14 @@
  * Based on: https://github.com/tornadocash/tornado-nova
  */
 
-import BN from 'bn.js';
-import { Utxo } from '../models/utxo.js';
-import * as borsh from 'borsh';
 import { sha256 } from '@ethersproject/sha2';
 import { PublicKey } from '@solana/web3.js';
-import { RELAYER_API_URL, PROGRAM_ID } from './constants.js';
-import { logger } from './logger.js';
+import BN from 'bn.js';
+import * as borsh from 'borsh';
 import { getConfig } from '../config.js';
+import { Utxo } from '../models/utxo.js';
+import { PROGRAM_ID, RELAYER_API_URL } from './constants.js';
+import { logger } from './logger.js';
 
 /**
  * Calculate deposit fee based on deposit amount and fee rate
@@ -113,24 +113,29 @@ export function getExtDataHash(extData: {
   return Buffer.from(hashHex.slice(2), 'hex');
 }
 
+type Proof = { pathElements: string[], pathIndices: number[] }
 
 // Function to fetch Merkle proof from API for a given commitment
-export async function fetchMerkleProof(commitment: string, tokenName?: string): Promise<{ pathElements: string[], pathIndices: number[] }> {
+export async function fetchMerkleProof(commitments: string[], tokenName?: string): Promise<{
+  proofs: Proof[],
+  root: string,
+  nextIndex: number
+}> {
   try {
-    logger.debug(`Fetching Merkle proof for commitment: ${commitment}`);
-    let url = `${RELAYER_API_URL}/merkle/proof/${commitment}`
+    logger.debug(`Fetching Merkle proof for commitment: ${commitments.join(', ')} with token: ${tokenName || 'N/A'}`);
+    let url = `${RELAYER_API_URL}/merkle/proofv2/?commitments=${commitments.join(',')}`
     if (tokenName) {
-      url += '?token=' + tokenName
+      url += '&token=' + tokenName
     }
+    logger.debug(`Fetching Merkle proof from URL: ${url}`);
     const response = await fetch(url);
     if (!response.ok) {
       throw new Error(`Failed to fetch Merkle proof: ${url}`);
     }
-    const data = await response.json() as { pathElements: string[], pathIndices: number[] };
-    logger.debug(`✓ Fetched Merkle proof with ${data.pathElements.length} elements`);
+    const data = await response.json();
     return data;
   } catch (error) {
-    console.error(`Failed to fetch Merkle proof for commitment ${commitment}:`, error);
+    console.error(`Failed to fetch Merkle proof for commitments ${commitments.join(', ')}:`, error);
     throw error;
   }
 }

package/src/withdraw.ts

@@ -1,18 +1,18 @@
-import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
+import * as hasher from '@lightprotocol/hasher.rs';
+import { Connection, LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 import { Buffer } from 'buffer';
 import { Keypair as UtxoKeypair } from './models/keypair.js';
-import * as hasher from '@lightprotocol/hasher.rs';
 import { Utxo } from './models/utxo.js';
 import { parseProofToBytesArray, parseToBytesArray, prove } from './utils/prover.js';
 
-import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, RELAYER_API_URL, MERKLE_TREE_DEPTH, PROGRAM_ID } from './utils/constants.js';
+import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, RELAYER_API_URL } from './utils/constants.js';
 import { EncryptionService, serializeProofAndExtData } from './utils/encryption.js';
-import { fetchMerkleProof, findNullifierPDAs, getExtDataHash, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs } from './utils/utils.js';
+import { fetchMerkleProof, findCrossCheckNullifierPDAs, findNullifierPDAs, getExtDataHash, getProgramAccounts } from './utils/utils.js';
 
+import { getConfig } from './config.js';
 import { getUtxos } from './getUtxos.js';
 import { logger } from './utils/logger.js';
-import { getConfig } from './config.js';
 // Indexer API endpoint
 
 
@@ -65,11 +65,6 @@ export async function withdraw({ recipient, lightWasm, storage, publicKey, conne
 
     const { treeAccount, treeTokenAccount, globalConfigAccount } = getProgramAccounts()
 
-    // Get current tree state
-    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState();
-    logger.debug(`Using tree root: ${root}`);
-    logger.debug(`New UTXOs will be inserted at indices: ${currentNextIndex} and ${currentNextIndex + 1}`);
-
     // Generate a deterministic private key derived from the wallet keypair
     const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();
 
@@ -124,23 +119,26 @@ export async function withdraw({ recipient, lightWasm, storage, publicKey, conne
     logger.debug(`Withdrawing ${amount_in_lamports} lamports with ${fee_in_lamports} fee, ${changeAmount.toString()} as change`);
 
     // Get Merkle proofs for both input UTXOs
-    const inputMerkleProofs = await Promise.all(
-        inputs.map(async (utxo, index) => {
-            // For dummy UTXO (amount is 0), use a zero-filled proof
-            if (utxo.amount.eq(new BN(0))) {
-                return {
-                    pathElements: [...new Array(MERKLE_TREE_DEPTH).fill("0")],
-                    pathIndices: Array(MERKLE_TREE_DEPTH).fill(0)
-                };
-            }
-            // For real UTXOs, fetch the proof from API
-            const commitment = await utxo.getCommitment();
-            return fetchMerkleProof(commitment);
-        })
-    );
+    let commitmentsToFetch = inputs.map(utxo => utxo.getCommitment());
+    console.log('commitmentsToFetch', commitmentsToFetch)
+    const { root, nextIndex, proofs } = await fetchMerkleProof(commitmentsToFetch);
+    // const inputMerkleProofs = await Promise.all(
+    //     inputs.map(async (utxo, index) => {
+    //         // For dummy UTXO (amount is 0), use a zero-filled proof
+    //         if (utxo.amount.eq(new BN(0))) {
+    //             return {
+    //                 pathElements: [...new Array(MERKLE_TREE_DEPTH).fill("0")],
+    //                 pathIndices: Array(MERKLE_TREE_DEPTH).fill(0)
+    //             };
+    //         }
+    //         // For real UTXOs, fetch the proof from API
+    //         const commitment = await utxo.getCommitment();
+    //         return fetchMerkleProof(commitment);
+    //     })
+    // );
 
     // Extract path elements and indices
-    const inputMerklePathElements = inputMerkleProofs.map(proof => proof.pathElements);
+    const inputMerklePathElements = proofs.map(proof => proof.pathElements);
     const inputMerklePathIndices = inputs.map(utxo => utxo.index || 0);
 
     // Create outputs: first output is change, second is dummy (required by protocol)
@@ -149,13 +147,13 @@ export async function withdraw({ recipient, lightWasm, storage, publicKey, conne
             lightWasm,
             amount: changeAmount.toString(),
             keypair: utxoKeypairV2,
-            index: currentNextIndex
+            index: nextIndex
         }), // Change output
         new Utxo({
             lightWasm,
             amount: '0',
             keypair: utxoKeypairV2,
-            index: currentNextIndex + 1
+            index: nextIndex + 1
         }) // Empty UTXO
     ];
 

package/src/withdrawSPL.ts

@@ -1,19 +1,19 @@
-import { Connection, Keypair, PublicKey, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
+import * as hasher from '@lightprotocol/hasher.rs';
+import { Connection, PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 import { Buffer } from 'buffer';
 import { Keypair as UtxoKeypair } from './models/keypair.js';
-import * as hasher from '@lightprotocol/hasher.rs';
 import { Utxo } from './models/utxo.js';
 import { parseProofToBytesArray, parseToBytesArray, prove } from './utils/prover.js';
 
-import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, RELAYER_API_URL, MERKLE_TREE_DEPTH, PROGRAM_ID, SplList, tokens } from './utils/constants.js';
+import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, PROGRAM_ID, RELAYER_API_URL, tokens } from './utils/constants.js';
 import { EncryptionService, serializeProofAndExtData } from './utils/encryption.js';
-import { fetchMerkleProof, findNullifierPDAs, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs, getMintAddressField, getExtDataHash } from './utils/utils.js';
+import { fetchMerkleProof, findCrossCheckNullifierPDAs, findNullifierPDAs, getExtDataHash, getMintAddressField, getProgramAccounts } from './utils/utils.js';
 
-import { getUtxosSPL, isUtxoSpent } from './getUtxosSPL.js';
-import { logger } from './utils/logger.js';
-import { getConfig } from './config.js';
 import { getAssociatedTokenAddressSync, getMint } from '@solana/spl-token';
+import { getConfig } from './config.js';
+import { getUtxosSPL } from './getUtxosSPL.js';
+import { logger } from './utils/logger.js';
 // Indexer API endpoint
 
 
@@ -120,11 +120,6 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
 
     const { globalConfigAccount, treeTokenAccount } = getProgramAccounts()
 
-    // Get current tree state
-    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState(token.name);
-    logger.debug(`Using tree root: ${root}`);
-    logger.debug(`New UTXOs will be inserted at indices: ${currentNextIndex} and ${currentNextIndex + 1}`);
-
     // Generate a deterministic private key derived from the wallet keypair
     const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();
 
@@ -180,24 +175,11 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
     const changeAmount = totalInputAmount.sub(new BN(base_units)).sub(new BN(fee_base_units));
     logger.debug(`Withdrawing ${base_units} lamports with ${fee_base_units} fee, ${changeAmount.toString()} as change`);
 
-    // Get Merkle proofs for both input UTXOs
-    const inputMerkleProofs = await Promise.all(
-        inputs.map(async (utxo, index) => {
-            // For dummy UTXO (amount is 0), use a zero-filled proof
-            if (utxo.amount.eq(new BN(0))) {
-                return {
-                    pathElements: [...new Array(MERKLE_TREE_DEPTH).fill("0")],
-                    pathIndices: Array(MERKLE_TREE_DEPTH).fill(0)
-                };
-            }
-            // For real UTXOs, fetch the proof from API
-            const commitment = await utxo.getCommitment();
-            return fetchMerkleProof(commitment, token.name);
-        })
-    );
+    let commitmentsToFetch = inputs.map(utxo => utxo.getCommitment());
+    const { root, nextIndex, proofs } = await fetchMerkleProof(commitmentsToFetch, token.name);
 
     // Extract path elements and indices
-    const inputMerklePathElements = inputMerkleProofs.map(proof => proof.pathElements);
+    const inputMerklePathElements = proofs.map(proof => proof.pathElements);
     const inputMerklePathIndices = inputs.map(utxo => utxo.index || 0);
 
     // Create outputs: first output is change, second is dummy (required by protocol)
@@ -206,14 +188,14 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
             lightWasm,
             amount: changeAmount.toString(),
             keypair: utxoKeypairV2,
-            index: currentNextIndex,
+            index: nextIndex,
             mintAddress: token.pubkey.toString()
         }), // Change output
         new Utxo({
             lightWasm,
             amount: '0',
             keypair: utxoKeypairV2,
-            index: currentNextIndex + 1,
+            index: nextIndex + 1,
             mintAddress: token.pubkey.toString()
         }) // Empty UTXO
     ];