@b3dotfun/sdk 0.1.69 → 0.1.70-alpha.10

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

@@ -6,7 +6,7 @@ import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
 import { ConnectionOptions } from "@thirdweb-dev/wagmi-adapter";
 import { getConnectors } from "@wagmi/core";
-import { useCallback, useContext, useEffect, useRef } from "react";
+import { useCallback, useContext, useEffect, useMemo, useRef } from "react";
 import {
   useActiveWallet,
   useAutoConnect,
@@ -18,7 +18,7 @@ import { Wallet, ecosystemWallet } from "thirdweb/wallets";
 import { preAuthenticate } from "thirdweb/wallets/in-app";
 import { useAccount, useConnect, useSwitchAccount } from "wagmi";
 import { LocalSDKContext } from "../components/B3Provider/LocalSDKProvider";
-import { getCachedWagmiConfig } from "../utils/createWagmiConfig";
+import { createWagmiConfig } from "../utils/createWagmiConfig";
 import { useSearchParam } from "./useSearchParamsSSR";
 import { useUserQuery } from "./useUserQuery";
 
@@ -30,7 +30,7 @@ const debug = debugB3React("useAuth");
  * This hook provides 1:1 feature parity with useAuthentication.ts
  */
 export function useAuth() {
-  const { onConnectCallback } = useContext(LocalSDKContext);
+  const { onConnectCallback, disableBSMNTAuthentication } = useContext(LocalSDKContext);
   const { disconnect } = useDisconnect();
   const wallets = useConnectedWallets();
   const activeWallet = useActiveWallet();
@@ -47,7 +47,7 @@ export function useAuth() {
   const useAutoConnectLoadingPrevious = useRef(false);
   const referralCode = useSearchParam("referralCode");
   const { partnerId } = useB3Config();
-  const wagmiConfig = getCachedWagmiConfig({ partnerId });
+  const wagmiConfig = useMemo(() => createWagmiConfig({ partnerId }), [partnerId]);
   const { connect } = useConnect();
   const activeWagmiAccount = useAccount();
   const { switchAccount } = useSwitchAccount();
@@ -62,7 +62,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();
@@ -76,8 +76,10 @@ export function useAuth() {
 
       // Authenticate with BSMNT
       try {
-        const b3Jwt = await authenticateWithB3JWT(response.accessToken);
-        debug("BSMNT re-authentication successful", b3Jwt);
+        if (!disableBSMNTAuthentication) {
+          const b3Jwt = await authenticateWithB3JWT(response.accessToken);
+          debug("BSMNT re-authentication successful", b3Jwt);
+        }
       } catch (bsmntError) {
         // BSMNT authentication failure shouldn't block the main auth flow
         debug("BSMNT re-authentication failed (non-critical)", bsmntError);
@@ -88,7 +90,7 @@ export function useAuth() {
       debug("Re-authentication failed", err);
       throw err;
     }
-  }, [setUser]);
+  }, [setUser, disableBSMNTAuthentication]);
 
   const syncWagmi = useCallback(async () => {
     function syncWagmiFunc() {
@@ -136,9 +138,7 @@ export function useAuth() {
       });
     }
     syncWagmiFunc();
-    // wagmi config shouldn't change
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [partnerId, wallets]);
+  }, [wagmiConfig, wallets, connect, switchAccount]);
 
   useEffect(() => {
     syncWagmi();
@@ -159,9 +159,11 @@ export function useAuth() {
       setIsAuthenticating(false);
       debug("Re-authenticated successfully", { userAuth });
 
-      // Authenticate on BSMNT with B3 JWT
-      const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
-      debug("@@b3Jwt", b3Jwt);
+      if (!disableBSMNTAuthentication) {
+        // Authenticate on BSMNT with B3 JWT
+        const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
+        debug("@@b3Jwt", b3Jwt);
+      }
 
       return userAuth;
     } catch (error) {
@@ -171,7 +173,14 @@ export function useAuth() {
       setIsAuthenticating(false);
       throw new Error("Authentication required. Please authenticate.");
     }
-  }, [reAuthenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting]);
+  }, [
+    reAuthenticate,
+    setIsAuthenticated,
+    setIsAuthenticating,
+    setUser,
+    setHasStartedConnecting,
+    disableBSMNTAuthentication,
+  ]);
 
   /**
    * Authenticate with B3
@@ -182,7 +191,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");
       }
@@ -208,8 +217,10 @@ export function useAuth() {
 
         // Step 3: Authenticate with BSMNT for basement integration
         try {
-          const b3Jwt = await authenticateWithB3JWT(response.accessToken);
-          debug("BSMNT authentication successful", b3Jwt);
+          if (!disableBSMNTAuthentication) {
+            const b3Jwt = await authenticateWithB3JWT(response.accessToken);
+            debug("BSMNT authentication successful", b3Jwt);
+          }
         } catch (bsmntError) {
           // BSMNT authentication failure shouldn't block the main auth flow
           debug("BSMNT authentication failed (non-critical)", bsmntError);
@@ -221,7 +232,7 @@ export function useAuth() {
         throw err;
       }
     },
-    [referralCode, setUser],
+    [referralCode, setUser, disableBSMNTAuthentication],
   );
 
   /**

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

@@ -6,7 +6,7 @@ import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
 import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
 import { ConnectionOptions } from "@thirdweb-dev/wagmi-adapter";
 import { getConnectors } from "@wagmi/core";
-import { useCallback, useContext, useEffect, useRef } from "react";
+import { useCallback, useContext, useEffect, useMemo, useRef } from "react";
 import {
   useActiveWallet,
   useAutoConnect,
@@ -25,7 +25,7 @@ import { useUserQuery } from "./useUserQuery";
 const debug = debugB3React("useAuthentication");
 
 export function useAuthentication(partnerId: string, { skipAutoConnect = false }: { skipAutoConnect?: boolean } = {}) {
-  const { onConnectCallback, onLogoutCallback } = useContext(LocalSDKContext);
+  const { onConnectCallback, onLogoutCallback, disableBSMNTAuthentication } = useContext(LocalSDKContext);
   const { disconnect } = useDisconnect();
   const wallets = useConnectedWallets();
   // Keep refs so logout() always disconnects current wallets, not stale closure values.
@@ -57,7 +57,7 @@ export function useAuthentication(partnerId: string, { skipAutoConnect = false }
   const { authenticate } = useTWAuth();
   const { user, setUser } = useUserQuery();
   const useAutoConnectLoadingPrevious = useRef(false);
-  const wagmiConfig = createWagmiConfig({ partnerId });
+  const wagmiConfig = useMemo(() => createWagmiConfig({ partnerId }), [partnerId]);
   const { connect } = useConnect();
   const activeWagmiAccount = useAccount();
   const { switchAccount } = useSwitchAccount();
@@ -113,16 +113,14 @@ export function useAuthentication(partnerId: string, { skipAutoConnect = false }
       });
     }
     syncWagmiFunc();
-    // wagmi config shouldn't change
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [partnerId, wallets]);
+  }, [wagmiConfig, wallets, connect, switchAccount]);
 
   useEffect(() => {
     syncWagmi();
   }, [wallets, syncWagmi]);
 
   const authenticateUser = useCallback(
-    async (wallet?: Wallet) => {
+    async (wallet?: Wallet): Promise<Record<string, any>> => {
       setHasStartedConnecting(true);
 
       if (!wallet) {
@@ -142,9 +140,11 @@ export function useAuthentication(partnerId: string, { skipAutoConnect = false }
         setIsAuthenticating(false);
         debug("Re-authenticated successfully", { userAuth });
 
-        // Authenticate on BSMNT with B3 JWT
-        const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
-        debug("@@b3Jwt", b3Jwt);
+        if (!disableBSMNTAuthentication) {
+          // Authenticate on BSMNT with B3 JWT
+          const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
+          debug("@@b3Jwt", b3Jwt);
+        }
 
         return userAuth;
       } catch (error) {
@@ -156,14 +156,25 @@ export function useAuthentication(partnerId: string, { skipAutoConnect = false }
         setIsAuthenticating(false);
         debug("Fresh authentication successful", { userAuth });
 
-        // Authenticate on BSMNT with B3 JWT
-        const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
-        debug("@@b3Jwt", b3Jwt);
+        if (!disableBSMNTAuthentication) {
+          // Authenticate on BSMNT with B3 JWT
+          const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
+          debug("@@b3Jwt", b3Jwt);
+        }
 
         return userAuth;
       }
     },
-    [activeWallet, partnerId, authenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting],
+    [
+      activeWallet,
+      partnerId,
+      authenticate,
+      setIsAuthenticated,
+      setIsAuthenticating,
+      setUser,
+      setHasStartedConnecting,
+      disableBSMNTAuthentication,
+    ],
   );
 
   const logout = useCallback(
@@ -205,7 +216,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/useAutoSelectWallet.ts

@@ -1,19 +1,53 @@
+import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
-import { useCallback, useEffect } from "react";
-import { getLastAuthProvider, useConnectedWallets, useSetActiveWallet } from "thirdweb/react";
-import { Wallet } from "thirdweb/wallets";
+import { useCallback, useEffect, useRef } from "react";
+import { getLastAuthProvider, useAddConnectedWallet, useConnectedWallets, useSetActiveWallet } from "thirdweb/react";
+import { EIP1193, Wallet } from "thirdweb/wallets";
 import { useAuthStore } from "../stores";
 
 const debug = debugB3React("useAutoSelectWallet");
 
 /**
- * Hook to automatically select the first EOA wallet when user is authenticated
- * Only auto-selects if the last auth was via wallet or no previous auth provider
+ * Hook to automatically connect a default EOA provider (if given) and
+ * select the first EOA wallet when user is authenticated.
+ * Only auto-selects if the last auth was via wallet or no previous auth provider.
  */
