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

package/src/zod/TxEnvelopeEip1559.ts

@@ -1,9 +1,10 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 import * as z_AccessList from './AccessList.js'
-import * as z_Uint from './Uint.js'
 import {
   baseFields,
   signedBaseFields,
+  strict,
+  toRpc,
   type,
 } from './internal/TransactionEnvelope.js'
 import * as z from 'zod/mini'
@@ -11,17 +12,37 @@ import * as z from 'zod/mini'
 const Type = type('0x2', 'eip1559')
 
 /** EIP-1559 transaction envelope schema. */
-export const TxEnvelopeEip1559 = z.object({
-  ...baseFields(Type),
-  accessList: z.optional(z_AccessList.AccessList),
-  maxFeePerGas: z.optional(z_Uint.Uint),
-  maxPriorityFeePerGas: z.optional(z_Uint.Uint),
-})
+export const TxEnvelopeEip1559 = z.object(fields(strict.uint, strict.num))
+
+/** Encode-only EIP-1559 transaction envelope schema accepting numberish `toRpc` inputs. */
+export const TxEnvelopeEip1559ToRpc = z.object(fields(toRpc.uint, toRpc.num))
 
 /** Signed EIP-1559 transaction envelope schema. */
-export const Signed = z.object({
-  ...signedBaseFields(Type),
-  accessList: z.optional(z_AccessList.AccessList),
-  maxFeePerGas: z.optional(z_Uint.Uint),
-  maxPriorityFeePerGas: z.optional(z_Uint.Uint),
-})
+export const Signed = z.object(signedFields(strict.uint, strict.num))
+
+/** Encode-only signed EIP-1559 transaction envelope schema accepting numberish `toRpc` inputs. */
+export const SignedToRpc = z.object(signedFields(toRpc.uint, toRpc.num))
+
+function fields<uint extends z.ZodMiniType, num extends z.ZodMiniType>(
+  uint: uint,
+  num: num,
+) {
+  return {
+    ...baseFields(Type, uint, num),
+    accessList: z.optional(z_AccessList.AccessList),
+    maxFeePerGas: z.optional(uint),
+    maxPriorityFeePerGas: z.optional(uint),
+  }
+}
+
+function signedFields<uint extends z.ZodMiniType, num extends z.ZodMiniType>(
+  uint: uint,
+  num: num,
+) {
+  return {
+    ...signedBaseFields(Type, uint, num),
+    accessList: z.optional(z_AccessList.AccessList),
+    maxFeePerGas: z.optional(uint),
+    maxPriorityFeePerGas: z.optional(uint),
+  }
+}

package/src/zod/TxEnvelopeEip2930.ts

@@ -1,9 +1,10 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 import * as z_AccessList from './AccessList.js'
-import * as z_Uint from './Uint.js'
 import {
   baseFields,
   signedBaseFields,
+  strict,
+  toRpc,
   type,
 } from './internal/TransactionEnvelope.js'
 import * as z from 'zod/mini'
@@ -11,15 +12,35 @@ import * as z from 'zod/mini'
 const Type = type('0x1', 'eip2930')
 
 /** EIP-2930 transaction envelope schema. */
-export const TxEnvelopeEip2930 = z.object({
-  ...baseFields(Type),
-  accessList: z.optional(z_AccessList.AccessList),
-  gasPrice: z.optional(z_Uint.Uint),
-})
+export const TxEnvelopeEip2930 = z.object(fields(strict.uint, strict.num))
+
+/** Encode-only EIP-2930 transaction envelope schema accepting numberish `toRpc` inputs. */
+export const TxEnvelopeEip2930ToRpc = z.object(fields(toRpc.uint, toRpc.num))
 
 /** Signed EIP-2930 transaction envelope schema. */
-export const Signed = z.object({
-  ...signedBaseFields(Type),
-  accessList: z.optional(z_AccessList.AccessList),
-  gasPrice: z.optional(z_Uint.Uint),
-})
+export const Signed = z.object(signedFields(strict.uint, strict.num))
+
+/** Encode-only signed EIP-2930 transaction envelope schema accepting numberish `toRpc` inputs. */
+export const SignedToRpc = z.object(signedFields(toRpc.uint, toRpc.num))
+
+function fields<uint extends z.ZodMiniType, num extends z.ZodMiniType>(
+  uint: uint,
+  num: num,
+) {
+  return {
+    ...baseFields(Type, uint, num),
+    accessList: z.optional(z_AccessList.AccessList),
+    gasPrice: z.optional(uint),
+  }
+}
+
+function signedFields<uint extends z.ZodMiniType, num extends z.ZodMiniType>(
+  uint: uint,
+  num: num,
+) {
+  return {
+    ...signedBaseFields(Type, uint, num),
+    accessList: z.optional(z_AccessList.AccessList),
+    gasPrice: z.optional(uint),
+  }
+}

package/src/zod/TxEnvelopeEip4844.ts

@@ -1,10 +1,11 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 import * as z_AccessList from './AccessList.js'
 import * as z_Hex from './Hex.js'
-import * as z_Uint from './Uint.js'
 import {
   baseFields,
   signedBaseFields,
+  strict,
+  toRpc,
   type,
 } from './internal/TransactionEnvelope.js'
 import * as z from 'zod/mini'
@@ -19,23 +20,43 @@ export const Sidecars = z.object({
 })
 
 /** EIP-4844 transaction envelope schema. */
-export const TxEnvelopeEip4844 = z.object({
-  ...baseFields(Type),
-  accessList: z.optional(z_AccessList.AccessList),
-  blobVersionedHashes: z.readonly(z.array(z_Hex.Hex)),
-  maxFeePerBlobGas: z.optional(z_Uint.Uint),
-  maxFeePerGas: z.optional(z_Uint.Uint),
-  maxPriorityFeePerGas: z.optional(z_Uint.Uint),
-  sidecars: z.optional(Sidecars),
-})
+export const TxEnvelopeEip4844 = z.object(fields(strict.uint, strict.num))
+
+/** Encode-only EIP-4844 transaction envelope schema accepting numberish `toRpc` inputs. */
+export const TxEnvelopeEip4844ToRpc = z.object(fields(toRpc.uint, toRpc.num))
 
 /** Signed EIP-4844 transaction envelope schema. */
-export const Signed = z.object({
-  ...signedBaseFields(Type),
-  accessList: z.optional(z_AccessList.AccessList),
-  blobVersionedHashes: z.readonly(z.array(z_Hex.Hex)),
-  maxFeePerBlobGas: z.optional(z_Uint.Uint),
-  maxFeePerGas: z.optional(z_Uint.Uint),
-  maxPriorityFeePerGas: z.optional(z_Uint.Uint),
-  sidecars: z.optional(Sidecars),
-})
+export const Signed = z.object(signedFields(strict.uint, strict.num))
+
+/** Encode-only signed EIP-4844 transaction envelope schema accepting numberish `toRpc` inputs. */
+export const SignedToRpc = z.object(signedFields(toRpc.uint, toRpc.num))
+
+function fields<uint extends z.ZodMiniType, num extends z.ZodMiniType>(
+  uint: uint,
+  num: num,
+) {
+  return {
+    ...baseFields(Type, uint, num),
+    accessList: z.optional(z_AccessList.AccessList),
+    blobVersionedHashes: z.readonly(z.array(z_Hex.Hex)),
+    maxFeePerBlobGas: z.optional(uint),
+    maxFeePerGas: z.optional(uint),
+    maxPriorityFeePerGas: z.optional(uint),
+    sidecars: z.optional(Sidecars),
+  }
+}
+
+function signedFields<uint extends z.ZodMiniType, num extends z.ZodMiniType>(
+  uint: uint,
+  num: num,
+) {
+  return {
+    ...signedBaseFields(Type, uint, num),
+    accessList: z.optional(z_AccessList.AccessList),
+    blobVersionedHashes: z.readonly(z.array(z_Hex.Hex)),
+    maxFeePerBlobGas: z.optional(uint),
+    maxFeePerGas: z.optional(uint),
+    maxPriorityFeePerGas: z.optional(uint),
+    sidecars: z.optional(Sidecars),
+  }
+}

package/src/zod/TxEnvelopeEip7702.ts

@@ -1,10 +1,11 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 import * as z_AccessList from './AccessList.js'
 import * as z_Authorization from './Authorization.js'
-import * as z_Uint from './Uint.js'
 import {
   baseFields,
   signedBaseFields,
+  strict,
+  toRpc,
   type,
 } from './internal/TransactionEnvelope.js'
 import * as z from 'zod/mini'
@@ -12,19 +13,49 @@ import * as z from 'zod/mini'
 const Type = type('0x4', 'eip7702')
 
 /** EIP-7702 transaction envelope schema. */
