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

package/dist/esm/global-account/react/hooks/useAuthentication.js

@@ -12,7 +12,7 @@ import { preAuthenticate } from "thirdweb/wallets/in-app";
 import { useAccount, useConnect, useSwitchAccount } from "wagmi";
 import { LocalSDKContext } from "../components/B3Provider/LocalSDKProvider.js";
 import { createWagmiConfig } from "../utils/createWagmiConfig.js";
-import { useTWAuth } from "./useTWAuth.js";
+import { useAuth } from "./useAuth.js";
 import { useUserQuery } from "./useUserQuery.js";
 const debug = debugB3React("useAuthentication");
 export function useAuthentication(partnerId) {
@@ -30,7 +30,7 @@ export function useAuthentication(partnerId) {
     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 });
@@ -90,18 +90,19 @@ export function useAuthentication(partnerId) {
     useEffect(() => {
         syncWagmi();
     }, [wallets, syncWagmi]);
-    const authenticateUser = useCallback(async (wallet) => {
+    /**
+     * 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);
-        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();
+            const userAuth = await reAuthenticate();
             setUser(userAuth.user);
             setIsAuthenticated(true);
             setIsAuthenticating(false);
@@ -112,67 +113,50 @@ export function useAuthentication(partnerId) {
             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);
+            // 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);
-            debug("Fresh authentication successful", { userAuth });
-            // Authenticate on BSMNT with B3 JWT
-            const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
-            debug("@@b3Jwt", b3Jwt);
-            return userAuth;
-        }
-    }, [activeWallet, partnerId, authenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting]);
-    const logout = useCallback(async (callback) => {
-        if (activeWallet) {
-            debug("@@logout:activeWallet", activeWallet);
-            disconnect(activeWallet);
-            debug("@@logout:activeWallet", activeWallet);
+            throw new Error("Authentication required. Please authenticate via Turnkey.");
         }
-        // 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]);
+    }, [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, allConnectedWallets) => {
         debug("@@useAuthentication: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("@@useAuthentication:onConnect", { wallet });
         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);
+            // 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 });
             setIsAuthenticated(false);
             setUser(undefined);
-            await logout();
         }
         finally {
             setIsAuthenticating(false);
@@ -183,19 +167,44 @@ export function useAuthentication(partnerId) {
             isConnected,
         });
     }, [
+        onConnectCallback,
+        authenticateUser,
         isAuthenticated,
         isAuthenticating,
         isConnected,
-        setHasStartedConnecting,
-        setIsConnected,
-        setIsAuthenticating,
         setActiveWallet,
-        authenticateUser,
-        onConnectCallback,
+        setHasStartedConnecting,
         setIsAuthenticated,
+        setIsAuthenticating,
+        setIsConnected,
         setUser,
-        logout,
     ]);
+    const logout = useCallback(async (callback) => {
+        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],

package/dist/esm/global-account/react/hooks/useTWAuth.d.ts

@@ -1,4 +1,7 @@
 import { Wallet } from "thirdweb/wallets";
+/**
+ * @deprecated Use useAuth() with Turnkey authentication instead
+ */
 export declare function useTWAuth(): {
     authenticate: (wallet: Wallet, partnerId: string) => Promise<import("@feathersjs/authentication").AuthenticationResult>;
 };

package/dist/esm/global-account/react/hooks/useTWAuth.js

@@ -1,8 +1,16 @@
+/**
+ * @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 "../../../global-account/app.js";
 import debug from "../../../shared/utils/debug.js";
 import { useCallback } from "react";
 import { useSearchParam } from "./useSearchParamsSSR.js";
+/**
+ * @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(async (wallet, partnerId) => {
         if (!wallet || !wallet?.getAuthToken?.())

package/dist/esm/global-account/react/hooks/useTurnkeyAuth.js

@@ -1,8 +1,9 @@
-import app from "../../app.js";
-import { useAuthStore } from "../stores/index.js";
+import { debugB3React } from "../../../shared/utils/debug.js";
 import { useCallback, useState } from "react";
+import app from "../../app.js";
 import { useB3 } from "../components/B3Provider/useB3.js";
-import { debugB3React } from "../../../shared/utils/debug.js";
+import { useAuthStore } from "../stores/index.js";
+import { useAuth } from "./useAuth.js";
 const debug = debugB3React("useTurnkeyAuth");
 /**
  * Hook for Turnkey email-based OTP authentication
@@ -17,29 +18,55 @@ export function useTurnkeyAuth() {
     const [error, setError] = useState(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) => {
         setIsLoading(true);
         setError(null);
         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 = 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,
+            });
+            // The strategy returns the TurnkeyAuthInitResponse directly
+            const data = response;
             debug(`OTP initialized successfully. OtpId: ${data.otpId}`);
             return data;
         }
         catch (err) {
             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;
         }
@@ -47,11 +74,11 @@ export function useTurnkeyAuth() {
             setIsLoading(false);
             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
      */
@@ -60,19 +87,22 @@ export function useTurnkeyAuth() {
         setError(null);
         setIsAuthenticating(true);
         try {
-            debug(`Verifying OTP...`, { userId: user?.userId });
-            // Step 1: Verify OTP and get Turnkey session JWT
-            const { turnkeySessionJwt } = await app.service("turnkey-auth").verify({
+            debug(`Verifying OTP...`, { otpId });
+            // 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,
             });
-            debug(`OTP verified! Authenticating with b3-api...`);
+            // The strategy returns the TurnkeyAuthVerifyResponse directly
+            const verifyResult = response;
+            const { turnkeySessionJwt } = verifyResult;
+            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,
-            });
+            // Use the unified useAuth hook for authentication with "turnkey-jwt" strategy
+            const authResult = await authenticate(turnkeySessionJwt, partnerId || "");
             debug(`Successfully authenticated with b3-api!`, authResult);
             // Update auth store to reflect authenticated state
             setIsAuthenticated(true);
@@ -92,7 +122,7 @@ export function useTurnkeyAuth() {
             setIsLoading(false);
             setIsAuthenticating(false);
         }
-    }, [user, setIsAuthenticating, setIsAuthenticated]);
+    }, [partnerId, setIsAuthenticating, setIsAuthenticated, authenticate]);
     const clearError = useCallback(() => {
         setError(null);
     }, []);

package/dist/esm/global-account/react/hooks/useUserQuery.d.ts

@@ -36,8 +36,8 @@ export declare function useUserQuery(): {
                 name?: string | undefined;
                 address?: string | undefined;
                 email?: string | undefined;
-                username?: string | undefined;
                 phone?: string | undefined;
+                username?: string | undefined;
                 fid?: string | undefined;
             };
         }[] | undefined;