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

package/src/zod/_test/RpcSchema.test-d.ts

@@ -2,17 +2,28 @@ import type * as core_Address from '../../core/Address.js'
 import type * as core_Block from '../../core/Block.js'
 import type * as core_Fee from '../../core/Fee.js'
 import type * as core_Hex from '../../core/Hex.js'
-import type * as z from 'zod/mini'
 import { expectTypeOf, test } from 'vp/test'
+import * as z from 'zod/mini'
 import * as z_RpcSchema from '../RpcSchema.js'
 
 test('method items mirror wire (input) and domain (output) shapes', () => {
-  // Scalar return types stay as wire hex.
+  // Scalar quantity return types are wire hex on input, native on output.
   expectTypeOf<
     z.input<typeof z_RpcSchema.Eth.eth_blockNumber.returns>
   >().toEqualTypeOf<core_Hex.Hex>()
   expectTypeOf<
     z.output<typeof z_RpcSchema.Eth.eth_blockNumber.returns>
+  >().toEqualTypeOf<bigint>()
+  expectTypeOf<
+    z.output<typeof z_RpcSchema.Eth.eth_chainId.returns>
+  >().toEqualTypeOf<number>()
+
+  // Data/bytecode return types stay as wire hex.
+  expectTypeOf<
+    z.output<typeof z_RpcSchema.Eth.eth_call.returns>
+  >().toEqualTypeOf<core_Hex.Hex>()
+  expectTypeOf<
+    z.output<typeof z_RpcSchema.Eth.eth_getCode.returns>
   >().toEqualTypeOf<core_Hex.Hex>()
 
   // Address arrays.
@@ -29,10 +40,10 @@ test('method items mirror wire (input) and domain (output) shapes', () => {
   >().toEqualTypeOf<core_Fee.FeeHistory>()
 })
 
-test('parse helpers infer params/returns by method', () => {
+test('decode helpers infer params/returns by method', () => {
   // Params: block number is wire hex on input, bigint on output.
   expectTypeOf(
-    z_RpcSchema.parseParams(z_RpcSchema.Eth, 'eth_getBlockByNumber', [
+    z_RpcSchema.decodeParams(z_RpcSchema.Eth, 'eth_getBlockByNumber', [
       '0x1',
       true,
     ]),
@@ -40,11 +51,47 @@ test('parse helpers infer params/returns by method', () => {
 
   // Returns: decoded to domain values.
   expectTypeOf(
-    z_RpcSchema.parseReturns(z_RpcSchema.Eth, 'eth_blockNumber', '0x1b4'),
-  ).toEqualTypeOf<core_Hex.Hex>()
+    z_RpcSchema.decodeReturns(z_RpcSchema.Eth, 'eth_blockNumber', '0x1b4'),
+  ).toEqualTypeOf<bigint>()
 
   // Item lookup preserves the literal method name.
   expectTypeOf(
     z_RpcSchema.parseItem(z_RpcSchema.Eth, 'eth_blockNumber').method,
   ).toEqualTypeOf<'eth_blockNumber'>()
 })
+
+test('encode helpers infer params/returns by method', () => {
+  // Returns: native bigint on input, wire hex on output.
+  expectTypeOf(
+    z_RpcSchema.encodeReturns(z_RpcSchema.Eth, 'eth_blockNumber', 436n),
+  ).toEqualTypeOf<core_Hex.Hex>()
+})
+
+test('from: namespace returns a decodable namespace', () => {
+  const schema = z_RpcSchema.from({
+    abe_foo: {
+      params: z.tuple([z.number()]),
+      returns: z.string(),
+    },
+  })
+
+  // Method name taken from the key.
+  expectTypeOf(schema.abe_foo.method).toEqualTypeOf<'abe_foo'>()
+
+  // Usable with decode* methods.
+  expectTypeOf(z_RpcSchema.decodeParams(schema, 'abe_foo', [1])).toEqualTypeOf<
+    [number]
+  >()
+  expectTypeOf(
+    z_RpcSchema.decodeReturns(schema, 'abe_foo', 'hello'),
+  ).toEqualTypeOf<string>()
+})
+
+test('from: single method returns an Item', () => {
+  const item = z_RpcSchema.from({
+    method: 'abe_foo',
+    params: z.tuple([z.number()]),
+    returns: z.string(),
+  })
+  expectTypeOf(item.method).toEqualTypeOf<'abe_foo'>()
+})

package/src/zod/_test/RpcSchema.test.ts

@@ -6,10 +6,10 @@ const address = '0x0000000000000000000000000000000000000000'
 const hash = `0x${'11'.repeat(32)}` as const
 const topic = `0x${'33'.repeat(32)}` as const
 
-describe('parseParams', () => {
+describe('decodeParams', () => {
   test('decodes params (block number / tag coercion)', () => {
     expect(
-      z_RpcSchema.parseParams(z_RpcSchema.Eth, 'eth_getBlockByNumber', [
+      z_RpcSchema.decodeParams(z_RpcSchema.Eth, 'eth_getBlockByNumber', [
         '0x1b4',
         true,
       ]),
@@ -20,7 +20,7 @@ describe('parseParams', () => {
       ]
     `)
     expect(
-      z_RpcSchema.parseParams(z_RpcSchema.Eth, 'eth_getBlockByNumber', [
+      z_RpcSchema.decodeParams(z_RpcSchema.Eth, 'eth_getBlockByNumber', [
         'latest',
         false,
       ]),
@@ -34,7 +34,7 @@ describe('parseParams', () => {
 
   test('decodes wallet params', () => {
     expect(
-      z_RpcSchema.parseParams(
+      z_RpcSchema.decodeParams(
         z_RpcSchema.Wallet,
         'wallet_switchEthereumChain',
         [{ chainId: '0x1' }],
@@ -49,13 +49,27 @@ describe('parseParams', () => {
   })
 })
 
-describe('parseReturns', () => {
+describe('decodeReturns', () => {
   test('decodes scalar return types', () => {
     expect(
-      z_RpcSchema.parseReturns(z_RpcSchema.Eth, 'eth_blockNumber', '0x1b4'),
-    ).toMatchInlineSnapshot(`"0x1b4"`)
-    expect(z_RpcSchema.parseReturns(z_RpcSchema.Eth, 'eth_accounts', [address]))
-      .toMatchInlineSnapshot(`
+      z_RpcSchema.decodeReturns(z_RpcSchema.Eth, 'eth_blockNumber', '0x1b4'),
+    ).toMatchInlineSnapshot(`436n`)
+    expect(
+      z_RpcSchema.decodeReturns(z_RpcSchema.Eth, 'eth_chainId', '0x1'),
+    ).toMatchInlineSnapshot(`1`)
+    expect(
+      z_RpcSchema.decodeReturns(
+        z_RpcSchema.Eth,
+        'eth_getTransactionCount',
+        '0x2',
+      ),
+    ).toMatchInlineSnapshot(`2`)
+    expect(
+      z_RpcSchema.decodeReturns(z_RpcSchema.Eth, 'eth_call', '0x1234'),
+    ).toMatchInlineSnapshot(`"0x1234"`)
+    expect(
+      z_RpcSchema.decodeReturns(z_RpcSchema.Eth, 'eth_accounts', [address]),
+    ).toMatchInlineSnapshot(`
       [
         "0x0000000000000000000000000000000000000000",
       ]
@@ -64,7 +78,7 @@ describe('parseReturns', () => {
 
   test('decodes fee history return type', () => {
     expect(
-      z_RpcSchema.parseReturns(z_RpcSchema.Eth, 'eth_feeHistory', {
+      z_RpcSchema.decodeReturns(z_RpcSchema.Eth, 'eth_feeHistory', {
         baseFeePerGas: ['0x1', '0x2'],
         gasUsedRatio: [0.5],
         oldestBlock: '0x10',
@@ -91,7 +105,7 @@ describe('parseReturns', () => {
 
   test('decodes log return types', () => {
     expect(
-      z_RpcSchema.parseReturns(z_RpcSchema.Eth, 'eth_getLogs', [
+      z_RpcSchema.decodeReturns(z_RpcSchema.Eth, 'eth_getLogs', [
         {
           address,
           blockHash: hash,
@@ -125,7 +139,7 @@ describe('parseReturns', () => {
 
   test('decodes nullable return types', () => {
     expect(
-      z_RpcSchema.parseReturns(
+      z_RpcSchema.decodeReturns(
         z_RpcSchema.Eth,
         'eth_getTransactionReceipt',
         null,
@@ -134,6 +148,55 @@ describe('parseReturns', () => {
   })
 })
 
+describe('encodeParams', () => {
+  test('encodes params (native → wire)', () => {
+    expect(
+      z_RpcSchema.encodeParams(z_RpcSchema.Eth, 'eth_getBlockByNumber', [
+        436n,
+        true,
+      ]),
+    ).toMatchInlineSnapshot(`
+      [
+        "0x1b4",
+        true,
+      ]
+    `)
+  })
+})
+
+describe('encodeReturns', () => {
+  test('encodes scalar return types (native → wire)', () => {
+    expect(
+      z_RpcSchema.encodeReturns(z_RpcSchema.Eth, 'eth_blockNumber', 436n),
+    ).toMatchInlineSnapshot(`"0x1b4"`)
+    expect(
+      z_RpcSchema.encodeReturns(z_RpcSchema.Eth, 'eth_chainId', 1),
+    ).toMatchInlineSnapshot(`"0x1"`)
+    expect(
+      z_RpcSchema.encodeReturns(z_RpcSchema.Eth, 'eth_call', '0x1234'),
+    ).toMatchInlineSnapshot(`"0x1234"`)
+  })
+})
+
+describe('encodeRequest', () => {
+  test('encodes a request (native → wire)', () => {
+    expect(
+      z_RpcSchema.encodeRequest(z_RpcSchema.Eth, {
+        method: 'eth_getBlockByNumber',
+        params: [436n, true],
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "method": "eth_getBlockByNumber",
+        "params": [
+          "0x1b4",
+          true,
+        ],
+      }
+    `)
+  })
+})
+
 describe('parseItem', () => {
   test('looks up a method schema', () => {
     expect(
@@ -150,10 +213,10 @@ describe('parseItem', () => {
   })
 })
 
-describe('parseRequest', () => {
+describe('decodeRequest', () => {
   test('dispatches by method', () => {
     expect(
-      z_RpcSchema.parseRequest(z_RpcSchema.Eth, {
+      z_RpcSchema.decodeRequest(z_RpcSchema.Eth, {
         method: 'eth_getBlockByNumber',
         params: ['0x1', true],
       }),
@@ -168,7 +231,7 @@ describe('parseRequest', () => {
     `)
   })
 
-  test('parse is an alias of parseRequest', () => {
+  test('parse is an alias of decodeRequest', () => {
     expect(
       z_RpcSchema.parse(z_RpcSchema.Wallet, {
         method: 'wallet_switchEthereumChain',
@@ -188,7 +251,7 @@ describe('parseRequest', () => {
 
   test('Default dispatches across eth_ and wallet_ methods', () => {
     expect(
-      z_RpcSchema.parseRequest(z_RpcSchema.Default, {
+      z_RpcSchema.decodeRequest(z_RpcSchema.Default, {
         method: 'eth_getBlockByNumber',
         params: ['0x1', true],
       }),
@@ -202,7 +265,7 @@ describe('parseRequest', () => {
       }
     `)
     expect(
-      z_RpcSchema.parseRequest(z_RpcSchema.Default, {
+      z_RpcSchema.decodeRequest(z_RpcSchema.Default, {
         method: 'wallet_switchEthereumChain',
         params: [{ chainId: '0x1' }],
       }),
@@ -226,10 +289,67 @@ describe('parseRequest', () => {
       ).success,
     ).toMatchInlineSnapshot(`false`)
     expect(() =>
-      z_RpcSchema.parseRequest(z_RpcSchema.Eth, {
+      z_RpcSchema.decodeRequest(z_RpcSchema.Eth, {
         method: 'eth_unknownMethod',
         params: [],
       } as never),
     ).toThrow()
   })
 })
+
+describe('from', () => {
+  test('single method returns an Item', () => {
+    const item = z_RpcSchema.from({
+      method: 'eth_blockNumber',
+      params: z.optional(z.tuple([])),
+      returns: z.string(),
+    })
+    expect(item.method).toMatchInlineSnapshot(`"eth_blockNumber"`)
+    expect(item.request).toBeDefined()
+  })
+
+  test('namespace normalizes keyed params/returns into Items', () => {
+    const schema = z_RpcSchema.from({
+      abe_foo: {
+        params: z.tuple([z.number()]),
+        returns: z.string(),
+      },
+    })
+
+    expect(schema.abe_foo.method).toMatchInlineSnapshot(`"abe_foo"`)
+    expect(z_RpcSchema.decodeParams(schema, 'abe_foo', [1]))
+      .toMatchInlineSnapshot(`
+      [
+        1,
+      ]
+    `)
+    expect(
+      z_RpcSchema.decodeReturns(schema, 'abe_foo', 'hello'),
+    ).toMatchInlineSnapshot(`"hello"`)
+    expect(
+      z_RpcSchema.decodeRequest(schema, { method: 'abe_foo', params: [1] }),
+    ).toMatchInlineSnapshot(`
+      {
+        "method": "abe_foo",
+        "params": [
+          1,
+        ],
+      }
+    `)
+  })
+
+  test('namespace spreads existing ox/zod namespaces', () => {
+    const schema = z_RpcSchema.from({
+      ...z_RpcSchema.Eth,
+      abe_foo: {
+        params: z.tuple([z.number()]),
+        returns: z.string(),
+      },
+    })
+
+    expect(schema.eth_blockNumber.method).toMatchInlineSnapshot(
+      `"eth_blockNumber"`,
+    )
+    expect(schema.abe_foo.method).toMatchInlineSnapshot(`"abe_foo"`)
+  })
+})

package/src/zod/internal/rpcSchemas/Eth.ts

@@ -7,10 +7,12 @@ import * as z_Fee from '../../Fee.js'
 import * as z_Filter from '../../Filter.js'
 import * as z_Hex from '../../Hex.js'
 import * as z_Log from '../../Log.js'
+import * as z_Number from '../../Number.js'
 import * as z_StateOverrides from '../../StateOverrides.js'
 import * as z_Transaction from '../../Transaction.js'
 import * as z_TransactionReceipt from '../../TransactionReceipt.js'
 import * as z_TransactionRequest from '../../TransactionRequest.js'
+import * as z_Uint from '../../Uint.js'
 import * as z from 'zod/mini'
 import { from } from './from.js'
 
@@ -60,13 +62,13 @@ export const eth_accounts = from({
 export const eth_blobBaseFee = from({
   method: 'eth_blobBaseFee',
   params: NoParams,
-  returns: z_Hex.Hex,
+  returns: z_Uint.Uint,
 })
 
 export const eth_blockNumber = from({
   method: 'eth_blockNumber',
   params: NoParams,
-  returns: z_Hex.Hex,
+  returns: z_Uint.Uint,
 })
 
 export const eth_call = from({
@@ -78,7 +80,7 @@ export const eth_call = from({
 export const eth_chainId = from({
   method: 'eth_chainId',
   params: NoParams,
-  returns: z_Hex.Hex,
+  returns: z_Number.Number,
 })
 
 export const eth_coinbase = from({
@@ -90,7 +92,7 @@ export const eth_coinbase = from({
 export const eth_estimateGas = from({
   method: 'eth_estimateGas',
   params: Call,
-  returns: z_Hex.Hex,
+  returns: z_Uint.Uint,
 })
 
 export const eth_feeHistory = from({
@@ -106,13 +108,13 @@ export const eth_feeHistory = from({
 export const eth_gasPrice = from({
   method: 'eth_gasPrice',
   params: NoParams,
-  returns: z_Hex.Hex,
+  returns: z_Uint.Uint,
 })
 
 export const eth_getBalance = from({
   method: 'eth_getBalance',
   params: z.tuple([z_Address.Address, BlockNumberOrTagOrIdentifier]),
-  returns: z_Hex.Hex,
+  returns: z_Uint.Uint,
 })
 
 export const eth_getBlockByHash = from({
@@ -130,13 +132,13 @@ export const eth_getBlockByNumber = from({
 export const eth_getBlockTransactionCountByHash = from({
   method: 'eth_getBlockTransactionCountByHash',
   params: z.tuple([z_Hex.Hex]),
-  returns: z_Hex.Hex,
+  returns: z_Number.Number,
 })
 
 export const eth_getBlockTransactionCountByNumber = from({
   method: 'eth_getBlockTransactionCountByNumber',
   params: z.tuple([BlockNumberOrTag]),
-  returns: z_Hex.Hex,
+  returns: z_Number.Number,
 })
 
 export const eth_getCode = from({
@@ -200,7 +202,7 @@ export const eth_getTransactionByHash = from({
 export const eth_getTransactionCount = from({
   method: 'eth_getTransactionCount',
   params: z.tuple([z_Address.Address, BlockNumberOrTagOrIdentifier]),
-  returns: z_Hex.Hex,
+  returns: z_Number.Number,
 })
 
 export const eth_getTransactionReceipt = from({
@@ -212,19 +214,19 @@ export const eth_getTransactionReceipt = from({
 export const eth_getUncleCountByBlockHash = from({
   method: 'eth_getUncleCountByBlockHash',
   params: z.tuple([z_Hex.Hex]),
-  returns: z_Hex.Hex,
+  returns: z_Number.Number,
 })
 
 export const eth_getUncleCountByBlockNumber = from({
   method: 'eth_getUncleCountByBlockNumber',
   params: z.tuple([BlockNumberOrTag]),
-  returns: z_Hex.Hex,
+  returns: z_Number.Number,
 })
 
 export const eth_maxPriorityFeePerGas = from({
   method: 'eth_maxPriorityFeePerGas',
   params: NoParams,
-  returns: z_Hex.Hex,
+  returns: z_Uint.Uint,
 })
 
 export const eth_newBlockFilter = from({

package/src/zod/tempo/SignatureEnvelope.ts

@@ -140,7 +140,7 @@ export const Keychain = z.object({
 /** Native multisig signature envelope schema. */
 export const Multisig = z.object({
   account: z_Address.Address,
-  configId: z_Hex.Hex,
+  genesisConfigId: z_Hex.Hex,
   init: z.optional(z_MultisigConfig.Config),
   // `signatures` is recursive; type the getter concretely to break the cycle.
   signatures: z.lazy(

package/src/zod/tempo/_test/RpcSchemaTempo.test.ts

@@ -5,7 +5,7 @@ import * as z from 'zod/mini'
 
 describe('tempo_simulateV1', () => {
   test('decodes params', () => {
-    const params = z_RpcSchema.parseParams(
+    const params = z_RpcSchema.decodeParams(
       z_RpcSchemaTempo.Tempo,
       'tempo_simulateV1',
       [

package/src/zod/tempo/_test/SignatureEnvelope.test.ts

@@ -19,6 +19,16 @@ const p256 = {
   type: 'p256',
 } as const
 
+const multisig = {
+  account: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+  configId:
+    '0x0000000000000000000000000000000000000000000000000000000000000000',
+  signatures: [
+    core_SignatureEnvelope.serialize(core_SignatureEnvelope.fromRpc(secp256k1)),
+  ],
+  type: 'multisig',
+} as const
+
 describe('SignatureEnvelope', () => {
   test('decodes a secp256k1 envelope', () => {
     expect(z.decode(z_SignatureEnvelope.SignatureEnvelope, secp256k1)).toEqual(
@@ -43,6 +53,12 @@ describe('SignatureEnvelope', () => {
     )
   })
 
+  test('decodes a multisig envelope', () => {
+    expect(z.decode(z_SignatureEnvelope.SignatureEnvelope, multisig)).toEqual(
+      core_SignatureEnvelope.fromRpc(multisig),
+    )
+  })
+
   test('round-trips secp256k1 via encode', () => {
     const decoded = z.decode(z_SignatureEnvelope.SignatureEnvelope, secp256k1)
     expect(z.encode(z_SignatureEnvelope.SignatureEnvelope, decoded)).toEqual(
@@ -50,6 +66,13 @@ describe('SignatureEnvelope', () => {
     )
   })
 
+  test('round-trips multisig via encode', () => {
+    const decoded = z.decode(z_SignatureEnvelope.SignatureEnvelope, multisig)
+    expect(z.encode(z_SignatureEnvelope.SignatureEnvelope, decoded)).toEqual(
+      core_SignatureEnvelope.toRpc(decoded),
+    )
+  })
+
   test('rejects an invalid envelope', () => {
     expect(
       z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {