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

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

@@ -0,0 +1,54 @@
+import { useAccountWallet } from "../../../global-account/react/index.js";
+import { useAccount } from "wagmi";
+import { CryptoPaymentMethodType } from "../components/common/CryptoPaymentMethod.js";
+/**
+ * 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
+ */
+export function useConnectedWalletDisplay(selectedCryptoPaymentMethod) {
+    const { connectedEOAWallet, connectedSmartWallet } = useAccountWallet();
+    const { address: wagmiAddress, isConnected: wagmiWalletIsConnected } = 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 === CryptoPaymentMethodType.GLOBAL_WALLET) {
+        walletAddress = connectedSmartWallet?.getAccount()?.address;
+    }
+    else if (selectedCryptoPaymentMethod === 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 = CryptoPaymentMethodType.NONE;
+    if (connectedEOAAddress || wagmiAddress) {
+        // If there's a connected EOA or wagmi wallet, suggest CONNECT_WALLET
+        suggestedPaymentMethod = CryptoPaymentMethodType.CONNECT_WALLET;
+    }
+    else if (connectedSmartWallet?.getAccount()?.address) {
+        // If only global wallet is available, suggest that
+        suggestedPaymentMethod = CryptoPaymentMethodType.GLOBAL_WALLET;
+    }
+    return {
+        walletAddress,
+        shouldShowConnectedEOA,
+        shouldShowWagmiWallet,
+        isWalletDuplicated,
+        suggestedPaymentMethod,
+    };
+}

package/dist/esm/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/esm/anyspend/react/hooks/usePhantomTransfer.js

@@ -0,0 +1,208 @@
+import { createAssociatedTokenAccountInstruction, createTransferCheckedInstruction, getAssociatedTokenAddressSync, } from "@solana/spl-token";
+import { ComputeBudgetProgram, Connection, PublicKey, SystemProgram, Transaction } from "@solana/web3.js";
+import { useCallback, useMemo } from "react";
+import { toast } from "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: "..."
+ * });
+ * ```
+ */
+export 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 = useMemo(() => navigator.userAgent.includes("Phantom"), []);
+    const isPhantomBrowser = useMemo(() => window.phantom?.solana?.isPhantom, []);
+    const isPhantomAvailable = isPhantomMobile || isPhantomBrowser;
+    /**
+     * Get the connected Phantom wallet address if available
+     */
+    const getConnectedAddress = 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 = 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 = 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 Transaction()
+            .add(
+        // Set compute unit limit first (must come before other instructions)
+        ComputeBudgetProgram.setComputeUnitLimit({
+            units: computeUnitLimit,
+        }))
+            .add(
+        // Set priority fee
+        ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: computeUnitPrice,
+        }))
+            .add(
+        // Actual transfer instruction
+        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 = useCallback(async (connection, fromPubkey, toPubkey, mintPubkey, amount, priorityFee) => {
+        // Get associated token accounts
+        const fromTokenAccount = getAssociatedTokenAddressSync(mintPubkey, fromPubkey);
+        const toTokenAccount = 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 = createTransferCheckedInstruction(fromTokenAccount, mintPubkey, toTokenAccount, fromPubkey, Number(amount), decimals);
+        const transaction = new Transaction()
+            .add(ComputeBudgetProgram.setComputeUnitLimit({
+            units: computeUnitLimit,
+        }))
+            .add(ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: computeUnitPrice,
+        }));
+        // Add create destination account instruction if needed
+        if (needsDestinationAccount) {
+            transaction.add(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 = useCallback(async ({ amountLamports, tokenAddress, recipientAddress }) => {
+        try {
+            // Step 1: Check if Phantom is installed
+            if (!isPhantomAvailable) {
+                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) {
+                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) {
+                toast.error("Failed to connect to Phantom wallet");
+                return;
+            }
+            // Step 3: Setup connection and public keys
+            const connection = new Connection(effectiveRpcEndpoint);
+            const fromPubkey = new PublicKey(publicKey.toString());
+            const toPubkey = new 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 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);
+            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")) {
+                toast.error("Transaction was cancelled by user");
+            }
+            else if (errorMessage.includes("insufficient")) {
+                toast.error("Insufficient balance for this transaction");
+            }
+            else if (errorMessage.includes("blockhash not found")) {
+                toast.error("Network congestion detected. Please try again in a moment.");
+            }
+            else {
+                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/esm/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/esm/global-account/react/hooks/index.js

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

package/dist/esm/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/esm/global-account/react/hooks/useSimBalance.js

@@ -1,8 +1,9 @@
 import { useQuery } from "@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}`;
     }
