@b3dotfun/sdk 0.0.1-alpha.1

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAccountAssets = useAccountAssets;
+const simplehash_1 = require("../../../shared/utils/simplehash");
+const react_query_1 = require("@tanstack/react-query");
+async function fetchAccountAssets(address) {
+    if (!address)
+        throw new Error("Address is required");
+    const [nftResponse] = await Promise.all([
+        (0, simplehash_1.fetchSimpleHashData)(`/v0/nfts/owners`, {
+            chains: "b3,b3-sepolia,base",
+            wallet_addresses: address,
+            count: true
+        })
+        // we are not using the tokenResponse anywhere in the app, let's not call it, if we don't need it
+        // getERC20Balances(address, {
+        //   chainIds: [8333, 1993, 8453, 84532],
+        //   includeSpam: false,
+        //   metadata: true,
+        // }),
+    ]);
+    return {
+        nftResponse
+        //tokenResponse,
+    };
+}
+function useAccountAssets(address) {
+    return (0, react_query_1.useQuery)({
+        queryKey: ["accountAssets", address],
+        queryFn: () => fetchAccountAssets(address),
+        enabled: Boolean(address),
+        staleTime: 30 * 1000, // Consider data fresh for 30 seconds
+        gcTime: 5 * 60 * 1000 // Keep unused data in cache for 5 minutes
+    });
+}

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

@@ -0,0 +1,18 @@
+import { Account, Wallet } from "thirdweb/wallets";
+export declare function useAccountWallet(): {
+    wallet: {
+        address?: string;
+        ensName?: string;
+        meta?: {
+            icon: string;
+        };
+    } & Partial<Account>;
+    address?: string;
+    ensName?: string;
+    connectedSmartWallet?: Wallet;
+    connectedEOAWallet?: Wallet;
+    isActiveSmartWallet?: boolean;
+    isActiveEOAWallet?: boolean;
+    eoaWalletIcon?: string;
+    smartWalletIcon?: string;
+};

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAccountWallet = useAccountWallet;
+const global_account_1 = require("../../../global-account");
+const constants_1 = require("../../../shared/constants");
+const react_1 = require("react");
+const react_2 = require("thirdweb/react");
+const in_app_1 = require("thirdweb/wallets/in-app");
+const useBsmntProfile_1 = require("./useBsmntProfile");
+function useLastAuthProvider() {
+    const [lastAuthProvider, setLastAuthProvider] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        const fn = async () => {
+            const provider = await (0, react_2.getLastAuthProvider)();
+            setLastAuthProvider(provider);
+        };
+        fn();
+    }, []);
+    return lastAuthProvider;
+}
+function useAccountWallet() {
+    const { account } = (0, global_account_1.useB3)();
+    const activeWallet = (0, react_2.useActiveWallet)();
+    const connectedWallets = (0, react_2.useConnectedWallets)();
+    const connectedSmartWallet = connectedWallets.find(wallet => wallet.id === constants_1.ecosystemWalletId);
+    const connectedEOAWallet = connectedWallets.find(wallet => wallet.id !== constants_1.ecosystemWalletId);
+    const isActiveSmartWallet = activeWallet?.id === connectedSmartWallet?.id;
+    const isActiveEOAWallet = activeWallet?.id === connectedEOAWallet?.id;
+    const { data: walletImage } = (0, react_2.useWalletImage)(connectedEOAWallet?.id);
+    // If not EOA sign in, then we need to show the smart wallet icon
+    const lastAuthProvider = useLastAuthProvider();
+    const smartWalletIcon = lastAuthProvider && !connectedEOAWallet
+        ? in_app_1.socialIcons[lastAuthProvider]
+        : "https://gradvatar.com/0x0000000000000000000000000000000000000000"; // show smart wallet of eoa wallet is gradvatar
+    const { data: profileData } = (0, useBsmntProfile_1.useBsmntProfile)({ address: account?.address });
+    const ensName = profileData?.username?.replaceAll(".b3.fun", "");
+    const avatarUrl = profileData?.avatar;
+    const res = (0, react_1.useMemo)(() => ({
+        wallet: {
+            ...account,
+            ensName,
+            meta: {
+                icon: avatarUrl || (isActiveSmartWallet ? smartWalletIcon : walletImage) || ""
+            }
+        },
+        address: account?.address,
+        ensName,
+        connectedSmartWallet: connectedSmartWallet,
+        connectedEOAWallet: connectedEOAWallet,
+        isActiveSmartWallet: isActiveSmartWallet,
+        isActiveEOAWallet: isActiveEOAWallet,
+        smartWalletIcon: smartWalletIcon,
+        eoaWalletIcon: walletImage
+    }), [
+        account,
+        avatarUrl,
+        connectedEOAWallet,
+        connectedSmartWallet,
+        ensName,
+        isActiveEOAWallet,
+        isActiveSmartWallet,
+        smartWalletIcon,
+        walletImage
+    ]);
+    // useEffect(() => {
+    //   console.log(`account`, account);
+    //   console.log(`useAccountWallet`, res);
+    // }, [account, res]);
+    return res;
+}

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

