eco-solver 0.0.1-security → 1.5.0

package/src/sign/kms-account/kmsToAccount.ts

@@ -0,0 +1,73 @@
+import { signKms } from '@/sign/kms-account/signKms'
+import { signKmsTransaction } from '@/sign/kms-account/signKmsTransaction'
+import { signKmsTypedData } from '@/sign/kms-account/signKmsTypedData'
+import { Signer } from '@web3-kms-signer/core'
+import { KMSWallets } from '@web3-kms-signer/kms-wallets'
+import {
+  CustomSource,
+  getAddress,
+  hashMessage,
+  LocalAccount,
+  NonceManager,
+  Prettify,
+  toHex,
+} from 'viem'
+import { toAccount } from 'viem/accounts'
+
+export type KmsToAccountOptions = {
+  nonceManager?: NonceManager | undefined
+  keyID: string
+}
+
+/**
+ * @description Creates an Account from a KMS signer.
+ *
+ * @returns A Private Key Account.
+ */
+export async function kmsToAccount(
+  signer: Signer,
+  wallets: KMSWallets,
+  options: KmsToAccountOptions,
+): Promise<KmsAccount> {
+  const { nonceManager, keyID } = options
+  const publicKey = toHex(await wallets.getPublickey(keyID))
+  const addressHex = getAddress(await wallets.getAddressHex(keyID))
+  const addressBuffer = await wallets.getAddress(keyID)
+
+  const account = toAccount({
+    address: addressHex,
+    nonceManager,
+    async sign({ hash }) {
+      return await signKms({ hash, signer, keyID, addressBuffer, to: 'hex' })
+    },
+    async signMessage({ message }) {
+      return await signKms({ hash: hashMessage(message), signer, keyID, addressBuffer, to: 'hex' })
+    },
+    async signTransaction(transaction, { serializer } = {}) {
+      return await signKmsTransaction({
+        transaction,
+        serializer,
+        config: { signer, keyID, addressBuffer },
+      })
+    },
+    async signTypedData(typedData) {
+      return await signKmsTypedData({
+        ...typedData,
+        config: { signer, keyID, addressBuffer },
+      } as any)
+    },
+  })
+
+  return {
+    ...account,
+    publicKey,
+    source: 'kms',
+  } as KmsAccount
+}
+
+export type KmsAccount = Prettify<
+  LocalAccount<'kms'> & {
+    // TODO(v3): This will be redundant.
+    sign: NonNullable<CustomSource['sign']>
+  }
+>

package/src/sign/kms-account/signKms.ts

@@ -0,0 +1,30 @@
+import { Signer } from '@web3-kms-signer/core'
+import { Hex, parseSignature } from 'viem'
+import { SignReturnType } from 'viem/accounts'
+
+export type To = 'object' | 'bytes' | 'hex'
+
+export type KmsSignParameters<to extends To = 'object'> = {
+  hash: Hex
+  signer: Signer
+  keyID: string
+  addressBuffer: Buffer
+  to?: to | To | undefined
+}
+/**
+ * @description Signs a hash using a KMS signer.
+ *
+ * @returns A signature.
+ */
+export async function signKms<to extends To = 'object'>(
+  config: KmsSignParameters<to>,
+): Promise<SignReturnType<to>> {
+  const { hash, signer, keyID, addressBuffer, to = 'object' } = config
+  const hexSig = (await signer.signDigest({ keyId: keyID, address: addressBuffer }, hash)) as Hex
+  return (() => {
+    if (to === 'bytes' || to === 'hex') {
+      return hexSig
+    }
+    return parseSignature(hexSig)
+  })() as SignReturnType<to>
+}

package/src/sign/kms-account/signKmsTransaction.ts

