ox 1.7.4 → 1.8.0

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.7.4'
+export const version = '1.8.0'

package/src/zod/Frame.ts

@@ -0,0 +1,82 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as core_Frame from '../core/Frame.js'
+import * as z_Address from './Address.js'
+import * as z_Hex from './Hex.js'
+import * as z from 'zod/mini'
+
+const Mode = z.union([z.number(), z.enum(['default', 'sender', 'verify'])])
+const Flags = z.union([
+  z.number(),
+  z.enum([
+    'approveExecution',
+    'approveExecutionAndPayment',
+    'approvePayment',
+    'atomicBatch',
+    'none',
+  ]),
+])
+
+/** Decoded frame schema. */
+export const Decoded: z.ZodMiniType<core_Frame.Frame, core_Frame.Frame> = z
+  .object(fields(z.bigint()))
+  .check(z.refine(core_Frame.validate, 'Invalid frame'))
+
+/** RPC frame schema. */
+export const Rpc = z
+  .object({
+    data: z_Hex.Hex,
+    executionGasLimit: z_Hex.Hex,
+    flags: z.number(),
+    mode: z.number(),
+    stateGasLimit: z_Hex.Hex,
+    target: z.optional(z.nullable(z_Address.Address)),
+    value: z_Hex.Hex,
+  })
+  .check(
+    z.refine((value) => {
+      try {
+        core_Frame.fromRpc(value)
+        return true
+      } catch {
+        return false
+      }
+    }, 'Invalid frame'),
+  )
+
+/** Codec between RPC and decoded frames. */
+export const Frame = z.codec(Rpc, Decoded, {
+  decode: core_Frame.fromRpc,
+  encode: core_Frame.toRpc,
+})
+
+/** Decoded frame schema accepting numberish budgets. */
+export const DecodedToRpc = z
+  .object(fields(z.union([z_Hex.Hex, z.bigint(), z.number()])))
+  .check(
+    z.refine((value) => {
+      try {
+        core_Frame.fromRpc(core_Frame.toRpc(value))
+        return true
+      } catch {
+        return false
+      }
+    }, 'Invalid frame'),
+  )
+
+/** Encode-only frame codec accepting numberish budgets. */
+export const FrameToRpc = z.codec(Rpc, DecodedToRpc, {
+  decode: core_Frame.fromRpc,
+  encode: core_Frame.toRpc,
+})
+
+function fields<uint extends z.ZodMiniType>(uint: uint) {
+  return {
+    data: z.optional(z_Hex.Hex),
+    flags: z.optional(Flags),
+    gas: z.optional(uint),
+    mode: z.optional(Mode),
+    stateGas: z.optional(uint),
+    target: z.optional(z_Address.Address),
+    value: z.optional(uint),
+  }
+}

package/src/zod/FrameReceipt.ts

@@ -0,0 +1,48 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as core_FrameReceipt from '../core/FrameReceipt.js'
+import * as z_Address from './Address.js'
+import * as z_Hex from './Hex.js'
+import {
+  quantityHex,
+  uintBigint,
+  uintBigintNumberish,
+} from './internal/Integer.js'
+import * as z from 'zod/mini'
+
+const frameLog = z.object({
+  address: z_Address.Address,
+  data: z_Hex.Hex,
+  topics: z.array(z_Hex.Hex),
+})
+
+const frameReceiptRpc = z.object({
+  executionGasUsed: quantityHex(),
+  logs: z.readonly(z.array(frameLog)),
+  stateGasUsed: quantityHex(),
+  status: z.union([z.literal(0), z.literal(1), z.literal(2)]),
+})
+const frameReceiptDecoded = z.object({
+  gasUsed: uintBigint(),
+  logs: z.readonly(z.array(frameLog)),
+  stateGasUsed: uintBigint(),
+  status: z.enum(['reverted', 'success', 'skipped']),
+})
+
+/** Codec between RPC and decoded frame receipts. */
+export const FrameReceipt = z.codec(frameReceiptRpc, frameReceiptDecoded, {
+  decode: core_FrameReceipt.fromRpc,
+  encode: core_FrameReceipt.toRpc,
+})
+
+/** Encode-only frame receipt codec accepting numberish gas. */
+export const FrameReceiptToRpc = z.codec(
+  frameReceiptRpc,
+  z.extend(frameReceiptDecoded, {
+    gasUsed: uintBigintNumberish(),
+    stateGasUsed: uintBigintNumberish(),
+  }),
+  {
+    decode: core_FrameReceipt.fromRpc,
+    encode: core_FrameReceipt.toRpc,
+  },
+)

