privacycash 1.0.17 → 1.0.19

package/dist/withdrawSPL.js

@@ -0,0 +1,289 @@
+import { PublicKey } from '@solana/web3.js';
+import BN from 'bn.js';
+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 } from './utils/constants.js';
+import { serializeProofAndExtData } from './utils/encryption.js';
+import { fetchMerkleProof, findNullifierPDAs, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs, getMintAddressField, getExtDataHash } from './utils/utils.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) {
+    try {
+        const response = await fetch(`${RELAYER_API_URL}/withdraw/spl`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(params)
+        });
+        if (!response.ok) {
+            const errorData = await response.json();
+            throw new Error(errorData.error);
+        }
+        const result = await response.json();
+        logger.debug('Withdraw request submitted successfully!');
+        logger.debug('Response:', result);
+        return result.signature;
+    }
+    catch (error) {
+        logger.debug('Failed to submit withdraw request to indexer:', typeof error, error);
+        throw error;
+    }
+}
+export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, connection, base_units, encryptionService, keyBasePath, mintAddress }) {
+    let mintInfo = await getMint(connection, mintAddress);
+    let units_per_token = 10 ** mintInfo.decimals;
+    let withdraw_fee_rate = await getConfig('withdraw_fee_rate');
+    let withdraw_rent_fee = await getConfig('usdc_withdraw_rent_fee');
+    let fee_base_units = Math.floor(base_units * withdraw_fee_rate + units_per_token * withdraw_rent_fee);
+    base_units -= fee_base_units;
+    if (base_units <= 0) {
+        throw new Error('withdraw amount too low');
+    }
+    let isPartial = false;
+    let recipient_ata = getAssociatedTokenAddressSync(mintAddress, recipient, true);
+    let feeRecipientTokenAccount = getAssociatedTokenAddressSync(mintAddress, FEE_RECIPIENT, true);
+    let signerTokenAccount = getAssociatedTokenAddressSync(mintAddress, publicKey);
+    logger.debug('Encryption key generated from user keypair');
+    // Derive tree account PDA with mint address for SPL (different from SOL version)
+    const [treeAccount] = PublicKey.findProgramAddressSync([Buffer.from('merkle_tree'), mintAddress.toBuffer()], PROGRAM_ID);
+    const { globalConfigAccount, treeTokenAccount } = getProgramAccounts();
+    // Get current tree state
+    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState('usdc');
+    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
+    const utxoKeypair = new UtxoKeypair(utxoPrivateKey, lightWasm);
+    logger.debug('Using wallet-derived UTXO keypair for withdrawal');
+    // Generate a deterministic private key derived from the wallet keypair (V2)
+    const utxoPrivateKeyV2 = encryptionService.getUtxoPrivateKeyV2();
+    const utxoKeypairV2 = new UtxoKeypair(utxoPrivateKeyV2, lightWasm);
+    // Fetch existing UTXOs for this user
+    logger.debug('\nFetching existing UTXOs...');
+    const mintUtxos = await getUtxosSPL({ connection, publicKey, encryptionService, storage, mintAddress });
+    logger.debug(`Found ${mintUtxos.length} total UTXOs`);
+    // Calculate and log total unspent UTXO balance
+    const totalUnspentBalance = mintUtxos.reduce((sum, utxo) => sum.add(utxo.amount), new BN(0));
+    logger.debug(`Total unspent UTXO balance before: ${totalUnspentBalance.toString()} lamports (${totalUnspentBalance.toNumber() / 1e9} SOL)`);
+    if (mintUtxos.length < 1) {
+        throw new Error('Need at least 1 unspent UTXO to perform a withdrawal');
+    }
+    // Sort UTXOs by amount in descending order to use the largest ones first
+    mintUtxos.sort((a, b) => b.amount.cmp(a.amount));
+    // Use the largest UTXO as first input, and either second largest UTXO or dummy UTXO as second input
+    const firstInput = mintUtxos[0];
+    const secondInput = mintUtxos.length > 1 ? mintUtxos[1] : new Utxo({
+        lightWasm,
+        keypair: utxoKeypair,
+        amount: '0',
+        mintAddress: mintAddress.toString()
+    });
+    const inputs = [firstInput, secondInput];
+    logger.debug(`firstInput index: ${firstInput.index}, commitment: ${firstInput.getCommitment()}`);
+    logger.debug(`secondInput index: ${secondInput.index}, commitment: ${secondInput.getCommitment()}`);
+    const totalInputAmount = firstInput.amount.add(secondInput.amount);
+    logger.debug(`Using UTXO with amount: ${firstInput.amount.toString()} and ${secondInput.amount.gt(new BN(0)) ? 'second UTXO with amount: ' + secondInput.amount.toString() : 'dummy UTXO'}`);
+    if (totalInputAmount.toNumber() === 0) {
+        throw new Error('no balance');
+    }
+    if (totalInputAmount.lt(new BN(base_units + fee_base_units))) {
+        isPartial = true;
+        base_units = totalInputAmount.toNumber();
+        base_units -= fee_base_units;
+    }
+    // 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, 'usdc');
+    }));
+    // Extract path elements and indices
+    const inputMerklePathElements = inputMerkleProofs.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 = [
+        new Utxo({
+            lightWasm,
+            amount: changeAmount.toString(),
+            keypair: utxoKeypairV2,
+            index: currentNextIndex,
+            mintAddress: mintAddress.toString()
+        }), // Change output
+        new Utxo({
+            lightWasm,
+            amount: '0',
+            keypair: utxoKeypairV2,
+            index: currentNextIndex + 1,
+            mintAddress: mintAddress.toString()
+        }) // Empty UTXO
+    ];
+    // For withdrawals, extAmount is negative (funds leaving the system)
+    const extAmount = -base_units;
+    const publicAmountForCircuit = new BN(extAmount).sub(new BN(fee_base_units)).add(FIELD_SIZE).mod(FIELD_SIZE);
+    logger.debug(`Public amount calculation: (${extAmount} - ${fee_base_units} + FIELD_SIZE) % FIELD_SIZE = ${publicAmountForCircuit.toString()}`);
+    // Verify this matches the circuit balance equation: sumIns + publicAmount = sumOuts
+    const sumIns = inputs.reduce((sum, input) => sum.add(input.amount), new BN(0));
+    const sumOuts = outputs.reduce((sum, output) => sum.add(output.amount), new BN(0));
+    logger.debug(`Circuit balance check: sumIns(${sumIns.toString()}) + publicAmount(${publicAmountForCircuit.toString()}) should equal sumOuts(${sumOuts.toString()})`);
+    // Convert to circuit-compatible format
+    const publicAmountCircuitResult = sumIns.add(publicAmountForCircuit).mod(FIELD_SIZE);
+    logger.debug(`Balance verification: ${sumIns.toString()} + ${publicAmountForCircuit.toString()} (mod FIELD_SIZE) = ${publicAmountCircuitResult.toString()}`);
+    logger.debug(`Expected sum of outputs: ${sumOuts.toString()}`);
+    logger.debug(`Balance equation satisfied: ${publicAmountCircuitResult.eq(sumOuts)}`);
+    // Generate nullifiers and commitments
+    const inputNullifiers = await Promise.all(inputs.map(x => x.getNullifier()));
+    const outputCommitments = await Promise.all(outputs.map(x => x.getCommitment()));
+    // Save original commitment and nullifier values for verification
+    logger.debug('\n=== UTXO VALIDATION ===');
+    logger.debug('Output 0 Commitment:', outputCommitments[0]);
+    logger.debug('Output 1 Commitment:', outputCommitments[1]);
+    // Encrypt the UTXO data using a compact format that includes the keypair
+    logger.debug('\nEncrypting UTXOs with keypair data...');
+    const encryptedOutput1 = encryptionService.encryptUtxo(outputs[0]);
+    const encryptedOutput2 = encryptionService.encryptUtxo(outputs[1]);
+    logger.debug(`\nOutput[0] (change):`);
+    await outputs[0].log();
+    logger.debug(`\nOutput[1] (empty):`);
+    await outputs[1].log();
+    logger.debug(`Encrypted output 1: ${encryptedOutput1.toString('hex')}`);
+    logger.debug(`Encrypted output 2: ${encryptedOutput2.toString('hex')}`);
+    logger.debug(`\nEncrypted output 1 size: ${encryptedOutput1.length} bytes`);
+    logger.debug(`Encrypted output 2 size: ${encryptedOutput2.length} bytes`);
+    logger.debug(`Total encrypted outputs size: ${encryptedOutput1.length + encryptedOutput2.length} bytes`);
+    // Test decryption to verify commitment values match
+    logger.debug('\n=== TESTING DECRYPTION ===');
+    logger.debug('Decrypting output 1 to verify commitment matches...');
+    const decryptedUtxo1 = await encryptionService.decryptUtxo(encryptedOutput1, lightWasm);
+    const decryptedCommitment1 = await decryptedUtxo1.getCommitment();
+    logger.debug('Original commitment:', outputCommitments[0]);
+    logger.debug('Decrypted commitment:', decryptedCommitment1);
+    logger.debug('Commitment matches:', outputCommitments[0] === decryptedCommitment1);
+    // Create the withdrawal ExtData with real encrypted outputs
+    const extData = {
+        // it can be any address
+        recipient: recipient_ata,
+        extAmount: new BN(extAmount),
+        encryptedOutput1: encryptedOutput1,
+        encryptedOutput2: encryptedOutput2,
+        fee: new BN(fee_base_units),
+        feeRecipient: feeRecipientTokenAccount,
+        mintAddress: mintAddress.toString()
+    };
+    // Calculate the extDataHash with the encrypted outputs
+    const calculatedExtDataHash = getExtDataHash(extData);
+    // Create the input for the proof generation
+    const input = {
+        // Common transaction data
+        root: root,
+        mintAddress: getMintAddressField(mintAddress), // new mint address
+        publicAmount: publicAmountForCircuit.toString(), // Use proper field arithmetic result
+        extDataHash: calculatedExtDataHash,
+        // Input UTXO data (UTXOs being spent) - ensure all values are in decimal format
+        inAmount: inputs.map(x => x.amount.toString(10)),
+        inPrivateKey: inputs.map(x => x.keypair.privkey),
+        inBlinding: inputs.map(x => x.blinding.toString(10)),
+        inPathIndices: inputMerklePathIndices,
+        inPathElements: inputMerklePathElements,
+        inputNullifier: inputNullifiers, // Use resolved values instead of Promise objects
+        // Output UTXO data (UTXOs being created) - ensure all values are in decimal format
+        outAmount: outputs.map(x => x.amount.toString(10)),
+        outBlinding: outputs.map(x => x.blinding.toString(10)),
+        outPubkey: outputs.map(x => x.keypair.pubkey),
+        outputCommitment: outputCommitments,
+    };
+    logger.info('generating ZK proof...');
+    // Generate the zero-knowledge proof
+    const { proof, publicSignals } = await prove(input, keyBasePath);
+    // Parse the proof and public signals into byte arrays
+    const proofInBytes = parseProofToBytesArray(proof);
+    const inputsInBytes = parseToBytesArray(publicSignals);
+    // Create the proof object to submit to the program
+    const proofToSubmit = {
+        proofA: proofInBytes.proofA,
+        proofB: proofInBytes.proofB.flat(),
+        proofC: proofInBytes.proofC,
+        root: inputsInBytes[0],
+        publicAmount: inputsInBytes[1],
+        extDataHash: inputsInBytes[2],
+        inputNullifiers: [
+            inputsInBytes[3],
+            inputsInBytes[4]
+        ],
+        outputCommitments: [
+            inputsInBytes[5],
+            inputsInBytes[6]
+        ],
+    };
+    // Find PDAs for nullifiers and commitments
+    const { nullifier0PDA, nullifier1PDA } = findNullifierPDAs(proofToSubmit);
+    const { nullifier2PDA, nullifier3PDA } = findCrossCheckNullifierPDAs(proofToSubmit);
+    // Serialize the proof and extData
+    const serializedProof = serializeProofAndExtData(proofToSubmit, extData, true);
+    logger.debug(`Total instruction data size: ${serializedProof.length} bytes`);
+    const [globalConfigPda, globalConfigPdaBump] = await PublicKey.findProgramAddressSync([Buffer.from("global_config")], PROGRAM_ID);
+    const treeAta = getAssociatedTokenAddressSync(mintAddress, globalConfigPda, true);
+    // Prepare withdraw parameters for indexer backend
+    const withdrawParams = {
+        serializedProof: serializedProof.toString('base64'),
+        treeAccount: treeAccount.toString(),
+        nullifier0PDA: nullifier0PDA.toString(),
+        nullifier1PDA: nullifier1PDA.toString(),
+        nullifier2PDA: nullifier2PDA.toString(),
+        nullifier3PDA: nullifier3PDA.toString(),
+        treeTokenAccount: treeTokenAccount.toString(),
+        globalConfigAccount: globalConfigAccount.toString(),
+        recipient: recipient.toString(),
+        feeRecipientAccount: FEE_RECIPIENT.toString(),
+        extAmount: extAmount,
+        fee: fee_base_units,
+        lookupTableAddress: ALT_ADDRESS.toString(),
+        senderAddress: publicKey.toString(),
+        treeAta: treeAta.toString(),
+        recipientAta: recipient_ata.toString(),
+        mintAddress: mintAddress.toString(),
+        feeRecipientTokenAccount: feeRecipientTokenAccount.toString()
+    };
+    logger.debug('Prepared withdraw parameters for indexer backend');
+    // Submit to indexer backend instead of directly to Solana
+    logger.info('submitting transaction to relayer...');
+    const signature = await submitWithdrawToIndexer(withdrawParams);
+    // Wait a moment for the transaction to be confirmed
+    logger.info('waiting for transaction confirmation...');
+    let retryTimes = 0;
+    let itv = 2;
+    const encryptedOutputStr = Buffer.from(encryptedOutput1).toString('hex');
+    let start = Date.now();
+    while (true) {
+        console.log(`retryTimes: ${retryTimes}`);
+        await new Promise(resolve => setTimeout(resolve, itv * 1000));
+        console.log('Fetching updated tree state...');
+        let res = await fetch(RELAYER_API_URL + '/utxos/check/' + encryptedOutputStr + '?token=usdc');
+        let resJson = await res.json();
+        console.log('resJson:', resJson);
+        if (resJson.exists) {
+            return { isPartial, tx: signature, recipient: recipient.toString(), base_units, fee_base_units };
+        }
+        if (retryTimes >= 10) {
+            throw new Error('Refresh the page to see latest balance.');
+        }
+        retryTimes++;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "privacycash",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "",
   "main": "dist/index.js",
   "repository": "https://github.com/Privacy-Cash/privacy-cash-sdk",
@@ -12,8 +12,9 @@
   "type": "module",
   "scripts": {
     "build": "tsc",
-    "test": "vitest run --exclude \"**/__tests__/e2e.test.ts\"",
-    "teste2e": "vitest run e2e.test.ts"
+    "test": "vitest run --exclude \"**/__tests__/e2e.test.ts,**/__tests__/e2espl.test.ts\"",
+    "teste2e": "vitest run e2e.test.ts",
+    "teste2espl": "vitest run e2espl.test.ts"
   },
   "keywords": [],
   "author": "",
@@ -23,6 +24,7 @@
     "@ethersproject/keccak256": "^5.8.0",
     "@ethersproject/sha2": "^5.8.0",
     "@lightprotocol/hasher.rs": "^0.2.1",
+    "@solana/spl-token": "^0.4.14",
     "@solana/web3.js": "^1.98.4",
     "@types/bn.js": "^5.2.0",
     "@types/snarkjs": "^0.7.9",

package/src/config.ts

@@ -1,28 +1,21 @@
-import { INDEXER_API_URL } from "./utils/constants.js";
+import { RELAYER_API_URL } from "./utils/constants.js";
 
 type Config = {
     withdraw_fee_rate: number
     withdraw_rent_fee: number
     deposit_fee_rate: number
+    usdc_withdraw_rent_fee: number
 }
 
 let config: Config | undefined
 
 export async function getConfig<K extends keyof Config>(key: K): Promise<Config[K]> {
     if (!config) {
-        const res = await fetch(INDEXER_API_URL + '/config')
-        const data = await res.json()
-
-        // check types
-        if (
-            typeof data.withdraw_fee_rate !== 'number' ||
-            typeof data.withdraw_rent_fee !== 'number' ||
-            typeof data.deposit_fee_rate !== 'number'
-        ) {
-            throw new Error("Invalid config received from server")
-        }
-
-        config = data
+        const res = await fetch(RELAYER_API_URL + '/config')
+        config = await res.json()
+    }
+    if (typeof config![key] != 'number') {
+        throw new Error(`can not get ${key} from ${RELAYER_API_URL}/config`)
     }
     return config![key]
 }

package/src/deposit.ts

@@ -8,7 +8,7 @@ import { MerkleTree } from './utils/merkle_tree.js';
 import { EncryptionService, serializeProofAndExtData } from './utils/encryption.js';
 import { Keypair as UtxoKeypair } from './models/keypair.js';
 import { getUtxos, isUtxoSpent } from './getUtxos.js';
-import { FIELD_SIZE, FEE_RECIPIENT, MERKLE_TREE_DEPTH, INDEXER_API_URL, PROGRAM_ID } from './utils/constants.js';
+import { FIELD_SIZE, FEE_RECIPIENT, MERKLE_TREE_DEPTH, RELAYER_API_URL, PROGRAM_ID, ALT_ADDRESS } from './utils/constants.js';
 import { useExistingALT } from './utils/address_lookup_table.js';
 import { logger } from './utils/logger.js';
 
@@ -27,7 +27,7 @@ async function relayDepositToIndexer(signedTransaction: string, publicKey: Publi
             params.referralWalletAddress = referrer
         }
 
-        const response = await fetch(`${INDEXER_API_URL}/deposit`, {
+        const response = await fetch(`${RELAYER_API_URL}/deposit`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -83,7 +83,7 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
     logger.debug(`Wallet balance: ${balance / 1e9} SOL`);
 
     if (balance < amount_in_lamports + fee_amount_in_lamports) {
-        new Error(`Insufficient balance: ${balance / 1e9} SOL. Need at least ${(amount_in_lamports + fee_amount_in_lamports) / LAMPORTS_PER_SOL} SOL.`);
+        throw new Error(`Insufficient balance: ${balance / 1e9} SOL. Need at least ${(amount_in_lamports + fee_amount_in_lamports) / LAMPORTS_PER_SOL} SOL.`);
     }
 
     const { treeAccount, treeTokenAccount, globalConfigAccount } = getProgramAccounts()
@@ -348,7 +348,6 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
     // Address Lookup Table for transaction size optimization
     logger.debug('Setting up Address Lookup Table...');
 
-    const ALT_ADDRESS = new PublicKey('72bpRay17JKp4k8H87p7ieU9C6aRDy5yCqwvtpTN2wuU');
     const lookupTableAccount = await useExistingALT(connection, ALT_ADDRESS);
 
     if (!lookupTableAccount?.value) {
@@ -423,7 +422,7 @@ export async function deposit({ lightWasm, storage, keyBasePath, publicKey, conn
         logger.debug(`retryTimes: ${retryTimes}`)
         await new Promise(resolve => setTimeout(resolve, itv * 1000));
         logger.debug('Fetching updated tree state...');
-        let res = await fetch(INDEXER_API_URL + '/utxos/check/' + encryptedOutputStr)
+        let res = await fetch(RELAYER_API_URL + '/utxos/check/' + encryptedOutputStr)
         let resJson = await res.json()
         if (resJson.exists) {
             logger.debug(`Top up successfully in ${((Date.now() - start) / 1000).toFixed(2)} seconds!`);
@@ -463,11 +462,6 @@ async function checkDepositLimit(connection: Connection) {
         const maxDepositAmount = new BN(accountInfo.data.slice(4120, 4128), 'le');
         const bump = accountInfo.data[4128];
 
-        console.log('\n📋 MerkleTreeAccount Details:');
-        console.log(`┌─ Authority: ${authority.toString()}`);
-        console.log(`├─ Next Index: ${nextIndex.toString()}`);
-        console.log(`├─ Root Index: ${rootIndex.toString()}`);
-        console.log(`├─ Max Deposit Amount: ${maxDepositAmount.toString()} lamports`);
 
         // Convert to SOL using BN division to handle large numbers
         const lamportsPerSol = new BN(1_000_000_000);
@@ -483,7 +477,6 @@ async function checkDepositLimit(connection: Connection) {
             const fractional = remainder.toNumber() / 1e9;
             solFormatted = `${maxDepositSol.toString()}${fractional.toFixed(9).substring(1)}`;
         }
-        console.log('solFormatted', solFormatted)
         return Number(solFormatted)
 
     } catch (error) {