thirdweb 5.29.2 → 5.29.3-nightly-476b6cc271b0891fa01fb09ca509c564b850ccfa-20240614185219

package/src/wallets/create-wallet.ts

@@ -8,17 +8,15 @@ import type {
   CreateWalletArgs,
   InjectedConnectOptions,
   WalletAutoConnectionOption,
-  WalletConnectionOption,
   WalletId,
 } from "./wallet-types.js";
 
 import { trackConnect } from "../analytics/track.js";
-import type { ThirdwebClient } from "../client/client.js";
-import { getContract } from "../contract/contract.js";
-import { isContractDeployed } from "../utils/bytecode/is-contract-deployed.js";
+import { coinbaseWalletSDK } from "./coinbase/coinbase-wallet.js";
+import { getCoinbaseWebProvider } from "./coinbase/coinbaseSDKWallet.js";
 import { COINBASE } from "./constants.js";
-import { logoutAuthenticatedUser } from "./in-app/core/authentication/index.js";
-import { DEFAULT_ACCOUNT_FACTORY } from "./smart/lib/constants.js";
+import { inAppWallet } from "./in-app/web/in-app.js";
+import { smartWallet } from "./smart/smart-wallet.js";
 import type { WCConnectOptions } from "./wallet-connect/types.js";
 import { createWalletEmitter } from "./wallet-emitter.js";
 
