thirdweb 5.29.2 → 5.29.3-nightly-476b6cc271b0891fa01fb09ca509c564b850ccfa-20240614185219

package/src/wallets/in-app/web/lib/auth/index.ts

@@ -1,266 +1,141 @@
 import type { ThirdwebClient } from "../../../../../client/client.js";
-import type {
-  AuthAndWalletRpcReturnType,
-  AuthLoginReturnType,
-  AuthStoredTokenWithCookieReturnType,
-  LogoutReturnType,
-  SendEmailOtpReturnType,
+import {
+  type AuthArgsType,
+  type AuthLoginReturnType,
+  type GetAuthenticatedUserParams,
+  type PreAuthArgsType,
+  UserWalletStatus,
 } from "../../../core/authentication/type.js";
-import type { ClientIdWithQuerierType } from "../../types.js";
-import { LocalStorage } from "../../utils/Storage/LocalStorage.js";
-import type { InAppWalletIframeCommunicator } from "../../utils/iFrameCommunication/InAppWalletIframeCommunicator.js";
-import { BaseLogin } from "./base-login.js";
+import { getOrCreateInAppWalletConnector } from "../../../core/wallet/in-app-core.js";
 
-export type AuthQuerierTypes = {
-  logout: undefined;
-  initIframe: {
-    clientId: string;
-    authCookie: string;
-    walletUserId: string;
-    deviceShareStored: string;
-  };
-  loginWithStoredTokenDetails: {
-    storedToken: AuthStoredTokenWithCookieReturnType["storedToken"];
-    recoveryCode?: string;
-  };
-};
+// ---- KEEP IN SYNC WITH /wallets/in-app/native/auth/index.ts ---- //
+// duplication needed for separate exports between web and native
 
 /**
- *
+ * @internal
  */
-export class Auth {
-  protected client: ThirdwebClient;
-  protected AuthQuerier: InAppWalletIframeCommunicator<AuthQuerierTypes>;
-  protected localStorage: LocalStorage;
-  protected onAuthSuccess: (
-    authResults: AuthAndWalletRpcReturnType,
-  ) => Promise<AuthLoginReturnType>;
-  private BaseLogin: BaseLogin;
-
-  /**
-   * Used to manage the user's auth states. This should not be instantiated directly.
-   * Call {@link InAppWalletSdk.auth} instead.
-   * @internal
-   */
-  constructor({
-    client,
-    querier,
-    onAuthSuccess,
-    baseUrl,
-  }: ClientIdWithQuerierType & {
-    baseUrl: string;
-    onAuthSuccess: (
-      authDetails: AuthAndWalletRpcReturnType,
-    ) => Promise<AuthLoginReturnType>;
-  }) {
-    this.client = client;
-
-    this.AuthQuerier = querier;
-    this.localStorage = new LocalStorage({ clientId: client.clientId });
-    this.onAuthSuccess = onAuthSuccess;
-    this.BaseLogin = new BaseLogin({
-      postLogin: async (result) => {
-        return this.postLogin(result);
-      },
-      preLogin: async () => {
-        await this.preLogin();
-      },
-      querier: querier,
-      client,
-      baseUrl,
+async function getInAppWalletConnector(client: ThirdwebClient) {
+  return getOrCreateInAppWalletConnector(client, async (client) => {
+    const { InAppWebConnector } = await import("../web-connector.js");
+    return new InAppWebConnector({
+      client: client,
     });
-  }
-
-  private async preLogin() {
-    await this.logout();
-  }
+  });
+}
 
-  private async postLogin({
-    storedToken,
-    walletDetails,
-  }: AuthAndWalletRpcReturnType): Promise<AuthLoginReturnType> {
-    if (storedToken.shouldStoreCookieString) {
-      await this.localStorage.saveAuthCookie(storedToken.cookieString);
+/**
+ * Retrieves the authenticated user for the active in-app wallet.
+ * @param options - The arguments for retrieving the authenticated user.
+ * @returns The authenticated user if logged in and wallet initialized, otherwise undefined.
+ * @example
+ * ```ts
+ * import { getAuthenticatedUser } from "thirdweb/wallets/in-app";
+ *
+ * const user = await getAuthenticatedUser({ client });
+ * if (user) {
+ *  console.log(user.walletAddress);
+ * }
+ * ```
+ * @wallet
+ */
+export async function getAuthenticatedUser(
+  options: GetAuthenticatedUserParams,
+) {
+  const { client } = options;
+  const connector = await getInAppWalletConnector(client);
+  const user = await connector.getUser();
+  switch (user.status) {
+    case UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED: {
+      return user;
     }
-    const initializedUser = await this.onAuthSuccess({
-      storedToken,
-      walletDetails,
-    });
-    return initializedUser;
-  }
-
-  async loginWithAuthToken(
-    authToken: AuthStoredTokenWithCookieReturnType,
-    recoveryCode?: string,
-  ): Promise<AuthLoginReturnType> {
-    await this.preLogin();
-    const result = await this.AuthQuerier.call<AuthAndWalletRpcReturnType>({
-      procedureName: "loginWithStoredTokenDetails",
-      params: {
-        storedToken: authToken.storedToken,
-        recoveryCode,
-      },
-    });
-    return this.postLogin(result);
-  }
-
-  /**
-   * Used to log the user into their thirdweb wallet on your platform via a myriad of auth providers
-   * @example
-   * ```typescript
-   * const thirdwebInAppWallet = new InAppWalletSdk({clientId: "YOUR_CLIENT_ID", chain: "Polygon"})
-   * try {
-   *   const user = await thirdwebInAppWallet.auth.loginWithModal();
-   *   // user is now logged in
-   * } catch (e) {
-   *   // User closed modal or something else went wrong during the authentication process
-   *   console.error(e)
-   * }
-   * ```
-   * @returns `{{user: InitializedUser}}` An InitializedUser object.
-   */
-  async loginWithModal(): Promise<AuthLoginReturnType> {
-    return this.BaseLogin.loginWithModal();
-  }
-
-  /**
-   * Used to log the user into their thirdweb wallet using email OTP
-   * @example
-   * ```typescript
-   *  // Basic Flow
-   *  const thirdwebInAppWallet = new InAppWalletSdk({clientId: "", chain: "Polygon"});
-   *  try {
-   *    // prompts user to enter the code they received
-   *    const user = await thirdwebInAppWallet.auth.loginWithThirdwebEmailOtp({ email : "you@example.com" });
-   *    // user is now logged in
-   *  } catch (e) {
-   *    // User closed the OTP modal or something else went wrong during the authentication process
-   *    console.error(e)
-   *  }
-   * ```
-   * @param args - args.email: We will send the email an OTP that needs to be entered in order for them to be logged in.
-   * @returns `{{user: InitializedUser}}` An InitializedUser object. See {@link InAppWalletSdk.getUser} for more
-   */
-  async loginWithEmailOtp(
-    args: Parameters<BaseLogin["loginWithEmailOtp"]>[0],
-  ): Promise<AuthLoginReturnType> {
-    return this.BaseLogin.loginWithEmailOtp(args);
-  }
-
-  /**
-   * @internal
-   */
-  async loginWithCustomJwt(
-    args: Parameters<BaseLogin["loginWithCustomJwt"]>[0],
-  ): Promise<AuthLoginReturnType> {
-    return this.BaseLogin.loginWithCustomJwt(args);
-  }
-
-  /**
-   * @internal
-   */
-  async loginWithCustomAuthEndpoint(
-    args: Parameters<BaseLogin["loginWithCustomAuthEndpoint"]>[0],
-  ): Promise<AuthLoginReturnType> {
-    return this.BaseLogin.loginWithCustomAuthEndpoint(args);
-  }
-
-  /**
-   * @internal
-   */
-  async loginWithOauth(
-    args: Parameters<BaseLogin["loginWithOauth"]>[0],
-  ): Promise<AuthLoginReturnType> {
-    return this.BaseLogin.loginWithOauth(args);
-  }
-
-  /**
-   * A headless way to send the users at the passed email an OTP code.
-   * You need to then call {@link Auth.verifyEmailLoginOtp} in order to complete the login process
-   * @example
-   * @param param0.email
-   * ```typescript
-   *  const thirdwebInAppWallet = new InAppWalletSdk({clientId: "", chain: "Polygon"});
-   *  // sends user an OTP code
-   * try {
-   *    await thirdwebInAppWallet.auth.sendEmailLoginOtp({ email : "you@example.com" });
-   * } catch(e) {
-   *    // Error Sending user's email an OTP code
-   *    console.error(e);
-   * }
-   *
-   * // Then when your user is ready to verify their OTP
-   * try {
-   *    const user = await thirdwebInAppWallet.auth.verifyEmailLoginOtp({ email: "you@example.com", otp: "6-DIGIT_CODE_HERE" });
-   * } catch(e) {
-   *    // Error verifying the OTP code
-   *    console.error(e)
-   * }
-   * ```
-   * @param param0 - param0.email We will send the email an OTP that needs to be entered in order for them to be logged in.
-   * @returns `{{ isNewUser: boolean }}` IsNewUser indicates if the user is a new user to your platform
-   * @internal
-   */
-  async sendEmailLoginOtp({
-    email,
-  }: Parameters<
-    BaseLogin["sendEmailLoginOtp"]
-  >[0]): Promise<SendEmailOtpReturnType> {
-    return this.BaseLogin.sendEmailLoginOtp({
-      email,
-    });
-  }
-
-  /**
-   * @internal
-   */
-  async sendSmsLoginOtp({
-    phoneNumber,
-  }: Parameters<
-    BaseLogin["sendSmsLoginOtp"]
-  >[0]): Promise<SendEmailOtpReturnType> {
-    return this.BaseLogin.sendSmsLoginOtp({
-      phoneNumber,
-    });
   }
+  return undefined;
+}
 
-  /**
-   * Used to verify the otp that the user receives from thirdweb
-   *
-   * See {@link Auth.sendEmailLoginOtp} for how the headless call flow looks like. Simply swap out the calls to `loginWithThirdwebEmailOtp` with `verifyThirdwebEmailLoginOtp`
-   * @param args - props.email We will send the email an OTP that needs to be entered in order for them to be logged in.
-   * props.otp The code that the user received in their email
-   * @returns `{{user: InitializedUser}}` An InitializedUser object containing the user's status, wallet, authDetails, and more
-   * @internal
-   */
-  async verifyEmailLoginOtp(
-    args: Parameters<BaseLogin["verifyEmailLoginOtp"]>[0],
-  ) {
-    return this.BaseLogin.verifyEmailLoginOtp(args);
+/**
+ * Retrieves the authenticated user email for the active in-app wallet.
+ * @param options - The arguments for retrieving the authenticated user.
+ * @returns The authenticated user email if logged in and wallet initialized, otherwise undefined.
+ * @example
+ * ```ts
+ * import { getUserEmail } from "thirdweb/wallets/in-app";
+ *
+ * const email = await getUserEmail({ client });
+ * console.log(email);
+ * ```
+ * @wallet
+ */
+export async function getUserEmail(options: GetAuthenticatedUserParams) {
+  const user = await getAuthenticatedUser(options);
+  if (user && "email" in user.authDetails) {
+    return user.authDetails.email;
   }
+  return undefined;
+}
 
-  /**
-   * @internal
-   */
-  async verifySmsLoginOtp(args: Parameters<BaseLogin["verifySmsLoginOtp"]>[0]) {
-    return this.BaseLogin.verifySmsLoginOtp(args);
+/**
+ * Retrieves the authenticated user phone number for the active embedded wallet.
+ * @param options - The arguments for retrieving the authenticated user.
+ * @returns The authenticated user phone number if authenticated with phone number, otherwise undefined.
+ * @example
+ * ```ts
+ * import { getUserPhoneNumber } from "thirdweb/wallets/embedded";
+ *
+ * const phoneNumber = await getUserPhoneNumber({ client });
+ * console.log(phoneNumber);
+ * ```
+ * @wallet
+ */
+export async function getUserPhoneNumber(options: GetAuthenticatedUserParams) {
+  const user = await getAuthenticatedUser(options);
+  if (user && "phoneNumber" in user.authDetails) {
+    return user.authDetails.phoneNumber;
   }
+  return undefined;
+}
 
-  /**
-   * Logs any existing user out of their wallet.
-   * @returns `{{success: boolean}}` true if a user is successfully logged out. false if there's no user currently logged in.
-   * @internal
-   */
-  async logout(): Promise<LogoutReturnType> {
-    const { success } = await this.AuthQuerier.call<LogoutReturnType>({
-      procedureName: "logout",
-      params: undefined,
-    });
-    const isRemoveAuthCookie = await this.localStorage.removeAuthCookie();
-    const isRemoveUserId = await this.localStorage.removeWalletUserId();
+/**
+ * Pre-authenticates the user based on the provided authentication strategy.
+ * @param args - The arguments required for pre-authentication.
+ * @returns A promise that resolves to the pre-authentication result.
+ * @throws An error if the provided authentication strategy doesn't require pre-authentication.
+ * @example
+ * ```ts
+ * import { preAuthenticate } from "thirdweb/wallets/in-app";
+ *
+ * const result = await preAuthenticate({
+ *  client,
+ *  strategy: "email",
+ *  email: "example@example.org",
+ * });
+ * ```
+ * @wallet
+ */
+export async function preAuthenticate(args: PreAuthArgsType) {
+  const connector = await getInAppWalletConnector(args.client);
+  return connector.preAuthenticate(args);
+}
 
-    return {
-      success: success || isRemoveAuthCookie || isRemoveUserId,
-    };
-  }
+/**
+ * Authenticates the user based on the provided authentication arguments.
+ * @param args - The authentication arguments.
+ * @returns A promise that resolves to the authentication result.
+ * @example
+ * ```ts
+ * import { authenticate } from "thirdweb/wallets/in-app";
+ *
+ * const result = await authenticate({
+ *  client,
+ *  strategy: "email",
+ *  email: "example@example.org",
+ *  verificationCode: "123456",
+ * });
+ * ```
+ * @wallet
+ */
+export async function authenticate(
+  args: AuthArgsType,
+): Promise<AuthLoginReturnType> {
+  const connector = await getInAppWalletConnector(args.client);
+  return connector.authenticate(args);
 }

package/src/wallets/in-app/web/lib/web-connector.ts

@@ -1,7 +1,6 @@
 import type { ThirdwebClient } from "../../../../client/client.js";
 import { getThirdwebBaseUrl } from "../../../../utils/domains.js";
 import type { Account } from "../../../interfaces/wallet.js";
-import { oauthStrategyToAuthProvider } from "../../core/authentication/index.js";
 import {
   type AuthArgsType,
   type AuthLoginReturnType,
@@ -10,11 +9,12 @@ import {
   type PreAuthArgsType,
   type SendEmailOtpReturnType,
   UserWalletStatus,
+  oauthStrategyToAuthProvider,
 } from "../../core/authentication/type.js";
 import type { InAppConnector } from "../../core/interfaces/connector.js";
 import type { InAppWalletConstructorType } from "../types.js";
 import { InAppWalletIframeCommunicator } from "../utils/iFrameCommunication/InAppWalletIframeCommunicator.js";
-import { Auth, type AuthQuerierTypes } from "./auth/index.js";
+import { Auth, type AuthQuerierTypes } from "./auth/iframe-auth.js";
 import { loginWithPasskey, registerPasskey } from "./auth/passkeys.js";
 import { IFrameWallet } from "./in-app-account.js";
 

package/src/wallets/manager/index.ts

@@ -4,8 +4,8 @@ import { hasSmartAccount } from "../../react/web/utils/isSmartWallet.js";
 import { computedStore } from "../../reactive/computedStore.js";
 import { effect } from "../../reactive/effect.js";
 import { createStore } from "../../reactive/store.js";
-import { smartWallet } from "../create-wallet.js";
 import type { Account, Wallet } from "../interfaces/wallet.js";
+import { smartWallet } from "../smart/smart-wallet.js";
 import type { SmartWalletOptions } from "../smart/types.js";
 import type { AsyncStorage } from "../storage/AsyncStorage.js";
 import { deleteConnectParamsFromStorage } from "../storage/walletStorage.js";

package/src/wallets/native/create-wallet.ts

@@ -0,0 +1,224 @@
+// TODO: figure out how to define the type without tuple args type and using function overloads
+
+import { trackConnect } from "../../analytics/track.js";
+import type { Chain } from "../../chains/types.js";
+import type { WCSupportedWalletIds } from "../__generated__/wallet-ids.js";
+import { coinbaseWalletSDK } from "../coinbase/coinbase-wallet.js";
+import { getCoinbaseMobileProvider } from "../coinbase/coinbaseMobileSDK.js";
+import { COINBASE } from "../constants.js";
+import type { Account, Wallet } from "../interfaces/wallet.js";
+import { smartWallet } from "../smart/smart-wallet.js";
+import type { WCConnectOptions } from "../wallet-connect/types.js";
+import { createWalletEmitter } from "../wallet-emitter.js";
+import type {
+  CreateWalletArgs,
+  WalletAutoConnectionOption,
+  WalletId,
+} from "../wallet-types.js";
+
+/**
+ * Creates a wallet based on the provided ID and arguments.
+ * @param args - The arguments for creating the wallet.
+ * @returns - The created wallet.
+ * @example
+ * ```ts
+ * import { createWallet } from "thirdweb/wallets";
+ *
+ * const metamaskWallet = createWallet("io.metamask");
+ *
+ * const account = await metamaskWallet.connect({
+ *  client,
+ * });
+ * ```
+ * @wallet
+ */
+export function createWallet<const ID extends WalletId>(
+  ...args: CreateWalletArgs<ID>
+): Wallet<ID> {
+  const [id, creationOptions] = args;
+
+  switch (id) {
+    /**
+     * SMART WALLET
+     */
+    case "smart": {
+      // same as web
+      return smartWallet(
+        creationOptions as CreateWalletArgs<"smart">[1],
+      ) as Wallet<ID>;
+    }
+    /**
+     * IN-APP WALLET
+     */
+    case "embedded":
+    case "inApp": {
+      // TODO pass RN connector
+      throw new Error("TODO");
+      // return inAppWallet(
+      //   creationOptions as CreateWalletArgs<"inApp">[1],
+      // ) as Wallet<ID>;
+    }
+
+    /**
+     * COINBASE WALLET VIA SDK
+     * -> if no injected coinbase found, we'll use the coinbase SDK
+     */
+    case COINBASE: {
+      const options = creationOptions as CreateWalletArgs<typeof COINBASE>[1];
+      return coinbaseWalletSDK({
+        createOptions: options,
+        providerFactory: () => getCoinbaseMobileProvider(options),
+      }) as Wallet<ID>;
+    }
+
+    /**
+     * WALLET CONNECT AND INJECTED WALLETS + walletConnect standalone
+     * TODO extract into a core + inject storage and link open callback
+     */
+    default: {
+      const emitter = createWalletEmitter<ID>();
+      let account: Account | undefined = undefined;
+      let chain: Chain | undefined = undefined;
+
+      const unsubscribeChain = emitter.subscribe("chainChanged", (newChain) => {
+        chain = newChain;
+      });
+
+      function reset() {
+        account = undefined;
+        chain = undefined;
+      }
+
+      let handleDisconnect = async () => {};
+
+      const unsubscribeDisconnect = emitter.subscribe("disconnect", () => {
+        reset();
+        unsubscribeChain();
+        unsubscribeDisconnect();
+      });
+
+      emitter.subscribe("accountChanged", (_account) => {
+        account = _account;
+      });
+
+      let handleSwitchChain: (chain: Chain) => Promise<void> = async () => {
+        throw new Error("Not implemented yet");
+      };
+
+      const wallet: Wallet<ID> = {
+        id,
+        subscribe: emitter.subscribe,
+        getConfig: () => args[1],
+        getChain: () => chain,
+        getAccount: () => account,
+        autoConnect: async (
+          options: WalletAutoConnectionOption<WCSupportedWalletIds>,
+        ) => {
+          if (options && "client" in options) {
+            const { autoConnectWC } = await import(
+              "../wallet-connect/controller.js"
+            );
+
+            const [
+              connectedAccount,
+              connectedChain,
+              doDisconnect,
+              doSwitchChain,
+            ] = await autoConnectWC(
+              options,
+              emitter,
+              wallet.id as WCSupportedWalletIds,
+            );
+            // set the states
+            account = connectedAccount;
+            chain = connectedChain;
+            handleDisconnect = doDisconnect;
+            handleSwitchChain = doSwitchChain;
+            trackConnect({
+              client: options.client,
+              walletType: id,
+              walletAddress: account.address,
+            });
+            // return account
+            return account;
+          }
+          throw new Error("Failed to auto connect");
+        },
+        connect: async (options) => {
+          async function wcConnect(wcOptions: WCConnectOptions) {
+            const { connectWC } = await import(
+              "../wallet-connect/controller.js"
+            );
+
+            const [
+              connectedAccount,
+              connectedChain,
+              doDisconnect,
+              doSwitchChain,
+            ] = await connectWC(
+              wcOptions,
+              emitter,
+              wallet.id as WCSupportedWalletIds | "walletConnect",
+            );
+            // set the states
+            account = connectedAccount;
+            chain = connectedChain;
+            handleDisconnect = doDisconnect;
+            handleSwitchChain = doSwitchChain;
+            trackConnect({
+              client: wcOptions.client,
+              walletType: id,
+              walletAddress: account.address,
+            });
+            return account;
+          }
+
+          if (id === "walletConnect") {
+            const { client, chain: _chain, ...walletConnectOptions } = options;
+
+            return wcConnect({
+              client,
+              chain: _chain,
+              walletConnect: {
+                ...walletConnectOptions,
+              },
+            });
+          }
+
+          if (options && "client" in options) {
+            return wcConnect(options);
+          }
+          throw new Error("Failed to connect");
+        },
+        // these get overridden in connect and autoConnect
+        disconnect: async () => {
+          reset();
+          await handleDisconnect();
+        },
+        switchChain: (c) => handleSwitchChain(c),
+      };
+      return wallet;
+    }
+  }
+}
+
+/**
+ * Creates a wallet that allows connecting to any wallet that supports the WalletConnect protocol.
+ * @returns The created smart wallet.
+ * @example
+ * ```ts
+ * import { walletConnect } from "thirdweb/wallets";
+ *
+ * const wallet = walletConnect();
+ *
+ * const account = await wallet.connect({
+ *  client
+ * });
+ * ```
+ * @wallet
+ */
+export function walletConnect() {
+  return createWallet("walletConnect");
+}
+
+// TODO in-app wallet

package/src/wallets/smart/smart-wallet-integration.test.ts

@@ -18,9 +18,9 @@ import { estimateGasCost } from "../../transaction/actions/estimate-gas-cost.js"
 import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
 import { sendBatchTransaction } from "../../transaction/actions/send-batch-transaction.js";
 import { isContractDeployed } from "../../utils/bytecode/is-contract-deployed.js";
-import { smartWallet } from "../create-wallet.js";
 import type { Account, Wallet } from "../interfaces/wallet.js";
 import { generateAccount } from "../utils/generateAccount.js";
+import { smartWallet } from "./smart-wallet.js";
 
 let wallet: Wallet;
 let smartAccount: Account;

package/src/wallets/smart/smart-wallet-zksync.test.ts

@@ -7,9 +7,9 @@ import { getContract } from "../../contract/contract.js";
 import { claimTo } from "../../extensions/erc1155/drops/write/claimTo.js";
 import { sendTransaction } from "../../transaction/actions/send-transaction.js";
 import { prepareTransaction } from "../../transaction/prepare-transaction.js";
-import { smartWallet } from "../create-wallet.js";
 import type { Account, Wallet } from "../interfaces/wallet.js";
 import { privateKeyToAccount } from "../private-key.js";
+import { smartWallet } from "./smart-wallet.js";
 
 let wallet: Wallet;
 let smartAccount: Account;