ox 1.8.1 → 1.8.3

package/src/core/FrameRequest.ts

@@ -0,0 +1,78 @@
+import * as Frame from './Frame.js'
+import type { Compute, PartialBy } from './internal/types.js'
+
+/** A frame request whose omitted gas limits are estimated by the node. */
+export type FrameRequest<bigintType = bigint> = Frame.Frame<bigintType>
+
+/** JSON-RPC frame request. Only the execution mode is required. */
+export type Rpc = Compute<
+  PartialBy<Frame.Rpc, Exclude<keyof Frame.Rpc, 'mode'>>
+>
+
+/**
+ * Converts an RPC frame request, preserving omitted gas limits for node estimation.
+ *
+ * @example
+ * ```ts twoslash
+ * import { FrameRequest } from 'ox'
+ *
+ * const frame = FrameRequest.fromRpc({
+ *   mode: '0x2',
+ *   stateGas: '0x0'
+ * })
+ * ```
+ *
+ * @param frame - The RPC frame request.
+ * @returns The decoded request with omitted gas limits preserved.
+ */
+export function fromRpc(frame: Rpc): FrameRequest {
+  const { executionGas, stateGas, ...rest } = Frame.fromRpc({
+    ...frame,
+    data: frame.data ?? '0x',
+    executionGas: frame.executionGas ?? '0x0',
+    flags: frame.flags ?? '0x0',
+    stateGas: frame.stateGas ?? '0x0',
+    value: frame.value ?? '0x0',
+  })
+  return {
+    ...rest,
+    ...(frame.executionGas === undefined ? {} : { executionGas }),
+    ...(frame.stateGas === undefined ? {} : { stateGas }),
+  }
+}
+
+export declare namespace fromRpc {
+  type ErrorType = Frame.fromRpc.ErrorType
+}
+
+/**
+ * Converts a frame request to RPC fields without filling omitted gas limits.
+ *
+ * Explicit zero limits remain zero. Omitted mode, flags, value, and data use frame defaults.
+ *
+ * @example
+ * ```ts twoslash
+ * import { FrameRequest } from 'ox'
+ *
+ * const frame = FrameRequest.toRpc({
+ *   mode: 'sender',
+ *   stateGas: 0n
+ * })
+ * ```
+ *
+ * @param frame - The frame request. Gas and value accept hex, bigint, or number values.
+ * @returns The RPC request with omitted gas limits preserved.
+ */
+export function toRpc(frame: toRpc.Input): Rpc {
+  const { executionGas, stateGas, ...rest } = Frame.toRpc(frame)
+  return {
+    ...rest,
+    ...(frame.executionGas === undefined ? {} : { executionGas }),
+    ...(frame.stateGas === undefined ? {} : { stateGas }),
+  }
+}
+
+export declare namespace toRpc {
+  type Input = Frame.toRpc.Input
+  type ErrorType = Frame.toRpc.ErrorType
+}

package/src/core/FrameSignature.ts

@@ -26,19 +26,19 @@ export type Arbitrary = {
   signer?: undefined
 }
 
-/** A structured secp256k1 signature entry. */
+/** A secp256k1 signature entry. */
 export type Secp256k1 = {
   /** Explicit nonzero digest. Omit or use empty bytes for the transaction signing hash. */
   payload?: Hex.Hex | undefined
   /** secp256k1 verification scheme. */
   scheme: 1 | 'secp256k1'
-  /** Recovered signature. Omit for an unsigned entry. */
-  signature?: Signature.Signature | undefined
+  /** Recovered signature or `Signature.toHex` bytes. Omit or use `0x` for an unsigned entry. */
+  signature?: Hex.Hex | Signature.Signature | undefined
   /** Signer address. Omit to use the transaction sender. */
   signer?: Address.Address | undefined
 }
 
