ox 1.8.1 → 1.8.3

package/src/core/_test/TxEnvelopeEip8141.test.ts

@@ -245,7 +245,7 @@ describe('assert', () => {
     expect(() =>
       TxEnvelopeEip8141.assert({
         chainId: 1,
-        frames: [{ gas: 2n ** 64n - 1n }, { stateGas: 1n }],
+        frames: [{ executionGas: 2n ** 64n - 1n }, { stateGas: 1n }],
         sender: accounts[0].address,
       }),
     ).toThrowErrorMatchingInlineSnapshot(
@@ -257,7 +257,7 @@ describe('assert', () => {
     expect(() =>
       TxEnvelopeEip8141.assert({
         chainId: 1,
-        frames: [{ gas: 16_777_216n }],
+        frames: [{ executionGas: 16_777_216n }],
         sender: accounts[0].address,
       }),
     ).toThrowErrorMatchingInlineSnapshot(
@@ -354,8 +354,8 @@ describe('deserialize', () => {
         "frames": [
           {
             "data": "0x",
+            "executionGas": 0n,
             "flags": 0,
-            "gas": 0n,
             "mode": 0,
             "stateGas": 0n,
             "value": 0n,
@@ -450,7 +450,7 @@ describe('from', () => {
     expect(
       TxEnvelopeEip8141.from({
         chainId: 1,
-        frames: [{ gas: 50000n }],
+        frames: [{ executionGas: 50000n }],
         sender: accounts[0].address,
       }),
     ).toMatchInlineSnapshot(`
@@ -458,7 +458,7 @@ describe('from', () => {
         "chainId": 1,
         "frames": [
           {
-            "gas": 50000n,
+            "executionGas": 50000n,
           },
         ],
         "sender": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
@@ -479,8 +479,8 @@ describe('from', () => {
         "frames": [
           {
             "data": "0x",
+            "executionGas": 0n,
             "flags": 0,
-            "gas": 0n,
             "mode": 0,
             "stateGas": 0n,
             "value": 0n,
@@ -499,16 +499,43 @@ describe('from', () => {
 })
 
 describe('getSignPayload', () => {
+  test.each([
+    { scheme: 'secp256k1', signature: '0x' },
+    { scheme: 'p256', signature: '0x' },
+  ] as const)(
+    'empty $scheme placeholders preserve the signing hash',
+    (entry) => {
+      const { signature: _, ...unsigned } = entry
+      const envelope = {
+        chainId: 1,
+        frames: [{ executionGas: 50_000n, mode: 'sender' }],
+        sender: accounts[0].address,
+        signatures: [unsigned],
+      } as const
+      const input = {
+        ...envelope,
+        signatures: [entry],
+      } as const
+      expect(TxEnvelopeEip8141.getSignPayload(input)).toBe(
+        TxEnvelopeEip8141.getSignPayload(envelope),
+      )
+      expect(TxEnvelopeEip8141.serialize(input)).toBe(
+        TxEnvelopeEip8141.serialize(envelope),
+      )
+      expect(input.signatures[0].signature).toBe('0x')
+    },
+  )
+
   test('omitted nested defaults preserve the signing hash and encoding', () => {
     const envelope = TxEnvelopeEip8141.from({
       chainId: 1,
-      frames: [{ gas: 50_000n, mode: 'sender' }],
+      frames: [{ executionGas: 50_000n, mode: 'sender' }],
       sender: accounts[0].address,
       signatures: [{ scheme: 'secp256k1' }],
     })
     const explicit = TxEnvelopeEip8141.from({
       ...envelope,
-      frames: [Frame.from({ gas: 50_000n, mode: 'sender' })],
+      frames: [Frame.from({ executionGas: 50_000n, mode: 'sender' })],
       signatures: [FrameSignature.from({ scheme: 'secp256k1' })],
     })
     expect(TxEnvelopeEip8141.getSignPayload(envelope)).toBe(
@@ -630,26 +657,26 @@ describe('serialize', () => {
       const request = TransactionRequest.toRpc({
         frames: [
           Frame.from({
+            executionGas: 50_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
+            stateGas: 0n,
+          }),
+          Frame.from({
+            executionGas: 50_000n,
+            mode: 'sender',
+            stateGas: 0n,
+            to: target,
+            value: 1n,
           }),
-          Frame.from({ gas: 50_000n, mode: 'sender', to: target, value: 1n }),
         ],
         from: sender,
         signatures: [{ scheme: 'secp256k1' }],
-        // Nethermind's simulation mapping requires an outer recipient before processing frames.
-        to: sender,
         type: 'eip8141',
       })
-      // TODO: remove once migrated to reth or anvil.
-      // Nethermind validates signatures when filling gas, before the transaction can be signed.
-      await expect(
-        rpc.request({ method: 'eth_fillTransaction', params: [request] }),
-      ).rejects.toThrow('frame transaction signature has the wrong length')
       const { tx } = await rpc.request({
         method: 'eth_fillTransaction',
-        params: [{ ...request, gas: Hex.fromNumber(100_000n) }],
+        params: [request],
       })
       expect(tx.type).toBe('0x6')
       if (tx.type !== '0x6' || !tx.frames)
@@ -658,7 +685,6 @@ describe('serialize', () => {
       expect(tx.nonce).toBe(nonce)
       expect(tx.frames).toEqual(request.frames)
       expect(tx.signatures).toEqual(request.signatures)
-      expect(Hex.toBigInt(tx.gas)).toBe(100_000n)
       expect(Hex.toBigInt(tx.maxFeePerGas)).toBeGreaterThan(0n)
       expect(Hex.toBigInt(tx.maxPriorityFeePerGas)).toBeGreaterThanOrEqual(0n)
       expect(Hex.toBigInt(tx.maxFeePerGas)).toBeGreaterThanOrEqual(
@@ -728,14 +754,19 @@ describe('serialize', () => {
           chainId: 8141,
           frames: [
             Frame.from({
+              executionGas: 50_000n,
               flags: 'approveExecutionAndPayment',
-              gas: 50_000n,
               mode: 'verify',
             }),
-            Frame.from({ gas: 50_000n, mode: 'sender', to: target, value: 1n }),
+            Frame.from({
+              executionGas: 50_000n,
+              mode: 'sender',
+              to: target,
+              value: 1n,
+            }),
             Frame.from({
               data: '0xdeadbeef',
-              gas: 50_000n,
+              executionGas: 50_000n,
               mode: 'sender',
               to: '0x0000000000000000000000000000000000000004',
             }),
@@ -756,14 +787,12 @@ describe('serialize', () => {
         })
         const request = TransactionRequest.toRpc({
           ...TransactionEnvelope.toTransactionRequest(signed),
-          // Nethermind's simulation mapping requires an outer recipient before processing frames.
-          to: sender,
         })
         const result = await rpc.request({
           method,
           params: [request, 'latest'],
         })
-        // Frame return data is not exposed by Nethermind's transaction-level call result.
+        // Transaction-level calls do not expose individual frame return data.
         if (method === 'eth_call') expect(result).toBe('0x')
         else {
           // Estimation includes all signed frame budgets plus intrinsic gas.
@@ -774,11 +803,14 @@ describe('serialize', () => {
           rpc.request({
             method,
             params: [
-              { ...request, frames: [{ ...request.frames![0]!, mode: 255 }] },
+              {
+                ...request,
+                frames: [{ ...request.frames![0]!, mode: '0xff' }],
+              },
               'latest',
             ],
           }),
-        ).rejects.toThrow('frame mode')
+        ).rejects.toThrow('Invalid params')
         expect(
           await rpc.request({
             method: 'eth_getBalance',
@@ -806,11 +838,16 @@ describe('serialize', () => {
         chainId: 8141,
         frames: [
           Frame.from({
+            executionGas: 50_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
           }),
-          Frame.from({ gas: 50_000n, mode: 'sender', to: target, value: 1n }),
+          Frame.from({
+            executionGas: 50_000n,
+            mode: 'sender',
+            to: target,
+            value: 1n,
+          }),
         ],
         maxFeePerGas: 10_000_000_000n,
         maxPriorityFeePerGas: 1_000_000_000n,
@@ -840,10 +877,12 @@ describe('serialize', () => {
       })
       expect(hash).toBe(TransactionEnvelope.hash(signed))
       expect(
-        TransactionRequest.toEnvelope(
-          TransactionEnvelope.toTransactionRequest(signed),
+        TransactionEnvelope.serialize(
+          TransactionRequest.toEnvelope(
+            TransactionEnvelope.toTransactionRequest(signed),
+          ),
         ),
-      ).toEqual(signed)
+      ).toBe(serialized)
       expect(TxEnvelopeEip8141.toRpc(signed)).toMatchObject(
         TransactionRequest.toRpc(
           TransactionEnvelope.toTransactionRequest(signed),
@@ -939,18 +978,18 @@ describe('serialize', () => {
         chainId: 8141,
         frames: [
           Frame.from({
+            executionGas: 20_000n,
             flags: 'approveExecution',
-            gas: 50_000n,
             mode: 'verify',
           }),
           Frame.from({
+            executionGas: 20_000n,
             flags: 'approvePayment',
-            gas: 50_000n,
             mode: 'verify',
             to: accounts[1].address,
           }),
           Frame.from({
-            gas: 50_000n,
+            executionGas: 20_000n,
             mode: 'sender',
             to: accounts[1].address,
             value: 1n,
@@ -1045,25 +1084,25 @@ describe('serialize', () => {
         chainId: 8141,
         frames: [
           Frame.from({
+            executionGas: 50_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
           }),
           Frame.from({
+            executionGas: 50_000n,
             flags: 'atomicBatch',
-            gas: 50_000n,
             mode: 'sender',
             to: accounts[1].address,
             value: 1n,
           }),
           Frame.from({
+            executionGas: 50_000n,
             flags: 'atomicBatch',
-            gas: 50_000n,
             mode: 'sender',
             to: '0x0000000000000000000000000000000000001000',
           }),
           Frame.from({
-            gas: 50_000n,
+            executionGas: 50_000n,
             mode: 'sender',
             to: accounts[1].address,
             value: 2n,
@@ -1131,8 +1170,8 @@ describe('serialize', () => {
         chainId: 8141,
         frames: [
           Frame.from({
+            executionGas: 50_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
           }),
         ],
@@ -1166,7 +1205,7 @@ describe('serialize', () => {
           ],
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `[RpcResponse.InvalidInputError: transaction invalid, frame transaction SECP256K1 signer does not match the recovered address]`,
+        `[RpcResponse.InvalidInputError: EIP-8141 public mempool policy: validation prefix execution failed]`,
       )
     })
 
@@ -1176,13 +1215,13 @@ describe('serialize', () => {
         frames: [
           Frame.from({
             data: '0x0000000000000001',
-            gas: 50_000n,
+            executionGas: 20_000n,
             mode: 'verify',
             to: '0x0000000000000000000000000000000000008141',
           }),
           Frame.from({
+            executionGas: 20_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
           }),
         ],
@@ -1213,7 +1252,7 @@ describe('serialize', () => {
           params: [TxEnvelopeEip8141.serialize(signed)],
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `[RpcResponse.InvalidInputError: frame transaction expired]`,
+        `[RpcResponse.InvalidInputError: EIP-8141 public mempool policy: validation prefix execution failed]`,
       )
     })
 
@@ -1226,12 +1265,12 @@ describe('serialize', () => {
         chainId: 8141,
         frames: [
           Frame.from({
+            executionGas: 50_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
           }),
           Frame.from({
-            gas: 50_000n,
+            executionGas: 50_000n,
             mode: 'sender',
             to: accounts[1].address,
             value: 1n,
@@ -1613,7 +1652,7 @@ describe('validate', () => {
     expect(
       TxEnvelopeEip8141.validate({
         chainId: 1,
-        frames: [{ gas: 2n ** 64n - 1n }, { stateGas: 1n }],
+        frames: [{ executionGas: 2n ** 64n - 1n }, { stateGas: 1n }],
         sender: accounts[0].address,
       }),
     ).toBe(false)
@@ -1623,7 +1662,7 @@ describe('validate', () => {
     expect(
       TxEnvelopeEip8141.validate({
         chainId: 1,
-        frames: [{ gas: 16_777_216n }],
+        frames: [{ executionGas: 16_777_216n }],
         sender: accounts[0].address,
       }),
     ).toBe(false)
@@ -1706,7 +1745,7 @@ describe('validate', () => {
 
     const frame = {
       data: '0x0000000000000001',
-      gas: 5000n,
+      executionGas: 5000n,
       mode: 'verify',
       to: '0x0000000000000000000000000000000000008141',
     } as const
@@ -1738,10 +1777,10 @@ describe('toRpc', () => {
       frames: [
         {
           data: '0x',
-          executionGasLimit: '0x0',
-          flags: 0,
-          mode: 0,
-          stateGasLimit: '0x0',
+          executionGas: '0x0',
+          flags: '0x0',
+          mode: '0x0',
+          stateGas: '0x0',
           value: '0x0',
         },
       ],

package/src/core/_test/index.test.ts

@@ -43,6 +43,7 @@ test('exports', () => {
       "Filter",
       "Frame",
       "FrameReceipt",
+      "FrameRequest",
       "FrameSignature",
       "Hash",
       "HdKey",

package/src/core/internal/rpcSchemas/eth.ts

@@ -4,6 +4,7 @@ import type * as Block from '../../Block.js'
 import type * as BlockOverrides from '../../BlockOverrides.js'
 import type * as Fee from '../../Fee.js'
 import type * as Filter from '../../Filter.js'
+import type * as FrameReceipt from '../../FrameReceipt.js'
 import type * as Hex from '../../Hex.js'
 import type * as Log from '../../Log.js'
 import type * as RpcSchema from '../../RpcSchema.js'
@@ -11,6 +12,7 @@ import type * as StateOverrides from '../../StateOverrides.js'
 import type * as Transaction from '../../Transaction.js'
 import type * as TransactionReceipt from '../../TransactionReceipt.js'
 import type * as TransactionRequest from '../../TransactionRequest.js'
+import type * as TxEnvelope from '../../TxEnvelope.js'
 
 /**
  * Union of all JSON-RPC Methods for the `eth_` namespace.
@@ -219,12 +221,12 @@ export type Eth = RpcSchema.From<
       ReturnType: Fee.FeeHistoryRpc
     }
   /**
-   * Fills the defaults (nonce, gas, gasPrice, or 1559 fields) on a given unsigned transaction, and returns the unsigned transaction along with its raw form
+   * Fills transaction defaults and returns the unsigned transaction.
    *
    * @example
    * ```
    * request({ method: 'eth_fillTransaction', params: [{ from: '0x...', to: '0x...', value: '0x...' }] })
-   * // { raw: '0x...', tx: { ... } }
+   * // { tx: { ... } }
    * ```
    */
   | {
@@ -234,8 +236,8 @@ export type Eth = RpcSchema.From<
       }
       ReturnType: {
         capabilities?: Record<string, unknown> | undefined
-        raw: Hex.Hex
-        tx: Transaction.Rpc
+        raw?: Hex.Hex | undefined
+        tx: TxEnvelope.Rpc & { from: Address.Address }
       }
     }
   /**
@@ -769,6 +771,13 @@ export type Eth = RpcSchema.From<
                     message: string
                   }
                 | undefined
+              frameResults?:
+                | readonly (FrameReceipt.Rpc & {
+                    error?: { code: number; message: string } | undefined
+                    returnData: Hex.Hex
+                  })[]
+                | undefined
+              payer?: Address.Address | undefined
               logs?: readonly Log.Rpc[] | undefined
               gasUsed: Hex.Hex
               returnData: Hex.Hex

package/src/index.ts

@@ -1618,13 +1618,13 @@ export * as Filter from './core/Filter.js'
  * import { Frame } from 'ox'
  *
  * const frame = Frame.from({
+ *   executionGas: 50_000n,
  *   flags: 'approveExecutionAndPayment',
- *   gas: 50_000n,
  *   mode: 'verify'
  * })
  * ```
  *
- * @category Transaction Envelopes
+ * @category Frames (EIP-8141)
  */
 export * as Frame from './core/Frame.js'
 
@@ -1633,10 +1633,27 @@ export * as Frame from './core/Frame.js'
  *
  * Frame receipts include execution gas, state gas, logs, and execution status.
  *
- * @category Execution Spec
+ * @category Frames (EIP-8141)
  */
 export * as FrameReceipt from './core/FrameReceipt.js'
 
+/**
+ * Convert EIP-8141 frame requests while preserving omitted gas limits for node estimation.
+ *
+ * @example
+ * ```ts twoslash
+ * import { FrameRequest } from 'ox'
+ *
+ * const frame = FrameRequest.toRpc({
+ *   mode: 'sender',
+ *   stateGas: 0n
+ * })
+ * ```
+ *
+ * @category Frames (EIP-8141)
+ */
+export * as FrameRequest from './core/FrameRequest.js'
+
 /**
  * Utilities for constructing, validating, and encoding [EIP-8141](https://eips.ethereum.org/EIPS/eip-8141) signature entries.
  *
@@ -1656,7 +1673,7 @@ export * as FrameReceipt from './core/FrameReceipt.js'
  * // @log: { payload: '0x', scheme: 'arbitrary', signature: '0xaabb' }
  * ```
  *
- * @category Transaction Envelopes
+ * @category Frames (EIP-8141)
  */
 export * as FrameSignature from './core/FrameSignature.js'
 
@@ -3580,7 +3597,7 @@ export * as TxEnvelopeEip7702 from './core/TxEnvelopeEip7702.js'
  *
  * const envelope = TxEnvelopeEip8141.from({
  *   chainId: 1,
- *   frames: [{ gas: 50_000n, mode: 'sender' }],
+ *   frames: [{ executionGas: 50_000n, mode: 'sender' }],
  *   sender: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8'
  * })
  * ```

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.8.1'
+export const version = '1.8.3'

package/src/zod/Frame.ts

@@ -25,10 +25,10 @@ export const Decoded: z.ZodMiniType<core_Frame.Frame, core_Frame.Frame> = z
 export const Rpc = z
   .object({
     data: z_Hex.Hex,
-    executionGasLimit: z_Hex.Hex,
-    flags: z.number(),
-    mode: z.number(),
-    stateGasLimit: z_Hex.Hex,
+    executionGas: z_Hex.Hex,
+    flags: z_Hex.Hex,
+    mode: z_Hex.Hex,
+    stateGas: z_Hex.Hex,
     target: z.optional(z.nullable(z_Address.Address)),
     value: z_Hex.Hex,
   })
@@ -72,8 +72,8 @@ export const FrameToRpc = z.codec(Rpc, DecodedToRpc, {
 function fields<uint extends z.ZodMiniType>(uint: uint) {
   return {
     data: z.optional(z_Hex.Hex),
+    executionGas: z.optional(uint),
     flags: z.optional(Flags),
-    gas: z.optional(uint),
     mode: z.optional(Mode),
     stateGas: z.optional(uint),
     to: z.optional(z_Address.Address),

package/src/zod/FrameReceipt.ts

@@ -11,17 +11,26 @@ import * as z from 'zod/mini'
 
 const frameLog = z.object({
   address: z_Address.Address,
+  blockHash: z.optional(z_Hex.Hex),
+  blockNumber: z.optional(quantityHex()),
+  blockTimestamp: z.optional(quantityHex()),
   data: z_Hex.Hex,
+  logIndex: z.optional(quantityHex()),
+  removed: z.optional(z.boolean()),
   topics: z.array(z_Hex.Hex),
+  transactionHash: z.optional(z_Hex.Hex),
+  transactionIndex: z.optional(quantityHex()),
 })
 
 const frameReceiptRpc = z.object({
   executionGasUsed: quantityHex(),
+  gasUsed: quantityHex(),
   logs: z.readonly(z.array(frameLog)),
   stateGasUsed: quantityHex(),
-  status: z.union([z.literal(0), z.literal(1), z.literal(2)]),
+  status: z.enum(['0x0', '0x1', '0x2']),
 })
 const frameReceiptDecoded = z.object({
+  executionGasUsed: uintBigint(),
   gasUsed: uintBigint(),
   logs: z.readonly(z.array(frameLog)),
   stateGasUsed: uintBigint(),
@@ -38,6 +47,7 @@ export const FrameReceipt = z.codec(frameReceiptRpc, frameReceiptDecoded, {
 export const FrameReceiptToRpc = z.codec(
   frameReceiptRpc,
   z.extend(frameReceiptDecoded, {
+    executionGasUsed: uintBigintNumberish(),
     gasUsed: uintBigintNumberish(),
     stateGasUsed: uintBigintNumberish(),
   }),

package/src/zod/FrameRequest.ts

@@ -0,0 +1,46 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as core_FrameRequest from '../core/FrameRequest.js'
+import * as z_Address from './Address.js'
+import * as z_Frame from './Frame.js'
+import * as z_Hex from './Hex.js'
+import * as z from 'zod/mini'
+
+const quantity = z_Hex.Hex.check(
+  z.refine(
+    (value) => /^0x(0|[1-9a-f][0-9a-f]*)$/.test(value),
+    'Invalid RPC quantity',
+  ),
+)
+
+const rpc = z
+  .object({
+    data: z.optional(z_Hex.Hex),
+    executionGas: z.optional(quantity),
+    flags: z.optional(z_Hex.Hex),
+    mode: z_Hex.Hex,
+    stateGas: z.optional(quantity),
+    target: z.optional(z.nullable(z_Address.Address)),
+    value: z.optional(quantity),
+  })
+  .check(
+    z.refine((value) => {
+      try {
+        core_FrameRequest.fromRpc(value)
+        return true
+      } catch {
+        return false
+      }
+    }, 'Invalid frame request'),
+  )
+
+/** Codec between RPC and decoded frame requests, preserving omitted gas limits. */
+export const FrameRequest = z.codec(rpc, z_Frame.Decoded, {
+  decode: core_FrameRequest.fromRpc,
+  encode: core_FrameRequest.toRpc,
+})
+
+/** Encode-only frame request codec accepting numberish gas and value. */
+export const FrameRequestToRpc = z.codec(rpc, z_Frame.DecodedToRpc, {
+  decode: core_FrameRequest.fromRpc,
+  encode: core_FrameRequest.toRpc,
+})

package/src/zod/FrameSignature.ts

@@ -24,7 +24,10 @@ 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() }),
+    z.union([
+      z_Hex.Hex,
+      z.object({ r: z_Hex.Hex, s: z_Hex.Hex, yParity: z.number() }),
+    ]),
   ),
   signer: z.optional(z_Address.Address),
 })
@@ -36,11 +39,11 @@ const p256 = {
 }
 /** P-256 frame signature schema, including unsigned placeholders. */
 export const P256 = z.union([
-  z.object({ ...p256, publicKey, signature }),
+  z.object({ ...p256, publicKey, signature: z.union([z_Hex.Hex, signature]) }),
   z.object({
     ...p256,
     publicKey: z.optional(publicKey),
-    signature: z.optional(z.undefined()),
+    signature: z.optional(z.literal('0x')),
   }),
 ])
 
@@ -55,10 +58,10 @@ export const Decoded: z.ZodMiniType<
 /** 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)),
+    msg: z.optional(z_Hex.Hex),
+    scheme: z.enum(['0x0', '0x1', '0x2']),
+    signature: z.optional(z_Hex.Hex),
+    signer: z.optional(z.union([z.literal('0x'), z_Address.Address])),
   })
   .check(
     z.refine((value) => {

package/src/zod/Transaction.ts

@@ -179,18 +179,18 @@ function eip8141Fields<
     data: z.optional(z_Hex.Hex),
     frames: z.readonly(z.array(frame)),
     from: z_Address.Address,
-    gas: uint,
+    gas: z.optional(uint),
     gasPrice: z.optional(uint),
     hash: z_Hex.Hex,
-    input: z_Hex.Hex,
+    input: z.optional(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),
+    to: z.optional(z.nullable(z_Address.Address)),
     type: Eip8141Type,
-    value: uint,
+    value: z.optional(uint),
   }
 }