@b3dotfun/sdk 0.0.62-alpha.1 → 0.0.62-alpha.3

package/dist/cjs/anyspend/react/hooks/useConnectedWalletDisplay.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConnectedWalletDisplay = useConnectedWalletDisplay;
+const react_1 = require("../../../global-account/react");
+const wagmi_1 = require("wagmi");
+const CryptoPaymentMethod_1 = require("../components/common/CryptoPaymentMethod");
+/**
+ * Custom hook to determine which wallet to display and its address
+ * Handles logic for showing EOA wallet, wagmi wallet, or global wallet based on payment method
+ */
+function useConnectedWalletDisplay(selectedCryptoPaymentMethod) {
+    const { connectedEOAWallet, connectedSmartWallet } = (0, react_1.useAccountWallet)();
+    const { address: wagmiAddress, isConnected: wagmiWalletIsConnected } = (0, wagmi_1.useAccount)();
+    // Helper function to check if two addresses are the same
+    const isSameAddress = (addr1, addr2) => {
+        if (!addr1 || !addr2)
+            return false;
+        return addr1.toLowerCase() === addr2.toLowerCase();
+    };
+    // Check if connectedEOAWallet and wagmi wallet represent the same wallet
+    const connectedEOAAddress = connectedEOAWallet?.getAccount()?.address;
+    const isWalletDuplicated = isSameAddress(connectedEOAAddress, wagmiAddress);
+    // Determine which wallet to show (prefer connectedEOAWallet if both exist and are the same)
+    const shouldShowConnectedEOA = !!connectedEOAWallet;
+    const shouldShowWagmiWallet = wagmiWalletIsConnected && (!isWalletDuplicated || !connectedEOAWallet);
+    // Determine which address to use based on payment method
+    let walletAddress;
+    if (selectedCryptoPaymentMethod === CryptoPaymentMethod_1.CryptoPaymentMethodType.GLOBAL_WALLET) {
+        walletAddress = connectedSmartWallet?.getAccount()?.address;
+    }
+    else if (selectedCryptoPaymentMethod === CryptoPaymentMethod_1.CryptoPaymentMethodType.CONNECT_WALLET) {
+        // Prefer connectedEOAWallet, fallback to wagmi wallet
+        walletAddress = connectedEOAAddress || wagmiAddress;
+    }
+    else {
+        // Default behavior: use connectedEOAWallet if available, otherwise wagmi
+        walletAddress = connectedEOAAddress || wagmiAddress;
+    }
+    // Suggest a payment method based on available wallets
+    // Priority: Connected EOA/Wagmi wallet > Global wallet > None
+    let suggestedPaymentMethod = CryptoPaymentMethod_1.CryptoPaymentMethodType.NONE;
+    if (connectedEOAAddress || wagmiAddress) {
+        // If there's a connected EOA or wagmi wallet, suggest CONNECT_WALLET
+        suggestedPaymentMethod = CryptoPaymentMethod_1.CryptoPaymentMethodType.CONNECT_WALLET;
+    }
+    else if (connectedSmartWallet?.getAccount()?.address) {
+        // If only global wallet is available, suggest that
+        suggestedPaymentMethod = CryptoPaymentMethod_1.CryptoPaymentMethodType.GLOBAL_WALLET;
+    }
+    return {
+        walletAddress,
+        shouldShowConnectedEOA,
+        shouldShowWagmiWallet,
+        isWalletDuplicated,
+        suggestedPaymentMethod,
+    };
+}

package/dist/cjs/anyspend/react/hooks/usePhantomTransfer.d.ts

