@b3dotfun/sdk 0.1.70-alpha.2 → 0.1.70-alpha.21

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

@@ -7,6 +7,7 @@ export { RelayKitProviderWrapper } from "./B3Provider/RelayKitProviderWrapper";
 export { useB3 } from "./B3Provider/useB3";
 export { useB3Account } from "./B3Provider/useB3Account";
 export { useB3Config } from "./B3Provider/useB3Config";
+export { B3ConfigPartnerOverride } from "./B3Provider/B3ConfigProvider";
 export { StyleRoot } from "./StyleRoot";
 
 // SignInWithB3 Components
@@ -22,7 +23,6 @@ export { PermissionItem } from "./SignInWithB3/components/PermissionItem";
 export { WalletRow } from "./SignInWithB3/components/WalletRow";
 export { SignInWithB3 } from "./SignInWithB3/SignInWithB3";
 export { SignInWithB3Flow } from "./SignInWithB3/SignInWithB3Flow";
-export { SignInWithB3Privy } from "./SignInWithB3/SignInWithB3Privy";
 export { LoginStepContainer } from "./SignInWithB3/steps/LoginStep";
 export { getConnectOptionsFromStrategy, isWalletType, type AllowedStrategy } from "./SignInWithB3/utils/signInUtils";
 

package/src/global-account/react/components/ui/button.tsx

@@ -32,8 +32,7 @@ const buttonVariants = cva(
 );
 
 export interface ButtonProps
-  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
-    VariantProps<typeof buttonVariants> {
+  extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
   asChild?: boolean;
 }
 

package/src/global-account/react/hooks/__tests__/useUnifiedChainSwitchAndExecute.test.tsx

