privacycash 1.0.21 → 1.1.1

package/dist/index.js

@@ -2,7 +2,7 @@ import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.j
 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, USDC_MINT } from './utils/constants.js';
+import { LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET, tokens, 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';
@@ -62,9 +62,8 @@ 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);
+        for (let token of tokens) {
+            let ata = await getAssociatedTokenAddress(token.pubkey, this.publicKey);
             storage.removeItem(LSK_FETCH_OFFSET + localstorageKey(ata));
             storage.removeItem(LSK_ENCRYPTED_OUTPUTS + localstorageKey(ata));
         }
@@ -139,7 +138,7 @@ export class PrivacyCash {
             keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
             storage
         });
-        console.log(`Withdraw successful. Recipient ${recipient} received ${res.amount_in_lamports / LAMPORTS_PER_SOL} SOL, with ${res.fee_in_lamports / LAMPORTS_PER_SOL} SOL relayers fees`);
+        logger.debug(`Withdraw successful. Recipient ${recipient} received ${res.amount_in_lamports / LAMPORTS_PER_SOL} SOL, with ${res.fee_in_lamports / LAMPORTS_PER_SOL} SOL relayers fees`);
         this.isRuning = false;
         return res;
     }
@@ -164,7 +163,7 @@ export class PrivacyCash {
             keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
             storage
         });
-        console.log(`Withdraw successful. Recipient ${recipient} received ${base_units} USDC units`);
+        logger.debug(`Withdraw successful. Recipient ${recipient} received ${base_units} USDC units`);
         this.isRuning = false;
         return res;
     }
@@ -179,7 +178,7 @@ export class PrivacyCash {
         return getBalanceFromUtxos(utxos);
     }
     /**
-    * Returns the amount of lamports current wallet has in Privacy Cash.
+    * Returns the amount of base unites current wallet has in Privacy Cash.
     */
     async getPrivateBalanceUSDC() {
         logger.info('getting private balance');
@@ -188,6 +187,21 @@ export class PrivacyCash {
         this.isRuning = false;
         return getBalanceFromUtxosSPL(utxos);
     }
+    /**
+    * Returns the amount of base unites current wallet has in Privacy Cash.
+    */
+    async getPrivateBalanceSpl(mintAddress) {
+        this.isRuning = true;
+        let utxos = await getUtxosSPL({
+            publicKey: this.publicKey,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            storage,
+            mintAddress
+        });
+        this.isRuning = false;
+        return getBalanceFromUtxosSPL(utxos);
+    }
     /**
      * Returns true if the code is running in a browser.
      */
@@ -206,6 +220,55 @@ export class PrivacyCash {
             await new Promise(r => setTimeout(r, 250));
         }
     }
