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

package/src/zod/AbiParameters.ts

@@ -0,0 +1,7 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_AbiParameter from './AbiParameter.js'
+import * as z from 'zod/mini'
+
+export const AbiParameters = z.readonly(z.array(z_AbiParameter.AbiParameter))
+
+export const Parameter = z_AbiParameter.AbiParameter

package/src/zod/AbiReceive.ts

@@ -0,0 +1,7 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z from 'zod/mini'
+
+export const AbiReceive = z.object({
+  type: z.literal('receive'),
+  stateMutability: z.literal('payable'),
+})

package/src/zod/AccountProof.ts

@@ -6,19 +6,41 @@ import * as z_Uint from './Uint.js'
 import * as z from 'zod/mini'
 
 /** RPC storage proof schema decoded to a storage proof. */
-export const StorageProof = z.object({
-  key: z_Hex.Hex,
-  proof: z.readonly(z.array(z_Hex.Hex)),
-  value: z_Uint.Uint,
-})
+export const StorageProof = z.object(storageProofFields(z_Uint.Uint))
+
+/** Encode-only storage proof schema accepting numberish `toRpc` inputs. */
+export const StorageProofToRpc = z.object(storageProofFields(z_Uint.UintToRpc))
 
 /** RPC account proof schema decoded to an account proof. */
-export const AccountProof = z.object({
-  address: z_Address.Address,
-  balance: z_Uint.Uint,
-  codeHash: z_Hex.Hex,
-  nonce: z_Number.Number,
-  storageHash: z_Hex.Hex,
-  accountProof: z.readonly(z.array(z_Hex.Hex)),
-  storageProof: z.readonly(z.array(StorageProof)),
-})
+export const AccountProof = z.object(
+  accountProofFields(z_Uint.Uint, z_Number.Number, StorageProof),
+)
+
+/** Encode-only account proof schema accepting numberish `toRpc` inputs. */
+export const AccountProofToRpc = z.object(
+  accountProofFields(z_Uint.UintToRpc, z_Number.NumberToRpc, StorageProofToRpc),
+)
+
+function storageProofFields<uint extends z.ZodMiniType>(uint: uint) {
+  return {
+    key: z_Hex.Hex,
+    proof: z.readonly(z.array(z_Hex.Hex)),
+    value: uint,
+  }
+}
+
+function accountProofFields<
+  uint extends z.ZodMiniType,
+  num extends z.ZodMiniType,
+  storageProof extends z.ZodMiniType,
+>(uint: uint, num: num, storageProof: storageProof) {
+  return {
+    address: z_Address.Address,
+    balance: uint,
+    codeHash: z_Hex.Hex,
+    nonce: num,
+    storageHash: z_Hex.Hex,
+    accountProof: z.readonly(z.array(z_Hex.Hex)),
+    storageProof: z.readonly(z.array(storageProof)),
+  }
+}

package/src/zod/Authorization.ts

@@ -13,36 +13,38 @@ const yParityHex = z_Hex.Hex.check(
 )
 
 /** Unsigned EIP-7702 authorization schema. */
-export const Unsigned = z.object({
-  address: z_Address.Address,
-  chainId: z_Number.Number,
-  nonce: z_Uint.Uint,
-  r: z.optional(z.undefined()),
-  s: z.optional(z.undefined()),
-  yParity: z.optional(z.undefined()),
-})
+export const Unsigned = z.object(unsignedFields(z_Number.Number, z_Uint.Uint))
+
+/** Encode-only unsigned EIP-7702 authorization schema accepting numberish `toRpc` inputs. */
+export const UnsignedToRpc = z.object(
+  unsignedFields(z_Number.NumberToRpc, z_Uint.UintToRpc),
+)
 
 /** Signed EIP-7702 authorization schema. */
