privacycash 1.0.19 → 1.1.0

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,7 +360,7 @@ 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`);

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: {
@@ -46,38 +46,46 @@ async function relayDepositToIndexer({ signedTransaction, publicKey, referrer, m
         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`);
+    logger.debug(`wallet balance: ${balance / token.units_per_token}  ${token.name.toUpperCase()}`);
     console.log('balance', balance);
     console.log('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 +97,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 +129,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
@@ -159,7 +167,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
             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 +175,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 +210,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
@@ -256,7 +264,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 +272,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 +315,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 +335,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 +377,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 +393,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 +406,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 +419,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/getUtxos.d.ts

@@ -9,12 +9,13 @@ 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 getUtxos({ publicKey, connection, encryptionService, storage, abortSignal }: {
+export declare function getUtxos({ publicKey, connection, encryptionService, storage, abortSignal, offset }: {
     publicKey: PublicKey;
     connection: Connection;
     encryptionService: EncryptionService;
     storage: Storage;
     abortSignal?: AbortSignal;
+    offset?: number;
 }): Promise<Utxo[]>;
 /**
  * Check if a UTXO has been spent

package/dist/getUtxos.js

@@ -26,7 +26,7 @@ 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 getUtxos({ publicKey, connection, encryptionService, storage, abortSignal }) {
+export async function getUtxos({ publicKey, connection, encryptionService, storage, abortSignal, offset }) {
     let valid_utxos = [];
     let valid_strings = [];
     let history_indexes = [];
@@ -38,15 +38,22 @@ export async function getUtxos({ publicKey, connection, encryptionService, stora
         roundStartIndex = 0;
     }
     decryptionTaskFinished = 0;
+    if (!offset) {
+        offset = 0;
+    }
+    roundStartIndex = Math.max(offset, roundStartIndex);
     while (true) {
         if (abortSignal?.aborted) {
             throw new Error('aborted');
         }
         let offsetStr = storage.getItem(LSK_FETCH_OFFSET + localstorageKey(publicKey));
         let fetch_utxo_offset = offsetStr ? Number(offsetStr) : 0;
+        if (offset) {
+            fetch_utxo_offset = Math.max(offset, fetch_utxo_offset);
+        }
         let fetch_utxo_end = fetch_utxo_offset + FETCH_UTXOS_GROUP_SIZE;
         let fetch_utxo_url = `${RELAYER_API_URL}/utxos/range?start=${fetch_utxo_offset}&end=${fetch_utxo_end}`;
-        let fetched = await fetchUserUtxos({ publicKey, connection, url: fetch_utxo_url, encryptionService, storage });
+        let fetched = await fetchUserUtxos({ publicKey, connection, url: fetch_utxo_url, encryptionService, storage, initOffset: offset });
         let am = 0;
         const nonZeroUtxos = [];
         const nonZeroEncrypted = [];
@@ -96,7 +103,7 @@ export async function getUtxos({ publicKey, connection, encryptionService, stora
     storage.setItem(LSK_ENCRYPTED_OUTPUTS + localstorageKey(publicKey), JSON.stringify(valid_strings));
     return valid_utxos;
 }
-async function fetchUserUtxos({ publicKey, connection, url, storage, encryptionService }) {
+async function fetchUserUtxos({ publicKey, connection, url, storage, encryptionService, initOffset }) {
     const lightWasm = await WasmFactory.getInstance();
     // Derive the UTXO keypair from the wallet keypair
     const utxoPrivateKey = encryptionService.deriveUtxoPrivateKey();

package/dist/getUtxosSPL.d.ts

@@ -9,13 +9,14 @@ 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 }: {
+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[]>;
 /**
  * Check if a UTXO has been spent
@@ -26,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 }) {
+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);
@@ -43,15 +51,23 @@ export async function getUtxosSPL({ publicKey, connection, encryptionService, st
             roundStartIndex = 0;
         }
         decryptionTaskFinished = 0;
+        if (!offset) {
+            offset = 0;
+        }
+        roundStartIndex = Math.max(offset, roundStartIndex);
         while (true) {
             if (abortSignal?.aborted) {
                 throw new Error('aborted');
             }
             let offsetStr = storage.getItem(LSK_FETCH_OFFSET + localstorageKey(publicKey_ata));
             let fetch_utxo_offset = offsetStr ? Number(offsetStr) : 0;
+            if (offset) {
+                fetch_utxo_offset = Math.max(offset, fetch_utxo_offset);
+            }
+            console.log(' ####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 });
+            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 = [];
@@ -107,9 +123,14 @@ export async function getUtxosSPL({ publicKey, connection, encryptionService, st
     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());
+    if (valid_utxos.length) {
+        console.log('filter mint', valid_utxos[0].mintAddress, token.pubkey.toString());
+    }
+    let filtered_utxos = valid_utxos.filter(u => u.mintAddress == token.pubkey.toString());
+    console.log('filtered_utxos.len', filtered_utxos.length);
+    return filtered_utxos;
 }
-async function fetchUserUtxos({ publicKey, connection, url, storage, encryptionService, publicKey_ata }) {
+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();
@@ -152,7 +173,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++) {
@@ -170,7 +191,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++) {
@@ -250,8 +271,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' };
@@ -325,7 +357,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) {
@@ -351,7 +383,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;
+    }>;
 }