thirdweb 5.48.2 → 5.48.3-nightly-a8e2bc58c9e8fe5b75d6c27d406e6b80d5d067e2-20240828000339

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

@@ -6,22 +6,24 @@ import {
   getContract,
 } from "../../../contract/contract.js";
 import { getNonce } from "../../../extensions/erc4337/__generated__/IEntryPoint/read/getNonce.js";
+import { getUserOpHash as getUserOpHashV06 } from "../../../extensions/erc4337/__generated__/IEntryPoint/read/getUserOpHash.js";
+import { getUserOpHash as getUserOpHashV07 } from "../../../extensions/erc4337/__generated__/IEntryPoint_v07/read/getUserOpHash.js";
 import { getDefaultGasOverrides } from "../../../gas/fee-data.js";
 import { encode } from "../../../transaction/actions/encode.js";
 import type { PreparedTransaction } from "../../../transaction/prepare-transaction.js";
 import type { TransactionReceipt } from "../../../transaction/types.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 { hexToBytes } from "../../../utils/encoding/to-bytes.js";
 import { isThirdwebUrl } from "../../../utils/fetch.js";
-import { keccak256 } from "../../../utils/hashing/keccak256.js";
 import { resolvePromisedValue } from "../../../utils/promise/resolve-promised-value.js";
 import type { Account } from "../../interfaces/wallet.js";
 import type {
   BundlerOptions,
+  PaymasterResult,
   SmartWalletOptions,
-  UserOperation,
+  UserOperationV06,
+  UserOperationV07,
 } from "../types.js";
 import {
   estimateUserOpGas,
@@ -32,8 +34,11 @@ import { prepareCreateAccount } from "./calls.js";
 import {
   DUMMY_SIGNATURE,
   ENTRYPOINT_ADDRESS_v0_6,
+  ENTRYPOINT_ADDRESS_v0_7,
   getDefaultBundlerUrl,
+  getEntryPointVersion,
 } from "./constants.js";
+import { getPackedUserOperation } from "./packUserOp.js";
 import { getPaymasterAndData } from "./paymaster.js";
 import { generateRandomUint192 } from "./utils.js";
 
@@ -102,7 +107,7 @@ export async function createUnsignedUserOp(args: {
   adminAddress: string;
   sponsorGas: boolean;
   overrides?: SmartWalletOptions["overrides"];
-}): Promise<UserOperation> {
+}): Promise<UserOperationV06 | UserOperationV07> {
   const {
     transaction: executeTx,
     accountContract,
@@ -113,24 +118,88 @@ export async function createUnsignedUserOp(args: {
   } = args;
   const chain = executeTx.chain;
   const client = executeTx.client;
-  const isDeployed = await isContractDeployed(accountContract);
-  const initCode = isDeployed
-    ? "0x"
-    : await getAccountInitCode({
-        factoryContract: factoryContract,
-        adminAddress,
-        accountSalt: overrides?.accountSalt,
-        createAccountOverride: overrides?.createAccount,
-      });
-  const callData = await encode(executeTx);
+
   const bundlerOptions = {
     client,
     chain,
     entrypointAddress: overrides?.entrypointAddress,
   };
 
+  const entrypointVersion = getEntryPointVersion(
+    args.overrides?.entrypointAddress || ENTRYPOINT_ADDRESS_v0_6,
+  );
+
+  const [isDeployed, callData, gasFees, nonce] = await Promise.all([
+    isContractDeployed(accountContract),
+    encode(executeTx),
+    getGasFees({
+      executeTx,
+      bundlerOptions,
+      chain,
+      client,
+    }),
+    getAccountNonce({
+      accountContract,
+      chain,
+      client,
+      entrypointAddress: overrides?.entrypointAddress,
+      getNonceOverride: overrides?.getAccountNonce,
+    }),
+  ]);
+
+  const { maxFeePerGas, maxPriorityFeePerGas } = gasFees;
+
+  if (entrypointVersion === "v0.7") {
+    return populateUserOp_v0_7({
+      bundlerOptions,
+      factoryContract,
+      accountContract,
+      adminAddress,
+      sponsorGas,
+      overrides,
+      isDeployed,
+      nonce,
+      callData,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+    });
+  }
+
+  // default to v0.6
+  return populateUserOp_v0_6({
+    bundlerOptions,
+    factoryContract,
+    accountContract,
+    adminAddress,
+    sponsorGas,
+    overrides,
+    isDeployed,
+    nonce,
+    callData,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+  });
+}
+
+async function getGasFees(args: {
+  executeTx: PreparedTransaction;
+  bundlerOptions: BundlerOptions;
+  chain: Chain;
+  client: ThirdwebClient;
+}): Promise<{
+  maxFeePerGas: bigint;
+  maxPriorityFeePerGas: bigint;
+}> {
+  const { executeTx, bundlerOptions, chain, client } = args;
   let { maxFeePerGas, maxPriorityFeePerGas } = executeTx;
-  const bundlerUrl = overrides?.bundlerUrl ?? getDefaultBundlerUrl(chain);
+
+  const entrypointVersion = getEntryPointVersion(
+    bundlerOptions.entrypointAddress || ENTRYPOINT_ADDRESS_v0_6,
+  );
+  const bundlerVersion = entrypointVersion === "v0.6" ? "v1" : "v2";
+  const bundlerUrl =
+    bundlerOptions?.bundlerUrl ?? getDefaultBundlerUrl(chain, bundlerVersion);
+
   if (isThirdwebUrl(bundlerUrl)) {
     // get gas prices from bundler
     const bundlerGasPrice = await getUserOpGasFees({
@@ -160,16 +229,175 @@ export async function createUnsignedUserOp(args: {
       maxFeePerGas = resolvedMaxFeePerGas ?? feeData.maxFeePerGas ?? 0n;
     }
   }
+  return { maxFeePerGas, maxPriorityFeePerGas };
+}
 
-  const nonce = await getAccountNonce({
+async function populateUserOp_v0_7(args: {
+  bundlerOptions: BundlerOptions;
+  factoryContract: ThirdwebContract;
+  accountContract: ThirdwebContract;
+  adminAddress: string;
+  sponsorGas: boolean;
+  overrides?: SmartWalletOptions["overrides"];
+  isDeployed: boolean;
+  nonce: bigint;
+  callData: Hex;
+  maxFeePerGas: bigint;
+  maxPriorityFeePerGas: bigint;
+}): Promise<UserOperationV07> {
+  const {
+    bundlerOptions,
+    isDeployed,
+    factoryContract,
     accountContract,
-    chain,
-    client,
-    entrypointAddress: overrides?.entrypointAddress,
-    getNonceOverride: overrides?.getAccountNonce,
-  });
+    adminAddress,
+    sponsorGas,
+    overrides,
+    nonce,
+    callData,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+  } = args;
+  const { chain, client } = bundlerOptions;
+  const factory = isDeployed ? undefined : factoryContract.address;
+  const factoryData = isDeployed
+    ? "0x"
+    : await encode(
+        prepareCreateAccount({
+          factoryContract: factoryContract,
+          adminAddress,
+          accountSalt: overrides?.accountSalt,
+          createAccountOverride: overrides?.createAccount,
+        }),
+      );
 
-  const partialOp: UserOperation = {
+  const partialOp: UserOperationV07 = {
+    sender: accountContract.address,
+    nonce,
+    callData,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    callGasLimit: 0n,
+    verificationGasLimit: 0n,
+    preVerificationGas: 0n,
+    factory,
+    factoryData,
+    paymaster: undefined,
+    paymasterData: "0x",
+    paymasterVerificationGasLimit: 0n,
+    paymasterPostOpGasLimit: 0n,
+    signature: DUMMY_SIGNATURE,
+  };
+
+  if (sponsorGas) {
+    const paymasterResult = (await getPaymasterAndData({
+      userOp: partialOp,
+      chain,
+      client,
+      entrypointAddress: overrides?.entrypointAddress,
+      paymasterOverride: overrides?.paymaster,
+    })) as Extract<PaymasterResult, { paymaster: string }>;
+    if (paymasterResult.paymaster && paymasterResult.paymasterData) {
+      partialOp.paymaster = paymasterResult.paymaster;
+      partialOp.paymasterData = paymasterResult.paymasterData as Hex;
+    }
+    // paymaster can have the gas limits in the response
+    if (
+      paymasterResult.callGasLimit &&
+      paymasterResult.verificationGasLimit &&
+      paymasterResult.preVerificationGas &&
+      paymasterResult.paymasterPostOpGasLimit &&
+      paymasterResult.paymasterVerificationGasLimit
+    ) {
+      partialOp.callGasLimit = paymasterResult.callGasLimit;
+      partialOp.verificationGasLimit = paymasterResult.verificationGasLimit;
+      partialOp.preVerificationGas = paymasterResult.preVerificationGas;
+      partialOp.paymasterPostOpGasLimit =
+        paymasterResult.paymasterPostOpGasLimit;
+      partialOp.paymasterVerificationGasLimit =
+        paymasterResult.paymasterVerificationGasLimit;
+    } else {
+      // otherwise fallback to bundler for gas limits
+      const estimates = await estimateUserOpGas({
+        userOp: partialOp,
+        options: bundlerOptions,
+      });
+      partialOp.callGasLimit = estimates.callGasLimit;
+      partialOp.verificationGasLimit = estimates.verificationGasLimit;
+      partialOp.preVerificationGas = estimates.preVerificationGas;
+      partialOp.paymasterPostOpGasLimit =
+        paymasterResult.paymasterPostOpGasLimit || 0n;
+      partialOp.paymasterVerificationGasLimit =
+        paymasterResult.paymasterVerificationGasLimit || 0n;
+      // need paymaster to re-sign after estimates
+      const paymasterResult2 = (await getPaymasterAndData({
+        userOp: partialOp,
+        chain,
+        client,
+        entrypointAddress: overrides?.entrypointAddress,
+        paymasterOverride: overrides?.paymaster,
+      })) as Extract<PaymasterResult, { paymaster: string }>;
+      if (paymasterResult2.paymaster && paymasterResult2.paymasterData) {
+        partialOp.paymaster = paymasterResult2.paymaster;
+        partialOp.paymasterData = paymasterResult2.paymasterData as Hex;
+      }
+    }
+  } else {
+    // not gasless, so we just need to estimate gas limits
+    const estimates = await estimateUserOpGas({
+      userOp: partialOp,
+      options: bundlerOptions,
+    });
+    partialOp.callGasLimit = estimates.callGasLimit;
+    partialOp.verificationGasLimit = estimates.verificationGasLimit;
+    partialOp.preVerificationGas = estimates.preVerificationGas;
+    partialOp.paymasterPostOpGasLimit = estimates.paymasterPostOpGasLimit || 0n;
+    partialOp.paymasterVerificationGasLimit =
+      estimates.paymasterVerificationGasLimit || 0n;
+  }
+  return {
+    ...partialOp,
+    signature: "0x" as Hex,
+  };
+}
+
+async function populateUserOp_v0_6(args: {
+  bundlerOptions: BundlerOptions;
+  factoryContract: ThirdwebContract;
+  accountContract: ThirdwebContract;
+  adminAddress: string;
+  sponsorGas: boolean;
+  overrides?: SmartWalletOptions["overrides"];
+  isDeployed: boolean;
+  nonce: bigint;
+  callData: Hex;
+  maxFeePerGas: bigint;
+  maxPriorityFeePerGas: bigint;
+}): Promise<UserOperationV06> {
+  const {
+    bundlerOptions,
+    isDeployed,
+    factoryContract,
+    accountContract,
+    adminAddress,
+    sponsorGas,
+    overrides,
+    nonce,
+    callData,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+  } = args;
+  const { chain, client } = bundlerOptions;
+  const initCode = isDeployed
+    ? "0x"
+    : await getAccountInitCode({
+        factoryContract: factoryContract,
+        adminAddress,
+        accountSalt: overrides?.accountSalt,
+        createAccountOverride: overrides?.createAccount,
+      });
+
+  const partialOp: UserOperationV06 = {
     sender: accountContract.address,
     nonce,
     initCode,
@@ -191,7 +419,10 @@ export async function createUnsignedUserOp(args: {
       entrypointAddress: overrides?.entrypointAddress,
       paymasterOverride: overrides?.paymaster,
     });
-    const paymasterAndData = paymasterResult.paymasterAndData;
+    const paymasterAndData =
+      "paymasterAndData" in paymasterResult
+        ? paymasterResult.paymasterAndData
+        : "0x";
     if (paymasterAndData && paymasterAndData !== "0x") {
       partialOp.paymasterAndData = paymasterAndData as Hex;
     }
@@ -222,11 +453,12 @@ export async function createUnsignedUserOp(args: {
           entrypointAddress: overrides?.entrypointAddress,
           paymasterOverride: overrides?.paymaster,
         });
-        if (
-          paymasterResult2.paymasterAndData &&
-          paymasterResult2.paymasterAndData !== "0x"
-        ) {
-          partialOp.paymasterAndData = paymasterResult2.paymasterAndData as Hex;
+        const paymasterAndData2 =
+          "paymasterAndData" in paymasterResult2
+            ? paymasterResult2.paymasterAndData
+            : "0x";
+        if (paymasterAndData2 && paymasterAndData2 !== "0x") {
+          partialOp.paymasterAndData = paymasterAndData2 as Hex;
         }
       }
     }
@@ -242,7 +474,7 @@ export async function createUnsignedUserOp(args: {
   }
   return {
     ...partialOp,
-    signature: "0x",
+    signature: "0x" as Hex,
   };
 }
 
@@ -265,17 +497,41 @@ export async function createUnsignedUserOp(args: {
  * @walletUtils
  */
 export async function signUserOp(args: {
-  userOp: UserOperation;
+  client: ThirdwebClient;
+  userOp: UserOperationV06 | UserOperationV07;
   chain: Chain;
   entrypointAddress?: string;
   adminAccount: Account;
-}): Promise<UserOperation> {
+}): Promise<UserOperationV06 | UserOperationV07> {
   const { userOp, chain, entrypointAddress, adminAccount } = args;
-  const userOpHash = getUserOpHash({
-    userOp,
-    entryPoint: entrypointAddress || ENTRYPOINT_ADDRESS_v0_6,
-    chainId: chain.id,
-  });
+
+  const entrypointVersion = getEntryPointVersion(
+    entrypointAddress || ENTRYPOINT_ADDRESS_v0_6,
+  );
+
+  let userOpHash: Hex;
+
+  if (entrypointVersion === "v0.7") {
+    const packedUserOp = getPackedUserOperation(userOp as UserOperationV07);
+    userOpHash = await getUserOpHashV07({
+      contract: getContract({
+        address: entrypointAddress || ENTRYPOINT_ADDRESS_v0_7,
+        chain,
+        client: args.client,
+      }),
+      userOp: packedUserOp,
+    });
+  } else {
+    userOpHash = await getUserOpHashV06({
+      contract: getContract({
+        address: entrypointAddress || ENTRYPOINT_ADDRESS_v0_6,
+        chain,
+        client: args.client,
+      }),
+      userOp: userOp as UserOperationV06,
+    });
+  }
+
   if (adminAccount.signMessage) {
     const signature = await adminAccount.signMessage({
       message: {
@@ -336,52 +592,3 @@ async function getAccountNonce(options: {
     sender: accountContract.address,
   });
 }
-
-/**
- * Get the hash of a user operation.
- * @param args - The user operation, entrypoint address, and chain ID
- * @returns - The hash of the user operation
- * @walletUtils
- */
-function getUserOpHash(args: {
-  userOp: UserOperation;
-  entryPoint: string;
-  chainId: number;
-}): Hex {
-  const { userOp, entryPoint, chainId } = args;
-  const hashedInitCode = keccak256(userOp.initCode);
-  const hashedCallData = keccak256(userOp.callData);
-  const hashedPaymasterAndData = keccak256(userOp.paymasterAndData);
-
-  const packedUserOp = encodeAbiParameters(
-    [
-      { type: "address" },
-      { type: "uint256" },
-      { type: "bytes32" },
-      { type: "bytes32" },
-      { type: "uint256" },
-      { type: "uint256" },
-      { type: "uint256" },
-      { type: "uint256" },
-      { type: "uint256" },
-      { type: "bytes32" },
-    ],
-    [
-      userOp.sender,
-      userOp.nonce,
-      hashedInitCode,
-      hashedCallData,
-      userOp.callGasLimit,
-      userOp.verificationGasLimit,
-      userOp.preVerificationGas,
-      userOp.maxFeePerGas,
-      userOp.maxPriorityFeePerGas,
-      hashedPaymasterAndData,
-    ],
-  );
-  const encoded = encodeAbiParameters(
-    [{ type: "bytes32" }, { type: "address" }, { type: "uint256" }],
-    [keccak256(packedUserOp), entryPoint, BigInt(chainId)],
-  );
-  return keccak256(encoded);
-}

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

@@ -1,7 +1,12 @@
 import { concat } from "viem";
 import type { Chain } from "../../../chains/types.js";
 import { isHex, numberToHex, toHex } from "../../../utils/encoding/hex.js";
-import type { UserOperation, UserOperationHexed } from "../types.js";
+import type {
+  UserOperationV06,
+  UserOperationV06Hexed,
+  UserOperationV07,
+  UserOperationV07Hexed,
+} from "../types.js";
 
 export const generateRandomUint192 = (): bigint => {
   const rand1 = BigInt(Math.floor(Math.random() * 0x100000000));
@@ -32,14 +37,16 @@ export const randomNonce = () => {
 /**
  * @internal
  */
-export function hexlifyUserOp(userOp: UserOperation): UserOperationHexed {
+export function hexlifyUserOp(
+  userOp: UserOperationV06 | UserOperationV07,
+): UserOperationV06Hexed | UserOperationV07Hexed {
   return Object.fromEntries(
     Object.entries(userOp).map(([key, val]) => [
       key,
       // turn any value that's not hex into hex
-      isHex(val) ? val : toHex(val),
+      val === undefined || val === null || isHex(val) ? val : toHex(val),
     ]),
-  ) as UserOperationHexed;
+  ) as UserOperationV06Hexed | UserOperationV07Hexed;
 }
 
 export function isNativeAAChain(chain: Chain) {

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

@@ -0,0 +1,206 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "../../../test/src/test-clients.js";
+import { typedData } from "../../../test/src/typed-data.js";
+import { verifySignature } from "../../auth/verify-signature.js";
+import { type ThirdwebContract, getContract } from "../../contract/contract.js";
+import { parseEventLogs } from "../../event/actions/parse-logs.js";
+
+import { sepolia } from "../../chains/chain-definitions/sepolia.js";
+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 { checkContractWalletSignature } from "../../extensions/erc1271/checkContractWalletSignature.js";
+import { setContractURI } from "../../extensions/marketplace/__generated__/IMarketplace/write/setContractURI.js";
+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 { waitForReceipt } from "../../transaction/actions/wait-for-tx-receipt.js";
+import { getAddress } from "../../utils/address.js";
+import { isContractDeployed } from "../../utils/bytecode/is-contract-deployed.js";
+import type { Account, Wallet } from "../interfaces/wallet.js";
+import { generateAccount } from "../utils/generateAccount.js";
+import { ENTRYPOINT_ADDRESS_v0_7 } from "./lib/constants.js";
+import { smartWallet } from "./smart-wallet.js";
+
+let wallet: Wallet;
+let smartAccount: Account;
+let smartWalletAddress: string;
+let personalAccount: Account;
+let accountContract: ThirdwebContract;
+
+const chain = sepolia;
+const client = TEST_CLIENT;
+const contract = getContract({
+  client,
+  chain,
+  address: "0xe2cb0eb5147b42095c2FfA6F7ec953bb0bE347D8",
+});
+
+describe.runIf(process.env.TW_SECRET_KEY).sequential(
+  "SmartWallet 0.7 core tests",
+  {
+    retry: 0,
+    timeout: 240_000,
+  },
+  () => {
+    beforeAll(async () => {
+      personalAccount = await generateAccount({
+        client,
+      });
+      wallet = smartWallet({
+        chain,
+        gasless: true,
+        overrides: {
+          entrypointAddress: ENTRYPOINT_ADDRESS_v0_7,
+        },
+      });
+      smartAccount = await wallet.connect({
+        client: TEST_CLIENT,
+        personalAccount,
+      });
+      smartWalletAddress = smartAccount.address;
+      accountContract = getContract({
+        address: smartWalletAddress,
+        chain,
+        client,
+      });
+    });
+
+    it("can connect", async () => {
+      expect(smartWalletAddress).toHaveLength(42);
+    });
+
+    it("should revert on unsuccessful transactions", async () => {
+      const tx = sendAndConfirmTransaction({
+        transaction: setContractURI({
+          contract,
+          uri: "https://example.com",
+        }),
+        account: smartAccount,
+      });
+
+      await expect(tx).rejects.toMatchInlineSnapshot(`
+        [TransactionError: Error - Not authorized
+
+        contract: ${contract.address}
+        chainId: 11155111]
+      `);
+    });
+
+    it("can execute a tx", async () => {
+      const tx = await sendAndConfirmTransaction({
+        transaction: claimTo({
+          contract,
+          quantity: 1n,
+          to: smartWalletAddress,
+          tokenId: 0n,
+        }),
+        account: smartAccount,
+      });
+      expect(tx.transactionHash).toHaveLength(66);
+      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 () => {
+      const estimates = await estimateGasCost({
+        transaction: claimTo({
+          contract,
+          quantity: 1n,
+          to: smartWalletAddress,
+          tokenId: 0n,
+        }),
+        account: smartAccount,
+      });
+      expect(estimates.wei.toString()).not.toBe("0");
+    });
+
+    it("can execute a batched tx", async () => {
+      const tx = await sendBatchTransaction({
+        account: smartAccount,
+        transactions: [
+          claimTo({
+            contract,
+            quantity: 1n,
+            to: smartWalletAddress,
+            tokenId: 0n,
+          }),
+          claimTo({
+            contract,
+            quantity: 1n,
+            to: smartWalletAddress,
+            tokenId: 0n,
+          }),
+        ],
+      });
+      expect(tx.transactionHash).toHaveLength(66);
+      await waitForReceipt({
+        client,
+        transactionHash: tx.transactionHash,
+        chain,
+      });
+      const balance = await balanceOf({
+        contract,
+        owner: getAddress(smartWalletAddress),
+        tokenId: 0n,
+      });
+      expect(balance).toEqual(3n);
+    });
+
+    it("can sign and verify 1271 with replay protection", async () => {
+      const message = "hello world";
+      const signature = await smartAccount.signMessage({ message });
+      const isValidV1 = await verifySignature({
+        message,
+        signature,
+        address: smartWalletAddress,
+        chain,
+        client,
+      });
+      expect(isValidV1).toEqual(true);
+      const isValidV2 = await checkContractWalletSignature({
+        message,
+        signature,
+        contract: accountContract,
+      });
+      expect(isValidV2).toEqual(true);
+
+      // sign typed data
+      const signatureTyped = await smartAccount.signTypedData({
+        ...typedData.basic,
+        primaryType: "Mail",
+      });
+      expect(signatureTyped.length).toBe(132);
+
+      // add admin
+      const newAdmin = await generateAccount({ client });
+      const receipt = await sendAndConfirmTransaction({
+        account: smartAccount,
+        transaction: addAdmin({
+          account: smartAccount,
+          adminAddress: newAdmin.address,
+          contract: getContract({
+            address: smartAccount.address,
+            chain,
+            client,
+          }),
+        }),
+      });
+      const logs = parseEventLogs({
+        events: [adminUpdatedEvent()],
+        logs: receipt.logs,
+      });
+      expect(logs.some((l) => l.args.signer === newAdmin.address)).toBe(true);
+      expect(logs.some((l) => l.args.isAdmin)).toBe(true);
+    });
+  },
+);