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

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

@@ -109,6 +109,36 @@ describe('Transaction', () => {
     `)
   })
 
+  test('TransactionToRpc accepts numberish encode inputs', () => {
+    const decoded = {
+      ...base,
+      accessList: [],
+      gasPrice: 4n,
+      maxFeePerGas: 5n,
+      maxPriorityFeePerGas: 6n,
+      type: 'eip1559',
+    } as const
+    const expected = z.encode(z_Transaction.Transaction, decoded)
+
+    expect(
+      z.encode(z_Transaction.TransactionToRpc, {
+        ...decoded,
+        blockNumber: 1,
+        gas: 21000,
+        maxFeePerGas: 5,
+        value: 3,
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_Transaction.TransactionToRpc, {
+        ...decoded,
+        blockNumber: '0x1',
+        gas: '0x5208',
+        maxFeePerGas: '0x5',
+      }),
+    ).toEqual(expected)
+  })
+
   test('decodes legacy and pending transactions', () => {
     expect(
       z.decode(z_Transaction.Legacy, {

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

@@ -134,6 +134,40 @@ describe('TransactionEnvelope', () => {
     ).toMatchInlineSnapshot(`false`)
   })
 
+  test('TransactionEnvelopeToRpc accepts numberish encode inputs', () => {
+    const expected = {
+      chainId: '0x1',
+      maxFeePerGas: '0x2',
+      maxPriorityFeePerGas: '0x1',
+      type: '0x2',
+    }
+
+    expect(
+      z.encode(z_TransactionEnvelope.TransactionEnvelopeToRpc, {
+        chainId: 1,
+        maxFeePerGas: 2n,
+        maxPriorityFeePerGas: 1n,
+        type: 'eip1559',
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_TransactionEnvelope.TransactionEnvelopeToRpc, {
+        chainId: 1,
+        maxFeePerGas: 2,
+        maxPriorityFeePerGas: 1,
+        type: 'eip1559',
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_TransactionEnvelope.TransactionEnvelopeToRpc, {
+        chainId: '0x1',
+        maxFeePerGas: '0x2',
+        maxPriorityFeePerGas: '0x1',
+        type: 'eip1559',
+      }),
+    ).toEqual(expected)
+  })
+
   test('serialized codec round-trips signed envelopes against core', () => {
     const envelopes = {
       legacy: {

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

@@ -151,6 +151,50 @@ describe('TransactionReceipt', () => {
     expect(z.encode(z_TransactionReceipt.Type, 'custom')).toBe('custom')
   })
 
+  test('TransactionReceiptToRpc accepts numberish encode inputs', () => {
+    const decoded = {
+      blobGasPrice: 270441n,
+      blobGasUsed: 4919n,
+      blockHash,
+      blockNumber: 19868015n,
+      contractAddress: null,
+      cumulativeGasUsed: 533781n,
+      effectiveGasPrice: 9062804489n,
+      from: address,
+      gasUsed: 175034n,
+      logs: [],
+      logsBloom,
+      root: '0x',
+      status: 'success',
+      to: address,
+      transactionHash,
+      transactionIndex: 2,
+      type: 'eip1559',
+    } as const
+    const expected = z.encode(z_TransactionReceipt.TransactionReceipt, {
+      ...decoded,
+      logs: [],
+    })
+
+    expect(
+      z.encode(z_TransactionReceipt.TransactionReceiptToRpc, {
+        ...decoded,
+        logs: [],
+        blobGasUsed: 4919,
+        cumulativeGasUsed: 533781,
+        gasUsed: 175034,
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_TransactionReceipt.TransactionReceiptToRpc, {
+        ...decoded,
+        logs: [],
+        blockNumber: '0x12f296f',
+        gasUsed: '0x2abba',
+      }),
+    ).toEqual(expected)
+  })
+
   test('rejects invalid statuses and nested logs', () => {
     const invalidStatus: unknown = '0x2'
     const invalidReceiptStatus: unknown = {
@@ -182,7 +226,7 @@ describe('TransactionReceipt', () => {
           blockNumber: '0x1',
           data: '0x',
           logIndex: '0x0',
-          topics: [],
+          topics: ['0xz'],
           transactionHash,
           transactionIndex: '0x0',
           removed: false,

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

@@ -153,6 +153,37 @@ describe('TransactionRequest', () => {
     `)
   })
 
