@b3dotfun/sdk 0.0.41-test.0 → 0.0.42-alpha.0

package/src/bondkit/swapService.ts

@@ -1,15 +1,15 @@
-import type { Address, Hex, WalletClient, PublicClient } from "viem";
+import type { Address, Hex, PublicClient, WalletClient } from "viem";
 import {
-  parseUnits,
-  formatUnits,
+  createPublicClient,
   encodeAbiParameters,
-  parseAbiParameters,
+  formatUnits,
   getContract,
-  createPublicClient,
   http,
+  parseAbiParameters,
+  parseUnits,
 } from "viem";
 import { base } from "viem/chains";
-import { UniversalRouterAddress, QuoterAddress, Permit2Address, BaseMainnetRpcUrl } from "./constants";
+import { BaseMainnetRpcUrl, Permit2Address, QuoterAddress, UniversalRouterAddress } from "./constants";
 import type { SwapQuote } from "./types";
 
 // Minimal ABIs needed for swap functionality
@@ -230,7 +230,10 @@ export class BondkitSwapService {
    */
   private async getV4Config(): Promise<V4PoolConfig> {
     await this.initializeV4Config();
-    return this.v4Config!;
+    if (!this.v4Config) {
+      throw new Error("Failed to initialize V4 configuration");
+    }
+    return this.v4Config;
   }
 
   /**

package/src/global-account/react/components/B3Provider/B3Provider.tsx

@@ -6,11 +6,9 @@ import { ecosystemWalletId } from "@b3dotfun/sdk/shared/constants";
 import { supportedChains } from "@b3dotfun/sdk/shared/constants/chains/supported";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
-import { farcasterMiniApp as miniAppConnector } from "@farcaster/miniapp-wagmi-connector";
 import "@reservoir0x/relay-kit-ui/styles.css";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { inAppWalletConnector } from "@thirdweb-dev/wagmi-adapter";
-
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { Toaster } from "sonner";
 import {
@@ -90,31 +88,34 @@ export function B3Provider({
     };
   }, [partnerId]);
 
+  // Stringify rpcUrls for stable comparison to prevent wagmiConfig recreation
+  // when parent component passes new object references with same content
+  const rpcUrlsString = useMemo(() => (rpcUrls ? JSON.stringify(rpcUrls) : undefined), [rpcUrls]);
+
   /**
    * Creates wagmi config with optional custom RPC URLs
    * @param rpcUrls - Optional mapping of chain IDs to RPC URLs
    */
-  const wagmiConfig = useMemo(
-    () =>
-      createConfig({
-        chains: [supportedChains[0], ...supportedChains.slice(1)],
-        transports: Object.fromEntries(supportedChains.map(chain => [chain.id, http(rpcUrls?.[chain.id])])) as any,
-        connectors: [
-          inAppWalletConnector({
-            ...(ecocystemConfig || {}),
-            client,
-          }),
-          miniAppConnector(),
-          // injected(),
-          // coinbaseWallet({ appName: "HypeDuel" }),
-        ],
-      }),
-    [partnerId],
-  );
+  const wagmiConfig = useMemo(() => {
+    const parsedRpcUrls = rpcUrlsString ? JSON.parse(rpcUrlsString) : undefined;
+
+    return createConfig({
+      chains: [supportedChains[0], ...supportedChains.slice(1)],
+      transports: Object.fromEntries(supportedChains.map(chain => [chain.id, http(parsedRpcUrls?.[chain.id])])),
+      connectors: [
+        inAppWalletConnector({
+          ...(ecocystemConfig || {}),
+          client,
+        }),
+        // injected(),
+        // coinbaseWallet({ appName: "HypeDuel" }),
+      ],
+    });
+  }, [ecocystemConfig, rpcUrlsString]);
 
   return (
     <ThirdwebProvider>
-      <WagmiProvider config={wagmiConfig} reconnectOnMount={false}>
+      <WagmiProvider config={wagmiConfig}>
         <QueryClientProvider client={queryClient}>
           <TooltipProvider>
             <InnerProvider

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

@@ -14,6 +14,7 @@ export { useExchangeRate } from "./useExchangeRate";
 export { useFirstEOA } from "./useFirstEOA";
 export { useGetAllTWSigners, type TWSignerWithMetadata } from "./useGetAllTWSigners";
 export { useGetGeo } from "./useGetGeo";
+export { useGlobalAccount } from "./useGlobalAccount";
 export { useHandleConnectWithPrivy } from "./useHandleConnectWithPrivy";
 export { useHasMounted } from "./useHasMounted";
 export { useIsMobile } from "./useIsMobile";

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

@@ -1,8 +1,9 @@
 import { fetchSimpleHashData } from "@b3dotfun/sdk/shared/utils/simplehash";
 import { useQuery } from "@tanstack/react-query";
+import invariant from "invariant";
 
-async function fetchAccountAssets(address: string) {
-  if (!address) throw new Error("Address is required");
+async function fetchAccountAssets(address: string | undefined) {
+  invariant(address, "Address is required");
 
   const [nftResponse] = await Promise.all([
     fetchSimpleHashData(`/v0/nfts/owners`, {
@@ -27,7 +28,7 @@ async function fetchAccountAssets(address: string) {
 export function useAccountAssets(address?: string) {
   return useQuery({
     queryKey: ["accountAssets", address],
-    queryFn: () => fetchAccountAssets(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/src/global-account/react/hooks/useAuthentication.ts

@@ -100,7 +100,7 @@ export function useAuthentication(partnerId: string, loginWithSiwe?: boolean) {
       setIsAuthenticating(false);
     }
     useAutoConnectLoadingPrevious.current = useAutoConnectLoading;
-  }, [useAutoConnectLoading]);
+  }, [useAutoConnectLoading, hasStartedConnecting, setIsAuthenticating]);
 
   // Ensure isAuthenticating stays true until we're fully ready
   useEffect(() => {

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

@@ -0,0 +1,36 @@
+import { useAuthStore } from "@b3dotfun/sdk/global-account/react";
+import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
+import { useEffect, useState } from "react";
+import { useConnectedWallets, useWalletInfo } from "thirdweb/react";
+import { Wallet } from "thirdweb/wallets";
+
+const debug = debugB3React("useGlobalAccount");
+
+export function useGlobalAccount() {
+  const wallets = useConnectedWallets();
+  const isConnected = useAuthStore(state => state.isConnected);
+  const [globalAccount, setGlobalAccount] = useState<Wallet | undefined>(undefined);
+  const [address, setAddress] = useState<string | undefined>(undefined);
+  const walletInfo = useWalletInfo(globalAccount?.id);
+
+  useEffect(() => {
+    if (!isConnected) {
+      debug("Not connected");
+      setGlobalAccount(undefined);
+      setAddress(undefined);
+      return;
+    }
+
+    const globalAccountWallet = wallets.find(wallet => wallet.id.startsWith("ecosystem."));
+
+    const account = globalAccountWallet?.getAccount();
+    setGlobalAccount(globalAccountWallet);
+    setAddress(account?.address);
+  }, [isConnected, wallets]);
+
+  return {
+    account: globalAccount,
+    address,
+    info: walletInfo,
+  };
+}

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

@@ -30,7 +30,7 @@ export const useOneBalance = (bypassCache = false) => {
 
   const { data, isLoading, refetch } = useQuery({
     queryKey: ["balances", address, `testnet-${sprinterTestnet}`],
-    queryFn: () => fetchBalances(address!, sprinterTestnet),
+    queryFn: () => fetchBalances(address, sprinterTestnet),
     enabled: !!address,
     staleTime: 1000 * 60 * 1, // 1 minute
     gcTime: 1000 * 60 * 5, // 5 minutes (renamed from cacheTime in v5)

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

@@ -47,26 +47,33 @@ export function useQueryB3<
   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);
-    }
-  }, []);
+  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);
+      }
+    },
+    [service, method],
+  );
+
+  // Serialize params for stable comparison
+  const paramsJson = JSON.stringify(params);
 
   useEffect(() => {
     if (fetchInitially) {
       runQuery(params);
     }
-  }, [runQuery, fetchInitially, JSON.stringify(params)]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [runQuery, fetchInitially, paramsJson]);
 
   return { data, error, isLoading, runQuery };
 }

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

@@ -47,26 +47,33 @@ export function useQueryBSMNT<
   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);
-    }
-  }, []);
+  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);
+      }
+    },
+    [service, method],
+  );
+
+  // Serialize params for stable comparison
+  const paramsJson = JSON.stringify(params);
 
   useEffect(() => {
     if (fetchInitially) {
       runQuery(params);
     }
-  }, [runQuery, fetchInitially, JSON.stringify(params)]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [runQuery, fetchInitially, paramsJson]);
 
   return { data, error, isLoading, runQuery };
 }

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