@@ -0,0 +1,156 @@
+import { act, renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { useUnifiedChainSwitchAndExecute } from "../useUnifiedChainSwitchAndExecute";
+
+const mocks = vi.hoisted(() => ({
+  eoaGetAccount: vi.fn(),
+  globalAccountGetAccount: vi.fn(),
+  intentCreate: vi.fn(),
+  prepareTransaction: vi.fn(),
+  sendTransaction: vi.fn(),
+  toastError: vi.fn(),
+  toastInfo: vi.fn(),
+  toastSuccess: vi.fn(),
+  useAccountWallet: vi.fn(),
+}));
+
+vi.mock("@b3dotfun/sdk/anyspend", () => ({
+  getChainName: (chainId: number) => `Chain ${chainId}`,
+  getNativeToken: () => ({ name: "Ether", symbol: "ETH", decimals: 18 }),
+}));
+
+vi.mock("@b3dotfun/sdk/global-account/app", () => ({
+  default: {
+    service: () => ({ create: mocks.intentCreate }),
+  },
+}));
+
+vi.mock("@b3dotfun/sdk/global-account/react", () => ({
+  toast: {
+    dismiss: vi.fn(),
+    error: mocks.toastError,
+    info: mocks.toastInfo,
+    success: mocks.toastSuccess,
+  },
+}));
+
+vi.mock("@b3dotfun/sdk/shared/constants/chains/supported", () => ({
+  getThirdwebChain: (chainId: number) => ({ id: chainId }),
+  supportedChains: [],
+}));
+
+vi.mock("@b3dotfun/sdk/shared/utils/thirdweb", () => ({ client: {} }));
+
+vi.mock("thirdweb", () => ({
+  prepareTransaction: mocks.prepareTransaction,
+  sendTransaction: mocks.sendTransaction,
+}));
+
+vi.mock("viem", () => ({ isAddress: () => true }));
+
+vi.mock("wagmi", () => ({
+  useSwitchChain: () => ({ switchChainAsync: vi.fn() }),
+}));
+
+vi.mock("../../components/B3Provider/B3ConfigProvider", () => ({
+  useB3Config: () => ({ partnerId: "test-partner" }),
+}));
+
+vi.mock("../useAccountWallet", () => ({
+  useAccountWallet: mocks.useAccountWallet,
+}));
+
+const GLOBAL_ACCOUNT_ADDRESS = "0x1111111111111111111111111111111111111111";
+const OTHER_GLOBAL_ACCOUNT_ADDRESS = "0x2222222222222222222222222222222222222222";
+const EOA_ADDRESS = "0x3333333333333333333333333333333333333333";
+const TRANSACTION_HASH = `0x${"a".repeat(64)}`;
+
+const globalAccount = { address: GLOBAL_ACCOUNT_ADDRESS };
+const preparedTransaction = { prepared: true };
+const transactionParams = {
+  to: "0x4444444444444444444444444444444444444444",
+  data: "0x1234",
+  value: BigInt(0),
+};
+
+describe("useUnifiedChainSwitchAndExecute", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mocks.globalAccountGetAccount.mockReturnValue(globalAccount);
+    mocks.eoaGetAccount.mockReturnValue({ address: EOA_ADDRESS });
+    mocks.intentCreate.mockResolvedValue({});
+    mocks.prepareTransaction.mockReturnValue(preparedTransaction);
+    mocks.sendTransaction.mockResolvedValue({ transactionHash: TRANSACTION_HASH });
+    mocks.useAccountWallet.mockReturnValue({
+      connectedSmartWallet: { getAccount: mocks.globalAccountGetAccount },
+      connectedEOAWallet: { getAccount: mocks.eoaGetAccount },
+      isActiveSmartWallet: false,
+      isActiveEOAWallet: true,
+    });
+  });
+
+  it("uses the connected Global Account even when the EOA wallet is active", async () => {
+    const { result } = renderHook(() => useUnifiedChainSwitchAndExecute());
+
+    let transactionHash: string | undefined;
+    await act(async () => {
+      transactionHash = await result.current.switchChainAndExecuteWithGlobalAccount(
+        8453,
+        transactionParams,
+        GLOBAL_ACCOUNT_ADDRESS,
+      );
+    });
+
+    expect(transactionHash).toBe(TRANSACTION_HASH);
+    expect(mocks.globalAccountGetAccount).toHaveBeenCalledOnce();
+    expect(mocks.eoaGetAccount).not.toHaveBeenCalled();
+    expect(mocks.sendTransaction).toHaveBeenCalledWith({
+      account: globalAccount,
+      transaction: preparedTransaction,
+    });
+  });
+
+  it("rejects a signer that does not match the authenticated Global Account", async () => {
+    const { result } = renderHook(() => useUnifiedChainSwitchAndExecute());
+
+    let transactionHash: string | undefined;
+    await act(async () => {
+      transactionHash = await result.current.switchChainAndExecuteWithGlobalAccount(
+        8453,
+        transactionParams,
+        OTHER_GLOBAL_ACCOUNT_ADDRESS,
+      );
+    });
+
+    expect(transactionHash).toBeUndefined();
+    expect(mocks.toastError).toHaveBeenCalledWith("Connected Global Account does not match the authenticated account");
+    expect(mocks.prepareTransaction).not.toHaveBeenCalled();
+    expect(mocks.sendTransaction).not.toHaveBeenCalled();
+    expect(mocks.eoaGetAccount).not.toHaveBeenCalled();
+  });
+
+  it("fails closed when no Global Account signer is connected", async () => {
+    mocks.useAccountWallet.mockReturnValue({
+      connectedSmartWallet: undefined,
+      connectedEOAWallet: { getAccount: mocks.eoaGetAccount },
+      isActiveSmartWallet: false,
+      isActiveEOAWallet: true,
+    });
+    const { result } = renderHook(() => useUnifiedChainSwitchAndExecute());
+
+    let transactionHash: string | undefined;
+    await act(async () => {
+      transactionHash = await result.current.switchChainAndExecuteWithGlobalAccount(
+        8453,
+        transactionParams,
+        GLOBAL_ACCOUNT_ADDRESS,
+      );
+    });
+
+    expect(transactionHash).toBeUndefined();
+    expect(mocks.toastError).toHaveBeenCalledWith("Global Account not connected");
+    expect(mocks.sendTransaction).not.toHaveBeenCalled();
+    expect(mocks.eoaGetAccount).not.toHaveBeenCalled();
+  });
+});

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