@@ -0,0 +1,21 @@
+import { Chain, Hex, ThirdwebClient } from "thirdweb";
+import { Address } from "viem";
+export declare function useAddTWSessionKey({ onSuccess, onError, refetchSigners, chain }: {
+    chain?: Chain;
+    onSuccess: (transactionResult: {
+        transactionHash: Hex;
+    } & {
+        client: ThirdwebClient;
+        chain: Chain;
+    }) => void;
+    onError: (error: Error) => void;
+    refetchSigners: () => Promise<any>;
+}): {
+    newSessionKey: ({ sessionKeyAddress, approvedTargets, nativeTokenLimitPerTransaction, permissionStartTimestamp, permissionEndTimestamp }: {
+        sessionKeyAddress: Address;
+        approvedTargets: Address[];
+        nativeTokenLimitPerTransaction: number;
+        permissionStartTimestamp: Date;
+        permissionEndTimestamp: Date;
+    }) => Promise<void>;
+};

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

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAddTWSessionKey = useAddTWSessionKey;
+const thirdweb_1 = require("../../../shared/utils/thirdweb");
+const debug_1 = __importDefault(require("debug"));
+const thirdweb_2 = require("thirdweb");
+const erc4337_1 = require("thirdweb/extensions/erc4337");
+const react_1 = require("thirdweb/react");
+const debug = (0, debug_1.default)("@@b3:useHandleTWConnect");
+function useAddTWSessionKey({ onSuccess, onError, refetchSigners, chain }) {
+    if (!chain) {
+        throw new Error("Chain is required");
+    }
+    const account = (0, react_1.useActiveAccount)();
+    const newSessionKey = async ({ sessionKeyAddress, approvedTargets, nativeTokenLimitPerTransaction, permissionStartTimestamp, permissionEndTimestamp }) => {
+        if (!account || !chain)
+            return;
+        debug("@@newSessionKey:", {
+            sessionKeyAddress,
+            approvedTargets,
+            nativeTokenLimitPerTransaction,
+            permissionStartTimestamp,
+            permissionEndTimestamp
+        });
+        try {
+            const transaction = (0, erc4337_1.addSessionKey)({
+                contract: {
+                    client: thirdweb_1.client,
+                    chain,
+                    address: account.address
+                },
+                account,
+                sessionKeyAddress,
+                permissions: {
+                    approvedTargets,
+                    nativeTokenLimitPerTransaction,
+                    permissionStartTimestamp,
+                    permissionEndTimestamp
+                }
+            });
+            debug("@@ecosystem:newSessionKey:transaction:", transaction);
+            const transactionResult = await (0, thirdweb_2.sendTransaction)({ transaction, account });
+            debug("@@ecosystem:newSessionKey:transactionResult:", transactionResult);
+            onSuccess(transactionResult);
+            await refetchSigners();
+        }
+        catch (error) {
+            onError(error);
+            console.error("@@ecosystem:newSessionKey:error:", error);
+        }
+    };
+    return { newSessionKey };
+}

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

