@b3dotfun/sdk 0.0.82 → 0.0.83-test.0

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

@@ -18,7 +18,7 @@ const in_app_1 = require("thirdweb/wallets/in-app");
 const wagmi_1 = require("wagmi");
 const LocalSDKProvider_1 = require("../components/B3Provider/LocalSDKProvider");
 const createWagmiConfig_1 = require("../utils/createWagmiConfig");
-const useTWAuth_1 = require("./useTWAuth");
+const useAuth_1 = require("./useAuth");
 const useUserQuery_1 = require("./useUserQuery");
 const debug = (0, debug_1.debugB3React)("useAuthentication");
 function useAuthentication(partnerId) {
@@ -36,7 +36,7 @@ function useAuthentication(partnerId) {
     const setHasStartedConnecting = (0, react_1.useAuthStore)(state => state.setHasStartedConnecting);
     const setActiveWallet = (0, react_3.useSetActiveWallet)();
     const hasStartedConnecting = (0, react_1.useAuthStore)(state => state.hasStartedConnecting);
-    const { authenticate } = (0, useTWAuth_1.useTWAuth)();
+    const { reAuthenticate } = (0, useAuth_1.useAuth)();
     const { user, setUser } = (0, useUserQuery_1.useUserQuery)();
     const useAutoConnectLoadingPrevious = (0, react_2.useRef)(false);
     const wagmiConfig = (0, createWagmiConfig_1.createWagmiConfig)({ partnerId });
@@ -96,18 +96,19 @@ function useAuthentication(partnerId) {
     (0, react_2.useEffect)(() => {
         syncWagmi();
     }, [wallets, syncWagmi]);
-    const authenticateUser = (0, react_2.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 = (0, react_2.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_1.default.reAuthenticate();
+            const userAuth = await reAuthenticate();
             setUser(userAuth.user);
             setIsAuthenticated(true);
             setIsAuthenticating(false);
@@ -118,19 +119,19 @@ 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 (0, bsmnt_1.authenticateWithB3JWT)(userAuth.accessToken);
-            debug("@@b3Jwt", b3Jwt);
-            return userAuth;
+            throw new Error("Authentication required. Please authenticate via Turnkey.");
         }
-    }, [activeWallet, partnerId, authenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting]);
+    }, [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 = (0, react_2.useCallback)(async (_walleAutoConnectedWith, allConnectedWallets) => {
         debug("@@useAuthentication:onConnect", { _walleAutoConnectedWith, allConnectedWallets });
         const wallet = allConnectedWallets.find(wallet => wallet.id.startsWith("ecosystem."));
@@ -143,9 +144,19 @@ function useAuthentication(partnerId) {
             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) {

package/dist/cjs/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/cjs/global-account/react/hooks/useTWAuth.js

@@ -4,11 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useTWAuth = useTWAuth;
+/**
+ * @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.
+ */
 const app_1 = __importDefault(require("../../../global-account/app"));
 const debug_1 = __importDefault(require("../../../shared/utils/debug"));
 const react_1 = require("react");
 const useSearchParamsSSR_1 = require("./useSearchParamsSSR");
+/**
+ * @deprecated Use useAuth() with Turnkey authentication instead
+ */
 function useTWAuth() {
+    console.warn("useTWAuth is deprecated. Please migrate to useAuth() with Turnkey authentication. See useTurnkeyAuth.ts for the new implementation.");
     const referralCode = (0, useSearchParamsSSR_1.useSearchParam)("referralCode");
     const authenticate = (0, react_1.useCallback)(async (wallet, partnerId) => {
         if (!wallet || !wallet?.getAuthToken?.())

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

@@ -4,11 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useTurnkeyAuth = useTurnkeyAuth;
-const app_1 = __importDefault(require("../../app"));
-const stores_1 = require("../stores");
+const debug_1 = require("../../../shared/utils/debug");
 const react_1 = require("react");
+const app_1 = __importDefault(require("../../app"));
 const useB3_1 = require("../components/B3Provider/useB3");
-const debug_1 = require("../../../shared/utils/debug");
+const stores_1 = require("../stores");
+const useAuth_1 = require("./useAuth");
 const debug = (0, debug_1.debugB3React)("useTurnkeyAuth");
 /**
  * Hook for Turnkey email-based OTP authentication
@@ -23,29 +24,55 @@ function useTurnkeyAuth() {
     const [error, setError] = (0, react_1.useState)(null);
     const setIsAuthenticating = (0, stores_1.useAuthStore)(state => state.setIsAuthenticating);
     const setIsAuthenticated = (0, stores_1.useAuthStore)(state => state.setIsAuthenticated);
-    const { user } = (0, useB3_1.useB3)();
+    const { partnerId } = (0, useB3_1.useB3)();
+    const { authenticate } = (0, useAuth_1.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 = (0, react_1.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_1.default.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_1.default.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;
         }
@@ -53,11 +80,11 @@ 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
      */
@@ -66,19 +93,22 @@ 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_1.default.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_1.default.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_1.default.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);
@@ -98,7 +128,7 @@ function useTurnkeyAuth() {
             setIsLoading(false);
             setIsAuthenticating(false);
         }
-    }, [user, setIsAuthenticating, setIsAuthenticated]);
+    }, [partnerId, setIsAuthenticating, setIsAuthenticated, authenticate]);
     const clearError = (0, react_1.useCallback)(() => {
         setError(null);
     }, []);

package/dist/esm/global-account/react/components/SignInWithB3/SignInWithB3Flow.js

@@ -3,6 +3,7 @@ import { Loading, useAuthStore, useB3, useGetAllTWSigners, useModalStore, } from
 import { debugB3React } from "../../../../shared/utils/debug.js";
 import { useCallback, useEffect, useState } from "react";
 import { useActiveAccount } from "thirdweb/react";
+import { TurnkeyAuthModal } from "../TurnkeyAuthModal.js";
 import { SignInWithB3Privy } from "./SignInWithB3Privy.js";
 import { LoginStep, LoginStepContainer } from "./steps/LoginStep.js";
 import { LoginStepCustom } from "./steps/LoginStepCustom.js";
@@ -20,7 +21,9 @@ export function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySucce
     const account = useActiveAccount();
     const isAuthenticating = useAuthStore(state => state.isAuthenticating);
     const isAuthenticated = useAuthStore(state => state.isAuthenticated);
+    const setIsAuthenticated = useAuthStore(state => state.setIsAuthenticated);
     const isConnected = useAuthStore(state => state.isConnected);
+    const setIsConnected = useAuthStore(state => state.setIsConnected);
     const setJustCompletedLogin = useAuthStore(state => state.setJustCompletedLogin);
     const [refetchCount, setRefetchCount] = useState(0);
     const [refetchError, setRefetchError] = useState(null);
@@ -122,6 +125,10 @@ export function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySucce
         debug("Refetching user after Turnkey success...");
         await refetchUser();
         debug("User refetched successfully");
+        // Set authentication and connection state so UI updates properly
+        setIsAuthenticated(true);
+        setIsConnected(true);
+        setJustCompletedLogin(true);
         // After user data is refreshed, close Turnkey modal and go back to sign-in flow
         debug("Switching back to signInWithB3 modal");
         setB3ModalContentType({
@@ -151,6 +158,9 @@ export function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySucce
         closeAfterLogin,
         source,
         signersEnabled,
+        setIsAuthenticated,
+        setIsConnected,
+        setJustCompletedLogin,
     ]);
     // Handle post-login flow after signers are loaded
     useEffect(() => {
@@ -286,21 +296,56 @@ export function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySucce
     if (refetchError) {
         content = (_jsx(LoginStepContainer, { partnerId: partnerId, children: _jsx("div", { className: "p-4 text-center text-red-500", children: refetchError }) }));
     }
-    else if (isAuthenticating || (isFetchingSigners && step === "login") || source === "requestPermissions") {
-        content = (_jsx(LoginStepContainer, { partnerId: partnerId, children: _jsx("div", { className: "my-8 flex min-h-[350px] items-center justify-center", children: _jsx(Loading, { variant: "white", size: "lg" }) }) }));
-    }
     else if (step === "login") {
-        // Custom strategy
-        if (strategies?.[0] === "privy") {
-            content = _jsx(SignInWithB3Privy, { onSuccess: handleLoginSuccess, chain: chain });
-        }
-        else if (strategies) {
-            // Strategies are explicitly provided
-            content = (_jsx(LoginStepCustom, { strategies: strategies, chain: chain, onSuccess: handleLoginSuccess, onError: onError, automaticallySetFirstEoa: !!automaticallySetFirstEoa }));
+        // PRIORITY: If Turnkey is enabled, show Turnkey modal FIRST as the primary authentication option
+        // Show Turnkey when enabled and not already completed in this session
+        const shouldShowTurnkeyFirst = enableTurnkey && !turnkeyAuthCompleted;
+        if (shouldShowTurnkeyFirst) {
+            // Don't show loading spinner for Turnkey - let the modal handle its own loading state
+            // This prevents the infinite loop where isAuthenticating causes the modal to be replaced
+            debug("Showing Turnkey as primary authentication option", {
+                enableTurnkey,
+                turnkeyAuthCompleted,
+                isAuthenticated,
+            });
+            // Show Turnkey authentication as primary option
+            content = (_jsx(LoginStepContainer, { partnerId: partnerId, children: _jsx(TurnkeyAuthModal, { onSuccess: async (authenticatedUser) => {
+                        debug("Turnkey authentication successful in primary flow", { authenticatedUser });
+                        setTurnkeyAuthCompleted(true);
+                        // After Turnkey auth, refetch user to get the full user object
+                        await refetchUser();
+                        // User is now authenticated via Turnkey
+                        // Set both isAuthenticated and isConnected to true so UI updates properly
+                        // Wallet connection is optional and can happen later for signing transactions
+                        setIsAuthenticated(true);
+                        setIsConnected(true);
+                        setJustCompletedLogin(true);
+                        // Call the login success callback
+                        onLoginSuccess?.({});
+                    }, onClose: () => {
+                        // If user closes Turnkey modal, they can still use wallet connection as fallback
+                        setTurnkeyAuthCompleted(true);
+                    }, initialEmail: "", skipToOtp: false }) }));
         }
         else {
-            // Default to handle all strategies we support
-            content = _jsx(LoginStep, { chain: chain, onSuccess: handleLoginSuccess, onError: onError });
+            // Show loading spinner only if not in Turnkey flow
+            if (isAuthenticating || (isFetchingSigners && step === "login") || source === "requestPermissions") {
+                content = (_jsx(LoginStepContainer, { partnerId: partnerId, children: _jsx("div", { className: "my-8 flex min-h-[350px] items-center justify-center", children: _jsx(Loading, { variant: "white", size: "lg" }) }) }));
+            }
+            else {
+                // Custom strategy
+                if (strategies?.[0] === "privy") {
+                    content = _jsx(SignInWithB3Privy, { onSuccess: handleLoginSuccess, chain: chain });
+                }
+                else if (strategies) {
+                    // Strategies are explicitly provided
+                    content = (_jsx(LoginStepCustom, { strategies: strategies, chain: chain, onSuccess: handleLoginSuccess, onError: onError, automaticallySetFirstEoa: !!automaticallySetFirstEoa }));
+                }
+                else {
+                    // Default to handle all strategies we support
+                    content = _jsx(LoginStep, { chain: chain, onSuccess: handleLoginSuccess, onError: onError });
+                }
+            }
         }
     }
     return content;

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

@@ -3,6 +3,7 @@ export { useAccountAssets } from "./useAccountAssets";
 export { useAccountWallet } from "./useAccountWallet";
 export { useAddTWSessionKey } from "./useAddTWSessionKey";
 export { useAnalytics } from "./useAnalytics";
+export { useAuth } from "./useAuth";
 export { useAuthentication } from "./useAuthentication";
 export { useB3BalanceFromAddresses } from "./useB3BalanceFromAddresses";
 export { useB3EnsName } from "./useB3EnsName";

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

@@ -3,6 +3,7 @@ export { useAccountAssets } from "./useAccountAssets.js";
 export { useAccountWallet } from "./useAccountWallet.js";
 export { useAddTWSessionKey } from "./useAddTWSessionKey.js";
 export { useAnalytics } from "./useAnalytics.js";
+export { useAuth } from "./useAuth.js";
 export { useAuthentication } from "./useAuthentication.js";
 export { useB3BalanceFromAddresses } from "./useB3BalanceFromAddresses.js";
 export { useB3EnsName } from "./useB3EnsName.js";

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

@@ -0,0 +1,76 @@
+import { Wallet } from "thirdweb/wallets";
+import { preAuthenticate } from "thirdweb/wallets/in-app";
+/**
+ * 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 declare function useAuth(): {
+    authenticate: (turnkeySessionJwt: string, partnerId: string) => Promise<import("@feathersjs/authentication").AuthenticationResult>;
+    reAuthenticate: () => Promise<import("@feathersjs/authentication").AuthenticationResult>;
+    logout: (callback?: () => void) => Promise<void>;
+    isAuthenticated: boolean;
+    isReady: boolean;
+    isConnecting: boolean;
+    isConnected: boolean;
+    wallet: import("thirdweb/dist/types/wallets/in-app/core/wallet/types").EcosystemWallet;
+    preAuthenticate: typeof preAuthenticate;
+    connect: (_walleAutoConnectedWith: Wallet, allConnectedWallets: Wallet[]) => Promise<void>;
+    isAuthenticating: boolean;
+    onConnect: (_walleAutoConnectedWith: Wallet, allConnectedWallets: Wallet[]) => Promise<void>;
+    user: {
+        email?: string | undefined;
+        telNumber?: string | undefined;
+        username?: string | undefined;
+        ens?: string | undefined;
+        avatar?: string | undefined;
+        preferences?: {} | undefined;
+        referredBy?: string | {} | undefined;
+        sourceApp?: string | undefined;
+        referralCode?: string | undefined;
+        userGroups?: number[] | undefined;
+        isMigratedFromBSMNT?: boolean | undefined;
+        privyLinkedAccounts?: {
+            name?: string | undefined;
+            address?: string | undefined;
+            email?: string | undefined;
+            chain_type?: string | undefined;
+            lv?: number | undefined;
+            wallet_client_type?: string | undefined;
+            smart_wallet_type?: string | undefined;
+            subject?: string | undefined;
+            type: string;
+        }[] | undefined;
+        twProfiles?: {
+            type: string;
+            details: {
+                id?: string | undefined;
+                name?: string | undefined;
+                address?: string | undefined;
+                email?: string | undefined;
+                phone?: string | undefined;
+                username?: string | undefined;
+                fid?: string | undefined;
+            };
+        }[] | undefined;
+        turnkeySubOrgs?: {
+            hasDelegatedUser?: boolean | undefined;
+            subOrgId: string;
+            accounts: Record<string, any>[];
+        }[] | undefined;
+        _id: string | {};
+        userId: string;
+        smartAccountAddress: string;
+        createdAt: number;
+        updatedAt: number;
+        partnerIds: {
+            privyId?: string | undefined;
+            thirdwebId?: string | undefined;
+            turnkeyId?: string | undefined;
+            turnkeyOtpId?: string | undefined;
+        };
+    } | undefined;
+    refetchUser: () => Promise<import("@feathersjs/authentication").AuthenticationResult>;
+    setUser: (newUser?: import("@b3dotfun/b3-api").Users) => void;
+};