package/src/zod/FrameSignature.ts

@@ -0,0 +1,78 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as core_FrameSignature from '../core/FrameSignature.js'
+import * as z_Address from './Address.js'
+import * as z_Hex from './Hex.js'
+import * as z from 'zod/mini'
+
+const publicKey = z.object({ prefix: z.number(), x: z_Hex.Hex, y: z_Hex.Hex })
+const signature = z.object({
+  r: z_Hex.Hex,
+  s: z_Hex.Hex,
+  yParity: z.optional(z.number()),
+})
+
+/** Contract-defined frame signature schema. */
+export const Arbitrary = z.object({
+  payload: z.optional(z_Hex.Hex),
+  scheme: z.union([z.literal(0), z.literal('arbitrary')]),
+  signature: z_Hex.Hex,
+  signer: z.optional(z.undefined()),
+})
+
+/** secp256k1 frame signature schema. */
+export const Secp256k1 = z.object({
+  payload: z.optional(z_Hex.Hex),
+  scheme: z.union([z.literal(1), z.literal('secp256k1')]),
+  signature: z.optional(
+    z.object({ r: z_Hex.Hex, s: z_Hex.Hex, yParity: z.number() }),
+  ),
+  signer: z.optional(z_Address.Address),
+})
+
+const p256 = {
+  payload: z.optional(z_Hex.Hex),
+  scheme: z.union([z.literal(2), z.literal('p256')]),
+  signer: z.optional(z_Address.Address),
+}
+/** P-256 frame signature schema, including unsigned placeholders. */
+export const P256 = z.union([
+  z.object({ ...p256, publicKey, signature }),
+  z.object({
+    ...p256,
+    publicKey: z.optional(publicKey),
+    signature: z.optional(z.undefined()),
+  }),
+])
+
+/** Decoded frame signature schema. */
+export const Decoded: z.ZodMiniType<
+  core_FrameSignature.FrameSignature,
+  core_FrameSignature.FrameSignature
+> = z
+  .union([Arbitrary, Secp256k1, P256])
+  .check(z.refine(core_FrameSignature.validate, 'Invalid frame signature'))
+
+/** RPC frame signature schema. */
+export const Rpc = z
+  .object({
+    msg: z_Hex.Hex,
+    scheme: z.union([z.literal(0), z.literal(1), z.literal(2)]),
+    signature: z_Hex.Hex,
+    signer: z.optional(z.nullable(z_Address.Address)),
+  })
+  .check(
+    z.refine((value) => {
+      try {
+        core_FrameSignature.fromRpc(value)
+        return true
+      } catch {
+        return false
+      }
+    }, 'Invalid frame signature'),
+  )
+
+/** Codec between RPC and structured frame signatures. */
+export const FrameSignature = z.codec(Rpc, Decoded, {
+  decode: core_FrameSignature.fromRpc,
+  encode: core_FrameSignature.toRpc,
+})

package/src/zod/Transaction.ts

@@ -2,6 +2,9 @@
 import * as z_AccessList from './AccessList.js'
 import * as z_Address from './Address.js'
 import * as z_Authorization from './Authorization.js'
+import * as z_Frame from './Frame.js'
+import * as z_FrameSignature from './FrameSignature.js'
+import { chainId, chainIdToRpc } from './internal/Frame.js'
 import * as z_Hex from './Hex.js'
 import * as z_Number from './Number.js'
 import * as z_Uint from './Uint.js'
