ox 1.0.0-beta.0 → 1.0.0-beta.2

package/src/tempo/e2e.test.ts

@@ -87,6 +87,7 @@ test('behavior: default (secp256k1)', async () => {
       from,
       keyAuthorization: __,
       nonce,
+      gasPrice,
       maxFeePerGas,
       maxPriorityFeePerGas,
       signature,
@@ -100,6 +101,7 @@ test('behavior: default (secp256k1)', async () => {
     expect(chainId).toBe(chainId)
     expect(hash).toBe(receipt.transactionHash)
     expect(from).toBe(address)
+    expect(gasPrice).toBeDefined()
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(nonce).toBeDefined()
@@ -119,7 +121,6 @@ test('behavior: default (secp256k1)', async () => {
         "data": undefined,
         "feePayerSignature": null,
         "gas": 500000n,
-        "gasPrice": 20000000000n,
         "nonceKey": 0n,
         "type": "tempo",
         "validAfter": null,
@@ -133,6 +134,7 @@ test('behavior: default (secp256k1)', async () => {
     blockNumber,
     blockHash,
     cumulativeGasUsed,
+    effectiveGasPrice,
     feePayer,
     feeToken: _,
     from,
@@ -147,6 +149,7 @@ test('behavior: default (secp256k1)', async () => {
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
   expect(cumulativeGasUsed).toBeDefined()
+  expect(effectiveGasPrice).toBeDefined()
   expect(feePayer).toBeDefined()
   expect(from).toBe(address)
   expect(gasUsed).toBeDefined()
@@ -159,7 +162,6 @@ test('behavior: default (secp256k1)', async () => {
       "blobGasPrice": undefined,
       "blobGasUsed": undefined,
       "contractAddress": null,
-      "effectiveGasPrice": 20000000000n,
       "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
       "type": "0x76",
@@ -298,6 +300,7 @@ test('behavior: default (p256)', async () => {
       keyAuthorization: __,
       hash,
       nonce,
+      gasPrice,
       maxFeePerGas,
       maxPriorityFeePerGas,
       signature,
@@ -312,6 +315,7 @@ test('behavior: default (p256)', async () => {
     expect(from).toBe(address)
     expect(hash).toBe(receipt.transactionHash)
     expect(nonce).toBeDefined()
+    expect(gasPrice).toBeDefined()
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(signature).toBeDefined()
@@ -330,7 +334,6 @@ test('behavior: default (p256)', async () => {
         "data": undefined,
         "feePayerSignature": null,
         "gas": 500000n,
-        "gasPrice": 20000000000n,
         "nonceKey": 0n,
         "type": "tempo",
         "validAfter": null,
@@ -344,6 +347,7 @@ test('behavior: default (p256)', async () => {
     blockNumber,
     blockHash,
     cumulativeGasUsed,
+    effectiveGasPrice,
     feePayer,
     feeToken: _,
     from,
@@ -358,6 +362,7 @@ test('behavior: default (p256)', async () => {
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
   expect(cumulativeGasUsed).toBeDefined()
+  expect(effectiveGasPrice).toBeDefined()
   expect(feePayer).toBeDefined()
   expect(from).toBe(address)
   expect(gasUsed).toBeDefined()
@@ -370,7 +375,6 @@ test('behavior: default (p256)', async () => {
       "blobGasPrice": undefined,
       "blobGasUsed": undefined,
       "contractAddress": null,
-      "effectiveGasPrice": 20000000000n,
       "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
       "type": "0x76",
@@ -441,6 +445,7 @@ test('behavior: default (p256 - webcrypto)', async () => {
       keyAuthorization: __,
       hash,
       nonce,
+      gasPrice,
       maxFeePerGas,
       maxPriorityFeePerGas,
       signature,
@@ -455,6 +460,7 @@ test('behavior: default (p256 - webcrypto)', async () => {
     expect(from).toBeDefined()
     expect(hash).toBe(receipt.transactionHash)
     expect(nonce).toBeDefined()
+    expect(gasPrice).toBeDefined()
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(signature).toBeDefined()
@@ -473,7 +479,6 @@ test('behavior: default (p256 - webcrypto)', async () => {
         "data": undefined,
         "feePayerSignature": null,
         "gas": 500000n,
-        "gasPrice": 20000000000n,
         "nonceKey": 0n,
         "type": "tempo",
         "validAfter": null,
@@ -487,6 +492,7 @@ test('behavior: default (p256 - webcrypto)', async () => {
     blockNumber,
     blockHash,
     cumulativeGasUsed,
+    effectiveGasPrice,
     feePayer,
     feeToken: _,
     from,
@@ -501,6 +507,7 @@ test('behavior: default (p256 - webcrypto)', async () => {
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
   expect(cumulativeGasUsed).toBeDefined()
+  expect(effectiveGasPrice).toBeDefined()
   expect(feePayer).toBeDefined()
   expect(from).toBeDefined()
   expect(gasUsed).toBeDefined()
@@ -513,7 +520,6 @@ test('behavior: default (p256 - webcrypto)', async () => {
       "blobGasPrice": undefined,
       "blobGasUsed": undefined,
       "contractAddress": null,
-      "effectiveGasPrice": 20000000000n,
       "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
       "type": "0x76",
@@ -591,6 +597,7 @@ test('behavior: default (webauthn)', async () => {
       keyAuthorization: __,
       hash,
       nonce,
+      gasPrice,
       maxFeePerGas,
       maxPriorityFeePerGas,
       transactionIndex,
@@ -605,6 +612,7 @@ test('behavior: default (webauthn)', async () => {
     expect(from).toBeDefined()
     expect(hash).toBe(receipt.transactionHash)
     expect(nonce).toBeDefined()
+    expect(gasPrice).toBeDefined()
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(signature).toBeDefined()
@@ -623,7 +631,6 @@ test('behavior: default (webauthn)', async () => {
         "data": undefined,
         "feePayerSignature": null,
         "gas": 500000n,
-        "gasPrice": 20000000000n,
         "nonceKey": 0n,
         "type": "tempo",
         "validAfter": null,
@@ -637,6 +644,7 @@ test('behavior: default (webauthn)', async () => {
     blockNumber,
     blockHash,
     cumulativeGasUsed,
+    effectiveGasPrice,
     feePayer,
     feeToken: _,
     from,
@@ -651,6 +659,7 @@ test('behavior: default (webauthn)', async () => {
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
   expect(cumulativeGasUsed).toBeDefined()
+  expect(effectiveGasPrice).toBeDefined()
   expect(feePayer).toBeDefined()
   expect(from).toBe(address)
   expect(gasUsed).toBeDefined()
@@ -663,7 +672,6 @@ test('behavior: default (webauthn)', async () => {
       "blobGasPrice": undefined,
       "blobGasUsed": undefined,
       "contractAddress": null,
-      "effectiveGasPrice": 20000000000n,
       "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
       "type": "0x76",
@@ -745,6 +753,7 @@ test('behavior: feePayerSignature (user → feePayer)', async () => {
       blockNumber,
       blockHash,
       cumulativeGasUsed,
+      effectiveGasPrice,
       feePayer,
       feeToken: _,
       from,
@@ -759,6 +768,7 @@ test('behavior: feePayerSignature (user → feePayer)', async () => {
     expect(blockNumber).toBeDefined()
     expect(blockHash).toBeDefined()
     expect(cumulativeGasUsed).toBeDefined()
+    expect(effectiveGasPrice).toBeDefined()
     expect(feePayer).toBe(feePayerAddress)
     expect(from).toBe(senderAddress)
     expect(gasUsed).toBeDefined()
@@ -771,7 +781,6 @@ test('behavior: feePayerSignature (user → feePayer)', async () => {
         "blobGasPrice": undefined,
         "blobGasUsed": undefined,
         "contractAddress": null,
-        "effectiveGasPrice": 20000000000n,
         "status": "success",
         "to": "0x0000000000000000000000000000000000000000",
         "type": "0x76",
@@ -1019,6 +1028,7 @@ describe('behavior: keyAuthorization', () => {
       blockNumber,
       blockHash,
       cumulativeGasUsed,
+      effectiveGasPrice,
       feePayer,
       feeToken,
       from,
@@ -1033,6 +1043,7 @@ describe('behavior: keyAuthorization', () => {
     expect(blockNumber).toBeDefined()
     expect(blockHash).toBeDefined()
     expect(cumulativeGasUsed).toBeDefined()
+    expect(effectiveGasPrice).toBeDefined()
     expect(feeToken).toBeDefined()
     expect(feePayer).toBeDefined()
     expect(gasUsed).toBeDefined()
@@ -1046,7 +1057,6 @@ describe('behavior: keyAuthorization', () => {
         "blobGasPrice": undefined,
         "blobGasUsed": undefined,
         "contractAddress": null,
-        "effectiveGasPrice": 20000000000n,
         "status": "success",
         "to": "0x0000000000000000000000000000000000000000",
         "type": "0x76",
@@ -1238,6 +1248,7 @@ describe('behavior: keyAuthorization', () => {
       blockNumber,
       blockHash,
       cumulativeGasUsed,
+      effectiveGasPrice,
       feePayer,
       feeToken,
       from,
@@ -1252,6 +1263,7 @@ describe('behavior: keyAuthorization', () => {
     expect(blockNumber).toBeDefined()
     expect(blockHash).toBeDefined()
     expect(cumulativeGasUsed).toBeDefined()
+    expect(effectiveGasPrice).toBeDefined()
     expect(feePayer).toBeDefined()
     expect(feeToken).toBeDefined()
     expect(from).toBeDefined()
@@ -1265,7 +1277,6 @@ describe('behavior: keyAuthorization', () => {
         "blobGasPrice": undefined,
         "blobGasUsed": undefined,
         "contractAddress": null,
-        "effectiveGasPrice": 20000000000n,
         "status": "success",
         "to": "0x0000000000000000000000000000000000000000",
         "type": "0x76",
@@ -3015,7 +3026,7 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
       return { address, privateKey } as const
     })
 
-    const config = MultisigConfig.from({
+    const genesisConfig = MultisigConfig.from({
       // A fresh random salt yields a distinct account each run, exercising the
       // salt-inclusive config-ID derivation against the node.
       salt: Hex.random(32),
@@ -3025,10 +3036,9 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
         weight: 1,
       })),
     })
-    const configId = MultisigConfig.toId(config)
-    const account = MultisigConfig.getAddress({ configId })
+    const account = MultisigConfig.getAddress(genesisConfig)
 
-    return { account, config, configId, ownerKeys } as const
+    return { account, genesisConfig, ownerKeys } as const
   }
 
   // Signs the multisig owner digest with the provided owner keys, returning
@@ -3036,32 +3046,26 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
   // address (required by the node: "recovered owners must be strictly
   // ascending").
   function approve(parameters: {
-    account: Address.Address
-    configId: Hex.Hex
+    genesisConfig: MultisigConfig.Config
     payload: Hex.Hex
     signers: readonly { privateKey: Hex.Hex }[]
   }) {
-    const { account, configId, payload, signers } = parameters
-    const digest = MultisigConfig.getSignPayload({
-      account,
-      configId,
-      payload,
-    })
+    const { genesisConfig, payload, signers } = parameters
+    const digest = MultisigConfig.getSignPayload({ payload, genesisConfig })
     const signatures = signers.map((signer) =>
       SignatureEnvelope.from(
         Secp256k1.sign({ payload: digest, privateKey: signer.privateKey }),
       ),
     )
     return SignatureEnvelope.sortMultisigApprovals({
-      account,
-      configId,
+      genesisConfig,
       payload,
       signatures,
     })
   }
 
   test('behavior: bootstrap + spend (2-of-3 secp256k1)', async () => {
-    const { account, config, configId, ownerKeys } = setup({
+    const { account, genesisConfig, ownerKeys } = setup({
       count: 3,
       threshold: 2,
     })
@@ -3083,15 +3087,12 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
 
     const bootstrap_signed = TxEnvelopeTempo.serialize(bootstrap, {
       signature: SignatureEnvelope.from({
-        type: 'multisig',
-        account,
-        configId,
-        // The bootstrap config is carried by the signature `init`.
-        init: config,
+        genesisConfig,
+        // Initialize multisig.
+        init: true,
         // Approve with 2 of the 3 owners to satisfy the threshold.
         signatures: approve({
-          account,
-          configId,
+          genesisConfig,
           payload: TxEnvelopeTempo.getSignPayload(bootstrap),
           signers: [ownerKeys[0]!, ownerKeys[1]!],
         }),
@@ -3121,7 +3122,7 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
       // The bootstrap config is carried by the multisig signature `init`.
       expect(
         (response.signature as SignatureEnvelope.Multisig | undefined)?.init,
-      ).toEqual(config)
+      ).toEqual(genesisConfig)
     }
 
     // Spend (subsequent transaction): no signature `init`, nonce 1, uses the
@@ -3143,13 +3144,10 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
 
     const spend_signed = TxEnvelopeTempo.serialize(spend, {
       signature: SignatureEnvelope.from({
-        type: 'multisig',
-        account,
-        configId,
+        genesisConfig,
         // A different 2-of-3 subset still authorizes the transaction.
         signatures: approve({
-          account,
-          configId,
+          genesisConfig,
           payload: TxEnvelopeTempo.getSignPayload(spend),
           signers: [ownerKeys[1]!, ownerKeys[2]!],
         }),
@@ -3168,7 +3166,7 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
   })
 
   test('behavior: rejects below-threshold approvals', async () => {
-    const { account, config, configId, ownerKeys } = setup({
+    const { account, genesisConfig, ownerKeys } = setup({
       count: 3,
       threshold: 2,
     })
@@ -3187,15 +3185,12 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
 
     const serialized_signed = TxEnvelopeTempo.serialize(bootstrap, {
       signature: SignatureEnvelope.from({
-        type: 'multisig',
-        account,
-        configId,
-        // The bootstrap config is carried by the signature `init`.
-        init: config,
+        genesisConfig,
+        // Opt into bootstrap: writes `genesisConfig` into the signature `init`.
+        init: true,
         // Only one approval — below the threshold of 2.
         signatures: approve({
-          account,
-          configId,
+          genesisConfig,
           payload: TxEnvelopeTempo.getSignPayload(bootstrap),
           signers: [ownerKeys[0]!],
         }),

package/src/tempo/index.ts

@@ -131,7 +131,7 @@ export * as KeyAuthorization from './KeyAuthorization.js'
  * ```ts twoslash
  * import { MultisigConfig } from 'ox/tempo'
  *
- * const config = MultisigConfig.from({
+ * const genesisConfig = MultisigConfig.from({
  *   threshold: 2,
  *   owners: [
  *     {
@@ -145,7 +145,7 @@ export * as KeyAuthorization from './KeyAuthorization.js'
  *   ]
  * })
  *
- * const account = MultisigConfig.getAddress({ config })
+ * const account = MultisigConfig.getAddress(genesisConfig)
  * ```
  *
  * @category Reference

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.0.0-beta.0'
+export const version = '1.0.0-beta.2'

package/src/zod/RpcSchema.ts

@@ -1,12 +1,103 @@
 import * as Errors from '../core/Errors.js'
 import * as eth from './internal/rpcSchemas/Eth.js'
+import { from as fromItem } from './internal/rpcSchemas/from.js'
 import type { Item } from './internal/rpcSchemas/from.js'
 import * as wallet from './internal/rpcSchemas/Wallet.js'
 import * as z from 'zod/mini'
 
-export { from } from './internal/rpcSchemas/from.js'
 export type { Item } from './internal/rpcSchemas/from.js'
 
+/**
+ * Instantiates JSON-RPC method schema(s) from Zod `params`/`returns` schemas.
+ *
+ * Two forms are supported:
+ *
+ * - A single method `{ method, params, returns }`, returning a `RpcSchema.Item`.
+ * - A record of `{ params, returns }` keyed by method name, returning a
+ *   normalized `RpcSchema.Namespace` (each method's name is taken from its key
+ *   and its `request` schema is derived). The result is usable with the
+ *   `RpcSchema.decode*`/`RpcSchema.encode*` methods and as a schema for
+ *   `Provider`/`RpcTransport`.
+ *
+ * @example
+ * ### Single Method
+ *
+ * ```ts twoslash
+ * import { z } from 'ox/zod'
+ *
+ * const eth_blockNumber = z.RpcSchema.from({
+ *   method: 'eth_blockNumber',
+ *   params: z.optional(z.tuple([])),
+ *   returns: z.Hex.Hex
+ * })
+ * ```
+ *
+ * @example
+ * ### Namespace
+ *
+ * ```ts twoslash
+ * import { z } from 'ox/zod'
+ *
+ * const schema = z.RpcSchema.from({
+ *   ...z.RpcSchema.Eth,
+ *   abe_foo: {
+ *     params: z.tuple([z.number()]),
+ *     returns: z.string()
+ *   }
+ * })
+ *
+ * const params = z.RpcSchema.decodeParams(
+ *   schema,
+ *   'abe_foo',
+ *   [123]
+ * )
+ * ```
+ */
+export function from<
+  const method extends string,
+  params extends z.ZodMiniType,
+  returns extends z.ZodMiniType,
+>(parameters: {
+  method: method
+  params: params
+  returns: returns
+}): Item<method, params, returns>
+export function from<const namespace extends from.Namespace>(
+  namespace: namespace,
+): from.ReturnType<namespace>
+// eslint-disable-next-line jsdoc-js/require-jsdoc
+export function from(
+  input:
+    | { method?: string; params?: z.ZodMiniType; returns?: z.ZodMiniType }
+    | from.Namespace,
+): unknown {
+  if (typeof input.method === 'string')
+    return fromItem(input as Parameters<typeof fromItem>[0])
+  return Object.fromEntries(
+    Object.entries(input as from.Namespace).map(([method, item]) => [
+      method,
+      fromItem({ method, params: item.params, returns: item.returns }),
+    ]),
+  )
+}
+
+export declare namespace from {
+  /** A record of `{ params, returns }` Zod schemas keyed by method name. */
+  type Namespace = Record<
+    string,
+    { params: z.ZodMiniType; returns: z.ZodMiniType }
+  >
+
+  /** The normalized `RpcSchema.Namespace` derived from a {@link from.Namespace}. */
+  type ReturnType<namespace extends Namespace> = {
+    [method in keyof namespace & string]: Item<
+      method,
+      namespace[method]['params'],
+      namespace[method]['returns']
+    >
+  }
+}
+
 /** A namespace of JSON-RPC method schemas, keyed by method name. */
 export type Namespace = Record<string, Item>
 
@@ -61,13 +152,15 @@ export function parseItem<
 }
 
 /**
- * Validates and decodes the `params` for a method on a namespace.
+ * 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.
  *
  * @example
  * ```ts twoslash
  * import { z } from 'ox/zod'
  *
- * const params = z.RpcSchema.parseParams(
+ * const params = z.RpcSchema.decodeParams(
  *   z.RpcSchema.Eth,
  *   'eth_getBlockByNumber',
  *   ['0x1', true]
@@ -76,7 +169,7 @@ export function parseItem<
  *
  * @throws `RpcSchema.MethodNotFoundError` if the method does not exist.
  */
-export function parseParams<
+export function decodeParams<
   const namespace extends Namespace,
   method extends MethodName<namespace>,
 >(
@@ -88,13 +181,44 @@ export function parseParams<
 }
 
 /**
- * Validates and decodes the `returns` value for a method on a namespace.
+ * 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.
+ *
+ * @example
+ * ```ts twoslash
+ * import { z } from 'ox/zod'
+ *
+ * const params = z.RpcSchema.encodeParams(
+ *   z.RpcSchema.Eth,
+ *   'eth_getBlockByNumber',
+ *   [1n, true]
+ * )
+ * ```
+ *
+ * @throws `RpcSchema.MethodNotFoundError` if the method does not exist.
+ */
+export function encodeParams<
+  const namespace extends Namespace,
+  method extends MethodName<namespace>,
+>(
+  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
+}
+
+/**
+ * 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.
  *
  * @example
  * ```ts twoslash
  * import { z } from 'ox/zod'
  *
- * const result = z.RpcSchema.parseReturns(
+ * const result = z.RpcSchema.decodeReturns(
  *   z.RpcSchema.Eth,
  *   'eth_blockNumber',
  *   '0x1b4'
@@ -103,7 +227,7 @@ export function parseParams<
  *
  * @throws `RpcSchema.MethodNotFoundError` if the method does not exist.
  */
-export function parseReturns<
+export function decodeReturns<
   const namespace extends Namespace,
   method extends MethodName<namespace>,
 >(
@@ -118,20 +242,52 @@ export function parseReturns<
 }
 
 /**
- * Validates and decodes a full JSON-RPC request (`{ method, params }`) against
- * a namespace, dispatching on `method`.
+ * 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.
  *
  * @example
  * ```ts twoslash
  * import { z } from 'ox/zod'
  *
- * const request = z.RpcSchema.parseRequest(z.RpcSchema.Eth, {
+ * const result = z.RpcSchema.encodeReturns(
+ *   z.RpcSchema.Eth,
+ *   'eth_blockNumber',
+ *   436n
+ * )
+ * ```
+ *
+ * @throws `RpcSchema.MethodNotFoundError` if the method does not exist.
+ */
+export function encodeReturns<
+  const namespace extends Namespace,
+  method extends MethodName<namespace>,
+>(
+  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
+}
+
+/**
+ * Decodes (wire → native) a full JSON-RPC request (`{ method, params }`)
+ * against a namespace, dispatching on `method`.
+ *
+ * @example
+ * ```ts twoslash
+ * import { z } from 'ox/zod'
+ *
+ * const request = z.RpcSchema.decodeRequest(z.RpcSchema.Eth, {
  *   method: 'eth_getBlockByNumber',
  *   params: ['0x1', true]
  * })
  * ```
  */
-export function parseRequest<const namespace extends Namespace>(
+export function decodeRequest<const namespace extends Namespace>(
   namespace: namespace,
   request: RequestInput<namespace>,
 ): RequestOutput<namespace> {
@@ -139,7 +295,28 @@ export function parseRequest<const namespace extends Namespace>(
 }
 
 /**
- * Alias for `RpcSchema.parseRequest`.
+ * Encodes (native → wire) a full JSON-RPC request (`{ method, params }`)
+ * against a namespace, dispatching on `method`.
+ *
+ * @example
+ * ```ts twoslash
+ * import { z } from 'ox/zod'
+ *
+ * const request = z.RpcSchema.encodeRequest(z.RpcSchema.Eth, {
+ *   method: 'eth_getBlockByNumber',
+ *   params: [1n, true]
+ * })
+ * ```
+ */
+export function encodeRequest<const namespace extends Namespace>(
+  namespace: namespace,
+  request: RequestOutput<namespace>,
+): RequestInput<namespace> {
+  return z.encode(requestSchema(namespace), request as never) as never
+}
+
+/**
+ * Alias for `RpcSchema.decodeRequest`.
  *
  * @example
  * ```ts twoslash
@@ -154,7 +331,7 @@ export function parseRequest<const namespace extends Namespace>(
  * })
  * ```
  */
-export const parse = parseRequest
+export const parse = decodeRequest
 
 /** Wire (input) request envelope for a namespace. */
 export type RequestInput<namespace extends Namespace> = {