ox 1.8.1 → 1.8.4

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

@@ -1,3 +1,4 @@
+import { encodeRlp, keccak256 } from 'ethers'
 import {
   Address,
   Blobs,
@@ -245,7 +246,7 @@ describe('assert', () => {
     expect(() =>
       TxEnvelopeEip8141.assert({
         chainId: 1,
-        frames: [{ gas: 2n ** 64n - 1n }, { stateGas: 1n }],
+        frames: [{ executionGas: 2n ** 64n - 1n }, { stateGas: 1n }],
         sender: accounts[0].address,
       }),
     ).toThrowErrorMatchingInlineSnapshot(
@@ -257,7 +258,7 @@ describe('assert', () => {
     expect(() =>
       TxEnvelopeEip8141.assert({
         chainId: 1,
-        frames: [{ gas: 16_777_216n }],
+        frames: [{ executionGas: 16_777_216n }],
         sender: accounts[0].address,
       }),
     ).toThrowErrorMatchingInlineSnapshot(
@@ -354,8 +355,8 @@ describe('deserialize', () => {
         "frames": [
           {
             "data": "0x",
+            "executionGas": 0n,
             "flags": 0,
-            "gas": 0n,
             "mode": 0,
             "stateGas": 0n,
             "value": 0n,
@@ -402,7 +403,7 @@ describe('deserialize', () => {
     expect(() =>
       TxEnvelopeEip8141.deserialize('0x06c0' as TxEnvelopeEip8141.Serialized),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[TxEnvelopeEip8141.InvalidError: Expected seven transaction fields.]`,
+      `[TxEnvelopeEip8141.InvalidError: Expected seven or eight transaction fields.]`,
     )
   })
 
@@ -426,7 +427,7 @@ describe('deserialize', () => {
     expect(() =>
       TxEnvelopeEip8141.deserialize('0x06c180' as TxEnvelopeEip8141.Serialized),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[TxEnvelopeEip8141.InvalidError: Expected seven transaction fields.]`,
+      `[TxEnvelopeEip8141.InvalidError: Expected seven or eight transaction fields.]`,
     )
   })
 
@@ -450,7 +451,7 @@ describe('from', () => {
     expect(
       TxEnvelopeEip8141.from({
         chainId: 1,
-        frames: [{ gas: 50000n }],
+        frames: [{ executionGas: 50000n }],
         sender: accounts[0].address,
       }),
     ).toMatchInlineSnapshot(`
@@ -458,7 +459,7 @@ describe('from', () => {
         "chainId": 1,
         "frames": [
           {
-            "gas": 50000n,
+            "executionGas": 50000n,
           },
         ],
         "sender": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
@@ -479,8 +480,8 @@ describe('from', () => {
         "frames": [
           {
             "data": "0x",
+            "executionGas": 0n,
             "flags": 0,
-            "gas": 0n,
             "mode": 0,
             "stateGas": 0n,
             "value": 0n,
@@ -499,16 +500,43 @@ describe('from', () => {
 })
 
 describe('getSignPayload', () => {
+  test.each([
+    { scheme: 'secp256k1', signature: '0x' },
+    { scheme: 'p256', signature: '0x' },
+  ] as const)(
+    'empty $scheme placeholders preserve the signing hash',
+    (entry) => {
+      const { signature: _, ...unsigned } = entry
+      const envelope = {
+        chainId: 1,
+        frames: [{ executionGas: 50_000n, mode: 'sender' }],
+        sender: accounts[0].address,
+        signatures: [unsigned],
+      } as const
+      const input = {
+        ...envelope,
+        signatures: [entry],
+      } as const
+      expect(TxEnvelopeEip8141.getSignPayload(input)).toBe(
+        TxEnvelopeEip8141.getSignPayload(envelope),
+      )
+      expect(TxEnvelopeEip8141.serialize(input)).toBe(
+        TxEnvelopeEip8141.serialize(envelope),
+      )
+      expect(input.signatures[0].signature).toBe('0x')
+    },
+  )
+
   test('omitted nested defaults preserve the signing hash and encoding', () => {
     const envelope = TxEnvelopeEip8141.from({
       chainId: 1,
-      frames: [{ gas: 50_000n, mode: 'sender' }],
+      frames: [{ executionGas: 50_000n, mode: 'sender' }],
       sender: accounts[0].address,
       signatures: [{ scheme: 'secp256k1' }],
     })
     const explicit = TxEnvelopeEip8141.from({
       ...envelope,
-      frames: [Frame.from({ gas: 50_000n, mode: 'sender' })],
+      frames: [Frame.from({ executionGas: 50_000n, mode: 'sender' })],
       signatures: [FrameSignature.from({ scheme: 'secp256k1' })],
     })
     expect(TxEnvelopeEip8141.getSignPayload(envelope)).toBe(
@@ -630,26 +658,26 @@ describe('serialize', () => {
       const request = TransactionRequest.toRpc({
         frames: [
           Frame.from({
+            executionGas: 50_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
+            stateGas: 0n,
+          }),
+          Frame.from({
+            executionGas: 50_000n,
+            mode: 'sender',
+            stateGas: 0n,
+            to: target,
+            value: 1n,
           }),
-          Frame.from({ gas: 50_000n, mode: 'sender', to: target, value: 1n }),
         ],
         from: sender,
         signatures: [{ scheme: 'secp256k1' }],
-        // Nethermind's simulation mapping requires an outer recipient before processing frames.
-        to: sender,
         type: 'eip8141',
       })
-      // TODO: remove once migrated to reth or anvil.
-      // Nethermind validates signatures when filling gas, before the transaction can be signed.
-      await expect(
-        rpc.request({ method: 'eth_fillTransaction', params: [request] }),
-      ).rejects.toThrow('frame transaction signature has the wrong length')
       const { tx } = await rpc.request({
         method: 'eth_fillTransaction',
-        params: [{ ...request, gas: Hex.fromNumber(100_000n) }],
+        params: [request],
       })
       expect(tx.type).toBe('0x6')
       if (tx.type !== '0x6' || !tx.frames)
@@ -658,7 +686,6 @@ describe('serialize', () => {
       expect(tx.nonce).toBe(nonce)
       expect(tx.frames).toEqual(request.frames)
       expect(tx.signatures).toEqual(request.signatures)
-      expect(Hex.toBigInt(tx.gas)).toBe(100_000n)
       expect(Hex.toBigInt(tx.maxFeePerGas)).toBeGreaterThan(0n)
       expect(Hex.toBigInt(tx.maxPriorityFeePerGas)).toBeGreaterThanOrEqual(0n)
       expect(Hex.toBigInt(tx.maxFeePerGas)).toBeGreaterThanOrEqual(
@@ -728,14 +755,19 @@ describe('serialize', () => {
           chainId: 8141,
           frames: [
             Frame.from({
+              executionGas: 50_000n,
               flags: 'approveExecutionAndPayment',
-              gas: 50_000n,
               mode: 'verify',
             }),
-            Frame.from({ gas: 50_000n, mode: 'sender', to: target, value: 1n }),
+            Frame.from({
+              executionGas: 50_000n,
+              mode: 'sender',
+              to: target,
+              value: 1n,
+            }),
             Frame.from({
               data: '0xdeadbeef',
-              gas: 50_000n,
+              executionGas: 50_000n,
               mode: 'sender',
               to: '0x0000000000000000000000000000000000000004',
             }),
@@ -756,14 +788,12 @@ describe('serialize', () => {
         })
         const request = TransactionRequest.toRpc({
           ...TransactionEnvelope.toTransactionRequest(signed),
-          // Nethermind's simulation mapping requires an outer recipient before processing frames.
-          to: sender,
         })
         const result = await rpc.request({
           method,
           params: [request, 'latest'],
         })
-        // Frame return data is not exposed by Nethermind's transaction-level call result.
+        // Transaction-level calls do not expose individual frame return data.
         if (method === 'eth_call') expect(result).toBe('0x')
         else {
           // Estimation includes all signed frame budgets plus intrinsic gas.
@@ -774,11 +804,14 @@ describe('serialize', () => {
           rpc.request({
             method,
             params: [
-              { ...request, frames: [{ ...request.frames![0]!, mode: 255 }] },
+              {
+                ...request,
+                frames: [{ ...request.frames![0]!, mode: '0xff' }],
+              },
               'latest',
             ],
           }),
-        ).rejects.toThrow('frame mode')
+        ).rejects.toThrow('Invalid params')
         expect(
           await rpc.request({
             method: 'eth_getBalance',
@@ -806,11 +839,16 @@ describe('serialize', () => {
         chainId: 8141,
         frames: [
           Frame.from({
+            executionGas: 50_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
           }),
-          Frame.from({ gas: 50_000n, mode: 'sender', to: target, value: 1n }),
+          Frame.from({
+            executionGas: 50_000n,
+            mode: 'sender',
+            to: target,
+            value: 1n,
+          }),
         ],
         maxFeePerGas: 10_000_000_000n,
         maxPriorityFeePerGas: 1_000_000_000n,
@@ -840,10 +878,12 @@ describe('serialize', () => {
       })
       expect(hash).toBe(TransactionEnvelope.hash(signed))
       expect(
-        TransactionRequest.toEnvelope(
-          TransactionEnvelope.toTransactionRequest(signed),
+        TransactionEnvelope.serialize(
+          TransactionRequest.toEnvelope(
+            TransactionEnvelope.toTransactionRequest(signed),
+          ),
         ),
-      ).toEqual(signed)
+      ).toBe(serialized)
       expect(TxEnvelopeEip8141.toRpc(signed)).toMatchObject(
         TransactionRequest.toRpc(
           TransactionEnvelope.toTransactionRequest(signed),
@@ -939,18 +979,18 @@ describe('serialize', () => {
         chainId: 8141,
         frames: [
           Frame.from({
+            executionGas: 20_000n,
             flags: 'approveExecution',
-            gas: 50_000n,
             mode: 'verify',
           }),
           Frame.from({
+            executionGas: 20_000n,
             flags: 'approvePayment',
-            gas: 50_000n,
             mode: 'verify',
             to: accounts[1].address,
           }),
           Frame.from({
-            gas: 50_000n,
+            executionGas: 20_000n,
             mode: 'sender',
             to: accounts[1].address,
             value: 1n,
@@ -1045,25 +1085,25 @@ describe('serialize', () => {
         chainId: 8141,
         frames: [
           Frame.from({
+            executionGas: 50_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
           }),
           Frame.from({
+            executionGas: 50_000n,
             flags: 'atomicBatch',
-            gas: 50_000n,
             mode: 'sender',
             to: accounts[1].address,
             value: 1n,
           }),
           Frame.from({
+            executionGas: 50_000n,
             flags: 'atomicBatch',
-            gas: 50_000n,
             mode: 'sender',
             to: '0x0000000000000000000000000000000000001000',
           }),
           Frame.from({
-            gas: 50_000n,
+            executionGas: 50_000n,
             mode: 'sender',
             to: accounts[1].address,
             value: 2n,
@@ -1131,8 +1171,8 @@ describe('serialize', () => {
         chainId: 8141,
         frames: [
           Frame.from({
+            executionGas: 50_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
           }),
         ],
@@ -1166,7 +1206,7 @@ describe('serialize', () => {
           ],
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `[RpcResponse.InvalidInputError: transaction invalid, frame transaction SECP256K1 signer does not match the recovered address]`,
+        `[RpcResponse.InvalidInputError: EIP-8141 public mempool policy: validation prefix execution failed]`,
       )
     })
 
@@ -1176,13 +1216,13 @@ describe('serialize', () => {
         frames: [
           Frame.from({
             data: '0x0000000000000001',
-            gas: 50_000n,
+            executionGas: 20_000n,
             mode: 'verify',
             to: '0x0000000000000000000000000000000000008141',
           }),
           Frame.from({
+            executionGas: 20_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
           }),
         ],
@@ -1213,7 +1253,7 @@ describe('serialize', () => {
           params: [TxEnvelopeEip8141.serialize(signed)],
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `[RpcResponse.InvalidInputError: frame transaction expired]`,
+        `[RpcResponse.InvalidInputError: EIP-8141 public mempool policy: validation prefix execution failed]`,
       )
     })
 
@@ -1226,12 +1266,12 @@ describe('serialize', () => {
         chainId: 8141,
         frames: [
           Frame.from({
+            executionGas: 50_000n,
             flags: 'approveExecutionAndPayment',
-            gas: 50_000n,
             mode: 'verify',
           }),
           Frame.from({
-            gas: 50_000n,
+            executionGas: 50_000n,
             mode: 'sender',
             to: accounts[1].address,
             value: 1n,
@@ -1613,7 +1653,7 @@ describe('validate', () => {
     expect(
       TxEnvelopeEip8141.validate({
         chainId: 1,
-        frames: [{ gas: 2n ** 64n - 1n }, { stateGas: 1n }],
+        frames: [{ executionGas: 2n ** 64n - 1n }, { stateGas: 1n }],
         sender: accounts[0].address,
       }),
     ).toBe(false)
@@ -1623,7 +1663,7 @@ describe('validate', () => {
     expect(
       TxEnvelopeEip8141.validate({
         chainId: 1,
-        frames: [{ gas: 16_777_216n }],
+        frames: [{ executionGas: 16_777_216n }],
         sender: accounts[0].address,
       }),
     ).toBe(false)
@@ -1706,7 +1746,7 @@ describe('validate', () => {
 
     const frame = {
       data: '0x0000000000000001',
-      gas: 5000n,
+      executionGas: 5000n,
       mode: 'verify',
       to: '0x0000000000000000000000000000000000008141',
     } as const
@@ -1738,10 +1778,10 @@ describe('toRpc', () => {
       frames: [
         {
           data: '0x',
-          executionGasLimit: '0x0',
-          flags: 0,
-          mode: 0,
-          stateGasLimit: '0x0',
+          executionGas: '0x0',
+          flags: '0x0',
+          mode: '0x0',
+          stateGas: '0x0',
           value: '0x0',
         },
       ],
@@ -1773,3 +1813,456 @@ describe('fromRpc', () => {
     )
   })
 })
+
+describe('keyed nonces', () => {
+  const sender = '0x1111111111111111111111111111111111111111'
+  const envelope = TxEnvelopeEip8141.from({
+    chainId: 1,
+    frames: [{ mode: 'sender' }],
+    sender,
+    signatures: [{ scheme: 'arbitrary', signature: '0xdeadbeef' }],
+  })
+
+  // Generated independently with ethers 6.17 from the literal EIP-8250 RLP layout.
+  const vectors = [
+    {
+      nonceKeys: undefined,
+      nonce: 0n,
+      serialized:
+        '0x06f00180941111111111111111111111111111111111111111c9c8028080c280808080c9c880808084deadbeefc3808080c0',
+      hash: '0xa14c90dee4c545369e201e4975ee2ef415357df20a0a183d1be9f602bac9a47d',
+      signHash:
+        '0x5682abf965767351637964eed1fe3f775ab45de426def7da68736cf2ae0a43b5',
+    },
+    {
+      nonceKeys: [0n],
+      nonce: 0n,
+      serialized:
+        '0x06f201c18080941111111111111111111111111111111111111111c9c8028080c280808080c9c880808084deadbeefc3808080c0',
+      hash: '0x069a1528377db98ed06429aab0dad8043315859ac454ce3e1f5a250e365d072d',
+      signHash:
+        '0xd573654ae8d57432b3856b0078fb98f2f3e4d3f73a023d7ba8a952a16d0f4726',
+    },
+    {
+      nonceKeys: [1n, 128n, 2n ** 256n - 1n],
+      nonce: 2n ** 64n - 2n,
+      serialized:
+        '0x06f85d01e4018180a0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff88fffffffffffffffe941111111111111111111111111111111111111111c9c8028080c280808080c9c880808084deadbeefc3808080c0',
+      hash: '0x620915f063bdd017a09ae856d0043d064568b3455aba741d7ebc748731fc503f',
+      signHash:
+        '0x3d28f5f76f353611385be1512c2832220686b27cad3c53d5b07941de1515319b',
+    },
+  ] as const
+
+  describe('serialize', () => {
+    test.each(vectors)(
+      'independent encoding and signing vector %#',
+      (vector) => {
+        const value = {
+          ...envelope,
+          nonce: vector.nonce,
+          nonceKeys: vector.nonceKeys,
+        }
+        expect(TxEnvelopeEip8141.serialize(value)).toBe(vector.serialized)
+        expect(TxEnvelopeEip8141.hash(value)).toBe(vector.hash)
+        expect(TxEnvelopeEip8141.getSignPayload(value)).toBe(vector.signHash)
+        expect(TransactionEnvelope.serialize(value)).toBe(vector.serialized)
+        expect(TransactionEnvelope.getSignPayload(value)).toBe(vector.signHash)
+        const decoded = TransactionEnvelope.deserialize(vector.serialized)
+        expect(TxEnvelopeEip8141.serialize(decoded)).toBe(vector.serialized)
+        expect(decoded.nonceKeys).toEqual(vector.nonceKeys)
+        expect(decoded.nonce).toBe(vector.nonce)
+        expect(TxEnvelopeEip8141.getSignPayload(decoded)).toBe(vector.signHash)
+      },
+    )
+
+    test('matches independent literal RLP layout', () => {
+      const body = [
+        '0x01',
+        ['0x01', '0x8180'],
+        '0x05',
+        sender,
+        [['0x02', '0x', '0x', ['0x', '0x'], '0x', '0x']],
+        [['0x', '0x', '0x', '0xdeadbeef']],
+        ['0x', '0x', '0x'],
+        [],
+      ]
+      const serialized = `0x06${encodeRlp(body).slice(2)}`
+      const value = { ...envelope, nonceKeys: [1n, 33152n], nonce: 5n }
+      expect(TxEnvelopeEip8141.serialize(value)).toBe(serialized)
+      expect(TxEnvelopeEip8141.hash(value)).toBe(keccak256(serialized))
+    })
+
+    test('keyed PeerDAS wrapper preserves keys and excludes sidecars from hashes', () => {
+      const commitment = `0x${'00'.repeat(48)}` as const
+      const value = {
+        ...envelope,
+        nonceKeys: [1n],
+        blobVersionedHashes: [Blobs.commitmentToVersionedHash(commitment)],
+        sidecars: {
+          blobs: [`0x${'00'.repeat(Blobs.bytesPerBlob)}` as const],
+          commitments: [commitment],
+          cellProofs: Array.from({ length: 128 }, () => commitment),
+        },
+      }
+      const serialized = TxEnvelopeEip8141.serialize(value)
+      const decoded = TxEnvelopeEip8141.deserialize(serialized)
+      expect(decoded.nonceKeys).toMatchInlineSnapshot(`
+        [
+          1n,
+        ]
+      `)
+      expect(TxEnvelopeEip8141.serialize(decoded)).toBe(serialized)
+      expect(TxEnvelopeEip8141.hash(value)).toBe(
+        TxEnvelopeEip8141.hash({ ...value, sidecars: undefined }),
+      )
+      expect(TxEnvelopeEip8141.getSignPayload(value)).toBe(
+        TxEnvelopeEip8141.getSignPayload({ ...value, sidecars: undefined }),
+      )
+    })
+  })
+
+  describe('assert', () => {
+    test.each([
+      [],
+      [0n, 1n],
+      [1n, 1n],
+      [2n, 1n],
+      [-1n],
+      [2n ** 256n],
+      Array.from({ length: 17 }, (_, i) => BigInt(i + 1)),
+    ])('rejects invalid keys %#', (...nonceKeys) => {
+      expect(TxEnvelopeEip8141.validate({ ...envelope, nonceKeys })).toBe(false)
+      expect(() =>
+        TxEnvelopeEip8141.serialize({ ...envelope, nonceKeys }),
+      ).toThrow()
+    })
+
+    test('accepts 16 keys and the maximum key', () => {
+      expect(
+        TxEnvelopeEip8141.validate({
+          ...envelope,
+          nonceKeys: Array.from({ length: 16 }, (_, i) => BigInt(i + 1)),
+        }),
+      ).toBe(true)
+      expect(
+        TxEnvelopeEip8141.validate({
+          ...envelope,
+          nonceKeys: [2n ** 256n - 1n],
+        }),
+      ).toBe(true)
+    })
+
+    test.each([-1n, 2n ** 64n - 1n, 2n ** 64n])(
+      'rejects invalid shared sequence %s',
+      (nonce) => {
+        expect(() =>
+          TxEnvelopeEip8141.assert({ ...envelope, nonceKeys: [1n], nonce }),
+        ).toThrowErrorMatchingInlineSnapshot(
+          `[FrameNonce.InvalidError: Nonce must be less than 2^64 - 1 and nonnegative.]`,
+        )
+      },
+    )
+
+    test('rejects a numeric key or null list', () => {
+      // @ts-expect-error invalid runtime input
+      expect(TxEnvelopeEip8141.validate({ ...envelope, nonceKeys: [1] })).toBe(
+        false,
+      )
+      // @ts-expect-error invalid runtime input
+      expect(TxEnvelopeEip8141.validate({ ...envelope, nonceKeys: null })).toBe(
+        false,
+      )
+    })
+
+    test('charges encoded nonce calldata against the transaction gas cap', () => {
+      const value = {
+        ...envelope,
+        signatures: [],
+        frames: [{ executionGas: 16_764_741n }],
+      }
+      expect(TxEnvelopeEip8141.validate(value)).toBe(true)
+      expect(TxEnvelopeEip8141.validate({ ...value, nonceKeys: [0n] })).toBe(
+        false,
+      )
+      // rlp([0]) || rlp(0) = c1 80 80, three nonzero bytes at 16 gas each.
+      expect(
+        TxEnvelopeEip8141.validate({
+          ...value,
+          nonceKeys: [0n],
+          frames: [{ executionGas: 16_764_693n }],
+        }),
+      ).toBe(true)
+    })
+  })
+
+  describe('deserialize', () => {
+    test.each([
+      ['0x', '0x'],
+      [[], '0x'],
+      [['0x00'], '0x'],
+      [['0x0001'], '0x'],
+      [[['0x01']], '0x'],
+      [['0x01'], '0x00'],
+      [['0x01'], '0x0001'],
+      [['0x01'], []],
+      [['0x01', '0x01'], '0x'],
+      [['0x02', '0x01'], '0x'],
+      [['0x', '0x01'], '0x'],
+      [[`0x01${'00'.repeat(32)}`], '0x'],
+      [['0x01'], '0x010000000000000000'],
+    ])('rejects malformed nonce fields %#', (keys, nonce) => {
+      const serialized =
+        `0x06${encodeRlp(['0x01', keys, nonce, sender, [['0x02', '0x', '0x', ['0x', '0x'], '0x', '0x']], [], ['0x', '0x', '0x'], []]).slice(2)}` as const
+      expect(() => TxEnvelopeEip8141.deserialize(serialized)).toThrow()
+    })
+
+    test('rejects nonminimal RLP string and list lengths', () => {
+      const canonical = vectors[1].serialized
+      expect(() =>
+        TxEnvelopeEip8141.deserialize(
+          canonical.replace(
+            'f201c180',
+            'f301c28100',
+          ) as TxEnvelopeEip8141.Serialized,
+        ),
+      ).toThrow()
+      expect(() =>
+        TxEnvelopeEip8141.deserialize(
+          canonical.replace(
+            'f201c180',
+            'f301f80180',
+          ) as TxEnvelopeEip8141.Serialized,
+        ),
+      ).toThrow()
+      expect(() =>
+        TxEnvelopeEip8141.deserialize(
+          canonical.replace('f201', 'f83201') as TxEnvelopeEip8141.Serialized,
+        ),
+      ).toThrow()
+    })
+  })
+
+  describe('getSignPayload', () => {
+    test('signatures bind the complete key set and sequence', () => {
+      const value = {
+        ...envelope,
+        nonceKeys: [1n, 2n],
+        nonce: 0n,
+        signatures: [{ scheme: 'secp256k1' } as const],
+      }
+      const privateKey =
+        '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef'
+      const publicKey = Secp256k1.getPublicKey({ privateKey })
+      const signature = Secp256k1.sign({
+        privateKey,
+        payload: TxEnvelopeEip8141.getSignPayload(value),
+      })
+      const signed = {
+        ...value,
+        signatures: [{ scheme: 'secp256k1', signature } as const],
+      }
+      expect(
+        Secp256k1.verify({
+          publicKey,
+          signature,
+          payload: TxEnvelopeEip8141.getSignPayload(signed),
+        }),
+      ).toBe(true)
+      expect(
+        Secp256k1.verify({
+          publicKey,
+          signature,
+          payload: TxEnvelopeEip8141.getSignPayload({
+            ...signed,
+            nonceKeys: [1n, 3n],
+          }),
+        }),
+      ).toBe(false)
+      expect(
+        Secp256k1.verify({
+          publicKey,
+          signature,
+          payload: TxEnvelopeEip8141.getSignPayload({ ...signed, nonce: 1n }),
+        }),
+      ).toBe(false)
+    })
+
+    test('commits to keys and shared sequence without mutating signatures', () => {
+      const value = { ...envelope, nonceKeys: [1n, 2n], nonce: 3n }
+      const hash = TxEnvelopeEip8141.getSignPayload(value)
+      expect(
+        TxEnvelopeEip8141.getSignPayload({ ...value, nonceKeys: [1n, 3n] }),
+      ).not.toBe(hash)
+      expect(
+        TxEnvelopeEip8141.getSignPayload({ ...value, nonce: 4n }),
+      ).not.toBe(hash)
+      expect(
+        TxEnvelopeEip8141.getSignPayload({ ...value, nonceKeys: [1n] }),
+      ).not.toBe(hash)
+      expect(
+        TxEnvelopeEip8141.getSignPayload({
+          ...value,
+          signatures: [{ scheme: 'arbitrary', signature: '0xabcdef' }],
+        }),
+      ).toBe(hash)
+      expect(value.signatures[0].signature).toBe('0xdeadbeef')
+    })
+
+    test('retains explicit-message signatures', () => {
+      const value = {
+        ...envelope,
+        nonceKeys: [1n],
+        signatures: [
+          {
+            scheme: 'arbitrary',
+            payload: `0x${'11'.repeat(32)}`,
+            signature: '0xdeadbeef',
+          } as const,
+        ],
+      }
+      expect(TxEnvelopeEip8141.getSignPayload(value)).toBe(
+        TxEnvelopeEip8141.hash(value),
+      )
+      expect(
+        TxEnvelopeEip8141.getSignPayload({
+          ...value,
+          signatures: [{ ...value.signatures[0]!, signature: '0xabcdef' }],
+        }),
+      ).not.toBe(TxEnvelopeEip8141.getSignPayload(value))
+    })
+  })
+
+  describe('toRpc', () => {
+    test.each(vectors)(
+      'preserves absent or explicit nonce keys %#',
+      (vector) => {
+        const value = {
+          ...envelope,
+          nonceKeys: vector.nonceKeys,
+          nonce: vector.nonce,
+        }
+        const rpc = TxEnvelopeEip8141.toRpc(value)
+        expect('nonceSeq' in rpc).toBe(false)
+        expect('nonceKeys' in rpc).toBe(vector.nonceKeys !== undefined)
+        expect(rpc.nonceKeys).toEqual(
+          vector.nonceKeys?.map((key) => Hex.fromNumber(key)),
+        )
+        expect(rpc.nonce).toBe(Hex.fromNumber(vector.nonce))
+        expect(
+          TxEnvelopeEip8141.serialize(TxEnvelopeEip8141.fromRpc(rpc)),
+        ).toBe(vector.serialized)
+        const request = TransactionEnvelope.toTransactionRequest(value)
+        expect(request.nonceKeys).toEqual(vector.nonceKeys)
+        expect(
+          TransactionEnvelope.serialize(TransactionRequest.toEnvelope(request)),
+        ).toBe(vector.serialized)
+      },
+    )
+
+    test('request conversion preserves omitted sequence and frame gas', () => {
+      const request = {
+        type: 'eip8141',
+        nonceKeys: [1n, 2n],
+        frames: [{ mode: 'sender' }, { mode: 'sender', executionGas: 0n }],
+      } as const
+      const rpc = TransactionRequest.toRpc(request)
+      expect(rpc.nonce).toBeUndefined()
+      expect(rpc.nonceKeys).toMatchInlineSnapshot(`
+        [
+          "0x1",
+          "0x2",
+        ]
+      `)
+      expect(rpc.frames?.map((frame) => frame.executionGas)).toEqual([
+        undefined,
+        '0x0',
+      ])
+      expect(TransactionRequest.fromRpc(rpc).nonceKeys).toEqual(
+        request.nonceKeys,
+      )
+      expect(TransactionRequest.toRpc({ ...request, nonce: 0n }).nonce).toBe(
+        '0x0',
+      )
+    })
+
+    test('transaction result conversion retains keyed nonces', () => {
+      const rpc = {
+        ...TxEnvelopeEip8141.toRpc({
+          ...envelope,
+          nonceKeys: [1n, 2n],
+          nonce: 3n,
+        }),
+        blockHash: null,
+        blockNumber: null,
+        transactionIndex: null,
+        hash: `0x${'11'.repeat(32)}` as const,
+      }
+      const value = Transaction.fromRpc(rpc, { pending: true })!
+      expect(value.nonceKeys).toMatchInlineSnapshot(`
+        [
+          1n,
+          2n,
+        ]
+      `)
+      expect(Transaction.toRpc(value, { pending: true }).nonceKeys).toEqual(
+        rpc.nonceKeys,
+      )
+      expect(value.nonce).toBe(3n)
+    })
+
+    test('accepts numberish keys without losing uint256 precision', () => {
+      expect(
+        TxEnvelopeEip8141.toRpc({
+          ...envelope,
+          nonceKeys: ['0x1', 128, 2n ** 256n - 1n],
+          nonce: '0x0',
+        }).nonceKeys,
+      ).toEqual(['0x1', '0x80', `0x${'ff'.repeat(32)}`])
+    })
+  })
+
+  describe('fromRpc', () => {
+    test('requires the sequence in keyed transaction results', () => {
+      const value = {
+        ...TxEnvelopeEip8141.toRpc({ ...envelope, nonceKeys: [1n] }),
+        nonce: undefined,
+      }
+      expect(() =>
+        Transaction.fromRpc(value as never),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[FrameNonce.InvalidError: A keyed transaction result requires nonce.]`,
+      )
+    })
+
+    test.each([
+      '0x00',
+      '0x01',
+      '0x',
+      '0x10000000000000000',
+      '0xffffffffffffffff',
+    ])('rejects invalid keyed sequence %s', (nonce) => {
+      expect(() =>
+        TxEnvelopeEip8141.fromRpc({
+          ...TxEnvelopeEip8141.toRpc(envelope),
+          nonceKeys: ['0x1'],
+          nonce: nonce as Hex.Hex,
+        }),
+      ).toThrow()
+      expect(() =>
+        TransactionRequest.fromRpc({
+          nonceKeys: ['0x1'],
+          nonce: nonce as Hex.Hex,
+        }),
+      ).toThrow()
+    })
+    test.each([['0x01'], ['0x'], ['0x0', '0x1'], ['0x2', '0x1']])(
+      'rejects invalid RPC keys %j',
+      (...nonceKeys) => {
+        expect(() =>
+          TransactionRequest.fromRpc({ nonceKeys: nonceKeys as Hex.Hex[] }),
+        ).toThrow()
+      },
+    )
+  })
+})