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

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

@@ -14,6 +14,8 @@ const chains_1 = require("viem/chains");
 const wagmi_1 = require("wagmi");
 const CryptoPaymentMethod_1 = require("../components/common/CryptoPaymentMethod");
 const FiatPaymentMethod_1 = require("../components/common/FiatPaymentMethod");
+const useAutoSelectCryptoPaymentMethod_1 = require("./useAutoSelectCryptoPaymentMethod");
+const useAutoSetActiveWalletFromWagmi_1 = require("./useAutoSetActiveWalletFromWagmi");
 var PanelView;
 (function (PanelView) {
     PanelView[PanelView["MAIN"] = 0] = "MAIN";
@@ -25,21 +27,25 @@ var PanelView;
     PanelView[PanelView["POINTS_DETAIL"] = 6] = "POINTS_DETAIL";
     PanelView[PanelView["FEE_DETAIL"] = 7] = "FEE_DETAIL";
 })(PanelView || (exports.PanelView = PanelView = {}));
-function useAnyspendFlow({ paymentType = "crypto", recipientAddress, loadOrder, isDepositMode = false, onOrderSuccess, onTransactionSuccess, sourceTokenAddress, sourceTokenChainId, slippage = 0, disableUrlParamManagement = false, }) {
+// This hook serves for order hype_duel and custom_exact_in
+function useAnyspendFlow({ paymentType = "crypto", recipientAddress, loadOrder, isDepositMode = false, onOrderSuccess, onTransactionSuccess, sourceTokenAddress, sourceTokenChainId, destinationTokenAddress, destinationTokenChainId, slippage = 0, disableUrlParamManagement = false, orderType = "hype_duel", }) {
     const searchParams = (0, react_2.useSearchParamsSSR)();
     const router = (0, react_2.useRouter)();
     // Panel and order state
     const [activePanel, setActivePanel] = (0, react_3.useState)(loadOrder ? PanelView.ORDER_DETAILS : PanelView.MAIN);
     const [orderId, setOrderId] = (0, react_3.useState)(loadOrder);
     const { orderAndTransactions: oat } = (0, react_1.useAnyspendOrderAndTransactions)(orderId);
-    // Token selection state - use provided sourceTokenChainId if available
+    // Token selection state - use provided sourceTokenChainId and destinationTokenChainId if available
     const [selectedSrcChainId, setSelectedSrcChainId] = (0, react_3.useState)(sourceTokenChainId || (paymentType === "fiat" ? chains_1.base.id : chains_1.mainnet.id));
-    const [selectedDstChainId, setSelectedDstChainId] = (0, react_3.useState)(chains_1.base.id); // Default to Base for cross-chain swaps
     const defaultSrcToken = paymentType === "fiat" ? anyspend_1.USDC_BASE : (0, anyspend_1.getDefaultToken)(selectedSrcChainId);
+    const defaultDstToken = anyspend_1.B3_TOKEN; // Default destination token
     const [selectedSrcToken, setSelectedSrcToken] = (0, react_3.useState)(defaultSrcToken);
+    const [selectedDstToken, setSelectedDstToken] = (0, react_3.useState)(defaultDstToken);
     const [srcAmount, setSrcAmount] = (0, react_3.useState)(paymentType === "fiat" ? "5" : "0.1");
     const [dstAmount, setDstAmount] = (0, react_3.useState)("");
     const [isSrcInputDirty, setIsSrcInputDirty] = (0, react_3.useState)(true);
+    // Derive destination chain ID from token or prop (cannot change)
+    const selectedDstChainId = destinationTokenChainId || selectedDstToken.chainId;
     // Payment method state
     const [selectedCryptoPaymentMethod, setSelectedCryptoPaymentMethod] = (0, react_3.useState)(CryptoPaymentMethod_1.CryptoPaymentMethodType.NONE);
     const [selectedFiatPaymentMethod, setSelectedFiatPaymentMethod] = (0, react_3.useState)(FiatPaymentMethod_1.FiatPaymentMethod.NONE);
@@ -49,6 +55,8 @@ function useAnyspendFlow({ paymentType = "crypto", recipientAddress, loadOrder,
     const [selectedRecipientAddress, setSelectedRecipientAddress] = (0, react_3.useState)(recipientAddress);
     const recipientProfile = (0, react_2.useProfile)({ address: selectedRecipientAddress, fresh: true });
     const recipientName = recipientProfile.data?.name;
+    // Auto-set active wallet from wagmi
+    (0, useAutoSetActiveWalletFromWagmi_1.useAutoSetActiveWalletFromWagmi)();
     // Set default recipient address when wallet changes
     (0, react_3.useEffect)(() => {
         if (!selectedRecipientAddress && globalAddress) {
@@ -72,17 +80,14 @@ function useAnyspendFlow({ paymentType = "crypto", recipientAddress, loadOrder,
             return false;
         }
     }, [rawBalance, srcAmount, selectedSrcToken.decimals, isBalanceLoading, paymentType]);
-    // Auto-set crypto payment method based on balance
-    (0, react_3.useEffect)(() => {
-        if (paymentType === "crypto" && !isBalanceLoading) {
-            if (hasEnoughBalance) {
-                setSelectedCryptoPaymentMethod(CryptoPaymentMethod_1.CryptoPaymentMethodType.CONNECT_WALLET);
-            }
-            else {
-                setSelectedCryptoPaymentMethod(CryptoPaymentMethod_1.CryptoPaymentMethodType.TRANSFER_CRYPTO);
-            }
-        }
-    }, [paymentType, hasEnoughBalance, isBalanceLoading]);
+    // Auto-select crypto payment method based on available wallets and balance
+    (0, useAutoSelectCryptoPaymentMethod_1.useAutoSelectCryptoPaymentMethod)({
+        paymentType,
+        selectedCryptoPaymentMethod,
+        setSelectedCryptoPaymentMethod,
+        hasEnoughBalance,
+        isBalanceLoading,
+    });
     // Fetch specific token when sourceTokenAddress and sourceTokenChainId are provided
     (0, react_3.useEffect)(() => {
         const fetchSourceToken = async () => {
@@ -100,6 +105,23 @@ function useAnyspendFlow({ paymentType = "crypto", recipientAddress, loadOrder,
         };
         fetchSourceToken();
     }, [sourceTokenAddress, sourceTokenChainId]);
+    // Fetch specific token when destinationTokenAddress and destinationTokenChainId are provided
+    (0, react_3.useEffect)(() => {
+        const fetchDestinationToken = async () => {
+            if (destinationTokenAddress && destinationTokenChainId) {
+                try {
+                    const token = await anyspend_2.anyspendService.getToken(destinationTokenChainId, destinationTokenAddress);
+                    setSelectedDstToken(token);
+                }
+                catch (error) {
+                    console.error("Failed to fetch destination token:", error);
+                    sonner_1.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) => {
         switch (paymentMethod) {
@@ -119,8 +141,8 @@ function useAnyspendFlow({ paymentType = "crypto", recipientAddress, loadOrder,
         srcChain: paymentType === "fiat" ? chains_1.base.id : selectedSrcChainId,
         dstChain: isDepositMode ? chains_1.base.id : selectedDstChainId, // For deposits, always Base; for swaps, use selected destination
         srcTokenAddress: paymentType === "fiat" ? anyspend_1.USDC_BASE.address : selectedSrcToken.address,
-        dstTokenAddress: isDepositMode ? anyspend_1.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,
@@ -216,10 +238,11 @@ function useAnyspendFlow({ paymentType = "crypto", recipientAddress, loadOrder,
         // Token state
         selectedSrcChainId,
         setSelectedSrcChainId,
-        selectedDstChainId,
-        setSelectedDstChainId,
+        selectedDstChainId, // Derived, not stateful
         selectedSrcToken,
         setSelectedSrcToken,
+        selectedDstToken,
+        setSelectedDstToken,
         srcAmount,
         setSrcAmount,
         dstAmount,

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

@@ -53,6 +53,35 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
             relay?: Record<string, never>;
         } | null;
         fee?: Omit<import("../..").components["schemas"]["Fee"], "type"> | null;
+    } & {
+        type: "x402_swap";
+        payload: import("../..").components["schemas"]["X402SwapPayload"];
+        metadata: import("../..").components["schemas"]["X402SwapMetadata"];
+    }) | ({
+        id: string;
+        recipientAddress: string;
+        globalAddress: string;
+        srcChain: number;
+        dstChain: number;
+        srcTokenAddress: string;
+        dstTokenAddress: string;
+        srcAmount: string;
+        status: "scanning_deposit_transaction" | "waiting_stripe_payment" | "expired" | "sending_token_from_vault" | "relay" | "executing" | "executed" | "refunding" | "refunded" | "failure";
+        errorDetails: string | null;
+        createdAt: number;
+        expiredAt: number;
+        filledAt: number | null;
+        receivedDepositAt: number | null;
+        creatorAddress: string | null;
+        partnerId: string | null;
+        onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
+        oneClickBuyUrl: string | null;
+        stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount?: string;
+            relay?: Record<string, never>;
+        } | null;
+        fee?: Omit<import("../..").components["schemas"]["Fee"], "type"> | null;
     } & {
         type: "hype_duel";
         payload: import("../..").components["schemas"]["HypeDuelPayload"];
@@ -111,6 +140,35 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
             relay?: Record<string, never>;
         } | null;
         fee?: Omit<import("../..").components["schemas"]["Fee"], "type"> | null;
+    } & {
+        type: "custom_exact_in";
+        payload: import("../..").components["schemas"]["CustomExactInPayload"];
+        metadata: import("../..").components["schemas"]["CustomMetadata"];
+    }) | ({
+        id: string;
+        recipientAddress: string;
+        globalAddress: string;
+        srcChain: number;
+        dstChain: number;
+        srcTokenAddress: string;
+        dstTokenAddress: string;
+        srcAmount: string;
+        status: "scanning_deposit_transaction" | "waiting_stripe_payment" | "expired" | "sending_token_from_vault" | "relay" | "executing" | "executed" | "refunding" | "refunded" | "failure";
+        errorDetails: string | null;
+        createdAt: number;
+        expiredAt: number;
+        filledAt: number | null;
+        receivedDepositAt: number | null;
+        creatorAddress: string | null;
+        partnerId: string | null;
+        onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
+        oneClickBuyUrl: string | null;
+        stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount?: string;
+            relay?: Record<string, never>;
+        } | null;
+        fee?: Omit<import("../..").components["schemas"]["Fee"], "type"> | null;
     } & {
         type: "mint_nft";
         payload: import("../..").components["schemas"]["MintNftPayload"];
@@ -230,6 +288,35 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
             relay?: Record<string, never>;
         } | null;
         fee?: Omit<import("../..").components["schemas"]["Fee"], "type"> | null;
+    } & {
+        type: "x402_swap";
+        payload: import("../..").components["schemas"]["X402SwapPayload"];
+        metadata: import("../..").components["schemas"]["X402SwapMetadata"];
+    }) | ({
+        id: string;
+        recipientAddress: string;
+        globalAddress: string;
+        srcChain: number;
+        dstChain: number;
+        srcTokenAddress: string;
+        dstTokenAddress: string;
+        srcAmount: string;
+        status: "scanning_deposit_transaction" | "waiting_stripe_payment" | "expired" | "sending_token_from_vault" | "relay" | "executing" | "executed" | "refunding" | "refunded" | "failure";
+        errorDetails: string | null;
+        createdAt: number;
+        expiredAt: number;
+        filledAt: number | null;
+        receivedDepositAt: number | null;
+        creatorAddress: string | null;
+        partnerId: string | null;
+        onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
+        oneClickBuyUrl: string | null;
+        stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount?: string;
+            relay?: Record<string, never>;
+        } | null;
+        fee?: Omit<import("../..").components["schemas"]["Fee"], "type"> | null;
     } & {
         type: "hype_duel";
         payload: import("../..").components["schemas"]["HypeDuelPayload"];
@@ -288,6 +375,35 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
             relay?: Record<string, never>;
         } | null;
         fee?: Omit<import("../..").components["schemas"]["Fee"], "type"> | null;
+    } & {
+        type: "custom_exact_in";
+        payload: import("../..").components["schemas"]["CustomExactInPayload"];
+        metadata: import("../..").components["schemas"]["CustomMetadata"];
+    }) | ({
+        id: string;
+        recipientAddress: string;
+        globalAddress: string;
+        srcChain: number;
+        dstChain: number;
+        srcTokenAddress: string;
+        dstTokenAddress: string;
+        srcAmount: string;
+        status: "scanning_deposit_transaction" | "waiting_stripe_payment" | "expired" | "sending_token_from_vault" | "relay" | "executing" | "executed" | "refunding" | "refunded" | "failure";
+        errorDetails: string | null;
+        createdAt: number;
+        expiredAt: number;
+        filledAt: number | null;
+        receivedDepositAt: number | null;
+        creatorAddress: string | null;
+        partnerId: string | null;
+        onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
+        oneClickBuyUrl: string | null;
+        stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount?: string;
+            relay?: Record<string, never>;
+        } | null;
+        fee?: Omit<import("../..").components["schemas"]["Fee"], "type"> | null;
     } & {
         type: "mint_nft";
         payload: import("../..").components["schemas"]["MintNftPayload"];

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

@@ -14,7 +14,7 @@ function useAnyspendQuote(req) {
             req.dstChain &&
             req.srcTokenAddress &&
             req.dstTokenAddress &&
-            BigInt(req.type === "swap" || req.type === "hype_duel"
+            BigInt(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/dist/cjs/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/cjs/anyspend/react/hooks/useAutoSelectCryptoPaymentMethod.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAutoSelectCryptoPaymentMethod = useAutoSelectCryptoPaymentMethod;
+const react_1 = require("react");
+const CryptoPaymentMethod_1 = require("../components/common/CryptoPaymentMethod");
+const useConnectedWalletDisplay_1 = require("./useConnectedWalletDisplay");
+/**
+ * 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
+ */
+function useAutoSelectCryptoPaymentMethod({ paymentType = "crypto", selectedCryptoPaymentMethod, setSelectedCryptoPaymentMethod, hasEnoughBalance, isBalanceLoading, }) {
+    // Get suggested payment method based on available wallets
+    const { suggestedPaymentMethod } = (0, useConnectedWalletDisplay_1.useConnectedWalletDisplay)(selectedCryptoPaymentMethod);
+    (0, react_1.useEffect)(() => {
+        // Only auto-select when on crypto payment type and payment method is NONE
+        if (paymentType !== "crypto" || selectedCryptoPaymentMethod !== CryptoPaymentMethod_1.CryptoPaymentMethodType.NONE) {
+            return;
+        }
+        // If we have a suggested payment method (wallet is connected), use it
+        if (suggestedPaymentMethod !== CryptoPaymentMethod_1.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 === CryptoPaymentMethod_1.CryptoPaymentMethodType.CONNECT_WALLET) {
+                    setSelectedCryptoPaymentMethod(CryptoPaymentMethod_1.CryptoPaymentMethodType.CONNECT_WALLET);
+                }
+                else if (!hasEnoughBalance && suggestedPaymentMethod === CryptoPaymentMethod_1.CryptoPaymentMethodType.CONNECT_WALLET) {
+                    // Wallet connected but insufficient balance - suggest transfer
+                    setSelectedCryptoPaymentMethod(CryptoPaymentMethod_1.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/dist/cjs/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/cjs/anyspend/react/hooks/useAutoSetActiveWalletFromWagmi.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAutoSetActiveWalletFromWagmi = useAutoSetActiveWalletFromWagmi;
+const thirdweb_1 = require("../../../shared/utils/thirdweb");
+const react_1 = require("react");
+const react_2 = require("thirdweb/react");
+const wallets_1 = require("thirdweb/wallets");
+const wagmi_1 = require("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).
+ */
+function useAutoSetActiveWalletFromWagmi() {
+    const { address: wagmiAddress, connector: wagmiConnector } = (0, wagmi_1.useAccount)();
+    const setActiveWallet = (0, react_2.useSetActiveWallet)();
+    const prevWagmiAddress = (0, react_1.useRef)(undefined);
+    // Map wagmi connector names to thirdweb wallet IDs
+    const getThirdwebWalletId = (0, react_1.useCallback)((connectorName) => {
+        const walletMap = {
+            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 = (0, react_1.useCallback)(async (connectorName) => {
+        const walletId = getThirdwebWalletId(connectorName);
+        if (!walletId) {
+            console.warn(`No thirdweb wallet ID found for connector: ${connectorName}`);
+            return null;
+        }
+        try {
+            const thirdwebWallet = (0, wallets_1.createWallet)(walletId);
+            await thirdwebWallet.connect({ client: thirdweb_1.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
+    (0, react_1.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/dist/cjs/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/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 {};