+    /**
+   * Deposit SPL to the Privacy Cash.
+   */
+    async depositSPL({ base_units, mintAddress, amount }) {
+        this.isRuning = true;
+        logger.info('start depositting');
+        let lightWasm = await WasmFactory.getInstance();
+        let res = await depositSPL({
+            lightWasm,
+            base_units,
+            amount,
+            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,
+            mintAddress
+        });
+        this.isRuning = false;
+        return res;
+    }
+    /**
+      * Withdraw SPL from the Privacy Cash.
+      */
+    async withdrawSPL({ base_units, mintAddress, recipientAddress, amount }) {
+        this.isRuning = true;
+        logger.info('start withdrawing');
+        let lightWasm = await WasmFactory.getInstance();
+        let recipient = recipientAddress ? new PublicKey(recipientAddress) : this.publicKey;
+        let res = await withdrawSPL({
+            lightWasm,
+            base_units,
+            amount,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            publicKey: this.publicKey,
+            recipient,
+            keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
+            storage,
+            mintAddress
+        });
+        logger.debug(`Withdraw successful. Recipient ${recipient} received ${base_units} USDC units`);
+        this.isRuning = false;
+        return res;
+    }
 }
 function getSolanaKeypair(secret) {
     try {

package/dist/utils/address_lookup_table.js

@@ -1,18 +1,19 @@
 import { PublicKey, SystemProgram, ComputeBudgetProgram } from '@solana/web3.js';
 import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { logger } from './logger';
 /**
  * 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
  */
 export async function useExistingALT(connection, altAddress) {
     try {
-        console.log(`Using existing ALT: ${altAddress.toString()}`);
+        logger.debug(`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`);
+            logger.debug(`✅ ALT found with ${altAccount.value.state.addresses.length} addresses`);
         }
         else {
-            console.log('❌ ALT not found');
+            logger.error('❌ ALT not found');
         }
         return altAccount;
     }

package/dist/utils/constants.d.ts

@@ -13,3 +13,15 @@ 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;
+declare const tokenList: readonly ["sol", "usdc", "usdt", "zec", "ore"];
+export type TokenList = typeof tokenList[number];
+declare const splList: readonly ["usdc", "usdt", "ore"];
+export type SplList = typeof splList[number];
+export type Token = {
+    name: 'sol' | 'usdc' | 'usdt' | 'zec' | 'ore';
+    prefix: string;
+    units_per_token: number;
+    pubkey: PublicKey;
+};
+export declare const tokens: Token[];
+export {};

package/dist/utils/constants.js

@@ -14,3 +14,37 @@ export const SIGN_MESSAGE = `Privacy Money account sign in`;
 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');
+const tokenList = ['sol', 'usdc', 'usdt', 'zec', 'ore'];
+const splList = ['usdc', 'usdt', 'ore'];
+export const tokens = [
+    {
+        name: 'sol',
+        pubkey: new PublicKey('So11111111111111111111111111111111111111112'),
+        prefix: '',
+        units_per_token: 1e9
+    },
+    {
+        name: 'usdc',
+        pubkey: process.env.NEXT_PUBLIC_USDC_MINT ? new PublicKey(process.env.NEXT_PUBLIC_USDC_MINT) : new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
+        prefix: 'usdc_',
+        units_per_token: 1e6
+    },
+    {
+        name: 'usdt',
+        pubkey: process.env.NEXT_PUBLIC_USDT_MINT ? new PublicKey(process.env.NEXT_PUBLIC_USDT_MINT) : new PublicKey('Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB'),
+        prefix: 'usdt_',
+        units_per_token: 1e6
+    },
+    {
+        name: 'zec',
+        pubkey: process.env.NEXT_PUBLIC_ZEC_MINT ? new PublicKey(process.env.NEXT_PUBLIC_ZEC_MINT) : new PublicKey('A7bdiYdS5GjqGFtxf17ppRHtDKPkkRqbKtR27dxvQXaS'),
+        prefix: 'zec_',
+        units_per_token: 1e8
+    },
+    {
+        name: 'ore',
+        pubkey: process.env.NEXT_PUBLIC_ORE_MINT ? new PublicKey(process.env.NEXT_PUBLIC_ORE_MINT) : new PublicKey('oreoU2P8bN6jkk3jbaiVxYnG1dCXcYxwhwyK9jSybcp'),
+        prefix: 'ore_',
+        units_per_token: 1e11
+    }
+];

package/dist/withdraw.js

@@ -253,12 +253,12 @@ export async function withdraw({ recipient, lightWasm, storage, publicKey, conne
     const encryptedOutputStr = Buffer.from(encryptedOutput1).toString('hex');
     let start = Date.now();
     while (true) {
-        console.log(`retryTimes: ${retryTimes}`);
+        logger.info(`retryTimes: ${retryTimes}`);
         await new Promise(resolve => setTimeout(resolve, itv * 1000));
-        console.log('Fetching updated tree state...');
+        logger.info('Fetching updated tree state...');
         let res = await fetch(RELAYER_API_URL + '/utxos/check/' + encryptedOutputStr);
         let resJson = await res.json();
-        console.log('resJson:', resJson);
+        logger.debug('resJson:', resJson);
         if (resJson.exists) {
             return { isPartial, tx: signature, recipient: recipient.toString(), amount_in_lamports, fee_in_lamports };
         }

package/dist/withdrawSPL.d.ts

@@ -4,15 +4,16 @@ import { EncryptionService } from './utils/encryption.js';
 type WithdrawParams = {
     publicKey: PublicKey;
     connection: Connection;
-    base_units: number;
+    base_units?: number;
+    amount?: number;
     keyBasePath: string;
     encryptionService: EncryptionService;
     lightWasm: hasher.LightWasm;
     recipient: PublicKey;
-    mintAddress: PublicKey;
+    mintAddress: PublicKey | string;
     storage: Storage;
 };
-export declare function withdrawSPL({ recipient, lightWasm, storage, publicKey, connection, base_units, encryptionService, keyBasePath, mintAddress }: WithdrawParams): Promise<{
+export declare function withdrawSPL({ recipient, lightWasm, storage, publicKey, connection, base_units, amount, encryptionService, keyBasePath, mintAddress }: WithdrawParams): Promise<{
     isPartial: boolean;
     tx: string;
     recipient: string;

package/dist/withdrawSPL.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, 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, MERKLE_TREE_DEPTH, PROGRAM_ID, tokens } 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';
@@ -36,26 +36,43 @@ async function submitWithdrawToIndexer(params) {
         throw error;
     }
 }
-export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, connection, base_units, encryptionService, keyBasePath, mintAddress }) {
-    let mintInfo = await getMint(connection, mintAddress);
+export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, connection, base_units, amount, encryptionService, keyBasePath, mintAddress }) {
+    if (typeof mintAddress == 'string') {
+        mintAddress = new PublicKey(mintAddress);
+    }
+    let token = tokens.find(t => t.pubkey.toString() == mintAddress.toString());
+    if (!token) {
+        throw new Error('token not found: ' + mintAddress.toString());
+    }
+    if (amount) {
+        base_units = amount * token.units_per_token;
+    }
+    if (!base_units) {
+        throw new Error('You must input at leaset one of "base_units" or "amount"');
+    }
+    let mintInfo = await getMint(connection, token.pubkey);
     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);
+    let withdraw_rent_fees = await getConfig('rent_fees');
+    let token_rent_fee = withdraw_rent_fees[token.name];
+    if (!token_rent_fee) {
+        throw new Error('can not find token_rent_fee for ' + token.name);
+    }
+    let fee_base_units = Math.floor(base_units * withdraw_fee_rate + units_per_token * token_rent_fee);
     base_units -= fee_base_units;
     if (base_units <= 0) {
-        throw new Error('withdraw amount too low');
+        throw new Error('withdraw amount too low, at least ' + fee_base_units / token_rent_fee);
     }
     let isPartial = false;
-    let recipient_ata = getAssociatedTokenAddressSync(mintAddress, recipient, true);
-    let feeRecipientTokenAccount = getAssociatedTokenAddressSync(mintAddress, FEE_RECIPIENT, true);
-    let signerTokenAccount = getAssociatedTokenAddressSync(mintAddress, publicKey);
+    let recipient_ata = getAssociatedTokenAddressSync(token.pubkey, recipient, true);
+    let feeRecipientTokenAccount = getAssociatedTokenAddressSync(token.pubkey, FEE_RECIPIENT, true);
+    let signerTokenAccount = getAssociatedTokenAddressSync(token.pubkey, 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 [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('usdc');
+    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
@@ -69,7 +86,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
     // 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`);
+    logger.debug(`Found ${mintUtxos.length} total UTXOs for ${token.name}`);
     // 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)`);
@@ -84,7 +101,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
         lightWasm,
         keypair: utxoKeypair,
         amount: '0',
-        mintAddress: mintAddress.toString()
+        mintAddress: token.pubkey.toString()
     });
     const inputs = [firstInput, secondInput];
     logger.debug(`firstInput index: ${firstInput.index}, commitment: ${firstInput.getCommitment()}`);
@@ -113,7 +130,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
         }
         // For real UTXOs, fetch the proof from API
         const commitment = await utxo.getCommitment();
-        return fetchMerkleProof(commitment, 'usdc');
+        return fetchMerkleProof(commitment, token.name);
     }));
     // Extract path elements and indices
     const inputMerklePathElements = inputMerkleProofs.map(proof => proof.pathElements);
