@aztec/foundation 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/config/index.ts

@@ -1,6 +1,12 @@
+import { Fq, Fr } from '../fields/fields.js';
 import type { EnvVar } from './env_var.js';
+import { type NetworkNames, getActiveNetworkName } from './network_name.js';
+import { SecretValue } from './secret_value.js';
 
-export { type EnvVar } from './env_var.js';
+export { SecretValue, getActiveNetworkName };
+export type { EnvVar, NetworkNames };
+export type { NetworkConfig, NetworkConfigMap } from './network_config.js';
+export { NetworkConfigMapSchema, NetworkConfigSchema } from './network_config.js';
 
 export interface ConfigMapping {
   env?: EnvVar;
@@ -10,6 +16,7 @@ export interface ConfigMapping {
   description: string;
   isBoolean?: boolean;
   nested?: Record<string, ConfigMapping>;
+  fallback?: EnvVar[];
 }
 
 export function isBooleanConfigValue<T>(obj: T, key: keyof T): boolean {
@@ -18,20 +25,59 @@ export function isBooleanConfigValue<T>(obj: T, key: keyof T): boolean {
 
 export type ConfigMappingsType<T> = Record<keyof T, ConfigMapping>;
 
+/**
+ * Shared utility function to get a value from environment variables with fallback support.
+ * This can be used by both getConfigFromMappings and CLI utilities.
+ *
+ * @param env - The primary environment variable name
+ * @param fallback - Optional array of fallback environment variable names
+ * @param parseFunc - Optional function to parse the environment variable value
+ * @param defaultValue - Optional default value to use if no environment variable is set
+ * @returns The parsed value from environment variables or the default value
+ */
+export function getValueFromEnvWithFallback<T>(
+  env: EnvVar | undefined,
+  parseFunc: ((val: string) => T) | undefined,
+  defaultValue: T | undefined,
+  fallback?: EnvVar[],
+): T | undefined {
+  let value: string | undefined;
+
+  // Try primary env var
+  if (env) {
+    value = process.env[env];
+  }
+
+  // If primary not found, try fallbacks
+  if (value === undefined && fallback && fallback.length > 0) {
+    for (const fallbackEnv of fallback) {
+      const fallbackVal = process.env[fallbackEnv];
+      if (fallbackVal !== undefined) {
+        value = fallbackVal;
+        break;
+      }
+    }
+  }
+
+  // Parse the value if needed
+  if (value !== undefined) {
+    return parseFunc ? parseFunc(value) : (value as unknown as T);
+  }
+
+  // Return default if no env var found
+  return defaultValue;
+}
+
 export function getConfigFromMappings<T>(configMappings: ConfigMappingsType<T>): T {
   const config = {} as T;
 
   for (const key in configMappings) {
-    const { env, parseEnv, defaultValue: def, nested } = configMappings[key];
+    const { env, parseEnv, defaultValue, nested, fallback } = configMappings[key];
     if (nested) {
       (config as any)[key] = getConfigFromMappings(nested);
     } else {
-      const val = env ? process.env[env] : undefined;
-      if (val !== undefined) {
-        (config as any)[key] = parseEnv ? parseEnv(val) : val;
-      } else if (def !== undefined) {
-        (config as any)[key] = def;
-      }
+      // Use the shared utility function
+      (config as any)[key] = getValueFromEnvWithFallback(env, parseEnv, defaultValue, fallback);
     }
   }
 
@@ -65,6 +111,25 @@ export function numberConfigHelper(defaultVal: number): Pick<ConfigMapping, 'par
   };
 }
 
+/**
+ * Generates parseEnv and default values for a numerical config value.
+ * @param defaultVal - The default numerical value to use if the environment variable is not set or is invalid
+ * @returns Object with parseEnv and default values for a numerical config value
+ */
+export function floatConfigHelper(
+  defaultVal: number,
+  validationFn?: (val: number) => void,
+): Pick<ConfigMapping, 'parseEnv' | 'defaultValue'> {
+  return {
+    parseEnv: (val: string): number => {
+      const parsed = safeParseFloat(val, defaultVal);
+      validationFn?.(parsed);
+      return parsed;
+    },
+    defaultValue: defaultVal,
+  };
+}
+
 /**
  * Generates parseEnv and default values for a numerical config value.
  * @param defaultVal - The default numerical value to use if the environment variable is not set or is invalid
@@ -97,6 +162,26 @@ export function optionalNumberConfigHelper(): Pick<ConfigMapping, 'parseEnv'> {
   };
 }
 
+/** Generates parseEnv for an enum-like config value. */
+export function enumConfigHelper<T extends string>(
+  values: T[],
+  defaultValue?: NoInfer<T>,
+): Pick<ConfigMapping, 'parseEnv' | 'defaultValue'> {
+  return {
+    parseEnv: (val: string) => {
+      const sanitizedVal = (val ?? '').trim().toLowerCase();
+      if (values.includes(sanitizedVal as T)) {
+        return sanitizedVal as T;
+      }
+      if (!val && defaultValue) {
+        return defaultValue;
+      }
+      throw new Error(`Invalid config value '${val}' (must be one of ${values.join(', ')})`);
+    },
+    defaultValue,
+  };
+}
+
 /**
  * Generates parseEnv and default values for a boolean config value.
  * @param defaultVal - The default value to use if the environment variable is not set or is invalid
@@ -114,11 +199,97 @@ export function booleanConfigHelper(
   };
 }
 
+export function secretValueConfigHelper<T>(parse: (val: string | undefined) => T): Required<
+  Pick<ConfigMapping, 'parseEnv' | 'defaultValue' | 'isBoolean'> & {
+    parseVal: (val: string) => SecretValue<T>;
+  }
+> {
+  const wrap = (val: string) => new SecretValue(parse(val));
+  return {
+    parseEnv: wrap,
+    parseVal: wrap,
+    defaultValue: new SecretValue(parse(undefined)),
+    isBoolean: true,
+  };
+}
+
 /** Parses an env var as boolean. Returns true only if value is 1, true, or TRUE. */
 export function parseBooleanEnv(val: string | undefined): boolean {
   return val !== undefined && ['1', 'true', 'TRUE'].includes(val);
 }
 
+export function secretStringConfigHelper(): Required<
+  Pick<ConfigMapping, 'parseEnv' | 'defaultValue' | 'isBoolean'> & {
+    parseVal: (val: string) => SecretValue<string | undefined>;
+  }
+>;
+export function secretStringConfigHelper(defaultValue: string): Required<
+  Pick<ConfigMapping, 'parseEnv' | 'defaultValue' | 'isBoolean'> & {
+    parseVal: (val: string) => SecretValue<string>;
+  }
+>;
+export function secretStringConfigHelper(defaultValue?: string): Required<
+  Pick<ConfigMapping, 'parseEnv' | 'defaultValue' | 'isBoolean'> & {
+    parseVal: (val: string) => SecretValue<string | typeof defaultValue>;
+  }
+> {
+  const parse = (val: string) => new SecretValue(val);
+  return {
+    parseEnv: parse,
+    parseVal: parse,
+    defaultValue: defaultValue !== undefined ? new SecretValue(defaultValue) : undefined,
+    isBoolean: true,
+  };
+}
+
+export function secretFrConfigHelper(): Required<
+  Pick<ConfigMapping, 'parseEnv' | 'defaultValue' | 'isBoolean'> & {
+    parseVal: (val: string) => SecretValue<Fr | undefined>;
+  }
+>;
+export function secretFrConfigHelper(defaultValue: Fr): Required<
+  Pick<ConfigMapping, 'parseEnv' | 'defaultValue' | 'isBoolean'> & {
+    parseVal: (val: string) => SecretValue<Fr>;
+  }
+>;
+export function secretFrConfigHelper(defaultValue?: Fr): Required<
+  Pick<ConfigMapping, 'parseEnv' | 'defaultValue' | 'isBoolean'> & {
+    parseVal: (val: string) => SecretValue<Fr | typeof defaultValue>;
+  }
+> {
+  const parse = (val: string) => new SecretValue(Fr.fromHexString(val));
+  return {
+    parseEnv: parse,
+    parseVal: parse,
+    defaultValue: defaultValue !== undefined ? new SecretValue(defaultValue) : undefined,
+    isBoolean: true,
+  };
+}
+
+export function secretFqConfigHelper(defaultValue: Fq): Required<
+  Pick<ConfigMapping, 'parseEnv' | 'defaultValue' | 'isBoolean'> & {
+    parseVal: (val: string) => SecretValue<Fq>;
+  }
+>;
+export function secretFqConfigHelper(): Required<
+  Pick<ConfigMapping, 'parseEnv' | 'defaultValue' | 'isBoolean'> & {
+    parseVal: (val: string) => SecretValue<Fq | undefined>;
+  }
+>;
+export function secretFqConfigHelper(defaultValue?: Fq): Required<
+  Pick<ConfigMapping, 'parseEnv' | 'defaultValue' | 'isBoolean'> & {
+    parseVal: (val: string) => SecretValue<Fq | typeof defaultValue>;
+  }
+> {
+  const parse = (val: string) => new SecretValue(Fq.fromHexString(val));
+  return {
+    parseEnv: parse,
+    parseVal: parse,
+    defaultValue: typeof defaultValue !== 'undefined' ? new SecretValue(defaultValue) : undefined,
+    isBoolean: true,
+  };
+}
+
 /**
  * Safely parses a number from a string.
  * If the value is not a number or is not a safe integer, the default value is returned.
@@ -131,6 +302,18 @@ function safeParseNumber(value: string, defaultValue: number): number {
   return Number.isSafeInteger(parsedValue) ? parsedValue : defaultValue;
 }
 
+/**
+ * Safely parses a floating point number from a string.
+ * If the value is not a number, the default value is returned.
+ * @param value - The string value to parse
+ * @param defaultValue - The default value to return
+ * @returns Either parsed value or default value
+ */
+function safeParseFloat(value: string, defaultValue: number): number {
+  const parsedValue = parseFloat(value);
+  return Number.isNaN(parsedValue) ? defaultValue : parsedValue;
+}
+
 /**
  * Picks specific keys from the given configuration mappings.
  *

package/src/config/network_config.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+export const NetworkConfigSchema = z
+  .object({
+    bootnodes: z.array(z.string()),
+    snapshots: z.array(z.string()),
+    registryAddress: z.string(),
+    feeAssetHandlerAddress: z.string().optional(),
+    l1ChainId: z.number(),
+  })
+  .passthrough(); // Allow additional unknown fields to pass through
+
+export const NetworkConfigMapSchema = z.record(z.string(), NetworkConfigSchema);
+
+export type NetworkConfig = z.infer<typeof NetworkConfigSchema>;
+export type NetworkConfigMap = z.infer<typeof NetworkConfigMapSchema>;

package/src/config/network_name.ts

@@ -0,0 +1,28 @@
+export type NetworkNames =
+  | 'local'
+  | 'staging-ignition'
+  | 'staging-public'
+  | 'testnet'
+  | 'mainnet'
+  | 'next-net'
+  | 'devnet';
+
+export function getActiveNetworkName(name?: string): NetworkNames {
+  const network = name || process.env.NETWORK;
+  if (!network || network === '' || network === 'local') {
+    return 'local';
+  } else if (network === 'staging-ignition') {
+    return network;
+  } else if (network === 'staging-public') {
+    return network;
+  } else if (network === 'testnet' || network === 'alpha-testnet') {
+    return 'testnet';
+  } else if (network === 'mainnet') {
+    return 'mainnet';
+  } else if (network === 'next-net') {
+    return 'next-net';
+  } else if (network === 'devnet') {
+    return 'devnet';
+  }
+  throw new Error(`Unknown network: ${network}`);
+}

package/src/config/secret_value.ts

@@ -0,0 +1,49 @@
+import { inspect } from 'util';
+import type { ZodType } from 'zod';
+
+/**
+ * A class wrapping a secret value to protect it from accidently being leaked in logs
+ */
+export class SecretValue<T> {
+  /** The secret value. Use a private member field so that it's not visible to the outside */
+  #value: T;
+
+  constructor(
+    value: T,
+    private readonly redactedValue = '[Redacted]',
+  ) {
+    this.#value = value;
+  }
+
+  /**
+   * Returns the wrapped value
+   */
+  public getValue(): T {
+    return this.#value;
+  }
+
+  /**
+   * Returns a redacted string representation of the value
+   */
+  public toString(): string {
+    return this.redactedValue;
+  }
+
+  /**
+   * Returns a redacted string representation of the value
+   */
+  public toJSON(): string {
+    return this.redactedValue;
+  }
+
+  public [inspect.custom]() {
+    return this.toString();
+  }
+
+  /**
+   * Returns a Zod schema
+   */
+  static schema<O>(valueSchema: ZodType<O, any, any>): ZodType<SecretValue<O>, any, any> {
+    return valueSchema.transform(value => new SecretValue<O>(value));
+  }
+}

package/src/crypto/aes128/index.ts

@@ -1,4 +1,4 @@
-import { BarretenbergSync, RawBuffer } from '@aztec/bb.js';
+import { BarretenbergSync } from '@aztec/bb.js';
 
 import { Buffer } from 'buffer';
 
@@ -22,10 +22,15 @@ export class Aes128 {
     paddingBuffer.fill(numPaddingBytes);
     const input = Buffer.concat([data, paddingBuffer]);
 
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    return Buffer.from(
-      api.aesEncryptBufferCbc(new RawBuffer(input), new RawBuffer(iv), new RawBuffer(key), input.length),
-    );
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.aesEncrypt({
+      plaintext: input,
+      iv,
+      key,
+      length: input.length,
+    });
+    return Buffer.from(response.ciphertext);
   }
 
   /**
@@ -37,11 +42,15 @@ export class Aes128 {
    * @returns Decrypted data.
    */
   public async decryptBufferCBCKeepPadding(data: Uint8Array, iv: Uint8Array, key: Uint8Array): Promise<Buffer> {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const paddedBuffer = Buffer.from(
-      api.aesDecryptBufferCbc(new RawBuffer(data), new RawBuffer(iv), new RawBuffer(key), data.length),
-    );
-    return paddedBuffer;
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.aesDecrypt({
+      ciphertext: data,
+      iv,
+      key,
+      length: data.length,
+    });
+    return Buffer.from(response.plaintext);
   }
 
   /**

package/src/crypto/bls/bn254_keystore.ts

@@ -0,0 +1,287 @@
+import { randomBytes } from '@aztec/foundation/crypto';
+
+import { createCipheriv, createDecipheriv, createHash, pbkdf2Sync, randomUUID } from 'crypto';
+import { readFileSync } from 'fs';
+import { z } from 'zod';
+
+/**
+ * BN254 Keystore Format
+ *
+ * Implements encryption and decryption of keystores for BN254 BLS private keys
+ * using PBKDF2 and AES-128-CTR. This format is inspired by EIP-2335 but adapted
+ * for BN254 keys rather than BLS12-381.
+ *
+ * @see https://eips.ethereum.org/EIPS/eip-2335
+ */
+
+/**
+ * Zod schema for validating BN254 keystore structure
+ */
+const bn254KeystoreSchema = z.object({
+  crypto: z.object({
+    kdf: z.object({
+      function: z.literal('pbkdf2'),
+      params: z.object({
+        dklen: z.number(),
+        c: z.number(),
+        prf: z.string(),
+        salt: z.string(),
+      }),
+      message: z.string(),
+    }),
+    checksum: z.object({
+      function: z.literal('sha256'),
+      params: z.object({}),
+      message: z.string(),
+    }),
+    cipher: z.object({
+      function: z.literal('aes-128-ctr'),
+      params: z.object({
+        iv: z.string(),
+      }),
+      message: z.string(),
+    }),
+  }),
+  description: z.string().optional(),
+  pubkey: z.string(),
+  path: z.string(),
+  uuid: z.string(),
+  version: z.number(),
+});
+
+/**
+ * Error thrown when BN254 keystore operations fail
+ */
+export class Bn254KeystoreError extends Error {
+  constructor(
+    message: string,
+    public override cause?: Error,
+  ) {
+    super(message);
+    this.name = 'Bn254KeystoreError';
+  }
+}
+
+export type Bn254Keystore = z.infer<typeof bn254KeystoreSchema>;
+
+/**
+ * The JSON structure of a BN254 keystore file.
+ * @deprecated Use the inferred type from bn254KeystoreSchema instead
+ */
+export interface Bn254KeystoreInterface {
+  crypto: {
+    kdf: {
+      function: 'pbkdf2';
+      params: {
+        dklen: number;
+        c: number;
+        prf: string;
+        salt: string;
+      };
+      message: string;
+    };
+    checksum: {
+      function: 'sha256';
+      params: Record<string, never>;
+      message: string;
+    };
+    cipher: {
+      function: 'aes-128-ctr';
+      params: {
+        iv: string;
+      };
+      message: string;
+    };
+  };
+  description: string;
+  pubkey: string;
+  path: string;
+  uuid: string;
+  version: number;
+}
+
+/**
+ * Creates a BN254 keystore object for a BN254 BLS private key.
+ *
+ * Uses PBKDF2 with SHA-256 for key derivation and AES-128-CTR for encryption,
+ * following the EIP-2335 specification format.
+ *
+ * @param password - Password for encrypting the private key
+ * @param privateKeyHex - Private key as 0x-prefixed hex string (32 bytes)
+ * @param pubkeyHex - Public key as hex string (compressed or uncompressed)
+ * @param derivationPath - BIP-44 style derivation path (e.g., "m/12381/3600/0/0/0")
+ * @returns BN254 keystore object ready to be serialized to JSON
+ * @throws Error if private key is not 32-byte hex
+ */
+export function createBn254Keystore(
+  password: string,
+  privateKeyHex: string,
+  pubkeyHex: string,
+  derivationPath: string,
+): Bn254Keystore {
+  const ensureHex = (hex: string) => hex.replace(/^0x/i, '');
+  const privHex = ensureHex(privateKeyHex);
+  if (!/^[0-9a-fA-F]{64}$/.test(privHex)) {
+    throw new Error('BLS private key must be 32-byte hex');
+  }
+
+  const salt = randomBytes(32);
+  const iv = randomBytes(16);
+  const dk = pbkdf2Sync(Buffer.from(password.normalize('NFKD'), 'utf8'), salt, 262144, 32, 'sha256');
+  const cipherKey = dk.subarray(0, 16);
+
+  const cipher = createCipheriv('aes-128-ctr', cipherKey, iv);
+  const plaintext = Buffer.from(privHex, 'hex');
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+
+  const checksum = createHash('sha256')
+    .update(Buffer.concat([dk.subarray(16, 32), ciphertext]))
+    .digest();
+
+  const uuid = randomUUID();
+
+  return {
+    crypto: {
+      kdf: {
+        function: 'pbkdf2',
+        params: { dklen: 32, c: 262144, prf: 'hmac-sha256', salt: salt.toString('hex') },
+        message: '',
+      },
+      checksum: {
+        function: 'sha256',
+        params: {},
+        message: checksum.toString('hex'),
+      },
+      cipher: {
+        function: 'aes-128-ctr',
+        params: { iv: iv.toString('hex') },
+        message: ciphertext.toString('hex'),
+      },
+    },
+    description: ensureHex(pubkeyHex),
+    pubkey: pubkeyHex,
+    path: derivationPath ?? '',
+    uuid,
+    version: 4,
+  };
+}
+
+/**
+ * Loads and validates a BN254 keystore file.
+ *
+ * @param filePath - Path to the BN254 keystore JSON file
+ * @returns Validated keystore object
+ * @throws Bn254KeystoreError if file cannot be read or validated
+ */
+export function loadBn254Keystore(filePath: string): Bn254Keystore {
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const json = JSON.parse(content);
+    return bn254KeystoreSchema.parse(json);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Bn254KeystoreError(`Invalid JSON in keystore file: ${filePath}`, error);
+    }
+    if (error && typeof error === 'object' && 'issues' in error) {
+      const issues = (error as any).issues ?? [];
+      const message = issues.map((e: any) => `${e.message} at ${e.path?.join('.') ?? 'root'}`).join('; ');
+      throw new Bn254KeystoreError(`Invalid BN254 keystore format: ${message}`);
+    }
+    throw new Bn254KeystoreError(`Failed to load keystore from ${filePath}: ${String(error)}`, error as Error);
+  }
+}
+
+/**
+ * Decrypts a BN254 BLS private key from a keystore file.
+ *
+ * @param filePath - Path to the BN254 keystore JSON file
+ * @param password - Password to decrypt the keystore
+ * @returns Decrypted private key as 0x-prefixed hex string (32 bytes)
+ * @throws Bn254KeystoreError if decryption fails or checksum is invalid
+ */
+export function decryptBn254Keystore(filePath: string, password: string): string {
+  const keystore = loadBn254Keystore(filePath);
+  return decryptBn254KeystoreFromObject(keystore, password);
+}
+
+/**
+ * Decrypts a BN254 BLS private key from a keystore object.
+ *
+ * @param keystore - BN254 keystore object
+ * @param password - Password to decrypt the keystore
+ * @returns Decrypted private key as 0x-prefixed hex string (32 bytes)
+ * @throws Bn254KeystoreError if decryption fails or checksum is invalid
+ */
+export function decryptBn254KeystoreFromObject(keystore: Bn254Keystore, password: string): string {
+  try {
+    const { crypto } = keystore;
+
+    // Only support PBKDF2 + AES-128-CTR (as per our implementation)
+    if (crypto.kdf.function !== 'pbkdf2') {
+      throw new Bn254KeystoreError(`Unsupported KDF function: ${crypto.kdf.function}`);
+    }
+    if (crypto.cipher.function !== 'aes-128-ctr') {
+      throw new Bn254KeystoreError(`Unsupported cipher function: ${crypto.cipher.function}`);
+    }
+
+    // Derive decryption key using PBKDF2
+    const salt = Buffer.from(crypto.kdf.params.salt, 'hex');
+    const dk = pbkdf2Sync(
+      Buffer.from(password.normalize('NFKD'), 'utf8'),
+      salt,
+      crypto.kdf.params.c,
+      crypto.kdf.params.dklen,
+      'sha256',
+    );
+
+    const cipherKey = dk.subarray(0, 16);
+    const checksumKey = dk.subarray(16, 32);
+
+    // Decrypt the ciphertext
+    const iv = Buffer.from(crypto.cipher.params.iv, 'hex');
+    const ciphertext = Buffer.from(crypto.cipher.message, 'hex');
+    const decipher = createDecipheriv('aes-128-ctr', cipherKey, iv);
+    const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+
+    // Verify checksum
+    const computedChecksum = createHash('sha256')
+      .update(Buffer.concat([checksumKey, ciphertext]))
+      .digest();
+    const expectedChecksum = Buffer.from(crypto.checksum.message, 'hex');
+
+    if (!computedChecksum.equals(expectedChecksum)) {
+      throw new Bn254KeystoreError('Checksum verification failed - incorrect password or corrupted keystore');
+    }
+
+    // Return as 0x-prefixed hex
+    return '0x' + decrypted.toString('hex');
+  } catch (error) {
+    if (error instanceof Bn254KeystoreError) {
+      throw error;
+    }
+    throw new Bn254KeystoreError(`Failed to decrypt keystore: ${String(error)}`, error as Error);
+  }
+}
+
+/**
+ * Validates that a decrypted private key matches the public key in the keystore.
+ *
+ * @param privateKeyHex - Decrypted private key (0x-prefixed)
+ * @param expectedPubkey - Expected public key from keystore
+ * @param computePublicKey - Function to compute public key from private key
+ * @returns true if keys match, false otherwise
+ */
+export function verifyBn254Keypair(
+  privateKeyHex: string,
+  expectedPubkey: string,
+  computePublicKey: (privateKey: string) => string,
+): boolean {
+  try {
+    const computedPubkey = computePublicKey(privateKeyHex);
+    const normalizedExpected = expectedPubkey.toLowerCase().replace(/^0x/i, '');
+    const normalizedComputed = computedPubkey.toLowerCase().replace(/^0x/i, '');
+    return normalizedExpected === normalizedComputed;
+  } catch {
+    return false;
+  }
+}