@deserialize/multi-vm-wallet 1.2.10 → 1.2.21

package/utils/evm/utils.ts

@@ -1,6 +1,7 @@
-import { Balance, TokenInfo } from '../types'
+import { Balance, ChainWalletConfig, SUPPORTED_VM, UserTokenBalance, TokenInfo } from '../types'
 import { JsonRpcProvider, Contract, Wallet, TransactionRequest, TransactionResponse, TransactionReceipt, parseUnits, formatUnits } from 'ethers'
 import BN from 'bn.js'
+import { HelperAPI } from '../helpers';
 
 const KYBER_BASE_URL = 'https://aggregator-api.kyberswap.com';
 
@@ -23,7 +24,7 @@ interface TransactionResult {
     effectiveGasPrice?: bigint
     blockNumber?: number
     confirmations: number
-    
+
 }
 
 export interface SwapParams {
@@ -636,6 +637,22 @@ export const safeApprove = async (
     }
 }
 
+export const discoverTokens = async (wallet: string, chain: ChainWalletConfig): Promise<UserTokenBalance<string>[]> => {
+    const balances = await HelperAPI.getUserToken(wallet, chain.vmType ?? "EVM", chain.chainId)
+
+
+    const formatBalances: UserTokenBalance<string>[] = balances.data.map((token: any) => {
+        return {
+            address: token.contractAddress,
+            name: token.name,
+            symbol: token.symbol,
+            decimals: token.decimals,
+            balance: token.balance,
+            owner: wallet
+        }
+    })
+    return formatBalances
+}
 
 //swaps
 
@@ -769,9 +786,9 @@ export async function performSwap(params: {
             amountIn: params.amountIn,
             chainId: params.chainId
         });
-        
+
         console.log('Fetching best swap route across all DEXs...');