@@ -125,14 +142,14 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
             amount: changeAmount.toString(),
             keypair: utxoKeypairV2,
             index: currentNextIndex,
-            mintAddress: mintAddress.toString()
+            mintAddress: token.pubkey.toString()
         }), // Change output
         new Utxo({
             lightWasm,
             amount: '0',
             keypair: utxoKeypairV2,
             index: currentNextIndex + 1,
-            mintAddress: mintAddress.toString()
+            mintAddress: token.pubkey.toString()
         }) // Empty UTXO
     ];
     // For withdrawals, extAmount is negative (funds leaving the system)
@@ -185,7 +202,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
         encryptedOutput2: encryptedOutput2,
         fee: new BN(fee_base_units),
         feeRecipient: feeRecipientTokenAccount,
-        mintAddress: mintAddress.toString()
+        mintAddress: token.pubkey.toString()
     };
     // Calculate the extDataHash with the encrypted outputs
     const calculatedExtDataHash = getExtDataHash(extData);
@@ -193,7 +210,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
     const input = {
         // Common transaction data
         root: root,
-        mintAddress: getMintAddressField(mintAddress), // new mint address
+        mintAddress: getMintAddressField(token.pubkey), // 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
@@ -239,7 +256,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
     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);
+    const treeAta = getAssociatedTokenAddressSync(token.pubkey, globalConfigPda, true);
     // Prepare withdraw parameters for indexer backend
     const withdrawParams = {
         serializedProof: serializedProof.toString('base64'),
@@ -258,7 +275,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
         senderAddress: publicKey.toString(),
         treeAta: treeAta.toString(),
         recipientAta: recipient_ata.toString(),
-        mintAddress: mintAddress.toString(),
+        mintAddress: token.pubkey.toString(),
         feeRecipientTokenAccount: feeRecipientTokenAccount.toString()
     };
     logger.debug('Prepared withdraw parameters for indexer backend');