-/** A structured P-256 signature entry. */
+/** A P-256 signature entry. */
 export type P256 = {
   /** Explicit nonzero digest. Omit or use empty bytes for the transaction signing hash. */
   payload?: Hex.Hex | undefined
@@ -50,14 +50,14 @@ export type P256 = {
   | {
       /** Uncompressed P-256 public key. */
       publicKey: PublicKey.PublicKey
-      /** P-256 signature. */
-      signature: Signature.Signature<false>
+      /** P-256 signature or `Signature.toHex` bytes. */
+      signature: Hex.Hex | Signature.Signature<false>
     }
   | {
       /** Public key, if already known. Empty wire signatures do not retain it. */
       publicKey?: PublicKey.PublicKey | undefined
-      /** Omit for an unsigned entry. */
-      signature?: undefined
+      /** Omit or use `0x` for an unsigned entry. */
+      signature?: '0x' | undefined
     }
 )
 
@@ -67,13 +67,13 @@ export type FrameSignature = Arbitrary | Secp256k1 | P256
 /** JSON-RPC representation of a frame signature. */
 export type Rpc = {
   /** Explicit digest, or empty bytes for the transaction signing hash. */
-  msg: Hex.Hex
+  msg?: Hex.Hex | undefined
   /** Signature verification scheme. */
-  scheme: 0 | 1 | 2
+  scheme: '0x0' | '0x1' | '0x2'
   /** Encoded signature bytes. */
-  signature: Hex.Hex
+  signature?: Hex.Hex | undefined
   /** Signer address; absent for the transaction sender. */
-  signer?: Address.Address | null | undefined
+  signer?: Address.Address | '0x' | undefined
 }
 
 /** RLP-ready signature entry. The payload occupies the specification's `msg` field. */
@@ -164,24 +164,34 @@ export function assert(
           throw new InvalidError('Public key coordinates must fit in 32 bytes.')
       }
     }
-    if (entry.signature !== undefined && entry.publicKey === undefined)
+    if (
+      entry.signature !== undefined &&
+      entry.signature !== '0x' &&
+      entry.publicKey === undefined
+    )
       throw new InvalidError('P-256 signatures require a public key.')
   }