-        
+
         const routeResponse = await getKyberSwapRoute({
             chainId: params.chainId,
             tokenIn: params.tokenIn,
@@ -792,7 +809,7 @@ export async function performSwap(params: {
         }
 
         const { routeSummary, routerAddress } = routeResponse.data;
-        
+
         // Debug: Log what we actually received
         console.log('routeSummary keys:', Object.keys(routeSummary));
         console.log('routeSummary.swaps exists:', !!routeSummary.swaps);
@@ -808,13 +825,13 @@ export async function performSwap(params: {
             // Only try to access swaps if it exists
             swapsCount: routeSummary.swaps ? routeSummary.swaps.length : 0,
             // Only extract exchange names if swaps exists and has the expected structure
-            dexSources: routeSummary.swaps && Array.isArray(routeSummary.swaps) 
+            dexSources: routeSummary.swaps && Array.isArray(routeSummary.swaps)
                 ? routeSummary.swaps.map(swap => swap?.exchange || 'unknown').filter(Boolean)
                 : ['unknown']
         });
 
         console.log('Building executable transaction...');
-        
+
         const buildResponse = await buildKyberSwapTransaction(
             params.chainId,
             routeSummary,
@@ -852,7 +869,7 @@ export async function performSwap(params: {
 
     } catch (error) {
         console.error('❌ KyberSwap aggregation failed:', error);
-        
+
         // More detailed error logging
         if (error instanceof Error) {
             console.error('Error details:', {
@@ -861,7 +878,7 @@ export async function performSwap(params: {
                 name: error.name
             });
         }
-        
+
         throw new Error(`Swap preparation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
@@ -915,22 +932,6 @@ export function prepareSwapParams(
     };
 }
 
-/**
- * Normalize token address for Debonk
- * Converts 'native' or variations to the standard 0xEeeee... address
- */
-// export function normalizeTokenAddressForDebonk(tokenAddress: string): string {
-//     if (tokenAddress === 'native' || 
-//         tokenAddress.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee') {
-//         return getNativeTokenAddress();
-//     }
-//     return tokenAddress;
-// }
-
-/**
- * Convert slippage from basis points to percentage for Debonk
- * Input: 50 (0.5% in bps) -> Output: 0.5 (percentage)
- */
 export function convertSlippageForDebonk(slippageBps: number): number {
     return slippageBps / 100;
 }

package/utils/helpers/index.ts

@@ -0,0 +1,11 @@
+import { vmTypes } from "../types";
+
+const BASE_URL = "https://helper.decane.app"
+
+export class HelperAPI {
+    static async getUserToken(wallet: string, vm: vmTypes, chainId: number) {
+        const res = await fetch("" + BASE_URL + `/${vm}/tokens/discover?wallet=${wallet}&chainId=${chainId}`);
+        const data = await res.json();
+        return data;
+    }
+}

package/utils/svm/constant.ts

@@ -0,0 +1,29 @@
+const SVM_NETWORKS_NAME = {
+    SOLANA_MAINNET: "SOLANA_MAINNET",
+    SOLANA_TESTNET: "SOLANA_TESTNET",
+    ECLIPSE_MAINNET: "ECLIPSE_MAINNET"
+} as const
+
+
+
+
+export const SVM_CHAIN_DETAILS: { [key: string]: SVMNetwork } = {
+    "123456789": SVM_NETWORKS_NAME.SOLANA_MAINNET,
+    "123456790": SVM_NETWORKS_NAME.SOLANA_TESTNET,
+    "123456791": SVM_NETWORKS_NAME.ECLIPSE_MAINNET
+}
+
+export type SVMNetwork = typeof SVM_NETWORKS_NAME[keyof typeof SVM_NETWORKS_NAME];
+
+export const SVM_CHAIN_CONFIG: { [key in SVMNetwork]: { rpcUrl: string } } = {
+    [SVM_NETWORKS_NAME.SOLANA_MAINNET]: {
+        rpcUrl: "https://solana-mainnet.g.alchemy.com/v2/vB5mKztdJeFdz9RkW99Qf"
+    },
+    [SVM_NETWORKS_NAME.SOLANA_TESTNET]: {
+        rpcUrl: "https://solana-testnet.g.alchemy.com/v2/vB5mKztdJeFdz9RkW99Qf"
+    },
+    [SVM_NETWORKS_NAME.ECLIPSE_MAINNET]: {
+        rpcUrl: "https://mainnetbeta-rpc.eclipse.xyz"
+    }
+}
+

package/utils/svm/svm.ts

@@ -2,7 +2,7 @@ import { Connection, Keypair, PublicKey } from "@solana/web3.js";
 import { SVMDeriveChildPrivateKey } from "../walletBip32";
 import { VM } from "../vm";
 import { ChainWallet } from "../IChainWallet";
-import { Balance, ChainWalletConfig, TokenInfo, TransactionResult } from "../types";
+import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionResult } from "../types";
 import {
     getSvmNativeBalance,
     getTokenBalance,
@@ -15,11 +15,14 @@ import {
     uiAmountToBaseUnits,
     validateJupiterTokens,
     JupiterQuoteResponse,
-    getTokenInfo
+    getTokenInfo,
+    discoverTokens
 } from "./utils";
 import BN from "bn.js";
 import nacl from "tweetnacl";
 import base58 from "bs58";
+import { getSVMTransactionHistory, SVMTransactionHistoryItem } from "./transactionParsing";
+
 
 export class SVMVM extends VM<PublicKey, Keypair, Connection> {
     getTokenInfo = getTokenInfo
@@ -92,6 +95,11 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
         // Implement token balance retrieval logic here
         return await SVMVM.getTokenBalance(this.address, (tokenAddress), this.connection!);
     }
+    async discoverToken(): Promise<UserTokenBalance<PublicKey>[]> {
+        // Implement token discovery logic here
+        const tokens = await discoverTokens(this.address, this.connection!)
+        return tokens
+    }
 
     async transferNative(to: PublicKey, amount: number): Promise<TransactionResult> {
         // Implement native transfer logic here
@@ -107,6 +115,10 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
         return { success: true, hash }; // Placeholder
     }
 
+    async getTransactionHistory(): Promise<SVMTransactionHistoryItem[]> {
+        const history = await getSVMTransactionHistory(this.connection!, this.address);
+        return history;
+    }
 
     async swap(fromToken: TokenInfo, toToken: PublicKey, amount: number, slippage: number = 50): Promise<TransactionResult> {
         try {

package/utils/svm/transactionParsing.ts

@@ -0,0 +1,294 @@
+import { Connection, PublicKey, ParsedTransactionWithMeta, ConfirmedSignatureInfo, TokenBalance } from '@solana/web3.js';
+import { TRANSACTION_TYPE, TransactionType } from '../constant';
+
+export interface SVMTransactionHistoryItem {
+    hash: string;
+    timestamp: number | null | undefined;
+    status: 'success' | 'failed' | 'pending';
+    fee: number;
+    type: TransactionType;
+    from: string;
+    to?: string;
+
+
+
+    slot: number;
+    amount?: number;
+    token?: string;
+    memo?: string;
+}
+
+export interface TransactionHistoryOptions {
+    limit?: number;
+    before?: string;
+    until?: string;
+}
+
+/**
+ * Fetches and parses transaction history for a Solana wallet address
+ * @param connection - Solana RPC connection
+ * @param walletAddress - Public key of the wallet (string or PublicKey)
+ * @param options - Optional parameters for pagination and filtering
+ * @returns Array of parsed transaction history items
+ */
+export async function getSVMTransactionHistory(
+    connection: Connection,
+    walletAddress: PublicKey,
+    options: TransactionHistoryOptions = {}
+): Promise<SVMTransactionHistoryItem[]> {
+    const { limit = 50, before, until } = options;
+
+    const publicKey = typeof walletAddress === 'string'
+        ? new PublicKey(walletAddress)
+        : walletAddress;
+
+    try {
+        // Fetch signature info
+        const signatures = await connection.getSignaturesForAddress(publicKey, {
+            limit,
+            before,
+            until,
+        });
+
+        console.log(`Found ${signatures.length} transactions`);
+
+        // Fetch and parse transactions in batches to avoid rate limits
+        const transactions = await fetchTransactionsInBatches(
+            connection,
+            signatures,
+            5 // batch size
+        );
+
+        // Parse transactions into a user-friendly format
+        const history: SVMTransactionHistoryItem[] = [];
+
+        for (let i = 0; i < transactions.length; i++) {
+            const tx = transactions[i];
+            const sigInfo = signatures[i];
+
+            if (!tx) {
+                // Transaction might be null if it's not available
+                history.push({
+                    hash: sigInfo.signature,
+                    timestamp: sigInfo.blockTime,
+                    slot: sigInfo.slot,
+                    status: sigInfo.err ? 'failed' : 'success',
+                    fee: 0,
+                    type: TRANSACTION_TYPE.UNKNOWN,
+                    from: walletAddress.toBase58()
+                });
+                continue;
+            }
+
+            const parsed = parseTransaction(tx, publicKey.toBase58());
+            history.push({
+                hash: sigInfo.signature,
+                timestamp: sigInfo.blockTime,
+                slot: sigInfo.slot,
+                status: tx.meta?.err ? 'failed' : 'success',
+                fee: parsed.fee ?? 0,
+                type: parsed.type ?? TRANSACTION_TYPE.UNKNOWN,
+                from: parsed.from ?? walletAddress.toBase58(),
+                ...parsed,
+            });
+        }
+
+        return history;
+    } catch (error) {
+        console.error('Error fetching transaction history:', error);
+        throw error;
+    }
+}
+
+/**
+ * Fetches transactions in batches to avoid overwhelming the RPC
+ */
+async function fetchTransactionsInBatches(
+    connection: Connection,
+    signatures: ConfirmedSignatureInfo[],
+    batchSize: number
+): Promise<(ParsedTransactionWithMeta | null)[]> {
+    const transactions: (ParsedTransactionWithMeta | null)[] = [];
+
+    for (let i = 0; i < signatures.length; i += batchSize) {
+        const batch = signatures.slice(i, i + batchSize);
+        const batchPromises = batch.map(sig =>
+            connection.getParsedTransaction(sig.signature, {
+                maxSupportedTransactionVersion: 0,
+            })
+        );
+
+        const batchResults = await Promise.all(batchPromises);
+        transactions.push(...batchResults);
+
+        // Small delay to avoid rate limiting
+        if (i + batchSize < signatures.length) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+
+    return transactions;
+}
+
+/**
+ * Parses a transaction into a simplified format
+ */
+function parseTransaction(
+    tx: ParsedTransactionWithMeta,
+    walletAddress: string
+): Partial<SVMTransactionHistoryItem> {
+    const fee = tx.meta?.fee || 0;
+
+    // Try to determine transaction type and extract relevant info
+    const instructions = tx.transaction.message.instructions;
+
+    // Check for token transfers
+    if (tx.meta?.preTokenBalances && tx.meta?.postTokenBalances) {
+        // console.log('tx.meta: ', tx.meta);
+        const tokenTransfer = findTokenTransfer(
+            tx.meta.preTokenBalances,
+            tx.meta.postTokenBalances,
+            walletAddress
+        );
+
+        if (tokenTransfer) {
+            return {
+                fee,
+                type: TRANSACTION_TYPE.TOKEN_TRANSFER,
+                from: tokenTransfer.from,
+                to: tokenTransfer.to,
+                amount: tokenTransfer.amount,
+                token: tokenTransfer.mint,
+            };
+        }
+    }
+
+    // Check for SOL transfers
+    if (tx.meta?.preBalances && tx.meta?.postBalances) {
+        const solTransfer = findSolTransfer(
+            tx.meta.preBalances,
+            tx.meta.postBalances,
+            tx.transaction.message.accountKeys,
+            walletAddress
+        );
+
+        if (solTransfer) {
+            return {
+                fee,
+                type: TRANSACTION_TYPE.NATIVE_TRANSFER,
+                from: solTransfer.from,
+                to: solTransfer.to,
+                amount: solTransfer.amount,
+                token: 'SOL',
+            };
+        }
+    }
+
+    // Check for memo
+    const memo = extractMemo(instructions);
+
+    // Determine general type based on instructions
+    const type = determineTransactionType(instructions);
+
+    return {
+        fee,
+        type,
+        memo,
+    };
+}
+
+/**
+ * Finds token transfers in the transaction
+ */
+function findTokenTransfer(
+    preBalances: TokenBalance[],
+    postBalances: TokenBalance[],
+    walletAddress: string
+): { from: string; to: string; amount: number; mint: string } | null {
+    for (let i = 0; i < postBalances.length; i++) {
+        const post = postBalances[i]
+        const pre = preBalances.find(
+            p => p.accountIndex === post.accountIndex
+        );
+
+        if (!pre) continue;
+
+        const preAmount = parseFloat(pre.uiTokenAmount.uiAmountString || "0");
+        const postAmount = parseFloat(post.uiTokenAmount.uiAmountString || "0");
+        const diff = postAmount - preAmount;
+        const from = diff < 0 ? post.owner ?? "unknown" : postBalances[i + 1]?.owner ?? "unknown";
+
+        let to = diff > 0 ? post.owner ?? "unknown" : postBalances[i + 1]?.owner ?? "unknown";
+        if (to === "unknown") {
+            to = diff > 0 ? post.owner ?? "unknown" : postBalances[i - 1]?.owner ?? "unknown"
+        }
+
+        if (from && to) {
+
+            if (Math.abs(diff) > 0) {
+                return {
+                    from,
+                    to,
+                    amount: Math.abs(diff),
+                    mint: post.mint,
+                };
+            }
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Finds SOL transfers in the transaction
+ */
+function findSolTransfer(
+    preBalances: number[],
+    postBalances: number[],
+    accountKeys: any[],
+    walletAddress: string
+): { from: string; to: string; amount: number } | null {
+    for (let i = 0; i < preBalances.length; i++) {
+        const diff = postBalances[i] - preBalances[i];
+        const account = accountKeys[i];
+        const accountPubkey = typeof account === 'string' ? account : account.pubkey.toBase58();
+
+        if (Math.abs(diff) > 5000 && accountPubkey === walletAddress) { // Ignore fee-only changes
+            return {
+                from: diff < 0 ? accountPubkey : 'unknown',
+                to: diff > 0 ? accountPubkey : 'unknown',
+                amount: Math.abs(diff) / 1e9, // Convert lamports to SOL
+            };
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Extracts memo from transaction instructions
+ */
+function extractMemo(instructions: any[]): string | undefined {
+    for (const instruction of instructions) {
+        if (instruction.program === 'spl-memo' || instruction.programId?.toBase58() === 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr') {
+            return instruction.parsed || instruction.data;
+        }
+    }
+    return undefined;
+}
+
+/**
+ * Determines the general type of transaction
+ */
+function determineTransactionType(instructions: any[]): TransactionType {
+    if (instructions.length === 0) return TRANSACTION_TYPE.UNKNOWN;
+
+    const programs = instructions.map(i => i.program || i.programId?.toBase58());
+
+    if (programs.includes('spl-token')) return TRANSACTION_TYPE.TOKEN_INTERACTIONS;
+    if (programs.includes('system')) return TRANSACTION_TYPE.SYSTEM;
+    if (programs.some(p => p?.includes('Swap'))) return TRANSACTION_TYPE.SWAP;
+    if (programs.some(p => p?.includes('Stake'))) return TRANSACTION_TYPE.STAKING;
+
+    return TRANSACTION_TYPE.PROGRAM_INTERACTION;
+}

package/utils/svm/utils.ts

@@ -2,9 +2,10 @@
 
 import { Account, createAssociatedTokenAccountIdempotentInstruction, createTransferCheckedInstruction, getAccount, getAssociatedTokenAddress, getAssociatedTokenAddressSync, getMint, Mint, NATIVE_MINT, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
 import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, SystemProgram, TransactionInstruction, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
-import { TokenInfo } from "../types";
+import { ChainWalletConfig, UserTokenBalance, TokenInfo } from "../types";
 import { transactionSenderAndConfirmationWaiter } from "./transactionSender";
 import { BN } from "bn.js";
+import { Metaplex } from "@metaplex-foundation/js";
 
 const JUPITER_BASE_URL = 'https://lite-api.jup.ag';
 
@@ -270,9 +271,25 @@ export const getTransferNativeTransaction = async (from: Keypair, to: PublicKey,
     console.log('getTransferNativeTransaction: Completed');
     return transaction;
 }
+const getMetaTokenMetaplexData = (mintAddress: PublicKey, connection: Connection) => {
+    const metaplex = Metaplex.make(connection);
+    return metaplex.nfts().findByMint({ mintAddress: mintAddress });
+}
 
-export const getTokenInfo = async (tokenAddress: PublicKey, connection: Connection): Promise<TokenInfo> => {
+export const getTokenInfo = async (tokenAddress: PublicKey, connection: Connection, programId?: PublicKey): Promise<TokenInfo> => {
     let mint: Mint
+
+
+    const metaplexData = await getMetaTokenMetaplexData(tokenAddress, connection).catch(() => null);
+    if (programId) {
+        const mint = await getMint(connection, tokenAddress, "confirmed", programId)
+        return {
+            address: tokenAddress.toString(),
+            decimals: mint.decimals,
+            name: metaplexData?.name || "",
+            symbol: metaplexData?.symbol || ""
+        }
+    }
     try {
         mint = await getMint(connection, tokenAddress, "confirmed", TOKEN_PROGRAM_ID)
 
@@ -286,8 +303,8 @@ export const getTokenInfo = async (tokenAddress: PublicKey, connection: Connecti
     return {
         address: tokenAddress.toString(),
         decimals: mint.decimals,
-        name: "",
-        symbol: ""
+        name: metaplexData?.name || "",
+        symbol: metaplexData?.symbol || ""
     }
 }
 
@@ -359,6 +376,35 @@ export const signAndSendTransaction = async (transaction: VersionedTransaction,
     console.log('Transaction successful, signature:', signature);
     return signature;
 }
+export const discoverTokens = async (ownerAddress: PublicKey, connection: Connection): Promise<UserTokenBalance<PublicKey>[]> => {
+
+    const owner = new PublicKey(ownerAddress);
+    let response = await connection.getParsedTokenAccountsByOwner(owner, {
+        programId: TOKEN_PROGRAM_ID
+    });
+    console.log('response: ', response);
+    let tokens2022 = await connection.getParsedTokenAccountsByOwner(owner, {
+        programId: TOKEN_2022_PROGRAM_ID
+    });
+    console.log('tokens2022: ', tokens2022);
+
+    response.value = response.value.concat(tokens2022.value);
+    const tokens = await Promise.all(response.value.map(async (accountInfo) => {
+
+        const mintAddress = accountInfo.account.data["parsed"]["info"]["mint"]
+        const mint = await getTokenInfo(new PublicKey(mintAddress), connection)
+        return {
+            owner: accountInfo.account.data["parsed"]["info"]["owner"],
+            address: accountInfo.account.data["parsed"]["info"]["mint"],
+            decimals: accountInfo.account.data["parsed"]["info"]["tokenAmount"]["decimals"],
+            symbol: mint.symbol,
+            name: mint.name,
+            balance: accountInfo.account.data["parsed"]["info"]["tokenAmount"]["amount"]
+        }
+    }))
+
+    return tokens;
+}
 
 //swap
 //you will. use jupiter for this
@@ -417,17 +463,21 @@ export const getJupiterQuote = async (
 export const buildJupiterSwapTransaction = async (
     quote: JupiterQuoteResponse,
     userPublicKey: string,
-    prioritizationFeeLamports?: number
+    prioritizationFeeLamports?: number,
+    useSharedAccounts: boolean = true
 ): Promise<JupiterSwapResponse> => {
     console.log('buildJupiterSwapTransaction: Starting');
     console.log('User public key:', userPublicKey);
+    console.log('Use shared accounts:', useSharedAccounts);
+
     const priorityFee = prioritizationFeeLamports || 5000;
     console.log('Prioritization fee:', priorityFee);
+
     const body = {
         quoteResponse: quote,
         userPublicKey,
         wrapAndUnwrapSol: true,
-        useSharedAccounts: true,
+        useSharedAccounts: useSharedAccounts,
         feeAccount: undefined,
         trackingAccount: undefined,
         computeUnitPriceMicroLamports: undefined,
@@ -459,9 +509,23 @@ export const buildJupiterSwapTransaction = async (
         try {
             const error = await response.json();
             console.log('Swap build error details:', error);
+
+            // Check if this is the shared accounts error
+            if (error.errorCode === 'NOT_SUPPORTED' &&
+                error.error?.includes('Simple AMMs are not supported with shared accounts')) {
+                console.log('Detected shared accounts incompatibility error');
+                throw new Error('SHARED_ACCOUNTS_NOT_SUPPORTED');
+            }
+
             throw new Error(`Jupiter swap transaction build failed: ${error.message || response.statusText}`);
         } catch (parseError) {
             console.log('Failed to parse error response:', parseError);
+
+            // Re-throw if it's our custom error
+            if (parseError instanceof Error && parseError.message === 'SHARED_ACCOUNTS_NOT_SUPPORTED') {
+                throw parseError;
+            }
+
             throw new Error(`Jupiter swap transaction build failed: ${response.statusText}`);
         }
     }
@@ -500,12 +564,38 @@ export const executeJupiterSwap = async (
             priceImpact: quote.priceImpactPct
         });
 
-        console.log('Building swap transaction...');
-        const swapResponse = await buildJupiterSwapTransaction(
-            quote,
-            swapParams.userPublicKey.toString()
-        );
+        let swapResponse: JupiterSwapResponse;
+        let usedSharedAccounts = true;
 
+        try {
+            console.log('Building swap transaction with shared accounts enabled...');
+            swapResponse = await buildJupiterSwapTransaction(
+                quote,
+                swapParams.userPublicKey.toString(),
+                undefined,
+                true // Try with shared accounts first
+            );
+            console.log('Successfully built transaction with shared accounts');
+        } catch (error) {
+            if (error instanceof Error && error.message === 'SHARED_ACCOUNTS_NOT_SUPPORTED') {
+                console.log('Shared accounts not supported, retrying without shared accounts...');
+
+                // Retry without shared accounts
+                swapResponse = await buildJupiterSwapTransaction(
+                    quote,
+                    swapParams.userPublicKey.toString(),
+                    undefined,
+                    false // Retry with shared accounts disabled
+                );
+                usedSharedAccounts = false;
+                console.log('Successfully built transaction without shared accounts');
+            } else {
+                // Re-throw if it's a different error
+                throw error;
+            }
+        }
+
+        console.log('Transaction build method:', usedSharedAccounts ? 'with shared accounts' : 'without shared accounts');
         console.log('Deserializing transaction...');
         const swapTransactionBuf = Buffer.from(swapResponse.swapTransaction, 'base64');
         console.log('Transaction buffer length:', swapTransactionBuf.length);
@@ -530,7 +620,6 @@ export const executeJupiterSwap = async (
             }
         });
 
-        // console.log('signature: ', signature);
         if (!signature) {
             console.log('Transaction failed to confirm');
             return {
@@ -541,6 +630,7 @@ export const executeJupiterSwap = async (
 
         const txSignature = signature.transaction.signatures[0];
         console.log('Swap successful! Signature:', txSignature);
+        console.log('Used shared accounts:', usedSharedAccounts);
 
         return {
             success: true,
@@ -631,4 +721,5 @@ export const validateJupiterTokens = async (
         console.log('Token validation failed:', error);
         return { valid: false, message: 'Failed to validate tokens' };
     }
-};
+};
+