viem 2.22.19 → 2.22.21

package/experimental/erc7821/actions/executeBatches.ts

@@ -1,6 +1,4 @@
-import type { Abi, Address, Narrow } from 'abitype'
-import * as AbiError from 'ox/AbiError'
-import * as AbiParameters from 'ox/AbiParameters'
+import type { Address, Narrow } from 'abitype'
 
 import {
   type SendTransactionErrorType,
@@ -11,7 +9,7 @@ import type { Transport } from '../../../clients/transports/createTransport.js'
 import type { BaseError } from '../../../errors/base.js'
 import type { ErrorType } from '../../../errors/utils.js'
 import type { Account, GetAccountParameter } from '../../../types/account.js'
-import type { Batches, Call } from '../../../types/calls.js'
+import type { Batches, Calls } from '../../../types/calls.js'
 import type {
   Chain,
   DeriveChain,
@@ -19,26 +17,17 @@ import type {
 } from '../../../types/chain.js'
 import type { Hex } from '../../../types/misc.js'
 import type { UnionEvaluate, UnionPick } from '../../../types/utils.js'
-import {
-  type DecodeErrorResultErrorType,
-  decodeErrorResult,
-} from '../../../utils/abi/decodeErrorResult.js'
-import {
-  type EncodeFunctionDataErrorType,
-  encodeFunctionData,
-} from '../../../utils/abi/encodeFunctionData.js'
-import {
-  type GetContractErrorReturnType,
-  getContractError,
-} from '../../../utils/errors/getContractError.js'
 import type { FormattedTransactionRequest } from '../../../utils/formatters/transactionRequest.js'
 import { withCache } from '../../../utils/promise/withCache.js'
-import { abi, executionMode } from '../constants.js'
+import { ExecuteUnsupportedError } from '../errors.js'
+import {
+  type EncodeExecuteBatchesDataErrorType,
+  encodeExecuteBatchesData,
+} from '../utils/encodeExecuteBatchesData.js'
 import {
-  ExecuteUnsupportedError,
-  FunctionSelectorNotRecognizedError,
-} from '../errors.js'
-import { encodeCalls } from './execute.js'
+  type GetExecuteErrorReturnType,
+  getExecuteError,
+} from '../utils/getExecuteError.js'
 import { supportsExecutionMode } from './supportsExecutionMode.js'
 
 /** @internal */
@@ -66,16 +55,13 @@ export type ExecuteBatchesParameters<
     address: Address
     /** Batches to execute. */
     batches: Batches<Narrow<batches>, { opData?: Hex | undefined }>
-    /** Additional data to include for execution. */
-    opData?: Hex | undefined
   }
 
 export type ExecuteBatchesReturnType = Hex
 
 export type ExecuteBatchesErrorType =
-  | DecodeErrorResultErrorType
-  | GetContractErrorReturnType
-  | EncodeFunctionDataErrorType
+  | GetExecuteErrorReturnType
+  | EncodeExecuteBatchesDataErrorType
   | SendTransactionErrorType
   | ErrorType
 
@@ -182,12 +168,6 @@ export async function executeBatches<
   const { authorizationList, batches } = parameters
 
   const address = authorizationList?.[0]?.contractAddress ?? parameters.address
-  const encodedBatches = AbiParameters.encode(AbiParameters.from('bytes[]'), [
-    batches.map((b) => {
-      const batch = b as Batch
-      return encodeCalls(batch.calls, batch.opData)
-    }),
-  ])
 
   const supported = await withCache(
     () =>
@@ -205,50 +185,10 @@ export async function executeBatches<
     return await sendTransaction(client, {
       ...parameters,
       to: parameters.address,
-      data: encodeFunctionData({
-        abi,
-        functionName: 'execute',
-        args: [executionMode.batchOfBatches, encodedBatches],
-      }),
+      data: encodeExecuteBatchesData({ batches }),
     } as any)
   } catch (e) {
-    const error = (e as BaseError).walk((e) => 'data' in (e as Error)) as
-      | (BaseError & { data?: Hex | undefined })
-      | undefined
-
-    if (!error?.data) throw e
-    if (
-      error.data ===
-      AbiError.getSelector(AbiError.from('error FnSelectorNotRecognized()'))
-    )
-      throw new FunctionSelectorNotRecognizedError()
-
-    let matched: Call | null = null
-    for (const b of parameters.batches) {
-      const batch = b as Batch
-      for (const c of batch.calls) {
-        const call = c as Call
-        if (!call.abi) continue
-        try {
-          const matches = Boolean(
-            decodeErrorResult({
-              abi: call.abi,
-              data: error.data!,
-            }),
-          )
-          if (!matches) continue
-          matched = call
-        } catch {}
-      }
-    }
-    if (!matched) throw e
-
-    throw getContractError(error as BaseError, {
-      abi: matched.abi as Abi,
-      address: matched.to,
-      args: matched.args,
-      docsPath: '/experimental/erc7821/executeBatches',
-      functionName: matched.functionName,
-    })
+    const calls = batches.flatMap((b) => b.calls) as Calls<Narrow<batches>>
+    throw getExecuteError(e as BaseError, { calls })
   }
 }