@@ -0,0 +1,36 @@
+interface UsePhantomTransferParams {
+    /** RPC endpoint URL for Solana network */
+    rpcEndpoint?: string;
+}
+interface PhantomTransferParams {
+    /** Amount in lamports (for SOL) or smallest token unit (for SPL tokens) */
+    amountLamports: string;
+    /** Token address (use "11111111111111111111111111111111" for native SOL) */
+    tokenAddress: string;
+    /** Recipient address */
+    recipientAddress: string;
+}
+/**
+ * Custom hook for handling Phantom wallet transfers on Solana.
+ * Supports both native SOL and SPL token transfers with automatic priority fee calculation.
+ *
+ * @example
+ * ```tsx
+ * const { initiateTransfer, isPhantomAvailable } = usePhantomTransfer();
+ *
+ * await initiateTransfer({
+ *   amountLamports: "1000000000", // 1 SOL
+ *   tokenAddress: "11111111111111111111111111111111",
+ *   recipientAddress: "..."
+ * });
+ * ```
+ */
+export declare function usePhantomTransfer({ rpcEndpoint }?: UsePhantomTransferParams): {
+    /** Function to initiate a transfer */
+    initiateTransfer: ({ amountLamports, tokenAddress, recipientAddress }: PhantomTransferParams) => Promise<void>;
+    /** Whether Phantom wallet is available (installed) */
+    isPhantomAvailable: any;
+    /** Get the currently connected Phantom wallet address */
+    getConnectedAddress: () => any;
+};
+export {};