@@ -0,0 +1,37 @@
+import { signKms, KmsSignParameters } from '@/sign/kms-account/signKms'
+import {
+  keccak256,
+  serializeTransaction,
+  SerializeTransactionFn,
+  TransactionSerializable,
+} from 'viem'
+import { SignTransactionParameters, SignTransactionReturnType } from 'viem/accounts'
+
+export async function signKmsTransaction<
+  serializer extends
+    SerializeTransactionFn<TransactionSerializable> = SerializeTransactionFn<TransactionSerializable>,
+  transaction extends Parameters<serializer>[0] = Parameters<serializer>[0],
+>(
+  parameters: Omit<SignTransactionParameters<serializer, transaction>, 'privateKey'> & {
+    config: Omit<KmsSignParameters, 'hash'>
+  },
+): Promise<SignTransactionReturnType<serializer, transaction>> {
+  const { transaction, serializer = serializeTransaction, config } = parameters
+
+  const signableTransaction = (() => {
+    // For EIP-4844 Transactions, we want to sign the transaction payload body (tx_payload_body) without the sidecars (ie. without the network wrapper).
+    // See: https://github.com/ethereum/EIPs/blob/e00f4daa66bd56e2dbd5f1d36d09fd613811a48b/EIPS/eip-4844.md#networking
+    if (transaction.type === 'eip4844')
+      return {
+        ...transaction,
+        sidecars: false,
+      }
+    return transaction
+  })()
+  const signature = await signKms({
+    ...config,
+    hash: keccak256(serializer(signableTransaction)),
+    to: 'object',
+  })
+  return serializer(transaction, signature) as SignTransactionReturnType<serializer, transaction>
+}

package/src/sign/kms-account/signKmsTypedData.ts

@@ -0,0 +1,21 @@
+import { KmsSignParameters, signKms } from '@/sign/kms-account/signKms'
+import { hashTypedData, SignTypedDataReturnType, TypedData } from 'viem'
+import { SignTypedDataParameters } from 'viem/accounts'
+
+export async function signKmsTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(
+  parameters: Omit<SignTypedDataParameters<typedData, primaryType>, 'privateKey'> & {
+    config: Omit<KmsSignParameters, 'hash'>
+  },
+): Promise<SignTypedDataReturnType> {
+  const { config, ...typedData } = parameters as unknown as SignTypedDataParameters & {
+    config: Omit<KmsSignParameters, 'hash'>
+  }
+  return await signKms({
+    hash: hashTypedData(typedData),
+    ...config,
+    to: 'hex',
+  })
+}

package/src/sign/nonce.service.ts

