ox 1.0.0-beta.2 → 1.0.0-beta.20

package/src/core/AbiParameters.ts

@@ -3,6 +3,8 @@ import * as Address from './Address.js'
 import * as Bytes from './Bytes.js'
 import * as Errors from './Errors.js'
 import * as Hex from './Hex.js'
+import * as formatAbiParameters from './internal/human-readable/formatAbiParameters.js'
+import * as parseAbiParameters from './internal/human-readable/parseAbiParameters.js'
 import * as internal from './internal/abiParameters.js'
 import * as Cursor from './internal/cursor.js'
 import * as Solidity from './Solidity.js'
@@ -13,6 +15,16 @@ export type AbiParameters = readonly abitype.AbiParameter[]
 /** A parameter on an {@link ox#AbiParameters.AbiParameters}. */
 export type Parameter = abitype.AbiParameter
 
+export {
+  InvalidAbiParametersError,
+  InvalidAbiTypeParameterError,
+  InvalidFunctionModifierError,
+  InvalidModifierError,
+  InvalidParameterError,
+  SolidityProtectedKeywordError,
+} from './internal/human-readable/errors.js'
+export { InvalidParenthesisError } from './internal/human-readable/errors.js'
+
 /** A packed ABI type. */
 export type PackedAbiType =
   | abitype.SolidityAddress