package/dist/cjs/anyspend/react/hooks/usePhantomTransfer.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePhantomTransfer = usePhantomTransfer;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const react_1 = require("react");
+const sonner_1 = require("sonner");
+/**
+ * Custom hook for handling Phantom wallet transfers on Solana.
+ * Supports both native SOL and SPL token transfers with automatic priority fee calculation.
+ *
+ * @example
+ * ```tsx
+ * const { initiateTransfer, isPhantomAvailable } = usePhantomTransfer();
+ *
+ * await initiateTransfer({
+ *   amountLamports: "1000000000", // 1 SOL
+ *   tokenAddress: "11111111111111111111111111111111",
+ *   recipientAddress: "..."
+ * });
+ * ```
+ */
+function usePhantomTransfer({ rpcEndpoint } = {}) {
+    // Default RPC endpoint
+    const defaultRpcEndpoint = "https://mainnet.helius-rpc.com/?api-key=efafd9b3-1807-4cf8-8aa4-3d984f56d8fb";
+    const effectiveRpcEndpoint = rpcEndpoint || defaultRpcEndpoint;
+    // Check for Phantom wallet availability
+    const isPhantomMobile = (0, react_1.useMemo)(() => navigator.userAgent.includes("Phantom"), []);
+    const isPhantomBrowser = (0, react_1.useMemo)(() => window.phantom?.solana?.isPhantom, []);
+    const isPhantomAvailable = isPhantomMobile || isPhantomBrowser;
+    /**
+     * Get the connected Phantom wallet address if available
+     */
+    const getConnectedAddress = (0, react_1.useCallback)(() => {
+        const phantom = window.phantom?.solana;
+        if (phantom?.isConnected && phantom?.publicKey) {
+            return phantom.publicKey.toString();
+        }
+        return null;
+    }, []);
+    /**
+     * Calculate optimal priority fee based on recent network activity
+     */
+    const calculatePriorityFee = (0, react_1.useCallback)(async (connection, fromPubkey) => {
+        let priorityFee = 10000; // Default fallback (10,000 micro-lamports)
+        try {
+            const recentFees = await connection.getRecentPrioritizationFees({
+                lockedWritableAccounts: [fromPubkey],
+            });
+            if (recentFees && recentFees.length > 0) {
+                // Use 75th percentile of recent fees for good priority
+                const sortedFees = recentFees.map(fee => fee.prioritizationFee).sort((a, b) => a - b);
+                const percentile75Index = Math.floor(sortedFees.length * 0.75);
+                priorityFee = Math.max(sortedFees[percentile75Index] || 10000, 10000);
+            }
+        }
+        catch (feeError) {
+            console.warn("Failed to fetch recent priority fees, using default:", feeError);
+        }
+        return priorityFee;
+    }, []);
+    /**
+     * Create a native SOL transfer transaction with priority fees
+     */
+    const createNativeTransferTransaction = (0, react_1.useCallback)(async (_connection, fromPubkey, toPubkey, amount, priorityFee) => {
+        const computeUnitLimit = 1000; // SOL transfer + compute budget instructions need ~600-800 CU
+        const computeUnitPrice = Math.min(priorityFee, 100000); // Cap at 100k micro-lamports for safety
+        const transaction = new web3_js_1.Transaction()
+            .add(
+        // Set compute unit limit first (must come before other instructions)
+        web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+            units: computeUnitLimit,
+        }))
+            .add(
+        // Set priority fee
+        web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: computeUnitPrice,
+        }))
+            .add(
+        // Actual transfer instruction
+        web3_js_1.SystemProgram.transfer({
+            fromPubkey,
+            toPubkey,
+            lamports: Number(amount),
+        }));
+        console.log(`Using priority fee: ${computeUnitPrice} micro-lamports per CU, limit: ${computeUnitLimit} CU`);
+        return transaction;
+    }, []);
+    /**
+     * Create an SPL token transfer transaction with priority fees
+     */
+    const createSPLTransferTransaction = (0, react_1.useCallback)(async (connection, fromPubkey, toPubkey, mintPubkey, amount, priorityFee) => {
+        // Get associated token accounts
+        const fromTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(mintPubkey, fromPubkey);
+        const toTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(mintPubkey, toPubkey);
+        // Check if destination token account exists
+        const toTokenAccountInfo = await connection.getAccountInfo(toTokenAccount);
+        const needsDestinationAccount = !toTokenAccountInfo;
+        // Get mint info to determine decimals
+        const mintInfo = await connection.getParsedAccountInfo(mintPubkey);
+        const decimals = mintInfo.value?.data?.parsed?.info?.decimals || 9;
+        // SPL transfers need more compute units than SOL transfers
+        // Add extra CU if we need to create destination account
+        const computeUnitLimit = needsDestinationAccount ? 40000 : 20000;
+        const computeUnitPrice = Math.min(priorityFee, 100000);
+        // Create transfer instruction
+        const transferInstruction = (0, spl_token_1.createTransferCheckedInstruction)(fromTokenAccount, mintPubkey, toTokenAccount, fromPubkey, Number(amount), decimals);
+        const transaction = new web3_js_1.Transaction()
+            .add(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+            units: computeUnitLimit,
+        }))
+            .add(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: computeUnitPrice,
+        }));
+        // Add create destination account instruction if needed
+        if (needsDestinationAccount) {
+            transaction.add((0, spl_token_1.createAssociatedTokenAccountInstruction)(fromPubkey, // payer
+            toTokenAccount, // ata
+            toPubkey, // owner
+            mintPubkey));
+        }
+        // Add the transfer instruction
+        transaction.add(transferInstruction);
+        console.log(`SPL Token transfer: ${computeUnitPrice} micro-lamports per CU, limit: ${computeUnitLimit} CU, creating destination: ${needsDestinationAccount}`);
+        return transaction;
+    }, []);
+    /**
+     * Initiate a Phantom wallet transfer for SOL or SPL tokens
+     */
+    const initiateTransfer = (0, react_1.useCallback)(async ({ amountLamports, tokenAddress, recipientAddress }) => {
+        try {
+            // Step 1: Check if Phantom is installed
+            if (!isPhantomAvailable) {
+                sonner_1.toast.error("Phantom wallet not installed. Please install Phantom wallet to continue.");
+                return;
+            }
+            // Step 2: Ensure Phantom is connected/unlocked
+            const phantom = window.phantom?.solana;
+            if (!phantom) {
+                sonner_1.toast.error("Phantom wallet not accessible");
+                return;
+            }
+            // Connect and unlock wallet if needed
+            let publicKey;
+            try {
+                const connection = await phantom.connect();
+                publicKey = connection.publicKey;
+            }
+            catch (connectError) {
+                sonner_1.toast.error("Failed to connect to Phantom wallet");
+                return;
+            }
+            // Step 3: Setup connection and public keys
+            const connection = new web3_js_1.Connection(effectiveRpcEndpoint);
+            const fromPubkey = new web3_js_1.PublicKey(publicKey.toString());
+            const toPubkey = new web3_js_1.PublicKey(recipientAddress);
+            const amount = BigInt(amountLamports);
+            // Step 4: Calculate optimal priority fee
+            const priorityFee = await calculatePriorityFee(connection, fromPubkey);
+            // Step 5: Create transaction based on token type
+            let transaction;
+            if (tokenAddress === "11111111111111111111111111111111") {
+                // Native SOL transfer
+                transaction = await createNativeTransferTransaction(connection, fromPubkey, toPubkey, amount, priorityFee);
+            }
+            else {
+                // SPL Token transfer
+                const mintPubkey = new web3_js_1.PublicKey(tokenAddress);
+                transaction = await createSPLTransferTransaction(connection, fromPubkey, toPubkey, mintPubkey, amount, priorityFee);
+            }
+            // Step 6: Get latest blockhash and set fee payer
+            const { blockhash } = await connection.getLatestBlockhash("confirmed");
+            transaction.recentBlockhash = blockhash;
+            transaction.feePayer = fromPubkey;
+            // Step 7: Sign and send transaction
+            const signedTransaction = await phantom.signAndSendTransaction(transaction);
+            sonner_1.toast.success(`Transaction successful! Signature: ${signedTransaction.signature}`);
+            console.log("Transaction sent with priority fees. Signature:", signedTransaction.signature);
+        }
+        catch (error) {
+            console.error("Transfer error:", error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes("User rejected")) {
+                sonner_1.toast.error("Transaction was cancelled by user");
+            }
+            else if (errorMessage.includes("insufficient")) {
+                sonner_1.toast.error("Insufficient balance for this transaction");
+            }
+            else if (errorMessage.includes("blockhash not found")) {
+                sonner_1.toast.error("Network congestion detected. Please try again in a moment.");
+            }
+            else {
+                sonner_1.toast.error(`Transfer failed: ${errorMessage}`);
+            }
+        }
+    }, [
+        isPhantomAvailable,
+        effectiveRpcEndpoint,
+        calculatePriorityFee,
+        createNativeTransferTransaction,
+        createSPLTransferTransaction,
+    ]);
+    return {
+        /** Function to initiate a transfer */
+        initiateTransfer,
+        /** Whether Phantom wallet is available (installed) */
+        isPhantomAvailable,
+        /** Get the currently connected Phantom wallet address */
+        getConnectedAddress,
+    };
+}

