@b3dotfun/sdk 0.0.83-test.0 → 0.0.83

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

@@ -19,7 +19,7 @@ import { preAuthenticate } from "thirdweb/wallets/in-app";
 import { useAccount, useConnect, useSwitchAccount } from "wagmi";
 import { LocalSDKContext } from "../components/B3Provider/LocalSDKProvider";
 import { createWagmiConfig } from "../utils/createWagmiConfig";
-import { useAuth } from "./useAuth";
+import { useTWAuth } from "./useTWAuth";
 import { useUserQuery } from "./useUserQuery";
 
 const debug = debugB3React("useAuthentication");
@@ -39,7 +39,7 @@ export function useAuthentication(partnerId: string) {
   const setHasStartedConnecting = useAuthStore(state => state.setHasStartedConnecting);
   const setActiveWallet = useSetActiveWallet();
   const hasStartedConnecting = useAuthStore(state => state.hasStartedConnecting);
-  const { reAuthenticate } = useAuth();
+  const { authenticate } = useTWAuth();
   const { user, setUser } = useUserQuery();
   const useAutoConnectLoadingPrevious = useRef(false);
   const wagmiConfig = createWagmiConfig({ partnerId });
@@ -106,104 +106,49 @@ export function useAuthentication(partnerId: string) {
     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 = useCallback(async () => {
-    setHasStartedConnecting(true);
-
-    // Try to re-authenticate first
-    try {
-      const userAuth = await reAuthenticate();
-      setUser(userAuth.user);
-      setIsAuthenticated(true);
-      setIsAuthenticating(false);
-      debug("Re-authenticated successfully", { userAuth });
-
-      // Authenticate on BSMNT with B3 JWT
-      const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
-      debug("@@b3Jwt", b3Jwt);
-
-      return userAuth;
-    } catch (error) {
-      // If re-authentication fails, user needs to authenticate via Turnkey
-      // This should be handled by the Turnkey auth modal/flow
-      debug("Re-authentication failed. User needs to authenticate via Turnkey.", error);
-      setIsAuthenticated(false);
-      setIsAuthenticating(false);
-      throw new Error("Authentication required. Please authenticate via Turnkey.");
-    }
-  }, [reAuthenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting]);
-
-  /**
-   * Handle wallet connection
-   * Note: With Turnkey migration, wallet connection is primarily for signing transactions,
-   * not for authentication. Authentication should be done separately via Turnkey email OTP.
-   */
-  const onConnect = useCallback(
-    async (_walleAutoConnectedWith: Wallet, allConnectedWallets: Wallet[]) => {
-      debug("@@useAuthentication:onConnect", { _walleAutoConnectedWith, allConnectedWallets });
-
-      const wallet = allConnectedWallets.find(wallet => wallet.id.startsWith("ecosystem."));
+  const authenticateUser = useCallback(
+    async (wallet?: Wallet) => {
+      setHasStartedConnecting(true);
 
       if (!wallet) {
-        throw new Error("No smart wallet found during auto-connect");
+        throw new Error("No wallet found during auto-connect");
       }
 
-      debug("@@useAuthentication:onConnect", { wallet });
+      const account = wallet ? wallet.getAccount() : activeWallet?.getAccount();
+      if (!account) {
+        throw new Error("No account found during auto-connect");
+      }
 
+      // Try to re-authenticate first
       try {
-        setHasStartedConnecting(true);
-        setIsConnected(true);
-        setIsAuthenticating(true);
-        await setActiveWallet(wallet);
+        const userAuth = await app.reAuthenticate();
+        setUser(userAuth.user);
+        setIsAuthenticated(true);
+        setIsAuthenticating(false);
+        debug("Re-authenticated successfully", { userAuth });
 
-        // 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();
+        // Authenticate on BSMNT with B3 JWT
+        const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
+        debug("@@b3Jwt", b3Jwt);
 
-          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
-        }
+        return userAuth;
       } catch (error) {
-        debug("@@useAuthentication:onConnect:failed", { error });
-        setIsAuthenticated(false);
-        setUser(undefined);
-      } finally {
+        // If re-authentication fails, try fresh authentication
+        debug("Re-authentication failed, attempting fresh authentication");
+        const userAuth = await authenticate(wallet, partnerId);
+        setUser(userAuth.user);
+        setIsAuthenticated(true);
         setIsAuthenticating(false);
-      }
+        debug("Fresh authentication successful", { userAuth });
 
-      debug({
-        isAuthenticated,
-        isAuthenticating,
-        isConnected,
-      });
+        // Authenticate on BSMNT with B3 JWT
+        const b3Jwt = await authenticateWithB3JWT(userAuth.accessToken);
+        debug("@@b3Jwt", b3Jwt);
+
+        return userAuth;
+      }
     },
-    [
-      onConnectCallback,
-      authenticateUser,
-      isAuthenticated,
-      isAuthenticating,
-      isConnected,
-      setActiveWallet,
-      setHasStartedConnecting,
-      setIsAuthenticated,
-      setIsAuthenticating,
-      setIsConnected,
-      setUser,
-    ],
+    [activeWallet, partnerId, authenticate, setIsAuthenticated, setIsAuthenticating, setUser, setHasStartedConnecting],
   );
 
   const logout = useCallback(
@@ -240,6 +185,58 @@ export function useAuthentication(partnerId: string) {
     [activeWallet, disconnect, wallets, setIsAuthenticated, setUser, setIsConnected],
   );
 
+  const onConnect = useCallback(
+    async (_walleAutoConnectedWith: Wallet, allConnectedWallets: Wallet[]) => {
+      debug("@@useAuthentication:onConnect", { _walleAutoConnectedWith, allConnectedWallets });
+      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);
+        }
+      } catch (error) {
+        debug("@@useAuthentication:onConnect:failed", { error });
+        setIsAuthenticated(false);
+        setUser(undefined);
+
+        await logout();
+      } finally {
+        setIsAuthenticating(false);
+      }
+
+      debug({
+        isAuthenticated,
+        isAuthenticating,
+        isConnected,
+      });
+    },
+    [
+      isAuthenticated,
+      isAuthenticating,
+      isConnected,
+      setHasStartedConnecting,
+      setIsConnected,
+      setIsAuthenticating,
+      setActiveWallet,
+      authenticateUser,
+      onConnectCallback,
+      setIsAuthenticated,
+      setUser,
+      logout,
+    ],
+  );
+
   const { isLoading: useAutoConnectLoading } = useAutoConnect({
     client,
     wallets: [wallet],

package/src/global-account/react/hooks/useTWAuth.tsx

@@ -1,20 +1,10 @@
-/**
- * @deprecated This hook is deprecated. Use useAuth() with Turnkey authentication instead.
- * This file is kept for backward compatibility but should not be used in new code.
- */
 import app from "@b3dotfun/sdk/global-account/app";
 import debug from "@b3dotfun/sdk/shared/utils/debug";
 import { useCallback } from "react";
 import { Wallet } from "thirdweb/wallets";
 import { useSearchParam } from "./useSearchParamsSSR";
 
-/**
- * @deprecated Use useAuth() with Turnkey authentication instead
- */
 export function useTWAuth() {
-  console.warn(
-    "useTWAuth is deprecated. Please migrate to useAuth() with Turnkey authentication. See useTurnkeyAuth.ts for the new implementation.",
-  );
   const referralCode = useSearchParam("referralCode");
 
   const authenticate = useCallback(

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

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

package/dist/cjs/anyspend/react/hooks/useAutoSetActiveWalletFromWagmi.d.ts

@@ -1,10 +0,0 @@
-/**
- * Hook that automatically sets the active thirdweb wallet when a wagmi wallet connects.
- *
- * This is useful for syncing wagmi wallet connections with thirdweb's wallet system,
- * ensuring that when users connect via wagmi, the active wallet is properly set.
- *
- * Place this hook in components that stay mounted throughout the user flow
- * (not in components that unmount during navigation).
- */
-export declare function useAutoSetActiveWalletFromWagmi(): void;

package/dist/cjs/anyspend/react/hooks/useAutoSetActiveWalletFromWagmi.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useAutoSetActiveWalletFromWagmi = useAutoSetActiveWalletFromWagmi;
-const thirdweb_1 = require("../../../shared/utils/thirdweb");
-const react_1 = require("react");
-const react_2 = require("thirdweb/react");
-const wallets_1 = require("thirdweb/wallets");
-const wagmi_1 = require("wagmi");
-/**
- * Hook that automatically sets the active thirdweb wallet when a wagmi wallet connects.
- *
- * This is useful for syncing wagmi wallet connections with thirdweb's wallet system,
- * ensuring that when users connect via wagmi, the active wallet is properly set.
- *
- * Place this hook in components that stay mounted throughout the user flow
- * (not in components that unmount during navigation).
- */
-function useAutoSetActiveWalletFromWagmi() {
-    const { address: wagmiAddress, connector: wagmiConnector } = (0, wagmi_1.useAccount)();
-    const setActiveWallet = (0, react_2.useSetActiveWallet)();
-    const prevWagmiAddress = (0, react_1.useRef)(undefined);
-    // Map wagmi connector names to thirdweb wallet IDs
-    const getThirdwebWalletId = (0, react_1.useCallback)((connectorName) => {
-        const walletMap = {
-            MetaMask: "io.metamask",
-            "Coinbase Wallet": "com.coinbase.wallet",
-            Rainbow: "me.rainbow",
-            WalletConnect: "walletConnect",
-            Phantom: "app.phantom",
-        };
-        return walletMap[connectorName] || null;
-    }, []);
-    // Create thirdweb wallet from wagmi connector
-    const createThirdwebWalletFromConnector = (0, react_1.useCallback)(async (connectorName) => {
-        const walletId = getThirdwebWalletId(connectorName);
-        if (!walletId) {
-            console.warn(`No thirdweb wallet ID found for connector: ${connectorName}`);
-            return null;
-        }
-        try {
-            const thirdwebWallet = (0, wallets_1.createWallet)(walletId);
-            await thirdwebWallet.connect({ client: thirdweb_1.client });
-            return thirdwebWallet;
-        }
-        catch (error) {
-            console.error(`Failed to create thirdweb wallet for ${connectorName}:`, error);
-            return null;
-        }
-    }, [getThirdwebWalletId]);
-    // Listen for wagmi wallet connections and automatically set active wallet
-    (0, react_1.useEffect)(() => {
-        const isNewConnection = wagmiAddress && wagmiAddress !== prevWagmiAddress.current;
-        if (isNewConnection && wagmiConnector?.name) {
-            prevWagmiAddress.current = wagmiAddress;
-            const setupThirdwebWallet = async () => {
-                try {
-                    const thirdwebWallet = await createThirdwebWalletFromConnector(wagmiConnector.name);
-                    if (thirdwebWallet) {
-                        setActiveWallet(thirdwebWallet);
-                        console.log(`Auto-set active wallet for ${wagmiConnector.name}`);
-                    }
-                }
-                catch (error) {
-                    console.error("Failed to auto-set active wallet:", error);
-                }
-            };
-            setupThirdwebWallet();
-        }
-        if (!wagmiAddress) {
-            prevWagmiAddress.current = undefined;
-        }
-    }, [wagmiAddress, wagmiConnector?.name, setActiveWallet, createThirdwebWalletFromConnector]);
-}

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

@@ -1,76 +0,0 @@
-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;
-};