privacycash 1.0.21 → 1.1.1

package/README.md

@@ -9,11 +9,11 @@ THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR I
 ### Usage
 This SDK provides APIs for developers to interact with Privacy Cash relayers easily. Developers can easily deposit/withdraw/query balances in Privacy Cash solana program.
 
-Main APIs for this SDK are:
-a. for SOL:
-deposit(), withdraw(), getPrivateBalance()
-b. for USDC:
-depositUSDC(), withdrawUSDC(), getPrivateBalanceUSDC()
+Main APIs for this SDK are: 
+a. for SOL: 
+deposit(), withdraw(), getPrivateBalance() 
+b. for SPL (currently supporting USDC and USDT): 
+depositSPL(), withdrawSPL(), getPrivateBalanceSpl()
 
 Check the example project under /example folder. The code should be fairly self-explanatory.
 

package/dist/config.d.ts

@@ -3,6 +3,7 @@ type Config = {
     withdraw_rent_fee: number;
     deposit_fee_rate: number;
     usdc_withdraw_rent_fee: number;
+    rent_fees: any;
 };
 export declare function getConfig<K extends keyof Config>(key: K): Promise<Config[K]>;
 export {};

package/dist/config.js

@@ -5,7 +5,7 @@ export async function getConfig(key) {
         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/dist/deposit.js

@@ -360,10 +360,10 @@ async function checkDepositLimit(connection) {
         // Fetch the account data
         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');

package/dist/depositSPL.d.ts

@@ -2,10 +2,11 @@ import { Connection, PublicKey, VersionedTransaction } from '@solana/web3.js';
 import * as hasher from '@lightprotocol/hasher.rs';
 import { EncryptionService } from './utils/encryption.js';
 type DepositParams = {
-    mintAddress: PublicKey;
+    mintAddress: PublicKey | string;
     publicKey: PublicKey;
     connection: Connection;
-    base_units: number;
+    base_units?: number;
+    amount?: number;
     storage: Storage;
     encryptionService: EncryptionService;
     keyBasePath: string;
@@ -13,7 +14,7 @@ type DepositParams = {
     referrer?: string;
     transactionSigner: (tx: VersionedTransaction) => Promise<VersionedTransaction>;
 };
-export declare function depositSPL({ lightWasm, storage, keyBasePath, publicKey, connection, base_units, encryptionService, transactionSigner, referrer, mintAddress }: DepositParams): Promise<{
+export declare function depositSPL({ lightWasm, storage, keyBasePath, publicKey, connection, base_units, amount, encryptionService, transactionSigner, referrer, mintAddress }: DepositParams): Promise<{
     tx: string;
 }>;
 export {};

package/dist/depositSPL.js

@@ -7,10 +7,10 @@ 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 } from './utils/constants.js';
+import { FIELD_SIZE, FEE_RECIPIENT, MERKLE_TREE_DEPTH, RELAYER_API_URL, PROGRAM_ID, ALT_ADDRESS, tokens } from './utils/constants.js';
 import { useExistingALT } from './utils/address_lookup_table.js';
 import { logger } from './utils/logger.js';
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, getMint, getAccount } from '@solana/spl-token';
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, getAccount } from '@solana/spl-token';
 // Function to relay pre-signed deposit transaction to indexer backend
 async function relayDepositToIndexer({ signedTransaction, publicKey, referrer, mintAddress }) {
     try {
@@ -22,7 +22,7 @@ async function relayDepositToIndexer({ signedTransaction, publicKey, referrer, m
         if (referrer) {
             params.referralWalletAddress = referrer;
         }
-        params.mintAddress = mintAddress.toString();
+        params.mintAddress = mintAddress;
         const response = await fetch(`${RELAYER_API_URL}/deposit/spl`, {
             method: 'POST',
             headers: {
@@ -31,53 +31,68 @@ async function relayDepositToIndexer({ signedTransaction, publicKey, referrer, m
             body: JSON.stringify(params)
         });
         if (!response.ok) {
-            console.log('res text:', await response.json());
+            logger.debug('res text:', await response.text());
             throw new Error('response not ok');
             // const errorData = await response.json() as { error?: string };
             // throw new Error(`Deposit relay failed: ${response.status} ${response.statusText} - ${errorData.error || 'Unknown error'}`);
         }
-        const result = await response.json();
-        logger.debug('Pre-signed deposit transaction relayed successfully!');
-        logger.debug('Response:', result);
+        let result;
+        try {
+            result = await response.json();
+            logger.debug('Pre-signed deposit transaction relayed successfully!');
+            logger.debug('Response:', result);
+        }
+        catch (e) {
+            console.log('response.text', await response.text());
+            throw new Error('failed to parse json');
+        }
         return result.signature;
     }
     catch (error) {
-        console.error('Failed to relay deposit transaction to indexer:', error);
+        console.error('Failed to relay deposit transaction to indexer:', error.message);
         throw error;
     }
 }
-export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, connection, base_units, encryptionService, transactionSigner, referrer, mintAddress }) {
-    let mintInfo = await getMint(connection, mintAddress);
-    let units_per_token = 10 ** mintInfo.decimals;
+export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, connection, base_units, amount, encryptionService, transactionSigner, referrer, 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 least one of "base_units" or "amount"');
+    }
+    // let mintInfo = await getMint(connection, token.pubkey)
+    // let units_per_token = 10 ** mintInfo.decimals
     let recipient = new PublicKey('AWexibGxNFKTa1b5R5MN4PJr9HWnWRwf8EW9g8cLx3dM');
-    let recipient_ata = getAssociatedTokenAddressSync(mintAddress, recipient, true);
-    let feeRecipientTokenAccount = getAssociatedTokenAddressSync(mintAddress, FEE_RECIPIENT, true);
-    let signerTokenAccount = getAssociatedTokenAddressSync(mintAddress, publicKey);
-    // 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);
-    let limitAmount = await checkDepositLimit(connection, treeAccount);
-    if (limitAmount && base_units > limitAmount * 1e6) {
-        throw new Error(`Don't deposit more than ${limitAmount} USDC`);
+    let recipient_ata = getAssociatedTokenAddressSync(token.pubkey, recipient, true);
+    let feeRecipientTokenAccount = getAssociatedTokenAddressSync(token.pubkey, FEE_RECIPIENT, true);
+    let signerTokenAccount = getAssociatedTokenAddressSync(token.pubkey, publicKey);
+    // Derive tree account PDA with mint address for SPL
+    const [treeAccount] = PublicKey.findProgramAddressSync([Buffer.from('merkle_tree'), token.pubkey.toBuffer()], PROGRAM_ID);
+    let limitAmount = await checkDepositLimit(connection, treeAccount, token);
+    if (limitAmount && base_units > limitAmount * token.units_per_token) {
+        throw new Error(`Don't deposit more than ${limitAmount} ${token.name.toUpperCase()}`);
     }
-    // check limit
-    // let limitAmount = await checkDepositLimit(connection)
-    // if (limitAmount && base_units > limitAmount * units_per_token) {
-    //     throw new Error(`Don't deposit more than ${limitAmount} SOL`)
-    // }
     // const base_units = amount_in_sol * units_per_token
     const fee_base_units = 0;
     logger.debug('Encryption key generated from user keypair');
     logger.debug(`User wallet: ${publicKey.toString()}`);
-    logger.debug(`Deposit amount: ${base_units} base_units (${base_units / units_per_token} USDC)`);
-    logger.debug(`Calculated fee: ${fee_base_units} base_units (${fee_base_units / units_per_token} USDC)`);
+    logger.debug(`Deposit amount: ${base_units} base_units (${base_units / token.units_per_token}  ${token.name.toUpperCase()})`);
+    logger.debug(`Calculated fee: ${fee_base_units} base_units (${fee_base_units / token.units_per_token}  ${token.name.toUpperCase()})`);
     // Check SPL balance
     const accountInfo = await getAccount(connection, signerTokenAccount);
     let balance = Number(accountInfo.amount);
-    logger.debug(`USDC wallet balance: ${balance / units_per_token} USDC`);
-    console.log('balance', balance);
-    console.log('base_units + fee_base_units', base_units + fee_base_units);
+    logger.debug(`wallet balance: ${balance / token.units_per_token}  ${token.name.toUpperCase()}`);
+    logger.debug('balance', balance);
+    logger.debug('base_units + fee_base_units', base_units + fee_base_units);
     if (balance < (base_units + fee_base_units)) {
-        throw new Error(`Insufficient balance. Need at least ${(base_units + fee_base_units) / units_per_token} USDC.`);
+        throw new Error(`Insufficient balance. Need at least ${(base_units + fee_base_units) / token.units_per_token}  ${token.name.toUpperCase()}.`);
     }
     // Check SOL balance
     const solBalance = await connection.getBalance(publicKey);
@@ -89,7 +104,7 @@ 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('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
@@ -121,12 +136,12 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
             new Utxo({
                 lightWasm,
                 keypair: utxoKeypair,
-                mintAddress: mintAddress.toString()
+                mintAddress: token.pubkey.toString()
             }),
             new Utxo({
                 lightWasm,
                 keypair: utxoKeypair,
-                mintAddress: mintAddress.toString()
+                mintAddress: token.pubkey.toString()
             })
         ];
         // Both inputs are dummy, so use mock indices and zero-filled Merkle paths
@@ -153,13 +168,12 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
         logger.debug(`Output amount (existing UTXOs + deposit - fee): ${outputAmount}`);
         logger.debug(`External amount (deposit): ${extAmount}`);
         logger.debug('\nFirst UTXO to be consolidated:');
-        await firstUtxo.log();
         // 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,
             amount: '0', // This UTXO will be inserted at currentNextIndex
-            mintAddress: mintAddress.toString()
+            mintAddress: token.pubkey.toString()
         });
         inputs = [
             firstUtxo, // Use the first existing UTXO
@@ -167,12 +181,12 @@ 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, 'usdc');
+        const firstUtxoMerkleProof = await fetchMerkleProof(firstUtxoCommitment, token.name);
         let secondUtxoMerkleProof;
         if (secondUtxo.amount.gt(new BN(0))) {
             // Second UTXO is real, fetch its proof
             const secondUtxoCommitment = await secondUtxo.getCommitment();
-            secondUtxoMerkleProof = await fetchMerkleProof(secondUtxoCommitment, 'usdc');
+            secondUtxoMerkleProof = await fetchMerkleProof(secondUtxoCommitment, token.name);
             logger.debug('\nSecond UTXO to be consolidated:');
             await secondUtxo.log();
         }
@@ -202,14 +216,14 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
             amount: outputAmount,
             keypair: utxoKeypair,
             index: currentNextIndex, // This UTXO will be inserted at currentNextIndex
-            mintAddress: mintAddress.toString()
+            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
-            mintAddress: mintAddress.toString()
+            mintAddress: token.pubkey.toString()
         }) // Empty UTXO
     ];
     // Verify this matches the circuit balance equation: sumIns + publicAmount = sumOuts
