@b3dotfun/sdk 0.0.1-alpha.1

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

@@ -0,0 +1,95 @@
+"use client";
+
+import { fetchBalances } from "@b3dotfun/sdk/shared/utils/fetchBalances";
+import { useQuery } from "@tanstack/react-query";
+import { useEffect, useMemo } from "react";
+import { useAccountWallet } from "./useAccountWallet";
+
+export interface Asset {
+  symbol: string;
+  name: string;
+}
+
+export interface ChainBalance {
+  chainId: number;
+  balance: string;
+  tokenDecimals: number;
+}
+
+export interface AssetBalance {
+  symbol: string;
+  name: string;
+  totalBalance: string;
+  chainBalances: ChainBalance[];
+}
+
+export const useOneBalance = (bypassCache = false) => {
+  const account = useAccountWallet();
+  const address = account?.address;
+  const sprinterTestnet = false;
+
+  const { data, isLoading, refetch } = useQuery({
+    queryKey: ["balances", address, `testnet-${sprinterTestnet}`],
+    queryFn: () => fetchBalances(address!, sprinterTestnet),
+    enabled: !!address,
+    staleTime: 1000 * 60 * 1, // 1 minute
+    gcTime: 1000 * 60 * 5 // 5 minutes (renamed from cacheTime in v5)
+  });
+
+  useEffect(() => {
+    if (bypassCache) {
+      refetch();
+    }
+  }, [bypassCache, refetch]);
+
+  const aggregatedTokenBalances = useMemo(() => {
+    const tokenBalances: { [key: string]: number } = {};
+    data?.forEach(asset => {
+      const totalBalance = asset.chainBalances.reduce((sum, balance) => {
+        return sum + parseFloat(balance.balance) / Math.pow(10, balance.tokenDecimals);
+      }, 0);
+      tokenBalances[asset.symbol] = (tokenBalances[asset.symbol] || 0) + totalBalance;
+    });
+    return tokenBalances;
+  }, [data]);
+
+  const totalBalanceInEth = useMemo(() => {
+    return (
+      data?.reduce((total, asset) => {
+        if (asset.symbol === "ETH" || asset.symbol === "WETH") {
+          return total + parseFloat(asset.totalBalance);
+        }
+        // TODO: Add conversion logic for other assets to ETH equivalent
+        return total;
+      }, 0) || 0
+    );
+  }, [data]);
+
+  const totalB3BalanceInEth = useMemo(() => {
+    const b3Balance = data?.reduce((total, asset) => {
+      if (asset.symbol === "ETH") {
+        const b3ChainBalance = asset.chainBalances.find(balance => balance.chainId === 8333);
+        if (b3ChainBalance) {
+          return total + parseFloat(b3ChainBalance.balance) / Math.pow(10, b3ChainBalance.tokenDecimals);
+        }
+      }
+      return total;
+    }, 0);
+
+    return b3Balance || 0;
+  }, [data]);
+
+  const formatNumber = (num: number) => {
+    return num.toFixed(3);
+  };
+
+  return {
+    totalBalanceInEth,
+    totalB3BalanceInEth,
+    formattedTotalBalance: `${formatNumber(totalBalanceInEth)} ETH`,
+    aggregatedBalances: data || [],
+    aggregatedTokenBalances,
+    loading: isLoading,
+    refetch
+  };
+};

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

