privacycash 1.0.19 → 1.1.0

package/src/depositSPL.ts

@@ -8,7 +8,7 @@ import { MerkleTree } from './utils/merkle_tree.js';
 import { EncryptionService, serializeProofAndExtData } from './utils/encryption.js';
 import { Keypair as UtxoKeypair } from './models/keypair.js';
 import { getUtxosSPL, isUtxoSpent } 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, SplList, Token } from './utils/constants.js';
 import { getProtocolAddressesWithMint, useExistingALT } from './utils/address_lookup_table.js';
 import { logger } from './utils/logger.js';
 import { getAssociatedTokenAddress, ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, getMint, getAccount } from '@solana/spl-token';
@@ -34,7 +34,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',
@@ -63,10 +63,11 @@ async function relayDepositToIndexer({ signedTransaction, publicKey, referrer, m
 }
 
 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,
@@ -74,61 +75,70 @@ type DepositParams = {
     referrer?: string,
     transactionSigner: (tx: VersionedTransaction) => Promise<VersionedTransaction>
 }
-export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, connection, base_units, encryptionService, transactionSigner, referrer, mintAddress }: DepositParams) {
-    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 }: DepositParams) {
+    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,
+        token.pubkey,
         recipient,
         true
     );
     let feeRecipientTokenAccount = getAssociatedTokenAddressSync(
-        mintAddress,
+        token.pubkey,
         FEE_RECIPIENT,
         true
     );
     let signerTokenAccount = getAssociatedTokenAddressSync(
-        mintAddress,
+        token.pubkey,
         publicKey
     );
 
