ox 1.0.0-beta.2 → 1.0.0-beta.21

package/src/tempo/SignatureEnvelope.ts

@@ -86,7 +86,6 @@ export type GetType<
               ? 'keychain'
               : envelope extends {
                     account: Address.Address
-                    genesisConfigId: `0x${string}`
                     signatures: any
                   }
                 ? 'multisig'
@@ -162,9 +161,10 @@ export type KeychainRpc = {
 /**
  * Native multisig signature (type `0x05`).
  *
- * Wraps a set of primitive owner approvals (secp256k1, p256, or webAuthn) over the
- * multisig owner approval digest. The transaction sender is the derived `account`,
- * authorized once the recovered owner weights meet the configured threshold.
+ * Wraps a set of owner approvals (secp256k1, p256, webAuthn, or nested
+ * multisig) over the multisig owner approval digest. The transaction sender is
+ * the derived `account`, authorized once the recovered owner weights meet the
+ * configured threshold.
  *
  * [TIP-1061](https://tips.sh/1061)
  */
@@ -172,9 +172,11 @@ export type Multisig<numberType = number> = {
   type: 'multisig'
   /** Native multisig account address. */
   account: Address.Address
-  /** Permanent config ID derived from the initial multisig config. */
-  genesisConfigId: Hex.Hex
-  /** Primitive owner approvals over the multisig owner approval digest. */
+  /**
+   * Owner approvals over the multisig owner approval digest. Each approval is
+   * either a primitive signature or a nested multisig signature (keychain
+   * approvals are invalid).
+   */
   signatures: readonly SignatureEnvelope<numberType>[]
   /**
    * Initial native multisig config for bootstrapping this account. Present only on
@@ -188,14 +190,8 @@ export type MultisigRpc = {
   type: 'multisig'
   account: Address.Address
   /**
-   * The permanent multisig config ID (TIP-1061 wire field `config_id`).
-   * Maps to `genesisConfigId` on the typed
-   * {@link ox#SignatureEnvelope.Multisig} envelope.
-   */
-  configId: Hex.Hex
-  /**
-   * Encoded primitive owner approvals (raw serialized signatures), matching the
-   * node's `Vec<Bytes>` representation.
+   * Encoded owner approvals (raw serialized signatures), matching the node's
+   * `Vec<Bytes>` representation.
    */
   signatures: readonly Serialized[]
   init?: MultisigConfig.Config | undefined
@@ -345,11 +341,24 @@ export function assert(envelope: PartialBy<SignatureEnvelope, 'type'>): void {
     const multisig = envelope as Multisig
     const missing: string[] = []
     if (!multisig.account) missing.push('account')
-    if (!multisig.genesisConfigId) missing.push('genesisConfigId')
     if (!Array.isArray(multisig.signatures)) missing.push('signatures')
     if (missing.length > 0)
       throw new MissingPropertiesError({ envelope, missing, type: 'multisig' })
-    for (const inner of multisig.signatures) assert(inner)
+    if (getNestingDepth(multisig) > MultisigConfig.maxNestingDepth)
+      throw new InvalidMultisigApprovalError({
+        reason: `multisig nesting depth exceeds ${MultisigConfig.maxNestingDepth}`,
+      })
+    for (const inner of multisig.signatures) {
+      if (inner.type === 'keychain')
+        throw new InvalidMultisigApprovalError({
+          reason: 'keychain owner approvals are not allowed',
+        })
+      if (inner.type === 'multisig' && inner.init)
+        throw new InvalidMultisigApprovalError({
+          reason: 'nested multisig owner approvals cannot carry `init`',
+        })
+      assert(inner)
+    }
     if (multisig.init) MultisigConfig.assert(multisig.init)
     return
   }
@@ -358,12 +367,22 @@ export function assert(envelope: PartialBy<SignatureEnvelope, 'type'>): void {
 export declare namespace assert {
   type ErrorType =
     | CoercionError
+    | InvalidMultisigApprovalError
     | MissingPropertiesError
     | MultisigConfig.assert.ErrorType
     | Signature.assert.ErrorType
     | Errors.GlobalErrorType
 }
 
+// Returns the deepest multisig path length within a multisig envelope.
+function getNestingDepth(envelope: Multisig): number {
+  let deepest = 0
+  for (const inner of envelope.signatures)
+    if (inner.type === 'multisig')
+      deepest = Math.max(deepest, getNestingDepth(inner))
+  return 1 + deepest
+}
+
 /**
  * Extracts the address of the signer from a {@link ox#SignatureEnvelope.SignatureEnvelope}.
  *
@@ -630,24 +649,26 @@ export function deserialize(value: Serialized): SignatureEnvelope {
   }
 
   if (typeId === serializedMultisigType) {
-    // Wire format: `0x05 || rlp([account, genesisConfigId, signatures, init])`. `init`
-    // is optional: absent when the element is missing or the `0x80` placeholder
-    // (decoded as the empty string `0x`), otherwise the bootstrap config list.
-    const [account, genesisConfigId, signatures, init] = Rlp.toHex(data) as [
-      Hex.Hex,
+    // Wire format: `0x05 || rlp([account, signatures, init?])`. `init` is a
+    // trailing optional: the bootstrap config list when present, otherwise
+    // omitted entirely (the empty `0x80` placeholder is rejected).
+    const [account, signatures, init] = Rlp.toHex(data) as [
       Hex.Hex,
       readonly Hex.Hex[],
       (Hex.Hex | MultisigConfig.Tuple)?,
     ]
+    if (typeof init !== 'undefined' && !Array.isArray(init))
+      throw new InvalidSerializedError({
+        reason:
+          'Invalid multisig `init`: expected the bootstrap config list or an omitted trailing element',
+        serialized,
+      })
     return {
       type: 'multisig',
       account,
-      genesisConfigId,
       signatures: signatures.map((signature) => deserialize(signature)),
-      ...(init && init !== '0x'
-        ? {
-            init: MultisigConfig.fromTuple(init as MultisigConfig.Tuple),
-          }
+      ...(init
+        ? { init: MultisigConfig.fromTuple(init as MultisigConfig.Tuple) }
         : {}),
     } satisfies Multisig
   }
@@ -786,9 +807,9 @@ export function deserialize(value: Serialized): SignatureEnvelope {
  * @example
  * ### Multisig (from genesis config)
  *
- * Pass `genesisConfig` to derive `account` and `genesisConfigId` automatically.
- * Set `init: true` to opt into bootstrap (uses `genesisConfig` as the
- * bootstrap `init`); omit `init` for subsequent (non-bootstrap) transactions.
+ * Pass `genesisConfig` to derive `account` automatically. Set `init: true` to
+ * opt into bootstrap (uses `genesisConfig` as the bootstrap `init`); omit
+ * `init` for subsequent (non-bootstrap) transactions.
  *
  * ```ts twoslash
  * import { Secp256k1 } from 'ox'
@@ -849,18 +870,12 @@ export function from<const value extends from.Value>(
       init?: MultisigConfig.Config | boolean | undefined
     }
     const { genesisConfig, init, ...rest } = multisig
-    // Derive `account`/`genesisConfigId` from `genesisConfig` when not provided
-    // explicitly.
+    // Derive `account` from `genesisConfig` when not provided explicitly.
     const account = (() => {
       if (rest.account) return rest.account
       if (genesisConfig) return MultisigConfig.getAddress(genesisConfig)
       return rest.account
     })()
-    const genesisConfigId = (() => {
-      if (rest.genesisConfigId) return rest.genesisConfigId
-      if (genesisConfig) return MultisigConfig.toId(genesisConfig)
-      return rest.genesisConfigId
-    })()
     // `init: true` opts into bootstrap using the supplied `genesisConfig`.
     // Otherwise, `init` is treated as the explicit bootstrap config (or
     // omitted).
@@ -868,7 +883,6 @@ export function from<const value extends from.Value>(
     return {
       ...rest,
       account,
-      genesisConfigId,
       signatures: rest.signatures.map((signature) => from(signature)),
       // Normalize the bootstrap config (sorts owners, defaults the salt) so the
       // in-memory envelope matches what `deserialize` reconstructs.
@@ -920,9 +934,9 @@ export declare namespace from {
   }
 
   /**
-   * Multisig envelope input variant where `account` and `genesisConfigId` are derived
-   * from the supplied `genesisConfig`. Pass `init: true` to opt into bootstrap
-   * (uses `genesisConfig` as the bootstrap `init`); omit `init` for subsequent
+   * Multisig envelope input variant where `account` is derived from the
+   * supplied `genesisConfig`. Pass `init: true` to opt into bootstrap (uses
+   * `genesisConfig` as the bootstrap `init`); omit `init` for subsequent
    * (non-bootstrap) transactions.
    */
   type MultisigFromGenesisConfig = {
@@ -1063,17 +1077,12 @@ export function fromRpc(envelope: SignatureEnvelopeRpc): SignatureEnvelope {
 
   if (
     envelope.type === 'multisig' ||
-    ('account' in envelope &&
-      'configId' in envelope &&
-      'signatures' in envelope)
+    ('account' in envelope && 'signatures' in envelope)
   ) {
     const multisig = envelope as MultisigRpc
     return {
       type: 'multisig',
       account: multisig.account,
-      // Map RPC wire field `configId` (TIP-1061 spec name) to the typed
-      // envelope's `genesisConfigId`.
-      genesisConfigId: multisig.configId,
       // Owner approvals are raw serialized signatures (node `Vec<Bytes>`).
       signatures: multisig.signatures.map((signature) =>
         deserialize(signature),
@@ -1164,8 +1173,7 @@ export function getType<
 
   // Detect Multisig signature
   if (
-    (('account' in envelope && 'genesisConfigId' in envelope) ||
-      'genesisConfig' in envelope) &&
+    ('account' in envelope || 'genesisConfig' in envelope) &&
     'signatures' in envelope
   )
     return 'multisig' as never
@@ -1269,17 +1277,15 @@ export function serialize(
 
   if (type === 'multisig') {
     const multisig = envelope as Multisig
-    // Format: `0x05 || rlp([account, genesisConfigId, signatures, init])`, where each
-    // owner approval is an encoded primitive signature. `init` is the bootstrap
-    // config (an RLP list) when present, otherwise the canonical empty-string
-    // placeholder (`0x` → RLP `0x80`).
+    // Format: `0x05 || rlp([account, signatures, init?])`, where each owner
+    // approval is an encoded signature. `init` is a trailing optional: the
+    // bootstrap config list when present, otherwise omitted entirely.
     return Hex.concat(
       serializedMultisigType,
       Rlp.fromHex([
         multisig.account,
-        multisig.genesisConfigId,
         multisig.signatures.map((signature) => serialize(signature)),
-        multisig.init ? MultisigConfig.toTuple(multisig.init) : '0x',
+        ...(multisig.init ? [MultisigConfig.toTuple(multisig.init)] : []),
       ]),
       options.magic ? magicBytes : '0x',
     )
@@ -1307,10 +1313,10 @@ export declare namespace serialize {
  * ({@link ox#MultisigConfig.(getSignPayload:function)}), so the signer of
  * every approval is recovered against that digest and the list is sorted by the
  * recovered owner address. Works for any owner key type (secp256k1, p256,
- * webAuthn, keychain).
+ * webAuthn).
  *
- * Config updates never change `account`/`genesisConfigId`, so the genesis
- * config is the correct input even for post-update transactions.
+ * Config updates never change `account`, so the genesis config is the correct
+ * input even for post-update transactions.
  *
  * @example
  * ```ts twoslash
@@ -1370,12 +1376,7 @@ export function sortMultisigApprovals(
   const digest = MultisigConfig.getSignPayload(
     'genesisConfig' in value && value.genesisConfig
       ? { payload, genesisConfig: value.genesisConfig }
-      : {
-          payload,
-          account: (value as { account: Address.Address }).account,
-          genesisConfigId: (value as { genesisConfigId: Hex.Hex })
-            .genesisConfigId,
-        },
+      : { payload, account: (value as { account: Address.Address }).account },
   )
   // Recover each signer once (decorate–sort–undecorate) rather than inside the
   // comparator.
@@ -1392,20 +1393,17 @@ export declare namespace sortMultisigApprovals {
   type Value = {
     /** The inner transaction sign payload (`tx.signature_hash()`). */
     payload: Hex.Hex | Bytes.Bytes
-    /** The primitive owner approvals to order. */
+    /** The owner approvals to order. */
     signatures: readonly SignatureEnvelope[]
   } & OneOf<
     | {
         /** The native multisig account address. */
         account: Address.Address
-        /** The permanent config ID. */
-        genesisConfigId: Hex.Hex
       }
     | {
         /**
          * The initial multisig config (the bootstrap config that derived the
-         * permanent `account` and `genesisConfigId`). Used to derive both values
-         * automatically.
+         * permanent `account`). Used to derive the account automatically.
          */
         genesisConfig: MultisigConfig.Config
       }
@@ -1437,7 +1435,7 @@ export declare namespace sortMultisigApprovals {
  * @param envelope - The signature envelope to convert.
  * @returns The RPC signature envelope with hex values.
  */
-export function toRpc(envelope: SignatureEnvelope): SignatureEnvelopeRpc {
+export function toRpc(envelope: toRpc.Input): SignatureEnvelopeRpc {
   const type = getType(envelope)
 
   if (type === 'secp256k1') {
@@ -1493,9 +1491,6 @@ export function toRpc(envelope: SignatureEnvelope): SignatureEnvelopeRpc {
     return {
       type: 'multisig',
       account: multisig.account,
-      // Map the typed envelope's `genesisConfigId` to the RPC wire field
-      // `configId` (TIP-1061 spec name).
-      configId: multisig.genesisConfigId,
       // Owner approvals are raw serialized signatures (node `Vec<Bytes>`).
       signatures: multisig.signatures.map((signature) => serialize(signature)),
       ...(multisig.init ? { init: multisig.init } : {}),
@@ -1506,6 +1501,9 @@ export function toRpc(envelope: SignatureEnvelope): SignatureEnvelopeRpc {
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#SignatureEnvelope.(toRpc:function)}. */
+  type Input = SignatureEnvelope<Hex.Hex | number>
+
   type ErrorType =
     | CoercionError
     | Signature.toRpc.ErrorType
@@ -1777,6 +1775,16 @@ export class InvalidSerializedError extends Errors.BaseError {
   }
 }
 
+/**
+ * Error thrown when a native multisig owner approval is invalid.
+ */
+export class InvalidMultisigApprovalError extends Errors.BaseError {
+  override readonly name = 'SignatureEnvelope.InvalidMultisigApprovalError'
+  constructor({ reason }: { reason: string }) {
+    super(`Invalid native multisig owner approval: ${reason}.`)
+  }
+}
+
 /**
  * Error thrown when a signature envelope fails to verify.
  */

package/src/tempo/Transaction.test.ts

@@ -49,7 +49,6 @@ describe('fromRpc', () => {
           },
         ],
         "chainId": 1,
-        "data": undefined,
         "feeToken": "0x20c0000000000000000000000000000000000000",
         "from": "0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6",
         "gas": 278365n,
@@ -68,7 +67,6 @@ describe('fromRpc', () => {
         },
         "transactionIndex": 2,
         "type": "tempo",
-        "value": 0n,
       }
     `)
   })
@@ -125,7 +123,6 @@ describe('fromRpc', () => {
           },
         ],
         "chainId": 1,
-        "data": undefined,
         "feePayerSignature": {
           "r": "0x12f4d9e9924f62b19de816252efc125006298f43e62d394151e62600e2c2f91e",
           "s": "0x31daa78bb3e95dd22f6370e59617c60d109bf28e55c92b25994ddbed420e2a80",
@@ -150,7 +147,6 @@ describe('fromRpc', () => {
         },
         "transactionIndex": 2,
         "type": "tempo",
-        "value": 0n,
       }
     `)
   })
@@ -219,7 +215,6 @@ describe('fromRpc', () => {
           },
         ],
         "chainId": 1,
-        "data": undefined,
         "feeToken": "0x20c0000000000000000000000000000000000000",
         "from": "0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6",
         "gas": 278365n,
@@ -258,7 +253,6 @@ describe('fromRpc', () => {
         },
         "transactionIndex": 2,
         "type": "tempo",
-        "value": 0n,
       }
     `)
   })
@@ -319,7 +313,6 @@ describe('toRpc', () => {
         "gas": "0x43f5d",
         "gasPrice": "0x2ca6ae494",
         "hash": "0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0",
-        "input": undefined,
         "maxFeePerGas": "0x2",
         "maxPriorityFeePerGas": "0x1",
         "nonce": "0x357",
@@ -329,10 +322,8 @@ describe('toRpc', () => {
           "type": "secp256k1",
           "yParity": "0x0",
         },
-        "to": undefined,
         "transactionIndex": "0x2",
         "type": "0x76",
-        "value": "0x0",
       }
     `)
   })
@@ -401,7 +392,6 @@ describe('toRpc', () => {
         "gas": "0x43f5d",
         "gasPrice": "0x2ca6ae494",
         "hash": "0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0",
-        "input": undefined,
         "maxFeePerGas": "0x2",
         "maxPriorityFeePerGas": "0x1",
         "nonce": "0x357",
@@ -411,10 +401,8 @@ describe('toRpc', () => {
           "type": "secp256k1",
           "yParity": "0x0",
         },
-        "to": undefined,
         "transactionIndex": "0x2",
         "type": "0x76",
-        "value": "0x0",
       }
     `)
   })
@@ -491,7 +479,6 @@ describe('toRpc', () => {
         "gas": "0x43f5d",
         "gasPrice": "0x2ca6ae494",
         "hash": "0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0",
-        "input": undefined,
         "keyAuthorization": {
           "chainId": "0x1",
           "expiry": "0xffffffffffff",
@@ -519,10 +506,8 @@ describe('toRpc', () => {
           "type": "secp256k1",
           "yParity": "0x0",
         },
-        "to": undefined,
         "transactionIndex": "0x2",
         "type": "0x76",
-        "value": "0x0",
       }
     `)
   })

package/src/tempo/Transaction.ts

@@ -2,6 +2,7 @@ import type * as AccessList from '../core/AccessList.js'
 import type * as Address from '../core/Address.js'
 import type * as Errors from '../core/Errors.js'
 import * as Hex from '../core/Hex.js'
+import * as Quantity from '../core/internal/quantity.js'
 import type { Compute, OneOf, UnionCompute } from '../core/internal/types.js'
 import * as Signature from '../core/Signature.js'
 import * as ox_Transaction from '../core/Transaction.js'
@@ -102,18 +103,40 @@ export type Tempo<
 export type TempoRpc<pending extends boolean = false> = Compute<
   Omit<
     Tempo<pending, Hex.Hex, Hex.Hex, ToRpcType['tempo']>,
-    'authorizationList' | 'calls' | 'keyAuthorization' | 'signature'
+    | 'authorizationList'
+    | 'calls'
+    | 'feePayerSignature'
+    | 'gasPrice'
+    | 'keyAuthorization'
+    | 'nonceKey'
+    | 'signature'
+    | 'validAfter'
+    | 'validBefore'
   > & {
     aaAuthorizationList?: AuthorizationTempo.ListRpc | undefined
     calls:
       | readonly {
-          input?: Hex.Hex | undefined
-          to?: Hex.Hex | undefined
-          value?: Hex.Hex | undefined
+          data?: Hex.Hex | null | undefined
+          input?: Hex.Hex | null | undefined
+          to?: Hex.Hex | null | undefined
+          value?: Hex.Hex | null | undefined
         }[]
       | undefined
-    keyAuthorization?: KeyAuthorization.Rpc | undefined
+    feePayerSignature?:
+      | {
+          r: Hex.Hex
+          s: Hex.Hex
+          v?: Hex.Hex | undefined
+          yParity: Hex.Hex
+        }
+      | null
+      | undefined
+    gasPrice?: Hex.Hex | null | undefined
+    keyAuthorization?: KeyAuthorization.Rpc | null | undefined
+    nonceKey?: Hex.Hex | null | undefined
     signature: SignatureEnvelope.SignatureEnvelopeRpc
+    validAfter?: Hex.Hex | null | undefined
+    validBefore?: Hex.Hex | null | undefined
   }
 >
 
@@ -198,19 +221,26 @@ export function fromRpc<
     transaction as ox_Transaction.Rpc<pending>,
   ) as Transaction<pending>
 
-  transaction_.type = fromRpcType[transaction.type as keyof typeof fromRpcType]
+  if (transaction.type !== '0x76') return transaction_ as never
+
+  transaction_.type = 'tempo'
+
+  // Tempo transactions carry `calls`; scrub the flat call fields the generic
+  // decoder fabricates.
+  delete (transaction_ as any).data
+  delete (transaction_ as any).input
+  delete (transaction_ as any).to
+  delete (transaction_ as any).value
 
-  if (transaction.aaAuthorizationList) {
+  if (transaction.aaAuthorizationList?.length)
     transaction_.authorizationList = AuthorizationTempo.fromRpcList(
       transaction.aaAuthorizationList,
     )
-    delete (transaction_ as any).aaAuthorizationList
-  }
+  delete (transaction_ as any).aaAuthorizationList
   if (transaction.calls)
     transaction_.calls = transaction.calls.map((call) => ({
-      to: call.to,
+      to: call.to ?? undefined,
       value: call.value && call.value !== '0x' ? BigInt(call.value) : undefined,
-      // @ts-expect-error
       data: call.input || call.data || '0x',
     }))
   if (transaction.feeToken) transaction_.feeToken = transaction.feeToken
@@ -234,6 +264,18 @@ export function fromRpc<
     )
   }
 
+  // The node serializes absent optional fields as `null`; scrub them.
+  for (const key of [
+    'feePayer',
+    'feePayerSignature',
+    'gasPrice',
+    'keyAuthorization',
+    'nonceKey',
+    'validAfter',
+    'validBefore',
+  ] as const)
+    if ((transaction_ as any)[key] === null) delete (transaction_ as any)[key]
+
   return transaction_ as never
 }
 
@@ -292,14 +334,22 @@ export declare namespace fromRpc {
  * @returns An RPC-formatted transaction.
  */
 export function toRpc<pending extends boolean = false>(
-  transaction: Transaction<pending>,
+  transaction: toRpc.Input<pending>,
   _options?: toRpc.Options<pending>,
 ): Rpc<pending> {
   const rpc = ox_Transaction.toRpc(
     transaction as ox_Transaction.Transaction<pending>,
   ) as Rpc<pending>
 
-  rpc.type = toRpcType[transaction.type as keyof typeof toRpcType]
+  if (transaction.type !== 'tempo') return rpc
+
+  rpc.type = '0x76'
+
+  // Tempo transactions carry `calls`; scrub the flat call fields the generic
+  // encoder fabricates.
+  delete (rpc as any).input
+  delete (rpc as any).to
+  delete (rpc as any).value
 
   if (transaction.authorizationList)
     rpc.aaAuthorizationList = AuthorizationTempo.toRpcList(
@@ -308,7 +358,7 @@ export function toRpc<pending extends boolean = false>(
   if (transaction.calls)
     rpc.calls = transaction.calls.map((call) => ({
       to: call.to,
-      value: call.value ? Hex.fromNumber(call.value) : undefined,
+      value: call.value ? Quantity.fromNumberish(call.value) : undefined,
       data: call.data,
     }))
   if (transaction.feeToken) rpc.feeToken = transaction.feeToken
@@ -319,20 +369,29 @@ export function toRpc<pending extends boolean = false>(
       transaction.feePayerSignature,
     ) as any
     ;(rpc.feePayerSignature as any).v = Hex.fromNumber(
-      Signature.yParityToV(transaction.feePayerSignature?.yParity),
+      Signature.yParityToV(Number(transaction.feePayerSignature.yParity)),
     )
   }
+  if (transaction.nonceKey !== undefined)
+    rpc.nonceKey = Quantity.fromNumberish(transaction.nonceKey)
   if (transaction.signature)
     rpc.signature = SignatureEnvelope.toRpc(transaction.signature)
-  if (typeof transaction.validAfter === 'number')
-    rpc.validAfter = Hex.fromNumber(transaction.validAfter)
-  if (typeof transaction.validBefore === 'number')
-    rpc.validBefore = Hex.fromNumber(transaction.validBefore)
+  if (transaction.validAfter !== undefined)
+    rpc.validAfter = Quantity.fromNumberish(transaction.validAfter)
+  if (transaction.validBefore !== undefined)
+    rpc.validBefore = Quantity.fromNumberish(transaction.validBefore)
 
   return rpc as Rpc<pending>
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#(Transaction:namespace).(toRpc:function)}. */
+  type Input<pending extends boolean = false> = Transaction<
+    pending,
+    Hex.Hex | bigint | number,
+    Hex.Hex | number
+  >
+
   type Options<pending extends boolean = false> = {
     pending?: pending | boolean | undefined
   }