+  test('TransactionRequestToRpc accepts numberish encode inputs', () => {
+    const decoded = {
+      chainId: 1,
+      from: address,
+      gas: 21000n,
+      maxFeePerGas: 5n,
+      maxPriorityFeePerGas: 6n,
+      nonce: 7n,
+      to: null,
+      type: 'eip1559',
+      value: 8n,
+    } as const
+    const expected = z.encode(z_TransactionRequest.TransactionRequest, decoded)
+
+    expect(
+      z.encode(z_TransactionRequest.TransactionRequestToRpc, {
+        ...decoded,
+        gas: 21000,
+        maxFeePerGas: 5,
+        value: 8,
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_TransactionRequest.TransactionRequestToRpc, {
+        ...decoded,
+        gas: '0x5208',
+        nonce: '0x7',
+      }),
+    ).toEqual(expected)
+  })
+
   test('preserves unknown transaction types', () => {
     expect(z.decode(z_TransactionRequest.TransactionRequest, { type: '0x99' }))
       .toMatchInlineSnapshot(`

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

@@ -146,6 +146,38 @@ describe('TxEnvelope', () => {
     })
   })
 
+  test('TxEnvelopeEip1559ToRpc accepts numberish encode inputs', () => {
+    const decoded = {
+      ...base,
+      accessList: [],
+      maxFeePerGas: 4n,
+      maxPriorityFeePerGas: 5n,
+      type: 'eip1559',
+    } as const
+    const expected = z.encode(z_TxEnvelopeEip1559.TxEnvelopeEip1559, decoded)
+
+    expect(
+      z.encode(z_TxEnvelopeEip1559.TxEnvelopeEip1559ToRpc, {
+        ...decoded,
+        gas: 21000,
+        maxFeePerGas: 4,
+        maxPriorityFeePerGas: 5,
+        nonce: 2,
+        value: 3,
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_TxEnvelopeEip1559.TxEnvelopeEip1559ToRpc, {
+        ...decoded,
+        gas: '0x5208',
+        maxFeePerGas: '0x4',
+        maxPriorityFeePerGas: '0x5',
+        nonce: '0x2',
+        value: '0x3',
+      }),
+    ).toEqual(expected)
+  })
+
   test('validates signed envelopes and rejects invalid variants', () => {
     expect(
       z.decode(z_TxEnvelopeEip1559.Signed, {

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

@@ -0,0 +1,20 @@
+import type * as core_TypedData from '../../core/TypedData.js'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_TypedData from '../TypedData.js'
+import type * as z from 'zod/mini'
+
+test('TypedData schemas output Ox core TypedData types', () => {
+  expectTypeOf<z.output<typeof z_TypedData.Domain>>().toMatchTypeOf<{
+    chainId?: number | bigint | undefined
+    name?: string | undefined
+    salt?: string | undefined
+    verifyingContract?: core_TypedData.Domain['verifyingContract'] | undefined
+    version?: string | undefined
+  }>()
+  expectTypeOf<
+    z.output<typeof z_TypedData.Parameter>
+  >().toMatchTypeOf<core_TypedData.Parameter>()
+  expectTypeOf<
+    z.output<typeof z_TypedData.TypedData>
+  >().toMatchTypeOf<core_TypedData.TypedData>()
+})

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

@@ -0,0 +1,87 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_TypedData from '../TypedData.js'
+import * as z from 'zod/mini'
+
+describe('TypedData', () => {
+  test('decodes EIP-712 types maps', () => {
+    expect(
+      z.decode(z_TypedData.TypedData, {
+        Person: [
+          { name: 'name', type: 'string' },
+          { name: 'wallet', type: 'address' },
+        ],
+        Mail: [
+          { name: 'from', type: 'Person' },
+          { name: 'to', type: 'Person' },
+          { name: 'contents', type: 'string' },
+        ],
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "Mail": [
+          {
+            "name": "from",
+            "type": "Person",
+          },
+          {
+            "name": "to",
+            "type": "Person",
+          },
+          {
+            "name": "contents",
+            "type": "string",
+          },
+        ],
+        "Person": [
+          {
+            "name": "name",
+            "type": "string",
+          },
+          {
+            "name": "wallet",
+            "type": "address",
+          },
+        ],
+      }
+    `)
+  })
+
+  test('rejects invalid references', () => {
+    expect(
+      z.safeDecode(z_TypedData.TypedData, {
+        Mail: [{ name: 'from', type: 'Person' }],
+      }).success,
+    ).toBe(false)
+    expect(
+      z.safeDecode(z_TypedData.TypedData, {
+        Person: [{ name: 'parent', type: 'Person' }],
+      }).success,
+    ).toBe(false)
+    expect(
+      z.safeDecode(z_TypedData.TypedData, {
+        Foo: [{ name: 'bar', type: 'Bar' }],
+        Bar: [{ name: 'foo', type: 'Foo' }],
+      }).success,
+    ).toBe(false)
+  })
+
+  test('decodes domains with ABIType-compatible salt strings', () => {
+    expect(
+      z.decode(z_TypedData.Domain, {
+        chainId: 1,
+        name: 'EtherMail',
+        salt: 'not-hex',
+        verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+        version: '1',
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "chainId": 1,
+        "name": "EtherMail",
+        "salt": "not-hex",
+        "verifyingContract": "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC",
+        "version": "1",
+      }
+    `)
+  })
+})

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

@@ -43,3 +43,18 @@ describe('Uint', () => {
     expect(z.safeEncode(z_Uint.Uint64, 1n << 64n).success).toBe(false)
   })
 })
+
+describe('UintToRpc', () => {
+  test('accepts numberish encode inputs', () => {
+    expect(z.encode(z_Uint.UintToRpc, 42n)).toBe('0x2a')
+    expect(z.encode(z_Uint.UintToRpc, 42)).toBe('0x2a')
+    expect(z.encode(z_Uint.UintToRpc, '0x2a')).toBe('0x2a')
+  })
+})
+
+describe('Uint8ToRpc', () => {
+  test('accepts numberish encode inputs', () => {
+    expect(z.encode(z_Uint.Uint8ToRpc, 42)).toBe('0x2a')
+    expect(z.encode(z_Uint.Uint8ToRpc, '0x2a')).toBe('0x2a')
+  })
+})

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

@@ -35,4 +35,39 @@ describe('Withdrawal', () => {
       }
     `)
   })
+
+  test('WithdrawalToRpc accepts numberish encode inputs', () => {
+    const address = '0x0000000000000000000000000000000000000000'
+    const expected = {
+      address,
+      amount: '0x620323',
+      index: '0x0',
+      validatorIndex: '0x1',
+    }
+
+    expect(
+      z.encode(z_Withdrawal.WithdrawalToRpc, {
+        address,
+        amount: 6423331n,
+        index: 0,
+        validatorIndex: 1,
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_Withdrawal.WithdrawalToRpc, {
+        address,
+        amount: 6423331,
+        index: 0,
+        validatorIndex: 1,
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_Withdrawal.WithdrawalToRpc, {
+        address,
+        amount: '0x620323',
+        index: '0x0',
+        validatorIndex: '0x1',
+      }),
+    ).toEqual(expected)
+  })
 })

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

@@ -1,5 +1,6 @@
 import type * as core_AccountProof from '../../core/AccountProof.js'
 import type * as core_AccessList from '../../core/AccessList.js'
+import type * as core_Abi from '../../core/Abi.js'
 import type * as core_Authorization from '../../core/Authorization.js'
 import type * as core_Block from '../../core/Block.js'
 import type * as core_BlockOverrides from '../../core/BlockOverrides.js'
@@ -12,12 +13,17 @@ import type * as core_Transaction from '../../core/Transaction.js'
 import type * as core_TransactionEnvelope from '../../core/TxEnvelope.js'
 import type * as core_TransactionReceipt from '../../core/TransactionReceipt.js'
 import type * as core_TransactionRequest from '../../core/TransactionRequest.js'
+import type * as core_TypedData from '../../core/TypedData.js'
 import type * as core_TxEnvelopeEip1559 from '../../core/TxEnvelopeEip1559.js'
 import { z } from 'ox/zod'
 import type * as zod from 'zod/mini'
 import { expectTypeOf, test } from 'vp/test'
 
 test('z entrypoint exposes module and direct integer schema types', () => {
+  expectTypeOf<zod.output<typeof z.Abi.Abi>>().toMatchTypeOf<core_Abi.Abi>()
+  expectTypeOf<
+    zod.output<typeof z.TypedData.TypedData>
+  >().toMatchTypeOf<core_TypedData.TypedData>()
   expectTypeOf<
     zod.output<typeof z.AccountProof.AccountProof>
   >().toEqualTypeOf<core_AccountProof.AccountProof>()

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

@@ -5,6 +5,23 @@ const address = '0x0000000000000000000000000000000000000000'
 const storageKey = `0x${'11'.repeat(32)}` as const
 
 test('exports zod mini utilities, modules, and integer schemas', () => {
+  expect(
+    z.decode(z.Abi.Abi, [
+      {
+        inputs: [],
+        name: 'totalSupply',
+        outputs: [{ type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+      },
+    ]),
+  ).toMatchObject([{ name: 'totalSupply', type: 'function' }])
+  expect(z.decode(z.Solidity.Int, 'uint256')).toBe('uint256')
+  expect(
+    z.decode(z.TypedData.TypedData, {
+      Person: [{ name: 'wallet', type: 'address' }],
+    }),
+  ).toMatchObject({ Person: [{ name: 'wallet', type: 'address' }] })
   expect(
     z.decode(z.AccountProof.AccountProof, {
       address,

package/src/zod/internal/Integer.ts

@@ -5,6 +5,20 @@ import * as z from 'zod/mini'
 
 export type SmallBits = 8 | 16 | 24 | 32 | 40 | 48
 
+/** "Numberish" value accepted by `*ToRpc` bigint schemas. */
+export type BigintNumberish = z.output<typeof z_Hex.Hex> | bigint | number
+/** "Numberish" value accepted by `*ToRpc` number schemas. */
+export type NumberNumberish = z.output<typeof z_Hex.Hex> | number
+
+/** Encodes a "numberish" value to an RPC quantity hex (hex passes through). */
+export function encodeNumberish(
+  value: BigintNumberish,
+  options?: core_Hex.fromNumber.Options,
+): z.output<typeof z_Hex.Hex> {
+  if (typeof value === 'string') return value
+  return core_Hex.fromNumber(value, options)
+}
+
 export function decodeInteger(
   value: z.output<typeof z_Hex.Hex>,
   bits: number,
@@ -60,6 +74,50 @@ export function intBigint(bits: number) {
   return z.bigint().check(z.gte(min, message), z.lte(max, message))
 }
 
+/** Numberish output schema for unsized/bigint-width unsigned integers. */
+export function uintBigintNumberish(bits?: number) {
+  return z.union([quantityHex(bits), uintBigint(bits), uintSafeNumber(bits)])
+}
+
+/** Numberish output schema for number-width unsigned integers. */
+export function uintNumberNumberish(bits?: SmallBits) {
+  return z.union([quantityHex(bits), uintNumber(bits)])
+}
+
+/** Numberish output schema for unsized/bigint-width signed integers. */
+export function intBigintNumberish(bits: number) {
+  return z.union([quantityHex(bits), intBigint(bits), intSafeNumber(bits)])
+}
+
+/** Numberish output schema for number-width signed integers. */
+export function intNumberNumberish(bits: SmallBits) {
+  return z.union([quantityHex(bits), intNumber(bits)])
+}
+
+function uintSafeNumber(bits?: number) {
+  const max =
+    bits === undefined || bits > 53
+      ? globalThis.Number.MAX_SAFE_INTEGER
+      : 2 ** bits - 1
+  const message =
+    bits === undefined ? 'expected uint number' : `expected uint${bits}`
+  return z.int(message).check(z.gte(0, message), z.lte(max, message))
+}
+
+function intSafeNumber(bits?: number) {
+  const max =
+    bits === undefined || bits > 53
+      ? globalThis.Number.MAX_SAFE_INTEGER
+      : 2 ** (bits - 1) - 1
+  const min =
+    bits === undefined || bits > 53
+      ? globalThis.Number.MIN_SAFE_INTEGER
+      : -(2 ** (bits - 1))
+  const message =
+    bits === undefined ? 'expected int number' : `expected int${bits}`
+  return z.int(message).check(z.gte(min, message), z.lte(max, message))
+}
+
 function isIntegerHex(value: z.output<typeof z_Hex.Hex>, bits?: number) {
   try {
     if (bits !== undefined && core_Hex.size(value) > bits / 8) return false

package/src/zod/internal/TransactionEnvelope.ts

@@ -5,6 +5,14 @@ import * as z_Number from '../Number.js'
 import * as z_Uint from '../Uint.js'
 import * as z from 'zod/mini'
 
+/** Strict integer schema family (decode RPC hex to `bigint`/`number`). */
+export const strict = { uint: z_Uint.Uint, num: z_Number.Number } as const
+/** Numberish integer schema family for encode-only `*ToRpc` schemas. */
+export const toRpc = {
+  uint: z_Uint.UintToRpc,
+  num: z_Number.NumberToRpc,
+} as const
+
 export function type<input extends string, output extends string>(
   input: input,
   output: output,
@@ -15,31 +23,35 @@ export function type<input extends string, output extends string>(
   })
 }
 
-export function baseFields<const schema extends z.ZodMiniType<string, string>>(
-  type: schema,
-) {
+export function baseFields<
+  const schema extends z.ZodMiniType<string, string>,
+  uint extends z.ZodMiniType,
+  num extends z.ZodMiniType,
+>(type: schema, uint: uint, num: num) {
   return {
-    chainId: z_Number.Number,
+    chainId: num,
     data: z.optional(z_Hex.Hex),
     input: z.optional(z_Hex.Hex),
     from: z.optional(z_Address.Address),
-    gas: z.optional(z_Uint.Uint),
-    nonce: z.optional(z_Uint.Uint),
+    gas: z.optional(uint),
+    nonce: z.optional(uint),
     to: z.optional(z.union([z_Address.Address, z.null()])),
     type,
-    value: z.optional(z_Uint.Uint),
+    value: z.optional(uint),
     r: z.optional(z_Hex.Hex),
     s: z.optional(z_Hex.Hex),
-    yParity: z.optional(z_Number.Number),
-    v: z.optional(z_Number.Number),
+    yParity: z.optional(num),
+    v: z.optional(num),
   }
 }
 
 export function signedBaseFields<
   const schema extends z.ZodMiniType<string, string>,
->(type: schema) {
+  uint extends z.ZodMiniType,
+  num extends z.ZodMiniType,
+>(type: schema, uint: uint, num: num) {
   return {
-    ...baseFields(type),
+    ...baseFields(type, uint, num),
     r: z_Hex.Hex,
     s: z_Hex.Hex,
   }
@@ -47,18 +59,22 @@ export function signedBaseFields<
 
 export function optionalChainIdFields<
   const schema extends z.ZodMiniType<string, string>,
->(type: schema) {
+  uint extends z.ZodMiniType,
+  num extends z.ZodMiniType,
+>(type: schema, uint: uint, num: num) {
   return {
-    ...baseFields(type),
-    chainId: z.optional(z_Number.Number),
+    ...baseFields(type, uint, num),
+    chainId: z.optional(num),
   }
 }
 
 export function signedOptionalChainIdFields<
   const schema extends z.ZodMiniType<string, string>,
->(type: schema) {
+  uint extends z.ZodMiniType,
+  num extends z.ZodMiniType,
+>(type: schema, uint: uint, num: num) {
   return {
-    ...signedBaseFields(type),
-    chainId: z.optional(z_Number.Number),
+    ...signedBaseFields(type, uint, num),
+    chainId: z.optional(num),
   }
 }

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

@@ -41,16 +41,22 @@ const Transaction = z.union([z_Transaction.Transaction, z_Transaction.Pending])
 
 /** Call request shape shared by `eth_call` / `eth_estimateGas`. */
 const Call = z.union([
-  z.tuple([z_TransactionRequest.TransactionRequest]),
+  z.tuple([z_TransactionRequest.TransactionRequestToRpc]),
   z.tuple([
-    z_TransactionRequest.TransactionRequest,
+    z_TransactionRequest.TransactionRequestToRpc,
     BlockNumberOrTagOrIdentifier,
   ]),
   z.tuple([
-    z_TransactionRequest.TransactionRequest,
+    z_TransactionRequest.TransactionRequestToRpc,
     BlockNumberOrTagOrIdentifier,
     z_StateOverrides.StateOverrides,
   ]),
+  z.tuple([
+    z_TransactionRequest.TransactionRequestToRpc,
+    BlockNumberOrTagOrIdentifier,
+    z_StateOverrides.StateOverrides,
+    z_BlockOverrides.BlockOverrides,
+  ]),
 ])
 
 export const eth_accounts = from({
@@ -175,6 +181,12 @@ export const eth_getProof = from({
   returns: z_AccountProof.AccountProof,
 })
 
+export const eth_getRawTransactionByHash = from({
+  method: 'eth_getRawTransactionByHash',
+  params: z.tuple([z_Hex.Hex]),
+  returns: z.nullable(z_Hex.Hex),
+})
+
 export const eth_getStorageAt = from({
   method: 'eth_getStorageAt',
   params: z.tuple([z_Address.Address, z_Hex.Hex, BlockNumberOrTagOrIdentifier]),
@@ -273,7 +285,7 @@ export const eth_sendRawTransactionSync = from({
 
 export const eth_sendTransaction = from({
   method: 'eth_sendTransaction',
-  params: z.tuple([z_TransactionRequest.TransactionRequest]),
+  params: z.tuple([z_TransactionRequest.TransactionRequestToRpc]),
   returns: z_Hex.Hex,
 })
 
@@ -284,7 +296,9 @@ export const eth_simulateV1 = from({
       blockStateCalls: z.array(
         z.object({
           blockOverrides: z.optional(z_BlockOverrides.BlockOverrides),
-          calls: z.optional(z.array(z_TransactionRequest.TransactionRequest)),
+          calls: z.optional(
+            z.array(z_TransactionRequest.TransactionRequestToRpc),
+          ),
           stateOverrides: z.optional(z_StateOverrides.StateOverrides),
         }),
       ),
@@ -322,7 +336,7 @@ export const eth_simulateV1 = from({
 
 export const eth_signTransaction = from({
   method: 'eth_signTransaction',
-  params: z.tuple([z_TransactionRequest.TransactionRequest]),
+  params: z.tuple([z_TransactionRequest.TransactionRequestToRpc]),
   returns: z_Hex.Hex,
 })