-export const TxEnvelopeEip7702 = z.object({
-  ...baseFields(Type),
-  accessList: z.optional(z_AccessList.AccessList),
-  authorizationList: z_Authorization.ListSigned,
-  maxFeePerGas: z.optional(z_Uint.Uint),
-  maxPriorityFeePerGas: z.optional(z_Uint.Uint),
-})
+export const TxEnvelopeEip7702 = z.object(
+  fields(strict.uint, strict.num, z_Authorization.ListSigned),
+)
+
+/** Encode-only EIP-7702 transaction envelope schema accepting numberish `toRpc` inputs. */
+export const TxEnvelopeEip7702ToRpc = z.object(
+  fields(toRpc.uint, toRpc.num, z_Authorization.ListSignedToRpc),
+)
 
 /** Signed EIP-7702 transaction envelope schema. */
-export const Signed = z.object({
-  ...signedBaseFields(Type),
-  accessList: z.optional(z_AccessList.AccessList),
-  authorizationList: z_Authorization.ListSigned,
-  maxFeePerGas: z.optional(z_Uint.Uint),
-  maxPriorityFeePerGas: z.optional(z_Uint.Uint),
-})
+export const Signed = z.object(
+  signedFields(strict.uint, strict.num, z_Authorization.ListSigned),
+)
+
+/** Encode-only signed EIP-7702 transaction envelope schema accepting numberish `toRpc` inputs. */
+export const SignedToRpc = z.object(
+  signedFields(toRpc.uint, toRpc.num, z_Authorization.ListSignedToRpc),
+)
+
+function fields<
+  uint extends z.ZodMiniType,
+  num extends z.ZodMiniType,
+  authorizationList extends z.ZodMiniType,
+>(uint: uint, num: num, authorizationList: authorizationList) {
+  return {
+    ...baseFields(Type, uint, num),
+    accessList: z.optional(z_AccessList.AccessList),
+    authorizationList,
+    maxFeePerGas: z.optional(uint),
+    maxPriorityFeePerGas: z.optional(uint),
+  }
+}
+
+function signedFields<
+  uint extends z.ZodMiniType,
+  num extends z.ZodMiniType,
+  authorizationList extends z.ZodMiniType,
+>(uint: uint, num: num, authorizationList: authorizationList) {
+  return {
+    ...signedBaseFields(Type, uint, num),
+    accessList: z.optional(z_AccessList.AccessList),
+    authorizationList,
+    maxFeePerGas: z.optional(uint),
+    maxPriorityFeePerGas: z.optional(uint),
+  }
+}

package/src/zod/TxEnvelopeLegacy.ts

@@ -1,8 +1,9 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
-import * as z_Uint from './Uint.js'
 import {
   optionalChainIdFields,
   signedOptionalChainIdFields,
+  strict,
+  toRpc,
   type,
 } from './internal/TransactionEnvelope.js'
 import * as z from 'zod/mini'
@@ -10,13 +11,33 @@ import * as z from 'zod/mini'
 const Type = type('0x0', 'legacy')
 
 /** Legacy transaction envelope schema. */
-export const TxEnvelopeLegacy = z.object({
-  ...optionalChainIdFields(Type),
-  gasPrice: z.optional(z_Uint.Uint),
-})
+export const TxEnvelopeLegacy = z.object(fields(strict.uint, strict.num))
+
+/** Encode-only legacy transaction envelope schema accepting numberish `toRpc` inputs. */
+export const TxEnvelopeLegacyToRpc = z.object(fields(toRpc.uint, toRpc.num))
 
 /** Signed legacy transaction envelope schema. */
-export const Signed = z.object({
-  ...signedOptionalChainIdFields(Type),
-  gasPrice: z.optional(z_Uint.Uint),
-})
+export const Signed = z.object(signedFields(strict.uint, strict.num))
+
+/** Encode-only signed legacy transaction envelope schema accepting numberish `toRpc` inputs. */
+export const SignedToRpc = z.object(signedFields(toRpc.uint, toRpc.num))
+
+function fields<uint extends z.ZodMiniType, num extends z.ZodMiniType>(
+  uint: uint,
+  num: num,
+) {
+  return {
+    ...optionalChainIdFields(Type, uint, num),
+    gasPrice: z.optional(uint),
+  }
+}
+
+function signedFields<uint extends z.ZodMiniType, num extends z.ZodMiniType>(
+  uint: uint,
+  num: num,
+) {
+  return {
+    ...signedOptionalChainIdFields(Type, uint, num),
+    gasPrice: z.optional(uint),
+  }
+}