-export function useAutoSelectWallet({ enabled }: { enabled: boolean }) {
+export function useAutoSelectWallet({
+  enabled,
+  defaultEoaProvider,
+}: {
+  enabled: boolean;
+  defaultEoaProvider?: EIP1193.EIP1193Provider;
+}) {
   const isAuthenticated = useAuthStore(state => state.isAuthenticated);
   const wallets = useConnectedWallets();
   const setActiveWallet = useSetActiveWallet();
+  const addConnectedWallet = useAddConnectedWallet();
+  const hasConnectedProvider = useRef(false);
+
+  // Auto-connect the default EOA provider (e.g. Farcaster frame wallet) on mount.
+  // Uses useAddConnectedWallet instead of useConnect so the wallet is added to
+  // connectedWallets WITHOUT becoming the active wallet. This prevents
+  // useAuthentication's logout/onTimeout from disconnecting it (logout only
+  // disconnects ecosystem wallets and the active wallet).
+  useEffect(() => {
+    if (!defaultEoaProvider || hasConnectedProvider.current) return;
+    hasConnectedProvider.current = true;
+
+    const connectDefaultProvider = async () => {
+      try {
+        const wallet = EIP1193.fromProvider({ provider: defaultEoaProvider });
+        await wallet.connect({ client });
+        addConnectedWallet(wallet);
+        debug("Auto-connected default EOA provider", wallet.id);
+      } catch (error) {
+        debug("Failed to auto-connect default EOA provider", error);
+        hasConnectedProvider.current = false;
+      }
+    };
+
+    connectDefaultProvider();
+  }, [defaultEoaProvider, addConnectedWallet]);
 
   const setWallet = useCallback(
     (wallet: Wallet) => {

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

@@ -0,0 +1,192 @@
+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 { getBetterAuthClient } from "../../better-auth-client";
+import { useUserQuery } from "./useUserQuery";
+
+const debug = debugB3React("useBetterAuth");
+
+export type BetterAuthSocialProvider = "google" | "discord" | "apple" | "github" | "slack" | "microsoft";
+
+/** Thrown when email verification is required before the user can sign in. */
+export class EmailVerificationRequiredError extends Error {
+  constructor(message = "Check your email to verify your account before signing in.") {
+    super(message);
+    this.name = "EmailVerificationRequiredError";
+  }
+}
+
+/**
+ * Hook for authentication via Better Auth (email/password + social providers).
+ *
+ * Follows the same pattern as Thirdweb auth:
+ * 1. Better Auth sign-in returns a session token
+ * 2. Token is passed as accessToken to app.authenticate({ strategy: "better-auth" })
+ * 3. BetterAuthStrategy verifies the token and issues a Feathers JWT
+ */
+export function useBetterAuth() {
+  const { partnerId } = useB3Config();
+  const { setUser } = useUserQuery();
+  const setIsAuthenticated = useAuthStore(state => state.setIsAuthenticated);
+  const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
+  const setIsConnected = useAuthStore(state => state.setIsConnected);
+  const setHasStartedConnecting = useAuthStore(state => state.setHasStartedConnecting);
+
+  const exchangeForFeathersJWT = useCallback(
+    async (sessionToken: string): Promise<Record<string, any>> => {
+      debug("Exchanging Better Auth token for Feathers JWT");
+
+      const response = await app.authenticate({
+        strategy: "better-auth",
+        accessToken: sessionToken,
+        partnerId,
+      } as any);
+
+      if (!response.user) {
+        throw new Error("No user returned from authentication");
+      }
+
+      setUser(response.user);
+      setIsAuthenticated(true);
+      setIsConnected(true);
+      setIsAuthenticating(false);
+
+      debug("Feathers JWT exchange successful", { userId: response.user?.userId });
+      return response;
+    },
+    [partnerId, setUser, setIsAuthenticated, setIsConnected, setIsAuthenticating],
+  );
+
+  const signInWithEmail = useCallback(
+    async (email: string, password: string) => {
+      debug("Signing in with email", { email });
+      setHasStartedConnecting(true);
+      setIsAuthenticating(true);
+
+      try {
+        const result = await getBetterAuthClient().signIn.email({ email, password });
+
+        if (result.error) {
+          throw new Error(result.error.message || "Sign in failed");
+        }
+
+        const token = result.data?.token;
+        if (!token) {
+          throw new Error("No session token returned from sign in");
+        }
+
+        return await exchangeForFeathersJWT(token);
+      } catch (error) {
+        setIsAuthenticating(false);
+        debug("Sign in failed", error);
+        throw error;
+      }
+    },
+    [exchangeForFeathersJWT, setIsAuthenticating, setHasStartedConnecting],
+  );
+
+  const signUpWithEmail = useCallback(
+    async (email: string, password: string, name: string, verifyCallbackURL?: string) => {
+      debug("Signing up with email", { email, name });
+      setHasStartedConnecting(true);
+      setIsAuthenticating(true);
+
+      try {
+        const result = await getBetterAuthClient().signUp.email({ email, password, name });
+
+        if (result.error) {
+          throw new Error(result.error.message || "Sign up failed");
+        }
+
+        const token = result.data?.token;
+        if (!token) {
+          // 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 getBetterAuthClient().sendVerificationEmail({
+            email,
+            callbackURL: verifyCallbackURL || `${window.location.origin}?authStrategy=better-auth`,
+          });
+          throw new EmailVerificationRequiredError();
+        }
+
+        return await exchangeForFeathersJWT(token);
+      } catch (error) {
+        setIsAuthenticating(false);
+        debug("Sign up failed", error);
+        throw error;
+      }
+    },
+    [exchangeForFeathersJWT, setIsAuthenticating, setHasStartedConnecting],
+  );
+
+  const signInWithSocial = useCallback(
+    async (provider: BetterAuthSocialProvider) => {
+      debug("Signing in with social provider", { provider });
+      setHasStartedConnecting(true);
+      setIsAuthenticating(true);
+
+      try {
+        const result = await getBetterAuthClient().signIn.social({
+          provider,
+          callbackURL: window.location.href,
+        });
+
+        if (result.error) {
+          throw new Error(result.error.message || `${provider} sign in failed`);
+        }
+
+        // Social auth redirects to provider — JWT exchange happens on callback
+        // via BetterAuthProvider session restore
+      } catch (error) {
+        setIsAuthenticating(false);
+        debug("Social sign in failed", error);
+        throw error;
+      }
+    },
+    [setIsAuthenticating, setHasStartedConnecting],
+  );
+
+  const requestPasswordReset = useCallback(async (email: string, redirectTo?: string) => {
+    debug("Requesting password reset", { email });
+
+    const result = await getBetterAuthClient().requestPasswordReset({
+      email,
+      redirectTo,
+    });
+
+    if (result.error) {
+      throw new Error(result.error.message || "Password reset request failed");
+    }
+
+    debug("Password reset email sent");
+    return result;
+  }, []);
+
+  const resetPassword = useCallback(async (newPassword: string, token: string) => {
+    debug("Resetting password");
+
+    const result = await getBetterAuthClient().resetPassword({
+      newPassword,
+      token,
+    });
+
+    if (result.error) {
+      throw new Error(result.error.message || "Password reset failed");
+    }
+
+    debug("Password reset successful");
+    return result;
+  }, []);
+
+  return {
+    signInWithEmail,
+    signUpWithEmail,
+    signInWithSocial,
+    requestPasswordReset,
+    resetPassword,
+    exchangeForFeathersJWT,
+    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/useConnect.tsx

@@ -4,7 +4,7 @@ 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";
+import { ecosystemWallet, MultiStepAuthArgsType, SingleStepAuthArgsType } from "thirdweb/wallets";
 const debug = debugB3React("useConnect");
 
 /**
@@ -23,7 +23,7 @@ export function useConnect(partnerId: string, chain?: Chain) {
    * It is used to connect to a wallet using the thirdweb client.
    */
   const connectTw = useCallback(
-    async (strategyOptions?: SingleStepAuthArgsType) => {
+    async (strategyOptions?: MultiStepAuthArgsType | SingleStepAuthArgsType) => {
       setIsLoading(true);
       return await connect(async () => {
         if (!strategyOptions) throw new Error("Strategy options are required");

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/useSiwe.native.tsx

@@ -4,7 +4,7 @@ import { useCallback } from "react";
 import { Account } from "thirdweb/wallets";
 
 export function useSiwe() {
-  const authenticate = useCallback(async (account: Account, partnerId: string) => {
+  const authenticate = useCallback(async (account: Account, partnerId: string): Promise<Record<string, any>> => {
     if (!account || !account.signMessage) throw new Error("Account not found");
     // generate challenge
     const challenge = await app.service("global-accounts-challenge").create({

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

@@ -8,7 +8,7 @@ export function useSiwe() {
   const referralCode = useSearchParam("referralCode");
 
   const authenticate = useCallback(
-    async (account: Account, partnerId: string) => {
+    async (account: Account, partnerId: string): Promise<Record<string, any>> => {
       console.warn("@@useSiwe is deprecated, use useTWAuth instead");
       if (!account || !account.signMessage) throw new Error("Account not found");
 

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

@@ -12,11 +12,10 @@ import { useSearchParam } from "./useSearchParamsSSR";
  * @deprecated Use useAuth() instead
  */
 export function useTWAuth() {
-  console.warn("useTWAuth is deprecated. Please migrate to useAuth() for authentication.");
   const referralCode = useSearchParam("referralCode");
 
   const authenticate = useCallback(
-    async (wallet: Wallet, partnerId: string) => {
+    async (wallet: Wallet, partnerId: string): Promise<Record<string, any>> => {
       if (!wallet || !wallet?.getAuthToken?.()) throw new Error("Wallet not found");
 
       const authToken = wallet.getAuthToken();

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

@@ -9,6 +9,7 @@ import { useCallback, useState } from "react";
 import { prepareTransaction, sendTransaction as twSendTransaction } from "thirdweb";
 import { isAddress } from "viem";
 import { useSwitchChain } from "wagmi";
+import { useB3Config } from "../components/B3Provider/B3ConfigProvider";
 import { useB3Account } from "../components/B3Provider/useB3Account";
 import { useAccountWallet } from "./useAccountWallet";
 
@@ -18,14 +19,6 @@ export interface UnifiedTransactionParams {
   value: bigint;
 }
 
-const partnerId = String(
-  process.env.PUBLIC_THIRDWEB_PARTNER_ID ||
-    process.env.NEXT_PUBLIC_THIRDWEB_PARTNER_ID ||
-    process.env.PUBLIC_GLOBAL_ACCOUNTS_PARTNER_ID ||
-    process.env.NEXT_PUBLIC_GLOBAL_ACCOUNTS_PARTNER_ID,
-);
-invariant(partnerId, "Partner ID is required");
-
 export function useUnifiedChainSwitchAndExecute() {
   const { switchChainAsync } = useSwitchChain();
   const [isSwitchingOrExecuting, setIsSwitchingOrExecuting] = useState(false);
@@ -33,6 +26,9 @@ export function useUnifiedChainSwitchAndExecute() {
   const { isActiveSmartWallet, isActiveEOAWallet, connectedEOAWallet } = useAccountWallet();
   const aaAccount = useB3Account();
 
+  // From context, not process.env: partnerId is hashed into the server intent key and must match the ecosystem wallet.
+  const { partnerId } = useB3Config();
+
   // Handle EOA wallet chain switch and execute transaction
   const handleEOASwitchChainAndSendTransaction = useCallback(
     async (targetChainId: number, params: UnifiedTransactionParams): Promise<string | undefined> => {
@@ -144,17 +140,23 @@ export function useUnifiedChainSwitchAndExecute() {
           value: params.value,
         });
 
-        // Check if we can use global-accounts-intents, if yes, create an intent.
-        try {
-          await app.service("global-accounts-intents").create({
-            partnerId: partnerId,
-            chainId: targetChainId,
-            to: params.to,
-            data: params.data || "0x",
-            value: params.value.toString(),
-          });
-        } catch (err: any) {
-          console.error("Create global-accounts-intents error", err);
+        // Pre-register an intent to authorize the signature server-side; skip if partnerId is missing.
+        if (partnerId) {
+          try {
+            await app.service("global-accounts-intents").create({
+              partnerId,
+              chainId: targetChainId,
+              to: params.to,
+              data: params.data || "0x",
+              value: params.value.toString(),
+            });
+          } catch (err: any) {
+            console.error("Create global-accounts-intents error", err);
+          }
+        } else if (process.env.NODE_ENV !== "production") {
+          console.warn(
+            "useUnifiedChainSwitchAndExecute: missing partnerId from B3Config — skipping intent pre-authorization",
+          );
         }
 
         toast.info("Sending transaction…");
@@ -176,7 +178,7 @@ export function useUnifiedChainSwitchAndExecute() {
         setIsSwitchingOrExecuting(false);
       }
     },
-    [aaAccount],
+    [aaAccount, partnerId],
   );
 
   // Unified switch chain and execute function