@aztec/foundation 0.65.0 → 0.65.2

package/src/schemas/utils.ts

@@ -15,6 +15,17 @@ import { type ZodFor } from './types.js';
 
 export const hexSchema = z.string().refine(isHex, 'Not a valid hex string').transform(withoutHexPrefix);
 
+// Copied from zod internals, which was copied from https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
+const base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+
+/** Schema for a buffer represented as a base64 string. */
+export const bufferSchema = z
+  .string()
+  // We only test the str for base64 if it's shorter than 1024 bytes, otherwise we've run into maximum
+  // stack size exceeded errors when trying to validate excessively long strings (such as contract bytecode).
+  .refine(str => str.length > 1024 || base64Regex.test(str), 'Not a valid base64 string')
+  .transform(data => Buffer.from(data, 'base64'));
+
 export class ZodNullableOptional<T extends ZodTypeAny> extends ZodOptional<T> {
   _isNullableOptional = true;
 
@@ -43,6 +54,8 @@ export function optional<T extends ZodTypeAny>(schema: T) {
   return ZodNullableOptional.create(schema);
 }
 
+type ToJsonIs<T, TRet> = T extends { toJSON(): TRet } ? T : never;
+
 /**
  * Creates a schema that accepts a hex string and uses it to hydrate an instance.
  * @param klazz - Class that implements either fromString or fromBuffer.
@@ -50,28 +63,34 @@ export function optional<T extends ZodTypeAny>(schema: T) {
  */
 export function hexSchemaFor<TClass extends { fromString(str: string): any } | { fromBuffer(buf: Buffer): any }>(
   klazz: TClass,
+  refinement?: (input: string) => boolean,
 ): ZodType<
   TClass extends { fromString(str: string): infer TInstance } | { fromBuffer(buf: Buffer): infer TInstance }
-    ? TInstance
+    ? ToJsonIs<TInstance, string>
     : never,
   any,
   string
 > {
+  const stringSchema = refinement ? z.string().refine(refinement, `Not a valid instance`) : z.string();
+  const hexSchema = stringSchema.refine(isHex, 'Not a valid hex string').transform(withoutHexPrefix);
   return 'fromString' in klazz
     ? hexSchema.transform(klazz.fromString.bind(klazz))
     : hexSchema.transform(str => Buffer.from(str, 'hex')).transform(klazz.fromBuffer.bind(klazz));
 }
 
-// TODO(palla/schemas): Delete this class once all serialization of the type { type: string, value: string } are removed.
-export function maybeStructuredStringSchemaFor<TClass extends { fromString(str: string): any }>(
-  name: string,
+/**
+ * Creates a schema that accepts a base64 string and uses it to hydrate an instance.
+ * @param klazz - Class that implements fromBuffer.
+ * @returns A schema for the class.
+ */
+export function bufferSchemaFor<TClass extends { fromBuffer(buf: Buffer): any }>(
   klazz: TClass,
-  refinement?: (input: string) => boolean,
-): ZodFor<TClass extends { fromString(str: string): infer TInstance } ? TInstance : never> {
-  const stringSchema = refinement ? z.string().refine(refinement, `Not a valid ${name}`) : z.string();
-  return z
-    .union([stringSchema, z.object({ type: z.literal(name), value: stringSchema })])
-    .transform(input => klazz.fromString(typeof input === 'string' ? input : input.value));
+): ZodType<
+  TClass extends { fromBuffer(buf: Buffer): infer TInstance } ? ToJsonIs<TInstance, Buffer> : never,
+  any,
+  string
+> {
+  return bufferSchema.transform(klazz.fromBuffer.bind(klazz));
 }
 
 /** Creates a schema for a js Map type that matches the serialization used in jsonStringify. */

package/src/serialize/type_registry.ts

@@ -1,3 +1,5 @@
+import { mapValues } from '../collection/object.js';
+
 type Deserializable = { fromString(str: string): object };
 
 /**
@@ -23,9 +25,39 @@ export class TypeRegistry {
   }
 }
 
+function replace<T>(value: T) {
+  if (
+    value &&
+    typeof value === 'object' &&
+    'toString' in value &&
+    TypeRegistry.getConstructor(value.constructor.name)
+  ) {
+    return {
+      type: value.constructor.name,
+      value: value.toString(),
+    };
+  }
+
+  return value;
+}
+
 // Resolver function that enables JSON serialization of BigInts.
 export function resolver(_: any, value: any) {
-  return typeof value === 'bigint' ? value.toString() + 'n' : value;
+  if (typeof value === 'bigint') {
+    return value.toString() + 'n';
+  }
+
+  if (typeof value === 'object' && value) {
+    if (Array.isArray(value)) {
+      return value.map(replace);
+    } else if (Buffer.isBuffer(value)) {
+      return { type: 'buffer', value: value.toString('hex') };
+    } else {
+      return mapValues(value, replace);
+    }
+  }
+
+  return value;
 }
 
 // Reviver function that uses TypeRegistry to instantiate objects.

package/src/string/index.ts

@@ -14,6 +14,10 @@ export function hexToBuffer(str: string): Buffer {
   return Buffer.from(withoutHexPrefix(str), 'hex');
 }
 
+export function bufferToHex(buffer: Buffer): `0x${string}` {
+  return `0x${buffer.toString('hex')}`;
+}
+
 export function pluralize(str: string, count: number | bigint, plural?: string): string {
   return count === 1 || count === 1n ? str : plural ?? `${str}s`;
 }

package/src/testing/test_data.ts

@@ -66,7 +66,7 @@ export function updateInlineTestData(targetFileFromRepoRoot: string, itemName: s
   const logger = createConsoleLogger('aztec:testing:test_data');
   const targetFile = getPathToFile(targetFileFromRepoRoot);
   const contents = readFileSync(targetFile, 'utf8').toString();
-  const regex = new RegExp(`let ${itemName} = [\\s\\S]*?;`, 'g');
+  const regex = new RegExp(`let ${itemName} =[\\s\\S]*?;`, 'g');
   if (!regex.exec(contents)) {
     throw new Error(`Test data marker for ${itemName} not found in ${targetFile}`);
   }