privacycash 1.0.16 → 1.0.18

package/src/index.ts

@@ -1,8 +1,9 @@
 import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, VersionedTransaction } from '@solana/web3.js';
 import { deposit } from './deposit.js';
 import { getBalanceFromUtxos, getUtxos, localstorageKey } from './getUtxos.js';
+import { getBalanceFromUtxosSPL, getUtxosSPL } from './getUtxosSPL.js';
 
-import { LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET } from './utils/constants.js';
+import { LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET, USDC_MINT } from './utils/constants.js';
 import { logger, type LoggerFn, setLogger } from './utils/logger.js';
 import { EncryptionService } from './utils/encryption.js';
 import { WasmFactory } from '@lightprotocol/hasher.rs';
@@ -10,6 +11,9 @@ import bs58 from 'bs58'
 import { withdraw } from './withdraw.js';
 import { LocalStorage } from "node-localstorage";
 import path from 'node:path'
+import { depositSPL } from './depositSPL.js';
+import { withdrawSPL } from './withdrawSPL.js';
+import { getAssociatedTokenAddress } from '@solana/spl-token';
 
 let storage = new LocalStorage(path.join(process.cwd(), "cache"));
 
@@ -65,6 +69,16 @@ export class PrivacyCash {
         }
         storage.removeItem(LSK_FETCH_OFFSET + localstorageKey(this.publicKey))
         storage.removeItem(LSK_ENCRYPTED_OUTPUTS + localstorageKey(this.publicKey))
+        // spl
+        let mintAddresses = [USDC_MINT]
+        for (let mintAddress of mintAddresses) {
+            let ata = await getAssociatedTokenAddress(
+                mintAddress,
+                this.publicKey
+            );
+            storage.removeItem(LSK_FETCH_OFFSET + localstorageKey(ata))
+            storage.removeItem(LSK_ENCRYPTED_OUTPUTS + localstorageKey(ata))
+        }
         return this
     }
 
@@ -96,6 +110,33 @@ export class PrivacyCash {
         return res
     }
 
+    /**
+    * Deposit USDC to the Privacy Cash.
+    */
+    async depositUSDC({ base_units }: {
+        base_units: number
+    }) {
+        this.isRuning = true
+        logger.info('start depositting')
+        let lightWasm = await WasmFactory.getInstance()
+        let res = await depositSPL({
+            mintAddress: USDC_MINT,
+            lightWasm,
+            base_units: base_units,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            publicKey: this.publicKey,
+            transactionSigner: async (tx: VersionedTransaction) => {
+                tx.sign([this.keypair])
+                return tx
+            },
+            keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
+            storage
+        })
+        this.isRuning = false
+        return res
+    }
+
     /**
      * Withdraw SOL from the Privacy Cash.
      * 
@@ -124,17 +165,57 @@ export class PrivacyCash {
         return res
     }
 
+    /**
+      * Withdraw USDC from the Privacy Cash.
+      * 
+      * base_units is the amount of USDC in base unit. e.g. if you want to withdraw 1 USDC (1,000,000 base unit), call withdraw({ base_units: 1000000, recipientAddress: 'some_address' })
+      */
+    async withdrawUSDC({ base_units, recipientAddress }: {
+        base_units: number,
+        recipientAddress?: string
+    }) {
+        this.isRuning = true
+        logger.info('start withdrawing')
+        let lightWasm = await WasmFactory.getInstance()
+        let recipient = recipientAddress ? new PublicKey(recipientAddress) : this.publicKey
+        let res = await withdrawSPL({
+            mintAddress: USDC_MINT,
+            lightWasm,
+            base_units,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            publicKey: this.publicKey,
+            recipient,
+            keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
+            storage
+        })
+        console.log(`Withdraw successful. Recipient ${recipient} received ${base_units} USDC units`)
+        this.isRuning = false
+        return res
+    }
+
     /**
      * Returns the amount of lamports current wallet has in Privacy Cash.
      */