package/dist/cjs/global-account/react/hooks/index.d.ts

@@ -32,11 +32,12 @@ export { useSearchParamsSSR } from "./useSearchParamsSSR";
 export { useSimBalance } from "./useSimBalance";
 export { useSiwe } from "./useSiwe";
 export { useTokenBalance } from "./useTokenBalance";
+export { useTokenBalanceDirect } from "./useTokenBalanceDirect";
 export { useTokenBalancesByChain } from "./useTokenBalancesByChain";
 export { useTokenData } from "./useTokenData";
 export { useTokenFromUrl } from "./useTokenFromUrl";
 export { useTokenPrice } from "./useTokenPrice";
 export { useTokenPriceWithFallback } from "./useTokenPriceWithFallback";
 export { useTokensFromAddress } from "./useTokensFromAddress";
-export { useUnifiedChainSwitchAndExecute } from "./useUnifiedChainSwitchAndExecute";
 export { useURLParams } from "./useURLParams";
+export { useUnifiedChainSwitchAndExecute } from "./useUnifiedChainSwitchAndExecute";

package/dist/cjs/global-account/react/hooks/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useURLParams = exports.useUnifiedChainSwitchAndExecute = exports.useTokensFromAddress = exports.useTokenPriceWithFallback = exports.useTokenPrice = exports.useTokenFromUrl = exports.useTokenData = exports.useTokenBalancesByChain = exports.useTokenBalance = exports.useSiwe = exports.useSimBalance = exports.useSearchParamsSSR = exports.useRouter = exports.useRemoveSessionKey = exports.useQueryBSMNT = exports.useQueryB3 = exports.useProfilePreference = exports.useProfile = exports.useOneBalance = exports.useNativeBalanceFromRPC = exports.useNativeBalance = exports.useMediaQuery = exports.useIsomorphicLayoutEffect = exports.useIsMobile = exports.useHasMounted = exports.useHandleConnectWithPrivy = exports.useGlobalAccount = exports.useGetGeo = exports.useGetAllTWSigners = exports.useFirstEOA = exports.useExchangeRate = exports.useConnect = exports.useClient = exports.useChainSwitchWithAction = exports.useBestTransactionPath = exports.useB3EnsName = exports.useB3BalanceFromAddresses = exports.useAuthentication = exports.useAnalytics = exports.useAddTWSessionKey = exports.useAccountWallet = exports.useAccountAssets = exports.createWagmiConfig = void 0;
+exports.useUnifiedChainSwitchAndExecute = exports.useURLParams = exports.useTokensFromAddress = exports.useTokenPriceWithFallback = exports.useTokenPrice = exports.useTokenFromUrl = exports.useTokenData = exports.useTokenBalancesByChain = exports.useTokenBalanceDirect = exports.useTokenBalance = exports.useSiwe = exports.useSimBalance = exports.useSearchParamsSSR = exports.useRouter = exports.useRemoveSessionKey = exports.useQueryBSMNT = exports.useQueryB3 = exports.useProfilePreference = exports.useProfile = exports.useOneBalance = exports.useNativeBalanceFromRPC = exports.useNativeBalance = exports.useMediaQuery = exports.useIsomorphicLayoutEffect = exports.useIsMobile = exports.useHasMounted = exports.useHandleConnectWithPrivy = exports.useGlobalAccount = exports.useGetGeo = exports.useGetAllTWSigners = exports.useFirstEOA = exports.useExchangeRate = exports.useConnect = exports.useClient = exports.useChainSwitchWithAction = exports.useBestTransactionPath = exports.useB3EnsName = exports.useB3BalanceFromAddresses = exports.useAuthentication = exports.useAnalytics = exports.useAddTWSessionKey = exports.useAccountWallet = exports.useAccountAssets = exports.createWagmiConfig = void 0;
 var createWagmiConfig_1 = require("../utils/createWagmiConfig");
 Object.defineProperty(exports, "createWagmiConfig", { enumerable: true, get: function () { return createWagmiConfig_1.createWagmiConfig; } });
 var useAccountAssets_1 = require("./useAccountAssets");