@@ -0,0 +1,10 @@
+import { preAuthenticate } from "thirdweb/wallets/in-app";
+export default function useAuthentication(partnerId: string, loginWithSiwe?: boolean): {
+    logout: (callback?: () => void) => Promise<void>;
+    isAuthenticating: boolean;
+    isAuthenticated: boolean;
+    isReady: boolean;
+    wallet: import("thirdweb/wallets").Wallet<`ecosystem.${string}`>;
+    preAuthenticate: typeof preAuthenticate;
+    connect: (strategyOptions?: import("thirdweb/wallets").SingleStepAuthArgsType) => Promise<import("thirdweb/wallets").Wallet | null>;
+};

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

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = useAuthentication;
+const app_1 = __importDefault(require("../../../global-account/app"));
+const B3Provider_1 = require("../../../global-account/react/components/B3Provider");
+const useAuthStore_1 = require("../../../global-account/react/stores/useAuthStore");
+const constants_1 = require("../../../shared/constants");
+const supported_1 = require("../../../shared/constants/chains/supported");
+const debug_1 = require("../../../shared/utils/debug");
+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 in_app_1 = require("thirdweb/wallets/in-app");
+const useConnect_1 = require("./useConnect");
+const useSiwe_1 = require("./useSiwe");
+const debug = (0, debug_1.debugB3React)("useAuthentication");
+function useAuthentication(partnerId, loginWithSiwe) {
+    const { disconnect } = (0, react_2.useDisconnect)();
+    const wallets = (0, react_2.useConnectedWallets)();
+    const activeWallet = (0, react_2.useActiveWallet)();
+    const { authenticate } = (0, useSiwe_1.useSiwe)();
+    const { setUser } = (0, B3Provider_1.useB3)();
+    const isAuthenticating = (0, useAuthStore_1.useAuthStore)(state => state.isAuthenticating);
+    const isAuthenticated = (0, useAuthStore_1.useAuthStore)(state => state.isAuthenticated);
+    const setIsAuthenticated = (0, useAuthStore_1.useAuthStore)(state => state.setIsAuthenticated);
+    const setIsAuthenticating = (0, useAuthStore_1.useAuthStore)(state => state.setIsAuthenticating);
+    const { connect } = (0, useConnect_1.useConnect)(partnerId, supported_1.b3MainnetThirdWeb);
+    const wallet = (0, wallets_1.ecosystemWallet)(constants_1.ecosystemWalletId, {
+        partnerId: partnerId
+    });
+    const { isLoading: useAutoConnectLoading } = (0, react_2.useAutoConnect)({
+        client: thirdweb_1.client,
+        wallets: [wallet],
+        onConnect: async (wallet) => {
+            try {
+                if (!loginWithSiwe) {
+                    debug("Skipping SIWE login", { loginWithSiwe });
+                    return;
+                }
+                setIsAuthenticating(true);
+                const account = await wallet.getAccount();
+                if (!account) {
+                    throw new Error("No account found during auto-connect");
+                }
+                // Try to re-authenticate first
+                try {
+                    const userAuth = await app_1.default.reAuthenticate();
+                    setUser(userAuth.user);
+                    setIsAuthenticated(true);
+                    debug("Re-authenticated successfully", { userAuth });
+                }
+                catch (error) {
+                    // If re-authentication fails, try fresh authentication
+                    debug("Re-authentication failed, attempting fresh authentication");
+                    const userAuth = await authenticate(account);
+                    setUser(userAuth.user);
+                    setIsAuthenticated(true);
+                    debug("Fresh authentication successful", { userAuth });
+                }
+            }
+            catch (error) {
+                debug("Auto-connect authentication failed", { error });
+                setIsAuthenticated(false);
+                setUser();
+            }
+        }
+    });
+    // Ensure isAuthenticating stays true until we're fully ready
+    (0, react_1.useEffect)(() => {
+        if (useAutoConnectLoading) {
+            setIsAuthenticating(true);
+        }
+        else if (!isAuthenticated) {
+            // Only set isAuthenticating to false if we're not authenticated
+            // This prevents the flicker state where both isAuthenticating and isAuthenticated are false
+            const timeout = setTimeout(() => {
+                setIsAuthenticating(false);
+            }, 100); // Add a small delay to prevent quick flickers
+            return () => clearTimeout(timeout);
+        }
+        else {
+            setIsAuthenticating(false);
+        }
+    }, [useAutoConnectLoading, isAuthenticated, setIsAuthenticating]);
+    const logout = async (callback) => {
+        if (activeWallet) {
+            debug("@@logout:activeWallet", activeWallet);
+            disconnect(activeWallet);
+            debug("@@logout:disconnected");
+            console.log("@@gio:logout:activeWallet", activeWallet);
+        }
+        // Log out of each wallet
+        wallets.forEach(wallet => {
+            console.log("@@logging out", wallet);
+            disconnect(wallet);
+        });
+        // Delete localStorage thirdweb:connected-wallet-ids
+        // https://npc-labs.slack.com/archives/C070E6HNG85/p1750185115273099
+        if (typeof localStorage !== "undefined") {
+            localStorage.removeItem("thirdweb:connected-wallet-ids");
+            localStorage.removeItem("wagmi.store");
+        }
+        app_1.default.logout();
+        debug("@@logout:loggedOut");
+        setIsAuthenticated(false);
+        setUser();
+        callback?.();
+    };
+    const isReady = isAuthenticated && !useAutoConnectLoading && !isAuthenticating;
+    return {
+        logout,
+        isAuthenticating: useAutoConnectLoading || isAuthenticating,
+        isAuthenticated,
+        isReady,
+        wallet,
+        preAuthenticate: in_app_1.preAuthenticate,
+        connect
+    };
+}

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