@@ -272,12 +289,12 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
     const encryptedOutputStr = Buffer.from(encryptedOutput1).toString('hex');
     let start = Date.now();
     while (true) {
-        console.log(`retryTimes: ${retryTimes}`);
+        logger.info(`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');
+        logger.info('Fetching updated tree state...');
+        let res = await fetch(RELAYER_API_URL + '/utxos/check/' + encryptedOutputStr + '?token=' + token.name);
         let resJson = await res.json();
-        console.log('resJson:', resJson);
+        logger.debug('resJson:', resJson);
         if (resJson.exists) {
             return { isPartial, tx: signature, recipient: recipient.toString(), base_units, fee_base_units };
         }

package/package.json

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

package/src/config.ts

@@ -5,6 +5,7 @@ type Config = {
     withdraw_rent_fee: number
     deposit_fee_rate: number
     usdc_withdraw_rent_fee: number
+    rent_fees: any
 }
 
 let config: Config | undefined
@@ -14,7 +15,7 @@ export async function getConfig<K extends keyof Config>(key: K): Promise<Config[
         const res = await fetch(RELAYER_API_URL + '/config')
         config = await res.json()
     }
-    if (typeof config![key] != 'number') {
+    if (typeof config![key] == 'undefined') {
         throw new Error(`can not get ${key} from ${RELAYER_API_URL}/config`)
     }
     return config![key]

package/src/deposit.ts

@@ -67,6 +67,7 @@ type DepositParams = {
 export async function deposit({ lightWasm, storage, keyBasePath, publicKey, connection, amount_in_lamports, encryptionService, transactionSigner, referrer }: DepositParams) {
     // check limit
     let limitAmount = await checkDepositLimit(connection)
+
     if (limitAmount && amount_in_lamports > limitAmount * LAMPORTS_PER_SOL) {
         throw new Error(`Don't deposit more than ${limitAmount} SOL`)
     }
@@ -451,11 +452,11 @@ async function checkDepositLimit(connection: Connection) {
         const accountInfo = await connection.getAccountInfo(treeAccount);
 
         if (!accountInfo) {
-            console.error('❌ Tree account not found. Make sure the program is initialized.');
+            console.error('❌ Tree account not found. Make sure the program is initialized.' + PROGRAM_ID);
             return;
         }
 
-        console.log(`Account data size: ${accountInfo.data.length} bytes`);
+        logger.debug(`Account data size: ${accountInfo.data.length} bytes`);
         const authority = new PublicKey(accountInfo.data.slice(8, 40));
         const nextIndex = new BN(accountInfo.data.slice(40, 48), 'le');
         const rootIndex = new BN(accountInfo.data.slice(4112, 4120), 'le');