thirdweb 5.80.1-nightly-430475913d30ef7a30cb3092f6ef09c0c998a9b6-20250106000343 → 5.82.0

package/src/wallets/smart/index.ts

@@ -69,28 +69,26 @@ export function isSmartWallet(
 }
 
 /**
- * We can get the personal account for given smart account but not the other way around - this map gives us the reverse lookup
+ * For in-app wallets, the smart wallet creation is implicit so we track these to be able to retrieve the personal account for a smart account on the wallet API.
+ * Note: We have to go account to account here and NOT wallet to account because the smart wallet itself is never exposed to the in-app wallet, only the account.
  * @internal
  */
-const personalAccountToSmartAccountMap = new WeakMap<
-  Account,
-  Wallet<"smart">
->();
-
-const smartWalletToPersonalAccountMap = new WeakMap<Wallet<"smart">, Account>();
+const adminAccountToSmartAccountMap = new WeakMap<Account, Account>();
+const smartAccountToAdminAccountMap = new WeakMap<Account, Account>();
 
 /**
  * @internal
  */
-export async function connectSmartWallet(
-  wallet: Wallet<"smart">,
+export async function connectSmartAccount(
   connectionOptions: SmartWalletConnectionOptions,
   creationOptions: SmartWalletOptions,
 ): Promise<[Account, Chain]> {
   const { personalAccount, client, chain: connectChain } = connectionOptions;
 
   if (!personalAccount) {
-    throw new Error("Personal wallet does not have an account");
+    throw new Error(
+      "No personal account provided for smart account connection",
+    );
   }
 
   const options = creationOptions;
@@ -177,8 +175,8 @@ export async function connectSmartWallet(
     client,
   });
 
-  personalAccountToSmartAccountMap.set(personalAccount, wallet);
-  smartWalletToPersonalAccountMap.set(wallet, personalAccount);
+  adminAccountToSmartAccountMap.set(personalAccount, account);
+  smartAccountToAdminAccountMap.set(account, personalAccount);
 
   return [account, chain] as const;
 }
