ox 0.9.6 → 0.9.8

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.6";
+export declare const version = "0.9.8";
 //# sourceMappingURL=version.d.ts.map

package/core/Bytes.ts

@@ -231,7 +231,7 @@ export function fromHex(value: Hex.Hex, options: fromHex.Options = {}): Bytes {
         `Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`,
       )
     }
-    bytes[index] = nibbleLeft * 16 + nibbleRight
+    bytes[index] = (nibbleLeft << 4) | nibbleRight
   }
   return bytes
 }

package/core/Hex.ts

@@ -256,7 +256,7 @@ export function fromNumber(
   }
 
   const stringValue = (
-    signed && value_ < 0 ? (1n << BigInt(size * 8)) + BigInt(value_) : value_
+    signed && value_ < 0 ? BigInt.asUintN(size * 8, BigInt(value_)) : value_
   ).toString(16)
 
   const hex = `0x${stringValue}` as Hex

package/core/Rlp.ts

@@ -359,9 +359,9 @@ function getEncodableBytes(bytesOrHex: Bytes.Bytes | Hex.Hex): Encodable {
 }
 
 function getSizeOfLength(length: number) {
-  if (length < 2 ** 8) return 1
-  if (length < 2 ** 16) return 2
-  if (length < 2 ** 24) return 3
-  if (length < 2 ** 32) return 4
+  if (length <= 0xff) return 1
+  if (length <= 0xff_ff) return 2
+  if (length <= 0xff_ff_ff) return 3
+  if (length <= 0xff_ff_ff_ff) return 4
   throw new Errors.BaseError('Length is too large.')
 }

package/core/TransactionRequest.ts

@@ -4,6 +4,7 @@ import * as Authorization from './Authorization.js'
 import type * as Errors from './Errors.js'
 import * as Hex from './Hex.js'
 import type { Compute } from './internal/types.js'
+import * as Transaction from './Transaction.js'
 
 /** A Transaction Request that is generic to all transaction types, as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/4aca1d7a3e5aab24c8f6437131289ad386944eaa/src/schemas/transaction.yaml#L358-L423). */
 export type TransactionRequest<
@@ -132,7 +133,11 @@ export function toRpc(request: TransactionRequest): Rpc {
   if (typeof request.nonce !== 'undefined')
     request_rpc.nonce = Hex.fromNumber(request.nonce)
   if (typeof request.to !== 'undefined') request_rpc.to = request.to
-  if (typeof request.type !== 'undefined') request_rpc.type = request.type
+  if (typeof request.type !== 'undefined')
+    request_rpc.type =
+      Transaction.toRpcType[
+        request.type as keyof typeof Transaction.toRpcType
+      ] || request.type
   if (typeof request.value !== 'undefined')
     request_rpc.value = Hex.fromNumber(request.value)
 

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'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ox",
   "description": "Ethereum Standard Library",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "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.6'
+export const version = '0.9.8'