@@ -84,6 +84,8 @@ var useSiwe_1 = require("./useSiwe");
 Object.defineProperty(exports, "useSiwe", { enumerable: true, get: function () { return useSiwe_1.useSiwe; } });
 var useTokenBalance_1 = require("./useTokenBalance");
 Object.defineProperty(exports, "useTokenBalance", { enumerable: true, get: function () { return useTokenBalance_1.useTokenBalance; } });
+var useTokenBalanceDirect_1 = require("./useTokenBalanceDirect");
+Object.defineProperty(exports, "useTokenBalanceDirect", { enumerable: true, get: function () { return useTokenBalanceDirect_1.useTokenBalanceDirect; } });
 var useTokenBalancesByChain_1 = require("./useTokenBalancesByChain");
 Object.defineProperty(exports, "useTokenBalancesByChain", { enumerable: true, get: function () { return useTokenBalancesByChain_1.useTokenBalancesByChain; } });
 var useTokenData_1 = require("./useTokenData");
@@ -96,7 +98,7 @@ var useTokenPriceWithFallback_1 = require("./useTokenPriceWithFallback");
 Object.defineProperty(exports, "useTokenPriceWithFallback", { enumerable: true, get: function () { return useTokenPriceWithFallback_1.useTokenPriceWithFallback; } });
 var useTokensFromAddress_1 = require("./useTokensFromAddress");
 Object.defineProperty(exports, "useTokensFromAddress", { enumerable: true, get: function () { return useTokensFromAddress_1.useTokensFromAddress; } });
