privacycash 1.0.21 → 1.1.0

package/dist/utils/constants.js

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

package/dist/withdrawSPL.d.ts

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

package/dist/withdrawSPL.js

@@ -4,7 +4,7 @@ import { Buffer } from 'buffer';
 import { Keypair as UtxoKeypair } from './models/keypair.js';
 import { Utxo } from './models/utxo.js';
 import { parseProofToBytesArray, parseToBytesArray, prove } from './utils/prover.js';
-import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, RELAYER_API_URL, MERKLE_TREE_DEPTH, PROGRAM_ID } from './utils/constants.js';
+import { ALT_ADDRESS, FEE_RECIPIENT, FIELD_SIZE, RELAYER_API_URL, MERKLE_TREE_DEPTH, PROGRAM_ID, tokens } from './utils/constants.js';
 import { serializeProofAndExtData } from './utils/encryption.js';
 import { fetchMerkleProof, findNullifierPDAs, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs, getMintAddressField, getExtDataHash } from './utils/utils.js';
 import { getUtxosSPL } from './getUtxosSPL.js';
@@ -36,26 +36,43 @@ async function submitWithdrawToIndexer(params) {
         throw error;
     }
 }
-export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, connection, base_units, encryptionService, keyBasePath, mintAddress }) {
-    let mintInfo = await getMint(connection, mintAddress);
+export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, connection, base_units, amount, encryptionService, keyBasePath, mintAddress }) {
+    if (typeof mintAddress == 'string') {
+        mintAddress = new PublicKey(mintAddress);
+    }
+    let token = tokens.find(t => t.pubkey.toString() == mintAddress.toString());
+    if (!token) {
+        throw new Error('token not found: ' + mintAddress.toString());
+    }
+    if (amount) {
+        base_units = amount * token.units_per_token;
+    }
+    if (!base_units) {
+        throw new Error('You must input at leaset one of "base_units" or "amount"');
+    }
+    let mintInfo = await getMint(connection, token.pubkey);
     let units_per_token = 10 ** mintInfo.decimals;
     let withdraw_fee_rate = await getConfig('withdraw_fee_rate');
-    let withdraw_rent_fee = await getConfig('usdc_withdraw_rent_fee');
-    let fee_base_units = Math.floor(base_units * withdraw_fee_rate + units_per_token * withdraw_rent_fee);
+    let withdraw_rent_fees = await getConfig('rent_fees');
+    let token_rent_fee = withdraw_rent_fees[token.name];
+    if (!token_rent_fee) {
+        throw new Error('can not find token_rent_fee for ' + token.name);
+    }
+    let fee_base_units = Math.floor(base_units * withdraw_fee_rate + units_per_token * token_rent_fee);
     base_units -= fee_base_units;
     if (base_units <= 0) {
-        throw new Error('withdraw amount too low');
+        throw new Error('withdraw amount too low, at least ' + fee_base_units / token_rent_fee);
     }
     let isPartial = false;
-    let recipient_ata = getAssociatedTokenAddressSync(mintAddress, recipient, true);
-    let feeRecipientTokenAccount = getAssociatedTokenAddressSync(mintAddress, FEE_RECIPIENT, true);
-    let signerTokenAccount = getAssociatedTokenAddressSync(mintAddress, publicKey);
+    let recipient_ata = getAssociatedTokenAddressSync(token.pubkey, recipient, true);
+    let feeRecipientTokenAccount = getAssociatedTokenAddressSync(token.pubkey, FEE_RECIPIENT, true);
+    let signerTokenAccount = getAssociatedTokenAddressSync(token.pubkey, publicKey);
     logger.debug('Encryption key generated from user keypair');
     // Derive tree account PDA with mint address for SPL (different from SOL version)
-    const [treeAccount] = PublicKey.findProgramAddressSync([Buffer.from('merkle_tree'), mintAddress.toBuffer()], PROGRAM_ID);
+    const [treeAccount] = PublicKey.findProgramAddressSync([Buffer.from('merkle_tree'), token.pubkey.toBuffer()], PROGRAM_ID);
     const { globalConfigAccount, treeTokenAccount } = getProgramAccounts();
     // Get current tree state
-    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState('usdc');
+    const { root, nextIndex: currentNextIndex } = await queryRemoteTreeState(token.name);
     logger.debug(`Using tree root: ${root}`);
     logger.debug(`New UTXOs will be inserted at indices: ${currentNextIndex} and ${currentNextIndex + 1}`);
     // Generate a deterministic private key derived from the wallet keypair
@@ -69,7 +86,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
     // Fetch existing UTXOs for this user
     logger.debug('\nFetching existing UTXOs...');
     const mintUtxos = await getUtxosSPL({ connection, publicKey, encryptionService, storage, mintAddress });
-    logger.debug(`Found ${mintUtxos.length} total UTXOs`);
+    logger.debug(`Found ${mintUtxos.length} total UTXOs for ${token.name}`);
     // Calculate and log total unspent UTXO balance
     const totalUnspentBalance = mintUtxos.reduce((sum, utxo) => sum.add(utxo.amount), new BN(0));
     logger.debug(`Total unspent UTXO balance before: ${totalUnspentBalance.toString()} lamports (${totalUnspentBalance.toNumber() / 1e9} SOL)`);
@@ -84,7 +101,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
         lightWasm,
         keypair: utxoKeypair,
         amount: '0',
-        mintAddress: mintAddress.toString()
+        mintAddress: token.pubkey.toString()
     });
     const inputs = [firstInput, secondInput];
     logger.debug(`firstInput index: ${firstInput.index}, commitment: ${firstInput.getCommitment()}`);