package/src/zod/TypedData.ts

@@ -0,0 +1,111 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import type * as core_TypedData from '../core/TypedData.js'
+import * as z_Address from './Address.js'
+import * as z_Solidity from './Solidity.js'
+import * as z from 'zod/mini'
+
+export const Domain = z.object({
+  chainId: z.optional(z.union([z.number(), z.bigint()])),
+  name: z.optional(z_Solidity.Identifier),
+  salt: z.optional(z.string()),
+  verifyingContract: z.optional(z_Address.Address),
+  version: z.optional(z.string()),
+})
+
+export const Type = z.union([
+  z_Solidity.Address,
+  z_Solidity.Bool,
+  z_Solidity.Bytes,
+  z_Solidity.String,
+  z_Solidity.Int,
+  z_Solidity.Array,
+])
+
+export const Parameter = z.object({
+  name: z_Solidity.Identifier,
+  type: z.string(),
+})
+
+const Raw = z.record(z_Solidity.Identifier, z.readonly(z.array(Parameter)))
+
+export const TypedData = z.pipe(
+  Raw,
+  z.transform((value, ctx) => validate(value, ctx)),
+)
+
+function validate(
+  typedData: Record<string, readonly core_TypedData.Parameter[]>,
+  ctx: z.core.ParsePayload,
+) {
+  for (const key of Object.keys(typedData)) {
+    if (z_Solidity.isType(key)) {
+      ctx.issues.push({
+        code: 'custom',
+        input: key,
+        message: `Invalid key. ${key} is a solidity type.`,
+      })
+      return z.NEVER
+    }
+
+    validateParameters(key, typedData, ctx)
+  }
+
+  return typedData as core_TypedData.TypedData
+}
+
+const typeWithoutTupleRegex =
+  /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*?)(?<array>(?:\[\d*?\])+?)?$/
+
+function validateParameters(
+  key: string,
+  typedData: Record<string, readonly core_TypedData.Parameter[]>,
+  ctx: z.core.ParsePayload,
+  ancestors = new Set<string>(),
+) {
+  const value = typedData[key]
+  if (!value) return
+
+  for (const parameter of value) {
+    if (parameter.type === key) {
+      ctx.issues.push({
+        code: 'custom',
+        input: parameter.type,
+        message: `Invalid type. ${key} is a self reference.`,
+      })
+      return z.NEVER
+    }
+
+    const match = typeWithoutTupleRegex.exec(parameter.type)?.groups as
+      | { array?: string | undefined; type?: string | undefined }
+      | undefined
+    const type = match?.type
+    if (!type) {
+      ctx.issues.push({
+        code: 'custom',
+        input: parameter.type,
+        message: `Invalid type. ${key} does not have a type.`,
+      })
+      return z.NEVER
+    }
+
+    if (type in typedData) {
+      if (ancestors.has(type)) {
+        ctx.issues.push({
+          code: 'custom',
+          input: type,
+          message: `Invalid type. ${type} is a circular reference.`,
+        })
+        return z.NEVER
+      }
+
+      validateParameters(type, typedData, ctx, new Set([...ancestors, type]))
+    } else if (!z_Solidity.isType(type)) {
+      ctx.issues.push({
+        code: 'custom',
+        input: type,
+        message: `Invalid type. ${type} is not a valid EIP-712 type.`,
+      })
+      return z.NEVER
+    }
+  }
+}

package/src/zod/Uint.ts

@@ -2,10 +2,13 @@
 import * as core_Hex from '../core/Hex.js'
 import {
   decodeInteger,
+  encodeNumberish,
   quantityHex,
   type SmallBits,
   uintBigint,
+  uintBigintNumberish,
   uintNumber,
+  uintNumberNumberish,
 } from './internal/Integer.js'
 import * as z from 'zod/mini'
 
@@ -15,6 +18,15 @@ export const Uint = z.codec(quantityHex(), uintBigint(), {
   encode: (value) => core_Hex.fromNumber(value),
 })
 
+/** Encode-only unsized unsigned integer accepting `Hex | bigint | number`. */
+export const UintToRpc = z.codec(quantityHex(), uintBigintNumberish(), {
+  decode: (value) => core_Hex.toBigInt(value),
+  encode: (value) => encodeNumberish(value),
+})
+
+/** Encode-only 8-bit unsigned integer accepting `Hex | number`. */
+export const Uint8ToRpc = unsignedToRpc(8)
+
 /** 8-bit unsigned integer decoded as `number` and encoded as hex. */
 export const Uint8 = unsigned(8)
 /** 16-bit unsigned integer decoded as `number` and encoded as hex. */
