@b3dotfun/sdk 0.0.82-alpha.3 → 0.0.83-test.0

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

@@ -0,0 +1,380 @@
+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 { 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 {
+  useActiveWallet,
+  useAutoConnect,
+  useConnectedWallets,
+  useDisconnect,
+  useSetActiveWallet,
+} from "thirdweb/react";
+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 { useB3 } from "../components/B3Provider/useB3";
+import { createWagmiConfig } from "../utils/createWagmiConfig";
+import { useSearchParam } from "./useSearchParamsSSR";
+import { useUserQuery } from "./useUserQuery";
+
+const debug = debugB3React("useAuth");
+
+/**
+ * Unified authentication hook that uses Turnkey for authentication
+ * This replaces the previous Thirdweb-based authentication
+ *
+ * This hook provides 1:1 feature parity with useAuthentication.ts
+ */
+export function useAuth() {
+  const { onConnectCallback } = useContext(LocalSDKContext);
+  const { disconnect } = useDisconnect();
+  const wallets = useConnectedWallets();
+  const activeWallet = useActiveWallet();
+  const isAuthenticated = useAuthStore(state => state.isAuthenticated);
+  const setIsAuthenticated = useAuthStore(state => state.setIsAuthenticated);
+  const setIsConnected = useAuthStore(state => state.setIsConnected);
+  const isConnecting = useAuthStore(state => state.isConnecting);
+  const isConnected = useAuthStore(state => state.isConnected);
+  const isAuthenticating = useAuthStore(state => state.isAuthenticating);
+  const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
+  const setHasStartedConnecting = useAuthStore(state => state.setHasStartedConnecting);
+  const setActiveWallet = useSetActiveWallet();
+  const hasStartedConnecting = useAuthStore(state => state.hasStartedConnecting);
+  const useAutoConnectLoadingPrevious = useRef(false);
+  const referralCode = useSearchParam("referralCode");
+  const { partnerId } = useB3();
+  const wagmiConfig = createWagmiConfig({ partnerId });
+  const { connect } = useConnect();
+  const activeWagmiAccount = useAccount();
+  const { switchAccount } = useSwitchAccount();
+  const { user, setUser } = useUserQuery();
+  debug("@@activeWagmiAccount", activeWagmiAccount);
+
+  const wallet = ecosystemWallet(ecosystemWalletId, {
+    partnerId: partnerId,
+  });
+
+  /**
+   * Re-authenticate using existing session
+   * Also updates user state and authenticates with BSMNT
+   */
+  const reAuthenticate = useCallback(async () => {
+    debug("Re-authenticating...");
+    try {
+      const response = await app.reAuthenticate();
+      debug("Re-authentication successful", response);
+
+      // Update user state if user data exists
+      if (response.user) {
+        setUser(response.user);
+        debug("User state updated", response.user);
+      }
+
+      // Authenticate with BSMNT
+      try {
+        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);
+      }
+
+      return response;
+    } catch (err: any) {
+      debug("Re-authentication failed", err);
+      throw err;
+    }
+  }, [setUser]);
+
+  const syncWagmi = useCallback(async () => {
+    function syncWagmiFunc() {
+      const connectors = getConnectors(wagmiConfig);
+      debug("@@syncWagmi", {
+        connectors,
+        wallets,
+      });
+
+      // For each that matchs a TW wallet on wallets, connect to the wagmi connector
+      // or, since ecosystem wallets is separate, connect those via in-app-wallet from wagmi
+      connectors.forEach(async connector => {
+        const twWallet = wallets.find(wallet => wallet.id === connector.id || connector.id === "in-app-wallet");
+
+        // If no TW wallet, do not prompt the user to connect
+        if (!twWallet) {
+          return;
+        }
+
+        // Metamask will prompt to connect, we can just switch accounts here.
+        if (connector.id === "io.metamask") {
+          return switchAccount({ connector });
+        }
+
+        if (
+          // If it's not an in-app wallet or it is the ecosystem wallet, connect
+          connector.id !== "in-app-wallet" ||
+          (connector.id === "in-app-wallet" && twWallet.id === ecosystemWalletId)
+        ) {
+          try {
+            const options = {
+              wallet: twWallet, // the connected wallet
+            } satisfies ConnectionOptions;
+            debug("@@syncWagmi:connecting", { twWallet, connector });
+            connect({
+              connector,
+              ...options,
+            });
+          } catch (error) {
+            console.error("@@syncWagmi:error", error);
+          }
+        } else {
+          debug("@@syncWagmi:not-connecting", connector);
+        }
+      });
+    }
+    syncWagmiFunc();
+    // wagmi config shouldn't change
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [partnerId, wallets]);
+
+  useEffect(() => {
+    syncWagmi();
+  }, [wallets, syncWagmi]);
+
+  /**
+   * Authenticate user using Turnkey
+   * Note: This no longer requires a wallet for authentication.
+   * Wallets are still used for signing transactions, but authentication is done via Turnkey email OTP.
+   *
+   * For backward compatibility, this function still accepts a wallet parameter,
+   * but it's not used for authentication anymore.
+   */
+  const authenticateUser = useCallback(async () => {
+    setHasStartedConnecting(true);
+
+    // Try to re-authenticate first
+    try {
+      const userAuth = await reAuthenticate();
+      setUser(userAuth.user);
+      setIsAuthenticated(true);
+      setIsAuthenticating(false);
+      debug("Re-authenticated successfully", { userAuth });
+
+      // Authenticate on BSMNT with B3 JWT
+      const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
+      debug("@@b3Jwt", b3Jwt);
+
+      return userAuth;
+    } catch (error) {
+      // If re-authentication fails, user needs to authenticate via Turnkey
+      // This should be handled by the Turnkey auth modal/flow
+      debug("Re-authentication failed. User needs to authenticate via Turnkey.", error);
+      setIsAuthenticated(false);
+      setIsAuthenticating(false);
+      throw new Error("Authentication required. Please authenticate via Turnkey.");
+    }
+  }, [reAuthenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting]);
+
+  /**
+   * Authenticate with Turnkey using email OTP
+   * This is the primary authentication method, replacing Thirdweb wallet-based auth
+   *
+   * This function:
+   * 1. Authenticates with FeathersJS (persists session via cookies)
+   * 2. Sets user state in the user store (persists to localStorage)
+   * 3. Authenticates with BSMNT for basement integration
+   */
+  const authenticate = useCallback(
+    async (turnkeySessionJwt: string, partnerId: string) => {
+      if (!turnkeySessionJwt) {
+        throw new Error("Turnkey session JWT is required");
+      }
+
+      debug("Authenticating with Turnkey JWT", { referralCode, partnerId });
+
+      try {
+        // Step 1: Authenticate with FeathersJS (session persisted via cookies)
+        const response = await app.authenticate({
+          strategy: "turnkey-jwt",
+          accessToken: turnkeySessionJwt,
+          referralCode,
+          partnerId: partnerId,
+        } as any);
+
+        debug("Authentication successful", response);
+
+        // Step 2: Set user state (persists to localStorage via Zustand)
+        if (response.user) {
+          setUser(response.user);
+          debug("User state updated", response.user);
+        }
+
+        // Step 3: Authenticate with BSMNT for basement integration
+        try {
+          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);
+        }
+
+        return response;
+      } catch (err: any) {
+        debug("Authentication failed", err);
+        throw err;
+      }
+    },
+    [referralCode, setUser],
+  );
+
+  /**
+   * Handle wallet connection
+   * Note: With Turnkey migration, wallet connection is primarily for signing transactions,
+   * not for authentication. Authentication should be done separately via Turnkey email OTP.
+   */
+  /**
+   * Handle wallet connection
+   * Note: With Turnkey migration, wallet connection is primarily for signing transactions,
+   * not for authentication. Authentication should be done separately via Turnkey email OTP.
+   */
+  const onConnect = useCallback(
+    async (_walleAutoConnectedWith: Wallet, allConnectedWallets: Wallet[]) => {
+      debug("@@useAuth:onConnect", { _walleAutoConnectedWith, allConnectedWallets });
+
+      const wallet = allConnectedWallets.find(wallet => wallet.id.startsWith("ecosystem."));
+
+      if (!wallet) {
+        throw new Error("No smart wallet found during auto-connect");
+      }
+
+      debug("@@useAuth:onConnect", { wallet });
+
+      try {
+        setHasStartedConnecting(true);
+        setIsConnected(true);
+        setIsAuthenticating(true);
+        await setActiveWallet(wallet);
+
+        // Try to authenticate user (will use re-authenticate if session exists)
+        // If no session exists, authentication will need to happen via Turnkey flow
+        try {
+          const userAuth = await authenticateUser();
+
+          if (userAuth && onConnectCallback) {
+            await onConnectCallback(wallet, userAuth.accessToken);
+          }
+        } catch (authError) {
+          // Authentication failed - this is expected if user hasn't authenticated via Turnkey yet
+          // The Turnkey auth modal should handle this
+          debug("@@useAuth:onConnect:authFailed", { authError });
+          // Don't set isAuthenticated to false here - let the Turnkey flow handle it
+        }
+      } catch (error) {
+        debug("@@useAuth:onConnect:failed", { error });
+        setIsAuthenticated(false);
+        setUser(undefined);
+      } finally {
+        setIsAuthenticating(false);
+      }
+
+      debug({
+        isAuthenticated,
+        isAuthenticating,
+        isConnected,
+      });
+    },
+    [
+      onConnectCallback,
+      authenticateUser,
+      isAuthenticated,
+      isAuthenticating,
+      isConnected,
+      setActiveWallet,
+      setHasStartedConnecting,
+      setIsAuthenticated,
+      setIsAuthenticating,
+      setIsConnected,
+      setUser,
+    ],
+  );
+
+  const logout = useCallback(
+    async (callback?: () => void) => {
+      if (activeWallet) {
+        debug("@@logout:activeWallet", activeWallet);
+        disconnect(activeWallet);
+        debug("@@logout:activeWallet", activeWallet);
+      }
+
+      // Log out of each wallet
+      wallets.forEach(wallet => {
+        console.log("@@logging out", wallet);
+        disconnect(wallet);
+      });
+
+      // Delete localStorage thirdweb:connected-wallet-ids
+      // https://npc-labs.slack.com/archives/C070E6HNG85/p1750185115273099
+      if (typeof localStorage !== "undefined") {
+        localStorage.removeItem("thirdweb:connected-wallet-ids");
+        localStorage.removeItem("wagmi.store");
+        localStorage.removeItem("lastAuthProvider");
+        localStorage.removeItem("b3-user");
+      }
+
+      app.logout();
+      debug("@@logout:loggedOut");
+
+      setIsAuthenticated(false);
+      setIsConnected(false);
+      setUser();
+      callback?.();
+    },
+    [activeWallet, disconnect, wallets, setIsAuthenticated, setUser, setIsConnected],
+  );
+
+  const { isLoading: useAutoConnectLoading } = useAutoConnect({
+    client,
+    wallets: [wallet],
+    onConnect,
+    onTimeout: () => {
+      logout().catch(error => {
+        debug("@@useAuth:logout on timeout failed", { error });
+      });
+    },
+  });
+
+  /**
+   * useAutoConnectLoading starts as false
+   */
+  useEffect(() => {
+    if (!useAutoConnectLoading && useAutoConnectLoadingPrevious.current && !hasStartedConnecting) {
+      setIsAuthenticating(false);
+    }
+    useAutoConnectLoadingPrevious.current = useAutoConnectLoading;
+  }, [useAutoConnectLoading, hasStartedConnecting, setIsAuthenticating]);
+
+  const isReady = isAuthenticated && !isAuthenticating;
+
+  return {
+    authenticate,
+    reAuthenticate,
+    logout,
+    isAuthenticated,
+    isReady,
+    isConnecting,
+    isConnected,
+    wallet,
+    preAuthenticate,
+    connect: onConnect,
+    isAuthenticating,
+    onConnect,
+    user,
+    refetchUser: authenticateUser,
+    setUser,
+  };
+}

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