@@ -13,13 +14,13 @@ async function fetchSimBalance(address) {
     const balanceData = await response.json();
     return balanceData;
 }
-export function useSimBalance(address) {
+export function useSimBalance(address, chainIdsParam) {
     return 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/esm/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/esm/global-account/react/hooks/useTokenBalanceDirect.js

@@ -0,0 +1,59 @@
+"use client";
+import { isNativeToken } from "../../../anyspend/index.js";
+import { useAccountWallet } from "../../../global-account/react/index.js";
+import { formatTokenAmount } from "../../../shared/utils/number.js";
+import { getERC20Balances, getNativeTokenBalance } from "../../../shared/utils/thirdweb-insights.js";
+import { useQuery } from "@tanstack/react-query";
+import { useEffect } from "react";
+export function useTokenBalanceDirect({ token, address }) {
+    const account = useAccountWallet();
+    const effectiveAddress = address || account?.address;
+    const { data: tokenBalance, isLoading, isFetching, refetch, } = useQuery({
+        queryKey: ["tokenBalance", effectiveAddress, token.chainId, token.address],
+        queryFn: async () => {
+            if (!effectiveAddress)
+                return { formatted: "0", raw: null };
+            if (isNativeToken(token.address)) {
+                const nativeToken = await getNativeTokenBalance(effectiveAddress, token.chainId);
+                if (nativeToken && nativeToken.balance) {
+                    const rawBalance = nativeToken.balance;
+                    return {
+                        formatted: formatTokenAmount(BigInt(rawBalance), Number(nativeToken.decimals || 18)),
+                        raw: BigInt(rawBalance),
+                    };
+                }
+                return { formatted: "0", raw: null };
+            }
+            const response = await getERC20Balances(effectiveAddress, {
+                chainIds: [token.chainId],
+                includeSpam: false,
+            });
+            const tokenBalance = response.data?.find(t => t.token_address === token.address);
+            if (tokenBalance?.balance) {
+                return {
+                    formatted: 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
+    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/esm/global-account/react/hooks/useTokenFromUrl.js

@@ -28,10 +28,11 @@ export 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 ? getCoingeckoChainInfo(Number(chainIdParam)).coingecko_id : "";
+    const chainInfo = chainIdParam ? 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 } = useQuery({
         queryKey: ["tokenInfo", network, currencyParam],
         queryFn: () => fetchTokenInfo(network, currencyParam || ""),

package/dist/types/anyspend/react/components/common/CryptoReceiveSection.d.ts

@@ -1,10 +1,14 @@
 import { components } from "../../../types/api";
+import { CryptoPaymentMethodType } from "./CryptoPaymentMethod";
 interface CryptoReceiveSectionProps {
     isDepositMode?: boolean;
     isBuyMode?: boolean;
     selectedRecipientAddress?: string;
     recipientName?: string;
     onSelectRecipient: () => void;
+    setRecipientAddress?: (address: string | undefined) => void;
+    recipientAddressFromProps?: string;
+    globalAddress?: string;
     dstAmount: string;
     dstToken: components["schemas"]["Token"];
     selectedDstChainId?: number;
@@ -17,6 +21,7 @@ interface CryptoReceiveSectionProps {
     dstTokenLogoURI?: string;
     onShowPointsDetail?: () => void;
     onShowFeeDetail?: () => void;
+    selectedCryptoPaymentMethod?: CryptoPaymentMethodType;
 }
-export declare function CryptoReceiveSection({ isDepositMode, isBuyMode, selectedRecipientAddress, recipientName, onSelectRecipient, dstAmount, dstToken, selectedDstChainId, setSelectedDstChainId, setSelectedDstToken, isSrcInputDirty, onChangeDstAmount, anyspendQuote, dstTokenSymbol, dstTokenLogoURI, onShowPointsDetail, onShowFeeDetail, }: CryptoReceiveSectionProps): import("react/jsx-runtime").JSX.Element;
+export declare function CryptoReceiveSection({ isDepositMode, isBuyMode, selectedRecipientAddress, recipientName, onSelectRecipient, setRecipientAddress, recipientAddressFromProps, globalAddress, dstAmount, dstToken, selectedDstChainId, setSelectedDstChainId, setSelectedDstToken, isSrcInputDirty, onChangeDstAmount, anyspendQuote, dstTokenSymbol, dstTokenLogoURI, onShowPointsDetail, onShowFeeDetail, selectedCryptoPaymentMethod, }: CryptoReceiveSectionProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/anyspend/react/components/common/OrderTokenAmount.d.ts

@@ -1,5 +1,5 @@
 import { components } from "@b3dotfun/sdk/anyspend/types/api";
-export declare function OrderTokenAmount({ disabled, inputValue, onChangeInput, context, address, chainId, setChainId, token, setToken, hideTokenSelect, canEditAmount, className, innerClassName, amountClassName, tokenSelectClassName, onTokenSelect, }: {
+export declare function OrderTokenAmount({ disabled, inputValue, onChangeInput, context, address, chainId, setChainId, token, setToken, hideTokenSelect, canEditAmount, className, innerClassName, amountClassName, tokenSelectClassName, onTokenSelect, walletAddress, }: {
     disabled?: boolean;
     inputValue: string;
     onChangeInput: (value: string) => void;
@@ -18,4 +18,5 @@ export declare function OrderTokenAmount({ disabled, inputValue, onChangeInput,
     onTokenSelect?: (token: components["schemas"]["Token"], event: {
         preventDefault: () => void;
     }) => void;
+    walletAddress?: string | undefined;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/types/anyspend/react/hooks/useAutoSelectCryptoPaymentMethod.d.ts

@@ -0,0 +1,26 @@
+import { CryptoPaymentMethodType } from "../components/common/CryptoPaymentMethod";
+interface UseAutoSelectCryptoPaymentMethodParams {
+    /** Current payment type (crypto or fiat) */
+    paymentType?: "crypto" | "fiat";
+    /** Currently selected payment method */
+    selectedCryptoPaymentMethod: CryptoPaymentMethodType;
+    /** Function to update the selected payment method */
+    setSelectedCryptoPaymentMethod: (method: CryptoPaymentMethodType) => void;
+    /** Whether user has enough balance to pay */
+    hasEnoughBalance: boolean;
+    /** Whether balance is still loading */
+    isBalanceLoading: boolean;
+}
+/**
+ * Custom hook to automatically select appropriate crypto payment method
+ * based on available wallets and balance.
+ *
+ * Auto-selection logic:
+ * - Only auto-selects when payment method is NONE (doesn't override user choices)
+ * - If EOA/Wagmi wallet connected + has balance → CONNECT_WALLET
+ * - If EOA/Wagmi wallet connected + insufficient balance → TRANSFER_CRYPTO
+ * - If only Global wallet available → GLOBAL_WALLET
+ * - If no wallets → remains NONE
+ */
+export declare function useAutoSelectCryptoPaymentMethod({ paymentType, selectedCryptoPaymentMethod, setSelectedCryptoPaymentMethod, hasEnoughBalance, isBalanceLoading, }: UseAutoSelectCryptoPaymentMethodParams): void;
+export {};

package/dist/types/anyspend/react/hooks/useAutoSetActiveWalletFromWagmi.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hook that automatically sets the active thirdweb wallet when a wagmi wallet connects.
+ *
+ * This is useful for syncing wagmi wallet connections with thirdweb's wallet system,
+ * ensuring that when users connect via wagmi, the active wallet is properly set.
+ *
+ * Place this hook in components that stay mounted throughout the user flow
+ * (not in components that unmount during navigation).
+ */
+export declare function useAutoSetActiveWalletFromWagmi(): void;

package/dist/types/anyspend/react/hooks/useConnectedWalletDisplay.d.ts

@@ -0,0 +1,14 @@
+import { CryptoPaymentMethodType } from "../components/common/CryptoPaymentMethod";
+interface UseConnectedWalletDisplayResult {
+    walletAddress: string | undefined;
+    shouldShowConnectedEOA: boolean;
+    shouldShowWagmiWallet: boolean;
+    isWalletDuplicated: boolean;
+    suggestedPaymentMethod: CryptoPaymentMethodType;
+}
+/**
+ * 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
+ */
+export declare function useConnectedWalletDisplay(selectedCryptoPaymentMethod?: CryptoPaymentMethodType): UseConnectedWalletDisplayResult;
+export {};

package/dist/types/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/types/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/types/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/types/global-account/react/hooks/useTokenBalanceDirect.d.ts

@@ -0,0 +1,12 @@
+import { components } from "@b3dotfun/sdk/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b3dotfun/sdk",
-  "version": "0.0.62-alpha.1",
+  "version": "0.0.62-alpha.3",
   "source": "src/index.ts",
   "main": "./dist/cjs/index.js",
   "react-native": "./dist/cjs/index.native.js",