@b3dotfun/sdk 0.1.0 → 0.1.1-test.0

package/src/global-account/react/components/SignInWithB3/SignIn.tsx

@@ -5,7 +5,7 @@ import {
   StyleRoot,
   useAccountWallet,
   useAuthentication,
-  useB3Config,
+  useB3,
   useIsMobile,
 } from "@b3dotfun/sdk/global-account/react";
 import Icon from "@b3dotfun/sdk/global-account/react/components/custom/Icon";
@@ -30,7 +30,7 @@ type SignInWithB3Props = Omit<SignInWithB3ModalProps, "type" | "showBackButton">
 
 export function SignIn(props: SignInWithB3Props) {
   const { className } = props;
-  const { automaticallySetFirstEoa, partnerId } = useB3Config();
+  const { automaticallySetFirstEoa, partnerId } = useB3();
   const {
     address: globalAddress,
     ensName,

package/src/global-account/react/components/SignInWithB3/SignInWithB3Flow.tsx

@@ -3,12 +3,12 @@ import {
   SignInWithB3ModalProps,
   useAuthentication,
   useAuthStore,
-  useB3Config,
+  useB3,
   useGetAllTWSigners,
   useModalStore,
 } from "@b3dotfun/sdk/global-account/react";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { useActiveAccount } from "thirdweb/react";
 import { Account } from "thirdweb/wallets";
 import { TurnkeyAuthModal } from "../TurnkeyAuthModal";
@@ -35,8 +35,19 @@ export function SignInWithB3Flow({
   source = "signInWithB3Button",
   signersEnabled = false,
 }: SignInWithB3ModalProps) {
-  const { automaticallySetFirstEoa, enableTurnkey } = useB3Config();
-  const { user, refetchUser } = useAuthentication(partnerId);
+  const { automaticallySetFirstEoa, enableTurnkey } = useB3();
+  const { user, refetchUser, logout } = useAuthentication(partnerId);
+
+  // FIXME Logout before login to ensure a clean state
+  const hasLoggedOutRef = useRef(false);
+  useEffect(() => {
+    if (hasLoggedOutRef.current) return;
+    if (source !== "requestPermissions") {
+      debug("Logging out before login");
+      logout();
+      hasLoggedOutRef.current = true;
+    }
+  }, [source, logout]);
 
   const [step, setStep] = useState<"login" | "permissions" | null>(source === "requestPermissions" ? null : "login");
   const [sessionKeyAdded, setSessionKeyAdded] = useState(source === "requestPermissions" ? true : false);

package/src/global-account/react/components/SignInWithB3/SignInWithB3Privy.tsx

@@ -2,7 +2,7 @@ import {
   Loading,
   useAuthentication,
   useAuthStore,
-  useB3Config,
+  useB3,
   useHandleConnectWithPrivy,
 } from "@b3dotfun/sdk/global-account/react";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
@@ -19,7 +19,7 @@ interface SignInWithB3PrivyProps {
 }
 
 export function SignInWithB3Privy({ onSuccess, onError, chain }: SignInWithB3PrivyProps) {
-  const { partnerId } = useB3Config();
+  const { partnerId } = useB3();
   const { isLoading, connectTw, fullToken } = useHandleConnectWithPrivy(chain, onSuccess);
   const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
   const setIsAuthenticated = useAuthStore(state => state.setIsAuthenticated);

package/src/global-account/react/components/SignInWithB3/steps/LoginStep.tsx

@@ -1,4 +1,4 @@
-import { useAuthentication, useB3Config, useQueryB3 } from "@b3dotfun/sdk/global-account/react";
+import { useAuthentication, useB3, useQueryB3 } from "@b3dotfun/sdk/global-account/react";
 import { ecosystemWalletId } from "@b3dotfun/sdk/shared/constants";
 import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
 import { Chain } from "thirdweb";
@@ -50,7 +50,7 @@ export function LoginStepContainer({ children, partnerId }: LoginStepContainerPr
 }
 
 export function LoginStep({ onSuccess, chain }: LoginStepProps) {
-  const { partnerId, theme } = useB3Config();
+  const { partnerId, theme } = useB3();
   const wallet = ecosystemWallet(ecosystemWalletId, {
     partnerId: partnerId,
   });

package/src/global-account/react/components/SignInWithB3/steps/LoginStepCustom.tsx

@@ -7,7 +7,7 @@ import {
   LoginStepContainer,
   useAuthentication,
   useAuthStore,
-  useB3Config,
+  useB3,
   useConnect,
   WalletRow,
 } from "@b3dotfun/sdk/global-account/react";
@@ -37,7 +37,7 @@ export function LoginStepCustom({
   maxInitialWallets = 2,
   automaticallySetFirstEoa,
 }: LoginStepCustomProps) {
-  const { partnerId } = useB3Config();
+  const { partnerId } = useB3();
   const [isLoading, setIsLoading] = useState(false);
   const [showAllWallets, setShowAllWallets] = useState(false);
   const { connect } = useConnect(partnerId, chain);

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

@@ -1,8 +1,8 @@
 import { PropsWithChildren } from "react";
-import { useB3Config } from "./B3Provider/useB3Config";
+import { useB3 } from "./B3Provider/useB3";
 
 export function StyleRoot({ children, id }: PropsWithChildren<{ id?: string }>) {
-  const { theme } = useB3Config();
+  const { theme } = useB3();
 
   return (
     <div className="b3-root" id={id} data-theme={theme}>

package/src/global-account/react/components/custom/ManageAccountButton.tsx

@@ -1,10 +1,11 @@
-import { Button, StyleRoot, useModalStore, useUser } from "@b3dotfun/sdk/global-account/react";
+import { Button, StyleRoot, useAuthentication, useB3, useModalStore } from "@b3dotfun/sdk/global-account/react";
 import { cn } from "@b3dotfun/sdk/shared/utils";
 import { SignInWithB3Props } from "../SignInWithB3/SignInWithB3";
 
 export function ManageAccountButton(props: SignInWithB3Props & { className?: string }) {
+  const { partnerId } = useB3();
   const { setB3ModalOpen, setB3ModalContentType } = useModalStore();
-  const { isConnected } = useUser();
+  const { isConnected } = useAuthentication(partnerId);
 
   const handleClickManageAccount = () => {
     setB3ModalContentType({

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

@@ -1,8 +1,9 @@
 // TODO woj: Barrel file for all components, this might be reason of bundle size issues
 // Core Components
 export { B3DynamicModal } from "./B3DynamicModal";
-export { B3Provider } from "./B3Provider/B3Provider";
+export { B3Provider, InnerProvider } from "./B3Provider/B3Provider";
 export { RelayKitProviderWrapper } from "./B3Provider/RelayKitProviderWrapper";
+export { B3Context, type B3ContextType } from "./B3Provider/types";
 export { useB3 } from "./B3Provider/useB3";
 export { useB3Account } from "./B3Provider/useB3Account";
 export { useB3Config } from "./B3Provider/useB3Config";

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

@@ -39,7 +39,8 @@ export { useQueryBSMNT } from "./useQueryBSMNT";
 export { useRemoveSessionKey } from "./useRemoveSessionKey";
 export { useRouter } from "./useRouter";
 export { useSearchParamsSSR } from "./useSearchParamsSSR";
-export { useSimBalance, useSimSvmBalance } from "./useSimBalance";
+export { useSimBalance, useSimSvmBalance, useSimTokenBalance } from "./useSimBalance";
+export { useSimCollectibles } from "./useSimCollectibles";
 export { useSiwe } from "./useSiwe";
 export { useTokenBalance } from "./useTokenBalance";
 export { useTokenBalanceDirect } from "./useTokenBalanceDirect";
@@ -52,4 +53,3 @@ export { useTokensFromAddress } from "./useTokensFromAddress";
 export { useTurnkeyAuth } from "./useTurnkeyAuth";
 export { useUnifiedChainSwitchAndExecute } from "./useUnifiedChainSwitchAndExecute";
 export { useURLParams } from "./useURLParams";
-export { useUser } from "./useUser";

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

@@ -1,6 +1,6 @@
 import app from "@b3dotfun/sdk/global-account/app";
 import { authenticateWithB3JWT } from "@b3dotfun/sdk/global-account/bsmnt";
-import { useAuthStore, useB3Config } from "@b3dotfun/sdk/global-account/react";
+import { useAuthStore, useB3 } from "@b3dotfun/sdk/global-account/react";
 import { ecosystemWalletId } from "@b3dotfun/sdk/shared/constants";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
@@ -47,7 +47,7 @@ export function useAuth() {
   const hasStartedConnecting = useAuthStore(state => state.hasStartedConnecting);
   const useAutoConnectLoadingPrevious = useRef(false);
   const referralCode = useSearchParam("referralCode");
-  const { partnerId } = useB3Config();
+  const { partnerId } = useB3();
   const wagmiConfig = createWagmiConfig({ partnerId });
   const { connect } = useConnect();
   const activeWagmiAccount = useAccount();
@@ -330,7 +330,7 @@ export function useAuth() {
 
       setIsAuthenticated(false);
       setIsConnected(false);
-      setUser();
+      setUser(undefined);
       callback?.();
     },
     [activeWallet, disconnect, wallets, setIsAuthenticated, setUser, setIsConnected],

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

@@ -179,7 +179,7 @@ export function useAuthentication(partnerId: string) {
 
       setIsAuthenticated(false);
       setIsConnected(false);
-      setUser();
+      setUser(undefined);
       callback?.();
     },
     [activeWallet, disconnect, wallets, setIsAuthenticated, setUser, setIsConnected],

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

@@ -1,4 +1,4 @@
-import { useB3Config } from "@b3dotfun/sdk/global-account/react";
+import { useB3 } from "@b3dotfun/sdk/global-account/react";
 import { useCallback } from "react";
 import {
   ClientType,
@@ -13,7 +13,7 @@ import {
  * Hook to access the current FeathersJS client and client management utilities
  */
 export function useClient() {
-  const { clientType } = useB3Config();
+  const { clientType } = useB3();
 
   const getCurrentClient = useCallback(() => {
     return getClient();

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

@@ -1,4 +1,4 @@
-import { useB3Config, useConnect } from "@b3dotfun/sdk/global-account/react";
+import { useB3, useConnect } from "@b3dotfun/sdk/global-account/react";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { useIdentityToken, usePrivy } from "@privy-io/react-auth";
 import { useCallback, useRef, useState } from "react";
@@ -11,7 +11,7 @@ const debug = debugB3React("@@b3:useHandleConnectWithPrivy");
  * Currently, this is for the basement-privy strategy
  */
 export function useHandleConnectWithPrivy(chain?: Chain, onSuccess?: (account: Account) => void) {
-  const { partnerId } = useB3Config();
+  const { partnerId } = useB3();
   if (!chain) {
     throw new Error("Chain is required");
   }

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

@@ -1,4 +1,4 @@
-import { useB3Config } from "@b3dotfun/sdk/global-account/react";
+import { useB3 } from "@b3dotfun/sdk/global-account/react";
 import { getAuthToken } from "@b3dotfun/sdk/shared/utils/auth-token";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { useCallback, useEffect, useState } from "react";
@@ -56,7 +56,7 @@ export interface UseNotificationsReturn {
  */
 export function useNotifications(): UseNotificationsReturn {
   const { user } = useUserQuery();
-  const { partnerId } = useB3Config();
+  const { partnerId } = useB3();
   const [userData, setUserData] = useState<UserData | null>(null);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);

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

@@ -1,4 +1,5 @@
 import { useQuery } from "@tanstack/react-query";
+import { buildSimduneUrl } from "../utils/simdune";
 
 export interface SimTokenMetadata {
   logo?: string;
@@ -60,11 +61,12 @@ async function fetchSimBalance(address: string, chainIdsParam: number[]): Promis
   if (!address) throw new Error("Address is required");
 
   const chainIds = chainIdsParam.length === 0 ? "mainnet" : chainIdsParam.join(",");
-  let url = `https://simdune-api.sean-430.workers.dev/?url=https://api.sim.dune.com/v1/evm/balances/${address}?metadata=logo&chain_ids=${chainIds}&exclude_spam_tokens=true`;
-  if (process.env.NEXT_PUBLIC_DEVMODE_SHARED_SECRET) {
-    url += `&localkey=${process.env.NEXT_PUBLIC_DEVMODE_SHARED_SECRET}`;
-  }
+  const queryParams = new URLSearchParams();
+  queryParams.append("metadata", "logo");
+  queryParams.append("chain_ids", chainIds);
+  queryParams.append("exclude_spam_tokens", "true");
 
+  const url = buildSimduneUrl(`/v1/evm/balances/${address}`, queryParams);
   const response = await fetch(url);
 
   if (!response.ok) {
@@ -75,6 +77,29 @@ async function fetchSimBalance(address: string, chainIdsParam: number[]): Promis
   return balanceData;
 }
 
+async function fetchSimTokenBalance(
+  walletAddress: string,
+  tokenAddress: string,
+  chainId: number,
+): Promise<SimBalanceResponse> {
+  if (!walletAddress) throw new Error("Wallet address is required");
+  if (!tokenAddress) throw new Error("Token address is required");
+  if (!chainId) throw new Error("Chain ID is required");
+
+  const queryParams = new URLSearchParams();
+  queryParams.append("chain_ids", chainId.toString());
+
+  const url = buildSimduneUrl(`/v1/evm/balances/${walletAddress}/token/${tokenAddress}`, queryParams);
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch token balance: ${response.statusText}`);
+  }
+
+  const balanceData: SimBalanceResponse = await response.json();
+  return balanceData;
+}
+
 async function fetchSimSvmBalance(address: string, chains?: string[], limit?: number): Promise<SvmBalanceResponse> {
   if (!address) throw new Error("Address is required");
 
@@ -86,14 +111,7 @@ async function fetchSimSvmBalance(address: string, chains?: string[], limit?: nu
     queryParams.append("limit", limit.toString());
   }
 
-  let url = `https://simdune-api.sean-430.workers.dev/?url=https://api.sim.dune.com/beta/svm/balances/${address}`;
-  if (queryParams.toString()) {
-    url += `?${queryParams.toString()}`;
-  }
-  if (process.env.NEXT_PUBLIC_LOCAL_SIMDUNE_KEY) {
-    url += `${queryParams.toString() ? "&" : "?"}localkey=${process.env.NEXT_PUBLIC_LOCAL_SIMDUNE_KEY}`;
-  }
-
+  const url = buildSimduneUrl(`/beta/svm/balances/${address}`, queryParams.toString() ? queryParams : undefined);
   const response = await fetch(url);
 
   if (!response.ok) {
@@ -125,3 +143,22 @@ export function useSimSvmBalance(address?: string, chains?: ("solana" | "eclipse
     enabled: Boolean(address),
   });
 }
+
+/**
+ * Hook to fetch a single token balance for a wallet.
+ * @param walletAddress - The wallet address to fetch balance for
+ * @param tokenAddress - The token contract address, or "native" for native token (ETH, etc.)
+ * @param chainId - Chain ID to query (defaults to 1 for Ethereum mainnet)
+ */
+export function useSimTokenBalance(walletAddress?: string, tokenAddress?: string, chainId?: number) {
+  return useQuery({
+    queryKey: ["simTokenBalance", walletAddress, tokenAddress, chainId],
+    queryFn: () => {
+      if (!walletAddress || !tokenAddress || !chainId) {
+        throw new Error("Missing required parameters");
+      }
+      return fetchSimTokenBalance(walletAddress, tokenAddress, chainId);
+    },
+    enabled: Boolean(walletAddress) && Boolean(tokenAddress),
+  });
+}

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

@@ -0,0 +1,238 @@
+import type { NFT, SimpleHashNFTResponse } from "@b3dotfun/sdk/global-account/types/simplehash.types";
+import { useQuery } from "@tanstack/react-query";
+import { buildSimduneUrl } from "../utils/simdune";
+
+/**
+ * Safely parse a balance string to a number, capping at MAX_SAFE_INTEGER
+ * to prevent overflow issues with large ERC1155 balances.
+ */
+function safeParseBalance(balance: string | undefined): number {
+  if (!balance) return 1;
+  const parsed = parseInt(balance, 10);
+  if (Number.isNaN(parsed)) return 1;
+  return Math.min(parsed, Number.MAX_SAFE_INTEGER);
+}
+
+// Simdune Collectibles types
+export interface SimCollectibleMetadata {
+  uri: string;
+  attributes?: Array<{
+    trait_type: string;
+    value: string;
+    display_type?: string | null;
+  }>;
+}
+
+export interface SimCollectibleEntry {
+  contract_address: string;
+  token_standard: "ERC721" | "ERC1155";
+  token_id: string;
+  chain: string;
+  chain_id: number;
+  name?: string;
+  description?: string;
+  symbol?: string;
+  image_url?: string;
+  last_sale_price?: string;
+  metadata?: SimCollectibleMetadata;
+  is_spam?: boolean;
+  spam_score?: number;
+  explanations?: string[];
+  balance?: string;
+  last_acquired?: string;
+}
+
+export interface SimCollectiblesResponse {
+  address: string;
+  entries: SimCollectibleEntry[];
+  next_offset?: string;
+  request_time: string;
+  response_time: string;
+}
+
+async function fetchSimCollectibles(
+  address: string,
+  chainIdsParam?: number[],
+  options?: { limit?: number; filterSpam?: boolean },
+): Promise<SimCollectiblesResponse> {
+  if (!address) throw new Error("Address is required");
+
+  const queryParams = new URLSearchParams();
+  if (chainIdsParam && chainIdsParam.length > 0) {
+    queryParams.append("chain_ids", chainIdsParam.join(","));
+  }
+  if (options?.limit) {
+    queryParams.append("limit", options.limit.toString());
+  }
+  if (options?.filterSpam !== undefined) {
+    queryParams.append("filter_spam", options.filterSpam.toString());
+  }
+
+  const url = buildSimduneUrl(`/v1/evm/collectibles/${address}`, queryParams);
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch collectibles: ${response.statusText}`);
+  }
+
+  const data: SimCollectiblesResponse = await response.json();
+  return data;
+}
+
+/**
+ * Transforms Simdune collectibles response to SimpleHash NFT format
+ * for compatibility with existing AccountAssets component
+ */
+function transformToSimpleHashFormat(data: SimCollectiblesResponse): SimpleHashNFTResponse {
+  const nfts: NFT[] = data.entries.map(entry => ({
+    nft_id: `${entry.chain}.${entry.contract_address}.${entry.token_id}`,
+    chain: entry.chain,
+    contract_address: entry.contract_address,
+    token_id: entry.token_id,
+    name: entry.name || "",
+    description: entry.description || "",
+    previews: {
+      image_small_url: entry.image_url || "",
+      image_medium_url: entry.image_url || "",
+      image_large_url: entry.image_url || "",
+      image_opengraph_url: entry.image_url || "",
+      blurhash: "",
+      predominant_color: "",
+    },
+    image_url: entry.image_url || "",
+    image_properties: {
+      width: 0,
+      height: 0,
+      size: 0,
+      mime_type: "",
+      exif_orientation: null,
+    },
+    video_url: null,
+    video_properties: null,
+    audio_url: null,
+    audio_properties: null,
+    model_url: null,
+    model_properties: null,
+    other_url: null,
+    other_properties: null,
+    background_color: null,
+    external_url: null,
+    created_date: "",
+    status: "minted",
+    token_count: 1,
+    owner_count: 1,
+    owners: [
+      {
+        owner_address: data.address,
+        quantity: safeParseBalance(entry.balance),
+        quantity_string: entry.balance || "1",
+        first_acquired_date: entry.last_acquired || "",
+        last_acquired_date: entry.last_acquired || "",
+      },
+    ],
+    contract: {
+      type: entry.token_standard,
+      name: entry.name || "",
+      symbol: entry.symbol || null,
+      deployed_by: "",
+      deployed_via_contract: "",
+      owned_by: "",
+      has_multiple_collections: false,
+    },
+    collection: {
+      collection_id: entry.contract_address,
+      name: entry.symbol || "Unknown Collection",
+      description: null,
+      image_url: entry.image_url || "",
+      image_properties: {
+        width: 0,
+        height: 0,
+        mime_type: "",
+      },
+      banner_image_url: null,
+      category: null,
+      is_nsfw: null,
+      external_url: null,
+      twitter_username: null,
+      discord_url: null,
+      instagram_username: null,
+      medium_username: null,
+      telegram_url: null,
+      marketplace_pages: [],
+      metaplex_mint: null,
+      metaplex_candy_machine: null,
+      metaplex_first_verified_creator: null,
+      floor_prices: [],
+      top_bids: [],
+      distinct_owner_count: 0,
+      distinct_nft_count: 0,
+      total_quantity: 0,
+      chains: [entry.chain],
+      top_contracts: [entry.contract_address],
+      collection_royalties: [],
+    },
+    last_sale: entry.last_sale_price
+      ? {
+          price: entry.last_sale_price,
+        }
+      : null,
+    primary_sale: null,
+    first_created: {
+      minted_to: data.address,
+      quantity: 1,
+      quantity_string: "1",
+      timestamp: "",
+      block_number: 0,
+      transaction: "",
+      transaction_initiator: "",
+    },
+    rarity: {
+      rank: null,
+      score: null,
+      unique_attributes: null,
+    },
+    royalty: [],
+    extra_metadata: {
+      attributes: (entry.metadata?.attributes || []).map(attr => ({
+        trait_type: attr.trait_type,
+        value: attr.value,
+        display_type: attr.display_type ?? null,
+      })),
+      image_original_url: entry.image_url || "",
+      animation_original_url: null,
+      metadata_original_url: entry.metadata?.uri || "",
+    },
+  }));
+
+  return {
+    next_cursor: data.next_offset || null,
+    next: null,
+    previous: null,
+    nfts,
+  };
+}
+
+/**
+ * Hook to fetch NFT collectibles from Simdune API.
+ * Returns data in SimpleHash format for compatibility with AccountAssets component.
+ * @param address - Wallet address to fetch collectibles for
+ * @param chainIdsParam - Optional array of chain IDs to filter by
+ * @param options - Optional parameters (limit, filterSpam)
+ */
+export function useSimCollectibles(
+  address?: string,
+  chainIdsParam?: number[],
+  options?: { limit?: number; filterSpam?: boolean },
+) {
+  return useQuery({
+    queryKey: ["simCollectibles", address, chainIdsParam, options],
+    queryFn: async () => {
+      if (!address) throw new Error("Address is required");
+      const data = await fetchSimCollectibles(address, chainIdsParam, options);
+      return transformToSimpleHashFormat(data);
+    },
+    enabled: Boolean(address),
+    staleTime: 30 * 1000,
+    gcTime: 5 * 60 * 1000,
+  });
+}

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

@@ -1,12 +1,12 @@
 "use client";
 
 import { isNativeToken } from "@b3dotfun/sdk/anyspend";
-import { components } from "@b3dotfun/sdk/anyspend/types/api";
-import { useAccountWallet, useAuthStore } from "@b3dotfun/sdk/global-account/react";
+import { useB3, useAccountWallet } from "@b3dotfun/sdk/global-account/react";
 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";
+import { components } from "@b3dotfun/sdk/anyspend/types/api";
 
 interface UseTokenBalanceProps {
   token: components["schemas"]["Token"];
@@ -20,8 +20,7 @@ export interface TokenBalanceResult {
 }
 
 export function useTokenBalance({ token, address }: UseTokenBalanceProps): TokenBalanceResult {
-  const isAuthenticated = useAuthStore(state => state.isAuthenticated);
-
+  const { ready } = useB3();
   const account = useAccountWallet();
 
   const effectiveAddress = address || account?.address;
@@ -61,7 +60,7 @@ export function useTokenBalance({ token, address }: UseTokenBalanceProps): Token
       }
       return { formatted: "0", raw: null };
     },
-    enabled: isAuthenticated && !!effectiveAddress,
+    enabled: ready && !!effectiveAddress,
     staleTime: 30000,
     gcTime: 5 * 60 * 1000,
     retry: 2,
@@ -70,13 +69,13 @@ export function useTokenBalance({ token, address }: UseTokenBalanceProps): Token
 
   // Force a refetch when the wallet or token changes
   useEffect(() => {
-    if (isAuthenticated && effectiveAddress) {
+    if (ready && effectiveAddress) {
       refetch();
     }
-  }, [isAuthenticated, effectiveAddress, token.address, token.chainId, token.symbol, refetch]);
+  }, [ready, effectiveAddress, token.address, token.chainId, token.symbol, refetch]);
 
   // Determine if we're actually loading
-  const isActuallyLoading = !isAuthenticated || !effectiveAddress || isLoading || (isFetching && !tokenBalance);
+  const isActuallyLoading = !ready || !effectiveAddress || isLoading || (isFetching && !tokenBalance);
 
   return {
     rawBalance: tokenBalance?.raw || BigInt(0),

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

@@ -2,7 +2,7 @@ import { TurnkeyAuthInitResponse } from "@b3dotfun/b3-api";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { useCallback, useState } from "react";
 import app from "../../app";
-import { useB3Config } from "../components";
+import { useB3 } from "../components";
 import { useAuthStore } from "../stores";
 import { useAuth } from "./useAuth";
 
@@ -33,7 +33,7 @@ export function useTurnkeyAuth(): UseTurnkeyAuthReturn {
   const [error, setError] = useState<string | null>(null);
   const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
   const setIsAuthenticated = useAuthStore(state => state.setIsAuthenticated);
-  const { partnerId } = useB3Config();
+  const { partnerId } = useB3();
   const { authenticate } = useAuth();
 
   /**