@@ -69,9 +67,11 @@ export function createWallet<const ID extends WalletId>(
      * -> if no injected coinbase found, we'll use the coinbase SDK
      */
     case COINBASE: {
-      return coinbaseWalletSDK(
-        creationOptions as CreateWalletArgs<typeof COINBASE>[1],
-      ) as Wallet<ID>;
+      const options = creationOptions as CreateWalletArgs<typeof COINBASE>[1];
+      return coinbaseWalletSDK({
+        createOptions: options,
+        providerFactory: () => getCoinbaseWebProvider(options),
+      }) as Wallet<ID>;
     }
 
     /**
@@ -289,353 +289,3 @@ export function createWallet<const ID extends WalletId>(
 export function walletConnect() {
   return createWallet("walletConnect");
 }
-
-/**
- * Creates a smart wallet.
- * @param createOptions - The options for creating the wallet.
- * @returns The created smart wallet.
- * @example
- * ```ts
- * import { smartWallet } from "thirdweb/wallets";
- *
- * const wallet = smartWallet({
- *  chain: sepolia,
- *  gasless: true,
- * });
- *
- * const account = await wallet.connect({
- *   client,
- *   personalAccount: account,
- * });
- * ```
- * @wallet
- */
-export function smartWallet(
-  createOptions: CreateWalletArgs<"smart">[1],
-): Wallet<"smart"> {
-  const emitter = createWalletEmitter<"smart">();
-  let account: Account | undefined = undefined;
-  let chain: Chain | undefined = undefined;
-  let lastConnectOptions: WalletConnectionOption<"smart"> | undefined;
-
-  const _smartWallet: Wallet<"smart"> = {
-    id: "smart",
-    subscribe: emitter.subscribe,
-    getChain: () => chain,
-    getConfig: () => createOptions,
-    getAccount: () => account,
-    autoConnect: async (options) => {
-      const { connectSmartWallet } = await import("./smart/index.js");
-      const [connectedAccount, connectedChain] = await connectSmartWallet(
-        _smartWallet,
-        options,
-        createOptions,
-      );
-      // set the states
-      lastConnectOptions = options;
-      account = connectedAccount;
-      chain = connectedChain;
-      trackConnect({
-        client: options.client,
-        walletType: "smart",
-        walletAddress: account.address,
-      });
-      // return account
-      return account;
-    },
-    connect: async (options) => {
-      const { connectSmartWallet } = await import("./smart/index.js");
-      const [connectedAccount, connectedChain] = await connectSmartWallet(
-        _smartWallet,
-        options,
-        createOptions,
-      );
-      // set the states
-      lastConnectOptions = options;
-      account = connectedAccount;
-      chain = connectedChain;
-      trackConnect({
-        client: options.client,
-        walletType: "smart",
-        walletAddress: account.address,
-      });
-      // return account
-      emitter.emit("accountChanged", account);
-      return account;
-    },
-    disconnect: async () => {
-      account = undefined;
-      chain = undefined;
-      const { disconnectSmartWallet } = await import("./smart/index.js");
-      await disconnectSmartWallet(_smartWallet);
-      emitter.emit("disconnect", undefined);
-    },
-    switchChain: async (newChain: Chain) => {
-      if (!lastConnectOptions) {
-        throw new Error("Cannot switch chain without a previous connection");
-      }
-      // check if factory is deployed
-      const factory = getContract({
-        address: createOptions.factoryAddress || DEFAULT_ACCOUNT_FACTORY,
-        chain: newChain,
-        client: lastConnectOptions.client,
-      });
-      const isDeployed = await isContractDeployed(factory);
-      if (!isDeployed) {
-        throw new Error(
-          `Factory contract not deployed on chain: ${newChain.id}`,
-        );
-      }
-      const { connectSmartWallet } = await import("./smart/index.js");
-      const [connectedAccount, connectedChain] = await connectSmartWallet(
-        _smartWallet,
-        { ...lastConnectOptions, chain: newChain },
-        createOptions,
-      );
-      // set the states
-      account = connectedAccount;
-      chain = connectedChain;
-      emitter.emit("chainChanged", newChain);
-    },
-  };
-
-  return _smartWallet;
-}
-
-/**
- * Creates an in-app wallet.
- * @param createOptions - configuration options
- * @returns The created in-app wallet.
- * @example
- * ```ts
- * import { inAppWallet } from "thirdweb/wallets";
- *
- * const wallet = inAppWallet();
- *
- * const account = await wallet.connect({
- *   client,
- *   chain,
- *   strategy: "google",
- * });
- * ```
- *
- * Enable smart accounts and sponsor gas for your users:
- * ```ts
- * import { inAppWallet } from "thirdweb/wallets";
- * const wallet = inAppWallet({
- *  smartAccount: {
- *   chain: sepolia,
- *   sponsorGas: true,
- * },
- * });
- * ```
- *
- * Specify a logo for your login page
- * ```ts
- * import { inAppWallet } from "thirdweb/wallets";
- * const wallet = inAppWallet({
- *  metadata: {
- *   image: {
- *    src: "https://example.com/logo.png",
- *    alt: "My logo",
- *    width: 100,
- *    height: 100,
- *   },
- *  },
- * });
- * ```
- *
- * Hide the ability to export the private key within the Connect Modal
- * ```ts
- * import { inAppWallet } from "thirdweb/wallets";
- * const wallet = inAppWallet({
- *  hidePrivateKeyExport: true
- * });
- * ```
- * @wallet
- */
-export function inAppWallet(
-  createOptions?: CreateWalletArgs<"inApp">[1],
-): Wallet<"inApp"> {
-  const emitter = createWalletEmitter<"inApp">();
-  let account: Account | undefined = undefined;
-  let chain: Chain | undefined = undefined;
-  let client: ThirdwebClient | undefined;
-
-  return {
-    id: "inApp",
-    subscribe: emitter.subscribe,
-    getChain: () => chain,
-    getConfig: () => createOptions,
-    getAccount: () => account,
-    autoConnect: async (options) => {
-      const { autoConnectInAppWallet } = await import(
-        "./in-app/core/wallet/index.js"
-      );
-
-      const [connectedAccount, connectedChain] = await autoConnectInAppWallet(
-        options,
-        createOptions,
-      );
-      // set the states
-      client = options.client;
-      account = connectedAccount;
-      chain = connectedChain;
-      trackConnect({
-        client: options.client,
-        walletType: "inApp",
-        walletAddress: account.address,
-      });
-      // return only the account
-      return account;
-    },
-    connect: async (options) => {
-      const { connectInAppWallet } = await import(
-        "./in-app/core/wallet/index.js"
-      );
-
-      const [connectedAccount, connectedChain] = await connectInAppWallet(
-        options,
-        createOptions,
-      );
-      // set the states
-      client = options.client;
-      account = connectedAccount;
-      chain = connectedChain;
-      trackConnect({
-        client: options.client,
-        walletType: "inApp",
-        walletAddress: account.address,
-      });
-      // return only the account
-      return account;
-    },
-    disconnect: async () => {
-      // If no client is assigned, we should be fine just unsetting the states
-      if (client) {
-        const result = await logoutAuthenticatedUser({ client });
-        if (!result.success) {
-          throw new Error("Failed to logout");
-        }
-      }
-      account = undefined;
-      chain = undefined;
-      emitter.emit("disconnect", undefined);
-    },
-    switchChain: async (newChain) => {
-      if (createOptions?.smartAccount && client && account) {
-        // if account abstraction is enabled, reconnect to smart account on the new chain
-        const { autoConnectInAppWallet } = await import(
-          "./in-app/core/wallet/index.js"
-        );
-        const [connectedAccount, connectedChain] = await autoConnectInAppWallet(
-          {
-            chain: newChain,
-            client,
-          },
-          createOptions,
-        );
-        account = connectedAccount;
-        chain = connectedChain;
-      } else {
-        // if not, simply set the new chain
-        chain = newChain;
-      }
-      emitter.emit("chainChanged", newChain);
-    },
-  };
-}
-
-/**
- * internal helper functions
- */
-
-function coinbaseWalletSDK(
-  createOptions?: CreateWalletArgs<typeof COINBASE>[1],
-): Wallet<typeof COINBASE> {
-  const emitter = createWalletEmitter<typeof COINBASE>();
-  let account: Account | undefined = undefined;
-  let chain: Chain | undefined = undefined;
-
-  function reset() {
-    account = undefined;
-    chain = undefined;
-  }
-
-  let handleDisconnect = async () => {};
-
-  let handleSwitchChain = async (newChain: Chain) => {
-    chain = newChain;
-  };
-
-  const unsubscribeChainChanged = emitter.subscribe(
-    "chainChanged",
-    (newChain) => {
-      chain = newChain;
-    },
-  );
-
-  const unsubscribeDisconnect = emitter.subscribe("disconnect", () => {
-    reset();
-    unsubscribeChainChanged();
-    unsubscribeDisconnect();
-  });
-
-  emitter.subscribe("accountChanged", (_account) => {
-    account = _account;
-  });
-
-  return {
-    id: COINBASE,
-    subscribe: emitter.subscribe,
-    getChain: () => chain,
-    getConfig: () => createOptions,
-    getAccount: () => account,
-    autoConnect: async (options) => {
-      const { autoConnectCoinbaseWalletSDK } = await import(
-        "./coinbase/coinbaseSDKWallet.js"
-      );
-      const [connectedAccount, connectedChain, doDisconnect, doSwitchChain] =
-        await autoConnectCoinbaseWalletSDK(options, createOptions, emitter);
-      // set the states
-      account = connectedAccount;
-      chain = connectedChain;
-      handleDisconnect = doDisconnect;
-      handleSwitchChain = doSwitchChain;
-      trackConnect({
-        client: options.client,
-        walletType: COINBASE,
-        walletAddress: account.address,
-      });
-      // return account
-      return account;
-    },
-    connect: async (options) => {
-      const { connectCoinbaseWalletSDK } = await import(
-        "./coinbase/coinbaseSDKWallet.js"
-      );
-      const [connectedAccount, connectedChain, doDisconnect, doSwitchChain] =
-        await connectCoinbaseWalletSDK(options, createOptions, emitter);
-
-      // set the states
-      account = connectedAccount;
-      chain = connectedChain;
-      handleDisconnect = doDisconnect;
-      handleSwitchChain = doSwitchChain;
-      trackConnect({
-        client: options.client,
-        walletType: COINBASE,
-        walletAddress: account.address,
-      });
-      // return account
-      return account;
-    },
-    disconnect: async () => {
-      reset();
-      await handleDisconnect();
-    },
-    switchChain: async (newChain) => {
-      await handleSwitchChain(newChain);
-    },
-  };
-}

package/src/wallets/in-app/core/authentication/type.ts

@@ -210,3 +210,16 @@ export type GetUser =
       walletAddress: string;
     }
   | InitializedUser;
