ox 1.8.1 → 1.8.4

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

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

@@ -214,3 +214,48 @@ test('eth_call accepts a 4-tuple with state + block overrides', () => {
     ]
   >().toExtend<Params>()
 })
+
+test('frame fill responses do not require raw bytes or lookup metadata', () => {
+  type Filled = Extract<
+    RpcSchema.Eth,
+    { Request: { method: 'eth_fillTransaction' } }
+  >['ReturnType']
+  const filled = {
+    tx: {
+      type: '0x6',
+      chainId: '0x1',
+      nonce: '0x0',
+      from: '0x1111111111111111111111111111111111111111',
+      frames: [
+        {
+          mode: '0x2',
+          flags: '0x0',
+          executionGas: '0x10000',
+          stateGas: '0x0',
+          value: '0x0',
+          data: '0x',
+        },
+      ],
+      signatures: [{ scheme: '0x1' }],
+      maxFeePerGas: '0x2',
+      maxPriorityFeePerGas: '0x1',
+      maxFeePerBlobGas: '0x0',
+      blobVersionedHashes: [],
+    },
+  } as const satisfies Filled
+  expectTypeOf(filled).toExtend<Filled>()
+})
+
+test('frame simulation results expose payer and frame results', () => {
+  type Result = Extract<
+    RpcSchema.Eth,
+    { Request: { method: 'eth_simulateV1' } }
+  >['ReturnType'][number]
+  type Call = NonNullable<Result['calls']>[number]
+  expectTypeOf<Call['payer']>().toEqualTypeOf<`0x${string}` | undefined>()
+  type Frame = NonNullable<Call['frameResults']>[number]
+  expectTypeOf<Frame['status']>().toEqualTypeOf<'0x0' | '0x1' | '0x2'>()
+  expectTypeOf<Frame['executionGasUsed']>().toEqualTypeOf<`0x${string}`>()
+  expectTypeOf<Frame['stateGasUsed']>().toEqualTypeOf<`0x${string}`>()
+  expectTypeOf<Frame['returnData']>().toEqualTypeOf<`0x${string}`>()
+})

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

@@ -773,6 +773,153 @@ Resources:
   `)
   })
 
+  test('behavior: "Resources:" in statement', () => {
+    const message = `example.com wants you to sign in with your Ethereum account:
+0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+See the Resources: list below.
+
+URI: https://example.com/path
+Version: 1
+Chain ID: 1
+Nonce: foobarbaz
+Issued At: 2023-02-01T00:00:00.000Z
+Resources:
+- https://example.com/foo
+- https://example.com/bar`
+    const parsed = Siwe.parseMessage(message)
+    expect(parsed).toMatchInlineSnapshot(`
+      {
+        "address": "0xA0Cf798816D4b9b9866b5330EEa46a18382f251e",
+        "chainId": 1,
+        "domain": "example.com",
+        "issuedAt": 2023-02-01T00:00:00.000Z,
+        "nonce": "foobarbaz",
+        "resources": [
+          "https://example.com/foo",
+          "https://example.com/bar",
+        ],
+        "statement": "See the Resources: list below.",
+        "uri": "https://example.com/path",
+        "version": "1",
+      }
+    `)
+  })
+
+  test('behavior: "Resources:" in statement without resources', () => {
+    const message = `example.com wants you to sign in with your Ethereum account:
+0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+See the Resources: page.
+
+URI: https://example.com/path
+Version: 1
+Chain ID: 1
+Nonce: foobarbaz
+Issued At: 2023-02-01T00:00:00.000Z`
+    const parsed = Siwe.parseMessage(message)
+    expect(parsed.resources).toBeUndefined()
+  })
+
+  test('behavior: "Resources:" in uri', () => {
+    const message = `example.com wants you to sign in with your Ethereum account:
+0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+
+URI: https://example.com/Resources:path
+Version: 1
+Chain ID: 1
+Nonce: foobarbaz
+Issued At: 2023-02-01T00:00:00.000Z
+Resources:
+- https://example.com/foo`
+    const parsed = Siwe.parseMessage(message)
+    expect(parsed.resources).toMatchInlineSnapshot(`
+      [
+        "https://example.com/foo",
+      ]
+    `)
+  })
+
+  test('behavior: "Resources:" in requestId', () => {
+    const message = `example.com wants you to sign in with your Ethereum account:
+0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+
+URI: https://example.com/path
+Version: 1
+Chain ID: 1
+Nonce: foobarbaz
+Issued At: 2023-02-01T00:00:00.000Z
+Request ID: Resources:123
+Resources:
+- https://example.com/foo`
+    const parsed = Siwe.parseMessage(message)
+    expect(parsed.resources).toMatchInlineSnapshot(`
+      [
+        "https://example.com/foo",
+      ]
+    `)
+  })
+
+  test('behavior: "Resources:" in a resource', () => {
+    const message = `example.com wants you to sign in with your Ethereum account:
+0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+
+URI: https://example.com/path
+Version: 1
+Chain ID: 1
+Nonce: foobarbaz
+Issued At: 2023-02-01T00:00:00.000Z
+Resources:
+- https://example.com/Resources:foo
+- https://example.com/bar`
+    const parsed = Siwe.parseMessage(message)
+    expect(parsed.resources).toMatchInlineSnapshot(`
+      [
+        "https://example.com/Resources:foo",
+        "https://example.com/bar",
+      ]
+    `)
+  })
+
+  test('behavior: empty requestId with resources', () => {
+    // EIP-4361 allows an empty Request ID (`request-id = *pchar`).
+    const message = `example.com wants you to sign in with your Ethereum account:
+0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+
+URI: https://example.com/path
+Version: 1
+Chain ID: 1
+Nonce: foobarbaz
+Issued At: 2023-02-01T00:00:00.000Z
+Request ID: \nResources:
+- https://example.com/foo`
+    const parsed = Siwe.parseMessage(message)
+    expect(parsed.resources).toMatchInlineSnapshot(`
+      [
+        "https://example.com/foo",
+      ]
+    `)
+  })
+
+  test('behavior: empty resources', () => {
+    const message = Siwe.createMessage({
+      address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+      chainId: 1,
+      domain: 'example.com',
+      issuedAt: new Date('2023-02-01T00:00:00.000Z'),
+      nonce: 'foobarbaz',
+      resources: [],
+      statement: 'Resources:',
+      uri: 'https://example.com/path',
+      version: '1',
+    })
+    expect(Siwe.parseMessage(message).resources).toMatchInlineSnapshot('[]')
+  })
+
   test('behavior: no suffix', () => {
     const message = `https://example.com wants you to sign in with your Ethereum account:
 0xA0Cf798816D4b9b9866b5330EEa46a18382f251e

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({
@@ -434,7 +460,7 @@ describe('toTransactionRequest', () => {
   test('maps frame sender to request from', () => {
     expect(TransactionEnvelope.toTransactionRequest(eip8141)).toEqual({
       chainId: 1,
-      frames: [{}],
+      frames: [{ executionGas: 0n, stateGas: 0n }],
       from: '0x1111111111111111111111111111111111111111',
       type: 'eip8141',
     })