ox 0.9.7 → 0.9.9

package/erc7821/Execute.ts

@@ -0,0 +1,197 @@
+import * as AbiFunction from '../core/AbiFunction.js'
+import type * as Hex from '../core/Hex.js'
+import { AbiParameters } from '../index.js'
+import * as Calls from './Calls.js'
+
+export type Batch = {
+  calls: readonly Call[]
+  opData?: Hex.Hex | undefined
+}
+
+export type Call = Calls.Call
+
+export const abiFunction = {
+  type: 'function',
+  name: 'execute',
+  inputs: [
+    {
+      name: 'mode',
+      type: 'bytes32',
+      internalType: 'bytes32',
+    },
+    {
+      name: 'executionData',
+      type: 'bytes',
+      internalType: 'bytes',
+    },
+  ],
+  outputs: [],
+  stateMutability: 'payable',
+} satisfies AbiFunction.AbiFunction
+
+export const mode = {
+  default: '0x0100000000000000000000000000000000000000000000000000000000000000',
+  opData: '0x0100000000007821000100000000000000000000000000000000000000000000',
+  batchOfBatches:
+    '0x0100000000007821000200000000000000000000000000000000000000000000',
+} as const
+
+/**
+ * Decodes calls from ERC-7821 `execute` function data.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Execute } from 'ox/erc7821'
+ *
+ * const { calls } = Execute.decodeData('0x...')
+ * ```
+ *
+ * @param data - The encoded data.
+ * @returns The decoded calls and optional opData.
+ */
+export function decodeData(data: Hex.Hex): decodeData.ReturnType {
+  const [m, executionData] = AbiFunction.decodeData(abiFunction, data) as [
+    Hex.Hex,
+    Hex.Hex,
+  ]
+  return Calls.decode(executionData, { opData: m !== mode.default })
+}
+
+export declare namespace decodeData {
+  type ReturnType = {
+    calls: Call[]
+    opData?: Hex.Hex | undefined
+  }
+}
+
+/**
+ * Decodes batches from ERC-7821 `execute` function data in "batch of batches" mode.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Execute } from 'ox/erc7821'
+ *
+ * const batches = Execute.decodeBatchOfBatchesData('0x...')
+ * ```
+ *
+ * @param data - The encoded data.
+ * @returns The decoded batches.
+ */
+export function decodeBatchOfBatchesData(
+  data: Hex.Hex,
+): decodeBatchOfBatchesData.ReturnType {
+  const [, executionData] = AbiFunction.decodeData(abiFunction, data) as [
+    Hex.Hex,
+    Hex.Hex,
+  ]
+
+  const [encodedBatches] = AbiParameters.decode(
+    AbiParameters.from('bytes[]'),
+    executionData,
+  ) as readonly [Hex.Hex[]]
+
+  return encodedBatches.map((encodedBatch) => {
+    // Try decoding with opData first
+    try {
+      const decoded = Calls.decode(encodedBatch, { opData: true })
+      if (decoded.opData) {
+        return {
+          calls: decoded.calls,
+          opData: decoded.opData,
+        }
+      }
+      // If opData is undefined, return without it
+      return { calls: decoded.calls }
+    } catch {
+      // If decoding with opData fails, decode without it
+      const decoded = Calls.decode(encodedBatch, { opData: false })
+      return { calls: decoded.calls }
+    }
+  })
+}
+
+export declare namespace decodeBatchOfBatchesData {
+  type ReturnType = Batch[]
+}
+
+/**
+ * Encodes calls for the ERC-7821 `execute` function with "batch of batches" mode.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Execute } from 'ox/erc7821'
+ *
+ * const data = Execute.encodeBatchOfBatchesData([
+ *   {
+ *     calls: [
+ *       {
+ *         data: '0xcafebabe',
+ *         to: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+ *         value: 1n,
+ *       }
+ *     ]
+ *   },
+ *   {
+ *     calls: [
+ *       {
+ *         data: '0xdeadbeef',
+ *         to: '0xcafebabecafebabecafebabecafebabecafebabe',
+ *         value: 2n,
+ *       }
+ *     ],
+ *     opData: '0xcafebabe',
+ *   }
+ * ])
+ * ```
+ *
+ * @param calls - The calls to encode.
+ * @param options - The options.
+ * @returns The encoded data.
+ */
+export function encodeBatchOfBatchesData(batches: readonly Batch[]) {
+  const b = AbiParameters.encode(AbiParameters.from('bytes[]'), [
+    batches.map((b) => {
+      const batch = b as Batch
+      return Calls.encode(batch.calls, {
+        opData: batch.opData,
+      })
+    }),
+  ])
+  return AbiFunction.encodeData(abiFunction, [mode.batchOfBatches, b])
+}
+
+/**
+ * Encodes calls for the ERC-7821 `execute` function.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Execute } from 'ox/erc7821'
+ *
+ * const data = Execute.encodeData([
+ *   {
+ *     data: '0xcafebabe',
+ *     to: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+ *     value: 1n,
+ *   }
+ * ])
+ * ```
+ *
+ * @param calls - The calls to encode.
+ * @param options - The options.
+ * @returns The encoded data.
+ */
+export function encodeData(
+  calls: readonly Call[],
+  options: encodeData.Options = {},
+) {
+  const { opData } = options
+  const c = Calls.encode(calls, { opData })
+  const m = opData ? mode.opData : mode.default
+  return AbiFunction.encodeData(abiFunction, [m, c])
+}
+
+export declare namespace encodeData {
+  type Options = {
+    opData?: Hex.Hex | undefined
+  }
+}