@@ -0,0 +1,15 @@
+export declare function useB3BalanceFromAddresses(addresses?: string[] | string | {
+    address: string;
+} | null, options?: {
+    enabled?: boolean;
+    refetchInterval?: number;
+}): import("@tanstack/react-query").UseQueryResult<{
+    totalBalance: bigint;
+    formattedTotal: string;
+    breakdown: {
+        address: string;
+        balance: bigint;
+        formatted: string;
+    }[];
+}, Error>;
+export default useB3BalanceFromAddresses;

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useB3BalanceFromAddresses = useB3BalanceFromAddresses;
+const anyspend_1 = require("../../../anyspend");
+const formatNumber_1 = require("../../../shared/utils/formatNumber");
+const react_query_1 = require("@tanstack/react-query");
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+// ABI for just balanceOf
+const abi = [
+    {
+        inputs: [{ name: "account", type: "address" }],
+        name: "balanceOf",
+        outputs: [{ name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function"
+    }
+];
+// Create a public client for Base
+const client = (0, viem_1.createPublicClient)({
+    chain: chains_1.base,
+    transport: (0, viem_1.http)()
+});
+async function fetchB3Balances(addresses) {
+    try {
+        // Fetch all balances in parallel
+        const balances = await Promise.all(addresses.map(async (address) => {
+            const balance = await client.readContract({
+                address: anyspend_1.B3_TOKEN.address,
+                abi,
+                functionName: "balanceOf",
+                args: [address]
+            });
+            return {
+                address,
+                balance,
+                formatted: (0, viem_1.formatUnits)(balance, anyspend_1.B3_TOKEN.decimals)
+            };
+        }));
+        // Calculate total
+        const totalBalance = balances.reduce((sum, { balance }) => sum + balance, BigInt(0));
+        return {
+            totalBalance,
+            formattedTotal: (0, formatNumber_1.formatNumber)(Number((0, viem_1.formatUnits)(totalBalance, anyspend_1.B3_TOKEN.decimals))),
+            breakdown: balances
+        };
+    }
+    catch (error) {
+        console.error("Error fetching B3 balances:", error);
+        throw new Error("Failed to fetch B3 balances");
+    }
+}
+function useB3BalanceFromAddresses(addresses, options) {
+    // Normalize addresses to array
+    const normalizedAddresses = Array.isArray(addresses)
+        ? addresses
+        : typeof addresses === "string"
+            ? [addresses]
+            : addresses?.address
+                ? [addresses.address]
+                : [];
+    return (0, react_query_1.useQuery)({
+        queryKey: ["b3Balance", normalizedAddresses.sort()],
+        queryFn: () => fetchB3Balances(normalizedAddresses),
+        enabled: (options?.enabled ?? true) && normalizedAddresses.length > 0,
+        refetchInterval: options?.refetchInterval ?? 30000, // Default 30s refresh
+        staleTime: 10000 // Consider data stale after 10s
+    });
+}
+exports.default = useB3BalanceFromAddresses;

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

@@ -0,0 +1,41 @@
+import { Token } from "../../../anyspend";
+export type TransactionType = "send" | "swap" | "bridge";
+export interface SprinterOption {
+    chainId: number;
+    balance: bigint;
+    formattedBalance: string;
+}
+export interface TransactionPath {
+    type: "native" | "sprinter" | "anyspend";
+    hasNativePath: boolean;
+    hasSprinterPath: boolean;
+    availableBalance: bigint;
+    totalCrossChainBalance: number;
+    sprinterOptions?: SprinterOption[];
+}
+export interface TransactionPathResult extends TransactionPath {
+    loading: boolean;
+}
+interface UseBestTransactionPathProps {
+    amount: bigint;
+    token: Token;
+    address?: string;
+    transactionType?: TransactionType;
+}
+/**
+ * Hook to determine the optimal transaction path based on user's balances across chains
+ *
+ * @param props.amount - Amount to transact
+ * @param props.token - Token (a Token object)
+ * @param props.address - Target address (optional, defaults to self)
+ * @param props.transactionType - Type of transaction (optional, defaults to 'send')
+ *
+ * - type: The recommended path type ('native', 'sprinter', or 'anyspend')
+ * - hasNativePath: Whether direct native token transfer is possible (1st best path)
+ * - hasSprinterPath: Whether bridging via Sprinter is possible (2nd best path)
+ * - availableBalance: The user's balance of this asset
+ * - sprinterOptions: Available chains and balances for bridging
+ * @returns TransactionPathResult object containing path information and loading state
+ */
+export declare function useBestTransactionPath({ amount, token, address, transactionType: _transactionType }: UseBestTransactionPathProps): TransactionPathResult;
+export {};

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

@@ -0,0 +1,150 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBestTransactionPath = useBestTransactionPath;
+const anyspend_1 = require("../../../anyspend");
+const useAccountWallet_1 = require("../../../global-account/react/hooks/useAccountWallet");
+const useOneBalance_1 = require("../../../global-account/react/hooks/useOneBalance");
+const useTokenBalance_1 = require("../../../global-account/react/hooks/useTokenBalance");
+const react_1 = require("react");
+const viem_1 = require("viem");
+const supportedSprinterTokenSymbols = ["ETH", "USDC", "WETH"];
+/**
+ * Hook to determine the optimal transaction path based on user's balances across chains
+ *
+ * @param props.amount - Amount to transact
+ * @param props.token - Token (a Token object)
+ * @param props.address - Target address (optional, defaults to self)
+ * @param props.transactionType - Type of transaction (optional, defaults to 'send')
+ *
+ * - type: The recommended path type ('native', 'sprinter', or 'anyspend')
+ * - hasNativePath: Whether direct native token transfer is possible (1st best path)
+ * - hasSprinterPath: Whether bridging via Sprinter is possible (2nd best path)
+ * - availableBalance: The user's balance of this asset
+ * - sprinterOptions: Available chains and balances for bridging
+ * @returns TransactionPathResult object containing path information and loading state
+ */
+function useBestTransactionPath({ amount, token, address, transactionType: _transactionType = "send" }) {
+    const account = (0, useAccountWallet_1.useAccountWallet)();
+    const effectiveAddress = address || account?.address;
+    const isSupportedSprinterToken = supportedSprinterTokenSymbols.includes(token.symbol.toUpperCase());
+    // Get balances across all chains
+    const { aggregatedBalances, aggregatedTokenBalances, loading: oneBalanceLoading } = (0, useOneBalance_1.useOneBalance)();
+    // Get the token balance using our new hook
+    const { rawBalance, isLoading: tokenBalanceLoading } = (0, useTokenBalance_1.useTokenBalance)({
+        token,
+        address: effectiveAddress
+    });
+    // Check if amount is available natively on destination chain
+    const hasNativeBalance = (0, react_1.useMemo)(() => {
+        if (!rawBalance || !amount)
+            return false;
+        return rawBalance >= amount;
+    }, [amount, rawBalance]);
+    // Calculate non-native token balance using the same logic as hasNativeBalance
+    const nonNativeTokenBalance = (0, react_1.useMemo)(() => {
+        if ((0, anyspend_1.isNativeToken)(token.address))
+            return 0n;
+        // For sprinter supported tokens, use aggregated balances
+        if (isSupportedSprinterToken && !oneBalanceLoading && aggregatedBalances) {
+            const asset = aggregatedBalances.find(asset => asset.symbol === token.symbol);
+            if (asset) {
+                const chainBalance = asset.chainBalances.find(cb => cb.chainId === token.chainId);
+                if (chainBalance) {
+                    return BigInt(chainBalance.balance);
+                }
+            }
+            return 0n;
+        }
+        // For non-sprinter tokens, use token balance from our new hook
+        return rawBalance;
+    }, [
+        token.address,
+        token.symbol,
+        token.chainId,
+        isSupportedSprinterToken,
+        oneBalanceLoading,
+        aggregatedBalances,
+        rawBalance
+    ]);
+    const totalCrossChainBalance = (0, react_1.useMemo)(() => {
+        if (oneBalanceLoading || !aggregatedTokenBalances || !token.symbol)
+            return 0;
+        return aggregatedTokenBalances[token.symbol] || 0;
+    }, [aggregatedTokenBalances, token.symbol, oneBalanceLoading]);
+    // Calculate available sprinter options and determine if sprinter path is available
+    const { hasSprinterPath, sprinterOptions } = (0, react_1.useMemo)(() => {
+        if (!isSupportedSprinterToken || oneBalanceLoading || !aggregatedBalances || !token.symbol || !amount) {
+            return { hasSprinterPath: false, sprinterOptions: [] };
+        }
+        const asset = aggregatedBalances.find(asset => asset.symbol === token.symbol);
+        if (!asset) {
+            return { hasSprinterPath: false, sprinterOptions: [] };
+        }
+        const options = [];
+        // Get all chains where user has sufficient balance
+        for (const chainBalance of asset.chainBalances) {
+            const balanceBi = BigInt(chainBalance.balance);
+            if (balanceBi >= amount && chainBalance.chainId !== token.chainId) {
+                options.push({
+                    chainId: chainBalance.chainId,
+                    balance: balanceBi,
+                    formattedBalance: (0, viem_1.formatUnits)(balanceBi, chainBalance.tokenDecimals)
+                });
+            }
+        }
+        return {
+            hasSprinterPath: options.length > 0,
+            sprinterOptions: options
+        };
+    }, [isSupportedSprinterToken, oneBalanceLoading, aggregatedBalances, token.symbol, token.chainId, amount]);
+    // Determine the best path
+    const path = (0, react_1.useMemo)(() => {
+        const availableBalance = ((0, anyspend_1.isNativeToken)(token.address) ? rawBalance : nonNativeTokenBalance) || 0n;
+        // Case 1: Native path if available
+        if (hasNativeBalance) {
+            return {
+                type: "native",
+                hasNativePath: true,
+                hasSprinterPath,
+                availableBalance,
+                totalCrossChainBalance,
+                sprinterOptions
+            };
+        }
+        // Case 2: Sprinter path if available
+        if (hasSprinterPath) {
+            return {
+                type: "sprinter",
+                hasNativePath: false,
+                hasSprinterPath: true,
+                availableBalance,
+                totalCrossChainBalance,
+                sprinterOptions
+            };
+        }
+        // Case 3: Fallback to anyspend
+        return {
+            type: "anyspend",
+            hasNativePath: false,
+            hasSprinterPath: false,
+            availableBalance,
+            totalCrossChainBalance,
+            sprinterOptions: []
+        };
+    }, [
+        token.address,
+        rawBalance,
+        nonNativeTokenBalance,
+        hasNativeBalance,
+        hasSprinterPath,
+        totalCrossChainBalance,
+        sprinterOptions
+    ]);
+    // Combine all loading states
+    const loading = oneBalanceLoading || tokenBalanceLoading;
+    return {
+        ...path,
+        loading
+    };
+}

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

@@ -0,0 +1,4 @@
+export interface UseProfileOptions {
+    address?: string;
+}
+export declare const useBsmntProfile: ({ address }: UseProfileOptions) => import("@tanstack/react-query").UseQueryResult<any, Error>;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBsmntProfile = void 0;
+const fetchBsmntProfile_1 = require("../../../shared/utils/fetchBsmntProfile");
+const react_query_1 = require("@tanstack/react-query");
+const useBsmntProfile = ({ address }) => {
+    return (0, react_query_1.useQuery)({
+        queryKey: ["useBsmntProfile", address],
+        queryFn: () => (0, fetchBsmntProfile_1.fetchBsmntProfile)(undefined, address),
+        enabled: !!address
+    });
+};
+exports.useBsmntProfile = useBsmntProfile;

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

@@ -0,0 +1,5 @@
+import { WalletClient } from "viem";
+export declare function useChainSwitchWithAction(): {
+    switchChainAndExecute: (targetChainId: number, action: (client: WalletClient) => Promise<void>) => Promise<void>;
+    isSwitchingOrExecuting: boolean;
+};