+
+export type GetAuthenticatedUserParams = {
+  client: ThirdwebClient;
+};
+
+export const oauthStrategyToAuthProvider: Record<
+  "google" | "facebook" | "apple",
+  AuthProvider
+> = {
+  google: AuthProvider.GOOGLE,
+  facebook: AuthProvider.FACEBOOK,
+  apple: AuthProvider.APPLE,
+};

package/src/wallets/in-app/core/wallet/in-app-core.ts

@@ -0,0 +1,134 @@
+import { trackConnect } from "../../../../analytics/track.js";
+import type { Chain } from "../../../../chains/types.js";
+import type { ThirdwebClient } from "../../../../client/client.js";
+import type { Account, Wallet } from "../../../interfaces/wallet.js";
+import { createWalletEmitter } from "../../../wallet-emitter.js";
+import type { CreateWalletArgs } from "../../../wallet-types.js";
+import type { InAppConnector } from "../interfaces/connector.js";
+
+const connectorCache = new WeakMap<ThirdwebClient, InAppConnector>();
+
+/**
+ * @internal
+ */
+export async function getOrCreateInAppWalletConnector(
+  client: ThirdwebClient,
+  connectorFactory: (client: ThirdwebClient) => Promise<InAppConnector>,
+) {
+  if (connectorCache.has(client)) {
+    return connectorCache.get(client) as InAppConnector;
+  }
+  const connector = await connectorFactory(client);
+  connectorCache.set(client, connector);
+  return connector;
+}
+
+/**
+ * @internal
+ */
+export function createInAppWallet(args: {
+  createOptions?: CreateWalletArgs<"inApp">[1];
+  connectorFactory: (client: ThirdwebClient) => Promise<InAppConnector>;
+}): Wallet<"inApp"> {
+  const { createOptions, connectorFactory } = args;
+  const emitter = createWalletEmitter<"inApp">();
+  let account: Account | undefined = undefined;
+  let chain: Chain | undefined = undefined;
+  let client: ThirdwebClient | undefined;
+
+  return {
+    id: "inApp",
+    subscribe: emitter.subscribe,
+    getChain: () => chain,
+    getConfig: () => createOptions,
+    getAccount: () => account,
+    autoConnect: async (options) => {
+      const { autoConnectInAppWallet } = await import("./index.js");
+
+      const connector = await getOrCreateInAppWalletConnector(
+        options.client,
+        connectorFactory,
+      );
+      const [connectedAccount, connectedChain] = await autoConnectInAppWallet(
+        options,
+        createOptions,
+        connector,
+      );
+      // set the states
+      client = options.client;
+      account = connectedAccount;
+      chain = connectedChain;
+      trackConnect({
+        client: options.client,
+        walletType: "inApp",
+        walletAddress: account.address,
+      });
+      // return only the account
+      return account;
+    },
+    connect: async (options) => {
+      const { connectInAppWallet } = await import("./index.js");
+
+      const connector = await getOrCreateInAppWalletConnector(
+        options.client,
+        connectorFactory,
+      );
+      const [connectedAccount, connectedChain] = await connectInAppWallet(
+        options,
+        createOptions,
+        connector,
+      );
+      // set the states
+      client = options.client;
+      account = connectedAccount;
+      chain = connectedChain;
+      trackConnect({
+        client: options.client,
+        walletType: "inApp",
+        walletAddress: account.address,
+      });
+      // return only the account
+      return account;
+    },
+    disconnect: async () => {
+      // If no client is assigned, we should be fine just unsetting the states
+      if (client) {
+        const connector = await getOrCreateInAppWalletConnector(
+          client,
+          connectorFactory,
+        );
+        const result = await connector.logout();
+        if (!result.success) {
+          throw new Error("Failed to logout");
+        }
+      }
+      account = undefined;
+      chain = undefined;
+      emitter.emit("disconnect", undefined);
+    },
+    switchChain: async (newChain) => {
+      if (createOptions?.smartAccount && client && account) {
+        // if account abstraction is enabled, reconnect to smart account on the new chain
+        const { autoConnectInAppWallet } = await import("./index.js");
+        const connector = await getOrCreateInAppWalletConnector(
+          client,
+          connectorFactory,
+        );
+        const [connectedAccount, connectedChain] = await autoConnectInAppWallet(
+          {
+            chain: newChain,
+            client,
+          },
+          createOptions,
+          connector,
+        );
+        account = connectedAccount;
+        chain = connectedChain;
+      } else {
+        // if not, simply set the new chain
+        chain = newChain;
+      }
+      emitter.emit("chainChanged", newChain);
+    },
+  };
+}