@@ -97,7 +109,9 @@ export function decode(
   for (let i = 0; i < parameters.length; ++i) {
     const param = parameters[i] as Parameter
     try {
-      cursor.setPosition(consumed)
+      // Zero-width types (e.g. `uint256[0]`, empty tuples) at the end of the
+      // data consume no bytes, so the cursor may already be exhausted.
+      if (consumed < bytes.length) cursor.setPosition(consumed)
       const [data_, consumed_] = internal.decodeParameter(cursor, param, {
         checksumAddress,
         staticPosition: 0,
@@ -386,11 +400,18 @@ export function format<
         Parameter | abitype.AbiEventParameter,
         ...(readonly (Parameter | abitype.AbiEventParameter)[]),
       ],
-): abitype.FormatAbiParameters<parameters> {
-  return abitype.formatAbiParameters(parameters)
+): format.ReturnType<parameters> {
+  return formatAbiParameters.formatAbiParameters(parameters)
 }
 
 export declare namespace format {
+  type ReturnType<
+    parameters extends readonly [
+      Parameter | abitype.AbiEventParameter,
+      ...(readonly (Parameter | abitype.AbiEventParameter)[]),
+    ] = readonly [Parameter, ...(readonly Parameter[])],
+  > = formatAbiParameters.FormatAbiParameters<parameters>
+
   type ErrorType = Errors.GlobalErrorType
 }
 
@@ -416,6 +437,22 @@ export declare namespace format {
  *
  * parameters
  * //^?
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
  * ```
  *
  * @example
@@ -432,6 +469,22 @@ export declare namespace format {
  *
  * parameters
  * //^?
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
  * ```
  *
  * @example
@@ -447,6 +500,22 @@ export declare namespace format {
  *
  * parameters
  * //^?
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
+ * //
  * ```
  *
  *
@@ -460,9 +529,9 @@ export function from<
   parameters: parameters | AbiParameters | string | readonly string[],
 ): from.ReturnType<parameters> {
   if (Array.isArray(parameters) && typeof parameters[0] === 'string')
-    return abitype.parseAbiParameters(parameters) as never
+    return parseAbiParameters.parseAbiParameters(parameters) as never
   if (typeof parameters === 'string')
-    return abitype.parseAbiParameters(parameters) as never
+    return parseAbiParameters.parseAbiParameters(parameters) as never
   return parameters as never
 }
 
@@ -470,9 +539,9 @@ export declare namespace from {
   type ReturnType<
     parameters extends AbiParameters | string | readonly string[],
   > = parameters extends string
-    ? abitype.ParseAbiParameters<parameters>
+    ? parseAbiParameters.ParseAbiParameters<parameters>
     : parameters extends readonly string[]
-      ? abitype.ParseAbiParameters<parameters>
+      ? parseAbiParameters.ParseAbiParameters<parameters>
       : parameters
 
   type ErrorType = Errors.GlobalErrorType
@@ -519,7 +588,7 @@ export class DataSizeTooSmallError extends Errors.BaseError {
   }) {
     super(`Data size of ${size} bytes is too small for given parameters.`, {
       metaMessages: [
-        `Params: (${abitype.formatAbiParameters(parameters as readonly [Parameter])})`,
+        `Params: (${formatAbiParameters.formatAbiParameters(parameters as readonly [Parameter])})`,
         `Data:   ${data} (${size} bytes)`,
       ],
     })

package/src/core/AccountProof.ts

@@ -130,22 +130,25 @@ export declare namespace fromRpc {
  * @param proof - The account proof to convert.
  * @returns An RPC account proof.
  */
-export function toRpc(proof: AccountProof): Rpc {
+export function toRpc(proof: toRpc.Input): Rpc {
   return {
     address: proof.address,
-    balance: Hex.fromNumber(proof.balance),
+    balance: Quantity.fromNumberish(proof.balance),
     codeHash: proof.codeHash,
-    nonce: Hex.fromNumber(proof.nonce),
+    nonce: Quantity.fromNumberish(proof.nonce),
     storageHash: proof.storageHash,
     accountProof: proof.accountProof,
     storageProof: proof.storageProof.map((slot) => ({
       key: slot.key,
       proof: slot.proof,
-      value: Quantity.fromBigInt(slot.value)!,
+      value: Quantity.fromNumberish(slot.value),
     })),
   }
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#AccountProof.(toRpc:function)}. */
+  type Input = AccountProof<Hex.Hex | bigint | number, Hex.Hex | number>
+
   type ErrorType = Errors.GlobalErrorType
 }

package/src/core/Authorization.ts

@@ -2,6 +2,7 @@ import type * as Address from './Address.js'
 import type * as Errors from './Errors.js'
 import * as Hash from './Hash.js'
 import * as Hex from './Hex.js'
+import * as Quantity from './internal/quantity.js'
 import type { Compute, Mutable, Undefined } from './internal/types.js'
 import * as Rlp from './Rlp.js'
 import * as Signature from './Signature.js'
@@ -497,18 +498,21 @@ export declare namespace hash {
  * @param authorization - An Authorization.
  * @returns An RPC-formatted Authorization.
  */
-export function toRpc(authorization: Signed): Rpc {
+export function toRpc(authorization: toRpc.Input): Rpc {
   const { address, chainId, nonce, ...signature } = authorization
 
   return {
     address,
-    chainId: Hex.fromNumber(chainId),
-    nonce: Hex.fromNumber(nonce),
+    chainId: Quantity.fromNumberish(chainId),
+    nonce: Quantity.fromNumberish(nonce),
     ...Signature.toRpc(signature),
   }
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#Authorization.(toRpc:function)}. */
+  type Input = Signed<Hex.Hex | bigint | number, Hex.Hex | number>
+
   type ErrorType = Errors.GlobalErrorType
 }
 
@@ -534,11 +538,14 @@ export declare namespace toRpc {
  * @param authorizationList - An Authorization List.
  * @returns An RPC-formatted Authorization List.
  */
-export function toRpcList(authorizationList: ListSigned): ListRpc {
+export function toRpcList(authorizationList: toRpcList.Input): ListRpc {
   return authorizationList.map(toRpc)
 }
 
 export declare namespace toRpcList {
+  /** Numberish input accepted by {@link ox#Authorization.(toRpcList:function)}. */
+  type Input = ListSigned<Hex.Hex | bigint | number, Hex.Hex | number>
+
   type ErrorType = Errors.GlobalErrorType
 }
 

package/src/core/Block.ts

@@ -148,7 +148,7 @@ export function toRpc<
   includeTransactions extends boolean = false,
   blockTag extends Tag = 'latest',
 >(
-  block: Block<includeTransactions, blockTag>,
+  block: toRpc.Input<includeTransactions, blockTag>,
   _options: toRpc.Options<includeTransactions, blockTag> = {},
 ): Rpc<boolean, blockTag> {
   const transactions = block.transactions.map((transaction) => {
@@ -156,30 +156,30 @@ export function toRpc<
     return Transaction.toRpc(transaction as any) as any
   })
   return {
-    baseFeePerGas: Quantity.fromBigInt(block.baseFeePerGas),
-    blobGasUsed: Quantity.fromBigInt(block.blobGasUsed),
-    excessBlobGas: Quantity.fromBigInt(block.excessBlobGas),
+    baseFeePerGas: Quantity.fromNumberishOptional(block.baseFeePerGas),
+    blobGasUsed: Quantity.fromNumberishOptional(block.blobGasUsed),
+    excessBlobGas: Quantity.fromNumberishOptional(block.excessBlobGas),
     extraData: block.extraData,
-    difficulty: Quantity.fromBigInt(block.difficulty),
-    gasLimit: Hex.fromNumber(block.gasLimit),
-    gasUsed: Hex.fromNumber(block.gasUsed),
+    difficulty: Quantity.fromNumberishOptional(block.difficulty),
+    gasLimit: Quantity.fromNumberish(block.gasLimit),
+    gasUsed: Quantity.fromNumberish(block.gasUsed),
     hash: block.hash,
     logsBloom: block.logsBloom,
     miner: block.miner,
     mixHash: block.mixHash,
     nonce: block.nonce,
-    number: (typeof block.number === 'bigint'
-      ? Hex.fromNumber(block.number)
-      : null) as never,
+    number: (block.number === null
+      ? null
+      : Quantity.fromNumberish(block.number)) as never,
     parentBeaconBlockRoot: block.parentBeaconBlockRoot,
     parentHash: block.parentHash,
     receiptsRoot: block.receiptsRoot,
     sealFields: block.sealFields,
     sha3Uncles: block.sha3Uncles,
-    size: Hex.fromNumber(block.size),
+    size: Quantity.fromNumberish(block.size),
     stateRoot: block.stateRoot,
-    timestamp: Hex.fromNumber(block.timestamp),
-    totalDifficulty: Quantity.fromBigInt(block.totalDifficulty),
+    timestamp: Quantity.fromNumberish(block.timestamp),
+    totalDifficulty: Quantity.fromNumberishOptional(block.totalDifficulty),
     transactions,
     transactionsRoot: block.transactionsRoot,
     uncles: block.uncles,
@@ -189,6 +189,17 @@ export function toRpc<
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#Block.(toRpc:function)}. */
+  type Input<
+    includeTransactions extends boolean = false,
+    blockTag extends Tag = 'latest',
+  > = Block<
+    includeTransactions,
+    blockTag,
+    Hex.Hex | bigint | number,
+    Hex.Hex | number
+  >
+
   type Options<
     includeTransactions extends boolean = false,
     blockTag extends Tag = 'latest',

package/src/core/BlockOverrides.ts

@@ -113,23 +113,28 @@ export function fromRpc(rpcBlockOverrides: Rpc): BlockOverrides {
  * @param blockOverrides - The block overrides to convert.
  * @returns An instantiated {@link ox#BlockOverrides.Rpc}.
  */
-export function toRpc(blockOverrides: BlockOverrides): Rpc {
+export function toRpc(blockOverrides: toRpc.Input): Rpc {
   const rpc: Rpc = {}
-  if (typeof blockOverrides.baseFeePerGas === 'bigint')
-    rpc.baseFeePerGas = Quantity.fromBigInt(blockOverrides.baseFeePerGas)
-  if (typeof blockOverrides.blobBaseFee === 'bigint')
-    rpc.blobBaseFee = Quantity.fromBigInt(blockOverrides.blobBaseFee)
+  if (blockOverrides.baseFeePerGas !== undefined)
+    rpc.baseFeePerGas = Quantity.fromNumberish(blockOverrides.baseFeePerGas)
+  if (blockOverrides.blobBaseFee !== undefined)
+    rpc.blobBaseFee = Quantity.fromNumberish(blockOverrides.blobBaseFee)
   if (typeof blockOverrides.feeRecipient === 'string')
     rpc.feeRecipient = blockOverrides.feeRecipient
-  if (typeof blockOverrides.gasLimit === 'bigint')
-    rpc.gasLimit = Quantity.fromBigInt(blockOverrides.gasLimit)
-  if (typeof blockOverrides.number === 'bigint')
-    rpc.number = Quantity.fromBigInt(blockOverrides.number)
-  if (typeof blockOverrides.prevRandao === 'bigint')
-    rpc.prevRandao = Quantity.fromBigInt(blockOverrides.prevRandao)
-  if (typeof blockOverrides.time === 'bigint')
-    rpc.time = Quantity.fromBigInt(blockOverrides.time)
+  if (blockOverrides.gasLimit !== undefined)
+    rpc.gasLimit = Quantity.fromNumberish(blockOverrides.gasLimit)
+  if (blockOverrides.number !== undefined)
+    rpc.number = Quantity.fromNumberish(blockOverrides.number)
+  if (blockOverrides.prevRandao !== undefined)
+    rpc.prevRandao = Quantity.fromNumberish(blockOverrides.prevRandao)
+  if (blockOverrides.time !== undefined)
+    rpc.time = Quantity.fromNumberish(blockOverrides.time)
   if (blockOverrides.withdrawals !== undefined)
     rpc.withdrawals = blockOverrides.withdrawals.map(Withdrawal.toRpc)
   return rpc
 }
+
+export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#BlockOverrides.(toRpc:function)}. */
+  type Input = BlockOverrides<Hex.Hex | bigint | number, Hex.Hex | number>
+}

package/src/core/Filter.ts

@@ -123,7 +123,7 @@ export declare namespace fromRpc {
  * @param filter - The filter to convert.
  * @returns An RPC filter.
  */
-export function toRpc(filter: Filter): Rpc {
+export function toRpc(filter: toRpc.Input): Rpc {
   const { address, topics, fromBlock, toBlock, blockHash } = filter
   return {
     ...(typeof address !== 'undefined' ? { address } : {}),
@@ -132,20 +132,23 @@ export function toRpc(filter: Filter): Rpc {
     ...(typeof fromBlock !== 'undefined'
       ? {
           fromBlock:
-            typeof fromBlock === 'bigint'
-              ? Hex.fromNumber(fromBlock)
-              : fromBlock,
+            typeof fromBlock === 'string'
+              ? fromBlock
+              : Hex.fromNumber(fromBlock),
         }
       : {}),
     ...(typeof toBlock !== 'undefined'
       ? {
           toBlock:
-            typeof toBlock === 'bigint' ? Hex.fromNumber(toBlock) : toBlock,
+            typeof toBlock === 'string' ? toBlock : Hex.fromNumber(toBlock),
         }
       : {}),
   } as unknown as Rpc
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#Filter.(toRpc:function)}. */
+  type Input = Filter<Hex.Hex | bigint | number>
+
   type ErrorType = Errors.GlobalErrorType
 }

package/src/core/Log.ts

@@ -23,7 +23,7 @@ export type Log<
   /** Index of this log within its block or `null` if pending */
   logIndex: pending extends true ? null : numberType
   /** List of topics associated with this log */
-  topics: [Hex.Hex, ...(readonly Hex.Hex[])]
+  topics: Hex.Hex[]
   /** Hash of the transaction that created this log or `null` if pending */
   transactionHash: pending extends true ? null : Hex.Hex
   /** Index of the transaction that created this log or `null` if pending */
@@ -217,31 +217,35 @@ export declare namespace fromRpc {
  * @returns An RPC log.
  */
 export function toRpc<
-  const log extends Log<boolean>,
+  const log extends toRpc.Input,
   pending extends boolean = false,
 >(log: log, _options: toRpc.Options<pending> = {}): Rpc<pending> {
   return {
     address: log.address,
     blockHash: log.blockHash,
-    blockNumber: Quantity.fromBigInt(log.blockNumber) ?? null,
+    blockNumber: Quantity.fromNumberishOptional(log.blockNumber) ?? null,
     ...('blockTimestamp' in log
       ? {
           blockTimestamp:
             log.blockTimestamp === null
               ? null
-              : Quantity.fromBigInt(log.blockTimestamp),
+              : Quantity.fromNumberishOptional(log.blockTimestamp),
         }
       : {}),
     data: log.data,
-    logIndex: Quantity.fromNumber(log.logIndex) ?? null,
+    logIndex: Quantity.fromNumberishOptional(log.logIndex) ?? null,
     topics: log.topics,
     transactionHash: log.transactionHash,
-    transactionIndex: Quantity.fromNumber(log.transactionIndex) ?? null,
+    transactionIndex:
+      Quantity.fromNumberishOptional(log.transactionIndex) ?? null,
     removed: log.removed,
   } as Rpc as never
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#Log.(toRpc:function)}. */
+  type Input = Log<boolean, Hex.Hex | bigint | number, Hex.Hex | number>
+
   type Options<pending extends boolean = false> = {
     pending?: pending | boolean | undefined
   }

package/src/core/Rlp.ts

@@ -5,6 +5,9 @@ import * as internal_bytes from './internal/bytes.js'
 import * as Cursor from './internal/cursor.js'
 import type { ExactPartial, RecursiveArray } from './internal/types.js'
 
+/** Maximum nesting depth permitted when decoding an RLP value. */
+const depthLimit = 1_024
+
 /**
  * Decodes a Recursive-Length Prefix (RLP) value into a {@link ox#Bytes.Bytes} value.
  *
@@ -68,6 +71,12 @@ export function to<
   })
   const result = decodeRlpCursor(cursor, to_)
 
+  // RLP payloads encode exactly one item (Yellow Paper, Appendix B).
+  if (cursor.position < cursor.bytes.length)
+    throw new TrailingBytesError({
+      count: cursor.bytes.length - cursor.position,
+    })
+
   return result as to.ReturnType<to>
 }
 
@@ -82,6 +91,7 @@ export declare namespace to {
     | decodeRlpCursor.ErrorType
     | Cursor.create.ErrorType
     | Hex.InvalidLengthError
+    | TrailingBytesError
     | Errors.GlobalErrorType
 }
 
@@ -91,7 +101,11 @@ export declare namespace to {
 export function decodeRlpCursor<to extends 'Hex' | 'Bytes' = 'Hex'>(
   cursor: Cursor.Cursor,
   to: to | 'Hex' | 'Bytes' | undefined = 'Hex',
+  depth = 0,
 ): decodeRlpCursor.ReturnType<to> {
+  if (depth >= depthLimit)
+    throw new DepthLimitExceededError({ limit: depthLimit })
+
   if (cursor.bytes.length === 0)
     return (
       to === 'Hex' ? Hex.fromBytes(cursor.bytes) : cursor.bytes
@@ -111,7 +125,12 @@ export function decodeRlpCursor<to extends 'Hex' | 'Bytes' = 'Hex'>(
 
   // list
   const length = readLength(cursor, prefix, 0xc0)
-  return readList(cursor, length, to) as {} as decodeRlpCursor.ReturnType<to>
+  return readList(
+    cursor,
+    length,
+    to,
+    depth + 1,
+  ) as {} as decodeRlpCursor.ReturnType<to>
 }
 
 /** @internal */
@@ -121,6 +140,7 @@ export declare namespace decodeRlpCursor {
     | Hex.fromBytes.ErrorType
     | readLength.ErrorType
     | readList.ErrorType
+    | DepthLimitExceededError
     | Errors.GlobalErrorType
 }
 
@@ -149,17 +169,27 @@ export function readList<to extends 'Hex' | 'Bytes'>(
   cursor: Cursor.Cursor,
   length: number,
   to: to | 'Hex' | 'Bytes',
+  depth = 0,
 ) {
   const position = cursor.position
   const value: decodeRlpCursor.ReturnType<to>[] = []
   while (cursor.position - position < length)
-    value.push(decodeRlpCursor(cursor, to))
+    value.push(decodeRlpCursor(cursor, to, depth))
+  // Items must consume exactly the declared list length.
+  if (cursor.position - position !== length)
+    throw new ListBoundaryExceededError({
+      consumed: cursor.position - position,
+      declared: length,
+    })
   return value
 }
 
 /** @internal */
 export declare namespace readList {
-  type ErrorType = Errors.GlobalErrorType
+  type ErrorType =
+    | DepthLimitExceededError
+    | ListBoundaryExceededError
+    | Errors.GlobalErrorType
 }
 
 /**
@@ -643,3 +673,36 @@ function writeBigEndian(
 function invalidNibble(hex: Hex.Hex): Errors.BaseError {
   return new Errors.BaseError(`Invalid hex string \`${hex}\`.`)
 }
+
+/** Thrown when an RLP value nests deeper than the decode depth limit. */
+export class DepthLimitExceededError extends Errors.BaseError {
+  override readonly name = 'Rlp.DepthLimitExceededError'
+
+  constructor({ limit }: { limit: number }) {
+    super(`RLP depth limit of \`${limit}\` exceeded.`)
+  }
+}
+
+/** Thrown when RLP list items overrun the list's declared length. */
+export class ListBoundaryExceededError extends Errors.BaseError {
+  override readonly name = 'Rlp.ListBoundaryExceededError'
+
+  constructor({ consumed, declared }: { consumed: number; declared: number }) {
+    super(
+      `RLP list items consumed \`${consumed}\` bytes but the list declared a length of \`${declared}\`.`,
+    )
+  }
+}
+
+/** Thrown when an RLP payload contains bytes after the decoded item. */
+export class TrailingBytesError extends Errors.BaseError {
+  override readonly name = 'Rlp.TrailingBytesError'
+
+  constructor({ count }: { count: number }) {
+    super(
+      `RLP payload encodes a single item, but \`${count}\` trailing ${
+        count === 1 ? 'byte remains' : 'bytes remain'
+      }.`,
+    )
+  }
+}

package/src/core/RpcSchema.ts

@@ -289,7 +289,7 @@ export type FromViem<schema extends readonly ViemSchemaItem[]> = {
  * Each method's name comes from its key. Both `params` and `ReturnType` are
  * derived from the Zod schema's input (wire) type, since raw JSON-RPC clients
  * send and receive wire values. Decode wire results to their native
- * representation explicitly via {@link ox#zod/RpcSchema.decodeReturns}.
+ * representation explicitly via `zod.RpcSchema.decodeReturns`.
  *
  * @example
  * ```ts twoslash
@@ -331,7 +331,7 @@ export type Schema = Generic | FromZod.Namespace
 
 /**
  * Resolves a {@link ox#RpcSchema.Schema} input to an Ox {@link ox#RpcSchema.Generic}.
- * A Zod namespace is converted via {@link ox#RpcSchema.FromZod}; a `Generic` is
+ * A Zod namespace is converted via {@link ox#RpcSchema.(FromZod:type)}; a `Generic` is
  * passed through; otherwise falls back to {@link ox#RpcSchema.Default}.
  */
 export type ToGeneric<schema extends Schema | undefined> =

package/src/core/Signature.ts

@@ -2,6 +2,7 @@ import { secp256k1 } from '@noble/curves/secp256k1.js'
 import * as Bytes from './Bytes.js'
 import * as Errors from './Errors.js'
 import * as Hex from './Hex.js'
+import * as Quantity from './internal/quantity.js'
 import type { Compute, ExactPartial, OneOf } from './internal/types.js'
 import * as Json from './Json.js'
 import * as Solidity from './Solidity.js'
@@ -806,16 +807,19 @@ export declare namespace toLegacy {
  * @param signature - The {@link ox#Signature.Signature} to convert.
  * @returns The converted {@link ox#Signature.Rpc}.
  */
-export function toRpc(signature: Signature): Rpc {
+export function toRpc(signature: toRpc.Input): Rpc {
   const { r, s, yParity } = signature
   return {
     r,
     s,
-    yParity: yParity === 0 ? '0x0' : '0x1',
+    yParity: Quantity.fromNumberish(yParity),
   }
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#Signature.(toRpc:function)}. */
+  type Input = Signature<true, Hex.Hex | number>
+
   type ErrorType = Errors.GlobalErrorType
 }
 

package/src/core/StateOverrides.ts

@@ -110,20 +110,20 @@ export function fromRpc(rpcStateOverrides: Rpc): StateOverrides {
  * @param stateOverrides - The state overrides to convert.
  * @returns An instantiated {@link ox#StateOverrides.Rpc}.
  */
-export function toRpc(stateOverrides: StateOverrides): Rpc {
+export function toRpc(stateOverrides: toRpc.Input): Rpc {
   const rpcStateOverrides: Rpc = {}
   for (const [address, accountOverrides] of Object.entries(stateOverrides)) {
     const accountOverridesRpc: RpcAccountOverrides = {}
-    if (typeof accountOverrides.balance === 'bigint')
-      accountOverridesRpc.balance = Quantity.fromBigInt(
+    if (accountOverrides.balance !== undefined)
+      accountOverridesRpc.balance = Quantity.fromNumberish(
         accountOverrides.balance,
       )
     if (accountOverrides.code) accountOverridesRpc.code = accountOverrides.code
     if (accountOverrides.movePrecompileToAddress)
       accountOverridesRpc.movePrecompileToAddress =
         accountOverrides.movePrecompileToAddress
-    if (typeof accountOverrides.nonce === 'bigint')
-      accountOverridesRpc.nonce = Quantity.fromBigInt(accountOverrides.nonce)
+    if (accountOverrides.nonce !== undefined)
+      accountOverridesRpc.nonce = Quantity.fromNumberish(accountOverrides.nonce)
     if (accountOverrides.state)
       accountOverridesRpc.state = accountOverrides.state
     if (accountOverrides.stateDiff)
@@ -132,3 +132,8 @@ export function toRpc(stateOverrides: StateOverrides): Rpc {
   }
   return rpcStateOverrides
 }
+
+export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#StateOverrides.(toRpc:function)}. */
+  type Input = StateOverrides<Hex.Hex | bigint | number>
+}