ox 1.7.4 → 1.8.0

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>()
+})