-  if (entry.signature === undefined) {
+  if (entry.signature === undefined || entry.signature === '0x') {
     if (options.signed) throw new InvalidError('Signature is required.')
     return
   }
-  Hex.assert(entry.signature.r, { strict: true })
-  Hex.assert(entry.signature.s, { strict: true })
+  if (typeof entry.signature === 'string')
+    Hex.assert(entry.signature, { strict: true })
+  const signature =
+    typeof entry.signature === 'string'
+      ? Signature.fromHex(entry.signature)
+      : entry.signature
+  Hex.assert(signature.r, { strict: true })
+  Hex.assert(signature.s, { strict: true })
   if (
-    (scheme === 1 || entry.signature.yParity !== undefined) &&
-    entry.signature.yParity !== 0 &&
-    entry.signature.yParity !== 1
+    (scheme === 1 || signature.yParity !== undefined) &&
+    signature.yParity !== 0 &&
+    signature.yParity !== 1
   )
     throw new InvalidError('Signature parity must be 0 or 1.')
-  Signature.assert(entry.signature, { recovered: scheme === 1 })
-  const r = Hex.toBigInt(entry.signature.r)
-  const s = Hex.toBigInt(entry.signature.s)
+  Signature.assert(signature, { recovered: scheme === 1 })
+  const r = Hex.toBigInt(signature.r)
+  const s = Hex.toBigInt(signature.s)
   const order = scheme === 1 ? secp256k1N : p256N
   if (
     r === 0n ||
@@ -210,13 +220,15 @@ export declare namespace assert {
     | Hex.toBigInt.ErrorType
     | PublicKey.assert.ErrorType
     | Signature.assert.ErrorType
+    | Signature.fromHex.ErrorType
     | Errors.GlobalErrorType
 }
 
 /**
  * Coerces a value into a {@link ox#FrameSignature.FrameSignature}.
  *
- * Accepts arbitrary signature bytes or a structured signature entry. Omitted
+ * Accepts arbitrary signature bytes or a signature entry. Protocol signatures accept
+ * structured objects or `Signature.toHex` bytes. P-256 entries still require a public key. Omitted
  * `scheme` and `payload` default to `'arbitrary'` and `'0x'`, respectively.
  * An empty payload selects the canonical transaction signing hash; an explicit
  * payload must be a nonzero 32-byte digest.
@@ -340,7 +352,7 @@ export declare namespace from {
  *
  * const entry = FrameSignature.fromRpc({
  *   msg: '0x',
- *   scheme: 0,
+ *   scheme: '0x0',
  *   signature: '0xdeadbeef'
  * })
  * ```
@@ -350,15 +362,20 @@ export declare namespace from {
  */
 export function fromRpc(entry: Rpc): FrameSignature {
   return fromTuple([
-    entry.scheme === 0 ? '0x' : Hex.fromNumber(entry.scheme, { size: 1 }),
+    entry.scheme === '0x0'
+      ? '0x'
+      : Hex.fromNumber(Hex.toNumber(entry.scheme), { size: 1 }),
     entry.signer ?? '0x',
-    entry.msg,
-    entry.signature,
+    entry.msg ?? '0x',
+    entry.signature ?? '0x',
   ])
 }
 
 export declare namespace fromRpc {
-  type ErrorType = fromTuple.ErrorType | Hex.fromNumber.ErrorType
+  type ErrorType =
+    | fromTuple.ErrorType
+    | Hex.fromNumber.ErrorType
+    | Hex.toNumber.ErrorType
 }
 
 /**
@@ -381,8 +398,10 @@ export function toRpc(entry: FrameSignature): Rpc {
   const [scheme, signer, msg, signature] = toTuple(entry)
   return {
     msg,
-    scheme: (scheme === '0x' ? 0 : Hex.toNumber(scheme)) as Rpc['scheme'],
-    signature,
+    scheme: (scheme === '0x'
+      ? '0x0'
+      : Hex.fromNumber(Hex.toNumber(scheme))) as Rpc['scheme'],
+    ...(signature === '0x' && scheme !== '0x' ? {} : { signature }),
     ...(signer === '0x' ? {} : { signer }),
   }
 }
@@ -509,13 +528,24 @@ export function toTuple(entry: FrameSignature): Tuple {
         return entry.signature
       case 1:
       case 'secp256k1':
-        return entry.signature === undefined
+        return entry.signature === undefined || entry.signature === '0x'
           ? '0x'
-          : Hex.fromBytes(Signature.toRecoveredBytes(entry.signature))
+          : Hex.fromBytes(
+              Signature.toRecoveredBytes(
+                typeof entry.signature === 'string'
+                  ? Signature.fromHex(entry.signature)
+                  : entry.signature,
+              ),
+            )
       case 2:
       case 'p256': {
-        if (entry.signature === undefined) return '0x'
-        const { publicKey, signature } = entry
+        if (entry.signature === undefined || entry.signature === '0x')
+          return '0x'
+        const publicKey = entry.publicKey!
+        const signature =
+          typeof entry.signature === 'string'
+            ? Signature.fromHex(entry.signature)
+            : entry.signature
         const s = Hex.toBigInt(signature.s)
         return Hex.concat(
           Hex.fromNumber(Hex.toBigInt(signature.r), { size: 32 }),

package/src/core/Siwe.ts

@@ -21,7 +21,7 @@ export const prefixRegex =
 
 // https://regexr.com/80gf9
 export const suffixRegex =
-  /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/
+  /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.*))?(?:\nResources:(?<resources>(?:\n- .+)*))?/
 
 const siweDateTimeRegex =
   /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])[Tt]([01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:[Zz]|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/
@@ -421,18 +421,26 @@ export function parseMessage(message: string): ExactPartial<Message> {
     scheme?: string
     statement?: string
   }
-  const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } =
-    (message.match(suffixRegex)?.groups ?? {}) as {
-      chainId: string
-      expirationTime?: string
-      issuedAt?: string
-      nonce: string
-      notBefore?: string
-      requestId?: string
-      uri: string
-      version: '1'
-    }
-  const resources = message.split('Resources:')[1]?.split('\n- ').slice(1)
+  const {
+    chainId,
+    expirationTime,
+    issuedAt,
+    notBefore,
+    requestId,
+    resources: resources_,
+    ...suffix
+  } = (message.match(suffixRegex)?.groups ?? {}) as {
+    chainId: string
+    expirationTime?: string
+    issuedAt?: string
+    nonce: string
+    notBefore?: string
+    requestId?: string
+    resources?: string
+    uri: string
+    version: '1'
+  }
+  const resources = resources_?.split('\n- ').slice(1)
   return {
     ...prefix,
     ...suffix,

package/src/core/Transaction.ts

@@ -6,7 +6,12 @@ import * as Frame from './Frame.js'
 import * as FrameSignature from './FrameSignature.js'
 import * as Hex from './Hex.js'
 import * as Quantity from './internal/quantity.js'
-import type { Compute, OneOf, UnionCompute } from './internal/types.js'
+import type {
+  Compute,
+  ExactPartial,
+  OneOf,
+  UnionCompute,
+} from './internal/types.js'
 import * as Signature from './Signature.js'
 
 /**
@@ -197,29 +202,35 @@ export type Eip8141<
 > = Compute<
   Omit<
     Base<type, pending, bigintType, numberType>,
-    'chainId' | 'r' | 's' | 'v' | 'yParity'
-  > & {
-    /** Versioned blob hashes. */
-    blobVersionedHashes: readonly Hex.Hex[]
-    /** Chain ID, retaining bigint precision when needed. */
-    chainId: numberType | bigintType
-    /** Frames in execution order. */
-    frames: readonly ([bigintType] extends [Hex.Hex]
-      ? Frame.Rpc
-      : Frame.Frame<bigintType>)[]
-    /** Effective gas price. */
-    gasPrice?: bigintType | undefined
-    /** Maximum fee per blob gas. */
-    maxFeePerBlobGas: bigintType
-    /** Maximum fee per gas. */
-    maxFeePerGas: bigintType
-    /** Maximum priority fee per gas. */
-    maxPriorityFeePerGas: bigintType
-    /** Frame signature entries. */
-    signatures: readonly ([bigintType] extends [Hex.Hex]
-      ? FrameSignature.Rpc
-      : FrameSignature.FrameSignature)[]
-  }
+    'chainId' | 'gas' | 'input' | 'to' | 'value' | 'r' | 's' | 'v' | 'yParity'
+  > &
+    ExactPartial<
+      Pick<
+        Base<type, pending, bigintType, numberType>,
+        'gas' | 'input' | 'to' | 'value'
+      >
+    > & {
+      /** Versioned blob hashes. */
+      blobVersionedHashes: readonly Hex.Hex[]
+      /** Chain ID, retaining bigint precision when needed. */
+      chainId: numberType | bigintType
+      /** Frames in execution order. */
+      frames: readonly ([bigintType] extends [Hex.Hex]
+        ? Frame.Rpc
+        : Frame.Frame<bigintType>)[]
+      /** Effective gas price. */
+      gasPrice?: bigintType | undefined
+      /** Maximum fee per blob gas. */
+      maxFeePerBlobGas: bigintType
+      /** Maximum fee per gas. */
+      maxFeePerGas: bigintType
+      /** Maximum priority fee per gas. */
+      maxPriorityFeePerGas: bigintType
+      /** Frame signature entries. */
+      signatures: readonly ([bigintType] extends [Hex.Hex]
+        ? FrameSignature.Rpc
+        : FrameSignature.FrameSignature)[]
+    }
 >
 
 /** An EIP-8141 RPC transaction. */

package/src/core/TransactionRequest.ts

@@ -3,7 +3,7 @@ import type * as Address from './Address.js'
 import * as Authorization from './Authorization.js'
 import * as Blobs from './Blobs.js'
 import * as Errors from './Errors.js'
-import * as Frame from './Frame.js'
+import * as FrameRequest from './FrameRequest.js'
 import * as FrameSignature from './FrameSignature.js'
 import * as Hex from './Hex.js'
 import * as Quantity from './internal/quantity.js'
@@ -19,7 +19,9 @@ export type TransactionRequest<
   bigintType = bigint,
   numberType = number,
   type extends string = string,
-  frame = [bigintType] extends [Hex.Hex] ? Frame.Rpc : Frame.Frame<bigintType>,
+  frame = [bigintType] extends [Hex.Hex]
+    ? FrameRequest.Rpc
+    : FrameRequest.FrameRequest<bigintType>,
   signature = [bigintType] extends [Hex.Hex]
     ? FrameSignature.Rpc
     : FrameSignature.FrameSignature,
@@ -79,7 +81,7 @@ export type Rpc = TransactionRequest<
   Hex.Hex,
   Hex.Hex,
   string,
-  Frame.Rpc,
+  FrameRequest.Rpc,
   FrameSignature.Rpc
 >
 
@@ -109,7 +111,7 @@ export function fromRpc(request: Rpc): TransactionRequest {
   if (typeof request.chainId !== 'undefined')
     request_.chainId = Hex.toNumber(request.chainId)
   if (request.frames !== undefined)
-    request_.frames = request.frames.map(Frame.fromRpc)
+    request_.frames = request.frames.map(FrameRequest.fromRpc)
   if (request.signatures !== undefined)
     request_.signatures = request.signatures.map(FrameSignature.fromRpc)
   if (typeof request.gas !== 'undefined')
@@ -141,7 +143,7 @@ export function fromRpc(request: Rpc): TransactionRequest {
 export declare namespace fromRpc {
   export type ErrorType =
     | Authorization.fromRpcList.ErrorType
-    | Frame.fromRpc.ErrorType
+    | FrameRequest.fromRpc.ErrorType
     | FrameSignature.fromRpc.ErrorType
     | Hex.toNumber.ErrorType
     | Hex.toBigInt.ErrorType
@@ -210,7 +212,7 @@ export function toRpc(request: toRpc.Input): Rpc {
     request_rpc.input = request.input
   }
   if (request.frames !== undefined)
-    request_rpc.frames = request.frames.map(Frame.toRpc)
+    request_rpc.frames = request.frames.map(FrameRequest.toRpc)
   if (request.signatures !== undefined)
     request_rpc.signatures = request.signatures.map(FrameSignature.toRpc)
   if (typeof request.from !== 'undefined') request_rpc.from = request.from
@@ -258,7 +260,7 @@ export declare namespace toRpc {
 
   export type ErrorType =
     | Authorization.toRpcList.ErrorType
-    | Frame.toRpc.ErrorType
+    | FrameRequest.toRpc.ErrorType
     | FrameSignature.toRpc.ErrorType
     | Hex.fromNumber.ErrorType
     | Errors.GlobalErrorType

package/src/core/TxEnvelope.ts

@@ -242,7 +242,9 @@ export declare namespace deserialize {
  *
  * const envelope = TransactionEnvelope.from({
  *   chainId: 1,
- *   frames: [Frame.from({ gas: 50_000n, mode: 'sender' })],
+ *   frames: [
+ *     Frame.from({ executionGas: 50_000n, mode: 'sender' })
+ *   ],
  *   sender: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8'
  * })
  * ```
@@ -779,6 +781,12 @@ export function toTransactionRequest(
       ...rest,
       ...(sidecars ? { blobs: sidecars.blobs } : {}),
       chainId: Hex.toNumber(Hex.fromNumber(rest.chainId)),
+      // Envelopes commit to zero defaults; request omission would trigger estimation.
+      frames: rest.frames.map((frame) => ({
+        ...frame,
+        executionGas: frame.executionGas ?? 0n,
+        stateGas: frame.stateGas ?? 0n,
+      })),
       from: sender,
     }
   }

package/src/core/TxEnvelopeEip8141.ts

@@ -90,7 +90,7 @@ export type Type = typeof type
  *
  * TxEnvelopeEip8141.assert({
  *   chainId: 1,
- *   frames: [{ gas: 50_000n, mode: 'verify' }],
+ *   frames: [{ executionGas: 50_000n, mode: 'verify' }],
  *   sender: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8'
  * })
  * ```
@@ -146,7 +146,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
@@ -193,7 +193,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 +210,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.')
@@ -337,8 +337,8 @@ export declare namespace deserialize {
  *   chainId: 1,
  *   frames: [
  *     {
+ *       executionGas: 50_000n,
  *       flags: 'approveExecutionAndPayment',
- *       gas: 50_000n,
  *       mode: 'verify'
  *     }
  *   ],
@@ -503,8 +503,8 @@ export declare namespace toRpc {
  *   chainId: 1,
  *   frames: [
  *     {
+ *       executionGas: 50_000n,
  *       flags: 'approveExecutionAndPayment',
- *       gas: 50_000n,
  *       mode: 'verify'
  *     }
  *   ],
@@ -589,7 +589,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)

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(