@b3dotfun/sdk 0.0.82 → 0.0.83-test.0

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

@@ -6,6 +6,7 @@ const react_1 = require("../../../../global-account/react");
 const debug_1 = require("../../../../shared/utils/debug");
 const react_2 = require("react");
 const react_3 = require("thirdweb/react");
+const TurnkeyAuthModal_1 = require("../TurnkeyAuthModal");
 const SignInWithB3Privy_1 = require("./SignInWithB3Privy");
 const LoginStep_1 = require("./steps/LoginStep");
 const LoginStepCustom_1 = require("./steps/LoginStepCustom");
@@ -23,7 +24,9 @@ function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySuccess, onE
     const account = (0, react_3.useActiveAccount)();
     const isAuthenticating = (0, react_1.useAuthStore)(state => state.isAuthenticating);
     const isAuthenticated = (0, react_1.useAuthStore)(state => state.isAuthenticated);
+    const setIsAuthenticated = (0, react_1.useAuthStore)(state => state.setIsAuthenticated);
     const isConnected = (0, react_1.useAuthStore)(state => state.isConnected);
+    const setIsConnected = (0, react_1.useAuthStore)(state => state.setIsConnected);
     const setJustCompletedLogin = (0, react_1.useAuthStore)(state => state.setJustCompletedLogin);
     const [refetchCount, setRefetchCount] = (0, react_2.useState)(0);
     const [refetchError, setRefetchError] = (0, react_2.useState)(null);
