privacycash 1.0.17 → 1.0.19

package/dist/index.js

@@ -1,7 +1,8 @@
 import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js';
 import { deposit } from './deposit.js';
 import { getBalanceFromUtxos, getUtxos, localstorageKey } from './getUtxos.js';
-import { LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET } from './utils/constants.js';
+import { getBalanceFromUtxosSPL, getUtxosSPL } from './getUtxosSPL.js';
+import { LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET, USDC_MINT } from './utils/constants.js';
 import { logger, setLogger } from './utils/logger.js';
 import { EncryptionService } from './utils/encryption.js';
 import { WasmFactory } from '@lightprotocol/hasher.rs';
@@ -9,6 +10,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"));
 export class PrivacyCash {
     connection;
@@ -57,6 +61,13 @@ 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;
     }
     /**
@@ -84,6 +95,30 @@ export class PrivacyCash {
         this.isRuning = false;
         return res;
     }
+    /**
+    * Deposit USDC to the Privacy Cash.
+    */
+    async depositUSDC({ base_units }) {
+        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) => {
+                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.
      *
@@ -108,16 +143,51 @@ export class PrivacyCash {
         this.isRuning = false;
         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 }) {
+        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) {
         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/dist/models/utxo.js

@@ -7,6 +7,8 @@
 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';
 /**
  * Simplified Utxo class inspired by Tornado Cash Nova
  * Based on: https://github.com/tornadocash/tornado-nova/blob/f9264eeffe48bf5e04e19d8086ee6ec58cdf0d9e/src/utxo.js
@@ -40,7 +42,14 @@ export class Utxo {
         this.version = version;
     }
     async getCommitment() {
-        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() {
         const commitmentValue = await this.getCommitment();

package/dist/utils/address_lookup_table.d.ts

@@ -6,3 +6,4 @@ import { Connection, PublicKey } from '@solana/web3.js';
 export declare function useExistingALT(connection: Connection, altAddress: PublicKey): Promise<{
     value: any;
 } | null>;
+export declare function getProtocolAddressesWithMint(programId: PublicKey, authority: PublicKey, treeAta: PublicKey, feeRecipient: PublicKey, feeRecipientAta: PublicKey): PublicKey[];

package/dist/utils/address_lookup_table.js

@@ -1,3 +1,5 @@
+import { PublicKey, SystemProgram, ComputeBudgetProgram } 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)
  * Use create_alt.ts to create the ALT once, then hardcode the address and use this function
@@ -19,3 +21,24 @@ export async function useExistingALT(connection, altAddress) {
         return null;
     }
 }
+export function getProtocolAddressesWithMint(programId, authority, treeAta, feeRecipient, feeRecipientAta) {
+    // 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/dist/utils/constants.d.ts

@@ -2,13 +2,14 @@ import { PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 export declare const FIELD_SIZE: BN;
 export declare const PROGRAM_ID: PublicKey;
-export declare const DEPLOYER_ID: PublicKey;
 export declare const FEE_RECIPIENT: PublicKey;
 export declare const FETCH_UTXOS_GROUP_SIZE = 10000;
 export declare const TRANSACT_IX_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const TRANSACT_SPL_IX_DISCRIMINATOR: Buffer<ArrayBuffer>;
 export declare const MERKLE_TREE_DEPTH = 26;
 export declare const ALT_ADDRESS: PublicKey;
-export declare const INDEXER_API_URL: string;
+export declare const RELAYER_API_URL: string;
 export declare const SIGN_MESSAGE = "Privacy Money account sign in";
 export declare const LSK_FETCH_OFFSET = "fetch_offset";
 export declare const LSK_ENCRYPTED_OUTPUTS = "encrypted_outputs";
+export declare const USDC_MINT: PublicKey;

package/dist/utils/constants.js

@@ -1,15 +1,16 @@
 import { PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 export const FIELD_SIZE = new BN('21888242871839275222246405745257275088548364400416034343698204186575808495617');
-export const PROGRAM_ID = new PublicKey('9fhQBbumKEFuXtMBDw8AaQyAjCorLGJQiS3skWZdQyQD');
-export const DEPLOYER_ID = new PublicKey('AWexibGxNFKTa1b5R5MN4PJr9HWnWRwf8EW9g8cLx3dM');
+export const PROGRAM_ID = process.env.NEXT_PUBLIC_PROGRAM_ID ? new PublicKey(process.env.NEXT_PUBLIC_PROGRAM_ID) : new PublicKey('9fhQBbumKEFuXtMBDw8AaQyAjCorLGJQiS3skWZdQyQD');
 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 INDEXER_API_URL = process.env.NEXT_PUBLIC_INDEXER_API_URL ?? 'https://api3.privacycash.org';
+export const ALT_ADDRESS = process.env.NEXT_PUBLIC_ALT_ADDRESS ? new PublicKey(process.env.NEXT_PUBLIC_ALT_ADDRESS) : new PublicKey('HEN49U2ySJ85Vc78qprSW9y6mFDhs1NczRxyppNHjofe');
+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 = process.env.NEXT_PUBLIC_USDC_MINT ? new PublicKey(process.env.NEXT_PUBLIC_USDC_MINT) : new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');

package/dist/utils/encryption.d.ts

@@ -104,4 +104,4 @@ export declare class EncryptionService {
      */
     getUtxoPrivateKeyV2(): string;
 }
