@aztec/foundation 0.65.0 → 0.65.1

package/src/abi/selector.ts

@@ -2,6 +2,7 @@ import { inspect } from 'util';
 
 import { toBufferBE } from '../bigint-buffer/index.js';
 import { Fr } from '../fields/index.js';
+import { bufferToHex } from '../string/index.js';
 
 /** A selector is the first 4 bytes of the hash of a signature. */
 export abstract class Selector {
@@ -36,7 +37,7 @@ export abstract class Selector {
    * @returns The string.
    */
   toString(): string {
-    return '0x' + this.toBuffer().toString('hex');
+    return bufferToHex(this.toBuffer());
   }
 
   [inspect.custom]() {

package/src/aztec-address/index.ts

@@ -2,6 +2,7 @@
 import { inspect } from 'util';
 
 import { Fr, Point, fromBuffer } from '../fields/index.js';
+import { hexSchemaFor } from '../schemas/utils.js';
 import { type BufferReader, FieldReader } from '../serialize/index.js';
 import { TypeRegistry } from '../serialize/type_registry.js';
 import { hexToBuffer } from '../string/index.js';
@@ -133,10 +134,11 @@ export class AztecAddress {
   }
 
   toJSON() {
-    return {
-      type: 'AztecAddress',
-      value: this.toString(),
-    };
+    return this.toString();
+  }
+
+  static get schema() {
+    return hexSchemaFor(AztecAddress, AztecAddress.isAddress);
   }
 }
 

package/src/buffer/buffer32.ts

@@ -2,6 +2,8 @@ import { randomBytes } from '@aztec/foundation/crypto';
 import { type Fr } from '@aztec/foundation/fields';
 import { BufferReader, deserializeBigInt, serializeBigInt } from '@aztec/foundation/serialize';
 
+import { bufferToHex } from '../string/index.js';
+
 /**
  * A class representing a 32 byte Buffer.
  */
@@ -67,17 +69,13 @@ export class Buffer32 {
    * @returns The hex string.
    */
   public toString() {
-    return this.buffer.toString('hex');
+    return bufferToHex(this.buffer);
   }
 
   toJSON() {
     return this.toString();
   }
 
-  public to0xString(): `0x${string}` {
-    return `0x${this.buffer.toString('hex')}`;
-  }
-
   /**
    * Convert this hash to a big int.
    * @returns The big int.
@@ -117,18 +115,6 @@ export class Buffer32 {
    * @param str - The TX hash in string format.
    * @returns A new Buffer32 object.
    */
-  public static fromStringUnchecked(str: string): Buffer32 {
-    return new Buffer32(Buffer.from(str, 'hex'));
-  }
-
-  /**
-   * Converts a string into a Buffer32 object.
-   * NOTE: this method includes checks for the 0x prefix and the length of the string.
-   *       if you dont need this checks, use fromStringUnchecked instead.
-   *
-   * @param str - The TX hash in string format.
-   * @returns A new Buffer32 object.
-   */
   public static fromString(str: string): Buffer32 {
     if (str.startsWith('0x')) {
       str = str.slice(2);

package/src/config/env_var.ts

@@ -155,6 +155,7 @@ export type EnvVar =
   | 'SEQ_VIEM_POLLING_INTERVAL_MS'
   | 'WS_DB_MAP_SIZE_KB'
   | 'WS_DATA_DIRECTORY'
+  | 'WS_NUM_HISTORIC_BLOCKS'
   | 'ETHEREUM_SLOT_DURATION'
   | 'AZTEC_SLOT_DURATION'
   | 'AZTEC_EPOCH_DURATION'

package/src/crypto/poseidon/index.ts

@@ -41,6 +41,17 @@ export function poseidon2HashWithSeparator(input: Fieldable[], separator: number
   );
 }
 
+export function poseidon2HashAccumulate(input: Fieldable[]): Fr {
+  const inputFields = serializeToFields(input);
+  return Fr.fromBuffer(
+    Buffer.from(
+      BarretenbergSync.getSingleton()
+        .poseidon2HashAccumulate(inputFields.map(i => new FrBarretenberg(i.toBuffer())))
+        .toBuffer(),
+    ),
+  );
+}
+
 /**
  * Runs a Poseidon2 permutation.
  * @param input the input state. Expected to be of size 4.

package/src/eth-address/index.ts

@@ -3,8 +3,10 @@ import { inspect } from 'util';
 import { keccak256String } from '../crypto/keccak/index.js';
 import { randomBytes } from '../crypto/random/index.js';
 import { Fr } from '../fields/index.js';
+import { hexSchemaFor } from '../schemas/utils.js';
 import { BufferReader, FieldReader } from '../serialize/index.js';
 import { TypeRegistry } from '../serialize/type_registry.js';
+import { bufferToHex } from '../string/index.js';
 
 /**
  * Represents an Ethereum address as a 20-byte buffer and provides various utility methods
@@ -154,7 +156,7 @@ export class EthAddress {
    * @returns A hex-encoded string representation of the Ethereum address.
    */
   public toString() {
-    return `0x${this.buffer.toString('hex')}` as `0x${string}`;
+    return bufferToHex(this.buffer);
   }
 
   [inspect.custom]() {
@@ -226,19 +228,12 @@ export class EthAddress {
     return new EthAddress(reader.readBytes(EthAddress.SIZE_IN_BYTES));
   }
 
-  /**
-   * Friendly representation for debugging purposes.
-   * @returns A hex string representing the address.
-   */
-  toFriendlyJSON() {
+  toJSON() {
     return this.toString();
   }
 
-  toJSON() {
-    return {
-      type: 'EthAddress',
-      value: this.toString(),
-    };
+  static get schema() {
+    return hexSchemaFor(EthAddress, EthAddress.isAddress);
   }
 }
 

package/src/eth-signature/eth_signature.ts

@@ -1,6 +1,10 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import { z } from 'zod';
+
+import { hasHexPrefix, hexToBuffer } from '../string/index.js';
+
 /**Viem Signature
  *
  * A version of the Signature class that uses `0x${string}` values for r and s rather than
@@ -45,7 +49,7 @@ export class Signature {
     return new Signature(r, s, v, isEmpty);
   }
 
-  static isValid0xString(sig: `0x${string}`): boolean {
+  static isValidString(sig: `0x${string}`): boolean {
     return /^0x[0-9a-f]{129,}$/i.test(sig);
   }
 
@@ -54,10 +58,9 @@ export class Signature {
    * parsing from viem, we can expect the v value to be a u8, rather than our
    * default serialization of u32
    */
-  static from0xString(sig: `0x${string}`): Signature {
-    const buf = Buffer.from(sig.slice(2), 'hex');
+  static fromString(sig: `0x${string}`): Signature {
+    const buf = hexToBuffer(sig);
     const reader = BufferReader.asReader(buf);
-
     const r = reader.readObject(Buffer32);
     const s = reader.readObject(Buffer32);
     const v = parseInt(sig.slice(2 + 64 * 2), 16);
@@ -95,8 +98,8 @@ export class Signature {
     return this.size;
   }
 
-  to0xString(): `0x${string}` {
-    return `0x${this.r.toString()}${this.s.toString()}${this.v.toString(16)}`;
+  toString(): `0x${string}` {
+    return `0x${this.r.buffer.toString('hex')}${this.s.buffer.toString('hex')}${this.v.toString(16)}`;
   }
 
   /**
@@ -104,14 +107,22 @@ export class Signature {
    */
   toViemSignature(): ViemSignature {
     return {
-      r: this.r.to0xString(),
-      s: this.s.to0xString(),
+      r: this.r.toString(),
+      s: this.s.toString(),
       v: this.v,
       isEmpty: this.isEmpty,
     };
   }
 
   toJSON() {
-    return this.to0xString();
+    return this.toString();
+  }
+
+  static get schema() {
+    return z
+      .string()
+      .refine(hasHexPrefix, 'No hex prefix')
+      .refine(Signature.isValidString, 'Not a valid Ethereum signature')
+      .transform(Signature.fromString);
   }
 }

package/src/fields/fields.ts

@@ -4,6 +4,7 @@ import { inspect } from 'util';
 
 import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
 import { randomBytes } from '../crypto/random/index.js';
+import { hexSchemaFor } from '../schemas/utils.js';
 import { BufferReader } from '../serialize/buffer_reader.js';
 import { TypeRegistry } from '../serialize/type_registry.js';
 
@@ -300,12 +301,12 @@ export class Fr extends BaseField {
     return Fr.fromBuffer(rootBuf);
   }
 
-  // TODO(palla/schemas): Use toString instead of structured type
   toJSON() {
-    return {
-      type: 'Fr',
-      value: this.toString(),
-    };
+    return this.toString();
+  }
+
+  static get schema() {
+    return hexSchemaFor(Fr);
   }
 }
 
@@ -385,10 +386,11 @@ export class Fq extends BaseField {
   }
 
   toJSON() {
-    return {
-      type: 'Fq',
-      value: this.toString(),
-    };
+    return this.toString();
+  }
+
+  static get schema() {
+    return hexSchemaFor(Fq);
   }
 }
 

package/src/fields/point.ts

@@ -1,7 +1,9 @@
 import { toBigIntBE } from '../bigint-buffer/index.js';
 import { poseidon2Hash } from '../crypto/poseidon/index.js';
 import { randomBoolean } from '../crypto/random/index.js';
+import { hexSchemaFor } from '../schemas/utils.js';
 import { BufferReader, FieldReader, serializeToBuffer } from '../serialize/index.js';
+import { bufferToHex, hexToBuffer } from '../string/index.js';
 import { Fr } from './fields.js';
 
 /**
@@ -34,6 +36,14 @@ export class Point {
     // TODO(#7386): check if on curve
   }
 
+  toJSON() {
+    return this.toString();
+  }
+
+  static get schema() {
+    return hexSchemaFor(Point);
+  }
+
   /**
    * Generate a random Point instance.
    *
@@ -84,14 +94,14 @@ export class Point {
 
   /**
    * Create a Point instance from a hex-encoded string.
-   * The input 'address' should be prefixed with '0x' or not, and have exactly 128 hex characters representing the x and y coordinates.
+   * The input should be prefixed with '0x' or not, and have exactly 128 hex characters representing the x and y coordinates.
    * Throws an error if the input length is invalid or coordinate values are out of range.
    *
-   * @param address - The hex-encoded string representing the Point coordinates.
+   * @param str - The hex-encoded string representing the Point coordinates.
    * @returns A Point instance.
    */
-  static fromString(address: string) {
-    return this.fromBuffer(Buffer.from(address.replace(/^0x/i, ''), 'hex'));
+  static fromString(str: string) {
+    return this.fromBuffer(hexToBuffer(str));
   }
 
   /**
@@ -211,7 +221,7 @@ export class Point {
    * @returns A hex-encoded string representing the Point instance.
    */
   toString() {
-    return '0x' + this.toBuffer().toString('hex');
+    return bufferToHex(this.toBuffer());
   }
 
   /**

package/src/json-rpc/client/fetch.ts

@@ -1,4 +1,4 @@
-import { format } from 'util';
+import { format, inspect } from 'util';
 
 import { type DebugLogger, createDebugLogger } from '../../log/index.js';
 import { NoRetryError, makeBackoff, retry } from '../../retry/index.js';
@@ -25,18 +25,23 @@ export async function defaultFetch(
 ) {
   log.debug(format(`JsonRpcClient.fetch`, host, rpcMethod, '->', body));
   let resp: Response;
-  if (useApiEndpoints) {
-    resp = await fetch(`${host}/${rpcMethod}`, {
-      method: 'POST',
-      body: jsonStringify(body),
-      headers: { 'content-type': 'application/json' },
-    });
-  } else {
-    resp = await fetch(host, {
-      method: 'POST',
-      body: jsonStringify({ ...body, method: rpcMethod }),
-      headers: { 'content-type': 'application/json' },
-    });
+  try {
+    if (useApiEndpoints) {
+      resp = await fetch(`${host}/${rpcMethod}`, {
+        method: 'POST',
+        body: jsonStringify(body),
+        headers: { 'content-type': 'application/json' },
+      });
+    } else {
+      resp = await fetch(host, {
+        method: 'POST',
+        body: jsonStringify({ ...body, method: rpcMethod }),
+        headers: { 'content-type': 'application/json' },
+      });
+    }
+  } catch (err) {
+    const errorMessage = `Error fetching from host ${host} with method ${rpcMethod}: ${inspect(err)}`;
+    throw new Error(errorMessage);
   }
 
   let responseJson;

package/src/json-rpc/convert.ts

@@ -23,7 +23,9 @@ export function jsonStringify(obj: object, prettify?: boolean): string {
     (_key, value) => {
       if (typeof value === 'bigint') {
         return value.toString();
-      } else if (typeof value === 'object' && Buffer.isBuffer(value)) {
+      } else if (typeof value === 'object' && value && value.type === 'Buffer' && Array.isArray(value.data)) {
+        return Buffer.from(value.data).toString('base64');
+      } else if (typeof value === 'object' && value && Buffer.isBuffer(value)) {
         return value.toString('base64');
       } else if (typeof value === 'object' && value instanceof Map) {
         return Array.from(value.entries());

package/src/json-rpc/index.ts

@@ -1 +1 @@
-export { jsonStringify } from './convert.js';
+export { jsonStringify, jsonParseWithSchema, tryJsonStringify } from './convert.js';

package/src/schemas/schemas.ts

@@ -7,65 +7,45 @@ import { NoteSelector } from '../abi/note_selector.js';
 import { AztecAddress } from '../aztec-address/index.js';
 import { Buffer32 } from '../buffer/buffer32.js';
 import { EthAddress } from '../eth-address/index.js';
-import { Signature } from '../eth-signature/eth_signature.js';
 import { Fq, Fr } from '../fields/fields.js';
 import { Point } from '../fields/point.js';
-import { hasHexPrefix, isHex, withoutHexPrefix } from '../string/index.js';
+import { isHex, withoutHexPrefix } from '../string/index.js';
 import { type ZodFor } from './types.js';
-import { hexSchema, maybeStructuredStringSchemaFor } from './utils.js';
-
-const FrSchema = maybeStructuredStringSchemaFor('Fr', Fr, isHex);
-const FqSchema = maybeStructuredStringSchemaFor('Fq', Fq, isHex);
+import { bufferSchema, hexSchema } from './utils.js';
 
 /** Validation schemas for common types. Every schema must match its toJSON. */
 export const schemas = {
-  /** Accepts both a 0x string and a structured `{ type: EthAddress, value: '0x...' }` */
-  EthAddress: maybeStructuredStringSchemaFor('EthAddress', EthAddress, EthAddress.isAddress),
-
-  /** Accepts both a 0x string and a structured `{ type: AztecAddress, value: '0x...' }` */
-  AztecAddress: maybeStructuredStringSchemaFor('AztecAddress', AztecAddress, AztecAddress.isAddress),
+  /** Accepts a hex string. */
+  EthAddress: EthAddress.schema,
 
-  /** Accepts both a 0x string and a structured type. */
-  FunctionSelector: maybeStructuredStringSchemaFor('FunctionSelector', FunctionSelector),
+  /** Accepts a hex string. */
+  AztecAddress: AztecAddress.schema,
 
-  /** Accepts both a 0x string and a structured type. */
-  NoteSelector: maybeStructuredStringSchemaFor('NoteSelector', NoteSelector),
+  /** Accepts a hex string. */
+  FunctionSelector: FunctionSelector.schema,
 
-  /** Accepts both a 0x string and a structured type. */
-  EventSelector: maybeStructuredStringSchemaFor('EventSelector', EventSelector),
+  /** Accepts a hex string. */
+  NoteSelector: NoteSelector.schema,
 
-  /** Field element. Accepts a 0x prefixed hex string or a structured type. */
-  Fr: FrSchema,
+  /** Accepts a hex string. */
+  EventSelector: EventSelector.schema,
 
-  /** Field element. Accepts a 0x prefixed hex string or a structured type. */
-  Fq: FqSchema,
+  /** Accepts a hex string. */
+  Fr: Fr.schema,
 
-  /** Point. Serialized as 0x prefixed string or a type. */
-  Point: z
-    .object({
-      x: FrSchema,
-      y: FrSchema,
-      isInfinite: z.boolean().optional(),
-    })
-    .or(hexSchema)
-    .transform(value =>
-      typeof value === 'string' ? Point.fromString(value) : new Point(value.x, value.y, value.isInfinite ?? false),
-    ),
+  /** Accepts a hex string. */
+  Fq: Fq.schema,
 
-  /** Accepts a 0x string */
-  Signature: z
-    .string()
-    .refine(hasHexPrefix, 'No hex prefix')
-    .refine(Signature.isValid0xString, 'Not a valid Ethereum signature')
-    .transform(Signature.from0xString),
+  /** Point. Serialized as a hex string. */
+  Point: Point.schema,
 
-  /** Coerces any input to bigint */
+  /** Coerces any input to bigint. */
   BigInt: z.union([z.bigint(), z.number(), z.string()]).pipe(z.coerce.bigint()),
 
-  /** Coerces any input to integer number */
+  /** Coerces any input to integer number. */
   Integer: z.union([z.bigint(), z.number(), z.string()]).pipe(z.coerce.number().int()),
 
-  /** Coerces input to UInt32 */
+  /** Coerces input to UInt32. */
   UInt32: z.union([z.bigint(), z.number(), z.string()]).pipe(
     z.coerce
       .number()
@@ -74,31 +54,28 @@ export const schemas = {
       .max(2 ** 32 - 1),
   ),
 
-  /** Accepts a hex string as a Buffer32 type */
+  /** Accepts a hex string as a Buffer32 type. */
   Buffer32: z.string().refine(isHex, 'Not a valid hex string').transform(Buffer32.fromString),
 
-  /** Accepts a base64 string or a structured `{ type: 'Buffer', data: [byte, byte...] }` as a buffer */
-  BufferB64: z.union([
-    z
-      .string()
-      .base64()
-      .transform(data => Buffer.from(data, 'base64')),
+  /** Accepts a base64 string or an object `{ type: 'Buffer', data: [byte, byte...] }` as a buffer. */
+  Buffer: z.union([
+    bufferSchema,
     z
       .object({
         type: z.literal('Buffer'),
-        data: z.array(z.number().int().max(255)),
+        data: z.array(z.number().int().min(0).max(255)),
       })
       .transform(({ data }) => Buffer.from(data)),
   ]),
 
-  /** Accepts a hex string with optional 0x prefix as a buffer */
+  /** Accepts a hex string as a buffer. */
   BufferHex: z
     .string()
     .refine(isHex, 'Not a valid hex string')
     .transform(withoutHexPrefix)
     .transform(data => Buffer.from(data, 'hex')),
 
-  /** Hex string with an optional 0x prefix, which gets removed as part of the parsing */
+  /** Hex string with an optional 0x prefix which gets removed as part of the parsing. */
   HexString: hexSchema,
 };
 

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}`);
   }