@@ -7,6 +7,7 @@ import { viemToThirdwebChain } from "@b3dotfun/sdk/shared/constants/chains/b3Cha
 import { getChainById } from "@b3dotfun/sdk/shared/utils/chains";
 import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
 import { getWalletBalance } from "thirdweb/wallets";
+import invariant from "invariant";
 
 type GetWalletBalanceResult = {
   value: bigint;
@@ -51,10 +52,12 @@ export function useTokenBalancesByChain({
           // Fetch native token balances
           Promise.all(
             chainIds.map(async chainId => {
+              const chain = getChainById(chainId);
+              invariant(chain, "Chain is required");
               const walletBalance = await getWalletBalance({
                 address,
                 client,
-                chain: viemToThirdwebChain(getChainById(chainId)!),
+                chain: viemToThirdwebChain(chain),
               });
 
               return {

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

@@ -69,7 +69,7 @@ export function useTokenFromUrl({ defaultToken, prefix }: UseTokenFromUrlOptions
 
   const { data: tokenInfo, isError } = useQuery({
     queryKey: ["tokenInfo", network, currencyParam],
-    queryFn: () => fetchTokenInfo(network, currencyParam!),
+    queryFn: () => fetchTokenInfo(network, currencyParam || ""),
     enabled: shouldFetchToken,
     staleTime: Infinity,
     gcTime: Infinity,
@@ -84,7 +84,7 @@ export function useTokenFromUrl({ defaultToken, prefix }: UseTokenFromUrlOptions
   if (isError || !tokenInfo) {
     return {
       ...defaultToken,
-      address: currencyParam!,
+      address: currencyParam || "",
       chainId: Number(chainIdParam),
     };
   }

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

@@ -8,7 +8,7 @@ import { toast } from "sonner";
 import { prepareTransaction, sendTransaction as twSendTransaction } from "thirdweb";
 import { useActiveWallet } from "thirdweb/react";
 import { isAddress } from "viem";
-import { useSwitchChain, useWalletClient } from "wagmi";
+import { useSwitchChain } from "wagmi";
 import { useB3 } from "../components";
 import { useAccountWallet } from "./useAccountWallet";
 
@@ -27,7 +27,6 @@ const partnerId = String(
 invariant(partnerId, "Partner ID is required");
 
 export function useUnifiedChainSwitchAndExecute() {
-  const { data: walletClient } = useWalletClient();
   const { switchChainAsync } = useSwitchChain();
   const [isSwitchingOrExecuting, setIsSwitchingOrExecuting] = useState(false);
   const activeWallet = useActiveWallet();
@@ -122,7 +121,7 @@ export function useUnifiedChainSwitchAndExecute() {
         setIsSwitchingOrExecuting(false);
       }
     },
-    [walletClient, switchChainAsync],
+    [connectedEOAWallet, activeWallet, switchChainAsync],
   );
 
   // Handle AA wallet transaction (no chain switch needed for AA)

package/src/shared/utils/fetchBalances.ts

@@ -19,7 +19,7 @@ export interface AssetBalance {
   chainBalances: ChainBalance[];
 }
 
-export const fetchBalances = async (address: string, testnet?: boolean): Promise<AssetBalance[]> => {
+export const fetchBalances = async (address: string | undefined, testnet?: boolean): Promise<AssetBalance[]> => {
   if (!address) return [];
 
   const assetsResponse = await fetch(`${getSprinterBaseUrl(testnet)}/assets/fungible`);