-export declare function serializeProofAndExtData(proof: any, extData: any): Buffer<ArrayBuffer>;
+export declare function serializeProofAndExtData(proof: any, extData: any, isSpl?: boolean): Buffer<ArrayBuffer>;

package/dist/utils/encryption.js

@@ -4,7 +4,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 { TRANSACT_IX_DISCRIMINATOR } from './constants.js';
+import { TRANSACT_IX_DISCRIMINATOR, TRANSACT_SPL_IX_DISCRIMINATOR } from './constants.js';
 import BN from 'bn.js';
 /**
  * Service for handling encryption and decryption of UTXO data
@@ -341,15 +341,17 @@ export class EncryptionService {
         return this.utxoPrivateKeyV2;
     }
 }
-export function serializeProofAndExtData(proof, extData) {
+export function serializeProofAndExtData(proof, extData, isSpl = 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/dist/utils/utils.d.ts

@@ -40,7 +40,7 @@ export declare function getExtDataHash(extData: {
     feeRecipient: string | PublicKey;
     mintAddress: string | PublicKey;
 }): Uint8Array;
-export declare function fetchMerkleProof(commitment: string): Promise<{
+export declare function fetchMerkleProof(commitment: string, tokenName?: string): Promise<{
     pathElements: string[];
     pathIndices: number[];
 }>;
@@ -48,7 +48,7 @@ export declare function findNullifierPDAs(proof: any): {
     nullifier0PDA: PublicKey;
     nullifier1PDA: PublicKey;
 };
-export declare function queryRemoteTreeState(): Promise<{
+export declare function queryRemoteTreeState(tokenName?: string): Promise<{
     root: string;
     nextIndex: number;
 }>;
@@ -61,3 +61,4 @@ export declare function findCrossCheckNullifierPDAs(proof: any): {
     nullifier2PDA: PublicKey;
     nullifier3PDA: PublicKey;
 };
+export declare function getMintAddressField(mint: PublicKey): string;

package/dist/utils/utils.js

@@ -8,7 +8,7 @@ import BN from 'bn.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';
 /**
@@ -91,12 +91,16 @@ 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) {
+export async function fetchMerkleProof(commitment, tokenName) {
     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();
         logger.debug(`✓ Fetched Merkle proof with ${data.pathElements.length} elements`);
@@ -114,10 +118,14 @@ export function findNullifierPDAs(proof) {
     return { nullifier0PDA, nullifier1PDA };
 }
 // Function to query remote tree state from indexer API
-export async function queryRemoteTreeState() {
+export async function queryRemoteTreeState(tokenName) {
     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}`);
         }
@@ -143,3 +151,15 @@ export function findCrossCheckNullifierPDAs(proof) {
     const [nullifier3PDA] = PublicKey.findProgramAddressSync([Buffer.from("nullifier1"), Buffer.from(proof.inputNullifiers[0])], PROGRAM_ID);
     return { nullifier2PDA, nullifier3PDA };
 }
+export function getMintAddressField(mint) {
+    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/dist/withdraw.js

@@ -4,7 +4,7 @@ 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, DEPLOYER_ID, FEE_RECIPIENT, FIELD_SIZE, INDEXER_API_URL, MERKLE_TREE_DEPTH } from './utils/constants.js';
+import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, RELAYER_API_URL, MERKLE_TREE_DEPTH } from './utils/constants.js';
 import { serializeProofAndExtData } from './utils/encryption.js';
 import { fetchMerkleProof, findNullifierPDAs, getExtDataHash, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs } from './utils/utils.js';
 import { getUtxos } from './getUtxos.js';
@@ -14,7 +14,7 @@ import { getConfig } from './config.js';
 // Function to submit withdraw request to indexer backend
 async function submitWithdrawToIndexer(params) {
     try {
-        const response = await fetch(`${INDEXER_API_URL}/withdraw`, {
+        const response = await fetch(`${RELAYER_API_URL}/withdraw`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -40,7 +40,6 @@ export async function withdraw({ recipient, lightWasm, storage, publicKey, conne
     amount_in_lamports -= fee_in_lamports;
     let isPartial = false;
     logger.debug('Encryption key generated from user keypair');
-    logger.debug(`Deployer wallet: ${DEPLOYER_ID.toString()}`);
     const { treeAccount, treeTokenAccount, globalConfigAccount } = getProgramAccounts();
     // Get current tree state
     const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState();
@@ -257,7 +256,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) {

package/dist/withdrawSPL.d.ts

@@ -0,0 +1,22 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import * as hasher from '@lightprotocol/hasher.rs';
+import { EncryptionService } from './utils/encryption.js';
+type WithdrawParams = {
+    publicKey: PublicKey;
+    connection: Connection;
+    base_units: number;
+    keyBasePath: string;
+    encryptionService: EncryptionService;
+    lightWasm: hasher.LightWasm;
+    recipient: PublicKey;
+    mintAddress: PublicKey;
+    storage: Storage;
+};
+export declare function withdrawSPL({ recipient, lightWasm, storage, publicKey, connection, base_units, encryptionService, keyBasePath, mintAddress }: WithdrawParams): Promise<{
+    isPartial: boolean;
+    tx: string;
+    recipient: string;
+    base_units: number;
+    fee_base_units: number;
+}>;
+export {};