-    // Derive tree account PDA with mint address for SPL (different from SOL version)
+    // Derive tree account PDA with mint address for SPL
     const [treeAccount] = PublicKey.findProgramAddressSync(
-        [Buffer.from('merkle_tree'), mintAddress.toBuffer()],
+        [Buffer.from('merkle_tree'), token.pubkey.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 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
@@ -145,7 +155,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
     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}`);
@@ -185,12 +195,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()
             })
         ];
 
@@ -227,7 +237,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 = [
@@ -237,13 +247,13 @@ 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();
         }
@@ -278,14 +288,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
     ];
 
@@ -341,7 +351,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);
@@ -350,7 +360,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,
 
@@ -403,7 +413,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
         [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);
 
@@ -428,7 +438,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)
@@ -482,7 +492,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
@@ -500,7 +510,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) {
@@ -516,7 +526,7 @@ export async function depositSPL({ lightWasm, storage, keyBasePath, publicKey, c
 }
 
 
-async function checkDepositLimit(connection: Connection, treeAccount: PublicKey) {
+async function checkDepositLimit(connection: Connection, treeAccount: PublicKey, token: Token) {
     try {
 
         // Fetch the account data
@@ -533,21 +543,21 @@ async function checkDepositLimit(connection: Connection, treeAccount: PublicKey)
         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);
+        // 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 SOL amount with decimals
-        let solFormatted = '1';
+        // 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/src/exportUtils.ts

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

package/src/getUtxos.ts

@@ -51,12 +51,13 @@ let decryptionTaskFinished = 0;
  * @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 }: {
     publicKey: PublicKey,
     connection: Connection,
     encryptionService: EncryptionService,
     storage: Storage,
     abortSignal?: AbortSignal
+    offset?: number
 }): Promise<Utxo[]> {
 
     let valid_utxos: Utxo[] = []
@@ -69,15 +70,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: Utxo[] = [];
@@ -131,12 +139,13 @@ export async function getUtxos({ publicKey, connection, encryptionService, stora
 
 }
 
-async function fetchUserUtxos({ publicKey, connection, url, storage, encryptionService }: {
+async function fetchUserUtxos({ publicKey, connection, url, storage, encryptionService, initOffset }: {
     publicKey: PublicKey,
     connection: Connection,
     url: string,
     encryptionService: EncryptionService,
     storage: Storage
+    initOffset: number
 }): Promise<{
     encryptedOutputs: string[],
     utxos: Utxo[],
@@ -188,6 +197,7 @@ async function fetchUserUtxos({ publicKey, connection, url, storage, encryptionS
 
 
     let decryptionTaskTotal = data.total + cachedStringNum - roundStartIndex;
+
     let batchRes = await decrypt_outputs(encryptedOutputs, encryptionService, utxoKeypair, lightWasm)
     decryptionTaskFinished += encryptedOutputs.length
     logger.debug('batchReslen', batchRes.length)

package/src/getUtxosSPL.ts

@@ -6,7 +6,7 @@ import { EncryptionService } from './utils/encryption.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, SplList, tokens } from './utils/constants.js';
 import { logger } from './utils/logger.js';
 import { getAssociatedTokenAddress } from '@solana/spl-token';
 
@@ -55,21 +55,34 @@ let decryptionTaskFinished = 0;
  * @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 }: {
     publicKey: PublicKey,
     connection: Connection,
     encryptionService: EncryptionService,
     storage: Storage,
-    mintAddress: PublicKey,
+    mintAddress: PublicKey | string,
     abortSignal?: AbortSignal
+    offset?: number
 }): Promise<Utxo[]> {
     let valid_utxos: Utxo[] = []
     let valid_strings: string[] = []
     let history_indexes: number[] = []
     let publicKey_ata: PublicKey
+
+    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,
+            token.pubkey,
             publicKey
         );
         let offsetStr = storage.getItem(LSK_FETCH_OFFSET + localstorageKey(publicKey_ata))
@@ -79,15 +92,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: Utxo[] = [];
@@ -142,16 +163,20 @@ 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 }: {
-    publicKey: PublicKey,
-    connection: Connection,
+async function fetchUserUtxos({ url, storage, encryptionService, publicKey_ata, tokenName }: {
     url: string,
     encryptionService: EncryptionService,
     storage: Storage,
     publicKey_ata: PublicKey
+    tokenName: string
 }): Promise<{
     encryptedOutputs: string[],
     utxos: Utxo[],
@@ -203,7 +228,7 @@ async function fetchUserUtxos({ publicKey, connection, url, storage, encryptionS
 
 
     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++) {
@@ -221,7 +246,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++) {
@@ -337,11 +362,23 @@ async function areUtxosSpent(
 // Calculate total balance
 export function getBalanceFromUtxosSPL(utxos: Utxo[]): {
     base_units: number
+    amount: number
     /** @deprecated use base_units instead */
     lamports: number
 } {
+    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
+    }
 }
 
 // Decrypt single output to Utxo
@@ -445,6 +482,7 @@ async function decrypt_outputs(
     encryptionService: EncryptionService,
     utxoKeypair: UtxoKeypair,
     lightWasm: any,
+    tokenName: string
 ): Promise<DecryptRes[]> {
     let results: DecryptRes[] = [];
 
@@ -476,7 +514,7 @@ async function decrypt_outputs(
         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/src/index.ts

@@ -3,7 +3,7 @@ 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, SplList, TokenList, tokens, USDC_MINT } from './utils/constants.js';
 import { logger, type LoggerFn, setLogger } from './utils/logger.js';
 import { EncryptionService } from './utils/encryption.js';
 import { WasmFactory } from '@lightprotocol/hasher.rs';
@@ -70,10 +70,9 @@ 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) {
+        for (let token of tokens) {
             let ata = await getAssociatedTokenAddress(
-                mintAddress,
+                token.pubkey,
                 this.publicKey
             );
             storage.removeItem(LSK_FETCH_OFFSET + localstorageKey(ata))
@@ -206,7 +205,7 @@ export class PrivacyCash {
     }
 
     /**
-    * 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')
@@ -216,6 +215,22 @@ export class PrivacyCash {
         return getBalanceFromUtxosSPL(utxos)
     }
 
+    /**
+    * Returns the amount of base unites current wallet has in Privacy Cash.
+    */
+    async getPrivateBalanceSpl(mintAddress: PublicKey | string) {
+        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.
      */
@@ -235,6 +250,69 @@ export class PrivacyCash {
             await new Promise(r => setTimeout(r, 250));
         }
     }
+
+    /**
+   * Deposit SPL to the Privacy Cash.
+   */
+    async depositSPL({ base_units, mintAddress, amount }: {
+        base_units?: number,
+        amount?: number,
+        mintAddress: PublicKey | string
+    }) {
+        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: VersionedTransaction) => {
+                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 }: {
+        base_units?: number,
+        amount?: number,
+        mintAddress: PublicKey | string,
+        recipientAddress?: string
+    }) {
+        this.isRuning = true
+        logger.info('start withdrawing')
+        let lightWasm = await WasmFactory.getInstance()
+        let recipient = recipientAddress ? new PublicKey(recipientAddress) : this.publicKey
+
+        let res = await withdrawSPL({
+            lightWasm,
+            base_units,
+            amount,
+            connection: this.connection,
+            encryptionService: this.encryptionService,
+            publicKey: this.publicKey,
+            recipient,
+            keyBasePath: path.join(import.meta.dirname, '..', 'circuit2', 'transaction2'),
+            storage,
+            mintAddress
+        })
+        console.log(`Withdraw successful. Recipient ${recipient} received ${base_units} USDC units`)
+        this.isRuning = false
+        return res
+    }
+
+
 }
 
 function getSolanaKeypair(