@b3dotfun/sdk 0.0.1-alpha.1

package/src/global-account/react/hooks/useAuthentication.ts

@@ -0,0 +1,127 @@
+import app from "@b3dotfun/sdk/global-account/app";
+import { useB3 } from "@b3dotfun/sdk/global-account/react/components/B3Provider";
+import { useAuthStore } from "@b3dotfun/sdk/global-account/react/stores/useAuthStore";
+import { ecosystemWalletId } from "@b3dotfun/sdk/shared/constants";
+import { b3MainnetThirdWeb } from "@b3dotfun/sdk/shared/constants/chains/supported";
+import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
+import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
+import { useEffect } from "react";
+import { useActiveWallet, useAutoConnect, useConnectedWallets, useDisconnect } from "thirdweb/react";
+import { ecosystemWallet } from "thirdweb/wallets";
+import { preAuthenticate } from "thirdweb/wallets/in-app";
+import { useConnect } from "./useConnect";
+import { useSiwe } from "./useSiwe";
+
+const debug = debugB3React("useAuthentication");
+
+export default function useAuthentication(partnerId: string, loginWithSiwe?: boolean) {
+  const { disconnect } = useDisconnect();
+  const wallets = useConnectedWallets();
+  const activeWallet = useActiveWallet();
+  const { authenticate } = useSiwe();
+  const { setUser } = useB3();
+  const isAuthenticating = useAuthStore(state => state.isAuthenticating);
+  const isAuthenticated = useAuthStore(state => state.isAuthenticated);
+  const setIsAuthenticated = useAuthStore(state => state.setIsAuthenticated);
+  const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
+  const { connect } = useConnect(partnerId, b3MainnetThirdWeb);
+
+  const wallet = ecosystemWallet(ecosystemWalletId, {
+    partnerId: partnerId
+  });
+
+  const { isLoading: useAutoConnectLoading } = useAutoConnect({
+    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.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
+  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?: () => void) => {
+    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.logout();
+    debug("@@logout:loggedOut");
+
+    setIsAuthenticated(false);
+    setUser();
+    callback?.();
+  };
+
+  const isReady = isAuthenticated && !useAutoConnectLoading && !isAuthenticating;
+
+  return {
+    logout,
+    isAuthenticating: useAutoConnectLoading || isAuthenticating,
+    isAuthenticated,
+    isReady,
+    wallet,
+    preAuthenticate,
+    connect
+  };
+}

package/src/global-account/react/hooks/useB3BalanceFromAddresses.ts

@@ -0,0 +1,91 @@
+import { B3_TOKEN } from "@b3dotfun/sdk/anyspend";
+import { formatNumber } from "@b3dotfun/sdk/shared/utils/formatNumber";
+import { useQuery } from "@tanstack/react-query";
+import { createPublicClient, formatUnits, http } from "viem";
+import { base } from "viem/chains";
+
+// ABI for just balanceOf
+const abi = [
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+] as const;
+
+// Create a public client for Base
+const client = createPublicClient({
+  chain: base,
+  transport: http()
+});
+
+async function fetchB3Balances(addresses: string[]): Promise<{
+  totalBalance: bigint;
+  formattedTotal: string;
+  breakdown: {
+    address: string;
+    balance: bigint;
+    formatted: string;
+  }[];
+}> {
+  try {
+    // Fetch all balances in parallel
+    const balances = await Promise.all(
+      addresses.map(async address => {
+        const balance = await client.readContract({
+          address: B3_TOKEN.address,
+          abi,
+          functionName: "balanceOf",
+          args: [address as `0x${string}`]
+        });
+
+        return {
+          address,
+          balance,
+          formatted: formatUnits(balance, B3_TOKEN.decimals)
+        };
+      })
+    );
+
+    // Calculate total
+    const totalBalance = balances.reduce((sum, { balance }) => sum + balance, BigInt(0));
+
+    return {
+      totalBalance,
+      formattedTotal: formatNumber(Number(formatUnits(totalBalance, B3_TOKEN.decimals))),
+      breakdown: balances
+    };
+  } catch (error) {
+    console.error("Error fetching B3 balances:", error);
+    throw new Error("Failed to fetch B3 balances");
+  }
+}
+
+export function useB3BalanceFromAddresses(
+  addresses?: string[] | string | { address: string } | null,
+  options?: {
+    enabled?: boolean;
+    refetchInterval?: number;
+  }
+) {
+  // Normalize addresses to array
+  const normalizedAddresses = Array.isArray(addresses)
+    ? addresses
+    : typeof addresses === "string"
+      ? [addresses]
+      : addresses?.address
+        ? [addresses.address]
+        : [];
+
+  return 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
+  });
+}
+
+export default useB3BalanceFromAddresses;