-var useUnifiedChainSwitchAndExecute_1 = require("./useUnifiedChainSwitchAndExecute");
-Object.defineProperty(exports, "useUnifiedChainSwitchAndExecute", { enumerable: true, get: function () { return useUnifiedChainSwitchAndExecute_1.useUnifiedChainSwitchAndExecute; } });
 var useURLParams_1 = require("./useURLParams");
 Object.defineProperty(exports, "useURLParams", { enumerable: true, get: function () { return useURLParams_1.useURLParams; } });
+var useUnifiedChainSwitchAndExecute_1 = require("./useUnifiedChainSwitchAndExecute");
+Object.defineProperty(exports, "useUnifiedChainSwitchAndExecute", { enumerable: true, get: function () { return useUnifiedChainSwitchAndExecute_1.useUnifiedChainSwitchAndExecute; } });

package/dist/cjs/global-account/react/hooks/useSimBalance.d.ts

@@ -21,4 +21,4 @@ export interface SimBalanceResponse {
     wallet_address: string;
     balances: SimBalanceItem[];
 }
-export declare function useSimBalance(address?: string): import("@tanstack/react-query").UseQueryResult<SimBalanceResponse, Error>;
+export declare function useSimBalance(address?: string, chainIdsParam?: number[]): import("@tanstack/react-query").UseQueryResult<SimBalanceResponse, Error>;

package/dist/cjs/global-account/react/hooks/useSimBalance.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useSimBalance = useSimBalance;
 const react_query_1 = require("@tanstack/react-query");
