thirdweb 5.29.2-nightly-eff710738ce3d4341257e5912311c95b28a34b5d-20240614173600 → 5.29.3-nightly-ffaff744f72d2cb22896e7501677b48f76ea857a-20240614184424

package/src/wallets/coinbase/coinbaseSDKWallet.ts

@@ -26,7 +26,6 @@ import {
   stringToHex,
   uint8ArrayToHex,
 } from "../../utils/encoding/hex.js";
-import { isReactNative } from "../../utils/platform.js";
 import { parseTypedData } from "../../utils/signatures/helpers/parseTypedData.js";
 import { COINBASE } from "../constants.js";
 import type {
@@ -128,20 +127,13 @@ export type CoinbaseSDKWalletConnectionOptions = {
 // this should be ok since all the creation options are provided at build time
 let _provider: ProviderInterface | undefined;
 
-async function getCoinbaseProvider(
+/**
+ * @internal
+ */
+export async function getCoinbaseWebProvider(
   options?: CreateWalletArgs<typeof COINBASE>[1],
 ): Promise<ProviderInterface> {
   if (!_provider) {
-    if (isReactNative()) {
-      const { initMobileProvider } = require("./coinbaseMobileSDK.js");
-      const mobileProvider = initMobileProvider({
-        chain: options?.chains ? options.chains[0] : undefined,
-        ...options?.mobileConfig,
-      });
-      _provider = mobileProvider;
-      return mobileProvider;
-    }
-
     const client = new CoinbaseWalletSDK({
       appName: options?.appMetadata?.name || getDefaultAppMetadata().name,
       appChainIds: options?.chains
@@ -186,7 +178,7 @@ export async function coinbaseSDKWalletGetCapabilities(args: {
   }
 
   const config = wallet.getConfig();
-  const provider = await getCoinbaseProvider(config);
+  const provider = await getCoinbaseWebProvider(config);
   try {
     return (await provider.request({
       method: "wallet_getCapabilities",
@@ -212,7 +204,7 @@ export async function coinbaseSDKWalletSendCalls(args: {
   const { wallet, params } = args;
 
   const config = wallet.getConfig();
-  const provider = await getCoinbaseProvider(config);
+  const provider = await getCoinbaseWebProvider(config);
 
   try {
     return (await provider.request({
@@ -238,7 +230,7 @@ export async function coinbaseSDKWalletShowCallsStatus(args: {
 }) {
   const { wallet, bundleId } = args;
 
-  const provider = await getCoinbaseProvider(wallet.getConfig());
+  const provider = await getCoinbaseWebProvider(wallet.getConfig());
 
   try {
     return await provider.request({
@@ -265,7 +257,7 @@ export async function coinbaseSDKWalletGetCallsStatus(args: {
   const { wallet, bundleId } = args;
 
   const config = wallet.getConfig();
-  const provider = await getCoinbaseProvider(config);
+  const provider = await getCoinbaseWebProvider(config);
 
   return provider.request({
     method: "wallet_getCallsStatus",
@@ -402,10 +394,9 @@ function onConnect(
  */
 export async function connectCoinbaseWalletSDK(
   options: WalletConnectionOption<typeof COINBASE>,
-  createOptions: CreateWalletArgs<typeof COINBASE>[1],
   emitter: WalletEmitter<typeof COINBASE>,
+  provider: ProviderInterface,
 ): Promise<ReturnType<typeof onConnect>> {
-  const provider = await getCoinbaseProvider(createOptions);
   const accounts = (await provider.request({
     method: "eth_requestAccounts",
   })) as string[];
@@ -443,11 +434,9 @@ export async function connectCoinbaseWalletSDK(
  */
 export async function autoConnectCoinbaseWalletSDK(
   options: WalletConnectionOption<typeof COINBASE>,
-  createOptions: CreateWalletArgs<typeof COINBASE>[1],
   emitter: WalletEmitter<typeof COINBASE>,
+  provider: ProviderInterface,
 ): Promise<ReturnType<typeof onConnect>> {
-  const provider = await getCoinbaseProvider(createOptions);
-
   // connected accounts
   const addresses = (await provider.request({
     method: "eth_accounts",

package/src/wallets/create-wallet.ts

@@ -8,17 +8,16 @@ 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 { smartWallet } from "./smart/smart-wallet.js";
 import type { WCConnectOptions } from "./wallet-connect/types.js";
 import { createWalletEmitter } from "./wallet-emitter.js";
 
@@ -69,9 +68,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>;
     }
 
     /**
@@ -290,118 +291,6 @@ 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
@@ -545,97 +434,3 @@ export function inAppWallet(
     },
   };
 }
-
-/**
- * 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/wallet/index.ts

@@ -85,7 +85,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"),
   ]);
 

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;