@@ -125,6 +128,10 @@ function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySuccess, onE
         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({
@@ -154,6 +161,9 @@ function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySuccess, onE
         closeAfterLogin,
         source,
         signersEnabled,
+        setIsAuthenticated,
+        setIsConnected,
+        setJustCompletedLogin,
     ]);
     // Handle post-login flow after signers are loaded
     (0, react_2.useEffect)(() => {
@@ -289,21 +299,56 @@ function SignInWithB3Flow({ strategies, onLoginSuccess, onSessionKeySuccess, onE
     if (refetchError) {
         content = ((0, jsx_runtime_1.jsx)(LoginStep_1.LoginStepContainer, { partnerId: partnerId, children: (0, jsx_runtime_1.jsx)("div", { className: "p-4 text-center text-red-500", children: refetchError }) }));
     }
-    else if (isAuthenticating || (isFetchingSigners && step === "login") || source === "requestPermissions") {
-        content = ((0, jsx_runtime_1.jsx)(LoginStep_1.LoginStepContainer, { partnerId: partnerId, children: (0, jsx_runtime_1.jsx)("div", { className: "my-8 flex min-h-[350px] items-center justify-center", children: (0, jsx_runtime_1.jsx)(react_1.Loading, { variant: "white", size: "lg" }) }) }));
-    }
     else if (step === "login") {
-        // Custom strategy
-        if (strategies?.[0] === "privy") {
-            content = (0, jsx_runtime_1.jsx)(SignInWithB3Privy_1.SignInWithB3Privy, { onSuccess: handleLoginSuccess, chain: chain });
-        }
-        else if (strategies) {
-            // Strategies are explicitly provided
-            content = ((0, jsx_runtime_1.jsx)(LoginStepCustom_1.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 = ((0, jsx_runtime_1.jsx)(LoginStep_1.LoginStepContainer, { partnerId: partnerId, children: (0, jsx_runtime_1.jsx)(TurnkeyAuthModal_1.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 = (0, jsx_runtime_1.jsx)(LoginStep_1.LoginStep, { chain: chain, onSuccess: handleLoginSuccess, onError: onError });
+            // Show loading spinner only if not in Turnkey flow
+            if (isAuthenticating || (isFetchingSigners && step === "login") || source === "requestPermissions") {
+                content = ((0, jsx_runtime_1.jsx)(LoginStep_1.LoginStepContainer, { partnerId: partnerId, children: (0, jsx_runtime_1.jsx)("div", { className: "my-8 flex min-h-[350px] items-center justify-center", children: (0, jsx_runtime_1.jsx)(react_1.Loading, { variant: "white", size: "lg" }) }) }));
+            }
+            else {
+                // Custom strategy
+                if (strategies?.[0] === "privy") {
+                    content = (0, jsx_runtime_1.jsx)(SignInWithB3Privy_1.SignInWithB3Privy, { onSuccess: handleLoginSuccess, chain: chain });
+                }
+                else if (strategies) {
+                    // Strategies are explicitly provided
+                    content = ((0, jsx_runtime_1.jsx)(LoginStepCustom_1.LoginStepCustom, { strategies: strategies, chain: chain, onSuccess: handleLoginSuccess, onError: onError, automaticallySetFirstEoa: !!automaticallySetFirstEoa }));
+                }
+                else {
+                    // Default to handle all strategies we support
+                    content = (0, jsx_runtime_1.jsx)(LoginStep_1.LoginStep, { chain: chain, onSuccess: handleLoginSuccess, onError: onError });
+                }
+            }
         }
     }
     return content;

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

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useURLParams = exports.useUnifiedChainSwitchAndExecute = exports.useTurnkeyAuth = exports.useTokensFromAddress = exports.useTokenPriceWithFallback = exports.useTokenPrice = exports.useTokenFromUrl = exports.useTokenData = exports.useTokenBalancesByChain = exports.useTokenBalanceDirect = exports.useTokenBalance = exports.useSiwe = exports.useSimSvmBalance = exports.useSimBalance = exports.useSearchParamsSSR = exports.useRouter = exports.useRemoveSessionKey = exports.useQueryBSMNT = exports.useQueryB3 = exports.useProfileSettings = exports.useProfilePreference = exports.useProfile = exports.useDisplayName = exports.useOneBalance = exports.useNotifications = exports.useNativeBalanceFromRPC = exports.useNativeBalance = exports.useMediaQuery = exports.useIsomorphicLayoutEffect = exports.useIsMobile = exports.useHasMounted = exports.useHandleConnectWithPrivy = exports.useGlobalAccount = exports.useGetGeo = exports.useGetAllTWSigners = exports.useFirstEOA = exports.useExchangeRate = exports.useConnect = exports.useClient = exports.useChainSwitchWithAction = exports.useBestTransactionPath = exports.useB3EnsName = exports.useB3BalanceFromAddresses = exports.useAuthentication = exports.useAnalytics = exports.useAddTWSessionKey = exports.useAccountWallet = exports.useAccountAssets = exports.createWagmiConfig = void 0;
+exports.useURLParams = exports.useUnifiedChainSwitchAndExecute = exports.useTurnkeyAuth = exports.useTokensFromAddress = exports.useTokenPriceWithFallback = exports.useTokenPrice = exports.useTokenFromUrl = exports.useTokenData = exports.useTokenBalancesByChain = exports.useTokenBalanceDirect = exports.useTokenBalance = exports.useSiwe = exports.useSimSvmBalance = exports.useSimBalance = exports.useSearchParamsSSR = exports.useRouter = exports.useRemoveSessionKey = exports.useQueryBSMNT = exports.useQueryB3 = exports.useProfileSettings = exports.useProfilePreference = exports.useProfile = exports.useDisplayName = exports.useOneBalance = exports.useNotifications = exports.useNativeBalanceFromRPC = exports.useNativeBalance = exports.useMediaQuery = exports.useIsomorphicLayoutEffect = exports.useIsMobile = exports.useHasMounted = exports.useHandleConnectWithPrivy = exports.useGlobalAccount = exports.useGetGeo = exports.useGetAllTWSigners = exports.useFirstEOA = exports.useExchangeRate = exports.useConnect = exports.useClient = exports.useChainSwitchWithAction = exports.useBestTransactionPath = exports.useB3EnsName = exports.useB3BalanceFromAddresses = exports.useAuthentication = exports.useAuth = exports.useAnalytics = exports.useAddTWSessionKey = exports.useAccountWallet = exports.useAccountAssets = exports.createWagmiConfig = void 0;
 var createWagmiConfig_1 = require("../utils/createWagmiConfig");
 Object.defineProperty(exports, "createWagmiConfig", { enumerable: true, get: function () { return createWagmiConfig_1.createWagmiConfig; } });
 var useAccountAssets_1 = require("./useAccountAssets");
@@ -25,6 +25,8 @@ var useAddTWSessionKey_1 = require("./useAddTWSessionKey");
 Object.defineProperty(exports, "useAddTWSessionKey", { enumerable: true, get: function () { return useAddTWSessionKey_1.useAddTWSessionKey; } });
 var useAnalytics_1 = require("./useAnalytics");
 Object.defineProperty(exports, "useAnalytics", { enumerable: true, get: function () { return useAnalytics_1.useAnalytics; } });
+var useAuth_1 = require("./useAuth");
+Object.defineProperty(exports, "useAuth", { enumerable: true, get: function () { return useAuth_1.useAuth; } });
 var useAuthentication_1 = require("./useAuthentication");
 Object.defineProperty(exports, "useAuthentication", { enumerable: true, get: function () { return useAuthentication_1.useAuthentication; } });
 var useB3BalanceFromAddresses_1 = require("./useB3BalanceFromAddresses");

package/dist/cjs/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;
+};

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

@@ -0,0 +1,338 @@
+"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 useB3_1 = require("../components/B3Provider/useB3");
+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, useB3_1.useB3)();
+    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/useAuthentication.d.ts

@@ -63,6 +63,6 @@ export declare function useAuthentication(partnerId: string): {
             turnkeyOtpId?: string | undefined;
         };
     } | undefined;
-    refetchUser: (wallet?: Wallet) => Promise<import("@feathersjs/authentication").AuthenticationResult>;
+    refetchUser: () => Promise<import("@feathersjs/authentication").AuthenticationResult>;
     setUser: (newUser?: import("@b3dotfun/b3-api").Users) => void;
 };