ox 0.9.7 → 0.9.8

package/_types/erc7821/Execute.d.ts

@@ -0,0 +1,126 @@
+import type * as Hex from '../core/Hex.js';
+import * as Calls from './Calls.js';
+export type Batch = {
+    calls: readonly Call[];
+    opData?: Hex.Hex | undefined;
+};
+export type Call = Calls.Call;
+export declare const abiFunction: {
+    type: "function";
+    name: string;
+    inputs: ({
+        name: string;
+        type: "bytes32";
+        internalType: string;
+    } | {
+        name: string;
+        type: "bytes";
+        internalType: string;
+    })[];
+    outputs: never[];
+    stateMutability: "payable";
+};
+export declare const mode: {
+    readonly default: "0x0100000000000000000000000000000000000000000000000000000000000000";
+    readonly opData: "0x0100000000007821000100000000000000000000000000000000000000000000";
+    readonly batchOfBatches: "0x0100000000007821000200000000000000000000000000000000000000000000";
+};
+/**
+ * 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 declare function decodeData(data: Hex.Hex): decodeData.ReturnType;
+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 declare function decodeBatchOfBatchesData(data: Hex.Hex): decodeBatchOfBatchesData.ReturnType;
+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 declare function encodeBatchOfBatchesData(batches: readonly Batch[]): `0x${string}`;
+/**
+ * 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 declare function encodeData(calls: readonly Call[], options?: encodeData.Options): `0x${string}`;
+export declare namespace encodeData {
+    type Options = {
+        opData?: Hex.Hex | undefined;
+    };
+}
+//# sourceMappingURL=Execute.d.ts.map

package/_types/erc7821/Execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Execute.d.ts","sourceRoot":"","sources":["../../erc7821/Execute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,GAAG,MAAM,gBAAgB,CAAA;AAE1C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC,MAAM,MAAM,KAAK,GAAG;IAClB,KAAK,EAAE,SAAS,IAAI,EAAE,CAAA;IACtB,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAA;AAE7B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;CAiBW,CAAA;AAEnC,eAAO,MAAM,IAAI;;;;CAKP,CAAA;AAEV;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,GAAG,UAAU,CAAC,UAAU,CAM/D;AAED,MAAM,CAAC,OAAO,WAAW,UAAU,CAAC;IAClC,KAAK,UAAU,GAAG;QAChB,KAAK,EAAE,IAAI,EAAE,CAAA;QACb,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,CAAA;KAC7B,CAAA;CACF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,GAAG,CAAC,GAAG,GACZ,wBAAwB,CAAC,UAAU,CA6BrC;AAED,MAAM,CAAC,OAAO,WAAW,wBAAwB,CAAC;IAChD,KAAK,UAAU,GAAG,KAAK,EAAE,CAAA;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,SAAS,KAAK,EAAE,iBAUjE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,OAAO,GAAE,UAAU,CAAC,OAAY,iBAMjC;AAED,MAAM,CAAC,OAAO,WAAW,UAAU,CAAC;IAClC,KAAK,OAAO,GAAG;QACb,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,CAAA;KAC7B,CAAA;CACF"}

package/_types/erc7821/index.d.ts

@@ -0,0 +1,71 @@
+/** @entrypointCategory ERCs */
+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';
+//# sourceMappingURL=index.d.ts.map

package/_types/erc7821/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../erc7821/index.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAE/B,YAAY,EAAE,CAAA;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA"}

package/_types/index.docs.d.ts

@@ -2,5 +2,6 @@
 export * from './index.js';
 export * from './erc4337/index.js';
 export * from './erc6492/index.js';
+export * from './erc7821/index.js';
 export * from './erc8010/index.js';
 //# sourceMappingURL=index.docs.d.ts.map

package/_types/index.docs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.docs.d.ts","sourceRoot":"","sources":["../index.docs.ts"],"names":[],"mappings":"AACA,2FAA2F;AAE3F,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"index.docs.d.ts","sourceRoot":"","sources":["../index.docs.ts"],"names":[],"mappings":"AACA,2FAA2F;AAE3F,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA"}

package/_types/version.d.ts

@@ -1,3 +1,3 @@
 /** @internal */
-export declare const version = "0.9.7";
+export declare const version = "0.9.8";
 //# sourceMappingURL=version.d.ts.map

package/erc7821/Calls/package.json

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

package/erc7821/Calls.ts