-async function fetchSimBalance(address) {
+async function fetchSimBalance(address, chainIdsParam) {
     if (!address)
         throw new Error("Address is required");
-    let url = `https://simdune-api.sean-430.workers.dev/?url=https://api.sim.dune.com/v1/evm/balances/${address}?metadata=logo&chain_ids=mainnet`;
+    const chainIds = chainIdsParam.length === 0 ? "mainnet" : chainIdsParam.join(",");
+    let url = `https://simdune-api.sean-430.workers.dev/?url=https://api.sim.dune.com/v1/evm/balances/${address}?metadata=logo&chain_ids=${chainIds}`;
     if (process.env.NEXT_PUBLIC_LOCAL_KEY) {
         url += `&localkey=${process.env.NEXT_PUBLIC_LOCAL_KEY}`;
     }
@@ -16,13 +17,13 @@ async function fetchSimBalance(address) {
     const balanceData = await response.json();
     return balanceData;
 }
-function useSimBalance(address) {
+function useSimBalance(address, chainIdsParam) {
     return (0, react_query_1.useQuery)({
-        queryKey: ["simBalance", address],
+        queryKey: ["simBalance", address, chainIdsParam],
         queryFn: () => {
             if (!address)
                 throw new Error("Address is required");
-            return fetchSimBalance(address);
+            return fetchSimBalance(address, chainIdsParam || []);
         },
         enabled: Boolean(address),
     });

package/dist/cjs/global-account/react/hooks/useTokenBalanceDirect.d.ts

@@ -0,0 +1,12 @@
+import { components } from "../../../anyspend/types/api";
+interface UseTokenBalanceProps {
+    token: components["schemas"]["Token"];
+    address?: string;
+}
+export interface TokenBalanceResult {
+    rawBalance: bigint | null;
+    formattedBalance: string;
+    isLoading: boolean;
+}
+export declare function useTokenBalanceDirect({ token, address }: UseTokenBalanceProps): TokenBalanceResult;
+export {};

package/dist/cjs/global-account/react/hooks/useTokenBalanceDirect.js

@@ -0,0 +1,62 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokenBalanceDirect = useTokenBalanceDirect;
+const anyspend_1 = require("../../../anyspend");
+const react_1 = require("../../../global-account/react");
+const number_1 = require("../../../shared/utils/number");
+const thirdweb_insights_1 = require("../../../shared/utils/thirdweb-insights");
+const react_query_1 = require("@tanstack/react-query");
+const react_2 = require("react");
+function useTokenBalanceDirect({ token, address }) {
+    const account = (0, react_1.useAccountWallet)();
+    const effectiveAddress = address || account?.address;
+    const { data: tokenBalance, isLoading, isFetching, refetch, } = (0, react_query_1.useQuery)({
+        queryKey: ["tokenBalance", effectiveAddress, token.chainId, token.address],
+        queryFn: async () => {
+            if (!effectiveAddress)
+                return { formatted: "0", raw: null };
+            if ((0, anyspend_1.isNativeToken)(token.address)) {
+                const nativeToken = await (0, thirdweb_insights_1.getNativeTokenBalance)(effectiveAddress, token.chainId);
+                if (nativeToken && nativeToken.balance) {
+                    const rawBalance = nativeToken.balance;
+                    return {
+                        formatted: (0, number_1.formatTokenAmount)(BigInt(rawBalance), Number(nativeToken.decimals || 18)),
+                        raw: BigInt(rawBalance),
+                    };
+                }
+                return { formatted: "0", raw: null };
+            }
+            const response = await (0, thirdweb_insights_1.getERC20Balances)(effectiveAddress, {
+                chainIds: [token.chainId],
+                includeSpam: false,
+            });
+            const tokenBalance = response.data?.find(t => t.token_address === token.address);
+            if (tokenBalance?.balance) {
+                return {
+                    formatted: (0, number_1.formatTokenAmount)(BigInt(tokenBalance.balance), Number(tokenBalance.decimals || 18)),
+                    raw: BigInt(tokenBalance.balance),
+                };
+            }
+            return { formatted: "0", raw: null };
+        },
+        enabled: !!effectiveAddress,
+        staleTime: 30000,
+        gcTime: 5 * 60 * 1000,
+        retry: 2,
+        structuralSharing: false,
+    });
+    // Force a refetch when the wallet or token changes
+    (0, react_2.useEffect)(() => {
+        if (effectiveAddress) {
+            refetch();
+        }
+    }, [effectiveAddress, token.address, token.chainId, token.symbol, refetch]);
+    // Determine if we're actually loading
+    const isActuallyLoading = !effectiveAddress || isLoading || (isFetching && !tokenBalance);
+    return {
+        rawBalance: tokenBalance?.raw || BigInt(0),
+        formattedBalance: tokenBalance?.formatted || "0",
+        isLoading: isActuallyLoading,
+    };
+}

package/dist/cjs/global-account/react/hooks/useTokenFromUrl.js

@@ -32,10 +32,11 @@ function useTokenFromUrl({ defaultToken, prefix }) {
     // Get parameters from URL
     const currencyParam = searchParams.get(`${prefix}Currency`);
     const chainIdParam = searchParams.get(`${prefix}ChainId`);
-    // Determine if we should fetch token info
-    const shouldFetchToken = Boolean(currencyParam && chainIdParam && currencyParam.toLowerCase() !== defaultToken.address.toLowerCase());
     // Determine network based on chainId
-    const network = chainIdParam ? (0, supported_1.getCoingeckoChainInfo)(Number(chainIdParam)).coingecko_id : "";
+    const chainInfo = chainIdParam ? (0, supported_1.getCoingeckoChainInfo)(Number(chainIdParam)) : null;
+    const network = chainInfo?.coingecko_id || "";
+    // Determine if we should fetch token info
+    const shouldFetchToken = Boolean(currencyParam && chainIdParam && chainInfo && currencyParam.toLowerCase() !== defaultToken.address.toLowerCase());
     const { data: tokenInfo, isError } = (0, react_query_1.useQuery)({
         queryKey: ["tokenInfo", network, currencyParam],
         queryFn: () => fetchTokenInfo(network, currencyParam || ""),