ox 0.14.49 → 0.14.52

package/_types/version.d.ts

@@ -1,3 +1,3 @@
 /** @internal */
-export declare const version = "0.14.49";
+export declare const version = "0.14.52";
 //# sourceMappingURL=version.d.ts.map

package/core/FrameRequest.ts

@@ -0,0 +1,72 @@
+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/core/FrameSignature.ts

@@ -32,7 +32,7 @@ export type Secp256k1 = {
   payload?: Hex.Hex | undefined
   /** secp256k1 verification scheme. */
   scheme: 1 | 'secp256k1'
-  /** Recovered signature or `Signature.toHex` bytes. Omit for an unsigned entry. */
+  /** 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
@@ -56,8 +56,8 @@ export type P256 = {
   | {
       /** 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
     }
 )
 
@@ -73,7 +73,7 @@ export type Rpc = {
   /** Encoded signature bytes. */
   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. */
@@ -167,10 +167,14 @@ 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
   }
@@ -531,7 +535,8 @@ export function toTuple(entry: FrameSignature): Tuple {
         return entry.signature
       case 1:
       case 'secp256k1': {
-        if (entry.signature === undefined) return '0x'
+        if (entry.signature === undefined || entry.signature === '0x')
+          return '0x'
         const signature =
           typeof entry.signature === 'string'
             ? Signature.fromHex(entry.signature)
@@ -544,8 +549,9 @@ export function toTuple(entry: FrameSignature): Tuple {
       }
       case 2:
       case 'p256': {
-        if (entry.signature === undefined) return '0x'
-        const { publicKey } = entry
+        if (entry.signature === undefined || entry.signature === '0x')
+          return '0x'
+        const publicKey = entry.publicKey!
         const signature =
           typeof entry.signature === 'string'
             ? Signature.fromHex(entry.signature)

package/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- .+)*))?/
 
 /** [EIP-4361](https://eips.ethereum.org/EIPS/eip-4361) message fields. */
 export type Message = {
@@ -372,18 +372,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/core/Transaction.ts

@@ -5,6 +5,7 @@ import type * as Errors from './Errors.js'
 import * as Frame from './Frame.js'
 import * as FrameSignature from './FrameSignature.js'
 import * as Hex from './Hex.js'
+import * as FrameNonce from './internal/frameNonce.js'
 import type { Compute, OneOf, UnionCompute } from './internal/types.js'
 import * as Signature from './Signature.js'
 
@@ -214,6 +215,8 @@ export type Eip8141<
     maxFeePerGas: bigintType
     /** Maximum priority fee per gas. */
     maxPriorityFeePerGas: bigintType
+    /** EIP-8250 domains sharing the transaction's `nonce` sequence. */
+    nonceKeys?: readonly bigintType[] | undefined
     /** Frame signature entries. */
     signatures: readonly ([bigintType] extends [Hex.Hex]
       ? FrameSignature.Rpc
@@ -354,6 +357,16 @@ export function fromRpc<
     : null
   transaction_.value = BigInt(transaction.value ?? 0n)
 
+  if (transaction.type === '0x6' && transaction.nonceKeys !== undefined) {
+    if (transaction.nonce === undefined)
+      throw new FrameNonce.InvalidError(
+        'A keyed transaction result requires nonce.',
+      )
+    transaction_.nonceKeys = FrameNonce.fromRpc(
+      transaction.nonceKeys,
+      transaction.nonce,
+    )
+  }
   if (transaction.frames)
     transaction_.frames = transaction.frames.map(Frame.fromRpc)
   if (transaction.signatures)
@@ -389,6 +402,7 @@ export declare namespace fromRpc {
   }
 
   type ErrorType =
+    | FrameNonce.InvalidError
     | Frame.fromRpc.ErrorType
     | FrameSignature.fromRpc.ErrorType
     | Signature.extract.ErrorType
@@ -456,6 +470,8 @@ export function toRpc<pending extends boolean = false>(
   rpc.type = (toRpcType as any)[transaction.type] ?? transaction.type
   rpc.value = Hex.fromNumber(transaction.value ?? 0n)
 
+  if (transaction.type === 'eip8141' && transaction.nonceKeys !== undefined)
+    rpc.nonceKeys = FrameNonce.toRpc(transaction.nonceKeys, transaction.nonce)
   if (transaction.frames) rpc.frames = transaction.frames.map(Frame.toRpc)
   if (transaction.signatures)
     rpc.signatures = transaction.signatures.map(FrameSignature.toRpc)
@@ -493,6 +509,7 @@ export declare namespace toRpc {
   }
 
   type ErrorType =
+    | FrameNonce.InvalidError
     | Frame.toRpc.ErrorType
     | FrameSignature.toRpc.ErrorType
     | Signature.extract.ErrorType

package/core/TransactionRequest.ts

@@ -2,9 +2,10 @@ import type * as AccessList from './AccessList.js'
 import type * as Address from './Address.js'
 import * as Authorization from './Authorization.js'
 import type * 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 FrameNonce from './internal/frameNonce.js'
 import type { Compute } from './internal/types.js'
 import * as Transaction from './Transaction.js'
 
@@ -13,7 +14,7 @@ export type TransactionRequest<
   bigintType = bigint,
   numberType = number,
   type extends string = string,
-  frame = Frame.Frame<bigintType>,
+  frame = FrameRequest.FrameRequest<bigintType>,
   signature = FrameSignature.FrameSignature,
 > = Compute<{
   /** EIP-2930 Access List. */
@@ -48,6 +49,8 @@ export type TransactionRequest<
   maxPriorityFeePerGas?: bigintType | undefined
   /** Unique number identifying this transaction */
   nonce?: bigintType | undefined
+  /** EIP-8250 nonce domains. `nonce` is their shared sequence; omitted keys preserve EIP-8141 encoding. */
+  nonceKeys?: readonly bigintType[] | undefined
   /** Frame signature entries for EIP-8141 transactions. */
   signatures?: readonly signature[] | undefined
   /** Transaction recipient */
@@ -63,7 +66,7 @@ export type Rpc = TransactionRequest<
   Hex.Hex,
   Hex.Hex,
   string,
-  Frame.Rpc,
+  FrameRequest.Rpc,
   FrameSignature.Rpc
 >
 
@@ -92,7 +95,7 @@ export function fromRpc(request: Rpc): TransactionRequest {
     )
   if (typeof request.chainId !== 'undefined')
     request_.chainId = Hex.toNumber(request.chainId)
-  if (request.frames) request_.frames = request.frames.map(Frame.fromRpc)
+  if (request.frames) request_.frames = request.frames.map(FrameRequest.fromRpc)
   if (request.signatures)
     request_.signatures = request.signatures.map(FrameSignature.fromRpc)
   if (typeof request.gas !== 'undefined')
@@ -107,6 +110,8 @@ export function fromRpc(request: Rpc): TransactionRequest {
     request_.maxPriorityFeePerGas = Hex.toBigInt(request.maxPriorityFeePerGas)
   if (typeof request.nonce !== 'undefined')
     request_.nonce = Hex.toBigInt(request.nonce)
+  if (request.nonceKeys !== undefined)
+    request_.nonceKeys = FrameNonce.fromRpc(request.nonceKeys, request.nonce)
   if (typeof request.type !== 'undefined')
     request_.type =
       Transaction.fromRpcType[
@@ -120,7 +125,8 @@ export function fromRpc(request: Rpc): TransactionRequest {
 
 export declare namespace fromRpc {
   export type ErrorType =
-    | Frame.fromRpc.ErrorType
+    | FrameNonce.InvalidError
+    | FrameRequest.fromRpc.ErrorType
     | FrameSignature.fromRpc.ErrorType
     | Authorization.fromRpcList.ErrorType
     | Hex.toNumber.ErrorType
@@ -189,7 +195,8 @@ export function toRpc(request: TransactionRequest): Rpc {
     request_rpc.input = request.input
   }
   if (typeof request.from !== 'undefined') request_rpc.from = request.from
-  if (request.frames) request_rpc.frames = request.frames.map(Frame.toRpc)
+  if (request.frames)
+    request_rpc.frames = request.frames.map(FrameRequest.toRpc)
   if (request.signatures)
     request_rpc.signatures = request.signatures.map(FrameSignature.toRpc)
   if (typeof request.gas !== 'undefined')
@@ -210,6 +217,8 @@ export function toRpc(request: TransactionRequest): Rpc {
     )
   if (typeof request.nonce !== 'undefined')
     request_rpc.nonce = Hex.fromNumber(request.nonce)
+  if (request.nonceKeys !== undefined)
+    request_rpc.nonceKeys = FrameNonce.toRpc(request.nonceKeys, request.nonce)
   if (typeof request.to !== 'undefined') request_rpc.to = request.to
   if (typeof request.type !== 'undefined')
     request_rpc.type =
@@ -224,7 +233,8 @@ export function toRpc(request: TransactionRequest): Rpc {
 
 export declare namespace toRpc {
   export type ErrorType =
-    | Frame.toRpc.ErrorType
+    | FrameNonce.InvalidError
+    | FrameRequest.toRpc.ErrorType
     | FrameSignature.toRpc.ErrorType
     | Authorization.toRpcList.ErrorType
     | Hex.fromNumber.ErrorType

package/core/TxEnvelopeEip8141.ts

@@ -6,11 +6,17 @@ 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'
 
-/** 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
@@ -24,8 +30,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. */
@@ -58,8 +66,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. */
@@ -111,6 +121,7 @@ export function assert(envelope: PartialBy<TxEnvelopeEip8141, 'type'>): void {
     maxFeePerGas = 0n,
     maxPriorityFeePerGas = 0n,
     nonce = 0n,
+    nonceKeys,
     sender,
     signatures = [],
   } = envelope
@@ -123,6 +134,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],
@@ -162,6 +174,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 =
@@ -226,6 +250,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
@@ -263,9 +288,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) ||
@@ -293,6 +323,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),
@@ -408,6 +439,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),
   })
@@ -415,6 +449,7 @@ export function fromRpc(envelope: Rpc): TxEnvelopeEip8141 {
 
 export declare namespace fromRpc {
   type ErrorType =
+    | FrameNonce.InvalidError
     | from.ErrorType
     | Frame.fromRpc.ErrorType
     | FrameSignature.fromRpc.ErrorType
@@ -453,6 +488,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',
   }
@@ -467,6 +505,7 @@ export declare namespace toRpc {
     | 'maxFeePerGas'
     | 'maxPriorityFeePerGas'
     | 'nonce'
+    | 'nonceKeys'
     | 'type'
   > & {
     chainId: Hex.Hex | bigint | number
@@ -475,9 +514,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
@@ -565,10 +606,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 {
@@ -692,8 +735,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)),
@@ -705,7 +747,6 @@ function toTuple(envelope: PartialBy<TxEnvelopeEip8141, 'type'>) {
     ],
     envelope.blobVersionedHashes ?? [],
   ] satisfies [
-    Hex.Hex,
     Hex.Hex,
     Address.Address,
     Frame.Tuple[],
@@ -713,4 +754,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/core/internal/frameNonce.ts

@@ -0,0 +1,70 @@
+import * as Errors from '../Errors.js'
+import * as Hex from '../Hex.js'
+import * as Quantity from './quantity.js'
+
+/**
+ * Asserts keyed nonce constraints.
+ * @internal
+ */
+export function assert(keys: readonly bigint[], nonce?: bigint): void {
+  if (!Array.isArray(keys) || keys.length < 1 || keys.length > 16)
+    throw new InvalidError('Expected between 1 and 16 nonce keys.')
+  for (const [index, key] of keys.entries()) {
+    if (typeof key !== 'bigint' || key < 0n || key >= 2n ** 256n)
+      throw new InvalidError('Nonce keys must be unsigned 256-bit integers.')
+    if (index > 0 && key <= keys[index - 1]!)
+      throw new InvalidError('Nonce keys must be strictly increasing.')
+  }
+  if (keys.length > 1 && keys[0] === 0n)
+    throw new InvalidError(
+      'The zero nonce key cannot be combined with other keys.',
+    )
+  if (
+    nonce !== undefined &&
+    (typeof nonce !== 'bigint' || nonce < 0n || nonce >= 2n ** 64n - 1n)
+  )
+    throw new InvalidError('Nonce must be less than 2^64 - 1 and nonnegative.')
+}
+
+/**
+ * Decodes and validates RPC nonce keys and their shared sequence.
+ * @internal
+ */
+export function fromRpc(
+  keys: readonly Hex.Hex[],
+  nonce?: Hex.Hex,
+): readonly bigint[] {
+  if (!Array.isArray(keys)) throw new InvalidError('Expected a nonce key list.')
+  const integer = (value: Hex.Hex): bigint => {
+    if (
+      typeof value !== 'string' ||
+      !/^0x(?:0|[1-9a-fA-F][0-9a-fA-F]*)$/.test(value)
+    )
+      throw new InvalidError('Expected a canonical RPC nonce quantity.')
+    return Hex.toBigInt(value)
+  }
+  const decoded = keys.map(integer)
+  assert(decoded, nonce === undefined ? undefined : integer(nonce))
+  return decoded
+}
+
+/**
+ * Encodes and validates nonce keys and their shared sequence.
+ * @internal
+ */
+export function toRpc(
+  keys: readonly (Hex.Hex | bigint | number)[],
+  nonce?: Hex.Hex | bigint | number,
+): readonly Hex.Hex[] {
+  if (!Array.isArray(keys)) throw new InvalidError('Expected a nonce key list.')
+  const encoded = keys.map((key) => Quantity.fromNumberish(key))
+  fromRpc(
+    encoded,
+    nonce === undefined ? undefined : Quantity.fromNumberish(nonce),
+  )
+  return encoded
+}
+
+export class InvalidError extends Errors.BaseError {
+  override readonly name = 'FrameNonce.InvalidError'
+}

package/core/internal/rpcSchemas/eth.ts

@@ -4,6 +4,7 @@ import type * as Block from '../../Block.js'
 import type * as BlockOverrides from '../../BlockOverrides.js'
 import type * as Fee from '../../Fee.js'
 import type * as Filter from '../../Filter.js'
+import type * as FrameReceipt from '../../FrameReceipt.js'
 import type * as Hex from '../../Hex.js'
 import type * as Log from '../../Log.js'
 import type * as RpcSchema from '../../RpcSchema.js'
@@ -11,6 +12,12 @@ import type * as StateOverrides from '../../StateOverrides.js'
 import type * as Transaction from '../../Transaction.js'
 import type * as TransactionReceipt from '../../TransactionReceipt.js'
 import type * as TransactionRequest from '../../TransactionRequest.js'
+import type * as TxEnvelopeEip1559 from '../../TxEnvelopeEip1559.js'
+import type * as TxEnvelopeEip2930 from '../../TxEnvelopeEip2930.js'
+import type * as TxEnvelopeEip4844 from '../../TxEnvelopeEip4844.js'
+import type * as TxEnvelopeEip7702 from '../../TxEnvelopeEip7702.js'
+import type * as TxEnvelopeEip8141 from '../../TxEnvelopeEip8141.js'
+import type * as TxEnvelopeLegacy from '../../TxEnvelopeLegacy.js'
 
 /**
  * Union of all JSON-RPC Methods for the `eth_` namespace.
@@ -217,6 +224,31 @@ export type Eth = RpcSchema.From<
       }
       ReturnType: Fee.FeeHistoryRpc
     }
+  /**
+   * Fills transaction defaults and returns the unsigned transaction.
+   *
+   * @example
+   * ```
+   * request({ method: 'eth_fillTransaction', params: [{ from: '0x...', to: '0x...', value: '0x...' }] })
+   * // { tx: { ... } }
+   * ```
+   */
+  | {
+      Request: {
+        method: 'eth_fillTransaction'
+        params: [transaction: TransactionRequest.Rpc]
+      }
+      ReturnType: {
+        tx: (
+          | TxEnvelopeLegacy.Rpc<false>
+          | TxEnvelopeEip2930.Rpc<false>
+          | TxEnvelopeEip1559.Rpc<false>
+          | TxEnvelopeEip4844.Rpc<false>
+          | TxEnvelopeEip7702.Rpc<false>
+          | TxEnvelopeEip8141.Rpc
+        ) & { from: Address.Address }
+      }
+    }
   /**
    * Returns the current price of gas expressed in wei
    *
@@ -772,6 +804,13 @@ export type Eth = RpcSchema.From<
                     message: string
                   }
                 | undefined
+              frameResults?:
+                | readonly (FrameReceipt.Rpc & {
+                    error?: { code: number; message: string } | undefined
+                    returnData: Hex.Hex
+                  })[]
+                | undefined
+              payer?: Address.Address | undefined
               logs?: readonly Log.Rpc[] | undefined
               gasUsed: Hex.Hex
               returnData: Hex.Hex