Add Sequence to benchmarks

package.json

@@ -9,6 +9,8 @@
     "prepare": "husky"
   },
   "devDependencies": {
+    "@0xsequence/account": "^1.9.13",
+    "@0xsequence/core": "^1.9.13",
     "@account-abstraction/sdk": "^0.6.0",
     "@eth-optimism/core-utils": "^0.13.2",
     "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
@@ -24,6 +26,7 @@
     "commander": "^12.0.0",
     "dotenv": "^16.4.4",
     "ethereum-cryptography": "^2.1.3",
+    "ethers": "^5.7.2",
     "hardhat": "^2.19.5",
     "hardhat-gas-reporter": "^1.0.8",
     "husky": "^9.0.11",

test/accounts.ts

@@ -15,6 +15,7 @@ import {lightAccount} from "./accounts/lightAccount";
 import {lightAccountV2} from "./accounts/lightAccountV2";
 import {modularAccount} from "./accounts/modularAccount";
 import {safe} from "./accounts/safe";
+import {sequence} from "./accounts/sequence";
 import {simpleAccount} from "./accounts/simpleAccount";
 import {TOKEN_ARTIFACTS} from "./artifacts/tokens";
 import {EntryPointV06, EntryPointV07} from "./utils/entryPoint";
@@ -28,7 +29,7 @@ export interface AccountData<
     ? UserOperation
     : PackedUserOperation,
 > {
-  entryPoint: TEntryPoint;
+  entryPoint: TEntryPoint | null;
   createAccount: (salt: bigint, ownerAddress: Address) => Promise<Address>;
   getAccountAddress: (salt: bigint, ownerAddress: Address) => Promise<Address>;
   getOwnerSignature: (
@@ -41,8 +42,8 @@ export interface AccountData<
     to: Address,
     value: bigint,
     data: Hex,
-    owner?: WalletClient<Transport, Chain, Account>,
-    accountAddress?: Address,
+    owner: WalletClient<Transport, Chain, Account>,
+    accountAddress: Address,
   ) => Promise<Hex>;
   getDummySignature: (userOp: TUserOperation) => Hex;
   getInitCode: (salt: bigint, ownerAddress: Address) => Hex;
@@ -97,6 +98,7 @@ export const ACCOUNTS_TO_BENCHMARK: AccountConfig[] = [
   biconomy_v2,
   kernel,
   safe,
+  sequence,
   simpleAccount,
   lightAccount,
   lightAccountV2,

test/accounts/sequence.ts

@@ -0,0 +1,197 @@
+import {commons, v2} from "@0xsequence/core";
+import {Orchestrator, signers} from "@0xsequence/signhub";
+import {Wallet} from "@0xsequence/wallet";
+import {ethers} from "ethers";
+import hre from "hardhat";
+import {
+  Account,
+  Chain,
+  Transport,
+  WalletClient,
+  encodeFunctionData,
+  encodePacked,
+  getAbiItem,
+  getContract,
+} from "viem";
+import {AccountConfig, AccountDataV07} from "../accounts";
+import {SEQUENCE_ARTIFACTS} from "../artifacts/sequence";
+
+export class ViemSignerWrapper implements signers.SapientSigner {
+  constructor(
+    public signer: WalletClient,
+    public eoa: boolean = true,
+  ) {}
+
+  getAddress(): Promise<string> {
+    return this.signer.account.address;
+  }
+
+  async buildDeployTransaction(
+    _metadata: object,
+  ): Promise<commons.transaction.TransactionBundle | undefined> {
+    // Wrapped signers don't require deployment
+    return;
+  }
+
+  async predecorateSignedTransactions(
+    _metadata: object,
+  ): Promise<commons.transaction.SignedTransactionBundle[]> {
+    return [];
+  }
+
+  async decorateTransactions(
+    bundle: commons.transaction.IntendedTransactionBundle,
+    _metadata: object,
+  ): Promise<commons.transaction.IntendedTransactionBundle> {
+    return bundle;
+  }
+
+  async sign(message: ethers.BytesLike): Promise<ethers.BytesLike> {
+    return this.signer.signMessage({
+      message: {raw: ethers.utils.hexlify(message)},
+    });
+  }
+
+  notifyStatusChange(): void {}
+
+  suffix() {
+    return [2];
+  }
+}
+
+async function accountFixture(): Promise<AccountDataV07> {
+  const [walletClient] = await hre.viem.getWalletClients();
+  const publicClient = await hre.viem.getPublicClient();
+
+  for (const {address, bytecode} of Object.values(SEQUENCE_ARTIFACTS)) {
+    await hre.network.provider.send("hardhat_setCode", [address, bytecode]);
+  }
+
+  const sequenceMainModule = getContract({
+    address: SEQUENCE_ARTIFACTS.SequenceMainModule.address,
+    abi: SEQUENCE_ARTIFACTS.SequenceMainModule.abi,
+    publicClient,
+    walletClient,
+  });
+
+  const sequenceFactory = getContract({
+    address: SEQUENCE_ARTIFACTS.SequenceFactory.address,
+    abi: SEQUENCE_ARTIFACTS.SequenceFactory.abi,
+    publicClient,
+    walletClient,
+  });
+
+  const v2Context = {
+    version: 2,
+
+    factory: SEQUENCE_ARTIFACTS.SequenceFactory.address,
+    mainModule: SEQUENCE_ARTIFACTS.SequenceMainModule.address,
+    mainModuleUpgradable:
+      SEQUENCE_ARTIFACTS.SequenceMainModuleUpgradeable.address,
+    guestModule: SEQUENCE_ARTIFACTS.SequenceGuestModule.address,
+
+    walletCreationCode:
+      "0x603a600e3d39601a805130553df3363d3d373d3d3d363d30545af43d82803e903d91601857fd5bf3",
+  };
+
+  const getSingleSignerConfig = (salt: bigint, ownerAddress: string) => {
+    salt += 100n; // Don't allow 0 salt
+    return v2.config.ConfigCoder.fromSimple({
+      threshold: 1,
+      checkpoint: 0,
+      signers: [{weight: salt, address: ownerAddress}],
+    });
+  };
+
+  return {
+    entryPoint: null, // Not supported
+    createAccount: async (salt, ownerAddress) => {
+      const config = getSingleSignerConfig(salt, ownerAddress);
+      const imageHash = v2.coders.config.imageHashOf(config);
+      return await sequenceFactory.write.deploy([
+        v2Context.mainModule,
+        imageHash,
+      ]);
+    },
+    getAccountAddress: async (salt, ownerAddress) => {
+      const config = getSingleSignerConfig(salt, ownerAddress);
+      const imageHash = v2.coders.config.imageHashOf(config);
+      return commons.context.addressOf(v2Context, imageHash);
+    },
+    encodeRuntimeExecute: async (
+      to,
+      value,
+      data,
+      owner: WalletClient<Transport, Chain, Account>,
+      accountAddress,
+    ) => {
+      if (!owner || !accountAddress) {
+        throw new Error("`owner` and `accountAddress` are required.");
+      }
+
+      const account = getContract({
+        address: accountAddress,
+        abi: SEQUENCE_ARTIFACTS.SequenceMainModule.abi,
+        publicClient,
+        walletClient: owner,
+      });
+      const code = await publicClient.getBytecode({
+        address: accountAddress,
+      });
+
+      const nonce = await account.read.nonce();
+      const config = getSingleSignerConfig(0n, owner.account.address);
+
+      const wallet = new Wallet({
+        coders: {
+          signature: v2.signature.SignatureCoder,
+          config: v2.config.ConfigCoder,
+        },
+        context: v2Context,
+        config,
+        chainId: 31337,
+        address: accountAddress,
+        orchestrator: new Orchestrator([new ViemSignerWrapper(owner)]),
+      });
+      const signedBundle = await wallet.signTransactions(
+        [
+          {
+            to,
+            value,
+            data,
+            revertOnError: true,
+          },
+        ],
+        nonce,
+      );
+      return commons.transaction.encodeBundleExecData(signedBundle);
+    },
+    getDummySignature: (_userOp) => {
+      return "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
+    },
+    getInitCode: (salt, ownerAddress) => {
+      const config = getSingleSignerConfig(salt, ownerAddress);
+      const imageHash = v2.coders.config.imageHashOf(config);
+      return encodePacked(
+        ["address", "bytes"],
+        [
+          sequenceFactory.address,
+          encodeFunctionData({
+            abi: [
+              getAbiItem({
+                abi: sequenceFactory.abi,
+                name: "deploy",
+              }),
+            ],
+            args: [sequenceMainModule.address, imageHash],
+          }),
+        ],
+      );
+    },
+  };
+}
+
+export const sequence: AccountConfig = {
+  name: "Sequence",
+  accountFixture,
+};