-export const Signed = z.object({
-  address: z_Address.Address,
-  chainId: z_Number.Number,
-  nonce: z_Uint.Uint,
-  r: z_Hex.Hex32,
-  s: z_Hex.Hex32,
-  yParity: z_Uint.Uint8.check(
-    z.refine((value) => value === 0 || value === 1, 'expected yParity'),
-  ),
-})
+export const Signed = z.object(
+  signedFields(z_Number.Number, z_Uint.Uint, yParityUint()),
+)
+
+/** Encode-only signed EIP-7702 authorization schema accepting numberish `toRpc` inputs. */
+export const SignedToRpc = z.object(
+  signedFields(z_Number.NumberToRpc, z_Uint.UintToRpc, yParityUintToRpc()),
+)
 
 /** EIP-7702 authorization schema. */
 export const Authorization = z.union([Signed, Unsigned])
 
+/** Encode-only EIP-7702 authorization schema accepting numberish `toRpc` inputs. */
+export const AuthorizationToRpc = z.union([SignedToRpc, UnsignedToRpc])
+
 /** EIP-7702 authorization list schema. */
 export const List = z.readonly(z.array(Authorization))
 
 /** Signed EIP-7702 authorization list schema. */
 export const ListSigned = z.readonly(z.array(Signed))
 
