chore: knip

Author: jxom

src/experimental/erc7821/actions/executeBatches.ts

@@ -41,7 +41,8 @@ import {
 import { encodeCalls } from './execute.js'
 import { supportsExecutionMode } from './supportsExecutionMode.js'
 
-type Batch = { calls: readonly unknown[]; opData?: Hex | undefined }
+/** @internal */
+export type Batch = { calls: readonly unknown[]; opData?: Hex | undefined }
 
 export type ExecuteBatchesParameters<
   batches extends readonly Batch[] = readonly Batch[],

src/experimental/erc7821/decorators/erc7821.test.ts

@@ -5,6 +5,7 @@ import { anvilMainnet } from '../../../../test/src/anvil.js'
 import { accounts } from '../../../../test/src/constants.js'
 import { deploy } from '../../../../test/src/utils.js'
 import { privateKeyToAccount } from '../../../accounts/privateKeyToAccount.js'
+import { mine } from '../../../actions/index.js'
 import { signAuthorization } from '../../eip7702/actions/signAuthorization.js'
 import { erc7821Actions } from './erc7821.js'
 
@@ -16,13 +17,15 @@ test('default', async () => {
   expect(erc7821Actions()(client)).toMatchInlineSnapshot(`
     {
       "execute": [Function],
+      "executeBatches": [Function],
       "supportsExecutionMode": [Function],
     }
   `)
 })
 
 describe('smoke test', () => {
   test('execute', async () => {
+    await mine(client, { blocks: 1 })
     const { contractAddress } = await deploy(client, {
       abi: ERC7821Example.abi,
       bytecode: ERC7821Example.bytecode.object,
@@ -44,11 +47,38 @@ describe('smoke test', () => {
     })
   })
 
+  test('executeBatches', async () => {
+    await mine(client, { blocks: 1 })
+    const { contractAddress } = await deploy(client, {
+      abi: ERC7821Example.abi,
+      bytecode: ERC7821Example.bytecode.object,
+    })
+
+    const authorization = await signAuthorization(client, {
+      contractAddress: contractAddress!,
+    })
+    await client.executeBatches({
+      authorizationList: [authorization],
+      address: client.account.address,
+      batches: [
+        {
+          calls: [
+            {
+              to: '0x0000000000000000000000000000000000000000',
+              data: '0x',
+              value: 0n,
+            },
+          ],
+        },
+      ],
+    })
+  })
+
   test('supportsExecutionMode', async () => {
     expect(
       await client.supportsExecutionMode({
         address: client.account.address,
       }),
-    ).toBe(false)
+    ).toBe(true)
   })
 })

src/experimental/erc7821/decorators/erc7821.ts

@@ -7,6 +7,12 @@ import {
   type ExecuteReturnType,
   execute,
 } from '../actions/execute.js'
+import {
+  type Batch,
+  type ExecuteBatchesParameters,
+  type ExecuteBatchesReturnType,
+  executeBatches,
+} from '../actions/executeBatches.js'
 import {
   type SupportsExecutionModeParameters,
   type SupportsExecutionModeReturnType,
@@ -91,6 +97,108 @@ export type Erc7821Actions<
   >(
     parameters: ExecuteParameters<calls, chain, account, chainOverride>,
   ) => Promise<ExecuteReturnType>
+  /**
+   * Executes batches of call(s) using "batch of batches" mode on an [ERC-7821-compatible contract](https://eips.ethereum.org/EIPS/eip-7821).
+   *
+   * @example
+   * ```ts
+   * import { createClient, http, parseEther } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   * import { erc7821Actions } from 'viem/experimental'
+   *
+   * const account = privateKeyToAccount('0x...')
+   *
+   * const client = createClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(erc7821Actions())
+   *
+   * const hash = await client.executeBatches({
+   *   account,
+   *   batches: [
+   *     {
+   *       calls: [
+   *         {
+   *           to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *           value: parseEther('1'),
+   *         },
+   *       ],
+   *     },
+   *     {
+   *       calls: [
+   *         {
+   *           to: '0xcb98643b8786950F0461f3B0edf99D88F274574D',
+   *           value: parseEther('2'),
+   *         },
+   *         {
+   *           data: '0xdeadbeef',
+   *           to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *         },
+   *       ],
+   *     },
+   *   ],
+   *   to: account.address,
+   * })
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Account Hoisting
+   * import { createClient, http, parseEther } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   * import { erc7821Actions } from 'viem/experimental'
+   *
+   * const account = privateKeyToAccount('0x...')
+   *
+   * const client = createClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(erc7821Actions())
+   *
+   * const hash = await client.executeBatches({
+   *   batches: [
+   *     {
+   *       calls: [
+   *         {
+   *           to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *           value: parseEther('1'),
+   *         },
+   *       ],
+   *     },
+   *     {
+   *       calls: [
+   *         {
+   *           to: '0xcb98643b8786950F0461f3B0edf99D88F274574D',
+   *           value: parseEther('2'),
+   *         },
+   *         {
+   *           data: '0xdeadbeef',
+   *           to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *         },
+   *       ],
+   *     },
+   *   ],
+   *   to: account.address,
+   * })
+   * ```
+   *
+   * @param client - Client to use.
+   * @param parameters - {@link ExecuteBatchesParameters}
+   * @returns Transaction hash. {@link ExecuteBatchesReturnType}
+   */
+  executeBatches: <
+    const batches extends readonly Batch[],
+    chainOverride extends Chain | undefined = undefined,
+  >(
+    parameters: ExecuteBatchesParameters<
+      batches,
+      chain,
+      account,
+      chainOverride
+    >,
+  ) => Promise<ExecuteBatchesReturnType>
   /**
    * Checks if the contract supports the ERC-7821 execution mode.
    *
@@ -142,6 +250,7 @@ export function erc7821Actions() {
   ): Erc7821Actions<chain, account> => {
     return {
       execute: (parameters) => execute(client, parameters),
+      executeBatches: (parameters) => executeBatches(client, parameters),
       supportsExecutionMode: (parameters) =>
         supportsExecutionMode(client, parameters),
     }

src/experimental/erc7821/index.ts

@@ -1,11 +1,16 @@
-/**  */
 // biome-ignore lint/performance/noBarrelFile: entrypoint
 export {
   type ExecuteErrorType,
   type ExecuteParameters,
   type ExecuteReturnType,
   execute,
 } from './actions/execute.js'
+export {
+  type ExecuteBatchesErrorType,
+  type ExecuteBatchesParameters,
+  type ExecuteBatchesReturnType,
+  executeBatches,
+} from './actions/executeBatches.js'
 export {
   type SupportsExecutionModeErrorType,
   type SupportsExecutionModeParameters,