privacycash 1.0.21 → 1.1.0

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,12 +55,12 @@ let decryptionTaskFinished = 0;
  * @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 }: {
     publicKey: PublicKey,
     connection: Connection,
     encryptionService: EncryptionService,
     storage: Storage,
-    mintAddress: PublicKey,
+    mintAddress: PublicKey | string,
     abortSignal?: AbortSignal
     offset?: number
 }): Promise<Utxo[]> {
@@ -68,9 +68,21 @@ export async function getUtxosSPL({ publicKey, connection, encryptionService, st
     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))
@@ -93,9 +105,10 @@ export async function getUtxosSPL({ publicKey, connection, encryptionService, st
             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, 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: Utxo[] = [];
@@ -150,17 +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, initOffset }: {
-    publicKey: PublicKey,
-    connection: Connection,
+async function fetchUserUtxos({ url, storage, encryptionService, publicKey_ata, tokenName }: {
     url: string,
     encryptionService: EncryptionService,
     storage: Storage,
     publicKey_ata: PublicKey
-    initOffset: number
+    tokenName: string
 }): Promise<{
     encryptedOutputs: string[],
     utxos: Utxo[],
@@ -212,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++) {
@@ -230,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++) {
@@ -346,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
@@ -454,6 +482,7 @@ async function decrypt_outputs(
     encryptionService: EncryptionService,
     utxoKeypair: UtxoKeypair,
     lightWasm: any,
+    tokenName: string
 ): Promise<DecryptRes[]> {
     let results: DecryptRes[] = [];
 
@@ -485,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(

package/src/utils/constants.ts

@@ -25,4 +25,48 @@ 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')
+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'] as const;
+export type TokenList = typeof tokenList[number];
+const splList = ['usdc', 'usdt', 'ore'] as const;
+export type SplList = typeof splList[number];
+export type Token = {
+    name: 'sol' | 'usdc' | 'usdt' | 'zec' | 'ore'
+    prefix: string
+    units_per_token: number
+    pubkey: PublicKey
+}
+export const tokens: Token[] = [
+    {
+        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/src/withdrawSPL.ts

@@ -6,7 +6,7 @@ import * as hasher from '@lightprotocol/hasher.rs';
 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, SplList, tokens } from './utils/constants.js';
 import { EncryptionService, serializeProofAndExtData } from './utils/encryption.js';
 import { fetchMerkleProof, findNullifierPDAs, getProgramAccounts, queryRemoteTreeState, findCrossCheckNullifierPDAs, getMintAddressField, getExtDataHash } from './utils/utils.js';
 
@@ -20,7 +20,6 @@ import { getAssociatedTokenAddressSync, getMint } from '@solana/spl-token';
 // Function to submit withdraw request to indexer backend
 async function submitWithdrawToIndexer(params: any): Promise<string> {
     try {
-
         const response = await fetch(`${RELAYER_API_URL}/withdraw/spl`, {
             method: 'POST',
             headers: {
@@ -48,43 +47,64 @@ async function submitWithdrawToIndexer(params: any): Promise<string> {
 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,
-    storage: Storage
+    mintAddress: PublicKey | string,
+    storage: Storage,
 }
 
-export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, connection, base_units, encryptionService, keyBasePath, mintAddress }: WithdrawParams) {
-    let mintInfo = await getMint(connection, mintAddress)
+export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, connection, base_units, amount, encryptionService, keyBasePath, mintAddress }: WithdrawParams) {
+    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,
+        token.pubkey,
         recipient,
         true
     );
 
     let feeRecipientTokenAccount = getAssociatedTokenAddressSync(
-        mintAddress,
+        token.pubkey,
         FEE_RECIPIENT,
         true
     );
     let signerTokenAccount = getAssociatedTokenAddressSync(
-        mintAddress,
+        token.pubkey,
         publicKey
     );
 
@@ -93,14 +113,14 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
 
     // Derive tree account PDA with mint address for SPL (different from SOL version)
     const [treeAccount] = PublicKey.findProgramAddressSync(
-        [Buffer.from('merkle_tree'), mintAddress.toBuffer()],
+        [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}`);
 
@@ -119,7 +139,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
     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));
@@ -138,7 +158,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];
@@ -171,7 +191,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);
         })
     );
 
@@ -186,14 +206,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
     ];
 
@@ -255,7 +275,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);
@@ -264,7 +284,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,
 
@@ -322,7 +342,7 @@ export async function withdrawSPL({ recipient, lightWasm, storage, publicKey, co
         [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 = {
@@ -342,7 +362,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()
     };
 
@@ -362,7 +382,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) {