@b3dotfun/sdk 0.0.82 → 0.0.83-test.0

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,51 +106,45 @@ export function useAuthentication(partnerId: string) {
     syncWagmi();
   }, [wallets, syncWagmi]);
 
-  const authenticateUser = useCallback(
-    async (wallet?: Wallet) => {
-      setHasStartedConnecting(true);
-
-      if (!wallet) {
-        throw new Error("No wallet found during auto-connect");
-      }
-
-      const account = wallet ? wallet.getAccount() : activeWallet?.getAccount();
-      if (!account) {
-        throw new Error("No account found during auto-connect");
-      }
-
-      // Try to re-authenticate first
-      try {
-        const userAuth = await app.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, try fresh authentication
-        debug("Re-authentication failed, attempting fresh authentication");
-        const userAuth = await authenticate(wallet, partnerId);
-        setUser(userAuth.user);
-        setIsAuthenticated(true);
-        setIsAuthenticating(false);
-        debug("Fresh authentication successful", { userAuth });
+  /**
+   * 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);
+      // Authenticate on BSMNT with B3 JWT
+      const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
+      debug("@@b3Jwt", b3Jwt);
 
-        return userAuth;
-      }
-    },
-    [activeWallet, partnerId, authenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting],
-  );
+      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 });
@@ -168,10 +162,20 @@ export function useAuthentication(partnerId: string) {
         setIsConnected(true);
         setIsAuthenticating(true);
         await setActiveWallet(wallet);
-        const userAuth = await authenticateUser(wallet);
 
-        if (userAuth && onConnectCallback) {
-          await onConnectCallback(wallet, userAuth.accessToken);
+        // 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("@@useAuthentication:onConnect:authFailed", { authError });
+          // Don't set isAuthenticated to false here - let the Turnkey flow handle it
         }
       } catch (error) {
         debug("@@useAuthentication:onConnect:failed", { error });

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(

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

@@ -1,9 +1,10 @@
-import app from "../../app";
-import { useAuthStore } from "../stores";
-import { useCallback, useState } from "react";
-import { useB3 } from "../components/B3Provider/useB3";
 import { TurnkeyAuthInitResponse } from "@b3dotfun/b3-api";
 import { debugB3React } from "@b3dotfun/sdk/shared/utils/debug";
+import { useCallback, useState } from "react";
+import app from "../../app";
+import { useB3 } from "../components/B3Provider/useB3";
+import { useAuthStore } from "../stores";
+import { useAuth } from "./useAuth";
 
 const debug = debugB3React("useTurnkeyAuth");
 
@@ -32,12 +33,16 @@ export function useTurnkeyAuth(): UseTurnkeyAuthReturn {
   const [error, setError] = useState<string | null>(null);
   const setIsAuthenticating = useAuthStore(state => state.setIsAuthenticating);
   const setIsAuthenticated = useAuthStore(state => state.setIsAuthenticated);
-  const { user } = useB3();
+  const { partnerId } = useB3();
+  const { authenticate } = useAuth();
 
   /**
    * Step 1: Initiate login with email
-   * - Calls backend to create sub-org (if needed) and send OTP
+   * - Calls backend turnkey-jwt strategy (init action) to create sub-org (if needed) and send OTP
    * - Returns otpId to use in verification step
+   *
+   * Note: Uses the turnkey-jwt authentication strategy, not the service directly.
+   * The turnkey-jwt strategy handles both OTP flow (init/verify) and final authentication.
    */
   const initiateLogin = useCallback(
     async (email: string): Promise<TurnkeyAuthInitResponse> => {
@@ -46,20 +51,44 @@ export function useTurnkeyAuth(): UseTurnkeyAuthReturn {
       setIsAuthenticating(true);
 
       try {
-        if (!user?.userId) {
-          throw new Error("User ID is required to initiate Turnkey login.");
-        }
         debug(`Initiating login for: ${email}`);
 
-        // Call FeathersJS service to initialize OTP
-        const data: TurnkeyAuthInitResponse = await app.service("turnkey-auth").init({ email, userId: user.userId });
+        // Use authentication service with turnkey-jwt strategy (init action)
+        // userId is resolved from authentication context on the backend (params.user.userId)
+        // Backend will get userId from _params.user?.userId if authenticated, or handle unauthenticated case
+        // So we only need to send email
+        debug(`Calling app.authenticate with turnkey-jwt strategy (init action)`, { email });
+
+        const response = await app.authenticate({
+          strategy: "turnkey-jwt",
+          action: "init",
+          email,
+        } as any);
+
+        // The strategy returns the TurnkeyAuthInitResponse directly
+        const data = response as unknown as TurnkeyAuthInitResponse;
 
         debug(`OTP initialized successfully. OtpId: ${data.otpId}`);
 
         return data;
       } catch (err: any) {
         debug("Error initiating login:", err);
-        const errorMessage = err.message || "Failed to send OTP email. Please try again.";
+
+        // Provide more detailed error information
+        let errorMessage = "Failed to send OTP email. Please try again.";
+
+        if (err.message) {
+          errorMessage = err.message;
+        } else if (err.name === "TypeError" && err.message?.includes("fetch")) {
+          errorMessage = "Network error: Unable to reach the server. Please check your connection and try again.";
+        } else if (err.code === "ECONNREFUSED" || err.code === "ENOTFOUND") {
+          errorMessage = "Connection error: Unable to reach the server. Please check your internet connection.";
+        } else if (err.response) {
+          // FeathersJS error response
+          errorMessage = err.response.message || err.message || errorMessage;
+          debug("FeathersJS error response:", err.response);
+        }
+
         setError(errorMessage);
         throw err;
       } finally {
@@ -67,13 +96,13 @@ export function useTurnkeyAuth(): UseTurnkeyAuthReturn {
         setIsAuthenticating(false);
       }
     },
-    [user, setIsAuthenticating],
+    [setIsAuthenticating],
   );
 
   /**
    * Step 2: Verify OTP and authenticate
-   * - Verifies OTP with backend
-   * - Gets Turnkey session JWT
+   * - Verifies OTP with backend via turnkey-jwt strategy (verify action)
+   * - Gets Turnkey session JWT from the verify response
    * - Authenticates with b3-api using "turnkey-jwt" strategy
    * - JWT automatically stored in cookies by SDK
    */
@@ -84,22 +113,26 @@ export function useTurnkeyAuth(): UseTurnkeyAuthReturn {
       setIsAuthenticating(true);
 
       try {
-        debug(`Verifying OTP...`, { userId: user?.userId });
+        debug(`Verifying OTP...`, { otpId });
 
-        // Step 1: Verify OTP and get Turnkey session JWT
-        const { turnkeySessionJwt }: TurnkeyVerifyResponse = await app.service("turnkey-auth").verify({
+        // Step 1: Verify OTP with backend using turnkey-jwt strategy (verify action)
+        // This returns the Turnkey session JWT
+        const response = await app.authenticate({
+          strategy: "turnkey-jwt",
+          action: "verify",
           otpId,
           otpCode,
-        });
+        } as any);
+
+        // The strategy returns the TurnkeyAuthVerifyResponse directly
+        const verifyResult = response as unknown as TurnkeyVerifyResponse;
+        const { turnkeySessionJwt } = verifyResult;
 
-        debug(`OTP verified! Authenticating with b3-api...`);
+        debug(`OTP verified! Got Turnkey session JWT. Authenticating with b3-api...`);
 
         // Step 2: Authenticate with b3-api using Turnkey JWT
-        // The SDK will automatically store the b3-api JWT in cookies
-        const authResult = await app.authenticate({
-          strategy: "turnkey-jwt",
-          accessToken: turnkeySessionJwt,
-        } as any);
+        // Use the unified useAuth hook for authentication with "turnkey-jwt" strategy
+        const authResult = await authenticate(turnkeySessionJwt, partnerId || "");
 
         debug(`Successfully authenticated with b3-api!`, authResult);
 
@@ -121,7 +154,7 @@ export function useTurnkeyAuth(): UseTurnkeyAuthReturn {
         setIsAuthenticating(false);
       }
     },
-    [user, setIsAuthenticating, setIsAuthenticated],
+    [partnerId, setIsAuthenticating, setIsAuthenticated, authenticate],
   );
 
   const clearError = useCallback(() => {