ox 1.8.3 → 1.8.4

package/src/core/TxEnvelopeEip8141.ts

@@ -6,12 +6,18 @@ import * as Frame from './Frame.js'
 import * as FrameSignature from './FrameSignature.js'
 import * as Hash from './Hash.js'
 import * as Hex from './Hex.js'
+import * as FrameNonce from './internal/frameNonce.js'
 import * as Quantity from './internal/quantity.js'
 import type { Assign, Compute, PartialBy } from './internal/types.js'
 import * as Rlp from './Rlp.js'
 import type * as TxEnvelopeEip4844 from './TxEnvelopeEip4844.js'
 
-/** An EIP-8141 transaction containing independently budgeted call frames. */
+/**
+ * An EIP-8141 transaction containing independently budgeted call frames.
+ *
+ * Omitted `nonceKeys` preserves the original EIP-8141 encoding. Supplying keys,
+ * including `[0n]`, selects EIP-8250 encoding and changes the signing hash.
+ */
 export type TxEnvelopeEip8141 = {
   /** Versioned blob hashes. @default [] */
   blobVersionedHashes?: readonly Hex.Hex[] | undefined
@@ -25,8 +31,10 @@ export type TxEnvelopeEip8141 = {
   maxFeePerGas?: bigint | undefined
   /** Maximum priority fee per gas, in wei. @default 0n */
   maxPriorityFeePerGas?: bigint | undefined
-  /** Sender nonce. @default 0n */
+  /** Sender nonce or shared sequence. With `nonceKeys`, the sequence must be less than 2^64 - 1. @default 0n */
   nonce?: bigint | undefined
+  /** EIP-8250 domains: 1–16 strictly increasing uint256 keys. `[0n]` selects the legacy account nonce; zero cannot accompany other keys. */
+  nonceKeys?: readonly bigint[] | undefined
   /** Account authorizing execution. */
   sender: Address.Address
   /** PeerDAS sidecars. Excluded from transaction and signing hashes. */
@@ -53,8 +61,10 @@ export type Rpc = {
   maxFeePerGas: Hex.Hex
   /** Maximum priority fee per gas. */
   maxPriorityFeePerGas: Hex.Hex
-  /** Sender nonce. */
+  /** Sender nonce or shared EIP-8250 sequence. */
   nonce: Hex.Hex
+  /** EIP-8250 domains. Omitted for the original EIP-8141 encoding. */
+  nonceKeys?: readonly Hex.Hex[] | undefined
   /** Frame signature entries. */
   signatures: readonly FrameSignature.Rpc[]
   /** RPC transaction type. */
@@ -106,6 +116,7 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
     maxFeePerGas = 0n,
     maxPriorityFeePerGas = 0n,
     nonce = 0n,
+    nonceKeys,
     sender,
     signatures = [],
   } = envelope
@@ -118,6 +129,7 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
     throw new InvalidError(
       'chainId must be an unsigned 256-bit integer; use bigint for large IDs.',
     )
+  if (nonceKeys !== undefined) FrameNonce.assert(nonceKeys, nonce)
   Address.assert(sender, { strict: false })
   for (const [field, value, bits] of [
     ['maxFeePerBlobGas', maxFeePerBlobGas, 256n],
@@ -157,6 +169,18 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
     for (const byte of Hex.toBytes(data)) tokens += byte === 0 ? 1n : 4n
     size += BigInt(Hex.size(data))
   }
+  if (nonceKeys !== undefined) {
+    count(
+      Rlp.fromHex(
+        nonceKeys.map((key) =>
+          key === 0n ? '0x' : Hex.fromBytes(Bytes.fromNumber(key)),
+        ),
+      ),
+    )
+    count(
+      Rlp.fromHex(nonce === 0n ? '0x' : Hex.fromBytes(Bytes.fromNumber(nonce))),
+    )
+  }
   for (const [index, frame] of (frames as readonly Frame.Frame[]).entries()) {
     Frame.assert(frame)
     const flags =
@@ -221,6 +245,7 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
 export declare namespace assert {
   type ErrorType =
     | InvalidError
+    | FrameNonce.InvalidError
     | Frame.assert.ErrorType
     | FrameSignature.toTuple.ErrorType
     | Address.assert.ErrorType
@@ -258,9 +283,14 @@ export function deserialize(serialized: Serialized): TxEnvelopeEip8141 {
     throw new InvalidError('Expected a transaction list.')
   const wrapped = Array.isArray(decoded[0])
   const body = wrapped ? decoded[0] : decoded
-  if (!Array.isArray(body) || body.length !== 7)
-    throw new InvalidError('Expected seven transaction fields.')
-  const [chainId, nonce, sender, frames, signatures, fees, hashes] = body
+  if (!Array.isArray(body) || (body.length !== 7 && body.length !== 8))
+    throw new InvalidError('Expected seven or eight transaction fields.')
+  const keyed = body.length === 8
+  const [chainId, ...fields] = body
+  const keys = keyed ? fields.shift() : undefined
+  if (keyed && !Array.isArray(keys))
+    throw new InvalidError('Expected a nonce key list.')
+  const [nonce, sender, frames, signatures, fees, hashes] = fields
   if (
     typeof sender !== 'string' ||
     !Array.isArray(frames) ||
@@ -288,6 +318,7 @@ export function deserialize(serialized: Serialized): TxEnvelopeEip8141 {
     maxFeePerGas: integer(fees[1]),
     maxPriorityFeePerGas: integer(fees[0]),
     nonce: integer(nonce),
+    ...(Array.isArray(keys) ? { nonceKeys: keys.map(integer) } : {}),
     sender: sender as Address.Address,
     signatures: signatures.map((entry) =>
       FrameSignature.fromTuple(entry as FrameSignature.Tuple),
@@ -403,6 +434,9 @@ export function fromRpc(envelope: Rpc): TxEnvelopeEip8141 {
     maxFeePerGas: Hex.toBigInt(envelope.maxFeePerGas),
     maxPriorityFeePerGas: Hex.toBigInt(envelope.maxPriorityFeePerGas),
     nonce: Hex.toBigInt(envelope.nonce),
+    ...(envelope.nonceKeys !== undefined
+      ? { nonceKeys: FrameNonce.fromRpc(envelope.nonceKeys, envelope.nonce) }
+      : {}),
     sender: envelope.from,
     signatures: envelope.signatures.map(FrameSignature.fromRpc),
   })
@@ -410,6 +444,7 @@ export function fromRpc(envelope: Rpc): TxEnvelopeEip8141 {
 
 export declare namespace fromRpc {
   type ErrorType =
+    | FrameNonce.InvalidError
     | from.ErrorType
     | Frame.fromRpc.ErrorType
     | FrameSignature.fromRpc.ErrorType
@@ -448,6 +483,9 @@ export function toRpc(envelope: toRpc.Input): Rpc {
       envelope.maxPriorityFeePerGas ?? 0n,
     ),
     nonce: Quantity.fromNumberish(envelope.nonce ?? 0n),
+    ...(envelope.nonceKeys !== undefined
+      ? { nonceKeys: FrameNonce.toRpc(envelope.nonceKeys, envelope.nonce) }
+      : {}),
     signatures: (envelope.signatures ?? []).map(FrameSignature.toRpc),
     type: '0x6',
   }
@@ -462,6 +500,7 @@ export declare namespace toRpc {
     | 'maxFeePerGas'
     | 'maxPriorityFeePerGas'
     | 'nonce'
+    | 'nonceKeys'
     | 'type'
   > & {
     chainId: Hex.Hex | bigint | number
@@ -470,9 +509,11 @@ export declare namespace toRpc {
     maxFeePerGas?: Hex.Hex | bigint | number | undefined
     maxPriorityFeePerGas?: Hex.Hex | bigint | number | undefined
     nonce?: Hex.Hex | bigint | number | undefined
+    nonceKeys?: readonly (Hex.Hex | bigint | number)[] | undefined
     type?: Type | undefined
   }
   type ErrorType =
+    | FrameNonce.InvalidError
     | Frame.toRpc.ErrorType
     | FrameSignature.toRpc.ErrorType
     | Hex.fromNumber.ErrorType
@@ -560,10 +601,12 @@ export function hash(
 ): Hex.Hex {
   assert(envelope)
   const body = toTuple(envelope)
-  if (options.presign)
-    body[4] = body[4].map((entry) =>
-      entry[2] === '0x' ? [entry[0], entry[1], entry[2], '0x'] : entry,
-    )
+  if (options.presign) {
+    const signatures = body.length === 8 ? body[5] : body[4]
+    for (const [index, entry] of signatures.entries())
+      if (entry[2] === '0x')
+        signatures[index] = [entry[0], entry[1], entry[2], '0x']
+  }
   return Hash.keccak256(Hex.concat(serializedType, Rlp.fromHex(body)))
 }
 export declare namespace hash {
@@ -690,8 +733,7 @@ export class InvalidError extends Errors.BaseError {
 function toTuple(envelope: PartialBy<TxEnvelopeEip8141, 'type'>) {
   const quantity = (value: bigint | number | undefined): Hex.Hex =>
     value ? Hex.fromBytes(Bytes.fromNumber(value)) : '0x'
-  return [
-    quantity(envelope.chainId),
+  const fields = [
     quantity(envelope.nonce),
     envelope.sender,
     envelope.frames.map((frame) => Frame.toTuple(frame)),
@@ -703,7 +745,6 @@ function toTuple(envelope: PartialBy<TxEnvelopeEip8141, 'type'>) {
     ],
     envelope.blobVersionedHashes ?? [],
   ] satisfies [
-    Hex.Hex,
     Hex.Hex,
     Address.Address,
     Frame.Tuple[],
@@ -711,4 +752,11 @@ function toTuple(envelope: PartialBy<TxEnvelopeEip8141, 'type'>) {
     Hex.Hex[],
     readonly Hex.Hex[],
   ]
+  return envelope.nonceKeys === undefined
+    ? ([quantity(envelope.chainId), ...fields] as const)
+    : ([
+        quantity(envelope.chainId),
+        envelope.nonceKeys.map(quantity),
+        ...fields,
+      ] as const)
 }

package/src/core/_test/TransactionEnvelope.test-d.ts

@@ -10,6 +10,33 @@ import {
 import { describe, expectTypeOf, test } from 'vp/test'
 
 describe('getType', () => {
+  test('infers frame transactions from nonce keys', () => {
+    expectTypeOf(
+      TransactionEnvelope.getType({ nonceKeys: [1n] }),
+    ).toEqualTypeOf<'eip8141'>()
+    expectTypeOf(
+      TransactionEnvelope.getType({ nonceKeys: [0n] }),
+    ).toEqualTypeOf<'eip8141'>()
+    expectTypeOf(
+      TransactionEnvelope.getType({ nonceKeys: [] }),
+    ).toEqualTypeOf<'eip8141'>()
+    expectTypeOf(
+      TransactionEnvelope.getType({
+        nonceKeys: [1n],
+        frames: undefined,
+        authorizationList: [],
+        blobVersionedHashes: [],
+        gasPrice: 1n,
+      }),
+    ).toEqualTypeOf<'eip8141'>()
+    expectTypeOf(
+      TransactionEnvelope.getType({ nonceKeys: undefined, maxFeePerGas: 1n }),
+    ).toEqualTypeOf<'eip1559'>()
+    expectTypeOf(
+      TransactionEnvelope.getType({ nonceKeys: [1n], type: 'eip1559' }),
+    ).toEqualTypeOf<'eip1559'>()
+  })
+
   test('behavior: infers explicit transaction types', () => {
     expectTypeOf(
       TransactionEnvelope.getType({ type: 'legacy' }),

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

@@ -99,6 +99,32 @@ test('exports', () => {
 })
 
 describe('getType', () => {
+  test('infers frame transactions from nonce keys', () => {
+    expect([
+      TransactionEnvelope.getType({ nonceKeys: [1n] }),
+      TransactionEnvelope.getType({ nonceKeys: [0n] }),
+      TransactionEnvelope.getType({ nonceKeys: [] }),
+      TransactionEnvelope.getType({
+        nonceKeys: [1n],
+        frames: undefined,
+        authorizationList: [],
+        blobVersionedHashes: [],
+        gasPrice: 1n,
+      }),
+      TransactionEnvelope.getType({ nonceKeys: undefined, maxFeePerGas: 1n }),
+      TransactionEnvelope.getType({ nonceKeys: [1n], type: 'eip1559' }),
+    ]).toMatchInlineSnapshot(`
+      [
+        "eip8141",
+        "eip8141",
+        "eip8141",
+        "eip8141",
+        "eip1559",
+        "eip1559",
+      ]
+    `)
+  })
+
   test('frame fields take precedence over blobs and fees', () => {
     expect(
       TransactionEnvelope.getType({

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

@@ -13,6 +13,21 @@ import { kzg } from '../../../test/kzg.js'
 import { anvilMainnet } from '../../../test/prool.js'
 
 describe('toRpc', () => {
+  test('preserves nonce keys without type or frames', () => {
+    const request = { nonceKeys: [1n, 2n], nonce: 0n }
+    const rpc = TransactionRequest.toRpc(request)
+    expect(rpc).toMatchInlineSnapshot(`
+      {
+        "nonce": "0x0",
+        "nonceKeys": [
+          "0x1",
+          "0x2",
+        ],
+      }
+    `)
+    expect(TransactionRequest.fromRpc(rpc)).toEqual(request)
+  })
+
   test('default', () => {
     const request = TransactionRequest.toRpc({
       to: '0x0000000000000000000000000000000000000000',
@@ -439,6 +454,19 @@ test('exports', () => {
 })
 
 describe('frame transactions', () => {
+  test('requires frames when nonce keys select a frame envelope', () => {
+    expect(() =>
+      TransactionRequest.toEnvelope({
+        chainId: 1,
+        from: '0x1111111111111111111111111111111111111111',
+        nonceKeys: [1n],
+        nonce: 0n,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      '[Quantity.MissingFieldError: Missing required field `frames` on `TransactionRequest`.]',
+    )
+  })
+
   test('derives frame blob sidecars and replaces stale hashes', () => {
     const blobs = Blobs.from('0xdeadbeef')
     const request = {

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

@@ -42,3 +42,30 @@ test('unsigned signature', () => {
   }>()
   expectTypeOf(envelope).toMatchTypeOf<TxEnvelopeEip8141.TxEnvelopeEip8141>()
 })
+
+test('keyed nonce literals and numberish RPC input', () => {
+  const envelope = TxEnvelopeEip8141.from({
+    chainId: 1,
+    frames: [{}],
+    sender: '0x1111111111111111111111111111111111111111',
+    nonceKeys: [1n, 2n],
+    nonce: 3n,
+  })
+  expectTypeOf(envelope.nonceKeys).toEqualTypeOf<readonly [1n, 2n]>()
+  expectTypeOf(envelope.nonce).toEqualTypeOf<3n>()
+  expectTypeOf(TxEnvelopeEip8141.toRpc(envelope).nonceKeys).toEqualTypeOf<
+    readonly `0x${string}`[] | undefined
+  >()
+  expectTypeOf(
+    TxEnvelopeEip8141.toRpc({
+      ...envelope,
+      nonceKeys: ['0x1', 2],
+      nonce: '0x3',
+    }),
+  ).toEqualTypeOf<TxEnvelopeEip8141.Rpc>()
+  // @ts-expect-error decoded nonce keys are bigint
+  TxEnvelopeEip8141.from({ ...envelope, nonceKeys: [1] })
+  expectTypeOf<keyof TxEnvelopeEip8141.Rpc>()
+    .exclude<'nonceSeq'>()
+    .toEqualTypeOf<keyof TxEnvelopeEip8141.Rpc>()
+})