@@ -13,6 +16,7 @@ const fromRpcType = {
   '0x2': 'eip1559',
   '0x3': 'eip4844',
   '0x4': 'eip7702',
+  '0x6': 'eip8141',
 } as const
 
 const toRpcType = {
@@ -21,6 +25,7 @@ const toRpcType = {
   eip1559: '0x2',
   eip4844: '0x3',
   eip7702: '0x4',
+  eip8141: '0x6',
 } as const
 
 /** Transaction type schema. */
@@ -134,6 +139,61 @@ export const PendingEip7702 = z.object(
   ),
 )
 
+const Eip8141Type = type('0x6', 'eip8141')
+
+/** EIP-8141 transaction schema. */
+export const Eip8141 = z.object({
+  ...eip8141Fields(z_Uint.Uint, chainId, z_Frame.Frame),
+  blockHash: z_Hex.Hex,
+  blockNumber: z_Uint.Uint,
+  blockTimestamp: z.optional(z_Uint.Uint),
+  transactionIndex: z_Number.Number,
+})
+
+/** Encode-only EIP-8141 transaction schema accepting numberish values. */
+export const Eip8141ToRpc = z.object({
+  ...eip8141Fields(z_Uint.UintToRpc, chainIdToRpc, z_Frame.FrameToRpc),
+  blockHash: z_Hex.Hex,
+  blockNumber: z_Uint.UintToRpc,
+  blockTimestamp: z.optional(z_Uint.UintToRpc),
+  transactionIndex: z_Number.NumberToRpc,
+})
+
+/** Pending EIP-8141 transaction schema. */
+export const PendingEip8141 = z.object({
+  ...eip8141Fields(z_Uint.Uint, chainId, z_Frame.Frame),
+  blockHash: z.null(),
+  blockNumber: z.null(),
+  blockTimestamp: z.optional(z.null()),
+  transactionIndex: z.null(),
+})
+
+function eip8141Fields<
+  uint extends z.ZodMiniType,
+  num extends z.ZodMiniType,
+  frame extends z.ZodMiniType,
+>(uint: uint, num: num, frame: frame) {
+  return {
+    blobVersionedHashes: z.readonly(z.array(z_Hex.Hex)),
+    chainId: num,
+    data: z.optional(z_Hex.Hex),
+    frames: z.readonly(z.array(frame)),
+    from: z_Address.Address,
+    gas: uint,
+    gasPrice: z.optional(uint),
+    hash: z_Hex.Hex,
+    input: z_Hex.Hex,
+    maxFeePerBlobGas: uint,
+    maxFeePerGas: uint,
+    maxPriorityFeePerGas: uint,
+    nonce: uint,
+    signatures: z.readonly(z.array(z_FrameSignature.FrameSignature)),
+    to: z.nullable(z_Address.Address),
+    type: Eip8141Type,
+    value: uint,
+  }
+}
+
 /** Unknown typed transaction schema. */
 export const Unknown = z.object(
   baseFields(UnknownType, z_Uint.Uint, z_Number.Number),
@@ -155,6 +215,7 @@ export const Transaction = z.union([
   Eip1559,
   Eip4844,
   Eip7702,
+  Eip8141,
   Unknown,
 ])
 
@@ -165,6 +226,7 @@ export const TransactionToRpc = z.union([
   Eip1559ToRpc,
   Eip4844ToRpc,
   Eip7702ToRpc,
+  Eip8141ToRpc,
   UnknownToRpc,
 ])
 
@@ -175,6 +237,7 @@ export const Pending = z.union([
   PendingEip1559,
   PendingEip4844,
   PendingEip7702,
+  PendingEip8141,
   PendingUnknown,
 ])
 

package/src/zod/TransactionEnvelope.ts

@@ -1,3 +1,4 @@
+import * as core_FrameSignature from '../core/FrameSignature.js'
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 import * as core_TxEnvelope from '../core/TxEnvelope.js'
 import * as z_AccessList from './AccessList.js'
@@ -7,6 +8,7 @@ import * as z_TxEnvelopeEip1559 from './TxEnvelopeEip1559.js'
 import * as z_TxEnvelopeEip2930 from './TxEnvelopeEip2930.js'
 import * as z_TxEnvelopeEip4844 from './TxEnvelopeEip4844.js'
 import * as z_TxEnvelopeEip7702 from './TxEnvelopeEip7702.js'
+import * as z_TxEnvelopeEip8141 from './TxEnvelopeEip8141.js'
 import * as z_TxEnvelopeLegacy from './TxEnvelopeLegacy.js'
 import {
   baseFields,
@@ -21,6 +23,7 @@ const fromRpcType = {
   '0x2': 'eip1559',
   '0x3': 'eip4844',
   '0x4': 'eip7702',
+  '0x6': 'eip8141',
 } as const
 
 const toRpcType = {
@@ -29,6 +32,7 @@ const toRpcType = {
   eip1559: '0x2',
   eip4844: '0x3',
   eip7702: '0x4',
+  eip8141: '0x6',
 } as const
 
 /** Transaction envelope type schema. */
@@ -47,6 +51,7 @@ export const BaseSigned = z.object(
 
 /** Transaction envelope schema. */
 export const TransactionEnvelope = z.union([
+  z_TxEnvelopeEip8141.TxEnvelopeEip8141,
   z_TxEnvelopeLegacy.TxEnvelopeLegacy,
   z_TxEnvelopeEip2930.TxEnvelopeEip2930,
   z_TxEnvelopeEip1559.TxEnvelopeEip1559,
@@ -56,6 +61,7 @@ export const TransactionEnvelope = z.union([
 
 /** Encode-only transaction envelope schema accepting numberish `toRpc` inputs. */
 export const TransactionEnvelopeToRpc = z.union([
+  z_TxEnvelopeEip8141.TxEnvelopeEip8141ToRpc,
   z_TxEnvelopeLegacy.TxEnvelopeLegacyToRpc,
   z_TxEnvelopeEip2930.TxEnvelopeEip2930ToRpc,
   z_TxEnvelopeEip1559.TxEnvelopeEip1559ToRpc,
@@ -65,6 +71,15 @@ export const TransactionEnvelopeToRpc = z.union([
 
 /** Signed transaction envelope schema. */
 export const Signed = z.union([
+  z_TxEnvelopeEip8141.TxEnvelopeEip8141.check(
+    z.refine(
+      (value) =>
+        (value.signatures ?? []).every((entry) =>
+          core_FrameSignature.validate(entry, { signed: true }),
+        ),
+      'Invalid signed frame transaction',
+    ),
+  ),
   z_TxEnvelopeLegacy.Signed,
   z_TxEnvelopeEip2930.Signed,
   z_TxEnvelopeEip1559.Signed,
@@ -74,6 +89,15 @@ export const Signed = z.union([
 
 /** Encode-only signed transaction envelope schema accepting numberish `toRpc` inputs. */
 export const SignedToRpc = z.union([
+  z_TxEnvelopeEip8141.TxEnvelopeEip8141ToRpc.check(
+    z.refine(
+      (value) =>
+        (value.signatures ?? []).every((entry) =>
+          core_FrameSignature.validate(entry, { signed: true }),
+        ),
+      'Invalid signed frame transaction',
+    ),
+  ),
   z_TxEnvelopeLegacy.SignedToRpc,
   z_TxEnvelopeEip2930.SignedToRpc,
   z_TxEnvelopeEip1559.SignedToRpc,
@@ -156,6 +180,15 @@ const SignedEip7702Decoded = z.object({
 
 /** Decoded signed transaction envelope schema. */
 export const SignedDecoded = z.union([
+  z_TxEnvelopeEip8141.Decoded.check(
+    z.refine(
+      (value) =>
+        (value.signatures ?? []).every((entry) =>
+          core_FrameSignature.validate(entry, { signed: true }),
+        ),
+      'Invalid signed frame transaction',
+    ),
+  ),
   SignedLegacyDecoded,
   SignedEip2930Decoded,
   SignedEip1559Decoded,

package/src/zod/TransactionReceipt.ts

@@ -1,5 +1,6 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 import * as z_Address from './Address.js'
+import * as z_FrameReceipt from './FrameReceipt.js'
 import * as z_Hex from './Hex.js'
 import * as z_Log from './Log.js'
 import * as z_Number from './Number.js'
@@ -22,6 +23,7 @@ const fromRpcType = {
   '0x2': 'eip1559',
   '0x3': 'eip4844',
   '0x4': 'eip7702',
+  '0x6': 'eip8141',
 } as const
 
 const toRpcType = {
@@ -30,6 +32,7 @@ const toRpcType = {
   eip1559: '0x2',
   eip4844: '0x3',
   eip7702: '0x4',
+  eip8141: '0x6',
 } as const
 
 /** Transaction receipt status schema. */
@@ -50,19 +53,25 @@ export const Type = z.codec(z.string(), z.string(), {
 
 /** Transaction receipt schema. */
 export const TransactionReceipt = z.object(
-  fields(z_Uint.Uint, z_Number.Number, z_Log.Log),
+  fields(z_Uint.Uint, z_Number.Number, z_Log.Log, z_FrameReceipt.FrameReceipt),
 )
 
 /** Encode-only transaction receipt schema accepting numberish `toRpc` inputs. */
 export const TransactionReceiptToRpc = z.object(
-  fields(z_Uint.UintToRpc, z_Number.NumberToRpc, z_Log.LogToRpc),
+  fields(
+    z_Uint.UintToRpc,
+    z_Number.NumberToRpc,
+    z_Log.LogToRpc,
+    z_FrameReceipt.FrameReceiptToRpc,
+  ),
 )
 
 function fields<
   uint extends z.ZodMiniType,
   num extends z.ZodMiniType,
   log extends z.ZodMiniType,
->(uint: uint, num: num, log: log) {
+  frame extends z.ZodMiniType,
+>(uint: uint, num: num, log: log, frame: frame) {
   return {
     blobGasPrice: z.optional(uint),
     blobGasUsed: z.optional(uint),
@@ -71,10 +80,12 @@ function fields<
     contractAddress: z.optional(z.union([z_Address.Address, z.null()])),
     cumulativeGasUsed: uint,
     effectiveGasPrice: uint,
+    frameReceipts: z.optional(z.readonly(z.array(frame))),
     from: z_Address.Address,
     gasUsed: uint,
     logs: z.array(log),
     logsBloom: z_Hex.Hex,
+    payer: z.optional(z_Address.Address),
     root: z.optional(z_Hex.Hex),
     status: Status,
     to: z.union([z_Address.Address, z.null()]),

package/src/zod/TransactionRequest.ts

@@ -2,6 +2,8 @@
 import * as z_AccessList from './AccessList.js'
 import * as z_Address from './Address.js'
 import * as z_Authorization from './Authorization.js'
+import * as z_Frame from './Frame.js'
+import * as z_FrameSignature from './FrameSignature.js'
 import * as z_Hex from './Hex.js'
 import * as z_Number from './Number.js'
 import * as z_Uint from './Uint.js'
@@ -13,6 +15,7 @@ const fromRpcType = {
   '0x2': 'eip1559',
   '0x3': 'eip4844',
   '0x4': 'eip7702',
+  '0x6': 'eip8141',
 } as const
 
 const toRpcType = {
@@ -21,6 +24,7 @@ const toRpcType = {
   eip1559: '0x2',
   eip4844: '0x3',
   eip7702: '0x4',
+  eip8141: '0x6',
 } as const
 
 const type = z.codec(z.string(), z.string(), {
@@ -30,7 +34,12 @@ const type = z.codec(z.string(), z.string(), {
 
 /** Transaction request schema. */
 export const TransactionRequest = z.object(
-  fields(z_Uint.Uint, z_Number.Number, z_Authorization.ListSigned),
+  fields(
+    z_Uint.Uint,
+    z_Number.Number,
+    z_Authorization.ListSigned,
+    z_Frame.Frame,
+  ),
 )
 
 /** Encode-only transaction request schema accepting numberish `toRpc` inputs. */
@@ -39,6 +48,7 @@ export const TransactionRequestToRpc = z.object(
     z_Uint.UintToRpc,
     z_Number.NumberToRpc,
     z_Authorization.ListSignedToRpc,
+    z_Frame.FrameToRpc,
   ),
 )
 
@@ -46,7 +56,8 @@ function fields<
   uint extends z.ZodMiniType,
   num extends z.ZodMiniType,
   authorizationList extends z.ZodMiniType,
->(uint: uint, num: num, authorizationList: authorizationList) {
+  frame extends z.ZodMiniType,
+>(uint: uint, num: num, authorizationList: authorizationList, frame: frame) {
   return {
     accessList: z.optional(z_AccessList.AccessList),
     authorizationList: z.optional(authorizationList),
@@ -54,14 +65,18 @@ function fields<
     blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
     chainId: z.optional(num),
     data: z.optional(z_Hex.Hex),
-    input: z.optional(z_Hex.Hex),
+    frames: z.optional(z.readonly(z.array(frame))),
     from: z.optional(z_Address.Address),
     gas: z.optional(uint),
     gasPrice: z.optional(uint),
+    input: z.optional(z_Hex.Hex),
     maxFeePerBlobGas: z.optional(uint),
     maxFeePerGas: z.optional(uint),
     maxPriorityFeePerGas: z.optional(uint),
     nonce: z.optional(uint),
+    signatures: z.optional(
+      z.readonly(z.array(z_FrameSignature.FrameSignature)),
+    ),
     to: z.optional(z.union([z_Address.Address, z.null()])),
     type: z.optional(type),
     value: z.optional(uint),

package/src/zod/TxEnvelopeEip8141.ts

@@ -0,0 +1,102 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as core_TxEnvelopeEip8141 from '../core/TxEnvelopeEip8141.js'
+import * as z_Address from './Address.js'
+import * as z_Frame from './Frame.js'
+import * as z_FrameSignature from './FrameSignature.js'
+import * as z_Hex from './Hex.js'
+import * as z_TxEnvelopeEip4844 from './TxEnvelopeEip4844.js'
+import * as z from 'zod/mini'
+
+/** Decoded EIP-8141 envelope schema. */
+export const Decoded = z
+  .object(
+    fields(z.bigint(), z.union([z.number(), z.bigint()]), z_Frame.Decoded),
+  )
+  .check(z.refine(core_TxEnvelopeEip8141.validate, 'Invalid frame transaction'))
+
+/** RPC EIP-8141 envelope schema. */
+export const Rpc = z
+  .object({
+    blobVersionedHashes: z.readonly(z.array(z_Hex.Hex)),
+    chainId: z_Hex.Hex,
+    frames: z.readonly(z.array(z_Frame.Rpc)),
+    from: z_Address.Address,
+    maxFeePerBlobGas: z_Hex.Hex,
+    maxFeePerGas: z_Hex.Hex,
+    maxPriorityFeePerGas: z_Hex.Hex,
+    nonce: z_Hex.Hex,
+    signatures: z.readonly(z.array(z_FrameSignature.Rpc)),
+    type: z.literal('0x6'),
+  })
+  .check(
+    z.refine((value) => {
+      try {
+        core_TxEnvelopeEip8141.fromRpc(value)
+        return true
+      } catch {
+        return false
+      }
+    }, 'Invalid frame transaction'),
+  )
+
+/** Codec between RPC and decoded EIP-8141 envelopes. */
+export const TxEnvelopeEip8141 = z.codec(Rpc, Decoded, {
+  decode: core_TxEnvelopeEip8141.fromRpc,
+  encode: core_TxEnvelopeEip8141.toRpc,
+})
+
+/** Encode-only EIP-8141 envelope codec accepting numberish values. */
+export const TxEnvelopeEip8141ToRpc = z.codec(
+  Rpc,
+  z
+    .object(
+      fields(
+        z.union([z_Hex.Hex, z.bigint(), z.number()]),
+        z.union([z_Hex.Hex, z.bigint(), z.number()]),
+        z_Frame.DecodedToRpc,
+      ),
+    )
+    .check(
+      z.refine((value) => {
+        try {
+          core_TxEnvelopeEip8141.fromRpc(core_TxEnvelopeEip8141.toRpc(value))
+          return true
+        } catch {
+          return false
+        }
+      }, 'Invalid frame transaction'),
+    ),
+  {
+    decode: core_TxEnvelopeEip8141.fromRpc,
+    encode: core_TxEnvelopeEip8141.toRpc,
+  },
+)
+
+/** Codec between serialized and decoded EIP-8141 envelopes. */
+export const serialized = z.codec(z_Hex.Hex, Decoded, {
+  decode: (value) =>
+    core_TxEnvelopeEip8141.deserialize(
+      value as core_TxEnvelopeEip8141.Serialized,
+    ),
+  encode: core_TxEnvelopeEip8141.serialize,
+})
+
+function fields<
+  uint extends z.ZodMiniType,
+  num extends z.ZodMiniType,
+  frame extends z.ZodMiniType,
+>(uint: uint, num: num, frame: frame) {
+  return {
+    blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
+    chainId: num,
+    frames: z.readonly(z.array(frame)),
+    maxFeePerBlobGas: z.optional(uint),
+    maxFeePerGas: z.optional(uint),
+    maxPriorityFeePerGas: z.optional(uint),
+    nonce: z.optional(uint),
+    sender: z_Address.Address,
+    sidecars: z.optional(z_TxEnvelopeEip4844.Sidecars),
+    signatures: z.optional(z.readonly(z.array(z_FrameSignature.Decoded))),
+    type: z.literal('eip8141'),
+  }
+}

package/src/zod/_test/Frame.test-d.ts

@@ -0,0 +1,41 @@
+import type {
+  Frame,
+  FrameReceipt,
+  FrameSignature,
+  Transaction,
+  TxEnvelopeEip8141,
+} from 'ox'
+import { z } from 'ox/zod'
+import { expectTypeOf, test } from 'vp/test'
+
+test('frame codecs preserve core types', () => {
+  expectTypeOf<z.output<typeof z.Frame.Frame>>().toEqualTypeOf<Frame.Frame>()
+  expectTypeOf<z.input<typeof z.Frame.Frame>>().toEqualTypeOf<Frame.Rpc>()
+  expectTypeOf<
+    z.output<typeof z.FrameSignature.FrameSignature>
+  >().toEqualTypeOf<FrameSignature.FrameSignature>()
+  expectTypeOf<
+    z.input<typeof z.FrameSignature.FrameSignature>
+  >().toEqualTypeOf<FrameSignature.Rpc>()
+  expectTypeOf<
+    z.output<typeof z.TxEnvelopeEip8141.TxEnvelopeEip8141>
+  >().toEqualTypeOf<TxEnvelopeEip8141.TxEnvelopeEip8141>()
+  expectTypeOf<
+    z.input<typeof z.TxEnvelopeEip8141.TxEnvelopeEip8141>
+  >().toEqualTypeOf<TxEnvelopeEip8141.Rpc>()
+  expectTypeOf<
+    z.output<typeof z.Transaction.Eip8141>
+  >().toEqualTypeOf<Transaction.Eip8141>()
+  expectTypeOf<
+    z.input<typeof z.Transaction.Eip8141>
+  >().toEqualTypeOf<Transaction.Eip8141Rpc>()
+  expectTypeOf<z.output<typeof z.Transaction.PendingEip8141>>().toEqualTypeOf<
+    Transaction.Eip8141<true>
+  >()
+  expectTypeOf<
+    z.output<typeof z.FrameReceipt.FrameReceipt>
+  >().toEqualTypeOf<FrameReceipt.FrameReceipt>()
+  expectTypeOf<
+    z.input<typeof z.FrameReceipt.FrameReceipt>
+  >().toEqualTypeOf<FrameReceipt.Rpc>()
+})