ox 1.8.3 → 1.8.4

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/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
+  }
+}