@@ -17,7 +17,6 @@ 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";
 export { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect";
@@ -40,8 +39,8 @@ export { useQueryBSMNT } from "./useQueryBSMNT";
 export { useRemoveSessionKey } from "./useRemoveSessionKey";
 export { useRouter } from "./useRouter";
 export { useSearchParamsSSR } from "./useSearchParamsSSR";
-export { useSimBalance, useSimSvmBalance, useSimTokenBalance } from "./useSimBalance";
-export { useSimCollectibles } from "./useSimCollectibles";
+export { usePortfolioBalance, usePortfolioTokenBalance } from "./usePortfolioBalance";
+export { usePortfolioCollectibles } from "./usePortfolioCollectibles";
 export { useSiwe } from "./useSiwe";
 export { useTokenBalance } from "./useTokenBalance";
 export { useTokenBalanceDirect } from "./useTokenBalanceDirect";

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

@@ -1,7 +1,7 @@
 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 { ecosystemWalletId } from "@b3dotfun/sdk/shared/constants";
+import { ecosystemWalletId, type EcosystemWallet } from "@b3dotfun/sdk/shared/constants";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
 import { ConnectionOptions } from "@thirdweb-dev/wagmi-adapter";
@@ -54,7 +54,8 @@ export function useAuth() {
   const { user, setUser } = useUserQuery();
   debug("@@activeWagmiAccount", activeWagmiAccount);
 
-  const wallet = ecosystemWallet(ecosystemWalletId, {
+  // Explicit annotation keeps the hook's declaration portable (TS2742).
+  const wallet: EcosystemWallet = ecosystemWallet(ecosystemWalletId, {
     partnerId: partnerId,
   });
 
@@ -62,7 +63,7 @@ export function useAuth() {
    * Re-authenticate using existing session
    * Also updates user state and authenticates with BSMNT
    */
-  const reAuthenticate = useCallback(async () => {
+  const reAuthenticate = useCallback(async (): Promise<Record<string, any>> => {
     debug("Re-authenticating...");
     try {
       const response = await app.reAuthenticate();
@@ -191,7 +192,7 @@ export function useAuth() {
    * 3. Authenticates with BSMNT for basement integration
    */
   const authenticate = useCallback(
-    async (accessToken: string, partnerId: string, strategy = "thirdweb-jwt") => {
+    async (accessToken: string, partnerId: string, strategy = "thirdweb-jwt"): Promise<Record<string, any>> => {
       if (!accessToken) {
         throw new Error("Access token is required");
       }

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

@@ -1,7 +1,7 @@
 import app from "@b3dotfun/sdk/global-account/app";
 import { authenticateWithB3JWT } from "@b3dotfun/sdk/global-account/bsmnt";
 import { useAuthStore } from "@b3dotfun/sdk/global-account/react";
-import { ecosystemWalletId } from "@b3dotfun/sdk/shared/constants";
+import { ecosystemWalletId, type EcosystemWallet } from "@b3dotfun/sdk/shared/constants";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
 import { ConnectionOptions } from "@thirdweb-dev/wagmi-adapter";
@@ -63,7 +63,8 @@ export function useAuthentication(partnerId: string, { skipAutoConnect = false }
   const { switchAccount } = useSwitchAccount();
   debug("@@activeWagmiAccount", activeWagmiAccount);
 
-  const wallet = ecosystemWallet(ecosystemWalletId, {
+  // Explicit annotation keeps the hook's declaration portable (TS2742).
+  const wallet: EcosystemWallet = ecosystemWallet(ecosystemWalletId, {
     partnerId: partnerId,
   });
 
@@ -120,7 +121,7 @@ export function useAuthentication(partnerId: string, { skipAutoConnect = false }
   }, [wallets, syncWagmi]);
 
   const authenticateUser = useCallback(
-    async (wallet?: Wallet) => {
+    async (wallet?: Wallet): Promise<Record<string, any>> => {
       setHasStartedConnecting(true);
 
       if (!wallet) {
@@ -216,7 +217,7 @@ export function useAuthentication(partnerId: string, { skipAutoConnect = false }
         localStorage.removeItem("b3-user");
       }
 
-      app.logout();
+      await app.logout();
       debug("@@logout:loggedOut");
 
       setIsAuthenticated(false);

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

@@ -2,12 +2,12 @@ import app from "@b3dotfun/sdk/global-account/app";
 import { useAuthStore, useB3Config } from "@b3dotfun/sdk/global-account/react";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { useCallback } from "react";
-import { betterAuthClient } from "../../better-auth-client";
+import { getBetterAuthClient } from "../../better-auth-client";
 import { useUserQuery } from "./useUserQuery";
 
 const debug = debugB3React("useBetterAuth");
 
-export type BetterAuthSocialProvider = "google" | "discord" | "apple" | "github" | "slack" | "microsoft";
+export type BetterAuthSocialProvider = "google" | "discord" | "apple" | "github" | "slack" | "microsoft" | "twitter";
 
 /** Thrown when email verification is required before the user can sign in. */
 export class EmailVerificationRequiredError extends Error {
@@ -34,7 +34,7 @@ export function useBetterAuth() {
   const setHasStartedConnecting = useAuthStore(state => state.setHasStartedConnecting);
 
   const exchangeForFeathersJWT = useCallback(
-    async (sessionToken: string) => {
+    async (sessionToken: string): Promise<Record<string, any>> => {
       debug("Exchanging Better Auth token for Feathers JWT");
 
       const response = await app.authenticate({
@@ -65,7 +65,7 @@ export function useBetterAuth() {
       setIsAuthenticating(true);
 
       try {
-        const result = await betterAuthClient.signIn.email({ email, password });
+        const result = await getBetterAuthClient().signIn.email({ email, password });
 
         if (result.error) {
           throw new Error(result.error.message || "Sign in failed");
@@ -93,7 +93,7 @@ export function useBetterAuth() {
       setIsAuthenticating(true);
 
       try {
-        const result = await betterAuthClient.signUp.email({ email, password, name });
+        const result = await getBetterAuthClient().signUp.email({ email, password, name });
 
         if (result.error) {
           throw new Error(result.error.message || "Sign up failed");
@@ -104,7 +104,7 @@ export function useBetterAuth() {
           // requireEmailVerification is enabled — send verification email with
           // a callbackURL Better Auth redirects to after server-side verify.
           // Pass verifyCallbackURL to land on a dedicated confirmation page.
-          await betterAuthClient.sendVerificationEmail({
+          await getBetterAuthClient().sendVerificationEmail({
             email,
             callbackURL: verifyCallbackURL || `${window.location.origin}?authStrategy=better-auth`,
           });
@@ -128,7 +128,7 @@ export function useBetterAuth() {
       setIsAuthenticating(true);
 
       try {
-        const result = await betterAuthClient.signIn.social({
+        const result = await getBetterAuthClient().signIn.social({
           provider,
           callbackURL: window.location.href,
         });
@@ -151,7 +151,7 @@ export function useBetterAuth() {
   const requestPasswordReset = useCallback(async (email: string, redirectTo?: string) => {
     debug("Requesting password reset", { email });
 
-    const result = await betterAuthClient.requestPasswordReset({
+    const result = await getBetterAuthClient().requestPasswordReset({
       email,
       redirectTo,
     });
@@ -167,7 +167,7 @@ export function useBetterAuth() {
   const resetPassword = useCallback(async (newPassword: string, token: string) => {
     debug("Resetting password");
 
-    const result = await betterAuthClient.resetPassword({
+    const result = await getBetterAuthClient().resetPassword({
       newPassword,
       token,
     });
@@ -187,6 +187,6 @@ export function useBetterAuth() {
     requestPasswordReset,
     resetPassword,
     exchangeForFeathersJWT,
-    betterAuthClient,
+    betterAuthClient: getBetterAuthClient(),
   };
 }

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

@@ -28,14 +28,23 @@ export function useClient() {
   }, []);
 
   const authenticateWithType = useCallback(
-    async (type: ClientType, accessToken: string, identityToken: string, params?: Record<string, any>) => {
+    async (
+      type: ClientType,
+      accessToken: string,
+      identityToken: string,
+      params?: Record<string, any>,
+    ): Promise<Record<string, any> | null> => {
       return authenticateWithClient(type, accessToken, identityToken, params);
     },
     [],
   );
 
   const authenticateWithBoth = useCallback(
-    async (accessToken: string, identityToken: string, params?: Record<string, any>) => {
+    async (
+      accessToken: string,
+      identityToken: string,
+      params?: Record<string, any>,
+    ): Promise<{ socket: Record<string, any> | null; rest: Record<string, any> | null; success: boolean }> => {
       return authenticateBoth(accessToken, identityToken, params);
     },
     [],

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

@@ -5,10 +5,17 @@ import { useEffect, useMemo, useState } from "react";
 import { viemAdapter } from "thirdweb/adapters/viem";
 import { useConnectedWallets, useWalletInfo } from "thirdweb/react";
 import { Wallet } from "thirdweb/wallets";
+import type { WalletClient } from "viem";
 
 const debug = debugB3React("useFirstEOA");
 
-export function useFirstEOA(chain?: { id: number; name: string; rpc: string }) {
+// Explicit return annotation keeps the hook's declaration portable (TS2742).
+export function useFirstEOA(chain?: { id: number; name: string; rpc: string }): {
+  account: Wallet | undefined;
+  address: string | undefined;
+  info: ReturnType<typeof useWalletInfo>;
+  walletClient: WalletClient | undefined;
+} {
   const wallets = useConnectedWallets();
   const isConnected = useAuthStore(state => state.isConnected);
   const [firstEOA, setFirstEOA] = useState<Wallet | undefined>(undefined);
@@ -41,7 +48,7 @@ export function useFirstEOA(chain?: { id: number; name: string; rpc: string }) {
     autoSelectFirstEOAWallet();
   }, [isConnected, wallets]);
 
-  const walletClient = useMemo(() => {
+  const walletClient = useMemo<WalletClient | undefined>(() => {
     if (!firstEOA) return undefined;
     if (!chain) return undefined;
     try {

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

@@ -1,6 +1,6 @@
 import { toast } from "@b3dotfun/sdk/global-account/react";
 import { PUBLIC_BASE_RPC_URL } from "@b3dotfun/sdk/shared/constants";
-import { b3Mainnet, b3Testnet } from "@b3dotfun/sdk/shared/constants/chains/supported";
+import { b3Mainnet, b3Testnet } from "@b3dotfun/sdk/shared/constants/chains/b3Chain";
 import { formatNumber } from "@b3dotfun/sdk/shared/utils/formatNumber";
 import { useQuery } from "@tanstack/react-query";
 

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

@@ -0,0 +1,89 @@
+import { useQuery } from "@tanstack/react-query";
+import {
+  adaptZerionPositions,
+  balanceMatchesToken,
+  type B3TokenBalance,
+  type ZerionPositionLike,
+} from "@b3dotfun/sdk/shared/utils/zerionPositions";
+
+/**
+ * Wallet holdings, read through the b3 portfolio proxy.
+ *
+ * The proxy holds the upstream API key server-side and authorizes browsers by Origin allowlist, so
+ * nothing secret ships to the client and no key is accepted from it. A consumer served from an
+ * origin the proxy does not know will be refused — adding an origin is a proxy config change, not
+ * an SDK change.
+ */
+const PORTFOLIO_API_BASE_URL = "https://portfolio-api.b3.fun";
+
+interface ZerionPositionsResponse {
+  data?: ZerionPositionLike[];
+}
+
+/**
+ * Fetch every spendable holding for a wallet in one request.
+ *
+ * Deliberately unpaginated and unfiltered by chain. The positions endpoint returns a wallet's full
+ * simple-position list in a single response, and passing a chain filter is actively harmful: the
+ * upstream rejects a handful of otherwise-valid chain slugs and fails the WHOLE request when one
+ * appears, so a caller asking for five chains can lose all five. Callers narrow the result instead.
+ */
+async function fetchWalletPositions(address: string): Promise<B3TokenBalance[]> {
+  const url = `${PORTFOLIO_API_BASE_URL}/v1/wallets/${encodeURIComponent(address)}/positions/?filter[positions]=only_simple`;
+  const response = await fetch(url, { headers: { Accept: "application/json" } });
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch wallet balances: ${response.status} ${response.statusText}`);
+  }
+
+  const body = (await response.json()) as ZerionPositionsResponse;
+  return adaptZerionPositions(body.data ?? []);
+}
+
+/**
+ * Keyed by wallet alone so every consumer of the same wallet shares one fetch and one cache entry.
+ * Keying by the requested chain subset instead would refetch per caller and share nothing.
+ */
+function walletPositionsQueryKey(address?: string) {
+  return ["walletPositions", address] as const;
+}
+
+/**
+ * Holdings for a wallet, optionally narrowed to specific chains.
+ *
+ * Read `isError` before reading `data`: a failed read and an empty wallet are different facts, and
+ * rendering the first as the second tells the user they hold nothing when nobody knows.
+ */
+export function usePortfolioBalance(address?: string, chainIds?: number[]) {
+  const wantedChainIds = chainIds && chainIds.length > 0 ? chainIds : undefined;
+
+  return useQuery({
+    queryKey: walletPositionsQueryKey(address),
+    queryFn: () => {
+      if (!address) throw new Error("Address is required");
+      return fetchWalletPositions(address);
+    },
+    enabled: Boolean(address),
+    select: (balances: B3TokenBalance[]) =>
+      wantedChainIds ? balances.filter(balance => wantedChainIds.includes(balance.chain_id)) : balances,
+  });
+}
+
+/**
+ * One token's balance for a wallet, served from the same per-wallet fetch as {@link usePortfolioBalance}.
+ *
+ * `tokenAddress` may be a contract address or the chain's native sentinel; matching is
+ * case-insensitive because callers pass addresses in whatever casing their source used.
+ */
+export function usePortfolioTokenBalance(walletAddress?: string, tokenAddress?: string, chainId?: number) {
+  return useQuery({
+    queryKey: walletPositionsQueryKey(walletAddress),
+    queryFn: () => {
+      if (!walletAddress) throw new Error("Address is required");
+      return fetchWalletPositions(walletAddress);
+    },
+    enabled: Boolean(walletAddress) && Boolean(tokenAddress) && Boolean(chainId),
+    select: (balances: B3TokenBalance[]) =>
+      balances.find(balance => balance.chain_id === chainId && balanceMatchesToken(balance, tokenAddress ?? "")),
+  });
+}