@@ -113,7 +130,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
         }
         // For real UTXOs, fetch the proof from API
         const commitment = await utxo.getCommitment();
-        return fetchMerkleProof(commitment, 'usdc');
+        return fetchMerkleProof(commitment, token.name);
     }));
     // Extract path elements and indices
     const inputMerklePathElements = inputMerkleProofs.map(proof => proof.pathElements);
@@ -125,14 +142,14 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
             amount: changeAmount.toString(),
             keypair: utxoKeypairV2,
             index: currentNextIndex,
-            mintAddress: mintAddress.toString()
+            mintAddress: token.pubkey.toString()
         }), // Change output
         new Utxo({
             lightWasm,
             amount: '0',
             keypair: utxoKeypairV2,
             index: currentNextIndex + 1,
-            mintAddress: mintAddress.toString()
+            mintAddress: token.pubkey.toString()
         }) // Empty UTXO
     ];
     // For withdrawals, extAmount is negative (funds leaving the system)
@@ -185,7 +202,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
         encryptedOutput2: encryptedOutput2,
         fee: new BN(fee_base_units),
         feeRecipient: feeRecipientTokenAccount,
-        mintAddress: mintAddress.toString()
+        mintAddress: token.pubkey.toString()
     };
     // Calculate the extDataHash with the encrypted outputs
     const calculatedExtDataHash = getExtDataHash(extData);
@@ -193,7 +210,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
     const input = {
         // Common transaction data
         root: root,
-        mintAddress: getMintAddressField(mintAddress), // new mint address
+        mintAddress: getMintAddressField(token.pubkey), // new mint address
         publicAmount: publicAmountForCircuit.toString(), // Use proper field arithmetic result
         extDataHash: calculatedExtDataHash,
         // Input UTXO data (UTXOs being spent) - ensure all values are in decimal format
@@ -239,7 +256,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
     const serializedProof = serializeProofAndExtData(proofToSubmit, extData, true);
     logger.debug(`Total instruction data size: ${serializedProof.length} bytes`);
     const [globalConfigPda, globalConfigPdaBump] = await PublicKey.findProgramAddressSync([Buffer.from("global_config")], PROGRAM_ID);
-    const treeAta = getAssociatedTokenAddressSync(mintAddress, globalConfigPda, true);
+    const treeAta = getAssociatedTokenAddressSync(token.pubkey, globalConfigPda, true);
     // Prepare withdraw parameters for indexer backend
     const withdrawParams = {
         serializedProof: serializedProof.toString('base64'),
@@ -258,7 +275,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
         senderAddress: publicKey.toString(),
         treeAta: treeAta.toString(),
         recipientAta: recipient_ata.toString(),
-        mintAddress: mintAddress.toString(),
+        mintAddress: token.pubkey.toString(),
         feeRecipientTokenAccount: feeRecipientTokenAccount.toString()
     };
     logger.debug('Prepared withdraw parameters for indexer backend');
@@ -275,7 +292,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
         console.log(`retryTimes: ${retryTimes}`);
         await new Promise(resolve => setTimeout(resolve, itv * 1000));
         console.log('Fetching updated tree state...');
-        let res = await fetch(RELAYER_API_URL + '/utxos/check/' + encryptedOutputStr + '?token=usdc');
+        let res = await fetch(RELAYER_API_URL + '/utxos/check/' + encryptedOutputStr + '?token=' + token.name);
         let resJson = await res.json();
         console.log('resJson:', resJson);
         if (resJson.exists) {

package/package.json

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

package/src/config.ts

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

package/src/deposit.ts

@@ -67,6 +67,7 @@ type DepositParams = {
 export async function deposit({ lightWasm, storage, keyBasePath, publicKey, connection, amount_in_lamports, encryptionService, transactionSigner, referrer }: DepositParams) {
     // check limit
     let limitAmount = await checkDepositLimit(connection)
+
     if (limitAmount && amount_in_lamports > limitAmount * LAMPORTS_PER_SOL) {
         throw new Error(`Don't deposit more than ${limitAmount} SOL`)
     }
@@ -451,7 +452,7 @@ async function checkDepositLimit(connection: Connection) {
         const accountInfo = await connection.getAccountInfo(treeAccount);
 
         if (!accountInfo) {
-            console.error('❌ Tree account not found. Make sure the program is initialized.');
+            console.error('❌ Tree account not found. Make sure the program is initialized.' + PROGRAM_ID);
             return;
         }
 

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'