package/src/global-account/react/hooks/useBestTransactionPath.tsx

@@ -0,0 +1,202 @@
+"use client";
+
+import { isNativeToken, Token } from "@b3dotfun/sdk/anyspend";
+import { useAccountWallet } from "@b3dotfun/sdk/global-account/react/hooks/useAccountWallet";
+import { useOneBalance } from "@b3dotfun/sdk/global-account/react/hooks/useOneBalance";
+import { useTokenBalance } from "@b3dotfun/sdk/global-account/react/hooks/useTokenBalance";
+import { useMemo } from "react";
+import { formatUnits } from "viem";
+
+export type TransactionType = "send" | "swap" | "bridge";
+
+const supportedSprinterTokenSymbols = ["ETH", "USDC", "WETH"] as const;
+
+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 function useBestTransactionPath({
+  amount,
+  token,
+  address,
+  transactionType: _transactionType = "send"
+}: UseBestTransactionPathProps): TransactionPathResult {
+  const account = useAccountWallet();
+  const effectiveAddress = address || account?.address;
+
+  const isSupportedSprinterToken = supportedSprinterTokenSymbols.includes(
+    token.symbol.toUpperCase() as (typeof supportedSprinterTokenSymbols)[number]
+  );
+
+  // Get balances across all chains
+  const { aggregatedBalances, aggregatedTokenBalances, loading: oneBalanceLoading } = useOneBalance();
+
+  // Get the token balance using our new hook
+  const { rawBalance, isLoading: tokenBalanceLoading } = useTokenBalance({
+    token,
+    address: effectiveAddress
+  });
+
+  // Check if amount is available natively on destination chain
+  const hasNativeBalance = useMemo(() => {
+    if (!rawBalance || !amount) return false;
+
+    return rawBalance >= amount;
+  }, [amount, rawBalance]);
+
+  // Calculate non-native token balance using the same logic as hasNativeBalance
+  const nonNativeTokenBalance = useMemo(() => {
+    if (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 = 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 } = 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: SprinterOption[] = [];
+
+    // 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: 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 = useMemo(() => {
+    const availableBalance = (isNativeToken(token.address) ? rawBalance : nonNativeTokenBalance) || 0n;
+
+    // Case 1: Native path if available
+    if (hasNativeBalance) {
+      return {
+        type: "native" as const,
+        hasNativePath: true,
+        hasSprinterPath,
+        availableBalance,
+        totalCrossChainBalance,
+        sprinterOptions
+      };
+    }
+
+    // Case 2: Sprinter path if available
+    if (hasSprinterPath) {
+      return {
+        type: "sprinter" as const,
+        hasNativePath: false,
+        hasSprinterPath: true,
+        availableBalance,
+        totalCrossChainBalance,
+        sprinterOptions
+      };
+    }
+
+    // Case 3: Fallback to anyspend
+    return {
+      type: "anyspend" as const,
+      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/src/global-account/react/hooks/useBsmntProfile.ts

@@ -0,0 +1,14 @@
+import { fetchBsmntProfile } from "@b3dotfun/sdk/shared/utils/fetchBsmntProfile";
+import { useQuery } from "@tanstack/react-query";
+
+export interface UseProfileOptions {
+  address?: string;
+}
+
+export const useBsmntProfile = ({ address }: UseProfileOptions) => {
+  return useQuery({
+    queryKey: ["useBsmntProfile", address],
+    queryFn: () => fetchBsmntProfile(undefined, address),
+    enabled: !!address
+  });
+};

package/src/global-account/react/hooks/useChainSwitchWithAction.ts

@@ -0,0 +1,79 @@
+import { getChainName, getNativeToken } from "@b3dotfun/sdk/anyspend";
+import { supportedChains } from "@b3dotfun/sdk/shared/constants/chains/supported";
+import { invariant } from "framer-motion";
+import { useCallback, useState } from "react";
+import { toast } from "sonner";
+import { WalletClient } from "viem";
+import { useSwitchChain, useWalletClient } from "wagmi";
+
+export function useChainSwitchWithAction() {
+  const { data: walletClient } = useWalletClient();
+  const { switchChainAsync } = useSwitchChain();
+  const [isSwitchingOrExecuting, setIsSwitchingOrExecuting] = useState(false);
+
+  const run = useCallback(async (fn: () => Promise<void>) => {
+    try {
+      setIsSwitchingOrExecuting(true);
+      await fn();
+    } catch (err: any) {
+      console.error(err);
+      toast.error(err?.message ?? "Unexpected error");
+    } finally {
+      setIsSwitchingOrExecuting(false);
+    }
+  }, []);
+
+  const switchChainAndExecute = useCallback(
+    async (targetChainId: number, action: (client: WalletClient) => Promise<void>) => {
+      if (!walletClient) {
+        toast.error("Please connect your wallet");
+        return;
+      }
+
+      const providerId = walletClient.chain.id;
+      const onCorrectChain = providerId === targetChainId;
+
+      if (onCorrectChain) {
+        return run(() => action(walletClient));
+      }
+
+      toast.info(`Switching to ${getChainName(targetChainId)}…`);
+
+      const targetChain = supportedChains.find(chain => chain.id === targetChainId);
+      if (!targetChain) {
+        toast.error(`Chain ${targetChainId} is not supported`);
+        return;
+      }
+
+      try {
+        invariant(!!targetChain.blockExplorers?.default.url, "Block explorer URL is required");
+        const nativeCurrency = getNativeToken(targetChainId);
+        await switchChainAsync({
+          chainId: targetChainId,
+          addEthereumChainParameter: {
+            chainName: targetChain.name,
+            rpcUrls: [targetChain.rpcUrls.default.http[0]],
+            blockExplorerUrls: [targetChain.blockExplorers?.default.url!],
+            nativeCurrency: {
+              name: nativeCurrency.name,
+              symbol: nativeCurrency.symbol,
+              decimals: nativeCurrency.decimals
+            }
+          }
+        });
+        await run(() => action(walletClient));
+      } catch (e: any) {
+        if (e?.code === -32603 || e?.message?.includes("f is not a function")) {
+          // This is a workaround for a bug in the wallet provider.
+          toast(`Switched to ${getChainName(targetChainId)}. Executing…`);
+          await switchChainAndExecute(targetChainId, action);
+        } else {
+          toast.error(e?.message ?? "Unexpected error");
+        }
+      }
+    },
+    [walletClient, run, switchChainAsync]
+  );
+
+  return { switchChainAndExecute, isSwitchingOrExecuting };
+}

package/src/global-account/react/hooks/useClaim.tsx

@@ -0,0 +1,66 @@
+import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
+import { useCallback, useState } from "react";
+import { Chain, getContract, sendTransaction } from "thirdweb";
+import { claimTo as claimTo1155 } from "thirdweb/extensions/erc1155";
+import { claimTo as claimTo721 } from "thirdweb/extensions/erc721";
+import { Account } from "thirdweb/wallets";
+
+interface UseClaimProps {
+  contractAddress: string;
+  quantity?: number;
+  chain: Chain;
+  to: string;
+  tokenId?: number; // Optional - if provided, use ERC1155 claim
+}
+
+export function useClaim({ contractAddress, quantity = 1, chain, to, tokenId }: UseClaimProps) {
+  const [isMinting, setIsMinting] = useState(false);
+
+  const claim = useCallback(
+    async (account: Account) => {
+      if (!to) {
+        throw new Error("No recipient address provided");
+      }
+
+      setIsMinting(true);
+      try {
+        const contract = getContract({
+          client,
+          chain,
+          address: contractAddress
+        });
+
+        // If tokenId is provided, use ERC1155 claim
+        const transaction =
+          tokenId !== undefined
+            ? claimTo1155({
+                contract,
+                to,
+                quantity: BigInt(quantity),
+                tokenId: BigInt(tokenId)
+              })
+            : claimTo721({
+                contract,
+                to,
+                quantity: BigInt(quantity)
+              });
+
+        const tx = await sendTransaction({
+          transaction,
+          account
+        });
+
+        return tx.transactionHash;
+      } finally {
+        setIsMinting(false);
+      }
+    },
+    [contractAddress, quantity, chain, to, tokenId]
+  );
+
+  return { claim, isMinting };
+}
+
+// Export both for backward compatibility
+export const useClaim721 = useClaim;
+export const useClaim1155 = useClaim;

package/src/global-account/react/hooks/useConnect.tsx

@@ -0,0 +1,60 @@
+import { ecosystemWalletId, THIRDWEB_CLIENT_ID } from "@b3dotfun/sdk/shared/constants";
+import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
+import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
+import { useCallback, useState } from "react";
+import { Chain } from "thirdweb";
+import { useConnect as useConnectTW } from "thirdweb/react";
+import { ecosystemWallet, SingleStepAuthArgsType } from "thirdweb/wallets";
+const debug = debugB3React("useConnect");
+
+/**
+ * This hook is used to connect to a wallet using the thirdweb client.
+ */
+export function useConnect(partnerId: string, chain?: Chain) {
+  if (!chain) {
+    throw new Error("Chain is required");
+  }
+
+  const { connect } = useConnectTW();
+  const [isLoading, setIsLoading] = useState(false);
+
+  /**
+   * This is a wrapper around the thirdweb connect function.
+   * It is used to connect to a wallet using the thirdweb client.
+   */
+  const connectTw = useCallback(
+    async (strategyOptions?: SingleStepAuthArgsType) => {
+      setIsLoading(true);
+      return await connect(async () => {
+        if (!strategyOptions) throw new Error("Strategy options are required");
+
+        debug("@@useConnect:strategyOptions", {
+          partnerId,
+          strategyOptions,
+          clientId: THIRDWEB_CLIENT_ID
+        });
+
+        // Create a wallet for "Allowlist" ecosystems restricted to partners
+        const wallet = ecosystemWallet(ecosystemWalletId, {
+          partnerId: partnerId
+        });
+
+        const connect = await wallet.connect({
+          client,
+          chain,
+          // This is the payload that is sent to the auth endpoint
+          ...strategyOptions
+        });
+
+        debug("@@useConnect:connect:", connect);
+        setIsLoading(false);
+
+        if (!wallet) throw new Error("Failed to connect");
+        return wallet;
+      });
+    },
+    [chain, connect, partnerId]
+  );
+
+  return { connect: connectTw, isLoading };
+}

package/src/global-account/react/hooks/useExchangeRate.tsx

@@ -0,0 +1,43 @@
+"use client";
+
+import { useQuery } from "@tanstack/react-query";
+
+interface UseExchangeRateProps {
+  baseCurrency: string;
+  quoteCurrency: string;
+  refreshInterval?: number;
+}
+
+async function fetchExchangeRate(baseCurrency: string, quoteCurrency: string) {
+  const response = await fetch(`https://api.coinbase.com/v2/exchange-rates?currency=${baseCurrency}`);
+  if (!response.ok) {
+    throw new Error("Failed to fetch exchange rate");
+  }
+  const data = await response.json();
+  return parseFloat(data.data.rates[quoteCurrency]);
+}
+
+export function useExchangeRate({ baseCurrency, quoteCurrency, refreshInterval = 30000 }: UseExchangeRateProps) {
+  const {
+    data: rate = 0,
+    isLoading,
+    error,
+    refetch
+  } = useQuery({
+    queryKey: ["exchangeRate", baseCurrency, quoteCurrency],
+    queryFn: () => fetchExchangeRate(baseCurrency, quoteCurrency),
+    refetchInterval: refreshInterval,
+    staleTime: refreshInterval / 2, // Consider data stale after half the refresh interval
+    retry: 3,
+    retryDelay: attemptIndex => Math.min(1000 * 2 ** attemptIndex, 30000)
+  });
+
+  return {
+    rate,
+    isLoading,
+    error,
+    refetch
+  };
+}
+
+export default useExchangeRate;