@@ -186,15 +184,13 @@ export async function connectSmartWallet(
 /**
  * @internal
  */
-export async function disconnectSmartWallet(
-  wallet: Wallet<"smart">,
-): Promise<void> {
+export async function disconnectSmartAccount(account: Account): Promise<void> {
   // look up the personalAccount for the smart wallet
-  const personalAccount = smartWalletToPersonalAccountMap.get(wallet);
+  const personalAccount = smartAccountToAdminAccountMap.get(account);
   if (personalAccount) {
     // remove the mappings
-    personalAccountToSmartAccountMap.delete(personalAccount);
-    smartWalletToPersonalAccountMap.delete(wallet);
+    adminAccountToSmartAccountMap.delete(personalAccount);
+    smartAccountToAdminAccountMap.delete(account);
   }
 }
 
@@ -214,7 +210,7 @@ async function createSmartAccount(
     }
   }
 
-  const { accountContract } = options;
+  let accountContract = options.accountContract;
   const account: Account = {
     address: getAddress(accountContract.address),
     async sendTransaction(transaction: SendTransactionOption) {
@@ -241,21 +237,17 @@ async function createSmartAccount(
         paymasterOverride = options.overrides?.paymaster;
       }
 
-      const accountContractForTransaction = (() => {
-        // If this transaction is for a different chain than the initial one, get the account contract for that chain
-        if (transaction.chainId !== accountContract.chain.id) {
-          return getContract({
-            address: account.address,
-            chain: getCachedChain(transaction.chainId),
-            client: options.client,
-          });
-        }
-        // Default to the existing account contract
-        return accountContract;
-      })();
+      // If this transaction is for a different chain than the initial one, get the account contract for that chain
+      if (transaction.chainId !== accountContract.chain.id) {
+        accountContract = getContract({
+          address: account.address,
+          chain: getCachedChain(transaction.chainId),
+          client: options.client,
+        });
+      }
 
       const executeTx = prepareExecute({
-        accountContract: accountContractForTransaction,
+        accountContract: accountContract,
         transaction,
         executeOverride: options.overrides?.execute,
       });
@@ -264,6 +256,7 @@ async function createSmartAccount(
         options: {
           ...options,
           chain: getCachedChain(transaction.chainId),
+          accountContract,
           overrides: {
             ...options.overrides,
             paymaster: paymasterOverride,
@@ -279,7 +272,11 @@ async function createSmartAccount(
       });
       return _sendUserOp({
         executeTx,
-        options,
+        options: {
+          ...options,
+          chain: getCachedChain(transactions[0]?.chainId ?? options.chain.id),
+          accountContract,
+        },
       });
     },
     async signMessage({ message }: { message: SignableMessage }) {
@@ -292,8 +289,8 @@ async function createSmartAccount(
         });
       }
 
-      const { deployAndSignMessage } = await import("./lib/signing.js");
-      return deployAndSignMessage({
+      const { smartAccountSignMessage } = await import("./lib/signing.js");
+      return smartAccountSignMessage({
         accountContract,
         factoryContract: options.factoryContract,
         options,
@@ -313,8 +310,8 @@ async function createSmartAccount(
         });
       }
 
-      const { deployAndSignTypedData } = await import("./lib/signing.js");
-      return deployAndSignTypedData({
+      const { smartAccountSignTypedData } = await import("./lib/signing.js");
+      return smartAccountSignTypedData({
         accountContract,
         factoryContract: options.factoryContract,
         options,

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

@@ -1,6 +1,11 @@
 import type * as ox__TypedData from "ox/TypedData";
 import { serializeErc6492Signature } from "../../../auth/serialize-erc6492-signature.js";
-import { verifyHash } from "../../../auth/verify-hash.js";
+import {
+  verifyEip1271Signature,
+  verifyHash,
+} from "../../../auth/verify-hash.js";
+import type { Chain } from "../../../chains/types.js";
+import type { ThirdwebClient } from "../../../client/client.js";
 import {
   type ThirdwebContract,
   getContract,
@@ -8,14 +13,22 @@ import {
 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";
+import type { Account } from "../../../wallets/interfaces/wallet.js";
 import type { SmartAccountOptions } from "../types.js";
 import { prepareCreateAccount } from "./calls.js";
 
-export async function deployAndSignMessage({
+/**
+ * If the account is already deployed, generate an ERC-1271 signature.
+ * If the account is not deployed, generate an ERC-6492 signature unless otherwise specified.
+ *
+ * @internal
+ */
+export async function smartAccountSignMessage({
   accountContract,
   factoryContract,
   options,
@@ -55,40 +68,51 @@ export async function deployAndSignMessage({
     sig = await options.personalAccount.signMessage({ message });
   }
 
-  const deployTx = prepareCreateAccount({
-    factoryContract,
-    adminAddress: options.personalAccount.address,
-    accountSalt: options.overrides?.accountSalt,
-    createAccountOverride: options.overrides?.createAccount,
-  });
-  if (!deployTx) {
-    throw new Error("Create account override not provided");
-  }
-  const initCode = await encode(deployTx);
-  const erc6492Sig = serializeErc6492Signature({
-    address: factoryContract.address,
-    data: initCode,
-    signature: sig,
-  });
+  const isDeployed = await isContractDeployed(accountContract);
+  if (isDeployed) {
+    const isValid = await verifyEip1271Signature({
+      hash: originalMsgHash,
+      signature: sig,
+      contract: accountContract,
+    });
+    if (isValid) {
+      return sig;
+    }
+    throw new Error("Failed to verify signature");
+  } else {
+    const deployTx = prepareCreateAccount({
+      factoryContract,
+      adminAddress: options.personalAccount.address,
+      accountSalt: options.overrides?.accountSalt,
+      createAccountOverride: options.overrides?.createAccount,
+    });
+    if (!deployTx) {
+      throw new Error("Create account override not provided");
+    }
+    const initCode = await encode(deployTx);
+    const erc6492Sig = serializeErc6492Signature({
+      address: factoryContract.address,
+      data: initCode,
+      signature: sig,
+    });
 
-  // check if the signature is valid
-  const isValid = await verifyHash({
-    hash: originalMsgHash,
-    signature: erc6492Sig,
-    address: accountContract.address,
-    chain: accountContract.chain,
-    client: accountContract.client,
-  });
+    // check if the signature is valid
+    const isValid = await verifyHash({
+      hash: originalMsgHash,
+      signature: erc6492Sig,
+      address: accountContract.address,
+      chain: accountContract.chain,
+      client: accountContract.client,
+    });
 
-  if (isValid) {
-    return erc6492Sig;
+    if (isValid) {
+      return erc6492Sig;
+    }
+    throw new Error("Unable to verify ERC-6492 signature after signing.");
   }
-  throw new Error(
-    "Unable to verify signature on smart account, please make sure the admin wallet has permissions and the signature is valid.",
-  );
 }
 
-export async function deployAndSignTypedData<
+export async function smartAccountSignTypedData<
   const typedData extends ox__TypedData.TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
 >({
@@ -142,37 +166,50 @@ export async function deployAndSignTypedData<
     sig = await options.personalAccount.signTypedData(typedData);
   }
 
-  const deployTx = prepareCreateAccount({
-    factoryContract,
-    adminAddress: options.personalAccount.address,
-    accountSalt: options.overrides?.accountSalt,
-    createAccountOverride: options.overrides?.createAccount,
-  });
-  if (!deployTx) {
-    throw new Error("Create account override not provided");
-  }
-  const initCode = await encode(deployTx);
-  const erc6492Sig = serializeErc6492Signature({
-    address: factoryContract.address,
-    data: initCode,
-    signature: sig,
-  });
+  const isDeployed = await isContractDeployed(accountContract);
+  if (isDeployed) {
+    const isValid = await verifyEip1271Signature({
+      hash: originalMsgHash,
+      signature: sig,
+      contract: accountContract,
+    });
+    if (isValid) {
+      return sig;
+    }
+    throw new Error("Failed to verify signature");
+  } else {
+    const deployTx = prepareCreateAccount({
+      factoryContract,
+      adminAddress: options.personalAccount.address,
+      accountSalt: options.overrides?.accountSalt,
+      createAccountOverride: options.overrides?.createAccount,
+    });
+    if (!deployTx) {
+      throw new Error("Create account override not provided");
+    }
+    const initCode = await encode(deployTx);
+    const erc6492Sig = serializeErc6492Signature({
+      address: factoryContract.address,
+      data: initCode,
+      signature: sig,
+    });
 
-  // check if the signature is valid
-  const isValid = await verifyHash({
-    hash: originalMsgHash,
-    signature: erc6492Sig,
-    address: accountContract.address,
-    chain: accountContract.chain,
-    client: accountContract.client,
-  });
+    // check if the signature is valid
+    const isValid = await verifyHash({
+      hash: originalMsgHash,
+      signature: erc6492Sig,
+      address: accountContract.address,
+      chain: accountContract.chain,
+      client: accountContract.client,
+    });
 
-  if (isValid) {
-    return 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.",
+    );
   }
-  throw new Error(
-    "Unable to verify signature on smart account, please make sure the admin wallet has permissions and the signature is valid.",
-  );
 }
 
 export async function confirmContractDeployment(args: {
@@ -229,3 +266,61 @@ async function checkFor712Factory({
     return false;
   }
 }
+
+/**
+ * Deployes a smart account via a dummy transaction.
+ *
+ * @param args - Arguments for the deployment.
+ * @param args.smartAccount - The smart account to deploy.
+ * @param args.chain - The chain to deploy on.
+ * @param args.client - The client to use for the deployment.
+ * @param args.accountContract - The account contract to deploy.
+ *
+ * @example
+ * ```ts
+ * import { deploySmartAccount } from "thirdweb";
+ *
+ * const account = await deploySmartAccount({
+ *   smartAccount,
+ *   chain,
+ *   client,
+ *   accountContract,
+ * });
+ * ```
+ *
+ * @wallets
+ */
+export async function deploySmartAccount(args: {
+  smartAccount: Account;
+  chain: Chain;
+  client: ThirdwebClient;
+  accountContract: ThirdwebContract;
+}) {
+  const { chain, client, smartAccount, accountContract } = args;
+  const isDeployed = await isContractDeployed(accountContract);
+  if (isDeployed) {
+    return;
+  }
+
+  const [{ sendTransaction }, { prepareTransaction }] = await Promise.all([
+    import("../../../transaction/actions/send-transaction.js"),
+    import("../../../transaction/prepare-transaction.js"),
+  ]);
+  const dummyTx = prepareTransaction({
+    client: client,
+    chain: chain,
+    to: accountContract.address,
+    value: 0n,
+    gas: 50000n, // force gas to avoid simulation error
+  });
+  const deployResult = await sendTransaction({
+    transaction: dummyTx,
+    account: smartAccount,
+  });
+
+  await confirmContractDeployment({
+    accountContract,
+  });
+
+  return deployResult;
+}

package/src/wallets/smart/presets/7579.ts

@@ -1,4 +1,5 @@
-import { AbiParameters, Hex } from "ox";
+import * as ox__AbiParameters from "ox/AbiParameters";
+import * as ox__Hex from "ox/Hex";
 import { serializeErc6492Signature } from "../../../auth/serialize-erc6492-signature.js";
 import { verifyHash } from "../../../auth/verify-hash.js";
 import { ZERO_ADDRESS } from "../../../constants/addresses.js";
@@ -56,9 +57,9 @@ export type ERC7579Config = SmartWalletOptions & {
 export function erc7579(options: ERC7579Config): SmartWalletOptions {
   const saltHex =
     options.overrides?.accountSalt &&
-    Hex.validate(options.overrides.accountSalt)
+    ox__Hex.validate(options.overrides.accountSalt)
       ? options.overrides.accountSalt
-      : Hex.fromString(options.overrides?.accountSalt ?? "");
+      : ox__Hex.fromString(options.overrides?.accountSalt ?? "");
   const defaultValidator = getAddress(options.validatorAddress);
   const modularAccountOptions: SmartWalletOptions = {
     ...options,
@@ -75,7 +76,7 @@ export function erc7579(options: ERC7579Config): SmartWalletOptions {
               {
                 moduleTypeId: 1n, // validator type id
                 module: defaultValidator,
-                initData: Hex.fromString(""),
+                initData: ox__Hex.fromString(""),
               },
             ];
             return {
@@ -99,8 +100,8 @@ export function erc7579(options: ERC7579Config): SmartWalletOptions {
           contract: accountContract,
           async asyncParams() {
             return {
-              mode: Hex.padRight("0x00", 32), // single execution
-              executionCalldata: AbiParameters.encodePacked(
+              mode: ox__Hex.padRight("0x00", 32), // single execution
+              executionCalldata: ox__AbiParameters.encodePacked(
                 ["address", "uint256", "bytes"],
                 [
                   transaction.to || ZERO_ADDRESS,
@@ -117,8 +118,8 @@ export function erc7579(options: ERC7579Config): SmartWalletOptions {
           contract: accountContract,
           async asyncParams() {
             return {
-              mode: Hex.padRight("0x01", 32), // batch execution
-              executionCalldata: AbiParameters.encode(
+              mode: ox__Hex.padRight("0x01", 32), // batch execution
+              executionCalldata: ox__AbiParameters.encode(
                 [
                   {
                     type: "tuple[]",
@@ -152,10 +153,10 @@ export function erc7579(options: ERC7579Config): SmartWalletOptions {
           sender: accountContract.address,
         });
         // TODO (msa) - could be different if validator for the deployed account is different
-        const withValidator = Hex.from(
-          `${defaultValidator}${Hex.fromNumber(entryPointNonce).slice(42)}`,
+        const withValidator = ox__Hex.from(
+          `${defaultValidator}${ox__Hex.fromNumber(entryPointNonce).slice(42)}`,
         );
-        return Hex.toBigInt(withValidator);
+        return ox__Hex.toBigInt(withValidator);
       },
       async signMessage(options) {
         const { accountContract, factoryContract, adminAccount, message } =
@@ -201,7 +202,7 @@ async function generateSignature(options: {
   accountContract: ThirdwebContract;
   factoryContract: ThirdwebContract;
   adminAccount: Account;
-  originalMsgHash: Hex.Hex;
+  originalMsgHash: ox__Hex.Hex;
   defaultValidator: string;
   createAccount: (
     factoryContract: ThirdwebContract,

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

@@ -6,6 +6,7 @@ import { type ThirdwebContract, getContract } from "../../contract/contract.js";
 import { parseEventLogs } from "../../event/actions/parse-logs.js";
 
 import { TEST_WALLET_A } from "~test/addresses.js";
+import { verifyEip1271Signature } from "../../auth/verify-hash.js";
 import { verifyTypedData } from "../../auth/verify-typed-data.js";
 import { baseSepolia } from "../../chains/chain-definitions/base-sepolia.js";
 import { sepolia } from "../../chains/chain-definitions/sepolia.js";
@@ -13,7 +14,6 @@ import {
   addAdmin,
   adminUpdatedEvent,
 } from "../../exports/extensions/erc4337.js";
-import { balanceOf } from "../../extensions/erc1155/__generated__/IERC1155/read/balanceOf.js";
 import { claimTo } from "../../extensions/erc1155/drops/write/claimTo.js";
 import { setContractURI } from "../../extensions/marketplace/__generated__/IMarketplace/write/setContractURI.js";
 import { estimateGasCost } from "../../transaction/actions/estimate-gas-cost.js";
@@ -21,14 +21,18 @@ import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-co
 import { sendBatchTransaction } from "../../transaction/actions/send-batch-transaction.js";
 import { waitForReceipt } from "../../transaction/actions/wait-for-tx-receipt.js";
 import { prepareTransaction } from "../../transaction/prepare-transaction.js";
-import { getAddress } from "../../utils/address.js";
 import { isContractDeployed } from "../../utils/bytecode/is-contract-deployed.js";
+import { hashMessage } from "../../utils/hashing/hashMessage.js";
+import { hashTypedData } from "../../utils/hashing/hashTypedData.js";
 import { sleep } from "../../utils/sleep.js";
 import type { Account, Wallet } from "../interfaces/wallet.js";
 import { generateAccount } from "../utils/generateAccount.js";
 import { predictSmartAccountAddress } from "./lib/calls.js";
 import { DEFAULT_ACCOUNT_FACTORY_V0_7 } from "./lib/constants.js";
-import { confirmContractDeployment } from "./lib/signing.js";
+import {
+  confirmContractDeployment,
+  deploySmartAccount,
+} from "./lib/signing.js";
 import { smartWallet } from "./smart-wallet.js";
 
 let wallet: Wallet;
@@ -98,6 +102,27 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       expect(isValid).toEqual(true);
     });
 
+    it("should use ERC-1271 signatures after deployment", async () => {
+      await deploySmartAccount({
+        chain,
+        client,
+        smartAccount,
+        accountContract,
+      });
+      await new Promise((resolve) => setTimeout(resolve, 1000)); // pause for a second to prevent race condition
+
+      const signature = await smartAccount.signMessage({
+        message: "hello world",
+      });
+
+      const isValid = await verifyEip1271Signature({
+        hash: hashMessage("hello world"),
+        signature,
+        contract: accountContract,
+      });
+      expect(isValid).toEqual(true);
+    });
+
     it("can sign typed data", async () => {
       const signature = await smartAccount.signTypedData(typedData.basic);
       const isValid = await verifyTypedData({
@@ -110,6 +135,27 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       expect(isValid).toEqual(true);
     });
 
+    it("should use ERC-1271 typed data signatures after deployment", async () => {
+      await deploySmartAccount({
+        chain,
+        client,
+        smartAccount,
+        accountContract,
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 1000)); // pause for a second to prevent race condition
+
+      const signature = await smartAccount.signTypedData(typedData.basic);
+
+      const messageHash = hashTypedData(typedData.basic);
+      const isValid = await verifyEip1271Signature({
+        signature,
+        hash: messageHash,
+        contract: accountContract,
+      });
+      expect(isValid).toEqual(true);
+    });
+
     it("can send a transaction on another chain", async () => {
       const tx = await sendAndConfirmTransaction({
         transaction: prepareTransaction({
@@ -155,12 +201,6 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       await confirmContractDeployment({ accountContract });
       const isDeployed = await isContractDeployed(accountContract);
       expect(isDeployed).toEqual(true);
-      const balance = await balanceOf({
-        contract,
-        owner: getAddress(smartWalletAddress),
-        tokenId: 0n,
-      });
-      expect(balance).toEqual(1n);
     });
 
     it("can estimate a tx", async () => {

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

@@ -2,6 +2,7 @@ import { beforeAll, describe, expect, it } from "vitest";
 import { TEST_WALLET_A } from "~test/addresses.js";
 import { TEST_CLIENT } from "../../../test/src/test-clients.js";
 import { typedData } from "../../../test/src/typed-data.js";
+import { verifyEip1271Signature } from "../../auth/verify-hash.js";
 import { verifySignature } from "../../auth/verify-signature.js";
 import { verifyTypedData } from "../../auth/verify-typed-data.js";
 import { arbitrumSepolia } from "../../chains/chain-definitions/arbitrum-sepolia.js";
@@ -22,10 +23,13 @@ import { sendTransaction } from "../../transaction/actions/send-transaction.js";
 import { waitForReceipt } from "../../transaction/actions/wait-for-tx-receipt.js";
 import { prepareTransaction } from "../../transaction/prepare-transaction.js";
 import { isContractDeployed } from "../../utils/bytecode/is-contract-deployed.js";
+import { hashMessage } from "../../utils/hashing/hashMessage.js";
+import { hashTypedData } from "../../utils/hashing/hashTypedData.js";
 import { sleep } from "../../utils/sleep.js";
 import type { Account, Wallet } from "../interfaces/wallet.js";
 import { generateAccount } from "../utils/generateAccount.js";
 import { predictSmartAccountAddress } from "./lib/calls.js";
+import { deploySmartAccount } from "./lib/signing.js";
 import { smartWallet } from "./smart-wallet.js";
 
 let wallet: Wallet;
@@ -94,6 +98,27 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
       expect(isValid).toEqual(true);
     });
 
+    it("should use ERC-1271 signatures after deployment", async () => {
+      await deploySmartAccount({
+        chain,
+        client,
+        smartAccount,
+        accountContract,
+      });
+      await new Promise((resolve) => setTimeout(resolve, 1000)); // pause for a second to prevent race condition
+
+      const signature = await smartAccount.signMessage({
+        message: "hello world",
+      });
+
+      const isValid = await verifyEip1271Signature({
+        hash: hashMessage("hello world"),
+        signature,
+        contract: accountContract,
+      });
+      expect(isValid).toEqual(true);
+    });
+
     it("can sign typed data", async () => {
       const signature = await smartAccount.signTypedData(typedData.basic);
       const isValid = await verifyTypedData({
@@ -106,6 +131,27 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
       expect(isValid).toEqual(true);
     });
 
+    it("should use ERC-1271 typed data signatures after deployment", async () => {
+      await deploySmartAccount({
+        chain,
+        client,
+        smartAccount,
+        accountContract,
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 1000)); // pause for a second to prevent race condition
+
+      const signature = await smartAccount.signTypedData(typedData.basic);
+
+      const messageHash = hashTypedData(typedData.basic);
+      const isValid = await verifyEip1271Signature({
+        signature,
+        hash: messageHash,
+        contract: accountContract,
+      });
+      expect(isValid).toEqual(true);
+    });
+
     it("should revert on unsuccessful transactions", async () => {
       const tx = sendAndConfirmTransaction({
         transaction: setContractURI({
@@ -184,7 +230,7 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
       expect(result.status).toEqual("success");
     });
 
-    it("can sign and verify 1271 with replay protection", async () => {
+    it("can sign and verify with replay protection", async () => {
       const message = "hello world";
       const signature = await smartAccount.signMessage({ message });
       const isValidV1 = await verifySignature({
@@ -371,6 +417,7 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
       expect(txs.every((t) => t.transactionHash.length === 66)).toBe(true);
 
       isDeployed = await isContractDeployed(newSmartAccountContract);
+      await sleep(1000);
       expect(isDeployed).toEqual(true);
       const balance = await balanceOf({
         contract,