ox 1.8.3 → 1.8.5

package/src/zod/TransactionRequest.ts

@@ -5,6 +5,7 @@ import * as z_Authorization from './Authorization.js'
 import * as z_FrameRequest from './FrameRequest.js'
 import * as z_FrameSignature from './FrameSignature.js'
 import * as z_Hex from './Hex.js'
+import { nonceKeys, nonceKeysToRpc, validNonce } from './internal/Frame.js'
 import * as z_Number from './Number.js'
 import * as z_Uint from './Uint.js'
 import * as z from 'zod/mini'
@@ -33,31 +34,44 @@ 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,
-    z_FrameRequest.FrameRequest,
-  ),
-)
+export const TransactionRequest = z
+  .object(
+    fields(
+      z_Uint.Uint,
+      z_Number.Number,
+      z_Authorization.ListSigned,
+      z_FrameRequest.FrameRequest,
+      nonceKeys,
+    ),
+  )
+  .check(z.refine(validNonce, 'Invalid keyed nonce'))
 
 /** Encode-only transaction request schema accepting numberish `toRpc` inputs. */
-export const TransactionRequestToRpc = z.object(
-  fields(
-    z_Uint.UintToRpc,
-    z_Number.NumberToRpc,
-    z_Authorization.ListSignedToRpc,
-    z_FrameRequest.FrameRequestToRpc,
-  ),
-)
+export const TransactionRequestToRpc = z
+  .object(
+    fields(
+      z_Uint.UintToRpc,
+      z_Number.NumberToRpc,
+      z_Authorization.ListSignedToRpc,
+      z_FrameRequest.FrameRequestToRpc,
+      nonceKeysToRpc,
+    ),
+  )
+  .check(z.refine(validNonce, 'Invalid keyed nonce'))
 
 function fields<
   uint extends z.ZodMiniType,
   num extends z.ZodMiniType,
   authorizationList extends z.ZodMiniType,
   frame extends z.ZodMiniType,
->(uint: uint, num: num, authorizationList: authorizationList, frame: frame) {
+  keys extends z.ZodMiniType,
+>(
+  uint: uint,
+  num: num,
+  authorizationList: authorizationList,
+  frame: frame,
+  keys: keys,
+) {
   return {
     accessList: z.optional(z_AccessList.AccessList),
     authorizationList: z.optional(authorizationList),
@@ -74,6 +88,7 @@ function fields<
     maxFeePerGas: z.optional(uint),
     maxPriorityFeePerGas: z.optional(uint),
     nonce: z.optional(uint),
+    nonceKeys: z.optional(keys),
     signatures: z.optional(
       z.readonly(z.array(z_FrameSignature.FrameSignature)),
     ),

package/src/zod/TxEnvelopeEip8141.ts

@@ -25,6 +25,7 @@ export const Rpc = z
     maxFeePerGas: z_Hex.Hex,
     maxPriorityFeePerGas: z_Hex.Hex,
     nonce: z_Hex.Hex,
+    nonceKeys: z.optional(z.readonly(z.array(z_Hex.Hex))),
     signatures: z.readonly(z.array(z_FrameSignature.Rpc)),
     type: z.literal('0x6'),
   })
@@ -94,6 +95,7 @@ function fields<
     maxFeePerGas: z.optional(uint),
     maxPriorityFeePerGas: z.optional(uint),
     nonce: z.optional(uint),
+    nonceKeys: z.optional(z.readonly(z.array(uint))),
     sender: z_Address.Address,
     sidecars: z.optional(z_TxEnvelopeEip4844.Sidecars),
     signatures: z.optional(z.readonly(z.array(z_FrameSignature.Decoded))),

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

@@ -82,6 +82,7 @@ test('encode helpers infer params/returns by method', () => {
         | core_Block.Tag
         | core_Block.Identifier<core_Hex.Hex>
       ),
+      (readonly core_Hex.Hex[] | undefined)?,
     ]
   >()
 })
@@ -103,6 +104,7 @@ test('codecs accept a resolved item and infer params/returns', () => {
         | core_Block.Tag
         | core_Block.Identifier<core_Hex.Hex>
       ),
+      (readonly core_Hex.Hex[] | undefined)?,
     ]
   >()
 
@@ -141,3 +143,19 @@ test('from: single method returns an Item', () => {
   })
   expectTypeOf(item.method).toEqualTypeOf<'abe_foo'>()
 })