@@ -0,0 +1,89 @@
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common'
+import { InjectModel } from '@nestjs/mongoose'
+import { Model } from 'mongoose'
+import { Nonce } from './schemas/nonce.schema'
+import { JobsOptions, Queue } from 'bullmq'
+import { QUEUES } from '../common/redis/constants'
+import { InjectQueue } from '@nestjs/bullmq'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { entries } from 'lodash'
+import { AtomicKeyClientParams, AtomicNonceService } from './atomic.nonce.service'
+import { createPublicClient, extractChain, Hex, sha256 } from 'viem'
+import { SignerService } from './signer.service'
+import { getTransport } from '../common/chains/transport'
+import { ChainsSupported } from '../common/chains/supported'
+
+/**
+ * TODO this class needs to be assigned to an EAO, a userOp gets its nonce throught the alchemy sdk
+ * which pulls its fromt the rpc bundler
+ */
+@Injectable()
+export class NonceService extends AtomicNonceService<Nonce> implements OnApplicationBootstrap {
+  protected logger = new Logger(NonceService.name)
+  private intentJobConfig: JobsOptions
+
+  constructor(
+    @InjectModel(Nonce.name) private nonceModel: Model<Nonce>,
+    @InjectQueue(QUEUES.SIGNER.queue) private readonly signerQueue: Queue,
+    private readonly signerService: SignerService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {
+    super(nonceModel)
+  }
+  async onApplicationBootstrap() {
+    this.intentJobConfig = this.ecoConfigService.getRedis().jobs.intentJobConfig
+    this.syncQueue()
+  }
+
+  async syncQueue() {
+    const { should, hash } = await this.shouldSync()
+    if (should) {
+      await this.signerQueue.add(
+        QUEUES.SIGNER.jobs.nonce_sync,
+        {},
+        {
+          jobId: hash,
+          ...this.intentJobConfig,
+        },
+      )
+    }
+  }
+
+  protected override async getSyncParams(): Promise<AtomicKeyClientParams[]> {
+    const address = this.signerService.getAccount().address
+    const apiKey = this.ecoConfigService.getAlchemy().apiKey
+    const paramsAsync = entries(this.ecoConfigService.getSolvers()).map(async ([chainIdString]) => {
+      const chainID = parseInt(chainIdString)
+      const chain = extractChain({
+        chains: ChainsSupported,
+        id: chainID,
+      })
+      const client = createPublicClient({
+        chain,
+        transport: getTransport(chain, apiKey),
+      } as any)
+      return { address, client } as AtomicKeyClientParams
+    })
+
+    return await Promise.all(paramsAsync)
+  }
+
+  async getLastSynceAt(): Promise<Date> {
+    const meta = await this.nonceModel
+      .findOne({ updatedAt: { $exists: true } })
+      .sort({ updatedAt: -1 })
+      .exec()
+    if (!meta) {
+      return new Date(0)
+    }
+    return meta.updatedAt
+  }
+
+  async shouldSync(): Promise<{ should: boolean; hash: string }> {
+    const lastSyncAt = await this.getLastSynceAt()
+    const should =
+      Date.now() - lastSyncAt.getTime() > this.ecoConfigService.getEth().nonce.update_interval_ms
+    const input = `0x${lastSyncAt.toISOString()}` as Hex
+    return { should, hash: sha256(input) }
+  }
+}

package/src/sign/schemas/nonce.schema.ts

@@ -0,0 +1,36 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
+import { now } from 'mongoose'
+import { AtomicKeyParams } from '../atomic.nonce.service'
+import { Hex } from 'viem'
+import { getAtomicNonceVals } from '../sign.helper'
+
+@Schema({ timestamps: true })
+export class Nonce {
+  @Prop({ required: true, unique: true })
+  key: string
+
+  @Prop({ required: true, default: 0 })
+  nonce: number
+
+  @Prop({ required: true })
+  chainID: number
+
+  @Prop({ required: true })
+  address: Hex
+
+  @Prop({ required: true, default: now() })
+  createdAt: Date
+
+  @Prop({ required: true, default: now() })
+  updatedAt: Date
+
+  toString(): string {
+    return `${this.key}:${this.nonce}`
+  }
+
+  getAtomicNonceVals(): AtomicKeyParams {
+    return getAtomicNonceVals(this.key)
+  }
+}
+
+export const NonceSchema = SchemaFactory.createForClass(Nonce)

package/src/sign/sign.controller.ts

@@ -0,0 +1,52 @@
+import { Controller, Get } from '@nestjs/common'
+import { Logger } from '@nestjs/common'
+import { SignerService } from './signer.service'
+
+@Controller('sign')
+export class SignController {
+  private logger = new Logger(SignController.name)
+  constructor(
+    // private readonly aa: MultichainSmartAccountService,
+    private readonly signer: SignerService,
+  ) {}
+  @Get()
+  async fake() {
+    await this.fakeSign()
+
+    return
+  }
+
+  async fakeSign() {
+    // const smartAccountClient = await this.aa.getClient(84532)
+    // let ans = await smartAccountClient.account.getImplementationAddress()
+    // console.log(ans, smartAccountClient.account.address)
+    // await smartAccountClient.signUserOperation({
+    //   // @ts-ignore
+    //   uoStruct: this.getUo().flat(),
+    //   account: this.atomicSigner.getSigner() as any,
+    // })
+    // // @ts-ignore
+    // const uo = await smartAccountClient.sendUserOperation({
+    //   uo: this.getUo().flat(),
+    // })
+    // const receipt = await smartAccountClient.waitForUserOperationTransaction(uo)
+    // console.log(receipt)
+    // ans = await smartAccountClient.account.getNonce()
+    // console.log(ans, smartAccountClient.account.address)
+  }
+
+  // getUo(){
+  //   const transferSolverAmount = encodeFunctionData({
+  //     abi: erc20Abi,
+  //     functionName: 'transfer',
+  //     args: ['0x3A322Ff8ef24592e5e50D2EB4E630cDA87Bd83A6' as Hex, BigInt(10)],
+  //   })
+
+  //   return [
+  //     {
+  //       target: '0xd3F4Bef596a04e2be4fbeB17Dd70f02F717c5a6c' as Hex,
+  //       data: transferSolverAmount,
+  //     },
+  //   ]
+  // }
+}

package/src/sign/sign.helper.ts

@@ -0,0 +1,23 @@
+import { Hex, NonceManagerSource, PrivateKeyAccount } from 'viem'
+import { privateKeyToAccount } from 'viem/accounts'
+import { createNonceManager } from 'viem/nonce'
+import { AtomicKeyParams } from './atomic.nonce.service'
+
+export function privateKeyAndNonceToAccountSigner(
+  atomicNonceSource: NonceManagerSource,
+  privateKey: Hex,
+): PrivateKeyAccount {
+  const nonceManager = createNonceManager({
+    source: atomicNonceSource,
+  })
+  return privateKeyToAccount(privateKey, { nonceManager })
+}
+
+export function getAtomicNonceKey(params: AtomicKeyParams) {
+  return `${params.address}.${params.chainId}`
+}
+
+export function getAtomicNonceVals(key: string): AtomicKeyParams {
+  const [address, chainId] = key.split('.')
+  return { address: address as Hex, chainId: parseInt(chainId) }
+}

package/src/sign/sign.module.ts

@@ -0,0 +1,27 @@
+import { Module } from '@nestjs/common'
+import { MongooseModule } from '@nestjs/mongoose'
+import { Nonce, NonceSchema } from './schemas/nonce.schema'
+import { initBullMQ } from '../bullmq/bullmq.helper'
+import { QUEUES } from '../common/redis/constants'
+import { SignerService } from './signer.service'
+import { AtomicSignerService } from './atomic-signer.service'
+import { NonceService } from './nonce.service'
+import { SignerKmsService } from '@/sign/signer-kms.service'
+import { KmsModule } from '@/kms/kms.module'
+
+@Module({
+  imports: [
+    KmsModule,
+    MongooseModule.forFeature([{ name: Nonce.name, schema: NonceSchema }]),
+    initBullMQ(QUEUES.SIGNER),
+  ],
+  providers: [SignerService, SignerKmsService, NonceService, AtomicSignerService],
+  exports: [
+    AtomicSignerService,
+    SignerService,
+    SignerKmsService,
+    NonceService,
+    MongooseModule, //add SignModule to the rest of the modules that import intents
+  ],
+})
+export class SignModule {}

package/src/sign/signer-kms.service.ts

@@ -0,0 +1,27 @@
+import { KmsService } from '@/kms/kms.service'
+import { KmsAccount, kmsToAccount } from '@/sign/kms-account/kmsToAccount'
+import { Injectable, OnModuleInit } from '@nestjs/common'
+
+/**
+ * A signer service that creates a {@link KmsAccount} from a KMS signer.
+ * Uses the {@link KmsService} to get the KMS signer from aws.
+ */
+@Injectable()
+export class SignerKmsService implements OnModuleInit {
+  private account: KmsAccount
+  constructor(readonly kmsService: KmsService) {}
+
+  async onModuleInit() {
+    this.account = await this.buildAccount()
+  }
+
+  getAccount() {
+    return this.account
+  }
+
+  protected async buildAccount(): Promise<KmsAccount> {
+    return await kmsToAccount(this.kmsService.signer, this.kmsService.wallets, {
+      keyID: this.kmsService.getKmsKeyId(),
+    })
+  }
+}

package/src/sign/signer.service.ts

@@ -0,0 +1,26 @@
+import { Injectable, OnModuleInit } from '@nestjs/common'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { Hex, PrivateKeyAccount } from 'viem'
+import { privateKeyToAccount } from 'viem/accounts'
+
+@Injectable()
+export class SignerService implements OnModuleInit {
+  private account: PrivateKeyAccount
+  constructor(readonly ecoConfigService: EcoConfigService) {}
+
+  async onModuleInit() {
+    this.account = this.buildAccount()
+  }
+
+  getAccount() {
+    return this.account
+  }
+
+  protected buildAccount(): PrivateKeyAccount {
+    return privateKeyToAccount(this.getPrivateKey())
+  }
+
+  protected getPrivateKey(): Hex {
+    return this.ecoConfigService.getEth().simpleAccount.signerPrivateKey
+  }
+}

package/src/solver/filters/tests/valid-smart-wallet.service.spec.ts

@@ -0,0 +1,87 @@
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import { ValidSmartWalletService } from '../valid-smart-wallet.service'
+import { MultichainPublicClientService } from '../../../transaction/multichain-public-client.service'
+import { EcoConfigService } from '../../../eco-configs/eco-config.service'
+import { Test, TestingModule } from '@nestjs/testing'
+
+describe('ValidSmartWalletService Tests', () => {
+  let validWalletService: ValidSmartWalletService
+  let publicClientService: DeepMocked<MultichainPublicClientService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+
+  beforeEach(async () => {
+    const validMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        ValidSmartWalletService,
+        {
+          provide: MultichainPublicClientService,
+          useValue: createMock<MultichainPublicClientService>(),
+        },
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+      ],
+    }).compile()
+
+    validWalletService = validMod.get(ValidSmartWalletService)
+    publicClientService = validMod.get(MultichainPublicClientService)
+    ecoConfigService = validMod.get(EcoConfigService)
+  })
+
+  afterEach(async () => {
+    // restore the spy created with spyOn
+    jest.restoreAllMocks()
+  })
+  const entryPoint = '0x123'
+  const factory = '0x456'
+
+  describe('on startup', () => {
+    it('should initialize the entry point and factory addresses', async () => {
+      const contracts = {
+        entryPoint: { contractAddress: entryPoint },
+        simpleAccountFactory: { contractAddress: factory },
+      }
+      ecoConfigService.getEth = jest.fn().mockReturnValue({ simpleAccount: { contracts } })
+
+      validWalletService.onModuleInit()
+
+      expect(validWalletService['entryPointAddress']).toEqual(entryPoint)
+      expect(validWalletService['factoryAddress']).toEqual(factory)
+    })
+  })
+
+  describe('on validate smart wallet', () => {
+    beforeEach(() => {
+      validWalletService['entryPointAddress'] = entryPoint
+      validWalletService['factoryAddress'] = factory
+    })
+
+    it('should return false if there are no deploy events for a SA address', async () => {
+      publicClientService.getClient = jest.fn().mockImplementation(async (chainID) => {
+        return {
+          getContractEvents: jest.fn().mockReturnValue([]),
+        }
+      })
+      const result = await validWalletService.validateSmartWallet('0x789', 1n)
+      expect(result).toEqual(false)
+    })
+
+    it('should return false if the SA address is from another factory', async () => {
+      publicClientService.getClient = jest.fn().mockImplementation(async (chainID) => {
+        return {
+          getContractEvents: jest.fn().mockReturnValue([{ args: { factory: '0xabc' } }]),
+        }
+      })
+      const result = await validWalletService.validateSmartWallet('0x789', 1n)
+      expect(result).toEqual(false)
+    })
+
+    it('should return true if the SA is from our factory', async () => {
+      publicClientService.getClient = jest.fn().mockImplementation(async (chainID) => {
+        return {
+          getContractEvents: jest.fn().mockReturnValue([{ args: { factory: factory } }]),
+        }
+      })
+      const result = await validWalletService.validateSmartWallet('0x789', 1n)
+      expect(result).toEqual(true)
+    })
+  })
+})

