@deserialize/multi-vm-wallet 1.0.2 → 1.0.4

package/utils/svm/svm.ts

@@ -17,16 +17,25 @@ import {
     JupiterQuoteResponse
 } from "./utils";
 import BN from "bn.js";
+import nacl from "tweetnacl";
+import base58 from "bs58";
 
 export class SVMVM extends VM<PublicKey, Keypair, Connection> {
+    static validateAddress(address: PublicKey): boolean {
+        try {
+            new PublicKey(address)
+            return true
+        } catch (error) {
+            return false
+
+        }
+    }
     derivationPath = "m/44'/501'/"; // Default SVM derivation path
 
     constructor(seed: string) {
         super(seed, "SVM");
     }
-    static validateAddress(address: PublicKey): boolean {
-        return PublicKey.isOnCurve(address.toBuffer());
-    }
+
     static getNativeBalance(address: PublicKey, connection: Connection): Promise<Balance> {
         return getSvmNativeBalance(address, connection);
     }
@@ -39,6 +48,8 @@ export class SVMVM extends VM<PublicKey, Keypair, Connection> {
     }
 
     static signAndSendTransaction = signAndSendTransaction
+
+
     generatePrivateKey(index: number, seed?: string, mnemonic?: string, derivationPath = this.derivationPath) {
         let _seed: string
 
@@ -52,7 +63,8 @@ export class SVMVM extends VM<PublicKey, Keypair, Connection> {
         const privateKey = SVMDeriveChildPrivateKey(_seed, index, derivationPath);
         return { privateKey, index };
     }
-    static fromMnemonic(seed: string): VM<PublicKey, Keypair, Connection> {
+    static fromMnemonic(mnemonic: string): VM<PublicKey, Keypair, Connection> {
+        const seed = VM.mnemonicToSeed(mnemonic)
         return new SVMVM(seed)
     }
 
@@ -130,14 +142,14 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
 
             const baseAmount = uiAmountToBaseUnits(amount, fromToken.decimals);
 
-            const balance = await this.getTokenBalance(fromTokenMint);
-            if (balance.balance.lt(new BN(baseAmount))) {
-                return {
-                    success: false,
-                    hash: "",
-                    error: "Insufficient balance for swap"
-                };
-            }
+            // const balance = await this.getTokenBalance(fromTokenMint);
+            // if (balance.balance.lt(new BN(baseAmount))) {
+            //     return {
+            //         success: false,
+            //         hash: "",
+            //         error: "Insufficient balance for swap"
+            //     };
+            // }
 
             const swapResult = await executeJupiterSwap(
                 {
@@ -209,4 +221,9 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
             };
         }
     }
+    signMessage = (message: string, signer: Keypair) => {
+        const messageBytes = new TextEncoder().encode(message);
+        const signature = nacl.sign.detached(messageBytes, signer.secretKey);
+        return base58.encode(signature);
+    };
 }

package/utils/svm/transactionSender.ts

@@ -26,6 +26,7 @@ export async function transactionSenderAndConfirmationWaiter({
         serializedTransaction,
         SEND_OPTIONS
     );
+    console.log('initial send txid: ', txid);
 
     const controller = new AbortController();
     const abortSignal = controller.signal;
@@ -51,7 +52,8 @@ export async function transactionSenderAndConfirmationWaiter({
             blockhashWithExpiryBlockHeight.lastValidBlockHeight - 150;
 
         // this would throw TransactionExpiredBlockheightExceededError
-        await Promise.race([
+        // console.log("conforming the transaction ....")
+        const res = await Promise.race([
             connection.confirmTransaction(
                 {
                     ...blockhashWithExpiryBlockHeight,
@@ -74,10 +76,13 @@ export async function transactionSenderAndConfirmationWaiter({
                 }
             }),
         ]);
+        console.log('res: ', res);
+
     } catch (e) {
+        console.log('e: ', e);
         if (e instanceof TransactionExpiredBlockheightExceededError) {
             // we consume this error and getTransaction would return null
-            return null;
+            // return null;
         } else {
             // invalid state from web3.js
             throw e;

package/utils/svm/utils.ts

@@ -68,8 +68,15 @@ export const createV0Transaction = async (
     payerPubKey: PublicKey,
     blockHash?: string
 ) => {
+    console.log('createV0Transaction: Starting transaction creation');
+    console.log('Instructions count:', inX.length);
+    console.log('Signers count:', signers.length);
+    console.log('Payer public key:', payerPubKey.toString());
+
     const blockhash =
         blockHash || (await connection.getLatestBlockhash()).blockhash;
+    console.log('Using blockhash:', blockhash);
+
     const message = new TransactionMessage({
         payerKey: payerPubKey,
         instructions: inX,
@@ -79,9 +86,11 @@ export const createV0Transaction = async (
     const transaction = new VersionedTransaction(message);
     transaction.message.staticAccountKeys;
     if (signers.length < 1) {
+        console.log('Signing transaction with signers');
         transaction.sign(signers);
     }
 
+    console.log('createV0Transaction: Transaction created successfully');
     return transaction;
 };
 
@@ -91,6 +100,11 @@ export const createAtaAndIx = async (
     tokenProgramId: PublicKey,
     connection: Connection,
 ) => {
+    console.log('createAtaAndIx: Starting ATA creation');
+    console.log('Token:', token.toString());
+    console.log('Owner:', ownerPublicKey.toString());
+    console.log('Token Program ID:', tokenProgramId.toString());
+
     let AtaTokenIx;
     const associatedToken = getAssociatedTokenAddressSync(
         token,
@@ -98,9 +112,11 @@ export const createAtaAndIx = async (
         false,
         tokenProgramId
     );
+    console.log('Associated token address:', associatedToken.toString());
 
     const accountExist = await connection.getAccountInfo(associatedToken);
     if (!accountExist) {
+        console.log('Account does not exist, creating ATA instruction');
         AtaTokenIx = createAssociatedTokenAccountIdempotentInstruction(
             ownerPublicKey,
             associatedToken,
@@ -108,17 +124,26 @@ export const createAtaAndIx = async (
             token,
             tokenProgramId
         );
+    } else {
+        console.log('Account already exists, no ATA instruction needed');
     }
+
+    console.log('createAtaAndIx: Completed');
     return {
         AtaTokenIx,
         associatedToken,
     };
 };
+
 export const getSureAssociatedTokenAddressAndAccount = async (
     connection: Connection,
     token: PublicKey,
     owner: PublicKey,
 ) => {
+    console.log('getSureAssociatedTokenAddressAndAccount: Starting');
+    console.log('Token:', token.toString());
+    console.log('Owner:', owner.toString());
+
     let ATA: PublicKey;
     let programId: PublicKey;
     let tokenAccount: Account;
@@ -126,90 +151,128 @@ export const getSureAssociatedTokenAddressAndAccount = async (
         programId = token.equals(NATIVE_MINT)
             ? TOKEN_PROGRAM_ID
             : TOKEN_2022_PROGRAM_ID;
+        console.log('Trying with program ID:', programId.toString());
+
         ATA = getAssociatedTokenAddressSync(token, owner, true, programId);
+        console.log('ATA address:', ATA.toString());
+
         tokenAccount = await getAccount(connection, ATA, "confirmed", programId);
+        console.log('Token account found with TOKEN_2022_PROGRAM_ID');
         return { ATA, programId, tokenAccount };
     } catch (error) {
+        console.log('Failed with TOKEN_2022_PROGRAM_ID, trying TOKEN_PROGRAM_ID');
+        console.log('Error:', error);
+
         programId = TOKEN_PROGRAM_ID;
         ATA = getAssociatedTokenAddressSync(token, owner, true, programId);
+        console.log('New ATA address:', ATA.toString());
+
         tokenAccount = await getAccount(connection, ATA, "confirmed", programId);
+        console.log('Token account found with TOKEN_PROGRAM_ID');
         return { ATA, programId, tokenAccount };
     }
 };
 
 export const getProgramIdOfToken = async (owner: PublicKey, token: PublicKey, connection: Connection) => {
+    console.log('getProgramIdOfToken: Starting');
+    console.log('Owner:', owner.toString());
+    console.log('Token:', token.toString());
+
     if (token.equals(NATIVE_MINT)) {
+        console.log('Token is native mint, returning TOKEN_PROGRAM_ID');
         return TOKEN_PROGRAM_ID;
     }
     let ATA: PublicKey;
     let programId: PublicKey = TOKEN_PROGRAM_ID
     let tokenAccount: Account;
     try {
+        console.log('Trying with TOKEN_PROGRAM_ID');
         ATA = getAssociatedTokenAddressSync(token, owner, true, programId);
         tokenAccount = await getAccount(connection, ATA, "confirmed", programId);
+        console.log('Found with TOKEN_PROGRAM_ID');
         return TOKEN_PROGRAM_ID
     } catch (error) {
+        console.log('Failed with TOKEN_PROGRAM_ID, returning TOKEN_2022_PROGRAM_ID');
+        console.log('Error:', error);
         return TOKEN_2022_PROGRAM_ID;
-
     }
-
-
-
 }
-//get native balance
 
+//get native balance
 export const getSvmNativeBalance = async (address: PublicKey, connection: Connection,) => {
+    console.log('getSvmNativeBalance: Getting balance for', address.toString());
     const balance = await connection.getBalance(address);
+    console.log('Raw balance:', balance);
+    console.log('Formatted balance:', balance / LAMPORTS_PER_SOL, 'SOL');
     return { balance: new BN(balance), formatted: balance / LAMPORTS_PER_SOL, decimal: 9 };
 };
 
 export const getTokenBalance = async (address: PublicKey, token: PublicKey, connection: Connection) => {
+    console.log('getTokenBalance: Starting');
+    console.log('Address:', address.toString());
+    console.log('Token:', token.toString());
 
     try {
         // Get the balance from the token account
         const tokenAccount = await getTokenAccountAccount(token, address, connection);
         if (!tokenAccount) {
-            console.error("Token account not found");
+            console.log("Token account not found");
             return 0;
         }
+        console.log('Token account found:', tokenAccount.address.toString());
+
         const tokenBalance = await connection.getTokenAccountBalance(
             tokenAccount.address
         );
 
         if (!tokenBalance) {
-            console.error("Token balance not found");
+            console.log("Token balance not found");
             return 0;
         }
 
+        console.log('Token balance:', tokenBalance.value);
         return tokenBalance.value;
 
     } catch (error) {
+        console.log('Error in getTokenBalance:', error);
         return 0;
     }
 }
 
 export const getTokenAccountAccount = async (token: PublicKey, address: PublicKey, connection: Connection): Promise<Account | null> => {
-    try {
+    console.log('getTokenAccountAccount: Starting');
+    console.log('Token:', token.toString());
+    console.log('Address:', address.toString());
 
+    try {
         // Get the associated token account address for the user and the token mint
         const associatedTokenAccount = await getAssociatedTokenAddress(
             token, // The token mint address
             address // The user's public key
         );
+        console.log('Associated token account:', associatedTokenAccount.toString());
+
         // Fetch the token account information
         const tokenAccount = await getAccount(
             connection,
             associatedTokenAccount
         );
 
+        console.log('Token account retrieved successfully');
         return tokenAccount;
     } catch (error) {
-        console.error("Error getting token balance:");
+        console.log("Error getting token account:", error);
         return null;
     }
 };
 
 export const getTransferNativeInx = async (from: PublicKey, to: PublicKey, amount: number): Promise<TransactionInstruction> => {
+    console.log('getTransferNativeInx: Creating transfer instruction');
+    console.log('From:', from.toString());
+    console.log('To:', to.toString());
+    console.log('Amount:', amount, 'SOL');
+    console.log('Lamports:', amount * LAMPORTS_PER_SOL);
+
     return SystemProgram.transfer({
         fromPubkey: from,
         toPubkey: to,
@@ -218,48 +281,86 @@ export const getTransferNativeInx = async (from: PublicKey, to: PublicKey, amoun
 }
 
 export const getTransferNativeTransaction = async (from: Keypair, to: PublicKey, amount: number, connection: Connection) => {
+    console.log('getTransferNativeTransaction: Starting');
     const instruction = await getTransferNativeInx(from.publicKey, to, amount);
     const transaction = await createV0Transaction(connection, [instruction], [from], from.publicKey);
+    console.log('getTransferNativeTransaction: Completed');
     return transaction;
 }
 
 export const getTransferTokenInx = async (from: PublicKey, to: PublicKey, token: TokenInfo, amount: number, connection: Connection): Promise<TransactionInstruction[]> => {
+    console.log('getTransferTokenInx: Starting');
+    console.log('From:', from.toString());
+    console.log('To:', to.toString());
+    console.log('Token:', token);
+    console.log('Amount:', amount);
+
     const inx: TransactionInstruction[] = []
 
     const tokenToSend = new PublicKey(token.address);
+    console.log('Token to send:', tokenToSend.toString());
+
     const { ATA: source, programId, tokenAccount } = await getSureAssociatedTokenAddressAndAccount(connection, from, tokenToSend);
+    console.log('Source ATA:', source.toString());
+
     const { associatedToken: destination, AtaTokenIx } = await createAtaAndIx(tokenToSend, to, programId, connection);
+    console.log('Destination ATA:', destination.toString());
 
     if (!tokenAccount) {
+        console.log('Token account not found, throwing error');
         throw new Error("Token account not found");
     }
     if (AtaTokenIx) {
+        console.log('Adding ATA creation instruction');
         inx.push(AtaTokenIx);
     }
+
+    console.log('Creating transfer instruction');
     const tInx = createTransferCheckedInstruction(source, tokenToSend, destination, from, amount, token.decimals, undefined, programId)
     inx.push(tInx);
 
+    console.log('getTransferTokenInx: Completed with', inx.length, 'instructions');
     return inx;
-
 }
+
 export const getTransferTokenTransaction = async (from: Keypair, to: PublicKey, token: TokenInfo, amount: number, connection: Connection): Promise<VersionedTransaction> => {
+    console.log('getTransferTokenTransaction: Starting');
     const instruction = await getTransferTokenInx(from.publicKey, to, token, amount, connection);
     const transaction = await createV0Transaction(connection, instruction, [from], from.publicKey);
+    console.log('getTransferTokenTransaction: Completed');
     return transaction;
 }
+
 export const signAndSendTransaction = async (transaction: VersionedTransaction, connection: Connection, signers: Keypair[]) => {
+    console.log('signAndSendTransaction: Starting');
+    console.log('Signers count:', signers.length);
+
     transaction.sign(signers)
+    console.log('Transaction signed');
+
     const blockhash = await connection.getLatestBlockhash()
-    const res = await transactionSenderAndConfirmationWaiter({ connection, serializedTransaction: Buffer.from(transaction.serialize()), blockhashWithExpiryBlockHeight: { blockhash: blockhash.blockhash, lastValidBlockHeight: blockhash.lastValidBlockHeight } })
+    console.log('Got latest blockhash:', blockhash.blockhash);
+
+    console.log('Sending transaction...');
+    const res = await transactionSenderAndConfirmationWaiter({
+        connection,
+        serializedTransaction: Buffer.from(transaction.serialize()),
+        blockhashWithExpiryBlockHeight: {
+            blockhash: blockhash.blockhash,
+            lastValidBlockHeight: blockhash.lastValidBlockHeight
+        }
+    });
+
     if (!res) {
+        console.log('Transaction failed to send or confirm');
         throw new Error("Transaction failed to send or confirm");
     }
-    return res.transaction.signatures[0];
 
+    const signature = res.transaction.signatures[0];
+    console.log('Transaction successful, signature:', signature);
+    return signature;
 }
 
-
-
 //swap
 //you will. use jupiter for this
 
@@ -269,6 +370,12 @@ export const getJupiterQuote = async (
     amount: number,
     slippageBps: number = 50
 ): Promise<JupiterQuoteResponse> => {
+    console.log('getJupiterQuote: Starting');
+    console.log('Input mint:', inputMint);
+    console.log('Output mint:', outputMint);
+    console.log('Amount:', amount);
+    console.log('Slippage BPS:', slippageBps);
+
     const params = new URLSearchParams({
         inputMint,
         outputMint,
@@ -278,14 +385,34 @@ export const getJupiterQuote = async (
         asLegacyTransaction: 'false'
     });
 
-    const response = await fetch(`${JUPITER_BASE_URL}/swap/v1/quote?${params}`);
+    const url = `${JUPITER_BASE_URL}/swap/v1/quote?${params}`;
+    console.log('Request URL:', url);
+
+    const response = await fetch(url);
+    console.log('Response status:', response.status);
+    console.log('Response status text:', response.statusText);
 
     if (!response.ok) {
-        const error = await response.json();
-        throw new Error(`Jupiter quote failed: ${error.message || response.statusText}`);
+        console.log('Jupiter quote request failed');
+        console.log('Status:', response.status);
+        console.log('Status Text:', response.statusText);
+        console.log('URL:', url);
+
+        try {
+            const error = await response.json();
+            console.log('Error details:', error);
+        } catch {
+            const textError = await response.text();
+            console.log('Error text:', textError);
+        }
+
+        throw new Error(`Jupiter quote failed: ${response.statusText}`);
     }
 
-    return await response.json();
+    const result = await response.json();
+    console.log('Jupiter quote successful');
+    console.log('Quote result:', result);
+    return result;
 };
 
 export const buildJupiterSwapTransaction = async (
@@ -293,6 +420,10 @@ export const buildJupiterSwapTransaction = async (
     userPublicKey: string,
     prioritizationFeeLamports?: number
 ): Promise<JupiterSwapResponse> => {
+    console.log('buildJupiterSwapTransaction: Starting');
+    console.log('User public key:', userPublicKey);
+    const priorityFee = prioritizationFeeLamports || 5000;
+    console.log('Prioritization fee:', priorityFee);
     const body = {
         quoteResponse: quote,
         userPublicKey,
@@ -301,7 +432,7 @@ export const buildJupiterSwapTransaction = async (
         feeAccount: undefined,
         trackingAccount: undefined,
         computeUnitPriceMicroLamports: undefined,
-        prioritizationFeeLamports: prioritizationFeeLamports || 1000,
+        prioritizationFeeLamports: priorityFee,
         asLegacyTransaction: false,
         useTokenLedger: false,
         destinationTokenAccount: undefined,
@@ -309,6 +440,8 @@ export const buildJupiterSwapTransaction = async (
         skipUserAccountsRpcCalls: false
     };
 
+    console.log('Request body:', body);
+
     const response = await fetch(`${JUPITER_BASE_URL}/swap/v1/swap`, {
         method: 'POST',
         headers: {
@@ -317,12 +450,26 @@ export const buildJupiterSwapTransaction = async (
         body: JSON.stringify(body),
     });
 
+    console.log('Swap transaction build response status:', response.status);
+
     if (!response.ok) {
-        const error = await response.json();
-        throw new Error(`Jupiter swap transaction build failed: ${error.message || response.statusText}`);
+        console.log('Jupiter swap transaction build failed');
+        console.log('Status:', response.status);
+        console.log('Status text:', response.statusText);
+
+        try {
+            const error = await response.json();
+            console.log('Swap build error details:', error);
+            throw new Error(`Jupiter swap transaction build failed: ${error.message || response.statusText}`);
+        } catch (parseError) {
+            console.log('Failed to parse error response:', parseError);
+            throw new Error(`Jupiter swap transaction build failed: ${response.statusText}`);
+        }
     }
 
-    return await response.json();
+    const result = await response.json();
+    console.log('Jupiter swap transaction built successfully');
+    return result;
 };
 
 export const executeJupiterSwap = async (
@@ -330,6 +477,15 @@ export const executeJupiterSwap = async (
     connection: Connection,
     payer: Keypair
 ): Promise<SwapResult> => {
+    console.log('executeJupiterSwap: Starting');
+    console.log('Swap params:', {
+        fromToken: swapParams.fromToken.toString(),
+        toToken: swapParams.toToken.toString(),
+        amount: swapParams.amount,
+        slippageBps: swapParams.slippageBps,
+        userPublicKey: swapParams.userPublicKey.toString()
+    });
+
     try {
         console.log('Getting Jupiter quote...');
         const quote = await getJupiterQuote(
@@ -353,13 +509,19 @@ export const executeJupiterSwap = async (
 
         console.log('Deserializing transaction...');
         const swapTransactionBuf = Buffer.from(swapResponse.swapTransaction, 'base64');
+        console.log('Transaction buffer length:', swapTransactionBuf.length);
+
         const transaction = VersionedTransaction.deserialize(swapTransactionBuf);
+        console.log('Transaction deserialized successfully');
 
         console.log('Signing transaction...');
         transaction.sign([payer]);
+        console.log('Transaction signed');
 
         console.log('Sending transaction...');
         const blockhash = await connection.getLatestBlockhash();
+        console.log('Got latest blockhash for confirmation');
+
         const signature = await transactionSenderAndConfirmationWaiter({
             connection,
             serializedTransaction: Buffer.from(transaction.serialize()),
@@ -369,25 +531,32 @@ export const executeJupiterSwap = async (
             }
         });
 
+        // console.log('signature: ', signature);
         if (!signature) {
+            console.log('Transaction failed to confirm');
             return {
                 success: false,
                 error: 'Transaction failed to confirm'
             };
         }
 
-        console.log('Swap successful! Signature:', signature.transaction.signatures[0]);
+        const txSignature = signature.transaction.signatures[0];
+        console.log('Swap successful! Signature:', txSignature);
 
         return {
             success: true,
-            hash: signature.transaction.signatures[0],
+            hash: txSignature,
             inputAmount: quote.inAmount,
             outputAmount: quote.outAmount,
             priceImpact: quote.priceImpactPct
         };
 
     } catch (error) {
-        console.error('Jupiter swap failed:', error);
+        console.log('Jupiter swap failed with error:', error);
+        console.log('Error type:', typeof error);
+        console.log('Error message:', error instanceof Error ? error.message : 'Unknown error');
+        console.log('Error stack:', error instanceof Error ? error.stack : 'No stack trace');
+
         return {
             success: false,
             error: error instanceof Error ? error.message : 'Unknown error occurred'
@@ -396,22 +565,34 @@ export const executeJupiterSwap = async (
 };
 
 export const uiAmountToBaseUnits = (uiAmount: number, decimals: number): number => {
-    return Math.floor(uiAmount * Math.pow(10, decimals));
+    console.log('uiAmountToBaseUnits: Converting', uiAmount, 'with', decimals, 'decimals');
+    const result = Math.floor(uiAmount * Math.pow(10, decimals));
+    console.log('Converted to base units:', result);
+    return result;
 };
 
 export const baseUnitsToUiAmount = (baseAmount: string | number, decimals: number): number => {
-    return Number(baseAmount) / Math.pow(10, decimals);
+    console.log('baseUnitsToUiAmount: Converting', baseAmount, 'with', decimals, 'decimals');
+    const result = Number(baseAmount) / Math.pow(10, decimals);
+    console.log('Converted to UI amount:', result);
+    return result;
 };
 
 export const getJupiterTokenList = async (): Promise<any[]> => {
+    console.log('getJupiterTokenList: Fetching token list');
     try {
         const response = await fetch(`${JUPITER_BASE_URL}/tokens/v1/mints/tradable`);
+        console.log('Token list response status:', response.status);
+
         if (!response.ok) {
+            console.log('Failed to fetch token list:', response.statusText);
             throw new Error(`Failed to fetch token list: ${response.statusText}`);
         }
-        return await response.json();
+        const result = await response.json();
+        console.log('Token list fetched, count:', result.length);
+        return result;
     } catch (error) {
-        console.error('Failed to fetch Jupiter token list:', error);
+        console.log('Failed to fetch Jupiter token list:', error);
         return [];
     }
 };
@@ -420,23 +601,35 @@ export const validateJupiterTokens = async (
     inputMint: string,
     outputMint: string
 ): Promise<{ valid: boolean; message?: string }> => {
+    console.log('validateJupiterTokens: Starting validation');
+    console.log('Input mint:', inputMint);
+    console.log('Output mint:', outputMint);
+
     try {
         const tokenList = await getJupiterTokenList();
         const inputSupported = tokenList.includes(inputMint);
         const outputSupported = tokenList.includes(outputMint);
 
+        console.log('Input token supported:', inputSupported);
+        console.log('Output token supported:', outputSupported);
+
         if (!inputSupported && !outputSupported) {
+            console.log('Both tokens not supported');
             return { valid: false, message: 'Both input and output tokens are not supported' };
         }
         if (!inputSupported) {
+            console.log('Input token not supported');
             return { valid: false, message: 'Input token is not supported' };
         }
         if (!outputSupported) {
+            console.log('Output token not supported');
             return { valid: false, message: 'Output token is not supported' };
         }
 
+        console.log('Both tokens are supported');
         return { valid: true };
     } catch (error) {
+        console.log('Token validation failed:', error);
         return { valid: false, message: 'Failed to validate tokens' };
     }
 };