package/src/wallets/in-app/core/wallet/index.ts

@@ -8,6 +8,8 @@ import type {
   WalletAutoConnectionOption,
   WalletConnectionOption,
 } from "../../../wallet-types.js";
+import { UserWalletStatus } from "../authentication/type.js";
+import type { InAppConnector } from "../interfaces/connector.js";
 
 /**
  * Checks if the provided wallet is an in-app wallet.
@@ -27,10 +29,9 @@ export function isInAppWallet(
 export async function connectInAppWallet(
   options: WalletConnectionOption<"inApp">,
   createOptions: CreateWalletArgs<"inApp">[1],
+  connector: InAppConnector,
 ): Promise<[Account, Chain]> {
-  const { authenticate } = await import("../authentication/index.js");
-
-  const authResult = await authenticate(options);
+  const authResult = await connector.authenticate(options);
   const authAccount = authResult.user.account;
 
   if (createOptions?.smartAccount) {
@@ -54,9 +55,9 @@ export async function connectInAppWallet(
 export async function autoConnectInAppWallet(
   options: WalletAutoConnectionOption<"inApp">,
   createOptions: CreateWalletArgs<"inApp">[1],
+  connector: InAppConnector,
 ): Promise<[Account, Chain]> {
-  const { getAuthenticatedUser } = await import("../authentication/index.js");
-  const user = await getAuthenticatedUser({ client: options.client });
+  const user = await getAuthenticatedUser(connector);
   if (!user) {
     throw new Error("not authenticated");
   }
@@ -85,7 +86,7 @@ async function convertToSmartAccount(options: {
   chain?: Chain;
 }) {
   const [{ smartWallet }, { connectSmartWallet }] = await Promise.all([
-    import("../../../create-wallet.js"),
+    import("../../../smart/smart-wallet.js"),
     import("../../../smart/index.js"),
   ]);
 
@@ -100,3 +101,13 @@ async function convertToSmartAccount(options: {
     options.smartAccountOptions,
   );
 }
+
+async function getAuthenticatedUser(connector: InAppConnector) {
+  const user = await connector.getUser();
+  switch (user.status) {
+    case UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED: {
+      return user;
+    }
+  }
+  return undefined;
+}

package/src/wallets/in-app/{core/authentication → native/auth}/index.ts

@@ -1,59 +1,26 @@
 import type { ThirdwebClient } from "../../../../client/client.js";
-import { isBrowser, isReactNative } from "../../../../utils/platform.js";
-import type { InAppConnector } from "../interfaces/connector.js";
 import {
   type AuthArgsType,
   type AuthLoginReturnType,
-  AuthProvider,
+  type GetAuthenticatedUserParams,
   type PreAuthArgsType,
   UserWalletStatus,
-} from "./type.js";
+} from "../../core/authentication/type.js";
+import { getOrCreateInAppWalletConnector } from "../../core/wallet/in-app-core.js";
 
-export type GetAuthenticatedUserParams = {
-  client: ThirdwebClient;
-};
-
-const ewsSDKCache = new WeakMap<ThirdwebClient, InAppConnector>();
+// ---- KEEP IN SYNC WITH /wallets/in-app/web/lib/auth/index.ts ---- //
+// duplication needed for separate exports between web and native
 
 /**
  * @internal
  */
 async function getInAppWalletConnector(client: ThirdwebClient) {
-  if (ewsSDKCache.has(client)) {
-    return ewsSDKCache.get(client) as InAppConnector;
-  }
-
-  let ewSDK: InAppConnector;
-  if (isBrowser()) {
-    const { InAppWebConnector } = await import(
-      "../../web/lib/web-connector.js"
-    );
-    ewSDK = new InAppWebConnector({
+  return getOrCreateInAppWalletConnector(client, async (client) => {
+    const { InAppNativeConnector } = await import("../native-connector.js");
+    return new InAppNativeConnector({
       client: client,
     });
-  } else if (isReactNative()) {
-    const {
-      InAppNativeConnector,
-    } = require("../../native/native-connector.js");
-    ewSDK = new InAppNativeConnector({
-      client,
-    });
-  } else {
-    throw new Error("Unsupported platform");
-  }
-
-  ewsSDKCache.set(client, ewSDK);
-  return ewSDK;
-}
-
-/**
- * @internal
- */
-export async function logoutAuthenticatedUser(
-  options: GetAuthenticatedUserParams,
-) {
-  const ewSDK = await getInAppWalletConnector(options.client);
-  return ewSDK.logout();
+  });
 }
 
 /**
@@ -75,8 +42,8 @@ export async function getAuthenticatedUser(
   options: GetAuthenticatedUserParams,
 ) {
   const { client } = options;
-  const ewSDK = await getInAppWalletConnector(client);
-  const user = await ewSDK.getUser();
+  const connector = await getInAppWalletConnector(client);
+  const user = await connector.getUser();
   switch (user.status) {
     case UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED: {
       return user;
@@ -145,8 +112,8 @@ export async function getUserPhoneNumber(options: GetAuthenticatedUserParams) {
  * @wallet
  */
 export async function preAuthenticate(args: PreAuthArgsType) {
-  const ewSDK = await getInAppWalletConnector(args.client);
-  return ewSDK.preAuthenticate(args);
+  const connector = await getInAppWalletConnector(args.client);
+  return connector.preAuthenticate(args);
 }
 
 /**
@@ -169,15 +136,6 @@ export async function preAuthenticate(args: PreAuthArgsType) {
 export async function authenticate(
   args: AuthArgsType,
 ): Promise<AuthLoginReturnType> {
-  const ewSDK = await getInAppWalletConnector(args.client);
-  return ewSDK.authenticate(args);
+  const connector = await getInAppWalletConnector(args.client);
+  return connector.authenticate(args);
 }
-
-export const oauthStrategyToAuthProvider: Record<
-  "google" | "facebook" | "apple",
-  AuthProvider
-> = {
-  google: AuthProvider.GOOGLE,
-  facebook: AuthProvider.FACEBOOK,
-  apple: AuthProvider.APPLE,
-};