@b3dotfun/sdk 0.0.62 → 0.0.63-test.0-alpha.0

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

@@ -23,6 +23,8 @@ import { useAccount } from "wagmi";
 import { components } from "../../types/api";
 import { CryptoPaymentMethodType } from "../components/common/CryptoPaymentMethod";
 import { FiatPaymentMethod } from "../components/common/FiatPaymentMethod";
+import { useAutoSelectCryptoPaymentMethod } from "./useAutoSelectCryptoPaymentMethod";
+import { useAutoSetActiveWalletFromWagmi } from "./useAutoSetActiveWalletFromWagmi";
 
 export enum PanelView {
   MAIN,
@@ -41,13 +43,17 @@ interface UseAnyspendFlowProps {
   loadOrder?: string;
   isDepositMode?: boolean;
   onOrderSuccess?: (orderId: string) => void;
-  onTransactionSuccess?: (amount?: string) => void;
+  onTransactionSuccess?: (amount: string) => void;
   sourceTokenAddress?: string;
   sourceTokenChainId?: number;
+  destinationTokenAddress?: string;
+  destinationTokenChainId?: number;
   slippage?: number;
   disableUrlParamManagement?: boolean;
+  orderType?: "hype_duel" | "custom_exact_in";
 }
 
+// This hook serves for order hype_duel and custom_exact_in
 export function useAnyspendFlow({
   paymentType = "crypto",
   recipientAddress,
@@ -57,8 +63,11 @@ export function useAnyspendFlow({
   onTransactionSuccess,
   sourceTokenAddress,
   sourceTokenChainId,
+  destinationTokenAddress,
+  destinationTokenChainId,
   slippage = 0,
   disableUrlParamManagement = false,
+  orderType = "hype_duel",
 }: UseAnyspendFlowProps) {
   const searchParams = useSearchParamsSSR();
   const router = useRouter();
@@ -68,17 +77,21 @@ export function useAnyspendFlow({
   const [orderId, setOrderId] = useState<string | undefined>(loadOrder);
   const { orderAndTransactions: oat } = useAnyspendOrderAndTransactions(orderId);
 
-  // Token selection state - use provided sourceTokenChainId if available
+  // Token selection state - use provided sourceTokenChainId and destinationTokenChainId if available
   const [selectedSrcChainId, setSelectedSrcChainId] = useState<number>(
     sourceTokenChainId || (paymentType === "fiat" ? base.id : mainnet.id),
   );
-  const [selectedDstChainId, setSelectedDstChainId] = useState<number>(base.id); // Default to Base for cross-chain swaps
   const defaultSrcToken = paymentType === "fiat" ? USDC_BASE : getDefaultToken(selectedSrcChainId);
+  const defaultDstToken = B3_TOKEN; // Default destination token
   const [selectedSrcToken, setSelectedSrcToken] = useState<components["schemas"]["Token"]>(defaultSrcToken);
+  const [selectedDstToken, setSelectedDstToken] = useState<components["schemas"]["Token"]>(defaultDstToken);
   const [srcAmount, setSrcAmount] = useState<string>(paymentType === "fiat" ? "5" : "0.1");
   const [dstAmount, setDstAmount] = useState<string>("");
   const [isSrcInputDirty, setIsSrcInputDirty] = useState(true);
 
+  // Derive destination chain ID from token or prop (cannot change)
+  const selectedDstChainId = destinationTokenChainId || selectedDstToken.chainId;
+
   // Payment method state
   const [selectedCryptoPaymentMethod, setSelectedCryptoPaymentMethod] = useState<CryptoPaymentMethodType>(
     CryptoPaymentMethodType.NONE,
@@ -92,6 +105,9 @@ export function useAnyspendFlow({
   const recipientProfile = useProfile({ address: selectedRecipientAddress, fresh: true });
   const recipientName = recipientProfile.data?.name;
 
+  // Auto-set active wallet from wagmi
+  useAutoSetActiveWalletFromWagmi();
+
   // Set default recipient address when wallet changes
   useEffect(() => {
     if (!selectedRecipientAddress && globalAddress) {
@@ -116,16 +132,14 @@ export function useAnyspendFlow({
     }
   }, [rawBalance, srcAmount, selectedSrcToken.decimals, isBalanceLoading, paymentType]);
 
-  // Auto-set crypto payment method based on balance
-  useEffect(() => {
-    if (paymentType === "crypto" && !isBalanceLoading) {
-      if (hasEnoughBalance) {
-        setSelectedCryptoPaymentMethod(CryptoPaymentMethodType.CONNECT_WALLET);
-      } else {
-        setSelectedCryptoPaymentMethod(CryptoPaymentMethodType.TRANSFER_CRYPTO);
-      }
-    }
-  }, [paymentType, hasEnoughBalance, isBalanceLoading]);
+  // Auto-select crypto payment method based on available wallets and balance
+  useAutoSelectCryptoPaymentMethod({
+    paymentType,
+    selectedCryptoPaymentMethod,
+    setSelectedCryptoPaymentMethod,
+    hasEnoughBalance,
+    isBalanceLoading,
+  });
 
   // Fetch specific token when sourceTokenAddress and sourceTokenChainId are provided
   useEffect(() => {
@@ -145,6 +159,24 @@ export function useAnyspendFlow({
     fetchSourceToken();
   }, [sourceTokenAddress, sourceTokenChainId]);
 
+  // Fetch specific token when destinationTokenAddress and destinationTokenChainId are provided
+  useEffect(() => {
+    const fetchDestinationToken = async () => {
+      if (destinationTokenAddress && destinationTokenChainId) {
+        try {
+          const token = await anyspendService.getToken(destinationTokenChainId, destinationTokenAddress);
+          setSelectedDstToken(token);
+        } catch (error) {
+          console.error("Failed to fetch destination token:", error);
+          toast.error(`Failed to load token ${destinationTokenAddress} on chain ${destinationTokenChainId}`);
+          // Keep the default token on error
+        }
+      }
+    };
+
+    fetchDestinationToken();
+  }, [destinationTokenAddress, destinationTokenChainId]);
+
   // Helper function for onramp vendor mapping
   const getOnrampVendor = (paymentMethod: FiatPaymentMethod): "coinbase" | "stripe" | "stripe-web2" | undefined => {
     switch (paymentMethod) {
@@ -165,8 +197,8 @@ export function useAnyspendFlow({
     srcChain: paymentType === "fiat" ? base.id : selectedSrcChainId,
     dstChain: isDepositMode ? base.id : selectedDstChainId, // For deposits, always Base; for swaps, use selected destination
     srcTokenAddress: paymentType === "fiat" ? USDC_BASE.address : selectedSrcToken.address,
-    dstTokenAddress: isDepositMode ? B3_TOKEN.address : selectedSrcToken.address, // For deposits, always B3
-    type: "hype_duel",
+    dstTokenAddress: selectedDstToken.address,
+    type: orderType,
     amount: activeInputAmountInWei,
     recipientAddress: selectedRecipientAddress,
     onrampVendor: paymentType === "fiat" ? getOnrampVendor(selectedFiatPaymentMethod) : undefined,
@@ -253,7 +285,7 @@ export function useAnyspendFlow({
       const formattedActualDstAmount = amount
         ? formatTokenAmount(BigInt(amount), oat.data.order.metadata.dstToken.decimals)
         : undefined;
-      onTransactionSuccess?.(formattedActualDstAmount);
+      onTransactionSuccess?.(formattedActualDstAmount ?? "");
     }
   }, [
     oat?.data?.order.status,
@@ -272,10 +304,11 @@ export function useAnyspendFlow({
     // Token state
     selectedSrcChainId,
     setSelectedSrcChainId,
-    selectedDstChainId,
-    setSelectedDstChainId,
+    selectedDstChainId, // Derived, not stateful
     selectedSrcToken,
     setSelectedSrcToken,
+    selectedDstToken,
+    setSelectedDstToken,
     srcAmount,
     setSrcAmount,
     dstAmount,

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

@@ -27,7 +27,7 @@ export function useAnyspendQuote(req: GetQuoteRequest): UseAnyspendQuoteResult {
         req.srcTokenAddress &&
         req.dstTokenAddress &&
         BigInt(
-          req.type === "swap" || req.type === "hype_duel"
+          req.type === "swap" || req.type === "hype_duel" || req.type === "x402_swap" || req.type === "custom_exact_in"
             ? req.amount
             : req.type === "mint_nft"
               ? req.price

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

@@ -0,0 +1,72 @@
+import { useEffect } from "react";
+import { CryptoPaymentMethodType } from "../components/common/CryptoPaymentMethod";
+import { useConnectedWalletDisplay } from "./useConnectedWalletDisplay";
+
+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 function useAutoSelectCryptoPaymentMethod({
+  paymentType = "crypto",
+  selectedCryptoPaymentMethod,
+  setSelectedCryptoPaymentMethod,
+  hasEnoughBalance,
+  isBalanceLoading,
+}: UseAutoSelectCryptoPaymentMethodParams) {
+  // Get suggested payment method based on available wallets
+  const { suggestedPaymentMethod } = useConnectedWalletDisplay(selectedCryptoPaymentMethod);
+
+  useEffect(() => {
+    // Only auto-select when on crypto payment type and payment method is NONE
+    if (paymentType !== "crypto" || selectedCryptoPaymentMethod !== CryptoPaymentMethodType.NONE) {
+      return;
+    }
+
+    // If we have a suggested payment method (wallet is connected), use it
+    if (suggestedPaymentMethod !== CryptoPaymentMethodType.NONE) {
+      // If we have balance info and enough balance, use CONNECT_WALLET
+      // Otherwise, default to TRANSFER_CRYPTO if balance is insufficient
+      if (!isBalanceLoading) {
+        if (hasEnoughBalance && suggestedPaymentMethod === CryptoPaymentMethodType.CONNECT_WALLET) {
+          setSelectedCryptoPaymentMethod(CryptoPaymentMethodType.CONNECT_WALLET);
+        } else if (!hasEnoughBalance && suggestedPaymentMethod === CryptoPaymentMethodType.CONNECT_WALLET) {
+          // Wallet connected but insufficient balance - suggest transfer
+          setSelectedCryptoPaymentMethod(CryptoPaymentMethodType.TRANSFER_CRYPTO);
+        } else {
+          // Use suggested method (e.g., GLOBAL_WALLET)
+          setSelectedCryptoPaymentMethod(suggestedPaymentMethod);
+        }
+      } else {
+        // Balance still loading, use suggested method
+        setSelectedCryptoPaymentMethod(suggestedPaymentMethod);
+      }
+    }
+  }, [
+    paymentType,
+    selectedCryptoPaymentMethod,
+    suggestedPaymentMethod,
+    hasEnoughBalance,
+    isBalanceLoading,
+    setSelectedCryptoPaymentMethod,
+  ]);
+}

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

@@ -0,0 +1,80 @@
+import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
+import { useCallback, useEffect, useRef } from "react";
+import { useSetActiveWallet } from "thirdweb/react";
+import { WalletId, createWallet } from "thirdweb/wallets";
+import { useAccount } from "wagmi";
+
+/**
+ * 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 function useAutoSetActiveWalletFromWagmi() {
+  const { address: wagmiAddress, connector: wagmiConnector } = useAccount();
+  const setActiveWallet = useSetActiveWallet();
+  const prevWagmiAddress = useRef<string | undefined>(undefined);
+
+  // Map wagmi connector names to thirdweb wallet IDs
+  const getThirdwebWalletId = useCallback((connectorName: string): WalletId | null => {
+    const walletMap: Record<string, WalletId> = {
+      MetaMask: "io.metamask",
+      "Coinbase Wallet": "com.coinbase.wallet",
+      Rainbow: "me.rainbow",
+      WalletConnect: "walletConnect",
+      Phantom: "app.phantom",
+    };
+    return walletMap[connectorName] || null;
+  }, []);
+
+  // Create thirdweb wallet from wagmi connector
+  const createThirdwebWalletFromConnector = useCallback(
+    async (connectorName: string) => {
+      const walletId = getThirdwebWalletId(connectorName);
+      if (!walletId) {
+        console.warn(`No thirdweb wallet ID found for connector: ${connectorName}`);
+        return null;
+      }
+
+      try {
+        const thirdwebWallet = createWallet(walletId);
+        await thirdwebWallet.connect({ client });
+        return thirdwebWallet;
+      } catch (error) {
+        console.error(`Failed to create thirdweb wallet for ${connectorName}:`, error);
+        return null;
+      }
+    },
+    [getThirdwebWalletId],
+  );
+
+  // Listen for wagmi wallet connections and automatically set active wallet
+  useEffect(() => {
+    const isNewConnection = wagmiAddress && wagmiAddress !== prevWagmiAddress.current;
+
+    if (isNewConnection && wagmiConnector?.name) {
+      prevWagmiAddress.current = wagmiAddress;
+
+      const setupThirdwebWallet = async () => {
+        try {
+          const thirdwebWallet = await createThirdwebWalletFromConnector(wagmiConnector.name);
+          if (thirdwebWallet) {
+            setActiveWallet(thirdwebWallet);
+            console.log(`Auto-set active wallet for ${wagmiConnector.name}`);
+          }
+        } catch (error) {
+          console.error("Failed to auto-set active wallet:", error);
+        }
+      };
+
+      setupThirdwebWallet();
+    }
+
+    if (!wagmiAddress) {
+      prevWagmiAddress.current = undefined;
+    }
+  }, [wagmiAddress, wagmiConnector?.name, setActiveWallet, createThirdwebWalletFromConnector]);
+}

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,
+  };
+}