+/** Encode-only signed EIP-7702 authorization list schema accepting numberish `toRpc` inputs. */
+export const ListSignedToRpc = z.readonly(z.array(SignedToRpc))
+
 /** Unsigned EIP-7702 authorization tuple schema. */
 export const TupleUnsigned = z.readonly(
   z.tuple([z_Hex.Hex, z_Address.Address, z_Hex.Hex]),
@@ -68,3 +70,48 @@ export const TupleList = z.readonly(z.array(Tuple))
 
 /** Signed EIP-7702 authorization tuple list schema. */
 export const TupleListSigned = z.readonly(z.array(TupleSigned))
+
+function yParityUint() {
+  return z_Uint.Uint8.check(
+    z.refine((value) => value === 0 || value === 1, 'expected yParity'),
+  )
+}
+
+function yParityUintToRpc() {
+  return z_Uint.Uint8ToRpc.check(
+    z.refine(
+      (value) =>
+        value === 0 || value === 1 || value === '0x0' || value === '0x1',
+      'expected yParity',
+    ),
+  )
+}
+
+function unsignedFields<num extends z.ZodMiniType, uint extends z.ZodMiniType>(
+  num: num,
+  uint: uint,
+) {
+  return {
+    address: z_Address.Address,
+    chainId: num,
+    nonce: uint,
+    r: z.optional(z.undefined()),
+    s: z.optional(z.undefined()),
+    yParity: z.optional(z.undefined()),
+  }
+}
+
+function signedFields<
+  num extends z.ZodMiniType,
+  uint extends z.ZodMiniType,
+  yParity extends z.ZodMiniType,
+>(num: num, uint: uint, yParity: yParity) {
+  return {
+    address: z_Address.Address,
+    chainId: num,
+    nonce: uint,
+    r: z_Hex.Hex32,
+    s: z_Hex.Hex32,
+    yParity,
+  }
+}

package/src/zod/BigInt.ts

@@ -1,6 +1,11 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 import * as core_Hex from '../core/Hex.js'
-import { quantityHex, uintBigint } from './internal/Integer.js'
+import {
+  encodeNumberish,
+  quantityHex,
+  uintBigint,
+  uintBigintNumberish,
+} from './internal/Integer.js'
 import * as z from 'zod/mini'
 
 /** Hex quantity decoded as `bigint` and encoded as hex. */
@@ -8,3 +13,9 @@ export const BigInt = z.codec(quantityHex(), uintBigint(), {
   decode: (value) => core_Hex.toBigInt(value),
   encode: (value) => core_Hex.fromNumber(value),
 })
+
+/** Encode-only hex quantity accepting `Hex | bigint | number`. */
+export const BigIntToRpc = z.codec(quantityHex(), uintBigintNumberish(), {
+  decode: (value) => core_Hex.toBigInt(value),
+  encode: (value) => encodeNumberish(value),
+})

package/src/zod/Block.ts

@@ -36,40 +36,80 @@ export const Identifier = z.union([
 ])
 
 /** Block schema with transaction hashes. */
-export const Block = z.object(blockFields(z.readonly(z.array(z_Hex.Hex))))
+export const Block = z.object(
+  blockFields(
+    z.readonly(z.array(z_Hex.Hex)),
+    z_Uint.Uint,
+    z_Withdrawal.Withdrawal,
+  ),
+)
+
+/** Encode-only block schema (transaction hashes) accepting numberish `toRpc` inputs. */
+export const BlockToRpc = z.object(
+  blockFields(
+    z.readonly(z.array(z_Hex.Hex)),
+    z_Uint.UintToRpc,
+    z_Withdrawal.WithdrawalToRpc,
+  ),
+)
 
 /** Block schema with full transactions. */
 export const WithTransactions = z.object(
-  blockFields(z.readonly(z.array(z_Transaction.Transaction))),
+  blockFields(
+    z.readonly(z.array(z_Transaction.Transaction)),
+    z_Uint.Uint,
+    z_Withdrawal.Withdrawal,
+  ),
+)
+
+/** Encode-only block schema (full transactions) accepting numberish `toRpc` inputs. */
+export const WithTransactionsToRpc = z.object(
+  blockFields(
+    z.readonly(z.array(z_Transaction.TransactionToRpc)),
+    z_Uint.UintToRpc,
+    z_Withdrawal.WithdrawalToRpc,
+  ),
 )
 
 /** Pending block schema with transaction hashes. */
 export const Pending = z.object(
-  pendingBlockFields(z.readonly(z.array(z_Hex.Hex))),
+  pendingBlockFields(
+    z.readonly(z.array(z_Hex.Hex)),
+    z_Uint.Uint,
+    z_Withdrawal.Withdrawal,
+  ),
 )
 
 /** Pending block schema with full transactions. */
 export const PendingWithTransactions = z.object(
-  pendingBlockFields(z.readonly(z.array(z_Transaction.Pending))),
+  pendingBlockFields(
+    z.readonly(z.array(z_Transaction.Pending)),
+    z_Uint.Uint,
+    z_Withdrawal.Withdrawal,
+  ),
 )
 
-function blockFields<const transactions extends z.ZodMiniType>(
-  transactions: transactions,
-) {
+function blockFields<
+  const transactions extends z.ZodMiniType,
+  uint extends z.ZodMiniType,
+  withdrawal extends z.ZodMiniType,
+>(transactions: transactions, uint: uint, withdrawal: withdrawal) {
   return {
-    ...commonFields(transactions),
+    ...commonFields(transactions, uint, withdrawal),
     hash: z_Hex.Hex,
     logsBloom: z_Hex.Hex,
     nonce: z_Hex.Hex,
-    number: Number,
+    number: uint,
   }
 }
 
-function pendingBlockFields<const transactions extends z.ZodMiniType>(
-  transactions: transactions,
-) {
+function pendingBlockFields<
+  const transactions extends z.ZodMiniType,
+  uint extends z.ZodMiniType,
+  withdrawal extends z.ZodMiniType,
+>(transactions: transactions, uint: uint, withdrawal: withdrawal) {
   return {
-    ...commonFields(transactions),
+    ...commonFields(transactions, uint, withdrawal),
     hash: z.null(),
     logsBloom: z.null(),
     nonce: z.null(),
@@ -77,17 +117,19 @@ function pendingBlockFields<const transactions extends z.ZodMiniType>(
   }
 }
 
-function commonFields<const transactions extends z.ZodMiniType>(
-  transactions: transactions,
-) {
+function commonFields<
+  const transactions extends z.ZodMiniType,
+  uint extends z.ZodMiniType,
+  withdrawal extends z.ZodMiniType,
+>(transactions: transactions, uint: uint, withdrawal: withdrawal) {
   return {
-    baseFeePerGas: z.optional(z_Uint.Uint),
-    blobGasUsed: z.optional(z_Uint.Uint),
-    difficulty: z.optional(z_Uint.Uint),
-    excessBlobGas: z.optional(z_Uint.Uint),
+    baseFeePerGas: z.optional(uint),
+    blobGasUsed: z.optional(uint),
+    difficulty: z.optional(uint),
+    excessBlobGas: z.optional(uint),
     extraData: z.optional(z_Hex.Hex),
-    gasLimit: z_Uint.Uint,
-    gasUsed: z_Uint.Uint,
+    gasLimit: uint,
+    gasUsed: uint,
     miner: z_Address.Address,
     mixHash: z_Hex.Hex,
     parentBeaconBlockRoot: z.optional(z_Hex.Hex),
@@ -95,14 +137,14 @@ function commonFields<const transactions extends z.ZodMiniType>(
     receiptsRoot: z_Hex.Hex,
     sealFields: z.optional(z.readonly(z.array(z_Hex.Hex))),
     sha3Uncles: z_Hex.Hex,
-    size: z_Uint.Uint,
+    size: uint,
     stateRoot: z_Hex.Hex,
-    timestamp: z_Uint.Uint,
-    totalDifficulty: z.optional(z_Uint.Uint),
+    timestamp: uint,
+    totalDifficulty: z.optional(uint),
     transactions,
     transactionsRoot: z_Hex.Hex,
     uncles: z.readonly(z.array(z_Hex.Hex)),
-    withdrawals: z.optional(z.readonly(z.array(z_Withdrawal.Withdrawal))),
+    withdrawals: z.optional(z.readonly(z.array(withdrawal))),
     withdrawalsRoot: z.optional(z_Hex.Hex),
   }
 }

package/src/zod/BlockOverrides.ts

@@ -5,13 +5,27 @@ import * as z_Withdrawal from './Withdrawal.js'
 import * as z from 'zod/mini'
 
 /** Block overrides schema. */
-export const BlockOverrides = z.object({
-  baseFeePerGas: z.optional(z_Uint.Uint),
-  blobBaseFee: z.optional(z_Uint.Uint),
-  feeRecipient: z.optional(z_Address.Address),
-  gasLimit: z.optional(z_Uint.Uint),
-  number: z.optional(z_Uint.Uint),
-  prevRandao: z.optional(z_Uint.Uint),
-  time: z.optional(z_Uint.Uint),
-  withdrawals: z.optional(z.array(z_Withdrawal.Withdrawal)),
-})
+export const BlockOverrides = z.object(
+  fields(z_Uint.Uint, z_Withdrawal.Withdrawal),
+)
+
+/** Encode-only block overrides schema accepting numberish `toRpc` inputs. */
+export const BlockOverridesToRpc = z.object(
+  fields(z_Uint.UintToRpc, z_Withdrawal.WithdrawalToRpc),
+)
+
+function fields<uint extends z.ZodMiniType, withdrawal extends z.ZodMiniType>(
+  uint: uint,
+  withdrawal: withdrawal,
+) {
+  return {
+    baseFeePerGas: z.optional(uint),
+    blobBaseFee: z.optional(uint),
+    feeRecipient: z.optional(z_Address.Address),
+    gasLimit: z.optional(uint),
+    number: z.optional(uint),
+    prevRandao: z.optional(uint),
+    time: z.optional(uint),
+    withdrawals: z.optional(z.array(withdrawal)),
+  }
+}

package/src/zod/Filter.ts

@@ -12,8 +12,6 @@ const blockTag = z.union([
   z.literal('finalized'),
 ])
 
-const blockNumber = z.union([z_Uint.Uint, blockTag])
-
 const address = z.union([
   z_Address.Address,
   z.readonly(z.array(z_Address.Address)),
@@ -30,23 +28,30 @@ export const Topic = z.union([
 /** Filter topics schema. */
 export const Topics = z.readonly(z.array(Topic))
 
-const base = {
-  address: z.optional(address),
-  topics: z.optional(Topics),
-}
-
 /** Filter schema. */
-export const Filter = z.union([
-  z.object({
-    ...base,
-    blockHash: z_Hex.Hex,
-    fromBlock: z.optional(z.undefined()),
-    toBlock: z.optional(z.undefined()),
-  }),
-  z.object({
-    ...base,
-    blockHash: z.optional(z.undefined()),
-    fromBlock: z.optional(blockNumber),
-    toBlock: z.optional(blockNumber),
-  }),
-])
+export const Filter = filter(z_Uint.Uint)
+
+/** Encode-only filter schema accepting numberish `toRpc` inputs. */
+export const FilterToRpc = filter(z_Uint.UintToRpc)
+
+function filter<uint extends z.ZodMiniType>(uint: uint) {
+  const blockNumber = z.union([uint, blockTag])
+  const base = {
+    address: z.optional(address),
+    topics: z.optional(Topics),
+  }
+  return z.union([
+    z.object({
+      ...base,
+      blockHash: z_Hex.Hex,
+      fromBlock: z.optional(z.undefined()),
+      toBlock: z.optional(z.undefined()),
+    }),
+    z.object({
+      ...base,
+      blockHash: z.optional(z.undefined()),
+      fromBlock: z.optional(blockNumber),
+      toBlock: z.optional(blockNumber),
+    }),
+  ])
+}

package/src/zod/Log.ts

@@ -5,21 +5,13 @@ import * as z_Number from './Number.js'
 import * as z_Uint from './Uint.js'
 import * as z from 'zod/mini'
 
-const topics = z.tuple([z_Hex.Hex], z_Hex.Hex)
+const topics = z.array(z_Hex.Hex)
 
 /** Log schema. */
-export const Log = z.object({
-  address: z_Address.Address,
-  blockHash: z_Hex.Hex,
-  blockNumber: z_Uint.Uint,
-  blockTimestamp: z.optional(z_Uint.Uint),
-  data: z_Hex.Hex,
-  logIndex: z_Number.Number,
-  topics,
-  transactionHash: z_Hex.Hex,
-  transactionIndex: z_Number.Number,
-  removed: z.boolean(),
-})
+export const Log = z.object(fields(z_Uint.Uint, z_Number.Number))
+
+/** Encode-only log schema accepting numberish `toRpc` inputs. */
+export const LogToRpc = z.object(fields(z_Uint.UintToRpc, z_Number.NumberToRpc))
 
 /** Pending log schema. */
 export const Pending = z.object({
@@ -34,3 +26,21 @@ export const Pending = z.object({
   transactionIndex: z.null(),
   removed: z.boolean(),
 })
+
+function fields<uint extends z.ZodMiniType, num extends z.ZodMiniType>(
+  uint: uint,
+  num: num,
+) {
+  return {
+    address: z_Address.Address,
+    blockHash: z_Hex.Hex,
+    blockNumber: uint,
+    blockTimestamp: z.optional(uint),
+    data: z_Hex.Hex,
+    logIndex: num,
+    topics,
+    transactionHash: z_Hex.Hex,
+    transactionIndex: num,
+    removed: z.boolean(),
+  }
+}

package/src/zod/Number.ts

@@ -1,6 +1,11 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 import * as core_Hex from '../core/Hex.js'
-import { quantityHex, uintNumber } from './internal/Integer.js'
+import {
+  encodeNumberish,
+  quantityHex,
+  uintNumber,
+  uintNumberNumberish,
+} from './internal/Integer.js'
 import * as z from 'zod/mini'
 
 /** Hex quantity decoded as `number` and encoded as hex. */
@@ -8,3 +13,9 @@ export const Number = z.codec(quantityHex(), uintNumber(), {
   decode: (value) => core_Hex.toNumber(value),
   encode: (value) => core_Hex.fromNumber(value),
 })
+
+/** Encode-only hex quantity accepting `Hex | number`. */
+export const NumberToRpc = z.codec(quantityHex(), uintNumberNumberish(), {
+  decode: (value) => core_Hex.toNumber(value),
+  encode: (value) => encodeNumberish(value),
+})