package/src/solver/filters/valid-smart-wallet.service.ts

@@ -0,0 +1,58 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common'
+import { MultichainPublicClientService } from '../../transaction/multichain-public-client.service'
+import { EcoConfigService } from '../../eco-configs/eco-config.service'
+import { Hex } from 'viem'
+import { EntryPointAbi_v6 } from '../../contracts/EntryPoint.V6.contract'
+import { EcoLogMessage } from '../../common/logging/eco-log-message'
+
+@Injectable()
+export class ValidSmartWalletService implements OnModuleInit {
+  private logger = new Logger(ValidSmartWalletService.name)
+
+  private entryPointAddress: Hex
+  private factoryAddress: Hex
+  constructor(
+    private readonly publicClient: MultichainPublicClientService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  onModuleInit() {
+    const contracts = this.ecoConfigService.getEth().simpleAccount.contracts
+    this.entryPointAddress = contracts.entryPoint.contractAddress
+    this.factoryAddress = contracts.simpleAccountFactory.contractAddress
+  }
+  /**
+   * Validates that the smart wallet account that posts and creates an IntentCreated event on chain
+   * for the IntentSource contract, is from the correct smart wallet factory.
+   *
+   * @param smartWalletAddress the address of the smart wallet to validate
+   * @param chainID the chain id of the transaction the event is from
+   */
+  async validateSmartWallet(smartWalletAddress: Hex, chainID: bigint): Promise<boolean> {
+    const client = await this.publicClient.getClient(Number(chainID))
+    try {
+      const deployedEvents = await client.getContractEvents({
+        address: this.entryPointAddress,
+        abi: EntryPointAbi_v6,
+        eventName: 'AccountDeployed',
+        args: { sender: smartWalletAddress },
+        fromBlock: 0n,
+        toBlock: 'latest',
+      })
+      //should be only one event, but comes as an array
+      return (
+        deployedEvents && deployedEvents.some((event) => event.args.factory === this.factoryAddress)
+      )
+    } catch (error) {
+      this.logger.error(
+        EcoLogMessage.fromDefault({
+          message: `RPC: getContractEvents error`,
+          properties: {
+            error,
+          },
+        }),
+      )
+      return false
+    }
+  }
+}

package/src/solver/solver.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common'
+import { ValidSmartWalletService } from './filters/valid-smart-wallet.service'
+import { TransactionModule } from '../transaction/transaction.module'
+
+@Module({
+  imports: [TransactionModule],
+  providers: [ValidSmartWalletService],
+  exports: [ValidSmartWalletService],
+})
+export class SolverModule {}

package/src/transaction/multichain-public-client.service.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@nestjs/common'
+import { createPublicClient, PublicClient, PublicClientConfig } from 'viem'
+import { ViemMultichainClientService } from './viem_multichain_client.service'
+
+@Injectable()
+export class MultichainPublicClientService extends ViemMultichainClientService<
+  PublicClient,
+  PublicClientConfig
+> {
+  protected override async createInstanceClient(
+    configs: PublicClientConfig,
+  ): Promise<PublicClient> {
+    return createPublicClient(configs)
+  }
+}

package/src/transaction/smart-wallets/kernel/actions/encodeData.kernel.ts

@@ -0,0 +1,57 @@
+import { encode7579Calls } from 'permissionless'
+import { KernelVersion } from 'permissionless/accounts'
+import { type Address, type Hex, encodeFunctionData } from 'viem'
+import { isKernelV2 } from '../kernel-account.config'
+import { KernelExecuteAbi } from '../../../../contracts'
+
+export const encodeKernelExecuteCallData = ({
+  kernelVersion,
+  calls,
+}: {
+  calls: readonly {
+    to: Address
+    value?: bigint | undefined
+    data?: Hex | undefined
+  }[]
+  kernelVersion: KernelVersion<'0.6' | '0.7'>
+}) => {
+  if (isKernelV2(kernelVersion)) {
+    if (calls.length > 1) {
+      // Encode a batched call
+      return encodeFunctionData({
+        abi: KernelExecuteAbi,
+        functionName: 'executeBatch',
+        args: [
+          calls.map((tx) => ({
+            to: tx.to,
+            value: tx.value ?? 0n,
+            data: tx.data ?? '0x',
+          })),
+        ],
+      })
+    }
+
+    const call = calls.length === 0 ? undefined : calls[0]
+
+    if (!call) {
+      throw new Error('No calls to encode')
+    }
+
+    // Encode a simple call
+    return encodeFunctionData({
+      abi: KernelExecuteAbi,
+      functionName: 'execute',
+      args: [call.to, call.value ?? 0n, call.data ?? '0x', 0],
+    })
+  }
+
+  return encode7579Calls({
+    mode: {
+      type: calls.length > 1 ? 'batchcall' : 'call',
+      revertOnError: false,
+      selector: '0x',
+      context: '0x',
+    },
+    callData: calls,
+  })
+}