package/experimental/erc7821/index.ts

@@ -26,3 +26,25 @@ export {
 } from './errors.js'
 
 export { type Erc7821Actions, erc7821Actions } from './decorators/erc7821.js'
+
+export {
+  type EncodeCallsErrorType,
+  encodeCalls,
+} from './utils/encodeCalls.js'
+export {
+  type EncodeExecuteBatchesDataErrorType,
+  type EncodeExecuteBatchesDataParameters,
+  type EncodeExecuteBatchesDataReturnType,
+  encodeExecuteBatchesData,
+} from './utils/encodeExecuteBatchesData.js'
+export {
+  type EncodeExecuteDataErrorType,
+  type EncodeExecuteDataParameters,
+  type EncodeExecuteDataReturnType,
+  encodeExecuteData,
+} from './utils/encodeExecuteData.js'
+export {
+  type GetExecuteErrorParameters,
+  type GetExecuteErrorReturnType,
+  getExecuteError,
+} from './utils/getExecuteError.js'

package/experimental/erc7821/utils/encodeCalls.ts

@@ -0,0 +1,38 @@
+import * as AbiParameters from 'ox/AbiParameters'
+
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Call, Calls } from '../../../types/calls.js'
+import type { Hex } from '../../../types/misc.js'
+import {
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+} from '../../../utils/abi/encodeFunctionData.js'
+
+export type EncodeCallsErrorType =
+  | AbiParameters.encode.ErrorType
+  | AbiParameters.from.ErrorType
+  | EncodeFunctionDataErrorType
+  | ErrorType
+
+export function encodeCalls(
+  calls_: Calls<readonly unknown[]>,
+  opData?: Hex | undefined,
+) {
+  const calls = calls_.map((call_) => {
+    const call = call_ as Call
+    return {
+      data: call.abi ? encodeFunctionData(call) : (call.data ?? '0x'),
+      value: call.value ?? 0n,
+      target: call.to,
+    }
+  })
+
+  return AbiParameters.encode(
+    AbiParameters.from([
+      'struct Call { address target; uint256 value; bytes data; }',
+      'Call[] calls',
+      ...(opData ? ['bytes opData'] : []),
+    ]),
+    [calls, ...(opData ? [opData] : [])] as any,
+  )
+}

package/experimental/erc7821/utils/encodeExecuteBatchesData.ts

@@ -0,0 +1,48 @@
+import type { Narrow } from 'abitype'
+import * as AbiParameters from 'ox/AbiParameters'
+import type { ErrorType } from '../../../errors/utils.js'
+
+import type { Batches } from '../../../types/calls.js'
+import type { Hex } from '../../../types/misc.js'
+import {
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+} from '../../../utils/abi/encodeFunctionData.js'
+import { abi, executionMode } from '../constants.js'
+import { type EncodeCallsErrorType, encodeCalls } from './encodeCalls.js'
+
+/** @internal */
+export type Batch = { calls: readonly unknown[]; opData?: Hex | undefined }
+
+export type EncodeExecuteBatchesDataParameters<
+  batches extends readonly Batch[] = readonly Batch[],
+> = {
+  /** Batches to execute. */
+  batches: Batches<Narrow<batches>, { opData?: Hex | undefined }>
+}
+
+export type EncodeExecuteBatchesDataReturnType = Hex
+
+export type EncodeExecuteBatchesDataErrorType =
+  | EncodeCallsErrorType
+  | EncodeFunctionDataErrorType
+  | ErrorType
+
+export function encodeExecuteBatchesData<batches extends readonly Batch[]>(
+  parameters: EncodeExecuteBatchesDataParameters<batches>,
+): EncodeExecuteBatchesDataReturnType {
+  const { batches } = parameters
+
+  const encodedBatches = AbiParameters.encode(AbiParameters.from('bytes[]'), [
+    batches.map((b) => {
+      const batch = b as Batch
+      return encodeCalls(batch.calls, batch.opData)
+    }),
+  ])
+
+  return encodeFunctionData({
+    abi,
+    functionName: 'execute',
+    args: [executionMode.batchOfBatches, encodedBatches],
+  })
+}

