@b3dotfun/sdk 0.0.88 → 0.0.89-alpha.1

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

@@ -0,0 +1,337 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuth = useAuth;
+const app_1 = __importDefault(require("../../../global-account/app"));
+const bsmnt_1 = require("../../../global-account/bsmnt");
+const react_1 = require("../../../global-account/react");
+const constants_1 = require("../../../shared/constants");
+const debug_1 = require("../../../shared/utils/debug");
+const thirdweb_1 = require("../../../shared/utils/thirdweb");
+const core_1 = require("@wagmi/core");
+const react_2 = require("react");
+const react_3 = require("thirdweb/react");
+const wallets_1 = require("thirdweb/wallets");
+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 useSearchParamsSSR_1 = require("./useSearchParamsSSR");
+const useUserQuery_1 = require("./useUserQuery");
+const debug = (0, debug_1.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
+ */
+function useAuth() {
+    const { onConnectCallback } = (0, react_2.useContext)(LocalSDKProvider_1.LocalSDKContext);
+    const { disconnect } = (0, react_3.useDisconnect)();
+    const wallets = (0, react_3.useConnectedWallets)();
+    const activeWallet = (0, react_3.useActiveWallet)();
+    const isAuthenticated = (0, react_1.useAuthStore)(state => state.isAuthenticated);
+    const setIsAuthenticated = (0, react_1.useAuthStore)(state => state.setIsAuthenticated);
+    const setIsConnected = (0, react_1.useAuthStore)(state => state.setIsConnected);
+    const isConnecting = (0, react_1.useAuthStore)(state => state.isConnecting);
+    const isConnected = (0, react_1.useAuthStore)(state => state.isConnected);
+    const isAuthenticating = (0, react_1.useAuthStore)(state => state.isAuthenticating);
+    const setIsAuthenticating = (0, react_1.useAuthStore)(state => state.setIsAuthenticating);
+    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 useAutoConnectLoadingPrevious = (0, react_2.useRef)(false);
+    const referralCode = (0, useSearchParamsSSR_1.useSearchParam)("referralCode");
+    const { partnerId } = (0, react_1.useB3Config)();
+    const wagmiConfig = (0, createWagmiConfig_1.createWagmiConfig)({ partnerId });
+    const { connect } = (0, wagmi_1.useConnect)();
+    const activeWagmiAccount = (0, wagmi_1.useAccount)();
+    const { switchAccount } = (0, wagmi_1.useSwitchAccount)();
+    const { user, setUser } = (0, useUserQuery_1.useUserQuery)();
+    debug("@@activeWagmiAccount", activeWagmiAccount);
+    const wallet = (0, wallets_1.ecosystemWallet)(constants_1.ecosystemWalletId, {
+        partnerId: partnerId,
+    });
+    /**
+     * Re-authenticate using existing session
+     * Also updates user state and authenticates with BSMNT
+     */
+    const reAuthenticate = (0, react_2.useCallback)(async () => {
+        debug("Re-authenticating...");
+        try {
+            const response = await app_1.default.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 (0, bsmnt_1.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) {
+            debug("Re-authentication failed", err);
+            throw err;
+        }
+    }, [setUser]);
+    const syncWagmi = (0, react_2.useCallback)(async () => {
+        function syncWagmiFunc() {
+            const connectors = (0, core_1.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 === constants_1.ecosystemWalletId)) {
+                    try {
+                        const options = {
+                            wallet: twWallet, // the connected wallet
+                        };
+                        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]);
+    (0, react_2.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 = (0, react_2.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 (0, bsmnt_1.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 = (0, react_2.useCallback)(async (turnkeySessionJwt, partnerId) => {
+        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_1.default.authenticate({
+                strategy: "turnkey-jwt",
+                accessToken: turnkeySessionJwt,
+                referralCode,
+                partnerId: partnerId,
+            });
+            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 (0, bsmnt_1.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) {
+            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 = (0, react_2.useCallback)(async (_walleAutoConnectedWith, allConnectedWallets) => {
+        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 = (0, react_2.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_1.default.logout();
+        debug("@@logout:loggedOut");
+        setIsAuthenticated(false);
+        setIsConnected(false);
+        setUser();
+        callback?.();
+    }, [activeWallet, disconnect, wallets, setIsAuthenticated, setUser, setIsConnected]);
+    const { isLoading: useAutoConnectLoading } = (0, react_3.useAutoConnect)({
+        client: thirdweb_1.client,
+        wallets: [wallet],
+        onConnect,
+        onTimeout: () => {
+            logout().catch(error => {
+                debug("@@useAuth:logout on timeout failed", { error });
+            });
+        },
+    });
+    /**
+     * useAutoConnectLoading starts as false
+     */
+    (0, react_2.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: in_app_1.preAuthenticate,
+        connect: onConnect,
+        isAuthenticating,
+        onConnect,
+        user,
+        refetchUser: authenticateUser,
+        setUser,
+    };
+}

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

@@ -8,7 +8,7 @@ const client_manager_1 = require("../../client-manager");
  * Hook to access the current FeathersJS client and client management utilities
  */
 function useClient() {
-    const { clientType } = (0, react_1.useB3)();
+    const { clientType } = (0, react_1.useB3Config)();
     const getCurrentClient = (0, react_2.useCallback)(() => {
         return (0, client_manager_1.getClient)();
     }, []);

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

@@ -11,7 +11,7 @@ const debug = (0, debug_1.debugB3React)("@@b3:useHandleConnectWithPrivy");
  * Currently, this is for the basement-privy strategy
  */
 function useHandleConnectWithPrivy(chain, onSuccess) {
-    const { partnerId } = (0, react_1.useB3)();
+    const { partnerId } = (0, react_1.useB3Config)();
     if (!chain) {
         throw new Error("Chain is required");
     }

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useNotifications = useNotifications;
+const react_1 = require("../../../global-account/react");
 const auth_token_1 = require("../../../shared/utils/auth-token");
 const debug_1 = require("../../../shared/utils/debug");
-const react_1 = require("react");
-const components_1 = require("../components");
+const react_2 = require("react");
 const notificationsAPI_1 = require("../utils/notificationsAPI");
 const useUserQuery_1 = require("./useUserQuery");
 const debug = (0, debug_1.debugB3React)("useNotifications");
@@ -30,14 +30,14 @@ const debug = (0, debug_1.debugB3React)("useNotifications");
  */
 function useNotifications() {
     const { user } = (0, useUserQuery_1.useUserQuery)();
-    const { partnerId } = (0, components_1.useB3)();
-    const [userData, setUserData] = (0, react_1.useState)(null);
-    const [loading, setLoading] = (0, react_1.useState)(true);
-    const [error, setError] = (0, react_1.useState)(null);
-    const [telegramStatus, setTelegramStatus] = (0, react_1.useState)("idle");
+    const { partnerId } = (0, react_1.useB3Config)();
+    const [userData, setUserData] = (0, react_2.useState)(null);
+    const [loading, setLoading] = (0, react_2.useState)(true);
+    const [error, setError] = (0, react_2.useState)(null);
+    const [telegramStatus, setTelegramStatus] = (0, react_2.useState)("idle");
     const userId = user?.userId;
     const jwtToken = (0, auth_token_1.getAuthToken)();
-    const loadUserData = (0, react_1.useCallback)(async () => {
+    const loadUserData = (0, react_2.useCallback)(async () => {
         if (!userId || !jwtToken) {
             setLoading(false);
             return;
@@ -66,10 +66,10 @@ function useNotifications() {
             setLoading(false);
         }
     }, [userId, jwtToken]);
-    (0, react_1.useEffect)(() => {
+    (0, react_2.useEffect)(() => {
         loadUserData();
     }, [loadUserData]);
-    const createDefaultNotificationSettings = (0, react_1.useCallback)(async () => {
+    const createDefaultNotificationSettings = (0, react_2.useCallback)(async () => {
         if (!userId || !jwtToken)
             return;
         try {
@@ -80,7 +80,7 @@ function useNotifications() {
             debug("Error creating default notification settings:", err);
         }
     }, [userId, jwtToken, partnerId]);
-    const connectEmail = (0, react_1.useCallback)(async (email) => {
+    const connectEmail = (0, react_2.useCallback)(async (email) => {
         if (!userId || !jwtToken) {
             throw new Error("User not authenticated");
         }
@@ -94,7 +94,7 @@ function useNotifications() {
             throw new Error("Failed to connect email");
         }
     }, [userId, jwtToken, loadUserData, createDefaultNotificationSettings]);
-    const connectTelegram = (0, react_1.useCallback)(async () => {
+    const connectTelegram = (0, react_2.useCallback)(async () => {
         if (!userId || !jwtToken) {
             throw new Error("User not authenticated");
         }
@@ -138,7 +138,7 @@ function useNotifications() {
             throw new Error("Failed to connect Telegram");
         }
     }, [userId, jwtToken, loadUserData, createDefaultNotificationSettings]);
-    const disconnectChannel = (0, react_1.useCallback)(async (channelType) => {
+    const disconnectChannel = (0, react_2.useCallback)(async (channelType) => {
         if (!userId || !jwtToken) {
             throw new Error("User not authenticated");
         }
@@ -154,7 +154,7 @@ function useNotifications() {
             throw new Error(`Failed to disconnect ${channelType}`);
         }
     }, [userId, jwtToken, loadUserData]);
-    const sendTestNotification = (0, react_1.useCallback)(async () => {
+    const sendTestNotification = (0, react_2.useCallback)(async () => {
         if (!userId || !jwtToken) {
             throw new Error("User not authenticated");
         }

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/useTokenBalance.js

@@ -9,7 +9,7 @@ const thirdweb_insights_1 = require("../../../shared/utils/thirdweb-insights");
 const react_query_1 = require("@tanstack/react-query");
 const react_2 = require("react");
 function useTokenBalance({ token, address }) {
-    const { ready } = (0, react_1.useB3)();
+    const isAuthenticated = (0, react_1.useAuthStore)(state => state.isAuthenticated);
     const account = (0, react_1.useAccountWallet)();
     const effectiveAddress = address || account?.address;
     const { data: tokenBalance, isLoading, isFetching, refetch, } = (0, react_query_1.useQuery)({
@@ -41,7 +41,7 @@ function useTokenBalance({ token, address }) {
             }
             return { formatted: "0", raw: null };
         },
-        enabled: ready && !!effectiveAddress,
+        enabled: isAuthenticated && !!effectiveAddress,
         staleTime: 30000,
         gcTime: 5 * 60 * 1000,
         retry: 2,
@@ -49,12 +49,12 @@ function useTokenBalance({ token, address }) {
     });
     // Force a refetch when the wallet or token changes
     (0, react_2.useEffect)(() => {
-        if (ready && effectiveAddress) {
+        if (isAuthenticated && effectiveAddress) {
             refetch();
         }
-    }, [ready, effectiveAddress, token.address, token.chainId, token.symbol, refetch]);
+    }, [isAuthenticated, effectiveAddress, token.address, token.chainId, token.symbol, refetch]);
     // Determine if we're actually loading
-    const isActuallyLoading = !ready || !effectiveAddress || isLoading || (isFetching && !tokenBalance);
+    const isActuallyLoading = !isAuthenticated || !effectiveAddress || isLoading || (isFetching && !tokenBalance);
     return {
         rawBalance: tokenBalance?.raw || BigInt(0),
         formattedBalance: tokenBalance?.formatted || "0",

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

@@ -10,8 +10,8 @@ const react_query_1 = require("@tanstack/react-query");
 const b3Chain_1 = require("../../../shared/constants/chains/b3Chain");
 const chains_1 = require("../../../shared/utils/chains");
 const thirdweb_1 = require("../../../shared/utils/thirdweb");
-const wallets_1 = require("thirdweb/wallets");
 const invariant_1 = __importDefault(require("invariant"));
+const wallets_1 = require("thirdweb/wallets");
 function useTokenBalancesByChain({ address, chainsIds, enabled = true, }) {
     // Normalize chains to array
     const chainIds = Array.isArray(chainsIds) ? chainsIds : [chainsIds];
@@ -52,7 +52,9 @@ function useTokenBalancesByChain({ address, chainsIds, enabled = true, }) {
         staleTime: 30000, // Consider data fresh for 30 seconds
         gcTime: 5 * 60 * 1000, // Keep in cache for 5 minutes
         retry: 2, // Limit retries on failure
-        structuralSharing: false,
+        // Enable structural sharing to prevent infinite loops
+        // This ensures we only get new references when data actually changes
+        structuralSharing: true,
     });
     return {
         nativeTokens: combinedData?.nativeTokens ?? [],

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

@@ -9,7 +9,7 @@ const react_1 = require("react");
 const app_1 = __importDefault(require("../../app"));
 const components_1 = require("../components");
 const stores_1 = require("../stores");
-const useAuthentication_1 = require("./useAuthentication");
+const useAuth_1 = require("./useAuth");
 const debug = (0, debug_1.debugB3React)("useTurnkeyAuth");
 /**
  * Hook for Turnkey email-based OTP authentication
@@ -25,29 +25,54 @@ function useTurnkeyAuth() {
     const setIsAuthenticating = (0, stores_1.useAuthStore)(state => state.setIsAuthenticating);
     const setIsAuthenticated = (0, stores_1.useAuthStore)(state => state.setIsAuthenticated);
     const { partnerId } = (0, components_1.useB3Config)();
-    const { user } = (0, useAuthentication_1.useAuthentication)(partnerId);
+    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;
         }
@@ -55,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
      */
@@ -68,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);
@@ -100,7 +128,7 @@ function useTurnkeyAuth() {
             setIsLoading(false);
             setIsAuthenticating(false);
         }
-    }, [user, setIsAuthenticating, setIsAuthenticated]);
+    }, [partnerId, setIsAuthenticating, setIsAuthenticated, authenticate]);
     const clearError = (0, react_1.useCallback)(() => {
         setError(null);
     }, []);