ox 1.0.0-beta.8 → 1.0.0

package/src/zod/AbiItem.ts

@@ -0,0 +1,28 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_AbiConstructor from './AbiConstructor.js'
+import * as z_AbiError from './AbiError.js'
+import * as z_AbiEvent from './AbiEvent.js'
+import * as z_AbiFallback from './AbiFallback.js'
+import * as z_AbiFunction from './AbiFunction.js'
+import * as z_AbiReceive from './AbiReceive.js'
+import * as z from 'zod/mini'
+
+export const Type = z.union([
+  z.literal('constructor'),
+  z.literal('event'),
+  z.literal('error'),
+  z.literal('fallback'),
+  z.literal('function'),
+  z.literal('receive'),
+])
+
+export const AbiItem = z.union([
+  z_AbiConstructor.AbiConstructor,
+  z_AbiError.AbiError,
+  z_AbiEvent.AbiEvent,
+  z_AbiFallback.AbiFallback,
+  z_AbiFunction.AbiFunction,
+  z_AbiReceive.AbiReceive,
+])
+
+export const AbiItemType = Type

package/src/zod/AbiParameter.ts

@@ -0,0 +1,36 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_Solidity from './Solidity.js'
+import * as z from 'zod/mini'
+
+const Name = z.union([z.optional(z_Solidity.Identifier), z.literal('')])
+const SimpleType = z.union([
+  z_Solidity.Address,
+  z_Solidity.Bool,
+  z_Solidity.Bytes,
+  z_Solidity.Function,
+  z_Solidity.String,
+  z_Solidity.Int,
+  z_Solidity.ArrayWithoutTuple,
+])
+const TupleType = z.union([z_Solidity.Tuple, z_Solidity.ArrayWithTuple])
+
+export const AbiParameter = z.intersection(
+  z.object({
+    name: Name,
+    internalType: z.optional(z.string()),
+  }),
+  z.union([
+    z.object({ type: SimpleType }),
+    z.object({
+      type: TupleType,
+      get components() {
+        return z.readonly(z.array(AbiParameter))
+      },
+    }),
+  ]),
+)
+
+export const AbiEventParameter = z.intersection(
+  AbiParameter,
+  z.object({ indexed: z.optional(z.boolean()) }),
+)

package/src/zod/AbiParameters.ts

@@ -0,0 +1,7 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_AbiParameter from './AbiParameter.js'
+import * as z from 'zod/mini'
+
+export const AbiParameters = z.readonly(z.array(z_AbiParameter.AbiParameter))
+
+export const Parameter = z_AbiParameter.AbiParameter

package/src/zod/AbiReceive.ts

@@ -0,0 +1,7 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z from 'zod/mini'
+
+export const AbiReceive = z.object({
+  type: z.literal('receive'),
+  stateMutability: z.literal('payable'),
+})

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,
@@ -167,7 +167,7 @@ function resolveItem(args: readonly unknown[]): [item: Item, value: unknown] {
  * 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 {@link parseItem}/{@link from}).
+ * `RpcSchema.Item` (from `parseItem`/`from`).
  *
  * @example
  * ```ts twoslash
@@ -218,7 +218,7 @@ export function decodeParams(...args: readonly unknown[]): unknown {
  * 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 {@link parseItem}/{@link from}).
+ * `RpcSchema.Item` (from `parseItem`/`from`).
  *
  * @example
  * ```ts twoslash
@@ -269,7 +269,7 @@ export function encodeParams(...args: readonly unknown[]): unknown {
  * 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 {@link parseItem}/{@link from}).
+ * `RpcSchema.Item` (from `parseItem`/`from`).
  *
  * @example
  * ```ts twoslash
@@ -320,7 +320,7 @@ export function decodeReturns(...args: readonly unknown[]): unknown {
  * 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 {@link parseItem}/{@link from}).
+ * (from `parseItem`/`from`).
  *
  * @example
  * ```ts twoslash

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/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/_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>()
+})

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