+
+test('eth_getTransactionCount nonce keys preserve wire and decoded types', () => {
+  type Params = typeof z_RpcSchema.Eth.eth_getTransactionCount.params
+  expectTypeOf<z.input<Params>[2]>().toEqualTypeOf<
+    readonly core_Hex.Hex[] | undefined
+  >()
+  expectTypeOf<z.output<Params>[2]>().toEqualTypeOf<
+    readonly (core_Hex.Hex | bigint | number)[] | undefined
+  >()
+  expectTypeOf<
+    z.input<typeof z_RpcSchema.Eth.eth_getTransactionCount.returns>
+  >().toEqualTypeOf<core_Hex.Hex>()
+  expectTypeOf<
+    z.output<typeof z_RpcSchema.Eth.eth_getTransactionCount.returns>
+  >().toEqualTypeOf<number>()
+})

package/src/zod/_test/RpcSchema.test.ts

@@ -7,6 +7,131 @@ const hash = `0x${'11'.repeat(32)}` as const
 const topic = `0x${'33'.repeat(32)}` as const
 
 describe('decodeParams', () => {
+  test.each([
+    'latest',
+    'pending',
+    '0x10',
+    { blockHash: hash },
+    { blockNumber: '0x10' },
+  ] as const)('decodes keyed nonce queries at %j', (block) => {
+    const params = z_RpcSchema.decodeParams(
+      z_RpcSchema.Eth,
+      'eth_getTransactionCount',
+      [address, block, ['0x1', '0xa']],
+    )
+    expect(params[2]).toMatchInlineSnapshot(`
+        [
+          1n,
+          10n,
+        ]
+      `)
+    expect(
+      z_RpcSchema.encodeParams(
+        z_RpcSchema.Eth,
+        'eth_getTransactionCount',
+        params,
+      ),
+    ).toEqual([address, block, ['0x1', '0xa']])
+  })
+
+  test('preserves legacy nonce query params', () => {
+    expect(
+      z_RpcSchema.decodeParams(z_RpcSchema.Eth, 'eth_getTransactionCount', [
+        address,
+        'pending',
+      ]),
+    ).toMatchInlineSnapshot(`
+      [
+        "0x0000000000000000000000000000000000000000",
+        "pending",
+      ]
+    `)
+    expect(
+      z_RpcSchema.decodeParams(z_RpcSchema.Eth, 'eth_getTransactionCount', [
+        address,
+        'pending',
+        ['0x0'],
+      ]),
+    ).toMatchInlineSnapshot(`
+      [
+        "0x0000000000000000000000000000000000000000",
+        "pending",
+        [
+          0n,
+        ],
+      ]
+    `)
+  })
+
+  test('accepts nonce key limits', () => {
+    expect(
+      z_RpcSchema.decodeParams(z_RpcSchema.Eth, 'eth_getTransactionCount', [
+        address,
+        'latest',
+        [`0x${'f'.repeat(64)}`],
+      ])[2],
+    ).toMatchInlineSnapshot(`
+      [
+        115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+      ]
+    `)
+    expect(
+      z_RpcSchema.decodeParams(z_RpcSchema.Eth, 'eth_getTransactionCount', [
+        address,
+        'latest',
+        Array.from(
+          { length: 16 },
+          (_, i) => `0x${(i + 1).toString(16)}` as const,
+        ),
+      ])[2]?.length,
+    ).toMatchInlineSnapshot(`16`)
+  })
+
+  test.each(
+    [
+      [],
+      ['0x1', '0x1'],
+      ['0x2', '0x1'],
+      ['0x0', '0x1'],
+      ['0x01'],
+      ['0x'],
+      ['0xg'],
+      [`0x1${'0'.repeat(64)}`],
+      Array.from(
+        { length: 17 },
+        (_, i) => `0x${(i + 1).toString(16)}` as const,
+      ),
+      [1],
+      '0x1',
+      null,
+    ].map((keys) => ({ keys })),
+  )('rejects invalid nonce keys $keys', ({ keys }) => {
+    expect(
+      z.safeParse(z_RpcSchema.Eth.eth_getTransactionCount.params, [
+        address,
+        'latest',
+        keys,
+      ]).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+
+  test('rejects misplaced nonce keys and extra parameters', () => {
+    expect(
+      z.safeParse(z_RpcSchema.Eth.eth_getTransactionCount.params, [
+        address,
+        ['0x1'],
+      ]).success,
+    ).toMatchInlineSnapshot(`false`)
+    expect(
+      z.safeParse(z_RpcSchema.Eth.eth_getTransactionCount.params, [
+        address,
+        'latest',
+        ['0x1'],
+        '0x2',
+      ]).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+
   test('decodes params (block number / tag coercion)', () => {
     expect(
       z_RpcSchema.decodeParams(z_RpcSchema.Eth, 'eth_getBlockByNumber', [
@@ -149,6 +274,38 @@ describe('decodeReturns', () => {
 })
 
 describe('encodeParams', () => {
+  test('encodes nonce keys as canonical quantities', () => {
+    expect(
+      z_RpcSchema.encodeParams(z_RpcSchema.Eth, 'eth_getTransactionCount', [
+        address,
+        'pending',
+        [1n, 10, '0x10'],
+      ]),
+    ).toMatchInlineSnapshot(`
+      [
+        "0x0000000000000000000000000000000000000000",
+        "pending",
+        [
+          "0x1",
+          "0xa",
+          "0x10",
+        ],
+      ]
+    `)
+  })
+
+  test('rejects unordered nonce keys when encoding', () => {
+    expect(() =>
+      z_RpcSchema.encodeParams(z_RpcSchema.Eth, 'eth_getTransactionCount', [
+        address,
+        'pending',
+        [2n, 1n],
+      ]),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[FrameNonce.InvalidError: Nonce keys must be strictly increasing.]`,
+    )
+  })
+
   test('encodes params (native → wire)', () => {
     expect(
       z_RpcSchema.encodeParams(z_RpcSchema.Eth, 'eth_getBlockByNumber', [

package/src/zod/_test/TxEnvelopeEip8141.nonce.test.ts

@@ -0,0 +1,174 @@
+import { TxEnvelopeEip8141 } from 'ox'
+import { z } from 'ox/zod'
+import { describe, expect, test } from 'vp/test'
+
+const envelope = TxEnvelopeEip8141.from({
+  chainId: 1,
+  frames: [{}],
+  sender: '0x1111111111111111111111111111111111111111',
+  nonceKeys: [1n, 2n ** 256n - 1n],
+  nonce: 2n ** 64n - 2n,
+})
+const rpc = TxEnvelopeEip8141.toRpc(envelope)
+
+describe('TxEnvelopeEip8141', () => {
+  test('retains keyed nonces through envelope codecs', () => {
+    const decoded = z.decode(z.TransactionEnvelope.TransactionEnvelope, rpc)
+    expect(decoded).toEqual(TxEnvelopeEip8141.fromRpc(rpc))
+    expect(
+      z.encode(z.TransactionEnvelope.TransactionEnvelope, envelope),
+    ).toEqual(rpc)
+    expect(
+      z.encode(z.TransactionEnvelope.TransactionEnvelopeToRpc, {
+        ...envelope,
+        nonceKeys: ['0x1', 2n ** 256n - 1n],
+        nonce: '0xfffffffffffffffe',
+      }),
+    ).toEqual(rpc)
+    const serialized = z.encode(z.TransactionEnvelope.serialized, envelope)
+    expect(z.decode(z.TransactionEnvelope.serialized, serialized)).toEqual(
+      decoded,
+    )
+    expect(z.encode(z.TransactionEnvelope.Signed, envelope)).toEqual(rpc)
+  })
+
+  test.each([
+    { nonceKeys: [] },
+    { nonceKeys: ['0x0', '0x1'] },
+    { nonceKeys: ['0x2', '0x1'] },
+    { nonceKeys: ['0x1', '0x1'] },
+    { nonceKeys: ['0x01'] },
+    { nonceKeys: ['0x0'], nonce: '0xffffffffffffffff' },
+    { nonce: '0x10000000000000000' },
+    { nonce: '0x00' },
+    { nonce: undefined },
+    { nonceKeys: null },
+  ])('rejects invalid keyed RPC envelope %#', (fields) => {
+    expect(
+      z.safeDecode(z.TxEnvelopeEip8141.TxEnvelopeEip8141, {
+        ...rpc,
+        ...fields,
+      } as never).success,
+    ).toBe(false)
+  })
+
+  test('rejects invalid decoded and numberish keys', () => {
+    for (const keys of [[], [0n, 1n], [2n, 1n], [1n, 1n], [2n ** 256n]]) {
+      expect(
+        z.safeEncode(z.TxEnvelopeEip8141.TxEnvelopeEip8141, {
+          ...envelope,
+          nonceKeys: keys,
+        }).success,
+      ).toBe(false)
+      expect(
+        z.safeEncode(z.TxEnvelopeEip8141.TxEnvelopeEip8141ToRpc, {
+          ...envelope,
+          nonceKeys: keys,
+        }).success,
+      ).toBe(false)
+    }
+  })
+})
+
+describe('TransactionRequest', () => {
+  test('retains keys while leaving sequence and frame limits unassigned', () => {
+    const input = {
+      type: '0x6',
+      nonceKeys: ['0x1', '0x2'],
+      frames: [{ mode: '0x2' }, { mode: '0x2', executionGas: '0x0' }],
+    } as const
+    const decoded = z.decode(z.TransactionRequest.TransactionRequest, input)
+    expect(decoded.nonceKeys).toMatchInlineSnapshot(`
+      [
+        1n,
+        2n,
+      ]
+    `)
+    expect(decoded.nonce).toBeUndefined()
+    expect(decoded.frames?.map((frame) => frame.executionGas)).toEqual([
+      undefined,
+      0n,
+    ])
+    const encoded = z.encode(z.TransactionRequest.TransactionRequest, decoded)
+    expect(encoded.nonceKeys).toEqual(input.nonceKeys)
+    expect(encoded.nonce).toBeUndefined()
+    expect(
+      z.encode(z.TransactionRequest.TransactionRequestToRpc, {
+        nonceKeys: [1, '0x2'],
+        nonce: 0,
+      }).nonceKeys,
+    ).toEqual(input.nonceKeys)
+  })
+  test.each([[], ['0x0', '0x1'], ['0x2', '0x1'], ['0x01'], ['0x1', '0x1']])(
+    'rejects invalid keys %#',
+    (...nonceKeys) => {
+      expect(
+        z.safeDecode(z.TransactionRequest.TransactionRequest, {
+          nonceKeys,
+        } as never).success,
+      ).toBe(false)
+    },
+  )
+  test('rejects an exhausted sequence', () => {
+    expect(
+      z.safeDecode(z.TransactionRequest.TransactionRequest, {
+        nonceKeys: ['0x1'],
+        nonce: '0xffffffffffffffff',
+      }).success,
+    ).toBe(false)
+    expect(
+      z.safeEncode(z.TransactionRequest.TransactionRequestToRpc, {
+        nonceKeys: [1],
+        nonce: '0xffffffffffffffff',
+      }).success,
+    ).toBe(false)
+  })
+})
+
+describe('Transaction', () => {
+  const pending = {
+    ...rpc,
+    blockHash: null,
+    blockNumber: null,
+    transactionIndex: null,
+    hash: `0x${'11'.repeat(32)}`,
+  } as const
+  const mined = {
+    ...pending,
+    blockHash: `0x${'22'.repeat(32)}`,
+    blockNumber: '0x1',
+    transactionIndex: '0x0',
+  } as const
+  test('preserves pending and mined keyed transaction results', () => {
+    const decoded = z.decode(z.Transaction.PendingEip8141, pending)
+    expect(decoded.nonceKeys).toEqual(envelope.nonceKeys)
+    expect(z.encode(z.Transaction.PendingEip8141, decoded)).toEqual(pending)
+    const result = z.decode(z.Transaction.Transaction, mined)
+    expect('nonceKeys' in result && result.nonceKeys).toEqual(
+      envelope.nonceKeys,
+    )
+    expect(z.encode(z.Transaction.Transaction, result)).toEqual(mined)
+    expect(z.encode(z.Transaction.TransactionToRpc, result)).toEqual(mined)
+  })
+  test('rejects invalid keyed transaction results', () => {
+    for (const fields of [
+      { nonceKeys: ['0x2', '0x1'] },
+      { nonceKeys: ['0x0', '0x1'] },
+      { nonce: '0xffffffffffffffff' },
+      { nonce: undefined },
+    ]) {
+      expect(
+        z.safeDecode(z.Transaction.Transaction, {
+          ...mined,
+          ...fields,
+        } as never).success,
+      ).toBe(false)
+      expect(
+        z.safeDecode(z.Transaction.PendingEip8141, {
+          ...pending,
+          ...fields,
+        } as never).success,
+      ).toBe(false)
+    }
+  })
+})

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

@@ -0,0 +1,29 @@
+import type { Transaction, TransactionRequest, TxEnvelopeEip8141 } from 'ox'
+import { z } from 'ox/zod'
+import { describe, expectTypeOf, test } from 'vp/test'
+
+describe('TxEnvelopeEip8141', () => {
+  test('nonce keys preserve decoded, RPC, and numberish types', () => {
+    expectTypeOf<
+      z.output<typeof z.TxEnvelopeEip8141.Decoded>
+    >().toEqualTypeOf<TxEnvelopeEip8141.TxEnvelopeEip8141>()
+    expectTypeOf<
+      z.input<typeof z.TxEnvelopeEip8141.TxEnvelopeEip8141>
+    >().toEqualTypeOf<TxEnvelopeEip8141.Rpc>()
+    expectTypeOf<
+      z.output<typeof z.TxEnvelopeEip8141.TxEnvelopeEip8141ToRpc>
+    >().toMatchTypeOf<TxEnvelopeEip8141.toRpc.Input>()
+    expectTypeOf<
+      z.output<typeof z.TransactionRequest.TransactionRequest>['nonceKeys']
+    >().toEqualTypeOf<TransactionRequest.TransactionRequest['nonceKeys']>()
+    expectTypeOf<
+      z.input<typeof z.TransactionRequest.TransactionRequest>['nonceKeys']
+    >().toEqualTypeOf<TransactionRequest.Rpc['nonceKeys']>()
+    expectTypeOf<
+      z.output<typeof z.Transaction.Eip8141>['nonceKeys']
+    >().toEqualTypeOf<Transaction.Eip8141['nonceKeys']>()
+    expectTypeOf<
+      z.input<typeof z.Transaction.Eip8141>['nonceKeys']
+    >().toEqualTypeOf<Transaction.Eip8141Rpc['nonceKeys']>()
+  })
+})

package/src/zod/internal/Frame.ts

@@ -1,5 +1,6 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 import * as Hex from '../../core/Hex.js'
+import * as FrameNonce from '../../core/internal/frameNonce.js'
 import * as Quantity from '../../core/internal/quantity.js'
 import { quantityHex, uintBigint, uintNumber } from './Integer.js'
 import * as z from 'zod/mini'
@@ -24,3 +25,47 @@ export const chainIdToRpc = z.codec(
     encode: (value) => Quantity.fromNumberish(value),
   },
 )
+
+export const nonceKeysRpc = z.readonly(z.array(quantityHex(256))).check(
+  z.refine((keys) => {
+    try {
+      FrameNonce.fromRpc(keys)
+      return true
+    } catch {
+      return false
+    }
+  }, 'Invalid nonce keys'),
+)
+
+export const nonceKeys = z.codec(
+  nonceKeysRpc,
+  z.readonly(z.array(uintBigint(256))),
+  {
+    decode: (keys) => FrameNonce.fromRpc(keys),
+    encode: (keys) => FrameNonce.toRpc(keys),
+  },
+)
+
+export const nonceKeysToRpc = z.codec(
+  nonceKeysRpc,
+  z.readonly(
+    z.array(z.union([quantityHex(256), uintBigint(256), uintNumber()])),
+  ),
+  {
+    decode: (keys) => FrameNonce.fromRpc(keys),
+    encode: (keys) => FrameNonce.toRpc(keys),
+  },
+)
+
+export function validNonce(value: {
+  nonceKeys?: readonly (Hex.Hex | bigint | number)[] | undefined
+  nonce?: Hex.Hex | bigint | number | undefined
+}): boolean {
+  if (value.nonceKeys === undefined) return true
+  try {
+    FrameNonce.toRpc(value.nonceKeys, value.nonce)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/zod/internal/rpcSchemas/Eth.ts

@@ -15,6 +15,7 @@ import * as z_TransactionReceipt from '../../TransactionReceipt.js'
 import * as z_TransactionRequest from '../../TransactionRequest.js'
 import * as z_Uint from '../../Uint.js'
 import * as z from 'zod/mini'
+import * as Frame from '../Frame.js'
 import { from } from './from.js'
 
 const NoParams = z.optional(z.tuple([]))
@@ -214,7 +215,11 @@ export const eth_getTransactionByHash = from({
 
 export const eth_getTransactionCount = from({
   method: 'eth_getTransactionCount',
-  params: z.tuple([z_Address.Address, BlockNumberOrTagOrIdentifier]),
+  params: z.tuple([
+    z_Address.Address,
+    BlockNumberOrTagOrIdentifier,
+    z.optional(Frame.nonceKeysToRpc),
+  ]),
   returns: z_Number.Number,
 })