@@ -0,0 +1,148 @@
+import * as AbiParameters from '../core/AbiParameters.js'
+import type * as Address from '../core/Address.js'
+import type * as Hex from '../core/Hex.js'
+
+export type Call<bigintType = bigint> = {
+  data?: Hex.Hex | undefined
+  to: Address.Address
+  value?: bigintType | undefined
+}
+
+/**
+ * Encodes a set of ERC-7821 calls.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Calls } from 'ox/erc7821'
+ *
+ * const calls = Calls.encode([
+ *   {
+ *     data: '0xdeadbeef',
+ *     to: '0xcafebabecafebabecafebabecafebabecafebabe',
+ *     value: 1n,
+ *   },
+ *   {
+ *     data: '0xcafebabe',
+ *     to: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+ *     value: 2n,
+ *   },
+ * ])
+ * // @log: '0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000120000000000000000000000000cafebabecafebabecafebabecafebabecafebabe0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000deadbeef000000000000000000000000deadbeefdeadbeefdeadbeefdeadbeefdeadbeef0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000cafebabe'
+ * ```
+ *
+ * @param calls - Calls to encode.
+ * @param options - Options for the encoding.
+ * @returns The encoded calls.
+ */
+export function encode(calls: readonly Call[], options: encode.Options = {}) {
+  const { opData } = options
+  return AbiParameters.encode(getAbiParameters({ opData: !!opData }), [
+    calls.map((call) => ({
+      target: call.to,
+      value: call.value ?? 0n,
+      data: call.data ?? '0x',
+    })),
+    ...(opData ? [opData] : []),
+  ] as any)
+}
+
+export declare namespace encode {
+  type Options = {
+    /** Additional data to include for execution. */
+    opData?: Hex.Hex | undefined
+  }
+}
+
+/**
+ * Gets the ABI parameters for the ERC-7821 calls.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Calls } from 'ox/erc7821'
+ *
+ * const abiParameters = Calls.getAbiParameters({ opData: true })
+ * ```
+ *
+ * @param options - Options.
+ * @returns The ABI parameters.
+ */
+export function getAbiParameters(options: getAbiParameters.Options = {}) {
+  const { opData } = options
+  return AbiParameters.from([
+    'struct Call { address target; uint256 value; bytes data; }',
+    'Call[] calls',
+    ...(opData ? ['bytes opData'] : []),
+  ])
+}
+
+export declare namespace getAbiParameters {
+  type Options = {
+    opData?: boolean | undefined
+  }
+}
+
+/**
+ * Decodes a set of ERC-7821 calls from encoded data.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Calls } from 'ox/erc7821'
+ *
+ * const data = Calls.decode('0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000cafebabecafebabecafebabecafebabecafebabe000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004deadbeef00000000000000000000000000000000000000000000000000000000000000000000000000000000deadbeefdeadbeefdeadbeefdeadbeefdeadbeef000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004cafebabe00000000000000000000000000000000000000000000000000000000')
+ * // @log: {
+ * // @log:   calls: [
+ * // @log:     {
+ * // @log:       data: '0xdeadbeef',
+ * // @log:       to: '0xcafebabecafebabecafebabecafebabecafebabe',
+ * // @log:       value: 1n,
+ * // @log:     },
+ * // @log:     {
+ * // @log:       data: '0xcafebabe',
+ * // @log:       to: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+ * // @log:       value: 2n,
+ * // @log:     },
+ * // @log:   ]
+ * // @log: }
+ * ```
+ *
+ * @param data - The encoded calls data.
+ * @param options - Options for decoding.
+ * @returns The decoded calls and optional opData.
+ */
+export function decode(
+  data: Hex.Hex,
+  options: decode.Options = {},
+): decode.ReturnType {
+  const { opData: withOpData = false } = options
+
+  const decoded = AbiParameters.decode(
+    getAbiParameters({ opData: withOpData }),
+    data,
+  ) as readonly unknown[]
+  const [encodedCalls, opData] = decoded as readonly [
+    { target: Address.Address; value: bigint; data: Hex.Hex }[],
+    Hex.Hex?,
+  ]
+
+  const calls = encodedCalls.map((call) => ({
+    to: call.target,
+    value: call.value,
+    data: call.data,
+  }))
+
+  return withOpData
+    ? { calls, opData: opData === '0x' ? undefined : opData }
+    : { calls }
+}
+
+export declare namespace decode {
+  type Options = {
+    /** Whether to decode opData if present. */
+    opData?: boolean | undefined
+  }
+
+  type ReturnType = {
+    calls: Call[]
+    opData?: Hex.Hex | undefined
+  }
+}

package/erc7821/Execute/package.json

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

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'