ox 1.7.4 → 1.8.0

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

@@ -572,6 +572,172 @@ describe('toBytes', () => {
   })
 })
 
+describe('toCompactBytes', () => {
+  test('default', () => {
+    const bytes = Signature.toCompactBytes({
+      r: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf',
+      s: '0x4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
+      yParity: 1,
+    })
+    expect(bytes.length).toBe(64)
+    expect(Hex.fromBytes(bytes)).toBe(
+      '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
+    )
+  })
+
+  test('behavior: r/s shorter than 32 bytes are left-padded, not right-padded', () => {
+    const bytes = Signature.toCompactBytes({
+      r: '0x01',
+      s: '0x02',
+      yParity: 0,
+    })
+    // `r` occupies the first 32 bytes and must be the big-endian integer `1`
+    // (left-padded), not `1` shifted into the top byte (right-padded).
+    expect(Hex.fromBytes(bytes.subarray(0, 32))).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000001',
+    )
+    expect(Hex.fromBytes(bytes.subarray(32, 64))).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000002',
+    )
+  })
+
+  test('behavior: round-trips through recoverPublicKey for a signature whose r has a leading zero byte', async () => {
+    const { Secp256k1 } = await import('ox')
+    const payload = `0x${'11'.repeat(32)}` as const
+    const privateKey = Hex.fromNumber(4n * 123456789013n + 7n, { size: 32 })
+    const signature = Secp256k1.sign({ payload, privateKey })
+    // sanity: this fixture's `r` genuinely has a leading zero byte
+    expect(signature.r.startsWith('0x00')).toBe(true)
+    const expectedPublicKey = Secp256k1.recoverPublicKey({ payload, signature })
+
+    // simulate an external source (RPC/subgraph/DB) that stores `r` in
+    // minimal (non-zero-padded) form, as the `Hex.Hex` type permits
+    const minimalR = `0x${signature.r.slice(4)}` as const
+    const recoveredBytes = Signature.toRecoveredBytes({
+      r: minimalR,
+      s: signature.s,
+      yParity: signature.yParity,
+    })
+    const roundTripped = Signature.fromRecoveredBytes(recoveredBytes)
+    const recoveredPublicKey = Secp256k1.recoverPublicKey({
+      payload,
+      signature: roundTripped,
+    })
+    expect(recoveredPublicKey.x).toBe(expectedPublicKey.x)
+    expect(recoveredPublicKey.y).toBe(expectedPublicKey.y)
+  })
+})
+
+describe('fromCompactBytes', () => {
+  test('default', () => {
+    const signature = Signature.fromCompactBytes(
+      Bytes.fromHex(
+        '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
+      ),
+    )
+    expect(signature).toStrictEqual({
+      r: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf',
+      s: '0x4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
+    })
+  })
+
+  test('behavior: throws on a byte length other than 64', () => {
+    expect(() => Signature.fromCompactBytes(new Uint8Array(65)))
+      .toThrowErrorMatchingInlineSnapshot(`
+      [Signature.InvalidSerializedSizeError: Value \`0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\` is an invalid signature size.
+
+      Expected: 64 bytes.
+      Received 65 bytes.]
+    `)
+  })
+})
+
+describe('toRecoveredBytes', () => {
+  test('default', () => {
+    const bytes = Signature.toRecoveredBytes({
+      r: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf',
+      s: '0x4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
+      yParity: 1,
+    })
+    expect(bytes.length).toBe(65)
+    expect(bytes[0]).toBe(1)
+    expect(Hex.fromBytes(bytes.subarray(1))).toBe(
+      '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
+    )
+  })
+
+  test('behavior: r/s shorter than 32 bytes are left-padded, not right-padded', () => {
+    const bytes = Signature.toRecoveredBytes({
+      r: '0x01',
+      s: '0x02',
+      yParity: 0,
+    })
+    expect(Hex.fromBytes(bytes.subarray(1, 33))).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000001',
+    )
+    expect(Hex.fromBytes(bytes.subarray(33, 65))).toBe(
+      '0x0000000000000000000000000000000000000000000000000000000000000002',
+    )
+  })
+
+  test('behavior: throws before coercing an out-of-range yParity', () => {
+    expect(() =>
+      Signature.toRecoveredBytes({
+        r: '0x01',
+        s: '0x02',
+        yParity: 256,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Signature.InvalidYParityError: Value \`256\` is an invalid y-parity value. Y-parity must be 0 or 1.]`,
+    )
+  })
+})
+
+describe('fromRecoveredBytes', () => {
+  test('default', () => {
+    const bytes = new Uint8Array(65)
+    bytes[0] = 1
+    bytes.set(
+      Bytes.fromHex(
+        '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf',
+      ),
+      1,
+    )
+    bytes.set(
+      Bytes.fromHex(
+        '0x4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
+      ),
+      33,
+    )
+    const signature = Signature.fromRecoveredBytes(bytes)
+    expect(signature).toStrictEqual({
+      r: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf',
+      s: '0x4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
+      yParity: 1,
+    })
+  })
+
+  test('behavior: throws on a byte length other than 65', () => {
+    expect(() => Signature.fromRecoveredBytes(new Uint8Array(64)))
+      .toThrowErrorMatchingInlineSnapshot(`
+      [Signature.InvalidSerializedSizeError: Value \`0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\` is an invalid signature size.
+
+      Expected: 65 bytes.
+      Received 64 bytes.]
+    `)
+  })
+
+  test('behavior: throws on an out-of-range yParity byte', () => {
+    const bytes = new Uint8Array(65)
+    bytes[0] = 7
+    expect(() =>
+      Signature.fromRecoveredBytes(bytes),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Signature.InvalidYParityError: Value \`7\` is an invalid y-parity value. Y-parity must be 0 or 1.]`,
+    )
+  })
+})
+
 describe('toDerHex', () => {
   test('default', () => {
     const signature = Signature.from({

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

@@ -324,6 +324,53 @@ describe('createMessage', () => {
   `)
   })
 
+  test('behavior: uri with no path (authority only)', () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date(Date.UTC(2023, 1, 1)))
+
+    expect(Siwe.createMessage({ ...message, uri: 'https://example.com' }))
+      .toMatchInlineSnapshot(`
+      "example.com wants you to sign in with your Ethereum account:
+      0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+
+      URI: https://example.com
+      Version: 1
+      Chain ID: 1
+      Nonce: foobarbaz
+      Issued At: 2023-02-01T00:00:00.000Z"
+    `)
+
+    vi.useRealTimers()
+  })
+
+  test('behavior: resources entry with no path (authority only)', () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date(Date.UTC(2023, 1, 1)))
+
+    expect(
+      Siwe.createMessage({
+        ...message,
+        resources: ['https://example.com', 'https://example.com/foo'],
+      }),
+    ).toMatchInlineSnapshot(`
+      "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
+      - https://example.com/foo"
+    `)
+
+    vi.useRealTimers()
+  })
+
   test('behavior: invalid version', () => {
     expect(() =>
       // @ts-expect-error
@@ -373,7 +420,7 @@ describe('createMessage', () => {
     - Every resource must be a RFC 3986 URI.
     - See https://www.rfc-editor.org/rfc/rfc3986
 
-    Provided value: https://example.com]
+    Provided value: foo]
   `)
   })
 
@@ -426,6 +473,58 @@ describe('isUri', () => {
     )
   })
 
+  test('behavior: authority with empty path (bare origin)', () => {
+    expect(Siwe.isUri('https://example.com')).toMatchInlineSnapshot(
+      `"https://example.com"`,
+    )
+  })
+
+  test('behavior: authority with empty path and port', () => {
+    expect(Siwe.isUri('https://example.com:8080')).toMatchInlineSnapshot(
+      `"https://example.com:8080"`,
+    )
+  })
+
+  test('behavior: authority with empty path and query', () => {
+    expect(Siwe.isUri('https://example.com?a=1')).toMatchInlineSnapshot(
+      `"https://example.com?a=1"`,
+    )
+  })
+
+  test('behavior: authority with empty path and fragment', () => {
+    expect(Siwe.isUri('https://example.com#top')).toMatchInlineSnapshot(
+      `"https://example.com#top"`,
+    )
+  })
+
+  test('behavior: authority with empty path (non-http scheme)', () => {
+    expect(Siwe.isUri('ipfs://bafybeiabc')).toMatchInlineSnapshot(
+      `"ipfs://bafybeiabc"`,
+    )
+  })
+
+  test('behavior: authority variants with empty path', () => {
+    expect([
+      Siwe.isUri('https://[2001:db8::1]'),
+      Siwe.isUri('https://user:pass@example.com:8080'),
+      Siwe.isUri('foo://[v1.fe]'),
+    ]).toMatchInlineSnapshot(`
+      [
+        "https://[2001:db8::1]",
+        "https://user:pass@example.com:8080",
+        "foo://[v1.fe]",
+      ]
+    `)
+  })
+
+  test.each([
+    'https://example.com:bad',
+    'https://[:::]',
+    'https://user@@example.com',
+  ])('behavior: invalid authority with empty path `%s`', (uri) => {
+    expect(Siwe.isUri(uri)).toMatchInlineSnapshot(`false`)
+  })
+
   test('behavior: check for illegal characters', () => {
     expect(Siwe.isUri('^')).toBeFalsy()
   })

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

@@ -3,6 +3,9 @@ import {
   Secp256k1,
   Transaction,
   TxEnvelopeEip1559,
+  Frame,
+  FrameSignature,
+  TxEnvelopeEip8141,
   TxEnvelopeLegacy,
 } from 'ox'
 import { describe, expect, test } from 'vp/test'
@@ -2046,3 +2049,33 @@ test('exports', () => {
     ]
   `)
 })
+
+describe('frame transaction RPC', () => {
+  test('preserves pending metadata and large chain IDs without outer signatures', () => {
+    const envelope = TxEnvelopeEip8141.from({
+      chainId: 9007199254740993n,
+      frames: [Frame.from({})],
+      sender: '0x1111111111111111111111111111111111111111',
+      signatures: [FrameSignature.from({ scheme: 'secp256k1' })],
+    })
+    const rpc = {
+      ...TxEnvelopeEip8141.toRpc(envelope),
+      blockHash: null,
+      blockNumber: null,
+      blockTimestamp: null,
+      gas: '0x0',
+      hash: '0x00',
+      input: '0x',
+      to: null,
+      transactionIndex: null,
+      value: '0x0',
+    } satisfies Transaction.Eip8141Rpc<true>
+    const transaction = Transaction.fromRpc(rpc, { pending: true })!
+    expect(transaction.chainId).toBe(9007199254740993n)
+    expect(transaction.blockNumber).toBeNull()
+    expect(transaction.transactionIndex).toBeNull()
+    expect(transaction).not.toHaveProperty('r')
+    expect(transaction).not.toHaveProperty('s')
+    expect(Transaction.toRpc(transaction, { pending: true })).toEqual(rpc)
+  })
+})

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

@@ -4,6 +4,7 @@ import {
   type TxEnvelopeEip2930,
   type TxEnvelopeEip4844,
   type TxEnvelopeEip7702,
+  type TxEnvelopeEip8141,
   type TxEnvelopeLegacy,
 } from 'ox'
 import { describe, expectTypeOf, test } from 'vp/test'
@@ -180,3 +181,76 @@ describe('toRpc', () => {
     expectTypeOf(rpc).toEqualTypeOf<TxEnvelopeEip1559.Rpc>()
   })
 })
+
+describe('eip8141', () => {
+  test('preserves constructor literals', () => {
+    const envelope = TransactionEnvelope.from({
+      chainId: 1n,
+      frames: [],
+      sender: '0x1111111111111111111111111111111111111111',
+    })
+    expectTypeOf(envelope).toEqualTypeOf<{
+      readonly chainId: 1n
+      readonly frames: readonly []
+      readonly sender: '0x1111111111111111111111111111111111111111'
+      readonly type: 'eip8141'
+    }>()
+    expectTypeOf(
+      TransactionEnvelope.serialize(envelope),
+    ).toEqualTypeOf<TxEnvelopeEip8141.Serialized>()
+    expectTypeOf(
+      TransactionEnvelope.deserialize('0x06c0'),
+    ).toEqualTypeOf<TxEnvelopeEip8141.TxEnvelopeEip8141>()
+    expectTypeOf(
+      TransactionEnvelope.from('0x06c0'),
+    ).toEqualTypeOf<TxEnvelopeEip8141.TxEnvelopeEip8141>()
+    expectTypeOf(
+      TransactionEnvelope.getSerializedType('0x06c0'),
+    ).toEqualTypeOf<'eip8141'>()
+    expectTypeOf(envelope).toMatchTypeOf<TransactionEnvelope.TxEnvelope<true>>()
+    expectTypeOf(
+      TransactionEnvelope.toRpc(envelope),
+    ).toEqualTypeOf<TxEnvelopeEip8141.Rpc>()
+  })
+
+  test('frames take precedence over blob and fee fields', () => {
+    expectTypeOf(
+      TransactionEnvelope.getType({
+        blobVersionedHashes: [],
+        frames: [],
+        maxFeePerGas: 1n,
+      }),
+    ).toEqualTypeOf<'eip8141'>()
+    expectTypeOf(
+      TransactionEnvelope.getType({ frames: undefined, maxFeePerGas: 1n }),
+    ).toEqualTypeOf<'eip1559'>()
+    expectTypeOf(
+      TransactionEnvelope.getType({ frames: [], type: 'eip1559' }),
+    ).toEqualTypeOf<'eip1559'>()
+  })
+})
+
+test('toRpc accepts implicit frame envelopes', () => {
+  const envelope = {
+    chainId: 1,
+    frames: [{}],
+    sender: '0x1111111111111111111111111111111111111111',
+  } as const
+  expectTypeOf(
+    TransactionEnvelope.toRpc(envelope),
+  ).toEqualTypeOf<TxEnvelopeEip8141.Rpc>()
+})
+
+test('request conversions accept frames and undefined', () => {
+  TransactionEnvelope.toRpc({ chainId: 1, frames: undefined, maxFeePerGas: 1n })
+  TransactionEnvelope.toTransactionRequest({
+    chainId: 1,
+    frames: undefined,
+    maxFeePerGas: 1n,
+  })
+  TransactionEnvelope.toTransactionRequest({
+    chainId: 1,
+    frames: [{}],
+    sender: '0x1111111111111111111111111111111111111111',
+  })
+})

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