@@ -0,0 +1,163 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_Abi from '../Abi.js'
+import * as z_AbiConstructor from '../AbiConstructor.js'
+import * as z_AbiFunction from '../AbiFunction.js'
+import * as z_AbiParameter from '../AbiParameter.js'
+import * as z_Solidity from '../Solidity.js'
+import * as z from 'zod/mini'
+
+describe('Abi', () => {
+  test('decodes ABI items and normalizes legacy mutability fields', () => {
+    const input = [
+      {
+        constant: true,
+        inputs: [{ name: 'owner', type: 'address' }],
+        name: 'balanceOf',
+        outputs: [{ name: 'balance', type: 'uint256' }],
+        type: 'function',
+      },
+      {
+        inputs: [{ name: 'owner', type: 'address' }],
+        payable: true,
+        type: 'constructor',
+      },
+      {
+        payable: false,
+        type: 'fallback',
+      },
+    ] as const
+
+    expect(z.decode(z_Abi.Abi, input)).toMatchInlineSnapshot(`
+      [
+        {
+          "constant": true,
+          "inputs": [
+            {
+              "name": "owner",
+              "type": "address",
+            },
+          ],
+          "name": "balanceOf",
+          "outputs": [
+            {
+              "name": "balance",
+              "type": "uint256",
+            },
+          ],
+          "stateMutability": "view",
+          "type": "function",
+        },
+        {
+          "inputs": [
+            {
+              "name": "owner",
+              "type": "address",
+            },
+          ],
+          "payable": true,
+          "stateMutability": "payable",
+          "type": "constructor",
+        },
+        {
+          "payable": false,
+          "stateMutability": "nonpayable",
+          "type": "fallback",
+        },
+      ]
+    `)
+    expect(input[0]).not.toHaveProperty('stateMutability')
+  })
+
+  test('strips unknown keys', () => {
+    const input: unknown = {
+      type: 'function',
+      inputs: [],
+      name: 'totalSupply',
+      outputs: [{ type: 'uint256', extra: true }],
+      stateMutability: 'view',
+      extra: true,
+    }
+
+    expect(z.parse(z_AbiFunction.AbiFunction, input)).toMatchInlineSnapshot(`
+      {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+          {
+            "type": "uint256",
+          },
+        ],
+        "stateMutability": "view",
+        "type": "function",
+      }
+    `)
+  })
+
+  test('decodes tuple parameters recursively', () => {
+    expect(
+      z.decode(z_AbiParameter.AbiParameter, {
+        name: 'foo',
+        type: 'tuple[]',
+        components: [
+          { name: 'owner', type: 'address' },
+          { name: 'ids', type: 'uint256[]' },
+        ],
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "components": [
+          {
+            "name": "owner",
+            "type": "address",
+          },
+          {
+            "name": "ids",
+            "type": "uint256[]",
+          },
+        ],
+        "name": "foo",
+        "type": "tuple[]",
+      }
+    `)
+  })
+
+  test('rejects invalid parameter types', () => {
+    expect(
+      z.safeDecode(z_AbiParameter.AbiParameter, { type: 'notAValidType' })
+        .success,
+    ).toBe(false)
+  })
+
+  test('decodes constructors with explicit mutability', () => {
+    expect(
+      z.decode(z_AbiConstructor.AbiConstructor, {
+        type: 'constructor',
+        inputs: [],
+        payable: true,
+        stateMutability: 'nonpayable',
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "inputs": [],
+        "payable": true,
+        "stateMutability": "nonpayable",
+        "type": "constructor",
+      }
+    `)
+  })
+})
+
+describe('Solidity', () => {
+  test('decodes Solidity type tokens', () => {
+    expect(z.decode(z_Solidity.Address, 'address')).toMatchInlineSnapshot(
+      `"address"`,
+    )
+    expect(z.decode(z_Solidity.Int, 'uint256')).toMatchInlineSnapshot(
+      `"uint256"`,
+    )
+    expect(z.decode(z_Solidity.Array, 'tuple[2][]')).toMatchInlineSnapshot(
+      `"tuple[2][]"`,
+    )
+    expect(z.safeDecode(z_Solidity.Bytes, 'bytes33').success).toBe(false)
+  })
+})

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/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,