package/erc7821/index.ts

@@ -0,0 +1,73 @@
+/** @entrypointCategory ERCs */
+// biome-ignore lint/complexity/noUselessEmptyExport: tsdoc
+export type {}
+
+/**
+ * Utility functions for encoding and decoding [ERC-7821](https://eips.ethereum.org/EIPS/eip-7821) calls.
+ *
+ * @example
+ * ### Encoding calls
+ *
+ * Calls can be encoded using `Calls.encode`.
+ *
+ * ```ts twoslash
+ * import { Calls } from 'ox/erc7821'
+ *
+ * const calls = Calls.encode([
+ *   {
+ *     data: '0xcafebabe',
+ *     to: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+ *     value: 1n,
+ *   }
+ * ])
+ * ```
+ *
+ * @example
+ * ### Decoding calls
+ *
+ * Calls can be decoded using `Calls.decode`.
+ *
+ * ```ts twoslash
+ * import { Calls } from 'ox/erc7821'
+ *
+ * const { calls } = Calls.decode('0x...')
+ * ```
+ *
+ * @category ERC-7821
+ */
+export * as Calls from './Calls.js'
+
+/**
+ * Utility functions for encoding and decoding [ERC-7821](https://eips.ethereum.org/EIPS/eip-7821) `execute` function data.
+ *
+ * @example
+ * ### Encoding `execute` Function Data
+ *
+ * The `execute` function data can be encoded using `Execute.encodeData`.
+ *
+ * ```ts twoslash
+ * import { Execute } from 'ox/erc7821'
+ *
+ * const data = Execute.encodeData([
+ *   {
+ *     data: '0xcafebabe',
+ *     to: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+ *     value: 1n,
+ *   }
+ * ])
+ * ```
+ *
+ * @example
+ * ### Decoding `execute` Function Data
+ *
+ * The `execute` function data can be decoded using `Execute.decodeData`.
+ *
+ * ```ts twoslash
+ * import { Execute } from 'ox/erc7821'
+ *
+ * const { calls } = Execute.decodeData('0xe9ae5c53...')
+ * ```
+ *
+ * @category ERC-7821
+ */
+export * as Execute from './Execute.js'

package/erc7821/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/erc7821/index.d.ts",
+  "main": "../_cjs/erc7821/index.js",
+  "module": "../_esm/erc7821/index.js"
+}

package/index.docs.ts

@@ -4,4 +4,5 @@
 export * from './index.js'
 export * from './erc4337/index.js'
 export * from './erc6492/index.js'
+export * from './erc7821/index.js'
 export * from './erc8010/index.js'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ox",
   "description": "Ethereum Standard Library",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -428,6 +428,21 @@
       "import": "./_esm/erc6492/index.js",
       "default": "./_cjs/erc6492/index.js"
     },
+    "./erc7821/Calls": {
+      "types": "./_types/erc7821/Calls.d.ts",
+      "import": "./_esm/erc7821/Calls.js",
+      "default": "./_cjs/erc7821/Calls.js"
+    },
+    "./erc7821/Execute": {
+      "types": "./_types/erc7821/Execute.d.ts",
+      "import": "./_esm/erc7821/Execute.js",
+      "default": "./_cjs/erc7821/Execute.js"
+    },
+    "./erc7821": {
+      "types": "./_types/erc7821/index.d.ts",
+      "import": "./_esm/erc7821/index.js",
+      "default": "./_cjs/erc7821/index.js"
+    },
     "./erc8010/SignatureErc8010": {
       "types": "./_types/erc8010/SignatureErc8010.d.ts",
       "import": "./_esm/erc8010/SignatureErc8010.js",

package/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '0.9.7'
+export const version = '0.9.9'