@@ -0,0 +1,72 @@
+import { ServiceTypes } from "@b3dotfun/b3-api";
+import { useCallback, useEffect, useState } from "react";
+// https://feathersjs.com/guides/cli/client#usage
+import app from "@b3dotfun/sdk/global-account/app";
+import { Paginated } from "@feathersjs/feathers";
+
+// Extract the callable methods from a service
+export type ServiceMethods<T extends keyof ServiceTypes> = {
+  [M in keyof ServiceTypes[T]]: ServiceTypes[T][M] extends (...args: any[]) => any ? M : never;
+}[keyof ServiceTypes[T]];
+
+// Infer the type of params for a method in a service
+export type ParamsType<T extends keyof ServiceTypes, M extends ServiceMethods<T>> = ServiceTypes[T][M] extends (
+  ...args: infer P
+) => any
+  ? P[0]
+  : never;
+
+type UnwrapArray<T> = T extends (infer U)[] ? U : T;
+type UnpaginatedData<T> = T extends Paginated<infer U> ? U : T;
+
+// Infer the resolved return type of a method (unwraps Promise)
+export type DataType<T extends keyof ServiceTypes, M extends ServiceMethods<T>> = ServiceTypes[T][M] extends (
+  ...args: any[]
+) => infer R
+  ? M extends "find"
+    ? {
+        data: UnpaginatedData<UnwrapArray<Awaited<R>>>[];
+        total: number;
+        limit: number;
+        skip: number;
+      }
+    : Awaited<R>
+  : never;
+
+export default function useQueryB3<
+  T extends keyof ServiceTypes, // Service name (key of ServiceTypes)
+  M extends ServiceMethods<T> // Method name within the service
+>(
+  service: T, // Service as string
+  method: M, // Method as string
+  params: ParamsType<T, M>, // Params type inferred dynamically
+  fetchInitially = true
+) {
+  // Use DataType to infer the type of data and unwrap the Promise
+  const [data, setData] = useState<DataType<T, M> | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+
+  const runQuery = useCallback(async (queryParams: ParamsType<T, M>) => {
+    setIsLoading(true);
+    try {
+      // Cast the service to avoid TypeScript issues with dynamic services
+      const serviceInstance = app.service(service) as any;
+      const result = await serviceInstance[method](queryParams);
+      setData(result); // Now `data` is correctly typed!
+      return result;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("An error occurred"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (fetchInitially) {
+      runQuery(params);
+    }
+  }, [runQuery, fetchInitially, JSON.stringify(params)]);
+
+  return { data, error, isLoading, runQuery };
+}

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

@@ -0,0 +1,72 @@
+import { ServiceTypes } from "@b3dotfun/basement-api";
+import { useCallback, useEffect, useState } from "react";
+// https://feathersjs.com/guides/cli/client#usage
+import app from "@b3dotfun/sdk/global-account/bsmnt";
+import { Paginated } from "@feathersjs/feathers";
+
+// Extract the callable methods from a service
+export type ServiceMethods<T extends keyof ServiceTypes> = {
+  [M in keyof ServiceTypes[T]]: ServiceTypes[T][M] extends (...args: any[]) => any ? M : never;
+}[keyof ServiceTypes[T]];
+
+// Infer the type of params for a method in a service
+export type ParamsType<T extends keyof ServiceTypes, M extends ServiceMethods<T>> = ServiceTypes[T][M] extends (
+  ...args: infer P
+) => any
+  ? P[0]
+  : never;
+
+type UnwrapArray<T> = T extends (infer U)[] ? U : T;
+type UnpaginatedData<T> = T extends Paginated<infer U> ? U : T;
+
+// Infer the resolved return type of a method (unwraps Promise)
+export type DataType<T extends keyof ServiceTypes, M extends ServiceMethods<T>> = ServiceTypes[T][M] extends (
+  ...args: any[]
+) => infer R
+  ? M extends "find"
+    ? {
+        data: UnpaginatedData<UnwrapArray<Awaited<R>>>[];
+        total: number;
+        limit: number;
+        skip: number;
+      }
+    : Awaited<R>
+  : never;
+
+export default function useQueryBSMNT<
+  T extends keyof ServiceTypes, // Service name (key of ServiceTypes)
+  M extends ServiceMethods<T> // Method name within the service
+>(
+  service: T, // Service as string
+  method: M, // Method as string
+  params: ParamsType<T, M>, // Params type inferred dynamically
+  fetchInitially = true
+) {
+  // Use DataType to infer the type of data and unwrap the Promise
+  const [data, setData] = useState<DataType<T, M> | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+
+  const runQuery = useCallback(async (queryParams: ParamsType<T, M>) => {
+    setIsLoading(true);
+    try {
+      // Cast the service to avoid TypeScript issues with dynamic services
+      const serviceInstance = app.service(service) as any;
+      const result = await serviceInstance[method](queryParams);
+      setData(result); // Now `data` is correctly typed!
+      return result;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("An error occurred"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (fetchInitially) {
+      runQuery(params);
+    }
+  }, [runQuery, fetchInitially, JSON.stringify(params)]);
+
+  return { data, error, isLoading, runQuery };
+}

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

@@ -0,0 +1,69 @@
+import { ActiveSigners } from "@b3dotfun/sdk/global-account/types";
+import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
+import createDebug from "debug";
+import { useCallback, useState } from "react";
+import { Chain, Hex, sendTransaction, ThirdwebClient } from "thirdweb";
+import { removeSessionKey } from "thirdweb/extensions/erc4337";
+import { useActiveAccount } from "thirdweb/react";
+
+const debug = createDebug("@@b3:useHandleTWConnect");
+
+export function useRemoveSessionKey({
+  onSuccess,
+  onError,
+  refetchSigners,
+  chain
+}: {
+  chain?: Chain;
+  onSuccess: (
+    transactionResult: { transactionHash: Hex } & {
+      client: ThirdwebClient;
+      chain: Chain;
+    }
+  ) => void;
+  onError: (error: Error) => void;
+  refetchSigners: () => Promise<any>;
+}) {
+  const [isRemovingSessionKey, setIsRemovingSessionKey] = useState(false);
+  if (!chain) {
+    throw new Error("Chain is required");
+  }
+
+  const account = useActiveAccount();
+
+  const removeSessionKeyHandler = useCallback(
+    async (signer: ActiveSigners[number]) => {
+      if (!account || !chain) return;
+
+      setIsRemovingSessionKey(true);
+
+      try {
+        const transaction = removeSessionKey({
+          contract: {
+            client,
+            chain,
+            address: account.address as `0x${string}`
+          },
+          account,
+          sessionKeyAddress: signer.signer as `0x${string}`
+        });
+
+        debug("@@ecosystem:removeSessionKey:transaction:", transaction);
+
+        const transactionResult = await sendTransaction({ transaction, account });
+        debug("@@ecosystem:removeSessionKey:transactionResult:", transactionResult);
+        onSuccess(transactionResult);
+
+        await refetchSigners();
+      } catch (error) {
+        onError(error as Error);
+        console.error("@@ecosystem:removeSessionKey:error:", error);
+      } finally {
+        setIsRemovingSessionKey(false);
+      }
+    },
+    [account, chain, onSuccess, onError, refetchSigners]
+  );
+
+  return { removeSessionKey: removeSessionKeyHandler, isRemovingSessionKey };
+}

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

@@ -0,0 +1,103 @@
+// We intentionally disable the hooks rules here because we need to conditionally return early for SSR.
+// This is safe in this context because the hook is only used in environments where window is defined.
+/* eslint-disable react-hooks/rules-of-hooks */
+
+import { useCallback, useEffect, useState } from "react";
+
+interface RouterState {
+  pathname: string;
+  search: string;
+  hash: string;
+}
+
+interface UseRouterReturn {
+  pathname: string;
+  search: string;
+  hash: string;
+  push: (url: string) => void;
+  replace: (url: string) => void;
+  back: () => void;
+  forward: () => void;
+}
+
+/**
+ * A router hook that works with both client-side and server-side rendering
+ */
+export function useRouter(): UseRouterReturn {
+  // For SSR, return dummy implementation
+  if (typeof window === "undefined") {
+    return {
+      pathname: "",
+      search: "",
+      hash: "",
+      push: () => {},
+      replace: () => {},
+      back: () => {},
+      forward: () => {}
+    };
+  }
+
+  // Initialize state with current location
+  const [routerState, setRouterState] = useState<RouterState>(() => ({
+    pathname: window.location.pathname,
+    search: window.location.search,
+    hash: window.location.hash
+  }));
+
+  // Update state when location changes
+  useEffect(() => {
+    const handleLocationChange = () => {
+      setRouterState({
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+      });
+    };
+
+    // Listen for popstate event (browser back/forward)
+    window.addEventListener("popstate", handleLocationChange);
+
+    return () => {
+      window.removeEventListener("popstate", handleLocationChange);
+    };
+  }, []);
+
+  // Navigation methods
+  const push = useCallback((url: string) => {
+    window.history.pushState({}, "", url);
+    // Manually trigger state update since pushState doesn't fire popstate
+    setRouterState({
+      pathname: window.location.pathname,
+      search: window.location.search,
+      hash: window.location.hash
+    });
+  }, []);
+
+  const replace = useCallback((url: string) => {
+    window.history.replaceState({}, "", url);
+    // Manually trigger state update
+    setRouterState({
+      pathname: window.location.pathname,
+      search: window.location.search,
+      hash: window.location.hash
+    });
+  }, []);
+
+  const back = useCallback(() => {
+    window.history.back();
+  }, []);
+
+  const forward = useCallback(() => {
+    window.history.forward();
+  }, []);
+
+  return {
+    ...routerState,
+    push,
+    replace,
+    back,
+    forward
+  };
+}
+
+export default useRouter;

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

@@ -0,0 +1,34 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+
+export default function useSearchParamsSSR() {
+  const [searchParams, setSearchParams] = useState<URLSearchParams>(() => {
+    if (typeof window === "undefined") {
+      return new URLSearchParams();
+    }
+    return new URLSearchParams(window.location.search);
+  });
+
+  // Use callback to read from window to avoid Suspense
+  const updateSearchParams = useCallback(() => {
+    if (typeof window !== "undefined") {
+      setSearchParams(new URLSearchParams(window.location.search));
+    }
+  }, []);
+
+  useEffect(() => {
+    updateSearchParams();
+
+    // Optional: Update on popstate
+    window.addEventListener("popstate", updateSearchParams);
+    return () => window.removeEventListener("popstate", updateSearchParams);
+  }, [updateSearchParams]);
+
+  return searchParams;
+}
+
+export function useSearchParam(param: string): string | null {
+  const searchParams = useSearchParamsSSR();
+  return searchParams.get(param);
+}

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

@@ -0,0 +1,39 @@
+import app from "@b3dotfun/sdk/global-account/app";
+import debug from "@b3dotfun/sdk/shared/utils/debug";
+import { useCallback } from "react";
+import { Account } from "thirdweb/wallets";
+
+export function useSiwe() {
+  const authenticate = useCallback(async (account: Account) => {
+    if (!account || !account.signMessage) throw new Error("Account not found");
+
+    // generate challenge
+    const challenge = await app.service("global-accounts-challenge").create({
+      address: account.address
+    });
+    debug("@@useAuthenticate:challenge", challenge);
+
+    // sign challenge
+    const signature = await account.signMessage({
+      message: challenge.message
+    });
+
+    debug("@@useAuthenticate:signature", signature);
+
+    // authenticate
+    const response = await app.authenticate({
+      strategy: "smart-account-siwe",
+      message: challenge.message,
+      signature,
+      serverSignature: challenge.serverSignature,
+      nonce: challenge.nonce
+    });
+    debug("@@useAuthenticate:response", response);
+
+    return response;
+  }, []);
+
+  return {
+    authenticate
+  };
+}

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

@@ -0,0 +1,85 @@
+"use client";
+
+import { isNativeToken, Token } from "@b3dotfun/sdk/anyspend";
+import { useB3 } from "@b3dotfun/sdk/global-account";
+import { useAccountWallet } from "@b3dotfun/sdk/global-account/react/hooks/useAccountWallet";
+import { formatTokenAmount } from "@b3dotfun/sdk/shared/utils/number";
+import { getERC20Balances, getNativeTokenBalance } from "@b3dotfun/sdk/shared/utils/thirdweb-insights";
+import { useQuery } from "@tanstack/react-query";
+import { useEffect } from "react";
+
+interface UseTokenBalanceProps {
+  token: Token;
+  address?: string;
+}
+
+export interface TokenBalanceResult {
+  rawBalance: bigint | null;
+  formattedBalance: string;
+  isLoading: boolean;
+}
+
+export function useTokenBalance({ token, address }: UseTokenBalanceProps): TokenBalanceResult {
+  const { ready } = useB3();
+  const account = useAccountWallet();
+
+  const effectiveAddress = address || account?.address;
+
+  const {
+    data: tokenBalance,
+    isLoading,
+    isFetching,
+    refetch
+  } = useQuery({
+    queryKey: ["tokenBalance", effectiveAddress, token.chainId, token.address],
+    queryFn: async (): Promise<{ formatted: string; raw: bigint | null }> => {
+      if (!effectiveAddress) return { formatted: "0", raw: null };
+
+      if (isNativeToken(token.address)) {
+        const nativeToken = await getNativeTokenBalance(effectiveAddress, token.chainId);
+        if (nativeToken && nativeToken.balance) {
+          const rawBalance = nativeToken.balance;
+          return {
+            formatted: formatTokenAmount(BigInt(rawBalance), Number(nativeToken.decimals || 18)),
+            raw: BigInt(rawBalance)
+          };
+        }
+        return { formatted: "0", raw: null };
+      }
+
+      const response = await getERC20Balances(effectiveAddress, {
+        chainIds: [token.chainId],
+        includeSpam: false
+      });
+      const tokenBalance = response.data?.find(t => t.token_address === token.address);
+      if (tokenBalance?.balance) {
+        return {
+          formatted: formatTokenAmount(BigInt(tokenBalance.balance), Number(tokenBalance.decimals || 18)),
+          raw: BigInt(tokenBalance.balance)
+        };
+      }
+      return { formatted: "0", raw: null };
+    },
+    enabled: ready && !!effectiveAddress,
+    staleTime: 30000,
+    gcTime: 5 * 60 * 1000,
+    retry: 2,
+    structuralSharing: false
+  });
+
+  // Force a refetch when the wallet or token changes
+  useEffect(() => {
+    if (ready && effectiveAddress) {
+      refetch();
+    }
+  }, [ready, effectiveAddress, token.address, token.chainId, token.symbol, refetch]);
+
+  // Determine if we're actually loading
+  const isActuallyLoading = !ready || !effectiveAddress || isLoading || (isFetching && !tokenBalance);
+
+  return {
+    rawBalance: tokenBalance?.raw || 0n,
+    formattedBalance: tokenBalance?.formatted || "0",
+    isLoading: isActuallyLoading
+  };
+}

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

@@ -0,0 +1,93 @@
+"use client";
+
+import { getERC20Balances, TokenData } from "@b3dotfun/sdk/shared/utils/thirdweb-insights";
+import { useQuery } from "@tanstack/react-query";
+
+import { viemToThirdwebChain } from "@b3dotfun/sdk/shared/constants/chains/b3Chain";
+import { getChainById } from "@b3dotfun/sdk/shared/utils/chains";
+import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
+import { getWalletBalance } from "thirdweb/wallets";
+
+type GetWalletBalanceResult = {
+  value: bigint;
+  decimals: number;
+  displayValue: string;
+  symbol: string;
+  name: string;
+  chainId: number;
+};
+
+export interface TokenBalancesByChain {
+  nativeTokens: GetWalletBalanceResult[];
+  fungibleTokens: TokenData[];
+  isLoading: boolean;
+  error: Error | null;
+}
+
+interface UseTokenBalancesByChainProps {
+  address: string;
+  chainsIds: number | number[];
+  enabled?: boolean;
+}
+
+export function useTokenBalancesByChain({
+  address,
+  chainsIds,
+  enabled = true
+}: UseTokenBalancesByChainProps): TokenBalancesByChain {
+  // Normalize chains to array
+  const chainIds = Array.isArray(chainsIds) ? chainsIds : [chainsIds];
+
+  const {
+    data: combinedData,
+    isLoading,
+    error
+  } = useQuery({
+    queryKey: ["tokenBalancesByChain", address, chainIds.join(",")],
+    queryFn: async () => {
+      try {
+        // Run both fetches in parallel
+        const [nativeTokens, fungibleResponse] = await Promise.all([
+          // Fetch native token balances
+          Promise.all(
+            chainIds.map(async chainId => {
+              const walletBalance = await getWalletBalance({
+                address,
+                client,
+                chain: viemToThirdwebChain(getChainById(chainId)!)
+              });
+
+              return {
+                chainId,
+                ...walletBalance
+              };
+            })
+          ),
+          getERC20Balances(address, {
+            chainIds
+          })
+        ]);
+
+        return {
+          nativeTokens,
+          fungibleTokens: fungibleResponse.data
+        };
+      } catch (err) {
+        console.error("Error fetching token balances:", err);
+        throw err;
+      }
+    },
+    enabled: enabled && !!address && chainIds.length > 0,
+    staleTime: 30000, // Consider data fresh for 30 seconds
+    gcTime: 5 * 60 * 1000, // Keep in cache for 5 minutes
+    retry: 2, // Limit retries on failure
+    structuralSharing: false
+  });
+
+  return {
+    nativeTokens: combinedData?.nativeTokens ?? [],
+    fungibleTokens: combinedData?.fungibleTokens ?? [],
+    isLoading,
+    error: error as Error | null
+  };
+}