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

package/src/zod/RpcSchema.ts

@@ -88,7 +88,7 @@ export declare namespace from {
     { params: z.ZodMiniType; returns: z.ZodMiniType }
   >
 
-  /** The normalized `RpcSchema.Namespace` derived from a {@link from.Namespace}. */
+  /** The normalized `RpcSchema.Namespace` derived from `from.Namespace`. */
   type ReturnType<namespace extends Namespace> = {
     [method in keyof namespace & string]: Item<
       method,
@@ -128,7 +128,9 @@ function requestSchema(namespace: Namespace): z.ZodMiniType {
 }
 
 /**
- * Looks up the `RpcSchema.Item` for a method on a namespace.
+ * Looks up the `RpcSchema.Item` for a method on a namespace. Resolve a method
+ * once and pass the item to the `decode*`/`encode*` codecs to encode params and
+ * decode returns without repeating the namespace and method name.
  *
  * @example
  * ```ts twoslash
@@ -136,8 +138,11 @@ function requestSchema(namespace: Namespace): z.ZodMiniType {
  *
  * const item = z.RpcSchema.parseItem(
  *   z.RpcSchema.Eth,
- *   'eth_blockNumber'
+ *   'eth_getBlockTransactionCountByNumber'
  * )
+ *
+ * const params = z.RpcSchema.encodeParams(item, [1n])
+ * const count = z.RpcSchema.decodeReturns(item, '0x1')
  * ```
  *
  * @throws `RpcSchema.MethodNotFoundError` if the method does not exist.
@@ -151,10 +156,18 @@ export function parseItem<
   return item
 }
 
+// Resolves a codec function's arguments into `[item, value]`, accepting either
+// `(item, value)` or `(namespace, method, value)`.
+function resolveItem(args: readonly unknown[]): [item: Item, value: unknown] {
+  if (args.length === 2) return [args[0] as Item, args[1]]
+  return [parseItem(args[0] as Namespace, args[1] as string), args[2]]
+}
+
 /**
- * Decodes (wire → native) the `params` for a method on a namespace. Use on the
- * receiving side (e.g. a server) to coerce incoming wire params into their
- * native representation.
+ * Decodes (wire → native) the `params` for a method. Use on the receiving side
+ * (e.g. a server) to coerce incoming wire params into their native
+ * representation. Accepts either a namespace + method name, or a resolved
+ * `RpcSchema.Item` (from `parseItem`/`from`).
  *
  * @example
  * ```ts twoslash
@@ -167,8 +180,26 @@ export function parseItem<
  * )
  * ```
  *
+ * @example
+ * ### From a Resolved Item
+ *
+ * ```ts twoslash
+ * import { z } from 'ox/zod'
+ *
+ * const item = z.RpcSchema.parseItem(
+ *   z.RpcSchema.Eth,
+ *   'eth_getBlockByNumber'
+ * )
+ *
+ * const params = z.RpcSchema.decodeParams(item, ['0x1', true])
+ * ```
+ *
  * @throws `RpcSchema.MethodNotFoundError` if the method does not exist.
  */
+export function decodeParams<const item extends Item>(
+  item: item,
+  params: z.input<item['params']>,
+): z.output<item['params']>
 export function decodeParams<
   const namespace extends Namespace,
   method extends MethodName<namespace>,
@@ -176,14 +207,18 @@ export function decodeParams<
   namespace: namespace,
   method: method,
   params: z.input<namespace[method]['params']>,
-): z.output<namespace[method]['params']> {
-  return z.decode(parseItem(namespace, method).params, params as never) as never
+): z.output<namespace[method]['params']>
+// eslint-disable-next-line jsdoc-js/require-jsdoc
+export function decodeParams(...args: readonly unknown[]): unknown {
+  const [item, params] = resolveItem(args)
+  return z.decode(item.params, params as never) as never
 }
 
 /**
- * Encodes (native → wire) the `params` for a method on a namespace. Use on the
- * sending side (e.g. a client) to serialize native params into the wire shape
- * a JSON-RPC endpoint expects.
+ * Encodes (native → wire) the `params` for a method. Use on the sending side
+ * (e.g. a client) to serialize native params into the wire shape a JSON-RPC
+ * endpoint expects. Accepts either a namespace + method name, or a resolved
+ * `RpcSchema.Item` (from `parseItem`/`from`).
  *
  * @example
  * ```ts twoslash
@@ -196,8 +231,26 @@ export function decodeParams<
  * )
  * ```
  *
+ * @example
+ * ### From a Resolved Item
+ *
+ * ```ts twoslash
+ * import { z } from 'ox/zod'
+ *
+ * const item = z.RpcSchema.parseItem(
+ *   z.RpcSchema.Eth,
+ *   'eth_getBlockByNumber'
+ * )
+ *
+ * const params = z.RpcSchema.encodeParams(item, [1n, true])
+ * ```
+ *
  * @throws `RpcSchema.MethodNotFoundError` if the method does not exist.
  */
+export function encodeParams<const item extends Item>(
+  item: item,
+  params: z.output<item['params']>,
+): z.input<item['params']>
 export function encodeParams<
   const namespace extends Namespace,
   method extends MethodName<namespace>,
@@ -205,14 +258,18 @@ export function encodeParams<
   namespace: namespace,
   method: method,
   params: z.output<namespace[method]['params']>,
-): z.input<namespace[method]['params']> {
-  return z.encode(parseItem(namespace, method).params, params as never) as never
+): z.input<namespace[method]['params']>
+// eslint-disable-next-line jsdoc-js/require-jsdoc
+export function encodeParams(...args: readonly unknown[]): unknown {
+  const [item, params] = resolveItem(args)
+  return z.encode(item.params, params as never) as never
 }
 
 /**
- * Decodes (wire → native) the `returns` value for a method on a namespace. Use
- * on the receiving side (e.g. a client) to coerce a wire result into its native
- * representation.
+ * Decodes (wire → native) the `returns` value for a method. Use on the
+ * receiving side (e.g. a client) to coerce a wire result into its native
+ * representation. Accepts either a namespace + method name, or a resolved
+ * `RpcSchema.Item` (from `parseItem`/`from`).
  *
  * @example
  * ```ts twoslash
@@ -225,8 +282,26 @@ export function encodeParams<
  * )
  * ```
  *
+ * @example
+ * ### From a Resolved Item
+ *
+ * ```ts twoslash
+ * import { z } from 'ox/zod'
+ *
+ * const item = z.RpcSchema.parseItem(
+ *   z.RpcSchema.Eth,
+ *   'eth_blockNumber'
+ * )
+ *
+ * const result = z.RpcSchema.decodeReturns(item, '0x1b4')
+ * ```
+ *
  * @throws `RpcSchema.MethodNotFoundError` if the method does not exist.
  */