-    async getPrivateBalance() {
+    async getPrivateBalance(abortSignal?: AbortSignal) {
         logger.info('getting private balance')
         this.isRuning = true
-        let utxos = await getUtxos({ publicKey: this.publicKey, connection: this.connection, encryptionService: this.encryptionService, storage })
+        let utxos = await getUtxos({ publicKey: this.publicKey, connection: this.connection, encryptionService: this.encryptionService, storage, abortSignal })
         this.isRuning = false
         return getBalanceFromUtxos(utxos)
     }
 
+    /**
+    * Returns the amount of lamports current wallet has in Privacy Cash.
+    */
+    async getPrivateBalanceUSDC() {
+        logger.info('getting private balance')
+        this.isRuning = true
+        let utxos = await getUtxosSPL({ publicKey: this.publicKey, connection: this.connection, encryptionService: this.encryptionService, storage, mintAddress: USDC_MINT })
+        this.isRuning = false
+        return getBalanceFromUtxosSPL(utxos)
+    }
+
     /**
      * Returns true if the code is running in a browser.
      */

package/src/models/utxo.ts

@@ -9,6 +9,8 @@ import BN from 'bn.js';
 import { Keypair } from './keypair.js';
 import * as hasher from '@lightprotocol/hasher.rs';
 import { ethers } from 'ethers';
+import { getMintAddressField } from '../utils/utils.js';
+import { PublicKey } from '@solana/web3.js';
 /**
  * Simplified Utxo class inspired by Tornado Cash Nova
  * Based on: https://github.com/tornadocash/tornado-nova/blob/f9264eeffe48bf5e04e19d8086ee6ec58cdf0d9e/src/utxo.js
@@ -57,7 +59,14 @@ export class Utxo {
     }
 
     async getCommitment(): Promise<string> {
-        return this.lightWasm.poseidonHashString([this.amount.toString(), this.keypair.pubkey.toString(), this.blinding.toString(), this.mintAddress]);
+        // 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([
+            this.amount.toString(),
+            this.keypair.pubkey.toString(),
+            this.blinding.toString(),
+            mintAddressField
+        ]);
     }
 
     async getNullifier(): Promise<string> {

package/src/utils/address_lookup_table.ts

@@ -1,7 +1,17 @@
-import { 
-  Connection, 
-  PublicKey
+import {
+  Connection,
+  Keypair,
+  PublicKey,
+  SystemProgram,
+  AddressLookupTableProgram,
+  Transaction,
+  sendAndConfirmTransaction,
+  ComputeBudgetProgram,
+  VersionedTransaction,
+  TransactionMessage
 } from '@solana/web3.js';
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token';
+
 
 /**
  * Helper function to use an existing ALT (recommended for production)
@@ -14,16 +24,54 @@ export async function useExistingALT(
   try {
     console.log(`Using existing ALT: ${altAddress.toString()}`);
     const altAccount = await connection.getAddressLookupTable(altAddress);
-    
+
     if (altAccount.value) {
       console.log(`✅ ALT found with ${altAccount.value.state.addresses.length} addresses`);
     } else {
       console.log('❌ ALT not found');
     }
-    
+
     return altAccount;
   } catch (error) {
     console.error('Error getting existing ALT:', error);
     return null;
   }
-} 
+}
+
+
+export function getProtocolAddressesWithMint(
+  programId: PublicKey,
+  authority: PublicKey,
+  treeAta: PublicKey,
+  feeRecipient: PublicKey,
+  feeRecipientAta: PublicKey
+): PublicKey[] {
+  // Derive global config PDA
+  const [globalConfigAccount] = PublicKey.findProgramAddressSync(
+    [Buffer.from('global_config')],
+    programId
+  );
+
+  // Derive tree accounts
+  const [treeAccount] = PublicKey.findProgramAddressSync(
+    [Buffer.from('merkle_tree')],
+    programId
+  );
+
+  return [
+    // Core program accounts (constant)
+    programId,
+    treeAccount,
+    treeAta,
+    globalConfigAccount,
+    authority,
+    feeRecipient,
+    feeRecipientAta,
+
+    // System programs (constant)
+    SystemProgram.programId,
+    ComputeBudgetProgram.programId,
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+    TOKEN_PROGRAM_ID,
+  ];
+}

package/src/utils/constants.ts

@@ -5,22 +5,27 @@ export const FIELD_SIZE = new BN('2188824287183927522224640574525727508854836440
 
 export const PROGRAM_ID = new PublicKey('9fhQBbumKEFuXtMBDw8AaQyAjCorLGJQiS3skWZdQyQD');
 
-export const DEPLOYER_ID = new PublicKey('AWexibGxNFKTa1b5R5MN4PJr9HWnWRwf8EW9g8cLx3dM')
+export const DEPLOYER_ID = new PublicKey('97rSMQUukMDjA7PYErccyx7ZxbHvSDaeXp2ig5BwSrTf')
 
+//BxuZn19npE43qkrQycBSb12vgruyD3vLygxwZss7eXLU
 export const FEE_RECIPIENT = new PublicKey('AWexibGxNFKTa1b5R5MN4PJr9HWnWRwf8EW9g8cLx3dM')
 
 export const FETCH_UTXOS_GROUP_SIZE = 10_000
 
 export const TRANSACT_IX_DISCRIMINATOR = Buffer.from([217, 149, 130, 143, 221, 52, 252, 119]);
 
+export const TRANSACT_SPL_IX_DISCRIMINATOR = Buffer.from([154, 66, 244, 204, 78, 225, 163, 151]);
+
 export const MERKLE_TREE_DEPTH = 26;
 
-export const ALT_ADDRESS = new PublicKey('72bpRay17JKp4k8H87p7ieU9C6aRDy5yCqwvtpTN2wuU');
+export const ALT_ADDRESS = new PublicKey('HEN49U2ySJ85Vc78qprSW9y6mFDhs1NczRxyppNHjofe');
 
-export const INDEXER_API_URL = process.env.NEXT_PUBLIC_INDEXER_API_URL ?? 'https://api3.privacycash.org';
+export const RELAYER_API_URL = process.env.NEXT_PUBLIC_RELAYER_API_URL ?? 'https://api3.privacycash.org';
 
 export const SIGN_MESSAGE = `Privacy Money account sign in`
 
 // localStorage cache keys
 export const LSK_FETCH_OFFSET = 'fetch_offset'
 export const LSK_ENCRYPTED_OUTPUTS = 'encrypted_outputs'
+
+export const USDC_MINT = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')

package/src/utils/encryption.ts

@@ -5,7 +5,7 @@ import { Utxo } from '../models/utxo.js';
 import { WasmFactory } from '@lightprotocol/hasher.rs';
 import { Keypair as UtxoKeypair } from '../models/keypair.js';
 import { keccak256 } from '@ethersproject/keccak256';
-import { PROGRAM_ID, TRANSACT_IX_DISCRIMINATOR } from './constants.js';
+import { PROGRAM_ID, TRANSACT_IX_DISCRIMINATOR, TRANSACT_SPL_IX_DISCRIMINATOR } from './constants.js';
 import BN from 'bn.js';
 
 
@@ -426,16 +426,19 @@ export class EncryptionService {// Version identifier for encryption scheme (8-b
   }
 }
 
-export function serializeProofAndExtData(proof: any, extData: any) {
+export function serializeProofAndExtData(proof: any, extData: any, isSpl: boolean = false) {
   // Create the ExtDataMinified object for the program call (only extAmount and fee)
   const extDataMinified = {
     extAmount: extData.extAmount,
     fee: extData.fee
   };
 
+  // Use the appropriate discriminator based on whether this is SPL or native SOL
+  const discriminator = isSpl ? TRANSACT_SPL_IX_DISCRIMINATOR : TRANSACT_IX_DISCRIMINATOR;
+
   // Use the same serialization approach as deposit script
   const instructionData = Buffer.concat([
-    TRANSACT_IX_DISCRIMINATOR,
+    discriminator,
     // Serialize proof
     Buffer.from(proof.proofA),
     Buffer.from(proof.proofB),

package/src/utils/prover.ts

@@ -23,7 +23,14 @@ type WtnsModule = {
 }
 
 type Groth16Module = {
-  fullProve: (input: any, wasmFile: string, zkeyFile: string) => Promise<{ proof: Proof; publicSignals: string[] }>
+  fullProve: (
+    input: any,
+    wasmFile: string,
+    zkeyFile: string,
+    logger?: any,
+    wtnsCalcOptions?: { singleThread?: boolean },
+    proverOptions?: { singleThread?: boolean }
+  ) => Promise<{ proof: Proof; publicSignals: string[] }>
   verify: (vkeyData: any, publicSignals: any, proof: Proof) => Promise<boolean>
 }
 
@@ -53,23 +60,49 @@ interface ProofResult {
 
 /**
  * Generates a ZK proof using snarkjs and formats it for use on-chain
- * 
+ *
  * @param input The circuit inputs to generate a proof for
  * @param keyBasePath The base path for the circuit keys (.wasm and .zkey files)
+ * @param options Optional proof generation options (e.g., singleThread for Deno/Bun)
  * @returns A proof object with formatted proof elements and public signals
  */
-async function prove(input: any, keyBasePath: string): Promise<{
+async function prove(input: any, keyBasePath: string, options?: { singleThread?: boolean }): Promise<{
   proof: Proof
   publicSignals: string[];
 }> {
+  // Detect if we should use single-threaded mode (for Deno/Bun compatibility)
+  const useSingleThread = options?.singleThread ?? shouldUseSingleThread();
+
+  // Single-thread options need to be passed to BOTH witness calculation AND proving
+  const singleThreadOpts = useSingleThread ? { singleThread: true } : undefined;
 
+  // Call fullProve with all parameters:
+  // 1. input, 2. wasmFile, 3. zkeyFile, 4. logger, 5. wtnsCalcOptions, 6. proverOptions
   return await groth16Typed.fullProve(
     utilsTyped.stringifyBigInts(input),
     `${keyBasePath}.wasm`,
     `${keyBasePath}.zkey`,
+    undefined, // logger parameter
+    singleThreadOpts, // wtnsCalcOptions (5th param) - for witness calculation
+    singleThreadOpts  // proverOptions (6th param) - for proving
   )
 }
 
+/**
+ * Detect if single-threaded mode should be used
+ */
+function shouldUseSingleThread(): boolean {
+  // @ts-ignore - Deno global
+  if (typeof Deno !== 'undefined') {
+    return true; // Deno has worker issues
+  }
+  // @ts-ignore - Bun global
+  if (typeof Bun !== 'undefined') {
+    return true; // Bun may have worker issues
+  }
+  return false;
+}
+
 export function parseProofToBytesArray(
   proof: Proof,
   compressed: boolean = false,

package/src/utils/utils.ts

@@ -10,7 +10,7 @@ import { Utxo } from '../models/utxo.js';
 import * as borsh from 'borsh';
 import { sha256 } from '@ethersproject/sha2';
 import { PublicKey } from '@solana/web3.js';
-import { INDEXER_API_URL, PROGRAM_ID } from './constants.js';
+import { RELAYER_API_URL, PROGRAM_ID } from './constants.js';
 import { logger } from './logger.js';
 import { getConfig } from '../config.js';
 
@@ -115,12 +115,16 @@ export function getExtDataHash(extData: {
 
 
 // Function to fetch Merkle proof from API for a given commitment
-export async function fetchMerkleProof(commitment: string): Promise<{ pathElements: string[], pathIndices: number[] }> {
+export async function fetchMerkleProof(commitment: string, tokenName?: string): Promise<{ pathElements: string[], pathIndices: number[] }> {
   try {
     logger.debug(`Fetching Merkle proof for commitment: ${commitment}`);
-    const response = await fetch(`${INDEXER_API_URL}/merkle/proof/${commitment}`);
+    let url = `${RELAYER_API_URL}/merkle/proof/${commitment}`
+    if (tokenName) {
+      url += '?token=' + tokenName
+    }
+    const response = await fetch(url);
     if (!response.ok) {
-      throw new Error(`Failed to fetch Merkle proof: ${response.status} ${response.statusText}`);
+      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`);
@@ -147,10 +151,14 @@ export function findNullifierPDAs(proof: any) {
 }
 
 // Function to query remote tree state from indexer API
-export async function queryRemoteTreeState(): Promise<{ root: string, nextIndex: number }> {
+export async function queryRemoteTreeState(tokenName?: string): Promise<{ root: string, nextIndex: number }> {
   try {
     logger.debug('Fetching Merkle root and nextIndex from API...');
-    const response = await fetch(`${INDEXER_API_URL}/merkle/root`);
+    let url = `${RELAYER_API_URL}/merkle/root`
+    if (tokenName) {
+      url += '?token=' + tokenName
+    }
+    const response = await fetch(url);
     if (!response.ok) {
       throw new Error(`Failed to fetch Merkle root and nextIndex: ${response.status} ${response.statusText}`);
     }
@@ -196,4 +204,19 @@ export function findCrossCheckNullifierPDAs(proof: any) {
   );
 
   return { nullifier2PDA, nullifier3PDA };
+}
+
+export function getMintAddressField(mint: PublicKey): string {
+  const mintStr = mint.toString();
+
+  // Special case for SOL (system program)
+  if (mintStr === '11111111111111111111111111111112') {
+    return mintStr;
+  }
+
+  // For SPL tokens (USDC, USDT, etc): use first 31 bytes (248 bits)
+  // This provides better collision resistance than 8 bytes while still fitting in the field
+  // We will only suppport private SOL, USDC and USDT send, so there won't be any collision.
+  const mintBytes = mint.toBytes();
+  return new BN(mintBytes.slice(0, 31), 'be').toString();
 }

package/src/withdraw.ts

@@ -6,7 +6,7 @@ import * as hasher from '@lightprotocol/hasher.rs';
 import { Utxo } from './models/utxo.js';
 import { parseProofToBytesArray, parseToBytesArray, prove } from './utils/prover.js';
 
-import { ALT_ADDRESS, DEPLOYER_ID, FEE_RECIPIENT, FIELD_SIZE, INDEXER_API_URL, MERKLE_TREE_DEPTH, PROGRAM_ID } from './utils/constants.js';
+import { ALT_ADDRESS, DEPLOYER_ID, FEE_RECIPIENT, FIELD_SIZE, RELAYER_API_URL, MERKLE_TREE_DEPTH, PROGRAM_ID } from './utils/constants.js';
 import { EncryptionService, serializeProofAndExtData } from './utils/encryption.js';
 import { fetchMerkleProof, findNullifierPDAs, getExtDataHash, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs } from './utils/utils.js';
 
@@ -20,7 +20,7 @@ import { getConfig } from './config.js';
 async function submitWithdrawToIndexer(params: any): Promise<string> {
     try {
 
-        const response = await fetch(`${INDEXER_API_URL}/withdraw`, {
+        const response = await fetch(`${RELAYER_API_URL}/withdraw`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -319,7 +319,7 @@ export async function withdraw({ recipient, lightWasm, storage, publicKey, conne
         console.log(`retryTimes: ${retryTimes}`)
         await new Promise(resolve => setTimeout(resolve, itv * 1000));
         console.log('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()
         console.log('resJson:', resJson)
         if (resJson.exists) {
@@ -331,4 +331,4 @@ export async function withdraw({ recipient, lightWasm, storage, publicKey, conne
         retryTimes++
     }
 
-}
+}