package/experimental/erc7821/utils/encodeExecuteData.ts

@@ -0,0 +1,42 @@
+import type { Narrow } from 'abitype'
+
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Calls } from '../../../types/calls.js'
+import type { Hex } from '../../../types/misc.js'
+import {
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+} from '../../../utils/abi/encodeFunctionData.js'
+import { abi, executionMode } from '../constants.js'
+import { type EncodeCallsErrorType, encodeCalls } from './encodeCalls.js'
+
+export type EncodeExecuteDataParameters<
+  calls extends readonly unknown[] = readonly unknown[],
+> = {
+  /** Calls to execute. */
+  calls: Calls<Narrow<calls>>
+  /** Additional data to include for execution. */
+  opData?: Hex | undefined
+}
+
+export type EncodeExecuteDataReturnType = Hex
+
+export type EncodeExecuteDataErrorType =
+  | EncodeCallsErrorType
+  | EncodeFunctionDataErrorType
+  | ErrorType
+
+export function encodeExecuteData<const calls extends readonly unknown[]>(
+  parameters: EncodeExecuteDataParameters<calls>,
+): EncodeExecuteDataReturnType {
+  const { calls, opData } = parameters
+
+  const encodedCalls = encodeCalls(calls, opData)
+  const mode = opData ? executionMode.opData : executionMode.default
+
+  return encodeFunctionData({
+    abi,
+    functionName: 'execute',
+    args: [mode, encodedCalls],
+  })
+}

package/experimental/erc7821/utils/getExecuteError.ts

@@ -0,0 +1,67 @@
+import type { Abi, Narrow } from 'abitype'
+import * as AbiError from 'ox/AbiError'
+
+import type { BaseError } from '../../../errors/base.js'
+import type { Call, Calls } from '../../../types/calls.js'
+import type { Hex } from '../../../types/misc.js'
+import { decodeErrorResult } from '../../../utils/abi/decodeErrorResult.js'
+import {
+  type GetContractErrorReturnType,
+  getContractError,
+} from '../../../utils/errors/getContractError.js'
+import {
+  FunctionSelectorNotRecognizedError,
+  type FunctionSelectorNotRecognizedErrorType,
+} from '../errors.js'
+
+export type GetExecuteErrorParameters<
+  calls extends readonly unknown[] = readonly unknown[],
+> = {
+  /** Calls to execute. */
+  calls: Calls<Narrow<calls>>
+}
+
+export type GetExecuteErrorReturnType =
+  | FunctionSelectorNotRecognizedErrorType
+  | GetContractErrorReturnType
+
+export function getExecuteError<const calls extends readonly unknown[]>(
+  e: BaseError,
+  parameters: GetExecuteErrorParameters<calls>,
+): GetExecuteErrorReturnType {
+  const error = e.walk((e) => 'data' in (e as Error)) as
+    | (BaseError & { data?: Hex | undefined })
+    | undefined
+
+  if (!error?.data) return e as never
+  if (
+    error.data ===
+    AbiError.getSelector(AbiError.from('error FnSelectorNotRecognized()'))
+  )
+    return new FunctionSelectorNotRecognizedError() as never
+
+  let matched: Call | null = null
+  for (const c of parameters.calls) {
+    const call = c as Call
+    if (!call.abi) continue
+    try {
+      const matches = Boolean(
+        decodeErrorResult({
+          abi: call.abi,
+          data: error.data!,
+        }),
+      )
+      if (!matches) continue
+      matched = call
+    } catch {}
+  }
+  if (matched)
+    return getContractError(error as BaseError, {
+      abi: matched.abi as Abi,
+      address: matched.to,
+      args: matched.args,
+      functionName: matched.functionName,
+    })
+
+  return e as never
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.22.19",
+  "version": "2.22.21",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",