ox 1.7.5 → 1.8.1

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

@@ -1,9 +1,12 @@
 import {
+  Frame,
+  FrameSignature,
   TransactionEnvelope,
   TxEnvelopeEip1559,
   TxEnvelopeEip2930,
   TxEnvelopeEip4844,
   TxEnvelopeEip7702,
+  TxEnvelopeEip8141,
   TxEnvelopeLegacy,
 } from 'ox'
 import { describe, expect, test } from 'vp/test'
@@ -62,6 +65,14 @@ const eip7702 = TxEnvelopeEip7702.from({
   value: 1n,
 })
 
+const eip8141 = TxEnvelopeEip8141.from({
+  chainId: 1,
+  frames: [Frame.from({})],
+  sender: '0x1111111111111111111111111111111111111111',
+})
+const serialized8141 =
+  '0x06e70180941111111111111111111111111111111111111111c9c8808080c280808080c0c3808080c0'
+
 test('exports', () => {
   expect(Object.keys(TransactionEnvelope)).toMatchInlineSnapshot(`
     [
@@ -88,6 +99,25 @@ test('exports', () => {
 })
 
 describe('getType', () => {
+  test('frame fields take precedence over blobs and fees', () => {
+    expect(
+      TransactionEnvelope.getType({
+        blobVersionedHashes: [],
+        frames: [],
+        maxFeePerGas: 1n,
+      }),
+    ).toBe('eip8141')
+    expect(
+      TransactionEnvelope.getType({ frames: undefined, maxFeePerGas: 1n }),
+    ).toBe('eip1559')
+    expect(TransactionEnvelope.getType({ frames: [], type: 'eip1559' })).toBe(
+      'eip1559',
+    )
+    expect(() => TransactionEnvelope.getType({ type: '0x6' })).toThrow(
+      TransactionEnvelope.InvalidTypeError,
+    )
+  })
+
   test('behavior: routes explicit transaction types', () => {
     expect(TransactionEnvelope.getType(legacy)).toBe('legacy')
     expect(TransactionEnvelope.getType(eip2930)).toBe('eip2930')
@@ -156,6 +186,12 @@ describe('getType', () => {
 })
 
 describe('getSerializedType', () => {
+  test('eip8141', () => {
+    expect(TransactionEnvelope.getSerializedType(serialized8141)).toBe(
+      'eip8141',
+    )
+  })
+
   test('behavior: routes serialized transaction types', () => {
     expect(
       TransactionEnvelope.getSerializedType(TxEnvelopeLegacy.serialize(legacy)),
@@ -202,6 +238,12 @@ describe('getSerializedType', () => {
 })
 
 describe('deserialize', () => {
+  test('eip8141', () => {
+    expect(TransactionEnvelope.deserialize(serialized8141)).toEqual(
+      TxEnvelopeEip8141.deserialize(serialized8141),
+    )
+  })
+
   test('behavior: routes to the matching concrete deserializer', () => {
     const serialized = TxEnvelopeEip1559.serialize(eip1559)
 
@@ -212,6 +254,14 @@ describe('deserialize', () => {
 })
 
 describe('from', () => {
+  test('eip8141', () => {
+    const { type: _, ...input } = eip8141
+    expect(TransactionEnvelope.from(input)).toEqual(eip8141)
+    expect(TransactionEnvelope.from(serialized8141)).toEqual(
+      TxEnvelopeEip8141.deserialize(serialized8141),
+    )
+  })
+
   test('behavior: routes objects to the matching concrete converter', () => {
     expect(TransactionEnvelope.from({ maxFeePerGas: 10n, chainId: 1 })).toEqual(
       TxEnvelopeEip1559.from({ maxFeePerGas: 10n, chainId: 1 }),
@@ -244,6 +294,26 @@ describe('from', () => {
 })
 
 describe('getSignPayload', () => {
+  test('eip8141 signature elision', () => {
+    const envelope = TxEnvelopeEip8141.from({
+      ...eip8141,
+      signatures: [
+        FrameSignature.from('0xaabb'),
+        FrameSignature.from({
+          payload: `0x${'ab'.repeat(32)}`,
+          signature: '0xccdd',
+        }),
+      ],
+    })
+    expect(TransactionEnvelope.getSignPayload(envelope)).toBe(
+      '0x85ec4544ddb227c5425add4b606f71ddfc0852100d14066d0061a1b092bad6d3',
+    )
+    expect(TransactionEnvelope.hash(envelope, { presign: true })).toBe(
+      TransactionEnvelope.getSignPayload(envelope),
+    )
+    expect(envelope.signatures[0].signature).toBe('0xaabb')
+  })
+
   test('behavior: routes to the matching concrete payload helper', () => {
     expect(TransactionEnvelope.getSignPayload(eip1559)).toBe(
       TxEnvelopeEip1559.getSignPayload(eip1559),
@@ -252,6 +322,12 @@ describe('getSignPayload', () => {
 })
 
 describe('hash', () => {
+  test('eip8141 without outer signature fields', () => {
+    expect(TransactionEnvelope.hash(eip8141)).toBe(
+      '0xa795b6de44696d46c096aaa3d6401d6eaa21b9b639408c82be7e9e60358e4387',
+    )
+  })
+
   test('behavior: routes to the matching concrete hash helper', () => {
     expect(TransactionEnvelope.hash(eip1559, { presign: true })).toBe(
       TxEnvelopeEip1559.hash(eip1559, { presign: true }),
@@ -260,6 +336,10 @@ describe('hash', () => {
 })
 
 describe('serialize', () => {
+  test('eip8141', () => {
+    expect(TransactionEnvelope.serialize(eip8141)).toBe(serialized8141)
+  })
+
   test('behavior: routes to the matching concrete serializer', () => {
     expect(TransactionEnvelope.serialize(eip1559)).toBe(
       TxEnvelopeEip1559.serialize(eip1559),
@@ -284,6 +364,12 @@ describe('serialize', () => {
 })
 
 describe('toRpc', () => {
+  test('converts frame envelopes', () => {
+    expect(TransactionEnvelope.toRpc(eip8141)).toEqual(
+      TxEnvelopeEip8141.toRpc(eip8141),
+    )
+  })
+
   test('behavior: routes to the matching concrete RPC converter', () => {
     expect(TransactionEnvelope.toRpc(eip1559)).toEqual(
       TxEnvelopeEip1559.toRpc(eip1559),
@@ -292,6 +378,13 @@ describe('toRpc', () => {
 })
 
 describe('assert', () => {
+  test('eip8141', () => {
+    expect(() => TransactionEnvelope.assert(eip8141)).not.toThrow()
+    expect(() =>
+      TransactionEnvelope.assert({ ...eip8141, frames: [] }),
+    ).toThrow(TxEnvelopeEip8141.InvalidError)
+  })
+
   test('behavior: routes to the matching concrete assertion', () => {
     expect(() =>
       TransactionEnvelope.assert({
@@ -306,6 +399,11 @@ describe('assert', () => {
 })
 
 describe('validate', () => {
+  test('eip8141', () => {
+    expect(TransactionEnvelope.validate(eip8141)).toBe(true)
+    expect(TransactionEnvelope.validate({ ...eip8141, frames: [] })).toBe(false)
+  })
+
   test('behavior: returns validation result for routed envelope', () => {
     expect(TransactionEnvelope.validate(eip1559)).toBe(true)
     expect(
@@ -333,6 +431,15 @@ describe('getType', () => {
 })
 
 describe('toTransactionRequest', () => {
+  test('maps frame sender to request from', () => {
+    expect(TransactionEnvelope.toTransactionRequest(eip8141)).toEqual({
+      chainId: 1,
+      frames: [{}],
+      from: '0x1111111111111111111111111111111111111111',
+      type: 'eip8141',
+    })
+  })
+
   test('behavior: eip1559', () => {
     const request = TransactionEnvelope.toTransactionRequest(eip1559)
     expect(request).toMatchInlineSnapshot(`

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

@@ -1,4 +1,5 @@
 import { TransactionReceipt } from 'ox'
+import { z } from 'ox/zod'
 import { describe, expect, test } from 'vp/test'
 import { anvilMainnet } from '../../../test/prool.js'
 
@@ -457,3 +458,61 @@ test('exports', () => {
     ]
   `)
 })
+
+describe('frame receipts', () => {
+  test('preserves payer, statuses, logs, and large gas totals', () => {
+    const rpc = {
+      blockHash: '0x00',
+      blockNumber: '0x1',
+      cumulativeGasUsed: '0x20000000000001',
+      effectiveGasPrice: '0x1',
+      frameReceipts: [
+        {
+          executionGasUsed: '0x20000000000001',
+          logs: [
+            {
+              address: '0x1111111111111111111111111111111111111111',
+              data: '0xab',
+              topics: ['0x01'],
+            },
+          ],
+          stateGasUsed: '0x2',
+          status: 1,
+        },
+        { executionGasUsed: '0x3', logs: [], stateGasUsed: '0x0', status: 0 },
+        { executionGasUsed: '0x0', logs: [], stateGasUsed: '0x0', status: 2 },
+      ],
+      from: '0x1111111111111111111111111111111111111111',
+      gasUsed: '0x20000000000001',
+      logs: [],
+      logsBloom: '0x00',
+      payer: '0x2222222222222222222222222222222222222222',
+      status: '0x0',
+      to: null,
+      transactionHash: '0x00',
+      transactionIndex: '0x0',
+      type: '0x6',
+    } satisfies TransactionReceipt.Rpc
+    const receipt = TransactionReceipt.fromRpc(rpc)
+    expect(receipt.type).toBe('eip8141')
+    expect(receipt.payer).toBe(rpc.payer)
+    expect(receipt.frameReceipts).toEqual([
+      {
+        gasUsed: 9007199254740993n,
+        logs: rpc.frameReceipts[0]!.logs,
+        stateGasUsed: 2n,
+        status: 'success',
+      },
+      { gasUsed: 3n, logs: [], stateGasUsed: 0n, status: 'reverted' },
+      { gasUsed: 0n, logs: [], stateGasUsed: 0n, status: 'skipped' },
+    ])
+    expect(TransactionReceipt.toRpc(receipt)).toMatchObject(rpc)
+    expect(
+      z.decode(z.TransactionReceipt.TransactionReceipt, rpc).frameReceipts,
+    ).toEqual(receipt.frameReceipts)
+    expect(
+      z.encode(z.TransactionReceipt.TransactionReceipt, receipt).frameReceipts,
+    ).toEqual(rpc.frameReceipts)
+    expect(rpc.frameReceipts[0]!.executionGasUsed).toBe('0x20000000000001')
+  })
+})

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

@@ -1,4 +1,6 @@
 import {
+  type Frame,
+  type FrameSignature,
   TransactionEnvelope,
   type TransactionRequest as TransactionRequestNs,
   TransactionRequest,
@@ -117,9 +119,57 @@ describe('round-trip: Request → Envelope → Request', () => {
       value: 1n,
     }
     const envelope = TransactionRequest.toEnvelope(request)
+    if ('frames' in envelope) throw new Error('Expected a non-frame envelope')
     const roundtripped = TransactionEnvelope.toTransactionRequest(envelope)
     expectTypeOf(
       roundtripped,
     ).toEqualTypeOf<TransactionRequestNs.TransactionRequest>()
   })
 })
+
+describe('frame generics', () => {
+  test('decoded defaults', () => {
+    expectTypeOf<
+      TransactionRequest.TransactionRequest['frames']
+    >().toEqualTypeOf<readonly Frame.Frame[] | undefined>()
+    expectTypeOf<
+      TransactionRequest.TransactionRequest['signatures']
+    >().toEqualTypeOf<readonly FrameSignature.FrameSignature[] | undefined>()
+  })
+
+  test('RPC types', () => {
+    expectTypeOf<TransactionRequest.Rpc['frames']>().toEqualTypeOf<
+      readonly Frame.Rpc[] | undefined
+    >()
+    expectTypeOf<TransactionRequest.Rpc['signatures']>().toEqualTypeOf<
+      readonly FrameSignature.Rpc[] | undefined
+    >()
+  })
+
+  test('custom frame and signature types', () => {
+    type Request = TransactionRequest.TransactionRequest<
+      bigint,
+      number,
+      string,
+      Frame.Frame & { label: string },
+      FrameSignature.Arbitrary
+    >
+    expectTypeOf<Request['frames']>().toEqualTypeOf<
+      readonly (Frame.Frame & { label: string })[] | undefined
+    >()
+    expectTypeOf<Request['signatures']>().toEqualTypeOf<
+      readonly FrameSignature.Arbitrary[] | undefined
+    >()
+  })
+})
+
+test('chain ID remains a number for every request type', () => {
+  expectTypeOf<
+    TransactionRequest.TransactionRequest['chainId']
+  >().toEqualTypeOf<number | undefined>()
+  expectTypeOf<
+    TransactionRequest.TransactionRequest<bigint, number, 'eip8141'>['chainId']
+  >().toEqualTypeOf<number | undefined>()
+  // @ts-expect-error Request chain IDs must be numbers.
+  TransactionRequest.toEnvelope({ chainId: 1n, type: 'eip1559' })
+})

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

@@ -1,4 +1,13 @@
-import { Blobs, Hex, TransactionRequest, Value } from 'ox'
+import {
+  Blobs,
+  Frame,
+  FrameSignature,
+  Hex,
+  TransactionEnvelope,
+  TransactionRequest,
+  TxEnvelopeEip8141,
+  Value,
+} from 'ox'
 import { describe, expect, test } from 'vp/test'
 import { kzg } from '../../../test/kzg.js'
 import { anvilMainnet } from '../../../test/prool.js'
@@ -428,3 +437,81 @@ test('exports', () => {
     ]
   `)
 })
+
+describe('frame transactions', () => {
+  test('derives frame blob sidecars and replaces stale hashes', () => {
+    const blobs = Blobs.from('0xdeadbeef')
+    const request = {
+      blobVersionedHashes: [],
+      blobs,
+      chainId: 1,
+      frames: [Frame.from({})],
+      from: '0x1111111111111111111111111111111111111111' as const,
+      maxFeePerBlobGas: 1n,
+    }
+    expect(() => TransactionRequest.toEnvelope(request)).toThrow(
+      TransactionRequest.MissingKzgError,
+    )
+    const envelope = TransactionRequest.toEnvelope(request, { kzg })
+    expect(envelope.type).toBe('eip8141')
+    if (envelope.type !== 'eip8141') throw new Error('Expected frame envelope')
+    expect(envelope.sidecars?.blobs).toEqual(blobs)
+    expect(envelope.sidecars?.cellProofs).toHaveLength(128)
+    expect(
+      TxEnvelopeEip8141.deserialize(TxEnvelopeEip8141.serialize(envelope))
+        .blobVersionedHashes,
+    ).toEqual(envelope.blobVersionedHashes)
+  })
+
+  test('round-trips frame requests and envelopes', () => {
+    const envelope = TxEnvelopeEip8141.from({
+      chainId: 8141,
+      frames: [Frame.from({ gas: 50_000n, mode: 'verify' })],
+      sender: '0x1111111111111111111111111111111111111111',
+      signatures: [FrameSignature.from('0xaabb')],
+    })
+    const request = TransactionEnvelope.toTransactionRequest(envelope)
+    const rpc = TransactionRequest.toRpc(request)
+    expect(rpc.chainId).toBe('0x1fcd')
+    expect(rpc.type).toBe('0x6')
+    expect(rpc.signatures).toEqual([
+      { msg: '0x', scheme: 0, signature: '0xaabb' },
+    ])
+    const decoded = TransactionRequest.fromRpc(rpc)
+    expect(decoded.chainId).toBe(8141)
+    expect(
+      TxEnvelopeEip8141.serialize(
+        TransactionRequest.toEnvelope(
+          decoded,
+        ) as TxEnvelopeEip8141.TxEnvelopeEip8141,
+      ),
+    ).toBe(TxEnvelopeEip8141.serialize(envelope))
+  })
+  test('requires a sender', () => {
+    expect(() =>
+      TransactionRequest.toEnvelope({ chainId: 1, frames: [] }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Quantity.MissingFieldError: Missing required field \`from\` on \`TransactionRequest\`.]`,
+    )
+  })
+})
+
+describe('chain ID precision', () => {
+  test('rejects unsafe RPC chain IDs', () => {
+    expect(() =>
+      TransactionRequest.fromRpc({
+        chainId: '0x20000000000001',
+        frames: [],
+        type: '0x6',
+      }),
+    ).toThrow()
+  })
+  test('rejects unsafe envelope chain IDs when converting to a request', () => {
+    const envelope = TxEnvelopeEip8141.from({
+      chainId: 9007199254740993n,
+      frames: [Frame.from({})],
+      sender: '0x1111111111111111111111111111111111111111',
+    })
+    expect(() => TransactionEnvelope.toTransactionRequest(envelope)).toThrow()
+  })
+})

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

@@ -0,0 +1,44 @@
+import { TxEnvelopeEip8141 } from 'ox'
+import { expectTypeOf, test } from 'vp/test'
+
+test('default', () => {
+  const envelope = TxEnvelopeEip8141.from({
+    chainId: 1,
+    frames: [{ gas: 50000n }],
+    sender: '0x1111111111111111111111111111111111111111',
+  })
+  expectTypeOf(envelope).toEqualTypeOf<{
+    readonly chainId: 1
+    readonly frames: readonly [{ readonly gas: 50000n }]
+    readonly sender: '0x1111111111111111111111111111111111111111'
+    readonly type: 'eip8141'
+  }>()
+  expectTypeOf(envelope).toMatchTypeOf<TxEnvelopeEip8141.TxEnvelopeEip8141>()
+  expectTypeOf(
+    TxEnvelopeEip8141.serialize(envelope),
+  ).toEqualTypeOf<TxEnvelopeEip8141.Serialized>()
+})
+
+test('serialized', () => {
+  const envelope = TxEnvelopeEip8141.from(
+    '0x06' as TxEnvelopeEip8141.Serialized,
+  )
+  expectTypeOf(envelope).toEqualTypeOf<TxEnvelopeEip8141.TxEnvelopeEip8141>()
+})
+
+test('unsigned signature', () => {
+  const envelope = TxEnvelopeEip8141.from({
+    chainId: 1n,
+    frames: [{}],
+    sender: '0x1111111111111111111111111111111111111111',
+    signatures: [{ scheme: 'secp256k1' }],
+  })
+  expectTypeOf(envelope).toEqualTypeOf<{
+    readonly chainId: 1n
+    readonly frames: readonly [{}]
+    readonly sender: '0x1111111111111111111111111111111111111111'
+    readonly signatures: readonly [{ readonly scheme: 'secp256k1' }]
+    readonly type: 'eip8141'
+  }>()
+  expectTypeOf(envelope).toMatchTypeOf<TxEnvelopeEip8141.TxEnvelopeEip8141>()
+})