fix(sdk): fix scale schema compat with zod-to-json-schema and type inference (#8602)

Author: Xaroz

.changeset/calm-foxes-sing.md

@@ -0,0 +1,5 @@
+---
+'@hyperlane-xyz/sdk': patch
+---
+
+Replaced z.coerce.bigint().positive() with ZBigNumberish.refine() in TokenMetadataSchema scale field for zod-to-json-schema compatibility. Fixed validateZodResult generic to correctly return output type for schemas with transforms.

typescript/sdk/src/token/types.ts

@@ -11,7 +11,7 @@ import {
   IsmType,
   OffchainLookupIsmConfigSchema,
 } from '../ism/types.js';
-import { ZHash } from '../metadata/customZodTypes.js';
+import { ZBigNumberish, ZHash } from '../metadata/customZodTypes.js';
 import {
   DerivedRouterConfig,
   GasRouterConfigSchema,
@@ -34,31 +34,13 @@ export const contractVersionMatchesDependency = (version: string) => {
 export const VERSION_ERROR_MESSAGE = `Contract version must match the @hyperlane-xyz/core dependency version (${CONTRACTS_PACKAGE_VERSION})`;
 
 /**
- * Coerces bigint or string to bigint with positivity check.
- * Needed because bigints are serialised as strings in JSON/YAML
- * and must be converted back on parse. Uses .refine() instead of
- * .positive() to avoid bigint values in zod-to-json-schema output.
+ * Coerces string to bigint at runtime with positivity check.
+ * Needed because bigints are serialized as strings in JSON/YAML
+ * and must be converted back on parse.
  */
-const PositiveBigIntFromString = z
-  .union([
-    z.bigint(),
-    z
-      .string()
-      .refine(
-        (s) => {
-          try {
-            BigInt(s);
-            return true;
-          } catch {
-            return false;
-          }
-        },
-        { message: 'Must be a bigint-compatible string' },
-      )
-      .transform((s) => BigInt(s)),
-  ])
-  .pipe(z.bigint())
-  .refine((n) => n > 0n, { message: 'Must be positive' });
+const PositiveZBigNumberish = ZBigNumberish.refine((n) => n > 0n, {
+  message: 'Must be positive',
+});
 
 export const TokenMetadataSchema = z.object({
   name: z.string(),
@@ -72,8 +54,8 @@ export const TokenMetadataSchema = z.object({
         denominator: z.number().int().gt(0),
       }),
       z.object({
-        numerator: PositiveBigIntFromString,
-        denominator: PositiveBigIntFromString,
+        numerator: PositiveZBigNumberish,
+        denominator: PositiveZBigNumberish,
       }),
     ])
     .optional(),

typescript/sdk/src/utils/schemas.test.ts

@@ -0,0 +1,37 @@
+import { expect } from 'chai';
+import { z } from 'zod';
+
+import { validateZodResult } from './schemas.js';
+
+describe('validateZodResult', () => {
+  it('returns parsed data on success', () => {
+    const schema = z.object({ name: z.string() });
+    const result = schema.safeParse({ name: 'hello' });
+    expect(validateZodResult(result)).to.deep.equal({ name: 'hello' });
+  });
+
+  it('throws on validation failure', () => {
+    const schema = z.object({ name: z.string() });
+    const result = schema.safeParse({ name: 123 });
+    expect(() => validateZodResult(result)).to.throw();
+  });
+
+  it('returns output type for schemas with transforms', () => {
+    const schema = z.object({
+      value: z.string().transform((s) => parseInt(s, 10)),
+    });
+    const result = schema.safeParse({ value: '42' });
+    const parsed = validateZodResult(result);
+    expect(parsed.value).to.equal(42);
+    expect(typeof parsed.value).to.equal('number');
+  });
+
+  it('handles schemas with bigint coercion', () => {
+    const schema = z.object({
+      amount: z.bigint().or(z.string().regex(/^\d+$/).transform(BigInt)),
+    });
+    const result = schema.safeParse({ amount: '1000000000000' });
+    const parsed = validateZodResult(result);
+    expect(parsed.amount).to.equal(1000000000000n);
+  });
+});

typescript/sdk/src/utils/schemas.ts

@@ -7,10 +7,10 @@ export function isCompliant<S extends z.ZodTypeAny>(schema: S) {
     schema.safeParse(config).success;
 }
 
-export function validateZodResult<T>(
-  result: SafeParseReturnType<T, T>,
+export function validateZodResult<I, O>(
+  result: SafeParseReturnType<I, O>,
   desc: string = 'config',
-): T {
+): O {
   if (!result.success) {
     rootLogger.warn(`Invalid ${desc}`, result.error);
     throw new Error(`Invalid desc: ${result.error.toString()}`);