thirdweb 5.105.19 → 5.105.21

package/src/react/core/hooks/usePaymentMethods.ts

@@ -240,10 +240,10 @@ export function usePaymentMethods(options: {
       validOwnedTokens.sort((a, b) => {
         const aDollarBalance =
           Number.parseFloat(toTokens(a.balance, a.originToken.decimals)) *
-          (a.originToken.prices["USD"] || 0);
+          (a.originToken.prices.USD || 0);
         const bDollarBalance =
           Number.parseFloat(toTokens(b.balance, b.originToken.decimals)) *
-          (b.originToken.prices["USD"] || 0);
+          (b.originToken.prices.USD || 0);
         return bDollarBalance - aDollarBalance;
       });
 

package/src/react/core/hooks/wallets/useConnect.ts

@@ -79,5 +79,15 @@ export function useConnect(options?: ConnectManagerOptions) {
     [connect, options, setConnectionStatus],
   );
 
-  return { connect: handleConnection, error, isConnecting } as const;
+  const cancelConnection = useCallback(() => {
+    setIsConnecting(false);
+    setConnectionStatus("disconnected");
+  }, [setConnectionStatus]);
+
+  return {
+    connect: handleConnection,
+    error,
+    isConnecting,
+    cancelConnection,
+  } as const;
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.105.19";
+export const version = "5.105.21";

package/src/wallets/create-wallet.ts

@@ -17,6 +17,7 @@ import { inAppWallet } from "./in-app/web/in-app.js";
 import { getInjectedProvider } from "./injected/index.js";
 import type { Account, Wallet } from "./interfaces/wallet.js";
 import { smartWallet } from "./smart/smart-wallet.js";
+import type { QROverlay } from "./wallet-connect/qr-overlay.js";
 import type { WCConnectOptions } from "./wallet-connect/types.js";
 import { createWalletEmitter } from "./wallet-emitter.js";
 import type {
@@ -299,30 +300,90 @@ export function createWallet<const ID extends WalletId>(
               "./wallet-connect/controller.js"
             );
 
-            const [
-              connectedAccount,
-              connectedChain,
-              doDisconnect,
-              doSwitchChain,
-            ] = await connectWC(
-              wcOptions,
-              emitter,
-              wallet.id as WCSupportedWalletIds | "walletConnect",
-              webLocalStorage,
-              sessionHandler,
-            );
-            // set the states
-            account = connectedAccount;
-            chain = connectedChain;
-            handleDisconnect = doDisconnect;
-            handleSwitchChain = doSwitchChain;
-            trackConnect({
-              chainId: chain.id,
-              client: wcOptions.client,
-              walletAddress: account.address,
-              walletType: id,
-            });
-            return account;
+            let qrOverlay: QROverlay | undefined;
+
+            try {
+              const [
+                connectedAccount,
+                connectedChain,
+                doDisconnect,
+                doSwitchChain,
+              ] = await connectWC(
+                {
+                  ...wcOptions,
+                  walletConnect: {
+                    ...wcOptions.walletConnect,
+                    onDisplayUri: wcOptions.walletConnect?.showQrModal
+                      ? async (uri) => {
+                          // Check if we're in a browser environment
+                          if (
+                            typeof window !== "undefined" &&
+                            typeof document !== "undefined"
+                          ) {
+                            try {
+                              const { createQROverlay } = await import(
+                                "./wallet-connect/qr-overlay.js"
+                              );
+
+                              // Clean up any existing overlay
+                              if (qrOverlay) {
+                                qrOverlay.destroy();
+                              }
+
+                              // Create new QR overlay
+                              qrOverlay = createQROverlay(uri, {
+                                theme:
+                                  wcOptions.walletConnect?.qrModalOptions
+                                    ?.themeMode ?? "dark",
+                                qrSize: 280,
+                                showCloseButton: true,
+                                onCancel: () => {
+                                  wcOptions.walletConnect?.onCancel?.();
+                                },
+                              });
+                            } catch (error) {
+                              console.error(
+                                "Failed to create QR overlay:",
+                                error,
+                              );
+                            }
+                          }
+                        }
+                      : undefined,
+                  },
+                },
+                emitter,
+                wallet.id as WCSupportedWalletIds | "walletConnect",
+                webLocalStorage,
+                sessionHandler,
+              );
+
+              // Clean up QR overlay on successful connection
+              if (qrOverlay) {
+                qrOverlay.destroy();
+                qrOverlay = undefined;
+              }
+
+              // set the states
+              account = connectedAccount;
+              chain = connectedChain;
+              handleDisconnect = doDisconnect;
+              handleSwitchChain = doSwitchChain;
+              trackConnect({
+                chainId: chain.id,
+                client: wcOptions.client,
+                walletAddress: account.address,
+                walletType: id,
+              });
+              return account;
+            } catch (error) {
+              // Clean up QR overlay on connection error
+              if (qrOverlay) {
+                qrOverlay.destroy();
+                qrOverlay = undefined;
+              }
+              throw error;
+            }
           }
 
           if (id === "walletConnect") {

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

@@ -57,7 +57,7 @@ export function createInAppWallet(args: {
   let client: ThirdwebClient | undefined;
   let authToken: string | null = null;
 
-  const resolveSmartAccountOptionsFromEcosystem = async (options: {
+  const resolveSmartAccountOptionsFromEcosystem = async (options?: {
     chain?: Chain;
   }) => {
     if (ecosystem) {
@@ -78,7 +78,7 @@ export function createInAppWallet(args: {
           // default to 4337
           const { defaultChainId } = ecosystemOptions.smartAccountOptions;
           const preferredChain =
-            options.chain ??
+            options?.chain ??
             (defaultChainId ? getCachedChain(defaultChainId) : undefined);
           if (!preferredChain) {
             throw new Error(
@@ -108,7 +108,7 @@ export function createInAppWallet(args: {
         ecosystem,
       );
 
-      await resolveSmartAccountOptionsFromEcosystem(options);
+      await resolveSmartAccountOptionsFromEcosystem();
 
       const {
         account: connectedAccount,
@@ -145,7 +145,7 @@ export function createInAppWallet(args: {
         ecosystem,
       );
 
-      await resolveSmartAccountOptionsFromEcosystem(options);
+      await resolveSmartAccountOptionsFromEcosystem();
 
       const {
         account: connectedAccount,

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

@@ -299,6 +299,24 @@ import type {
  * });
  * ```
  *
+ * ### Get the auth token for the wallet
+ *
+ * You can get the auth token for the wallet by calling `wallet.getAuthToken()`.
+ *
+ * ```ts
+ * import { inAppWallet } from "thirdweb/wallets";
+ *
+ * const wallet = inAppWallet();
+ *
+ * await wallet.connect({
+ *   client,
+ *   strategy: "google",
+ * });
+ *
+ * const authToken = await wallet.getAuthToken(); // this will return a JWT token that can be used to authenticate the user in the backend
+ * console.log(authToken);
+ * ```
+ *
  * @returns The created in-app wallet.
  * @wallet
  */

package/src/wallets/smart/index.ts

@@ -80,7 +80,7 @@ export async function connectSmartAccount(
   connectionOptions: SmartWalletConnectionOptions,
   creationOptions: SmartWalletOptions,
 ): Promise<[Account, Chain]> {
-  const { personalAccount, client, chain: connectChain } = connectionOptions;
+  const { personalAccount, client } = connectionOptions;
 
   if (!personalAccount) {
     throw new Error(
@@ -89,7 +89,7 @@ export async function connectSmartAccount(
   }
 
   const options = creationOptions;
-  const chain = connectChain ?? options.chain;
+  const chain = creationOptions.chain;
   const sponsorGas =
     "gasless" in options ? options.gasless : options.sponsorGas;
   if (await isZkSyncChain(chain)) {

package/src/wallets/smart/lib/signing.ts

@@ -1,20 +1,12 @@
 import type * as ox__TypedData from "ox/TypedData";
 import { serializeErc6492Signature } from "../../../auth/serialize-erc6492-signature.js";
-import {
-  verifyEip1271Signature,
-  verifyHash,
-} from "../../../auth/verify-hash.js";
+import { verifyEip1271Signature } from "../../../auth/verify-hash.js";
 import type { Chain } from "../../../chains/types.js";
 import type { ThirdwebClient } from "../../../client/client.js";
-import {
-  getContract,
-  type ThirdwebContract,
-} from "../../../contract/contract.js";
+import type { ThirdwebContract } from "../../../contract/contract.js";
 import { encode } from "../../../transaction/actions/encode.js";
-import { readContract } from "../../../transaction/read-contract.js";
 import { encodeAbiParameters } from "../../../utils/abi/encodeAbiParameters.js";
 import { isContractDeployed } from "../../../utils/bytecode/is-contract-deployed.js";
-import type { Hex } from "../../../utils/encoding/hex.js";
 import { hashMessage } from "../../../utils/hashing/hashMessage.js";
 import { hashTypedData } from "../../../utils/hashing/hashTypedData.js";
 import type { SignableMessage } from "../../../utils/types.js";
@@ -40,33 +32,24 @@ export async function smartAccountSignMessage({
   message: SignableMessage;
 }) {
   const originalMsgHash = hashMessage(message);
-  const is712Factory = await checkFor712Factory({
-    accountContract,
-    factoryContract,
-    originalMsgHash,
-  });
 
   let sig: `0x${string}`;
-  if (is712Factory) {
-    const wrappedMessageHash = encodeAbiParameters(
-      [{ type: "bytes32" }],
-      [originalMsgHash],
-    );
+  const wrappedMessageHash = encodeAbiParameters(
+    [{ type: "bytes32" }],
+    [originalMsgHash],
+  );
 
-    sig = await options.personalAccount.signTypedData({
-      domain: {
-        chainId: options.chain.id,
-        name: "Account",
-        verifyingContract: accountContract.address,
-        version: "1",
-      },
-      message: { message: wrappedMessageHash },
-      primaryType: "AccountMessage",
-      types: { AccountMessage: [{ name: "message", type: "bytes" }] },
-    });
-  } else {
-    sig = await options.personalAccount.signMessage({ message });
-  }
+  sig = await options.personalAccount.signTypedData({
+    domain: {
+      chainId: options.chain.id,
+      name: "Account",
+      verifyingContract: accountContract.address,
+      version: "1",
+    },
+    message: { message: wrappedMessageHash },
+    primaryType: "AccountMessage",
+    types: { AccountMessage: [{ name: "message", type: "bytes" }] },
+  });
 
   const isDeployed = await isContractDeployed(accountContract);
   if (isDeployed) {
@@ -96,19 +79,7 @@ export async function smartAccountSignMessage({
       signature: sig,
     });
 
-    // check if the signature is valid
-    const isValid = await verifyHash({
-      address: accountContract.address,
-      chain: accountContract.chain,
-      client: accountContract.client,
-      hash: originalMsgHash,
-      signature: erc6492Sig,
-    });
-
-    if (isValid) {
-      return erc6492Sig;
-    }
-    throw new Error("Unable to verify ERC-6492 signature after signing.");
+    return erc6492Sig;
   }
 }
 
@@ -138,33 +109,23 @@ export async function smartAccountSignTypedData<
   }
 
   const originalMsgHash = hashTypedData(typedData);
-  // check if the account contract supports EIP721 domain separator based signing
-  const is712Factory = await checkFor712Factory({
-    accountContract,
-    factoryContract,
-    originalMsgHash,
-  });
 
   let sig: `0x${string}`;
-  if (is712Factory) {
-    const wrappedMessageHash = encodeAbiParameters(
-      [{ type: "bytes32" }],
-      [originalMsgHash],
-    );
-    sig = await options.personalAccount.signTypedData({
-      domain: {
-        chainId: options.chain.id,
-        name: "Account",
-        verifyingContract: accountContract.address,
-        version: "1",
-      },
-      message: { message: wrappedMessageHash },
-      primaryType: "AccountMessage",
-      types: { AccountMessage: [{ name: "message", type: "bytes" }] },
-    });
-  } else {
-    sig = await options.personalAccount.signTypedData(typedData);
-  }
+  const wrappedMessageHash = encodeAbiParameters(
+    [{ type: "bytes32" }],
+    [originalMsgHash],
+  );
+  sig = await options.personalAccount.signTypedData({
+    domain: {
+      chainId: options.chain.id,
+      name: "Account",
+      verifyingContract: accountContract.address,
+      version: "1",
+    },
+    message: { message: wrappedMessageHash },
+    primaryType: "AccountMessage",
+    types: { AccountMessage: [{ name: "message", type: "bytes" }] },
+  });
 
   const isDeployed = await isContractDeployed(accountContract);
   if (isDeployed) {
@@ -194,21 +155,7 @@ export async function smartAccountSignTypedData<
       signature: sig,
     });
 
-    // check if the signature is valid
-    const isValid = await verifyHash({
-      address: accountContract.address,
-      chain: accountContract.chain,
-      client: accountContract.client,
-      hash: originalMsgHash,
-      signature: erc6492Sig,
-    });
-
-    if (isValid) {
-      return erc6492Sig;
-    }
-    throw new Error(
-      "Unable to verify signature on smart account, please make sure the admin wallet has permissions and the signature is valid.",
-    );
+    return erc6492Sig;
   }
 }
 
@@ -233,40 +180,6 @@ export async function confirmContractDeployment(args: {
   }
 }
 
-async function checkFor712Factory({
-  factoryContract,
-  accountContract,
-  originalMsgHash,
-}: {
-  factoryContract: ThirdwebContract;
-  accountContract: ThirdwebContract;
-  originalMsgHash: Hex;
-}) {
-  try {
-    const implementationAccount = await readContract({
-      contract: factoryContract,
-      method: "function accountImplementation() public view returns (address)",
-    });
-    // check if the account contract supports EIP721 domain separator or modular based signing
-    const is712Factory = await readContract({
-      contract: getContract({
-        address: implementationAccount,
-        chain: accountContract.chain,
-        client: accountContract.client,
-      }),
-      method:
-        "function getMessageHash(bytes32 _hash) public view returns (bytes32)",
-      params: [originalMsgHash],
-    })
-      .then((res) => res !== "0x")
-      .catch(() => false);
-
-    return is712Factory;
-  } catch {
-    return false;
-  }
-}
-
 /**
  * Deployes a smart account via a dummy transaction. If the account is already deployed, this will do nothing.
  *

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

@@ -47,7 +47,6 @@ const contract = getContract({
   chain,
   client,
 });
-const factoryAddress = "0x564cf6453a1b0FF8DB603E92EA4BbD410dea45F3"; // pre 712
 
 describe.runIf(process.env.TW_SECRET_KEY).sequential(
   "SmartWallet core tests",
@@ -301,79 +300,6 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
       expect(logs.some((l) => l.args.isAdmin)).toBe(true);
     });
 
-    it("can use a different factory without replay protection", async () => {
-      const wallet = smartWallet({
-        chain,
-        factoryAddress: factoryAddress,
-        gasless: true,
-      });
-
-      // should not be able to switch chains before connecting
-      await expect(
-        wallet.switchChain(baseSepolia),
-      ).rejects.toMatchInlineSnapshot(
-        "[Error: Cannot switch chain without a previous connection]",
-      );
-
-      const newAccount = await wallet.connect({ client, personalAccount });
-      const message = "hello world";
-      const signature = await newAccount.signMessage({ message });
-      const isValidV1 = await verifySignature({
-        address: newAccount.address,
-        chain,
-        client,
-        message,
-        signature,
-      });
-      expect(isValidV1).toEqual(true);
-
-      // sign typed data
-      const signatureTyped = await newAccount.signTypedData({
-        ...typedData.basic,
-        primaryType: "Mail",
-      });
-      const isValidV2 = await verifyTypedData({
-        address: newAccount.address,
-        chain,
-        client,
-        signature: signatureTyped,
-        ...typedData.basic,
-      });
-      expect(isValidV2).toEqual(true);
-
-      // add admin pre-deployment
-      const newAdmin = await generateAccount({ client });
-      const receipt = await sendAndConfirmTransaction({
-        account: newAccount,
-        transaction: addAdmin({
-          account: newAccount,
-          adminAddress: newAdmin.address,
-          contract: getContract({
-            address: newAccount.address,
-            chain,
-            client,
-          }),
-        }),
-      });
-      const logs = parseEventLogs({
-        events: [adminUpdatedEvent()],
-        logs: receipt.logs,
-      });
-      expect(logs.map((l) => l.args.signer)).toContain(newAdmin.address);
-      expect(logs.map((l) => l.args.isAdmin)).toContain(true);
-
-      // should not be able to switch chains since factory not deployed elsewhere
-      await expect(
-        wallet.switchChain(baseSepolia),
-      ).rejects.toMatchInlineSnapshot(
-        "[Error: Factory contract not deployed on chain: 84532]",
-      );
-
-      // check can disconnnect
-      await wallet.disconnect();
-      expect(wallet.getAccount()).toBeUndefined();
-    });
-
     it("can switch chains", async () => {
       await wallet.switchChain(baseSepolia);
       expect(wallet.getChain()?.id).toEqual(baseSepolia.id);
@@ -424,7 +350,7 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
             tokenId: 0n,
           }),
         }),
-        sleep(1000).then(() =>
+        sleep(1500).then(() =>
           sendAndConfirmTransaction({
             account: newSmartAccount,
             transaction: claimTo({
@@ -453,7 +379,6 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
     it("can use a different paymaster", async () => {
       const wallet = smartWallet({
         chain,
-        factoryAddress: factoryAddress,
         gasless: true,
         overrides: {
           paymaster: async () => {

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

@@ -229,7 +229,7 @@ export function smartWallet(
       const { connectSmartAccount } = await import("./index.js");
       const [connectedAccount, connectedChain] = await connectSmartAccount(
         { ...lastConnectOptions, chain: newChain },
-        createOptions,
+        { ...createOptions, chain: newChain },
       );
       // set the states
       account = connectedAccount;