ox 1.8.1 → 1.8.3

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

@@ -3,8 +3,8 @@ import { Rlp, Frame } from 'ox'
 
 const frame = {
   data: '0x',
+  executionGas: 50_000n,
   flags: 3,
-  gas: 50_000n,
   mode: 1,
   stateGas: 0n,
   value: 0n,
@@ -38,8 +38,8 @@ describe('toTuple', () => {
     expect(
       Frame.toTuple({
         data: undefined,
+        executionGas: undefined,
         flags: undefined,
-        gas: undefined,
         mode: undefined,
         stateGas: undefined,
         value: undefined,
@@ -47,8 +47,8 @@ describe('toTuple', () => {
     ).toEqual(Frame.toTuple({}))
     expect(
       Frame.toTuple({
+        executionGas: 50_000n,
         flags: 'approveExecutionAndPayment',
-        gas: 50_000n,
         mode: 'verify',
       }),
     ).toEqual(tuple)
@@ -95,9 +95,25 @@ describe('toTuple', () => {
     )
   })
 
+  test('preserves separate execution and state gas budgets', () => {
+    const frame = Frame.from({ executionGas: 50_000n, stateGas: 12n })
+    const tuple = Frame.toTuple(frame)
+    expect(tuple).toEqual(['0x', '0x', '0x', ['0xc350', '0x0c'], '0x', '0x'])
+    expect(Frame.fromTuple(tuple)).toEqual({
+      data: '0x',
+      executionGas: 50_000n,
+      flags: 0,
+      mode: 0,
+      stateGas: 12n,
+      value: 0n,
+    })
+  })
+
   test('encodes zero integers as empty bytes', () => {
     expect(
-      Rlp.fromHex(Frame.toTuple({ ...frame, flags: 0, gas: 0n, mode: 0 })),
+      Rlp.fromHex(
+        Frame.toTuple({ ...frame, executionGas: 0n, flags: 0, mode: 0 }),
+      ),
     ).toMatchInlineSnapshot('"0xc8808080c280808080"')
   })
 
@@ -105,8 +121,8 @@ describe('toTuple', () => {
     const input = {
       ...frame,
       data: '0x0001',
+      executionGas: 2n ** 63n,
       flags: 0,
-      gas: 2n ** 63n,
       mode: 2,
       stateGas: 2n ** 63n - 1n,
       value: 2n ** 256n - 1n,
@@ -158,10 +174,20 @@ describe('fromTuple', () => {
 })
 
 describe('assert', () => {
+  test('reports the execution gas field', () => {
+    expect(() =>
+      Frame.assert({ executionGas: -1n }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Frame.InvalidError: Invalid frame.
+
+Details: executionGas must be an unsigned 64-bit integer.]`,
+    )
+  })
+
   test.each([
     { data: null },
     { flags: null },
-    { gas: null },
+    { executionGas: null },
     { mode: null },
     { stateGas: null },
     { value: null },
@@ -185,11 +211,11 @@ describe('assert', () => {
     { value: 1n },
     { mode: 2, value: -1n },
     { mode: 2, value: 2n ** 256n },
-    { gas: -1n },
-    { gas: 2n ** 64n },
+    { executionGas: -1n },
+    { executionGas: 2n ** 64n },
     { stateGas: -1n },
     { stateGas: 2n ** 64n },
-    { gas: 2n ** 64n - 1n, stateGas: 1n },
+    { executionGas: 2n ** 64n - 1n, stateGas: 1n },
     { data: '0x0' },
     { data: '0xgg' },
     { to: '0x01' },
@@ -221,19 +247,19 @@ describe('fromRpc', () => {
     expect(
       Frame.fromRpc({
         data: '0xdeadbeef',
-        executionGasLimit: '0x20000000000001',
-        flags: 0,
-        mode: 2,
-        stateGasLimit: '0x0',
+        executionGas: '0x20000000000001',
+        flags: '0x0',
+        mode: '0x2',
+        stateGas: '0xc',
         target: null,
         value: '0x1',
       }),
     ).toEqual({
       data: '0xdeadbeef',
+      executionGas: 9007199254740993n,
       flags: 0,
-      gas: 9007199254740993n,
       mode: 2,
-      stateGas: 0n,
+      stateGas: 12n,
       value: 1n,
     })
   })
@@ -247,20 +273,22 @@ describe('toRpc', () => {
       ),
     ).toEqual({
       data: '0x',
-      executionGasLimit: '0x0',
-      flags: 3,
-      mode: 1,
-      stateGasLimit: '0x0',
+      executionGas: '0x0',
+      flags: '0x3',
+      mode: '0x1',
+      stateGas: '0x0',
       value: '0x0',
     })
   })
   test('accepts numberish budgets', () => {
-    expect(Frame.toRpc({ gas: '0xc350', stateGas: 12, value: 0n })).toEqual({
+    expect(
+      Frame.toRpc({ executionGas: '0xc350', stateGas: 12, value: 0n }),
+    ).toEqual({
       data: '0x',
-      executionGasLimit: '0xc350',
-      flags: 0,
-      mode: 0,
-      stateGasLimit: '0xc',
+      executionGas: '0xc350',
+      flags: '0x0',
+      mode: '0x0',
+      stateGas: '0xc',
       value: '0x0',
     })
   })

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

@@ -14,13 +14,14 @@ test('exports', () => {
 
 describe('fromRpc', () => {
   test.each([
-    [0, 'reverted'],
-    [1, 'success'],
-    [2, 'skipped'],
+    ['0x0', 'reverted'],
+    ['0x1', 'success'],
+    ['0x2', 'skipped'],
   ] as const)('status %s', (status, expected) => {
     expect(
       FrameReceipt.fromRpc({
         executionGasUsed: '0x20000000000001',
+        gasUsed: '0x20000000000003',
         logs: [
           {
             address: '0x1111111111111111111111111111111111111111',
@@ -32,7 +33,8 @@ describe('fromRpc', () => {
         status,
       }),
     ).toEqual({
-      gasUsed: 9007199254740993n,
+      executionGasUsed: 9007199254740993n,
+      gasUsed: 9007199254740995n,
       logs: [
         {
           address: '0x1111111111111111111111111111111111111111',
@@ -48,18 +50,20 @@ describe('fromRpc', () => {
 
 describe('toRpc', () => {
   test.each([
-    ['reverted', 0],
-    ['success', 1],
-    ['skipped', 2],
+    ['reverted', '0x0'],
+    ['success', '0x1'],
+    ['skipped', '0x2'],
   ] as const)('status %s', (status, expected) => {
     const receipt = FrameReceipt.fromRpc({
       executionGasUsed: '0x20000000000001',
+      gasUsed: '0x20000000000003',
       logs: [],
       stateGasUsed: '0x2',
       status: expected,
     })
     expect(FrameReceipt.toRpc({ ...receipt, status })).toEqual({
       executionGasUsed: '0x20000000000001',
+      gasUsed: '0x20000000000003',
       logs: [],
       stateGasUsed: '0x2',
       status: expected,
@@ -69,7 +73,8 @@ describe('toRpc', () => {
   test('numberish gas', () => {
     expect(
       FrameReceipt.toRpc({
-        gasUsed: '0x5208',
+        executionGasUsed: '0x5208',
+        gasUsed: '0x520a',
         logs: [],
         stateGasUsed: 2,
         status: 'success',
@@ -77,9 +82,10 @@ describe('toRpc', () => {
     ).toMatchInlineSnapshot(`
       {
         "executionGasUsed": "0x5208",
+        "gasUsed": "0x520a",
         "logs": [],
         "stateGasUsed": "0x2",
-        "status": 1,
+        "status": "0x1",
       }
     `)
   })

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

@@ -0,0 +1,16 @@
+import { FrameRequest } from 'ox'
+import { expectTypeOf, test } from 'vp/test'
+
+test('public frame request types', () => {
+  const rpc = { mode: '0x2' } as const satisfies FrameRequest.Rpc
+  const request = FrameRequest.fromRpc(rpc)
+  expectTypeOf(request).toEqualTypeOf<FrameRequest.FrameRequest>()
+  expectTypeOf(FrameRequest.toRpc(request)).toEqualTypeOf<FrameRequest.Rpc>()
+  const input = {
+    executionGas: '0x1',
+    stateGas: 0,
+  } as const satisfies FrameRequest.toRpc.Input
+  expectTypeOf(FrameRequest.toRpc(input)).toEqualTypeOf<FrameRequest.Rpc>()
+  expectTypeOf<FrameRequest.fromRpc.ErrorType>().not.toBeNever()
+  expectTypeOf<FrameRequest.toRpc.ErrorType>().not.toBeNever()
+})

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

@@ -0,0 +1,41 @@
+import { FrameRequest } from 'ox'
+import { describe, expect, test } from 'vp/test'
+
+test('exports', () => {
+  expect(Object.keys(FrameRequest).sort()).toMatchInlineSnapshot(`
+    [
+      "fromRpc",
+      "toRpc",
+    ]
+  `)
+})
+
+describe('fromRpc', () => {
+  test('preserves omitted execution gas and explicit zero state gas', () => {
+    expect(FrameRequest.fromRpc({ mode: '0x2', stateGas: '0x0' }))
+      .toMatchInlineSnapshot(`
+      {
+        "data": "0x",
+        "flags": 0,
+        "mode": 2,
+        "stateGas": 0n,
+        "value": 0n,
+      }
+    `)
+  })
+})
+
+describe('toRpc', () => {
+  test('preserves omitted gas and encodes numberish values', () => {
+    expect(FrameRequest.toRpc({ mode: 'sender', stateGas: 0, value: '0x1' }))
+      .toMatchInlineSnapshot(`
+      {
+        "data": "0x",
+        "flags": "0x0",
+        "mode": "0x2",
+        "stateGas": "0x0",
+        "value": "0x1",
+      }
+    `)
+  })
+})

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

@@ -0,0 +1,131 @@
+import {
+  Frame,
+  FrameSignature,
+  TransactionRequest,
+  TransactionEnvelope,
+  TxEnvelopeEip8141,
+} from 'ox'
+import { describe, expect, test } from 'vp/test'
+
+describe('TransactionRequest.toRpc', () => {
+  test('preserves omitted frame gas and explicit zero limits', () => {
+    expect(
+      TransactionRequest.toRpc({
+        type: 'eip8141',
+        frames: [
+          { mode: 'sender' },
+          { mode: 'sender', executionGas: 0n },
+          { mode: 'sender', stateGas: 0n },
+          { mode: 'sender', executionGas: 50_000n, stateGas: 1_000n },
+        ],
+      }),
+    ).toEqual({
+      type: '0x6',
+      frames: [
+        { mode: '0x2', flags: '0x0', data: '0x', value: '0x0' },
+        {
+          mode: '0x2',
+          flags: '0x0',
+          data: '0x',
+          value: '0x0',
+          executionGas: '0x0',
+        },
+        {
+          mode: '0x2',
+          flags: '0x0',
+          data: '0x',
+          value: '0x0',
+          stateGas: '0x0',
+        },
+        {
+          mode: '0x2',
+          flags: '0x0',
+          data: '0x',
+          value: '0x0',
+          executionGas: '0xc350',
+          stateGas: '0x3e8',
+        },
+      ],
+    })
+  })
+})
+
+describe('TransactionRequest.fromRpc', () => {
+  test('decodes minimal requests without assigning gas limits', () => {
+    expect(
+      TransactionRequest.fromRpc({
+        type: '0x6',
+        frames: [
+          { mode: '0x2' },
+          { mode: '0x2', executionGas: '0x0', stateGas: '0x0', target: null },
+        ],
+      }),
+    ).toEqual({
+      type: 'eip8141',
+      frames: [
+        { mode: 2, flags: 0, data: '0x', value: 0n },
+        {
+          mode: 2,
+          flags: 0,
+          data: '0x',
+          value: 0n,
+          executionGas: 0n,
+          stateGas: 0n,
+        },
+      ],
+    })
+  })
+})
+
+describe('TxEnvelopeEip8141.toRpc', () => {
+  test('retains complete frame gas fields', () => {
+    const envelope = TxEnvelopeEip8141.toRpc(
+      TxEnvelopeEip8141.from({
+        chainId: 1,
+        frames: [Frame.from({ mode: 'sender' })],
+        sender: '0x1111111111111111111111111111111111111111',
+      }),
+    )
+    expect(envelope.frames).toEqual([
+      {
+        mode: '0x2',
+        flags: '0x0',
+        data: '0x',
+        value: '0x0',
+        executionGas: '0x0',
+        stateGas: '0x0',
+      },
+    ])
+  })
+})
+
+describe('FrameSignature.fromRpc', () => {
+  test('accepts empty signers', () => {
+    expect(FrameSignature.fromRpc({ scheme: '0x1', signer: '0x' })).toEqual({
+      scheme: 'secp256k1',
+      payload: '0x',
+    })
+  })
+})
+
+describe('TransactionEnvelope.toTransactionRequest', () => {
+  test('retains committed zero defaults when converting envelopes to requests', () => {
+    const envelope = TxEnvelopeEip8141.from({
+      chainId: 1,
+      frames: [Frame.from({ mode: 'sender', executionGas: 50_000n })],
+      sender: '0x1111111111111111111111111111111111111111',
+      signatures: [FrameSignature.from('0xaabb')],
+    })
+    const request = TransactionEnvelope.toTransactionRequest(envelope)
+    expect(request.frames).toEqual([
+      { mode: 'sender', executionGas: 50_000n, stateGas: 0n },
+    ])
+    expect(
+      TxEnvelopeEip8141.getSignPayload(
+        TransactionRequest.toEnvelope(
+          request,
+        ) as TxEnvelopeEip8141.TxEnvelopeEip8141,
+      ),
+    ).toBe(TxEnvelopeEip8141.getSignPayload(envelope))
+  })
+})

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

@@ -91,3 +91,23 @@ test('from preserves structured signature types', () => {
     signature: { r: '0x01', s: '0x02' },
   })
 })
+
+test('preserves protocol hex signature types', () => {
+  const signature = '0x1234' as const
+  const secp = FrameSignature.from({ scheme: 'secp256k1', signature })
+  expectTypeOf(secp.signature).toEqualTypeOf<typeof signature>()
+  const p256 = FrameSignature.from({
+    publicKey: { prefix: 4, x: '0x01', y: '0x02' },
+    scheme: 'p256',
+    signature,
+  })
+  expectTypeOf(p256.signature).toEqualTypeOf<typeof signature>()
+  // @ts-expect-error P256 hex signatures also require a public key.
+  FrameSignature.from({ scheme: 'p256', signature })
+})
+
+test('preserves empty protocol signature placeholders', () => {
+  const entry = FrameSignature.from({ scheme: 'p256', signature: '0x' })
+  expectTypeOf(entry.signature).toEqualTypeOf<'0x'>()
+  expectTypeOf(entry).toExtend<FrameSignature.P256>()
+})

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

@@ -1,6 +1,6 @@
 import { p256 } from '@noble/curves/nist.js'
 import { secp256k1 } from '@noble/curves/secp256k1.js'
-import { FrameSignature, Hex, P256, Rlp, Secp256k1 } from 'ox'
+import { FrameSignature, Hex, P256, Rlp, Secp256k1, Signature } from 'ox'
 import { describe, expect, test } from 'vite-plus/test'
 
 const arbitrary = {
@@ -21,6 +21,27 @@ const p256Bytes =
   '0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000026b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2964fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5'
 
 describe('from', () => {
+  test.each([
+    { scheme: 'secp256k1', signature: '0x' },
+    { scheme: 1, signature: '0x' },
+    { scheme: 'p256', signature: '0x' },
+    { scheme: 2, signature: '0x' },
+  ] as const)('accepts empty unsigned signatures: $scheme', (input) => {
+    const entry = FrameSignature.from(input)
+    const { signature: _, ...unsigned } = input
+    expect(entry).toEqual({ payload: '0x', ...input })
+    expect(FrameSignature.toTuple(entry)).toEqual(
+      FrameSignature.toTuple(unsigned),
+    )
+    expect(FrameSignature.toRpc(entry)).toEqual(FrameSignature.toRpc(unsigned))
+    expect(FrameSignature.validate(entry)).toBe(true)
+    expect(FrameSignature.validate(entry, { signed: true })).toBe(false)
+    expect(() => FrameSignature.assert(entry, { signed: true }))
+      .toThrowErrorMatchingInlineSnapshot(`[FrameSignature.InvalidError: Invalid frame signature.
+
+Details: Signature is required.]`)
+  })
+
   test.each(['0x', '0xaabb'] as const)(
     'constructs an arbitrary signature from %s',
     (signature) => {
@@ -455,15 +476,19 @@ describe('fromRpc', () => {
     expect(
       FrameSignature.fromRpc({
         msg: '0x',
-        scheme: 0,
+        scheme: '0x0',
         signature: '0xaabb',
-        signer: null,
+        signer: '0x',
       }),
     ).toEqual(FrameSignature.from('0xaabb'))
   })
   test('secp256k1 signature', () => {
     expect(
-      FrameSignature.fromRpc({ msg: '0x', scheme: 1, signature: secpBytes }),
+      FrameSignature.fromRpc({
+        msg: '0x',
+        scheme: '0x1',
+        signature: secpBytes,
+      }),
     ).toEqual(
       FrameSignature.from({
         scheme: 'secp256k1',
@@ -478,24 +503,24 @@ describe('fromRpc', () => {
   test('P-256 signature', () => {
     const entry = FrameSignature.fromRpc({
       msg: '0x',
-      scheme: 2,
+      scheme: '0x2',
       signature: p256Bytes,
     })
     expect(entry).toMatchObject({ payload: '0x', publicKey, scheme: 'p256' })
     expect(FrameSignature.toRpc(entry)).toEqual({
       msg: '0x',
-      scheme: 2,
+      scheme: '0x2',
       signature: p256Bytes,
     })
   })
   test('unsigned placeholder', () => {
-    expect(
-      FrameSignature.fromRpc({ msg: '0x', scheme: 1, signature: '0x' }),
-    ).toEqual(FrameSignature.from({ scheme: 'secp256k1' }))
+    expect(FrameSignature.fromRpc({ scheme: '0x1' })).toEqual(
+      FrameSignature.from({ scheme: 'secp256k1' }),
+    )
   })
   test('malformed protocol signature', () => {
     expect(() =>
-      FrameSignature.fromRpc({ msg: '0x', scheme: 1, signature: '0x01' }),
+      FrameSignature.fromRpc({ msg: '0x', scheme: '0x1', signature: '0x01' }),
     ).toThrowErrorMatchingInlineSnapshot(
       `[FrameSignature.InvalidError: Invalid frame signature.
 
@@ -505,6 +530,11 @@ Details: Invalid protocol signature length.]`,
 })
 
 describe('toRpc', () => {
+  test('omits an unsigned protocol signature', () => {
+    expect(
+      FrameSignature.toRpc(FrameSignature.from({ scheme: 'secp256k1' })),
+    ).toEqual({ msg: '0x', scheme: '0x1' })
+  })
   test('preserves explicit payload and signer', () => {
     const entry = FrameSignature.from({
       payload,
@@ -514,7 +544,7 @@ describe('toRpc', () => {
     })
     expect(FrameSignature.toRpc(entry)).toEqual({
       msg: payload,
-      scheme: 1,
+      scheme: '0x1',
       signature: secpBytes,
       signer: '0x1111111111111111111111111111111111111111',
     })
@@ -552,3 +582,94 @@ describe('structured validation', () => {
     expect(() => FrameSignature.from(entry)).toThrow()
   })
 })
+
+describe('hex signatures', () => {
+  test.each(['secp256k1', 1] as const)('secp256k1 scheme %s', (scheme) => {
+    const signature = Secp256k1.sign({ payload, privateKey })
+    const hex = Signature.toHex(signature)
+    const entry = FrameSignature.from({ scheme, signature: hex })
+    const structured = FrameSignature.from({ scheme, signature })
+
+    expect(entry.signature).toBe(hex)
+    expect(FrameSignature.toRpc(entry)).toEqual(
+      FrameSignature.toRpc(structured),
+    )
+    expect(FrameSignature.toTuple(entry)).toEqual(
+      FrameSignature.toTuple(structured),
+    )
+    expect(FrameSignature.validate(entry, { signed: true })).toBe(true)
+  })
+
+  test.each(['p256', 2] as const)('P256 scheme %s', (scheme) => {
+    const signature = P256.sign({ payload, privateKey })
+    const hex = Signature.toHex({ r: signature.r, s: signature.s })
+    const entry = FrameSignature.from({ publicKey, scheme, signature: hex })
+    const structured = FrameSignature.from({ publicKey, scheme, signature })
+
+    expect(entry.signature).toBe(hex)
+    expect(FrameSignature.toRpc(entry)).toEqual(
+      FrameSignature.toRpc(structured),
+    )
+    expect(FrameSignature.toTuple(entry)).toEqual(
+      FrameSignature.toTuple(structured),
+    )
+    expect(FrameSignature.validate(entry, { signed: true })).toBe(true)
+  })
+
+  test.each(['0x01', `0x${'00'.repeat(65)}`, `0x${'gg'.repeat(65)}`] as const)(
+    'rejects invalid secp256k1 hex: %s',
+    (signature) => {
+      expect(() =>
+        FrameSignature.from({ scheme: 'secp256k1', signature }),
+      ).toThrow()
+    },
+  )
+
+  test('requires secp256k1 recovery parity', () => {
+    const signature = Signature.toHex({
+      r: Hex.fromNumber(1, { size: 32 }),
+      s: Hex.fromNumber(2, { size: 32 }),
+    })
+    expect(() =>
+      FrameSignature.from({ scheme: 'secp256k1', signature }),
+    ).toThrow()
+  })
+
+  test('requires a public key with P256 hex', () => {
+    const entry = {
+      scheme: 'p256',
+      signature: Signature.toHex({
+        r: Hex.fromNumber(1, { size: 32 }),
+        s: Hex.fromNumber(2, { size: 32 }),
+      }),
+    } as const
+    // @ts-expect-error P256 requires a public key.
+    expect(() => FrameSignature.from(entry)).toThrow(
+      'P-256 signatures require a public key.',
+    )
+  })
+
+  test('normalizes P256 scalars on encoding', () => {
+    const signature = {
+      r: Hex.fromNumber(1, { size: 32 }),
+      s: Hex.fromNumber(p256.Point.Fn.ORDER - 1n),
+    } as const
+    const entry = FrameSignature.from({
+      publicKey,
+      scheme: 'p256',
+      signature: Signature.toHex(signature),
+    })
+    expect(FrameSignature.toTuple(entry)).toEqual(
+      FrameSignature.toTuple(
+        FrameSignature.from({ publicKey, scheme: 'p256', signature }),
+      ),
+    )
+  })
+})
+
+test('rejects malformed P256 hex bytes', () => {
+  const signature = `0x${'00'.repeat(64)}gg` as const
+  expect(
+    FrameSignature.validate({ publicKey, scheme: 'p256', signature }),
+  ).toBe(false)
+})