@@ -232,10 +246,10 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     logger.debug('\nEncrypting UTXOs with keypair data...');
     const encryptedOutput1 = encryptionService.encryptUtxo(outputs[0]);
     const encryptedOutput2 = encryptionService.encryptUtxo(outputs[1]);
-    logger.debug(`\nOutput[0] (with value):`);
-    await outputs[0].log();
-    logger.debug(`\nOutput[1] (empty):`);
-    await outputs[1].log();
+    // logger.debug(`\nOutput[0] (with value):`);
+    // await outputs[0].log();
+    // logger.debug(`\nOutput[1] (empty):`);
+    // await outputs[1].log();
     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`);
@@ -256,7 +270,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
         encryptedOutput2: encryptedOutput2,
         fee: new BN(fee_base_units),
         feeRecipient: feeRecipientTokenAccount,
-        mintAddress: mintAddress.toString()
+        mintAddress: token.pubkey.toString()
     };
     // Calculate the extDataHash with the encrypted outputs (now includes mintAddress for security)
     const calculatedExtDataHash = getExtDataHash(extData);
@@ -264,7 +278,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     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
@@ -307,7 +321,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     const { nullifier0PDA, nullifier1PDA } = findNullifierPDAs(proofToSubmit);
     const { nullifier2PDA, nullifier3PDA } = findCrossCheckNullifierPDAs(proofToSubmit);
     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);
     const lookupTableAccount = await useExistingALT(connection, ALT_ADDRESS);
     if (!lookupTableAccount?.value) {
         throw new Error(`ALT not found at address ${ALT_ADDRESS.toString()} `);
@@ -327,7 +341,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
             // signer
             { pubkey: publicKey, isSigner: true, isWritable: true },
             // SPL token mint
-            { pubkey: mintAddress, isSigner: false, isWritable: false },
+            { pubkey: token.pubkey, isSigner: false, isWritable: false },
             // signer's token account
             { pubkey: signerTokenAccount, isSigner: false, isWritable: true },
             // recipient (placeholder)
@@ -369,7 +383,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     // Relay the pre-signed transaction to indexer backend
     logger.info('submitting transaction to relayer...');
     const signature = await relayDepositToIndexer({
-        mintAddress: mintAddress.toString(),
+        mintAddress: token.pubkey.toString(),
         publicKey,
         signedTransaction: serializedTransaction,
         referrer
@@ -385,7 +399,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
         logger.debug(`retryTimes: ${retryTimes}`);
         await new Promise(resolve => setTimeout(resolve, itv * 1000));
         logger.debug('Fetching updated tree state...');
-        let url = RELAYER_API_URL + '/utxos/check/' + encryptedOutputStr + '?token=usdc';
+        let url = RELAYER_API_URL + '/utxos/check/' + encryptedOutputStr + '?token=' + token.name;
         let res = await fetch(url);
         let resJson = await res.json();
         if (resJson.exists) {
@@ -398,7 +412,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
         retryTimes++;
     }
 }
-async function checkDepositLimit(connection, treeAccount) {
+async function checkDepositLimit(connection, treeAccount, token) {
     try {
         // Fetch the account data
         const accountInfo = await connection.getAccountInfo(treeAccount);
@@ -411,21 +425,21 @@ async function checkDepositLimit(connection, treeAccount) {
         const rootIndex = new BN(accountInfo.data.slice(4112, 4120), 'le');
         const maxDepositAmount = new BN(accountInfo.data.slice(4120, 4128), 'le');
         const bump = accountInfo.data[4128];
-        // Convert to SOL using BN division to handle large numbers
-        const lamportsPerSol = new BN(1e6);
-        const maxDepositSol = maxDepositAmount.div(lamportsPerSol);
-        const remainder = maxDepositAmount.mod(lamportsPerSol);
-        // Format the SOL amount with decimals
-        let solFormatted = '1';
+        // Convert to SPL using BN division to handle large numbers
+        const unitesPerToken = new BN(token.units_per_token);
+        const maxDepositSpl = maxDepositAmount.div(unitesPerToken);
+        const remainder = maxDepositAmount.mod(unitesPerToken);
+        // Format the SPL amount with decimals
+        let amountFormatted = '1';
         if (remainder.eq(new BN(0))) {
-            solFormatted = maxDepositSol.toString();
+            amountFormatted = maxDepositSpl.toString();
         }
         else {
-            // Handle fractional SOL by converting remainder to decimal
-            const fractional = remainder.toNumber() / 1e6;
-            solFormatted = `${maxDepositSol.toString()}${fractional.toFixed(9).substring(1)}`;
+            // Handle fractional SPL by converting remainder to decimal
+            const fractional = remainder.toNumber() / token.units_per_token;
+            amountFormatted = `${maxDepositSpl.toString()}${fractional.toFixed(Math.log10(token.units_per_token)).substring(1)}`;
         }
-        return Number(solFormatted);
+        return Number(amountFormatted);
     }
     catch (error) {
         console.log('❌ Error reading deposit limit:', error);

package/dist/exportUtils.d.ts

@@ -7,3 +7,4 @@ export { getBalanceFromUtxos, getUtxos, localstorageKey } from './getUtxos.js';
 export { depositSPL } from './depositSPL.js';
 export { withdrawSPL } from './withdrawSPL.js';
 export { getBalanceFromUtxosSPL, getUtxosSPL } from './getUtxosSPL.js';
+export { type TokenList, type SplList, tokens } from './utils/constants.js';

package/dist/exportUtils.js

@@ -7,3 +7,4 @@ export { getBalanceFromUtxos, getUtxos, localstorageKey } from './getUtxos.js';
 export { depositSPL } from './depositSPL.js';
 export { withdrawSPL } from './withdrawSPL.js';
 export { getBalanceFromUtxosSPL, getUtxosSPL } from './getUtxosSPL.js';
+export { tokens } from './utils/constants.js';

package/dist/getUtxosSPL.d.ts

@@ -9,12 +9,12 @@ export declare function localstorageKey(key: PublicKey): string;
  * @param setStatus A global state updator. Set live status message showing on webpage
  * @returns Array of decrypted UTXOs that belong to the user
  */
-export declare function getUtxosSPL({ publicKey, connection, encryptionService, storage, mintAddress, abortSignal, offset }: {
+export declare function getUtxosSPL({ publicKey, connection, encryptionService, storage, abortSignal, offset, mintAddress }: {
     publicKey: PublicKey;
     connection: Connection;
     encryptionService: EncryptionService;
     storage: Storage;
-    mintAddress: PublicKey;
+    mintAddress: PublicKey | string;
     abortSignal?: AbortSignal;
     offset?: number;
 }): Promise<Utxo[]>;
@@ -27,6 +27,7 @@ export declare function getUtxosSPL({ publicKey, connection, encryptionService,
 export declare function isUtxoSpent(connection: Connection, utxo: Utxo): Promise<boolean>;
 export declare function getBalanceFromUtxosSPL(utxos: Utxo[]): {
     base_units: number;
+    amount: number;
     /** @deprecated use base_units instead */
     lamports: number;
 };

package/dist/getUtxosSPL.js

@@ -4,7 +4,7 @@ import { Keypair as UtxoKeypair } from './models/keypair.js';
 import { WasmFactory } from '@lightprotocol/hasher.rs';
 //@ts-ignore
 import * as ffjavascript from 'ffjavascript';
-import { FETCH_UTXOS_GROUP_SIZE, RELAYER_API_URL, LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET, PROGRAM_ID } from './utils/constants.js';
+import { FETCH_UTXOS_GROUP_SIZE, RELAYER_API_URL, LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET, PROGRAM_ID, tokens } from './utils/constants.js';
 import { logger } from './utils/logger.js';
 import { getAssociatedTokenAddress } from '@solana/spl-token';
 // Use type assertion for the utility functions (same pattern as in get_verification_keys.ts)
@@ -28,13 +28,21 @@ let decryptionTaskFinished = 0;
  * @param setStatus A global state updator. Set live status message showing on webpage
  * @returns Array of decrypted UTXOs that belong to the user
  */
-export async function getUtxosSPL({ publicKey, connection, encryptionService, storage, mintAddress, abortSignal, offset }) {
+export async function getUtxosSPL({ publicKey, connection, encryptionService, storage, abortSignal, offset, mintAddress }) {
     let valid_utxos = [];
     let valid_strings = [];
     let history_indexes = [];
     let publicKey_ata;
+    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());
+    }
+    logger.debug('token name: ' + token.name + ', token address' + token.pubkey.toString());
     try {
-        publicKey_ata = await getAssociatedTokenAddress(mintAddress, publicKey);
+        publicKey_ata = await getAssociatedTokenAddress(token.pubkey, publicKey);
         let offsetStr = storage.getItem(LSK_FETCH_OFFSET + localstorageKey(publicKey_ata));
         if (offsetStr) {
             roundStartIndex = Number(offsetStr);
@@ -56,9 +64,10 @@ export async function getUtxosSPL({ publicKey, connection, encryptionService, st
             if (offset) {
                 fetch_utxo_offset = Math.max(offset, fetch_utxo_offset);
             }
+            logger.debug(' ####fetch_utxo_offset', fetch_utxo_offset);
             let fetch_utxo_end = fetch_utxo_offset + FETCH_UTXOS_GROUP_SIZE;
-            let fetch_utxo_url = `${RELAYER_API_URL}/utxos/range?token=usdc&start=${fetch_utxo_offset}&end=${fetch_utxo_end}`;
-            let fetched = await fetchUserUtxos({ publicKey, connection, url: fetch_utxo_url, encryptionService, storage, publicKey_ata, initOffset: offset });
+            let fetch_utxo_url = `${RELAYER_API_URL}/utxos/range?token=${token.name}&start=${fetch_utxo_offset}&end=${fetch_utxo_end}`;
+            let fetched = await fetchUserUtxos({ url: fetch_utxo_url, encryptionService, storage, publicKey_ata, tokenName: token.name });
             let am = 0;
             const nonZeroUtxos = [];
             const nonZeroEncrypted = [];
@@ -113,10 +122,9 @@ export async function getUtxosSPL({ publicKey, connection, encryptionService, st
     valid_strings = [...new Set(valid_strings)];
     logger.debug(`valid_strings len after set: ${valid_strings.length}`);
     storage.setItem(LSK_ENCRYPTED_OUTPUTS + localstorageKey(publicKey_ata), JSON.stringify(valid_strings));
-    // reorgnize
-    return valid_utxos.filter(u => u.mintAddress == mintAddress.toString());
+    return valid_utxos.filter(u => u.mintAddress == token.pubkey.toString());
 }
-async function fetchUserUtxos({ publicKey, connection, url, storage, encryptionService, publicKey_ata, initOffset }) {
+async function fetchUserUtxos({ url, storage, encryptionService, publicKey_ata, tokenName }) {
     const lightWasm = await WasmFactory.getInstance();
     // Derive the UTXO keypair from the wallet keypair
     const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();
@@ -159,7 +167,7 @@ async function fetchUserUtxos({ publicKey, connection, url, storage, encryptionS
         cachedStringNum = JSON.parse(cachedString).length;
     }
     let decryptionTaskTotal = data.total + cachedStringNum - roundStartIndex;
-    let batchRes = await decrypt_outputs(encryptedOutputs, encryptionService, utxoKeypair, lightWasm);
+    let batchRes = await decrypt_outputs(encryptedOutputs, encryptionService, utxoKeypair, lightWasm, tokenName);
     decryptionTaskFinished += encryptedOutputs.length;
     logger.debug('batchReslen', batchRes.length);
     for (let i = 0; i < batchRes.length; i++) {
@@ -177,7 +185,7 @@ async function fetchUserUtxos({ publicKey, connection, url, storage, encryptionS
             if (decryptionTaskFinished % 100 == 0) {
                 logger.info(`(decrypting cached utxo: ${decryptionTaskFinished + 1}/${decryptionTaskTotal}...)`);
             }
-            let batchRes = await decrypt_outputs(cachedEncryptedOutputs, encryptionService, utxoKeypair, lightWasm);
+            let batchRes = await decrypt_outputs(cachedEncryptedOutputs, encryptionService, utxoKeypair, lightWasm, tokenName);
             decryptionTaskFinished += cachedEncryptedOutputs.length;
             logger.debug('cachedbatchReslen', batchRes.length, ' source', cachedEncryptedOutputs.length);
             for (let i = 0; i < batchRes.length; i++) {
@@ -257,8 +265,19 @@ async function areUtxosSpent(connection, utxos) {
 }
 // Calculate total balance
 export function getBalanceFromUtxosSPL(utxos) {
+    if (!utxos.length) {
+        return { base_units: 0, amount: 0, lamports: 0 };
+    }
+    let token = tokens.find(t => t.pubkey.toString() == utxos[0].mintAddress.toString());
+    if (!token) {
+        throw new Error('token not found for ' + utxos[0].mintAddress.toString());
+    }
     const totalBalance = utxos.reduce((sum, utxo) => sum.add(utxo.amount), new BN(0));
-    return { base_units: totalBalance.toNumber(), lamports: totalBalance.toNumber() };
+    return {
+        base_units: totalBalance.toNumber(),
+        lamports: totalBalance.toNumber(),
+        amount: totalBalance.toNumber() / token.units_per_token
+    };
 }
 async function decrypt_output(encryptedOutput, encryptionService, utxoKeypair, lightWasm, connection) {
     let res = { status: 'unDecrypted' };
@@ -332,7 +351,7 @@ async function decrypt_output(encryptedOutput, encryptionService, utxoKeypair, l
     }
     return res;
 }
-async function decrypt_outputs(encryptedOutputs, encryptionService, utxoKeypair, lightWasm) {
+async function decrypt_outputs(encryptedOutputs, encryptionService, utxoKeypair, lightWasm, tokenName) {
     let results = [];
     // decript all UTXO
     for (const encryptedOutput of encryptedOutputs) {
@@ -358,7 +377,7 @@ async function decrypt_outputs(encryptedOutputs, encryptionService, utxoKeypair,
         let url = RELAYER_API_URL + `/utxos/indices`;
         let res = await fetch(url, {
             method: 'POST', headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ encrypted_outputs, token: 'usdc' })
+            body: JSON.stringify({ encrypted_outputs, token: tokenName })
         });
         let j = await res.json();
         if (!j.indices || !Array.isArray(j.indices) || j.indices.length != encrypted_outputs.length) {

package/dist/index.d.ts

@@ -77,10 +77,19 @@ export declare class PrivacyCash {
         lamports: number;
     }>;
     /**
-    * Returns the amount of lamports current wallet has in Privacy Cash.
+    * Returns the amount of base unites current wallet has in Privacy Cash.
     */
     getPrivateBalanceUSDC(): Promise<{
         base_units: number;
+        amount: number;
+        lamports: number;
+    }>;
+    /**
+    * Returns the amount of base unites current wallet has in Privacy Cash.
+    */
+    getPrivateBalanceSpl(mintAddress: PublicKey | string): Promise<{
+        base_units: number;
+        amount: number;
         lamports: number;
     }>;
     /**
@@ -88,4 +97,29 @@ export declare class PrivacyCash {
      */
     isBrowser(): boolean;
     startStatusRender(): Promise<void>;
+    /**
+   * Deposit SPL to the Privacy Cash.
+   */
+    depositSPL({ base_units, mintAddress, amount }: {
+        base_units?: number;
+        amount?: number;
+        mintAddress: PublicKey | string;
+    }): Promise<{
+        tx: string;
+    }>;
+    /**
+      * Withdraw SPL from the Privacy Cash.
+      */
+    withdrawSPL({ base_units, mintAddress, recipientAddress, amount }: {
+        base_units?: number;
+        amount?: number;
+        mintAddress: PublicKey | string;
+        recipientAddress?: string;
+    }): Promise<{
+        isPartial: boolean;
+        tx: string;
+        recipient: string;
+        base_units: number;
+        fee_base_units: number;
+    }>;
 }