ox 1.8.1 → 1.8.4

package/src/core/TxEnvelopeEip8141.ts

@@ -6,12 +6,18 @@ import * as Frame from './Frame.js'
 import * as FrameSignature from './FrameSignature.js'
 import * as Hash from './Hash.js'
 import * as Hex from './Hex.js'
+import * as FrameNonce from './internal/frameNonce.js'
 import * as Quantity from './internal/quantity.js'
 import type { Assign, Compute, PartialBy } from './internal/types.js'
 import * as Rlp from './Rlp.js'
 import type * as TxEnvelopeEip4844 from './TxEnvelopeEip4844.js'
 
-/** An EIP-8141 transaction containing independently budgeted call frames. */
+/**
+ * An EIP-8141 transaction containing independently budgeted call frames.
+ *
+ * Omitted `nonceKeys` preserves the original EIP-8141 encoding. Supplying keys,
+ * including `[0n]`, selects EIP-8250 encoding and changes the signing hash.
+ */
 export type TxEnvelopeEip8141 = {
   /** Versioned blob hashes. @default [] */
   blobVersionedHashes?: readonly Hex.Hex[] | undefined
@@ -25,8 +31,10 @@ export type TxEnvelopeEip8141 = {
   maxFeePerGas?: bigint | undefined
   /** Maximum priority fee per gas, in wei. @default 0n */
   maxPriorityFeePerGas?: bigint | undefined
-  /** Sender nonce. @default 0n */
+  /** Sender nonce or shared sequence. With `nonceKeys`, the sequence must be less than 2^64 - 1. @default 0n */
   nonce?: bigint | undefined
+  /** EIP-8250 domains: 1–16 strictly increasing uint256 keys. `[0n]` selects the legacy account nonce; zero cannot accompany other keys. */
+  nonceKeys?: readonly bigint[] | undefined
   /** Account authorizing execution. */
   sender: Address.Address
   /** PeerDAS sidecars. Excluded from transaction and signing hashes. */
@@ -53,8 +61,10 @@ export type Rpc = {
   maxFeePerGas: Hex.Hex
   /** Maximum priority fee per gas. */
   maxPriorityFeePerGas: Hex.Hex
-  /** Sender nonce. */
+  /** Sender nonce or shared EIP-8250 sequence. */
   nonce: Hex.Hex
+  /** EIP-8250 domains. Omitted for the original EIP-8141 encoding. */
+  nonceKeys?: readonly Hex.Hex[] | undefined
   /** Frame signature entries. */
   signatures: readonly FrameSignature.Rpc[]
   /** RPC transaction type. */
@@ -90,7 +100,7 @@ export type Type = typeof type
  *
  * TxEnvelopeEip8141.assert({
  *   chainId: 1,
- *   frames: [{ gas: 50_000n, mode: 'verify' }],
+ *   frames: [{ executionGas: 50_000n, mode: 'verify' }],
  *   sender: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8'
  * })
  * ```
@@ -106,6 +116,7 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
     maxFeePerGas = 0n,
     maxPriorityFeePerGas = 0n,
     nonce = 0n,
+    nonceKeys,
     sender,
     signatures = [],
   } = envelope
@@ -118,6 +129,7 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
     throw new InvalidError(
       'chainId must be an unsigned 256-bit integer; use bigint for large IDs.',
     )
+  if (nonceKeys !== undefined) FrameNonce.assert(nonceKeys, nonce)
   Address.assert(sender, { strict: false })
   for (const [field, value, bits] of [
     ['maxFeePerBlobGas', maxFeePerBlobGas, 256n],
@@ -146,7 +158,7 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
   }
   if (blobVersionedHashes.length === 0 && maxFeePerBlobGas !== 0n)
     throw new InvalidError('maxFeePerBlobGas must be zero without blobs.')
-  let gas = 0n
+  let executionGas = 0n
   let stateGas = 0n
   let previousBatch = false
   let expiry = false
@@ -157,6 +169,18 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
     for (const byte of Hex.toBytes(data)) tokens += byte === 0 ? 1n : 4n
     size += BigInt(Hex.size(data))
   }
+  if (nonceKeys !== undefined) {
+    count(
+      Rlp.fromHex(
+        nonceKeys.map((key) =>
+          key === 0n ? '0x' : Hex.fromBytes(Bytes.fromNumber(key)),
+        ),
+      ),
+    )
+    count(
+      Rlp.fromHex(nonce === 0n ? '0x' : Hex.fromBytes(Bytes.fromNumber(nonce))),
+    )
+  }
   for (const [index, frame] of (frames as readonly Frame.Frame[]).entries()) {
     Frame.assert(frame)
     const flags =
@@ -193,7 +217,7 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
         throw new InvalidError('Invalid or duplicate expiry verifier frame.')
       expiry = true
     }
-    gas += frame.gas ?? 0n
+    executionGas += frame.executionGas ?? 0n
     stateGas += frame.stateGas ?? 0n
     count(frame.data ?? '0x')
     if (
@@ -210,10 +234,10 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
     count(payload)
     count(signature)
   }
-  if (gas + stateGas >= 2n ** 64n)
+  if (executionGas + stateGas >= 2n ** 64n)
     throw new InvalidError('Combined frame gas must be less than 2^64.')
   if (
-    intrinsic + tokens * 4n + gas > 16_777_216n ||
+    intrinsic + tokens * 4n + executionGas > 16_777_216n ||
     intrinsic + size * 64n > 16_777_216n
   )
     throw new InvalidError('Transaction execution gas exceeds 16777216.')
@@ -221,6 +245,7 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
 export declare namespace assert {
   type ErrorType =
     | InvalidError
+    | FrameNonce.InvalidError
     | Frame.assert.ErrorType
     | FrameSignature.toTuple.ErrorType
     | Address.assert.ErrorType
@@ -258,9 +283,14 @@ export function deserialize(serialized: Serialized): TxEnvelopeEip8141 {
     throw new InvalidError('Expected a transaction list.')
   const wrapped = Array.isArray(decoded[0])
   const body = wrapped ? decoded[0] : decoded
-  if (!Array.isArray(body) || body.length !== 7)
-    throw new InvalidError('Expected seven transaction fields.')
-  const [chainId, nonce, sender, frames, signatures, fees, hashes] = body
+  if (!Array.isArray(body) || (body.length !== 7 && body.length !== 8))
+    throw new InvalidError('Expected seven or eight transaction fields.')
+  const keyed = body.length === 8
+  const [chainId, ...fields] = body
+  const keys = keyed ? fields.shift() : undefined
+  if (keyed && !Array.isArray(keys))
+    throw new InvalidError('Expected a nonce key list.')
+  const [nonce, sender, frames, signatures, fees, hashes] = fields
   if (
     typeof sender !== 'string' ||
     !Array.isArray(frames) ||
@@ -288,6 +318,7 @@ export function deserialize(serialized: Serialized): TxEnvelopeEip8141 {
     maxFeePerGas: integer(fees[1]),
     maxPriorityFeePerGas: integer(fees[0]),
     nonce: integer(nonce),
+    ...(Array.isArray(keys) ? { nonceKeys: keys.map(integer) } : {}),
     sender: sender as Address.Address,
     signatures: signatures.map((entry) =>
       FrameSignature.fromTuple(entry as FrameSignature.Tuple),
@@ -337,8 +368,8 @@ export declare namespace deserialize {
  *   chainId: 1,
  *   frames: [
  *     {
+ *       executionGas: 50_000n,
  *       flags: 'approveExecutionAndPayment',
- *       gas: 50_000n,
  *       mode: 'verify'
  *     }
  *   ],
@@ -403,6 +434,9 @@ export function fromRpc(envelope: Rpc): TxEnvelopeEip8141 {
     maxFeePerGas: Hex.toBigInt(envelope.maxFeePerGas),
     maxPriorityFeePerGas: Hex.toBigInt(envelope.maxPriorityFeePerGas),
     nonce: Hex.toBigInt(envelope.nonce),
+    ...(envelope.nonceKeys !== undefined
+      ? { nonceKeys: FrameNonce.fromRpc(envelope.nonceKeys, envelope.nonce) }
+      : {}),
     sender: envelope.from,
     signatures: envelope.signatures.map(FrameSignature.fromRpc),
   })
@@ -410,6 +444,7 @@ export function fromRpc(envelope: Rpc): TxEnvelopeEip8141 {
 
 export declare namespace fromRpc {
   type ErrorType =
+    | FrameNonce.InvalidError
     | from.ErrorType
     | Frame.fromRpc.ErrorType
     | FrameSignature.fromRpc.ErrorType
@@ -448,6 +483,9 @@ export function toRpc(envelope: toRpc.Input): Rpc {
       envelope.maxPriorityFeePerGas ?? 0n,
     ),
     nonce: Quantity.fromNumberish(envelope.nonce ?? 0n),
+    ...(envelope.nonceKeys !== undefined
+      ? { nonceKeys: FrameNonce.toRpc(envelope.nonceKeys, envelope.nonce) }
+      : {}),
     signatures: (envelope.signatures ?? []).map(FrameSignature.toRpc),
     type: '0x6',
   }
@@ -462,6 +500,7 @@ export declare namespace toRpc {
     | 'maxFeePerGas'
     | 'maxPriorityFeePerGas'
     | 'nonce'
+    | 'nonceKeys'
     | 'type'
   > & {
     chainId: Hex.Hex | bigint | number
@@ -470,9 +509,11 @@ export declare namespace toRpc {
     maxFeePerGas?: Hex.Hex | bigint | number | undefined
     maxPriorityFeePerGas?: Hex.Hex | bigint | number | undefined
     nonce?: Hex.Hex | bigint | number | undefined
+    nonceKeys?: readonly (Hex.Hex | bigint | number)[] | undefined
     type?: Type | undefined
   }
   type ErrorType =
+    | FrameNonce.InvalidError
     | Frame.toRpc.ErrorType
     | FrameSignature.toRpc.ErrorType
     | Hex.fromNumber.ErrorType
@@ -503,8 +544,8 @@ export declare namespace toRpc {
  *   chainId: 1,
  *   frames: [
  *     {
+ *       executionGas: 50_000n,
  *       flags: 'approveExecutionAndPayment',
- *       gas: 50_000n,
  *       mode: 'verify'
  *     }
  *   ],
@@ -560,10 +601,12 @@ export function hash(
 ): Hex.Hex {
   assert(envelope)
   const body = toTuple(envelope)
-  if (options.presign)
-    body[4] = body[4].map((entry) =>
-      entry[2] === '0x' ? [entry[0], entry[1], entry[2], '0x'] : entry,
-    )
+  if (options.presign) {
+    const signatures = body.length === 8 ? body[5] : body[4]
+    for (const [index, entry] of signatures.entries())
+      if (entry[2] === '0x')
+        signatures[index] = [entry[0], entry[1], entry[2], '0x']
+  }
   return Hash.keccak256(Hex.concat(serializedType, Rlp.fromHex(body)))
 }
 export declare namespace hash {
@@ -589,7 +632,7 @@ export declare namespace hash {
  *
  * const envelope = TxEnvelopeEip8141.from({
  *   chainId: 1,
- *   frames: [{ gas: 50_000n, mode: 'sender' }],
+ *   frames: [{ executionGas: 50_000n, mode: 'sender' }],
  *   sender: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8'
  * })
  * const serialized = TxEnvelopeEip8141.serialize(envelope)
@@ -690,8 +733,7 @@ export class InvalidError extends Errors.BaseError {
 function toTuple(envelope: PartialBy<TxEnvelopeEip8141, 'type'>) {
   const quantity = (value: bigint | number | undefined): Hex.Hex =>
     value ? Hex.fromBytes(Bytes.fromNumber(value)) : '0x'
-  return [
-    quantity(envelope.chainId),
+  const fields = [
     quantity(envelope.nonce),
     envelope.sender,
     envelope.frames.map((frame) => Frame.toTuple(frame)),
@@ -703,7 +745,6 @@ function toTuple(envelope: PartialBy<TxEnvelopeEip8141, 'type'>) {
     ],
     envelope.blobVersionedHashes ?? [],
   ] satisfies [
-    Hex.Hex,
     Hex.Hex,
     Address.Address,
     Frame.Tuple[],
@@ -711,4 +752,11 @@ function toTuple(envelope: PartialBy<TxEnvelopeEip8141, 'type'>) {
     Hex.Hex[],
     readonly Hex.Hex[],
   ]
+  return envelope.nonceKeys === undefined
+    ? ([quantity(envelope.chainId), ...fields] as const)
+    : ([
+        quantity(envelope.chainId),
+        envelope.nonceKeys.map(quantity),
+        ...fields,
+      ] as const)
 }

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

@@ -136,6 +136,8 @@ describe('decode', () => {
       params: [hash],
     }))!
 
+    if (input === undefined) throw new Error('Missing transaction input')
+
     expect(
       AbiConstructor.decode(abiConstructor, {
         bytecode: Constructor.bytecode.object,

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

@@ -4,14 +4,15 @@ import { expectTypeOf, test } from 'vite-plus/test'
 test('from preserves literals', () => {
   const frame = Frame.from({
     data: '0x',
+    executionGas: 50_000n,
     flags: 3,
-    gas: 50_000n,
     mode: 1,
     stateGas: 0n,
     value: 0n,
   })
   expectTypeOf(frame.mode).toEqualTypeOf<1>()
-  expectTypeOf(frame.gas).toEqualTypeOf<50_000n>()
+  expectTypeOf(frame.executionGas).toEqualTypeOf<50_000n>()
+  expectTypeOf(frame.stateGas).toEqualTypeOf<0n>()
   expectTypeOf(Frame.toTuple(frame)).toEqualTypeOf<Frame.Tuple>()
 })
 
@@ -31,8 +32,8 @@ test('tuple accepts readonly input', () => {
 test('rejects unsupported modes and unsafe numeric budgets', () => {
   Frame.from({
     data: '0x',
+    executionGas: 0n,
     flags: 0,
-    gas: 0n,
     // @ts-expect-error Unknown mode names are not supported.
     mode: 'unknown',
     stateGas: 0n,
@@ -40,9 +41,9 @@ test('rejects unsupported modes and unsafe numeric budgets', () => {
   })
   Frame.from({
     data: '0x',
-    flags: 0,
     // @ts-expect-error Gas budgets use bigint.
-    gas: 1,
+    executionGas: 1,
+    flags: 0,
     mode: 1,
     stateGas: 0n,
     value: 0n,
@@ -52,8 +53,8 @@ test('rejects unsupported modes and unsafe numeric budgets', () => {
 test('flags accept numbers and a strict named union', () => {
   const input = {
     data: '0x',
+    executionGas: 0n,
     flags: 'approvePayment',
-    gas: 0n,
     mode: 1,
     stateGas: 0n,
     value: 0n,
@@ -74,8 +75,8 @@ test('flags accept numbers and a strict named union', () => {
 test('mode accepts numbers and a strict named union', () => {
   const frame = Frame.from({
     data: '0x',
+    executionGas: 0n,
     flags: 0,
-    gas: 0n,
     mode: 'sender',
     stateGas: 0n,
     value: 1n,
@@ -95,6 +96,14 @@ test('allows omitted zero fields without widening supplied literals', () => {
   ).toEqualTypeOf<Frame.Tuple>()
 })
 
+test('execution gas is named explicitly', () => {
+  const invalid: Frame.Frame = {
+    // @ts-expect-error The execution budget is named executionGas.
+    gas: 50_000n,
+  }
+  void invalid
+})
+
 test('destination is named to', () => {
   const frame = Frame.from({ to: '0x1111111111111111111111111111111111111111' })
   expectTypeOf(

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",
+      }
+    `)
+  })
+})