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

package/src/anyspend/react/hooks/useConnectedWalletDisplay.ts

@@ -0,0 +1,69 @@
+import { useAccountWallet } from "@b3dotfun/sdk/global-account/react";
+import { useAccount } from "wagmi";
+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 function useConnectedWalletDisplay(
+  selectedCryptoPaymentMethod?: CryptoPaymentMethodType,
+): UseConnectedWalletDisplayResult {
+  const { connectedEOAWallet, connectedSmartWallet } = useAccountWallet();
+  const { address: wagmiAddress, isConnected: wagmiWalletIsConnected } = useAccount();
+
+  // Helper function to check if two addresses are the same
+  const isSameAddress = (addr1?: string, addr2?: string): boolean => {
+    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: string | undefined;
+
+  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/src/anyspend/react/hooks/usePhantomTransfer.ts

@@ -0,0 +1,301 @@
+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";
+
+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 function usePhantomTransfer({ rpcEndpoint }: UsePhantomTransferParams = {}) {
+  // 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 as any).phantom?.solana?.isPhantom, []);
+  const isPhantomAvailable = isPhantomMobile || isPhantomBrowser;
+
+  /**
+   * Get the connected Phantom wallet address if available
+   */
+  const getConnectedAddress = useCallback(() => {
+    const phantom = (window as any).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: Connection, fromPubkey: PublicKey): Promise<number> => {
+    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: Connection,
+      fromPubkey: PublicKey,
+      toPubkey: PublicKey,
+      amount: bigint,
+      priorityFee: number,
+    ): Promise<Transaction> => {
+      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: Connection,
+      fromPubkey: PublicKey,
+      toPubkey: PublicKey,
+      mintPubkey: PublicKey,
+      amount: bigint,
+      priorityFee: number,
+    ): Promise<Transaction> => {
+      // 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 as any)?.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, // mint
+          ),
+        );
+      }
+
+      // 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 }: PhantomTransferParams): Promise<void> => {
+      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 as any).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: 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: unknown) {
+        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/src/global-account/react/hooks/index.ts

@@ -38,11 +38,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/src/global-account/react/hooks/useTokenBalanceDirect.tsx

@@ -0,0 +1,84 @@
+"use client";
+
+import { isNativeToken } from "@b3dotfun/sdk/anyspend";
+import { components } from "@b3dotfun/sdk/anyspend/types/api";
+import { useAccountWallet } from "@b3dotfun/sdk/global-account/react";
+import { formatTokenAmount } from "@b3dotfun/sdk/shared/utils/number";
+import { getERC20Balances, getNativeTokenBalance } from "@b3dotfun/sdk/shared/utils/thirdweb-insights";
+import { useQuery } from "@tanstack/react-query";
+import { useEffect } from "react";
+
+interface UseTokenBalanceProps {
+  token: components["schemas"]["Token"];
+  address?: string;
+}
+
+export interface TokenBalanceResult {
+  rawBalance: bigint | null;
+  formattedBalance: string;
+  isLoading: boolean;
+}
+
+export function useTokenBalanceDirect({ token, address }: UseTokenBalanceProps): TokenBalanceResult {
+  const account = useAccountWallet();
+
+  const effectiveAddress = address || account?.address;
+
+  const {
+    data: tokenBalance,
+    isLoading,
+    isFetching,
+    refetch,
+  } = useQuery({
+    queryKey: ["tokenBalance", effectiveAddress, token.chainId, token.address],
+    queryFn: async (): Promise<{ formatted: string; raw: bigint | null }> => {
+      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/src/global-account/react/hooks/useTokenFromUrl.tsx

@@ -1,9 +1,9 @@
 "use client";
 
+import { components } from "@b3dotfun/sdk/anyspend/types/api";
 import { getCoingeckoChainInfo } from "@b3dotfun/sdk/shared/constants/chains/supported";
 import { useSearchParams } from "@b3dotfun/sdk/shared/react/hooks";
 import { useQuery } from "@tanstack/react-query";
-import { components } from "@b3dotfun/sdk/anyspend/types/api";
 
 interface UseTokenFromUrlOptions {
   /**
@@ -59,14 +59,15 @@ export function useTokenFromUrl({ defaultToken, prefix }: UseTokenFromUrlOptions
   const currencyParam = searchParams.get(`${prefix}Currency`);
   const chainIdParam = searchParams.get(`${prefix}ChainId`);
 
+  // Determine network based on chainId
+  const chainInfo = chainIdParam ? getCoingeckoChainInfo(Number(chainIdParam)) : null;
+  const network = chainInfo?.coingecko_id || "";
+
   // Determine if we should fetch token info
   const shouldFetchToken = Boolean(
-    currencyParam && chainIdParam && currencyParam.toLowerCase() !== defaultToken.address.toLowerCase(),
+    currencyParam && chainIdParam && chainInfo && currencyParam.toLowerCase() !== defaultToken.address.toLowerCase(),
   );
 
-  // Determine network based on chainId
-  const network = chainIdParam ? getCoingeckoChainInfo(Number(chainIdParam)).coingecko_id : "";
-
   const { data: tokenInfo, isError } = useQuery({
     queryKey: ["tokenInfo", network, currencyParam],
     queryFn: () => fetchTokenInfo(network, currencyParam || ""),