@@ -87,6 +99,13 @@ function unsigned(bits: SmallBits) {
   })
 }
 
+function unsignedToRpc(bits: SmallBits) {
+  return z.codec(quantityHex(bits), uintNumberNumberish(bits), {
+    decode: (value) => globalThis.Number(decodeInteger(value, bits, false)),
+    encode: (value) => encodeNumberish(value),
+  })
+}
+
 function unsignedBigint(bits: number) {
   return z.codec(quantityHex(bits), uintBigint(bits), {
     decode: (value) => decodeInteger(value, bits, false),

package/src/zod/Withdrawal.ts

@@ -5,9 +5,21 @@ import * as z_Uint from './Uint.js'
 import * as z from 'zod/mini'
 
 /** RPC withdrawal schema decoded to a withdrawal. */
-export const Withdrawal = z.object({
-  address: z_Address.Address,
-  amount: z_Uint.Uint,
-  index: z_Number.Number,
-  validatorIndex: z_Number.Number,
-})
+export const Withdrawal = z.object(fields(z_Uint.Uint, z_Number.Number))
+
+/** Encode-only withdrawal schema accepting numberish `toRpc` inputs. */
+export const WithdrawalToRpc = z.object(
+  fields(z_Uint.UintToRpc, z_Number.NumberToRpc),
+)
+
+function fields<uint extends z.ZodMiniType, num extends z.ZodMiniType>(
+  uint: uint,
+  num: num,
+) {
+  return {
+    address: z_Address.Address,
+    amount: uint,
+    index: num,
+    validatorIndex: num,
+  }
+}

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

@@ -0,0 +1,46 @@
+import type * as core_Abi from '../../core/Abi.js'
+import type * as core_AbiConstructor from '../../core/AbiConstructor.js'
+import type * as core_AbiError from '../../core/AbiError.js'
+import type * as core_AbiEvent from '../../core/AbiEvent.js'
+import type * as core_AbiFunction from '../../core/AbiFunction.js'
+import type * as core_AbiItem from '../../core/AbiItem.js'
+import type * as core_AbiParameter from '../../core/AbiParameter.js'
+import type * as core_AbiParameters from '../../core/AbiParameters.js'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_Abi from '../Abi.js'
+import * as z_AbiConstructor from '../AbiConstructor.js'
+import * as z_AbiError from '../AbiError.js'
+import * as z_AbiEvent from '../AbiEvent.js'
+import * as z_AbiFunction from '../AbiFunction.js'
+import * as z_AbiItem from '../AbiItem.js'
+import * as z_AbiParameter from '../AbiParameter.js'
+import * as z_AbiParameters from '../AbiParameters.js'
+import type * as z from 'zod/mini'
+
+test('ABI schemas output Ox core ABI types', () => {
+  expectTypeOf<z.output<typeof z_Abi.Abi>>().toMatchTypeOf<core_Abi.Abi>()
+  expectTypeOf<
+    z.output<typeof z_AbiConstructor.AbiConstructor>
+  >().toMatchTypeOf<core_AbiConstructor.AbiConstructor>()
+  expectTypeOf<
+    z.output<typeof z_AbiError.AbiError>
+  >().toMatchTypeOf<core_AbiError.AbiError>()
+  expectTypeOf<
+    z.output<typeof z_AbiEvent.AbiEvent>
+  >().toMatchTypeOf<core_AbiEvent.AbiEvent>()
+  expectTypeOf<
+    z.output<typeof z_AbiFunction.AbiFunction>
+  >().toMatchTypeOf<core_AbiFunction.AbiFunction>()
+  expectTypeOf<
+    z.output<typeof z_AbiItem.AbiItem>
+  >().toMatchTypeOf<core_AbiItem.AbiItem>()
+  expectTypeOf<
+    z.output<typeof z_AbiParameter.AbiParameter>
+  >().toMatchTypeOf<core_AbiParameter.AbiParameter>()
+  expectTypeOf<
+    z.output<typeof z_AbiParameter.AbiEventParameter>
+  >().toMatchTypeOf<core_AbiParameter.AbiEventParameter>()
+  expectTypeOf<
+    z.output<typeof z_AbiParameters.AbiParameters>
+  >().toMatchTypeOf<core_AbiParameters.AbiParameters>()
+})