@@ -19,7 +19,7 @@ import { preAuthenticate } from "thirdweb/wallets/in-app";
 import { useAccount, useConnect, useSwitchAccount } from "wagmi";
 import { LocalSDKContext } from "../components/B3Provider/LocalSDKProvider";
 import { createWagmiConfig } from "../utils/createWagmiConfig";
-import { useTWAuth } from "./useTWAuth";
+import { useAuth } from "./useAuth";
 import { useUserQuery } from "./useUserQuery";
 
 const debug = debugB3React("useAuthentication");
@@ -39,7 +39,7 @@ export function useAuthentication(partnerId: string) {
   const setHasStartedConnecting = useAuthStore(state => state.setHasStartedConnecting);
   const setActiveWallet = useSetActiveWallet();
   const hasStartedConnecting = useAuthStore(state => state.hasStartedConnecting);
-  const { authenticate } = useTWAuth();
+  const { reAuthenticate } = useAuth();
   const { user, setUser } = useUserQuery();
   const useAutoConnectLoadingPrevious = useRef(false);
   const wagmiConfig = createWagmiConfig({ partnerId });
@@ -106,49 +106,104 @@ export function useAuthentication(partnerId: string) {
     syncWagmi();
   }, [wallets, syncWagmi]);
 
-  const authenticateUser = useCallback(
-    async (wallet?: Wallet) => {
-      setHasStartedConnecting(true);
+  /**
+   * Authenticate user using Turnkey
+   * Note: This no longer requires a wallet for authentication.
+   * Wallets are still used for signing transactions, but authentication is done via Turnkey email OTP.
+   *
+   * For backward compatibility, this function still accepts a wallet parameter,
+   * but it's not used for authentication anymore.
+   */
+  const authenticateUser = useCallback(async () => {
+    setHasStartedConnecting(true);
+
+    // Try to re-authenticate first
+    try {
+      const userAuth = await reAuthenticate();
+      setUser(userAuth.user);
+      setIsAuthenticated(true);
+      setIsAuthenticating(false);
+      debug("Re-authenticated successfully", { userAuth });
+
+      // Authenticate on BSMNT with B3 JWT
+      const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
+      debug("@@b3Jwt", b3Jwt);
+
+      return userAuth;
+    } catch (error) {
+      // If re-authentication fails, user needs to authenticate via Turnkey
+      // This should be handled by the Turnkey auth modal/flow
+      debug("Re-authentication failed. User needs to authenticate via Turnkey.", error);
+      setIsAuthenticated(false);
+      setIsAuthenticating(false);
+      throw new Error("Authentication required. Please authenticate via Turnkey.");
+    }
+  }, [reAuthenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting]);
+
+  /**
+   * Handle wallet connection
+   * Note: With Turnkey migration, wallet connection is primarily for signing transactions,
+   * not for authentication. Authentication should be done separately via Turnkey email OTP.
+   */
+  const onConnect = useCallback(
+    async (_walleAutoConnectedWith: Wallet, allConnectedWallets: Wallet[]) => {
+      debug("@@useAuthentication:onConnect", { _walleAutoConnectedWith, allConnectedWallets });
+
+      const wallet = allConnectedWallets.find(wallet => wallet.id.startsWith("ecosystem."));
 
       if (!wallet) {
-        throw new Error("No wallet found during auto-connect");
+        throw new Error("No smart wallet found during auto-connect");
       }
 
-      const account = wallet ? wallet.getAccount() : activeWallet?.getAccount();
-      if (!account) {
-        throw new Error("No account found during auto-connect");
-      }
+      debug("@@useAuthentication:onConnect", { wallet });
 
-      // Try to re-authenticate first
       try {
-        const userAuth = await app.reAuthenticate();
-        setUser(userAuth.user);
-        setIsAuthenticated(true);
-        setIsAuthenticating(false);
-        debug("Re-authenticated successfully", { userAuth });
+        setHasStartedConnecting(true);
+        setIsConnected(true);
+        setIsAuthenticating(true);
+        await setActiveWallet(wallet);
 
-        // Authenticate on BSMNT with B3 JWT
-        const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
-        debug("@@b3Jwt", b3Jwt);
+        // Try to authenticate user (will use re-authenticate if session exists)
+        // If no session exists, authentication will need to happen via Turnkey flow
+        try {
+          const userAuth = await authenticateUser();
 
-        return userAuth;
+          if (userAuth && onConnectCallback) {
+            await onConnectCallback(wallet, userAuth.accessToken);
+          }
+        } catch (authError) {
+          // Authentication failed - this is expected if user hasn't authenticated via Turnkey yet
+          // The Turnkey auth modal should handle this
+          debug("@@useAuthentication:onConnect:authFailed", { authError });
+          // Don't set isAuthenticated to false here - let the Turnkey flow handle it
+        }
       } catch (error) {
-        // If re-authentication fails, try fresh authentication
-        debug("Re-authentication failed, attempting fresh authentication");
-        const userAuth = await authenticate(wallet, partnerId);
-        setUser(userAuth.user);
-        setIsAuthenticated(true);
+        debug("@@useAuthentication:onConnect:failed", { error });
+        setIsAuthenticated(false);
+        setUser(undefined);
+      } finally {
         setIsAuthenticating(false);
-        debug("Fresh authentication successful", { userAuth });
-
-        // Authenticate on BSMNT with B3 JWT
-        const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
-        debug("@@b3Jwt", b3Jwt);
-
-        return userAuth;
       }
+
+      debug({
+        isAuthenticated,
+        isAuthenticating,
+        isConnected,
+      });
     },
-    [activeWallet, partnerId, authenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting],
+    [
+      onConnectCallback,
+      authenticateUser,
+      isAuthenticated,
+      isAuthenticating,
+      isConnected,
+      setActiveWallet,
+      setHasStartedConnecting,
+      setIsAuthenticated,
+      setIsAuthenticating,
+      setIsConnected,
+      setUser,
+    ],
   );
 
   const logout = useCallback(
@@ -185,58 +240,6 @@ export function useAuthentication(partnerId: string) {
     [activeWallet, disconnect, wallets, setIsAuthenticated, setUser, setIsConnected],
   );
 
-  const onConnect = useCallback(
-    async (_walleAutoConnectedWith: Wallet, allConnectedWallets: Wallet[]) => {
-      debug("@@useAuthentication:onConnect", { _walleAutoConnectedWith, allConnectedWallets });
-      try {
-        const wallet = allConnectedWallets.find(wallet => wallet.id.startsWith("ecosystem."));
-
-        if (!wallet) {
-          throw new Error("No smart wallet found during auto-connect");
-        }
-
-        debug("@@useAuthentication:onConnect", { wallet });
-        setHasStartedConnecting(true);
-        setIsConnected(true);
-        setIsAuthenticating(true);
-        await setActiveWallet(wallet);
-        const userAuth = await authenticateUser(wallet);
-
-        if (userAuth && onConnectCallback) {
-          await onConnectCallback(wallet, userAuth.accessToken);
-        }
-      } catch (error) {
-        debug("@@useAuthentication:onConnect:failed", { error });
-        setIsAuthenticated(false);
-        setUser(undefined);
-
-        await logout();
-      } finally {
-        setIsAuthenticating(false);
-      }
-
-      debug({
-        isAuthenticated,
-        isAuthenticating,
-        isConnected,
-      });
-    },
-    [
-      isAuthenticated,
-      isAuthenticating,
-      isConnected,
-      setHasStartedConnecting,
-      setIsConnected,
-      setIsAuthenticating,
-      setActiveWallet,
-      authenticateUser,
-      onConnectCallback,
-      setIsAuthenticated,
-      setUser,
-      logout,
-    ],
-  );
-
   const { isLoading: useAutoConnectLoading } = useAutoConnect({
     client,
     wallets: [wallet],

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

@@ -1,10 +1,20 @@
+/**
+ * @deprecated This hook is deprecated. Use useAuth() with Turnkey authentication instead.
+ * This file is kept for backward compatibility but should not be used in new code.
+ */
 import app from "@b3dotfun/sdk/global-account/app";
 import debug from "@b3dotfun/sdk/shared/utils/debug";
 import { useCallback } from "react";
 import { Wallet } from "thirdweb/wallets";
 import { useSearchParam } from "./useSearchParamsSSR";
 
+/**
+ * @deprecated Use useAuth() with Turnkey authentication instead
+ */
 export function useTWAuth() {
+  console.warn(
+    "useTWAuth is deprecated. Please migrate to useAuth() with Turnkey authentication. See useTurnkeyAuth.ts for the new implementation.",
+  );
   const referralCode = useSearchParam("referralCode");
 
   const authenticate = useCallback(