+export function decodeReturns<const item extends Item>(
+  item: item,
+  returns: z.input<item['returns']>,
+): z.output<item['returns']>
 export function decodeReturns<
   const namespace extends Namespace,
   method extends MethodName<namespace>,
@@ -234,17 +309,18 @@ export function decodeReturns<
   namespace: namespace,
   method: method,
   returns: z.input<namespace[method]['returns']>,
-): z.output<namespace[method]['returns']> {
-  return z.decode(
-    parseItem(namespace, method).returns,
-    returns as never,
-  ) as never
+): z.output<namespace[method]['returns']>
+// eslint-disable-next-line jsdoc-js/require-jsdoc
+export function decodeReturns(...args: readonly unknown[]): unknown {
+  const [item, returns] = resolveItem(args)
+  return z.decode(item.returns, returns as never) as never
 }
 
 /**
- * Encodes (native → wire) the `returns` value for a method on a namespace. Use
- * on the sending side (e.g. a server) to serialize a native result into the
- * wire shape.
+ * Encodes (native → wire) the `returns` value for a method. Use on the sending
+ * side (e.g. a server) to serialize a native result into the wire shape.
+ * Accepts either a namespace + method name, or a resolved `RpcSchema.Item`
+ * (from `parseItem`/`from`).
  *
  * @example
  * ```ts twoslash
@@ -257,8 +333,26 @@ export function decodeReturns<
  * )
  * ```
  *
+ * @example
+ * ### From a Resolved Item
+ *
+ * ```ts twoslash
+ * import { z } from 'ox/zod'
+ *
+ * const item = z.RpcSchema.parseItem(
+ *   z.RpcSchema.Eth,
+ *   'eth_blockNumber'
+ * )
+ *
+ * const result = z.RpcSchema.encodeReturns(item, 436n)
+ * ```
+ *
  * @throws `RpcSchema.MethodNotFoundError` if the method does not exist.
  */
+export function encodeReturns<const item extends Item>(
+  item: item,
+  returns: z.output<item['returns']>,
+): z.input<item['returns']>
 export function encodeReturns<
   const namespace extends Namespace,
   method extends MethodName<namespace>,
@@ -266,11 +360,11 @@ export function encodeReturns<
   namespace: namespace,
   method: method,
   returns: z.output<namespace[method]['returns']>,
-): z.input<namespace[method]['returns']> {
-  return z.encode(
-    parseItem(namespace, method).returns,
-    returns as never,
-  ) as never
+): z.input<namespace[method]['returns']>
+// eslint-disable-next-line jsdoc-js/require-jsdoc
+export function encodeReturns(...args: readonly unknown[]): unknown {
+  const [item, returns] = resolveItem(args)
+  return z.encode(item.returns, returns as never) as never
 }
 
 /**

package/src/zod/Signature.ts

@@ -11,13 +11,28 @@ const yParityHex = z_Hex.Hex.check(
   ),
 )
 
+const yParityUint = z_Uint.Uint8.check(
+  z.refine((value) => value === 0 || value === 1, 'expected yParity'),
+)
+const yParityUintToRpc = z_Uint.Uint8ToRpc.check(
+  z.refine(
+    (value) => value === 0 || value === 1 || value === '0x0' || value === '0x1',
+    'expected yParity',
+  ),
+)
+
 /** RPC signature schema decoded to a recovered signature. */
 export const Signature = z.object({
   r: z_Hex.Hex32,
   s: z_Hex.Hex32,
-  yParity: z_Uint.Uint8.check(
-    z.refine((value) => value === 0 || value === 1, 'expected yParity'),
-  ),
+  yParity: yParityUint,
+})
+
+/** Encode-only recovered signature schema accepting numberish `toRpc` inputs. */
+export const SignatureToRpc = z.object({
+  r: z_Hex.Hex32,
+  s: z_Hex.Hex32,
+  yParity: yParityUintToRpc,
 })
 
 /** Legacy RPC signature schema decoded to a legacy signature. */

