thirdweb 5.105.19-nightly-8260af3a9258595b53f021a64a1e015791d33949-20250724000414 → 5.105.20

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 () => {