package/src/zod/Solidity.ts

@@ -0,0 +1,83 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import type * as abitype from 'abitype'
+import * as z from 'zod/mini'
+
+export const Identifier = z
+  .string()
+  .check(
+    z.refine(
+      (value) => /^[a-zA-Z$_][a-zA-Z0-9$_]*$/.test(value),
+      'expected identifier',
+    ),
+  )
+
+export const Address = z.literal('address')
+export const Bool = z.literal('bool')
+export const Bytes = z
+  .string()
+  .check(
+    z.refine(
+      (value): value is abitype.SolidityBytes =>
+        /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(value),
+      'expected Solidity bytes type',
+    ),
+  )
+export const Function = z.literal('function')
+export const String = z.literal('string')
+export const Tuple = z.literal('tuple')
+export const Int = z
+  .string()
+  .check(
+    z.refine(
+      (value): value is abitype.SolidityInt =>
+        /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(
+          value,
+        ),
+      'expected Solidity integer type',
+    ),
+  )
+export const ArrayWithoutTuple = z
+  .string()
+  .check(
+    z.refine(
+      (value): value is abitype.SolidityArrayWithoutTuple =>
+        /^(address|bool|function|string|bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?|u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?)(\[[0-9]{0,}\])+$/.test(
+          value,
+        ),
+      'expected Solidity array type',
+    ),
+  )
+export const ArrayWithTuple = z
+  .string()
+  .check(
+    z.refine(
+      (value): value is abitype.SolidityArrayWithTuple =>
+        /^tuple(\[[0-9]{0,}\])+$/.test(value),
+      'expected Solidity tuple array type',
+    ),
+  )
+export const Array = z.union([ArrayWithTuple, ArrayWithoutTuple])
+
+export const Type = z.union([
+  Address,
+  Bool,
+  Bytes,
+  Function,
+  String,
+  Tuple,
+  Int,
+  Array,
+])
+
+export function isType(type: string) {
+  return (
+    type === 'address' ||
+    type === 'bool' ||
+    type === 'function' ||
+    type === 'string' ||
+    /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(type) ||
+    /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(
+      type,
+    )
+  )
+}

package/src/zod/StateOverrides.ts

@@ -4,29 +4,41 @@ import * as z_Hex from './Hex.js'
 import * as z_Uint from './Uint.js'
 import * as z from 'zod/mini'
 
-const accountOverrideBase = {
-  balance: z.optional(z_Uint.Uint),
-  code: z.optional(z_Hex.Hex),
-  movePrecompileToAddress: z.optional(z_Address.Address),
-  nonce: z.optional(z_Uint.Uint),
-}
-
 /** Account storage override schema. */
 export const AccountStorage = z.record(z_Hex.Hex, z_Hex.Hex)
 
 /** Account override schema. */
-export const AccountOverrides = z.union([
-  z.object({
-    ...accountOverrideBase,
-    state: z.optional(AccountStorage),
-    stateDiff: z.optional(z.undefined()),
-  }),
-  z.object({
-    ...accountOverrideBase,
-    state: z.optional(z.undefined()),
-    stateDiff: z.optional(AccountStorage),
-  }),
-])
+export const AccountOverrides = accountOverrides(z_Uint.Uint)
+
+/** Encode-only account override schema accepting numberish `toRpc` inputs. */
+export const AccountOverridesToRpc = accountOverrides(z_Uint.UintToRpc)
 
 /** State override set schema. */
 export const StateOverrides = z.record(z_Address.Address, AccountOverrides)
+
+/** Encode-only state override set schema accepting numberish `toRpc` inputs. */
+export const StateOverridesToRpc = z.record(
+  z_Address.Address,
+  AccountOverridesToRpc,
+)
+
+function accountOverrides<uint extends z.ZodMiniType>(uint: uint) {
+  const base = {
+    balance: z.optional(uint),
+    code: z.optional(z_Hex.Hex),
+    movePrecompileToAddress: z.optional(z_Address.Address),
+    nonce: z.optional(uint),
+  }
+  return z.union([
+    z.object({
+      ...base,
+      state: z.optional(AccountStorage),
+      stateDiff: z.optional(z.undefined()),
+    }),
+    z.object({
+      ...base,
+      state: z.optional(z.undefined()),
+      stateDiff: z.optional(AccountStorage),
+    }),
+  ])
+}