@aztec/foundation 0.67.1 → 0.68.1

package/src/blob/index.ts

@@ -0,0 +1,152 @@
+import cKzg from 'c-kzg';
+import type { Blob as BlobBuffer } from 'c-kzg';
+
+import { poseidon2Hash, sha256 } from '../crypto/index.js';
+import { Fr } from '../fields/index.js';
+import { serializeToBuffer } from '../serialize/index.js';
+
+// Importing directly from 'c-kzg' does not work, ignoring import/no-named-as-default-member err:
+/* eslint-disable import/no-named-as-default-member */
+
+const {
+  BYTES_PER_BLOB,
+  FIELD_ELEMENTS_PER_BLOB,
+  blobToKzgCommitment,
+  computeKzgProof,
+  loadTrustedSetup,
+  verifyKzgProof,
+} = cKzg;
+
+try {
+  loadTrustedSetup();
+} catch (error: any) {
+  if (error.message.includes('trusted setup is already loaded')) {
+    // NB: The c-kzg lib has no way of checking whether the setup is loaded or not,
+    // and it throws an error if it's already loaded, even though nothing is wrong.
+    // This is a rudimentary way of ensuring we load the trusted setup if we need it.
+  } else {
+    throw new Error(error);
+  }
+}
+
+// The prefix to the EVM blobHash, defined here: https://eips.ethereum.org/EIPS/eip-4844#specification
+export const VERSIONED_HASH_VERSION_KZG = 0x01;
+
+/**
+ * A class to create, manage, and prove EVM blobs.
+ */
+export class Blob {
+  /** The blob to be broadcast on L1 in bytes form. */
+  public readonly data: BlobBuffer;
+  /** The hash of all tx effects inside the blob. Used in generating the challenge z and proving that we have included all required effects. */
+  public readonly fieldsHash: Fr;
+  /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y. */
+  public readonly challengeZ: Fr;
+  /** Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts. */
+  public readonly evaluationY: Buffer;
+  /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */
+  public readonly commitment: Buffer;
+  /** KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes). */
+  public readonly proof: Buffer;
+
+  constructor(
+    /** All fields to be broadcast in the blob. */
+    fields: Fr[],
+    /** If we want to broadcast more fields than fit into a blob, we hash those and used it as the fieldsHash across all blobs.
+     * This is much simpler and cheaper in the circuit to do, but MUST BE CHECKED before injecting here.
+     */
+    multiBlobFieldsHash?: Fr,
+  ) {
+    if (fields.length > FIELD_ELEMENTS_PER_BLOB) {
+      throw new Error(
+        `Attempted to overfill blob with ${fields.length} elements. The maximum is ${FIELD_ELEMENTS_PER_BLOB}`,
+      );
+    }
+    this.data = Buffer.concat([serializeToBuffer(fields)], BYTES_PER_BLOB);
+    // This matches the output of SpongeBlob.squeeze() in the blob circuit
+    this.fieldsHash = multiBlobFieldsHash ? multiBlobFieldsHash : poseidon2Hash(fields);
+    this.commitment = Buffer.from(blobToKzgCommitment(this.data));
+    this.challengeZ = poseidon2Hash([this.fieldsHash, ...this.commitmentToFields()]);
+    const res = computeKzgProof(this.data, this.challengeZ.toBuffer());
+    if (!verifyKzgProof(this.commitment, this.challengeZ.toBuffer(), res[1], res[0])) {
+      throw new Error(`KZG proof did not verify.`);
+    }
+    this.proof = Buffer.from(res[0]);
+    this.evaluationY = Buffer.from(res[1]);
+  }
+
+  // 48 bytes encoded in fields as [Fr, Fr] = [0->31, 31->48]
+  commitmentToFields(): [Fr, Fr] {
+    return [new Fr(this.commitment.subarray(0, 31)), new Fr(this.commitment.subarray(31, 48))];
+  }
+
+  // Returns ethereum's versioned blob hash, following kzg_to_versioned_hash: https://eips.ethereum.org/EIPS/eip-4844#helpers
+  getEthVersionedBlobHash(): Buffer {
+    const hash = sha256(this.commitment);
+    hash[0] = VERSIONED_HASH_VERSION_KZG;
+    return hash;
+  }
+
+  static getEthVersionedBlobHash(commitment: Buffer): Buffer {
+    const hash = sha256(commitment);
+    hash[0] = VERSIONED_HASH_VERSION_KZG;
+    return hash;
+  }
+
+  // Returns a proof of opening of the blob to verify on L1 using the point evaluation precompile:
+  //  * input[:32]     - versioned_hash
+  //  * input[32:64]   - z
+  //  * input[64:96]   - y
+  //  * input[96:144]  - commitment C
+  //  * input[144:192] - proof (a commitment to the quotient polynomial q(X))
+  // See https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
+  getEthBlobEvaluationInputs(): `0x${string}` {
+    const buf = Buffer.concat([
+      this.getEthVersionedBlobHash(),
+      this.challengeZ.toBuffer(),
+      this.evaluationY,
+      this.commitment,
+      this.proof,
+    ]);
+    return `0x${buf.toString('hex')}`;
+  }
+
+  static getEthBlobEvaluationInputs(blobs: Blob[]): `0x${string}` {
+    let buf = Buffer.alloc(0);
+    blobs.forEach(blob => {
+      buf = Buffer.concat([
+        buf,
+        blob.getEthVersionedBlobHash(),
+        blob.challengeZ.toBuffer(),
+        blob.evaluationY,
+        blob.commitment,
+        blob.proof,
+      ]);
+    });
+    // For multiple blobs, we prefix the number of blobs:
+    const lenBuf = Buffer.alloc(1);
+    lenBuf.writeUint8(blobs.length);
+    buf = Buffer.concat([lenBuf, buf]);
+    return `0x${buf.toString('hex')}`;
+  }
+
+  static getViemKzgInstance() {
+    return {
+      blobToKzgCommitment: cKzg.blobToKzgCommitment,
+      computeBlobKzgProof: cKzg.computeBlobKzgProof,
+    };
+  }
+
+  // Returns as many blobs as we require to broadcast the given fields
+  // Assumes we share the fields hash between all blobs
+  static getBlobs(fields: Fr[]): Blob[] {
+    const numBlobs = Math.max(Math.ceil(fields.length / FIELD_ELEMENTS_PER_BLOB), 1);
+    const multiBlobFieldsHash = poseidon2Hash(fields);
+    const res = [];
+    for (let i = 0; i < numBlobs; i++) {
+      const end = fields.length < (i + 1) * FIELD_ELEMENTS_PER_BLOB ? fields.length : (i + 1) * FIELD_ELEMENTS_PER_BLOB;
+      res.push(new Blob(fields.slice(i * FIELD_ELEMENTS_PER_BLOB, end), multiBlobFieldsHash));
+    }
+    return res;
+  }
+}

package/src/config/env_var.ts

@@ -52,6 +52,7 @@ export type EnvVar =
   | 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS'
   | 'INBOX_CONTRACT_ADDRESS'
   | 'L1_CHAIN_ID'
+  | 'L1_CONSENSUS_CLIENT_URL'
   | 'L1_PRIVATE_KEY'
   | 'L2_QUEUE_SIZE'
   | 'LOG_ELAPSED_TIME'
@@ -125,7 +126,6 @@ export type EnvVar =
   | 'PROVER_REAL_PROOFS'
   | 'PROVER_REQUIRED_CONFIRMATIONS'
   | 'PROVER_TEST_DELAY_MS'
-  | 'PROVER_CACHE_DIR'
   | 'PXE_L2_STARTING_BLOCK'
   | 'PXE_PROVER_ENABLED'
   | 'QUOTE_PROVIDER_BASIS_POINT_FEE'
@@ -136,17 +136,15 @@ export type EnvVar =
   | 'REGISTRY_CONTRACT_ADDRESS'
   | 'ROLLUP_CONTRACT_ADDRESS'
   | 'SEQ_ALLOWED_SETUP_FN'
-  | 'SEQ_ALLOWED_TEARDOWN_FN'
   | 'SEQ_MAX_BLOCK_SIZE_IN_BYTES'
-  | 'SEQ_MAX_SECONDS_BETWEEN_BLOCKS'
   | 'SEQ_MAX_TX_PER_BLOCK'
-  | 'SEQ_MIN_SECONDS_BETWEEN_BLOCKS'
   | 'SEQ_MIN_TX_PER_BLOCK'
   | 'SEQ_PUBLISH_RETRY_INTERVAL_MS'
   | 'SEQ_PUBLISHER_PRIVATE_KEY'
   | 'SEQ_REQUIRED_CONFIRMATIONS'
   | 'SEQ_TX_POLLING_INTERVAL_MS'
   | 'SEQ_ENFORCE_TIME_TABLE'
+  | 'SEQ_MAX_L1_TX_INCLUSION_TIME_INTO_SLOT'
   | 'STAKING_ASSET_CONTRACT_ADDRESS'
   | 'REWARD_DISTRIBUTOR_CONTRACT_ADDRESS'
   | 'TELEMETRY'
@@ -184,6 +182,7 @@ export type EnvVar =
   | 'L1_TX_MONITOR_CHECK_INTERVAL_MS'
   | 'L1_TX_MONITOR_STALL_TIME_MS'
   | 'L1_TX_MONITOR_TX_TIMEOUT_MS'
+  | 'L1_TX_PROPAGATION_MAX_QUERY_ATTEMPTS'
   | 'FAUCET_MNEMONIC_ACCOUNT_INDEX'
   | 'FAUCET_ETH_AMOUNT'
   | 'FAUCET_INTERVAL_MS'

package/src/index.ts

@@ -3,6 +3,7 @@ export * as abi from './abi/index.js';
 export * as asyncMap from './async-map/index.js';
 export * as aztecAddress from './aztec-address/index.js';
 export * as bigintBuffer from './bigint-buffer/index.js';
+export * as blob from './blob/index.js';
 export * as collection from './collection/index.js';
 export * as committable from './committable/index.js';
 export * as crypto from './crypto/index.js';

package/src/log/pino-logger.ts

@@ -69,7 +69,46 @@ const [logLevel, logFilters] = parseEnv(process.env.LOG_LEVEL, defaultLogLevel);
 
 // Define custom logging levels for pino.
 const customLevels = { verbose: 25 };
-const pinoOpts = { customLevels, useOnlyCustomLevels: false, level: logLevel };
+
+// inspired by https://github.com/pinojs/pino/issues/726#issuecomment-605814879
+const levelToSeverityFormatter = (label: string, level: number): object => {
+  // Severity labels https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
+  let severity: string;
+
+  switch (label as pino.Level | keyof typeof customLevels) {
+    case 'trace':
+    case 'debug':
+      severity = 'DEBUG';
+      break;
+    case 'verbose':
+    case 'info':
+      severity = 'INFO';
+      break;
+    case 'warn':
+      severity = 'WARNING';
+      break;
+    case 'error':
+      severity = 'ERROR';
+      break;
+    case 'fatal':
+      severity = 'CRITICAL';
+      break;
+    default:
+      severity = 'DEFAULT';
+      break;
+  }
+
+  return { severity, level };
+};
+
+const pinoOpts: pino.LoggerOptions<keyof typeof customLevels> = {
+  customLevels,
+  useOnlyCustomLevels: false,
+  level: logLevel,
+  formatters: {
+    level: levelToSeverityFormatter,
+  },
+};
 
 export const levels = {
   labels: { ...pino.levels.labels, ...Object.fromEntries(Object.entries(customLevels).map(e => e.reverse())) },
@@ -83,7 +122,7 @@ export const pinoPrettyOpts = {
   destination: 2,
   sync: true,
   colorize: useColor,
-  ignore: 'module,pid,hostname,trace_id,span_id,trace_flags',
+  ignore: 'module,pid,hostname,trace_id,span_id,trace_flags,severity',
   messageFormat: `${bold('{module}')} ${reset('{msg}')}`,
   customLevels: 'fatal:60,error:50,warn:40,info:30,verbose:25,debug:20,trace:10',
   customColors: 'fatal:bgRed,error:red,warn:yellow,info:green,verbose:magenta,debug:blue,trace:gray',

package/src/promise/running-promise.ts

@@ -1,3 +1,4 @@
+import { createLogger } from '../log/pino-logger.js';
 import { InterruptibleSleep } from '../sleep/index.js';
 import { type PromiseWithResolvers, promiseWithResolvers } from './utils.js';
 
@@ -12,7 +13,11 @@ export class RunningPromise {
   private interruptibleSleep = new InterruptibleSleep();
   private requested: PromiseWithResolvers<void> | undefined = undefined;
 
-  constructor(private fn: () => void | Promise<void>, private pollingIntervalMS = 10000) {}
+  constructor(
+    private fn: () => void | Promise<void>,
+    private logger = createLogger('running-promise'),
+    private pollingIntervalMS = 10000,
+  ) {}
 
   /**
    * Starts the running promise.
@@ -23,7 +28,11 @@ export class RunningPromise {
     const poll = async () => {
       while (this.running) {
         const hasRequested = this.requested !== undefined;
-        await this.fn();
+        try {
+          await this.fn();
+        } catch (err) {
+          this.logger.error('Error in running promise', err);
+        }
 
         // If an immediate run had been requested *before* the function started running, resolve the request.
         if (hasRequested) {

package/src/retry/index.ts

@@ -64,7 +64,7 @@ export async function retry<Result>(
         throw err;
       }
       log.verbose(`${name} failed. Will retry in ${s}s...`);
-      !failSilently && log.error(err);
+      !failSilently && log.error(`Error while retrying ${name}`, err);
       await sleep(s * 1000);
       continue;
     }

package/src/serialize/field_reader.ts

@@ -140,4 +140,12 @@ export class FieldReader {
   }): T {
     return deserializer.fromFields(this);
   }
+
+  /**
+   * Returns whether the reader has finished reading all fields.
+   * @returns A bool.
+   */
+  public isFinished(): boolean {
+    return this.index === this.length;
+  }
 }

package/src/sleep/index.ts

@@ -70,6 +70,6 @@ export class InterruptibleSleep {
  * @param returnValue - The return value of the promise.
  * @returns A Promise that resolves after the specified duration, allowing the use of 'await' to pause execution.
  */
-export function sleep<T>(ms: number, returnValue?: T): Promise<T | undefined> {
-  return new Promise(resolve => setTimeout(() => resolve(returnValue), ms));
+export function sleep<T>(ms: number, returnValue?: T): Promise<T> {
+  return new Promise(resolve => setTimeout(() => resolve(returnValue as T), ms));
 }

package/src/string/index.ts

@@ -25,3 +25,7 @@ export function pluralize(str: string, count: number | bigint, plural?: string):
 export function count(count: number | bigint, str: string, plural?: string): string {
   return `${count} ${pluralize(str, count, plural)}`;
 }
+
+export function truncate(str: string, length: number = 64): string {
+  return str.length > length ? str.slice(0, length) + '...' : str;
+}

package/src/testing/files/index.ts

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+
+import { createConsoleLogger } from '../../log/console.js';
+import { fileURLToPath } from '../../url/index.js';
+import { isGenerateTestDataEnabled } from '../test_data.js';
+
+/** Writes the contents specified to the target file if test data generation is enabled. */
+export function writeTestData(targetFileFromRepoRoot: string, contents: string | Buffer) {
+  if (!isGenerateTestDataEnabled()) {
+    return;
+  }
+  const targetFile = getPathToFile(targetFileFromRepoRoot);
+  const toWrite = typeof contents === 'string' ? contents : contents.toString('hex');
+  writeFileSync(targetFile, toWrite);
+  const logger = createConsoleLogger('aztec:testing:test_data');
+  logger(`Wrote test data to ${targetFile}`);
+}
+
+/**
+ * Looks for a variable assignment in the target file and updates the value, only if test data generation is enabled.
+ * Note that a magic inline comment would be a cleaner approach, like `/* TEST-DATA-START *\/` and `/* TEST-DATA-END *\/`,
+ * but running nargo fmt on it panics since the comment would be erased, so we roll with this for now.
+ * @remarks Requires AZTEC_GENERATE_TEST_DATA=1 to be set
+ */
+export function updateInlineTestData(targetFileFromRepoRoot: string, itemName: string, value: string) {
+  if (!isGenerateTestDataEnabled()) {
+    return;
+  }
+  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');
+  if (!regex.exec(contents)) {
+    throw new Error(`Test data marker for ${itemName} not found in ${targetFile}`);
+  }
+
+  const updatedContents = contents.replaceAll(regex, `let ${itemName} = ${value};`);
+  writeFileSync(targetFile, updatedContents);
+  logger(`Updated test data in ${targetFile} for ${itemName} to ${value}`);
+}
+
+/**
+ * Updates the sample Prover.toml files in noir-projects/noir-protocol-circuits/crates/.
+ * @remarks Requires AZTEC_GENERATE_TEST_DATA=1 & generateProtocolCircuitTestData=true to be set
+ * To re-gen, run 'AZTEC_GENERATE_TEST_DATA=1 FAKE_PROOFS=1 yarn workspace @aztec/end-to-end test full.test'
+ */
+export function updateProtocolCircuitSampleInputs(circuitName: string, value: string) {
+  const logger = createConsoleLogger('aztec:testing:test_data');
+  const targetFileFromRepoRoot = `noir-projects/noir-protocol-circuits/crates/${circuitName}/Prover.toml`;
+  const targetFile = getPathToFile(targetFileFromRepoRoot);
+  writeFileSync(targetFile, value);
+  logger(`Updated test data in ${targetFile} for ${circuitName}`);
+}
+
+function getPathToFile(targetFileFromRepoRoot: string) {
+  const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../../');
+  if (!existsSync(join(repoRoot, 'CODEOWNERS'))) {
+    throw new Error(`Path to repo root is incorrect (got ${repoRoot})`);
+  }
+
+  return join(repoRoot, targetFileFromRepoRoot);
+}

package/src/testing/index.ts

@@ -1,3 +1,3 @@
-export * from './test_data.js';
 export * from './snapshot_serializer.js';
 export * from './port_allocator.js';
+export * from './test_data.js';

package/src/testing/test_data.ts

@@ -1,25 +1,10 @@
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join, resolve } from 'path';
-
-import { createConsoleLogger } from '../log/console.js';
-import { fileURLToPath } from '../url/index.js';
-
 const testData: { [key: string]: unknown[] } = {};
-let generateProtocolCircuitTestData = false;
 
 /** Returns whether test data generation is enabled */
 export function isGenerateTestDataEnabled() {
   return ['1', 'true'].includes(process.env.AZTEC_GENERATE_TEST_DATA ?? '') && typeof expect !== 'undefined';
 }
 
-/**
- * This is separate so Prover.tomls don't get edited everytime any test is run,
- * Only full.test updates prover tomls, then switches this off.
- */
-export function switchGenerateProtocolCircuitTestData() {
-  generateProtocolCircuitTestData = !generateProtocolCircuitTestData;
-}
-
 /** Pushes test data with the given name, only if test data generation is enabled. */
 export function pushTestData<T>(itemName: string, data: T) {
   if (!isGenerateTestDataEnabled()) {
@@ -49,63 +34,3 @@ export function getTestData(itemName: string): unknown[] {
   const fullItemName = `${testName} ${itemName}`;
   return testData[fullItemName];
 }
-
-/** Writes the contents specified to the target file if test data generation is enabled. */
-export function writeTestData(targetFileFromRepoRoot: string, contents: string | Buffer) {
-  if (!isGenerateTestDataEnabled()) {
-    return;
-  }
-  const targetFile = getPathToFile(targetFileFromRepoRoot);
-  const toWrite = typeof contents === 'string' ? contents : contents.toString('hex');
-  writeFileSync(targetFile, toWrite);
-  const logger = createConsoleLogger('aztec:testing:test_data');
-  logger(`Wrote test data to ${targetFile}`);
-}
-
-/**
- * Looks for a variable assignment in the target file and updates the value, only if test data generation is enabled.
- * Note that a magic inline comment would be a cleaner approach, like `/* TEST-DATA-START *\/` and `/* TEST-DATA-END *\/`,
- * but running nargo fmt on it panics since the comment would be erased, so we roll with this for now.
- * @remarks Requires AZTEC_GENERATE_TEST_DATA=1 to be set
- */
-export function updateInlineTestData(targetFileFromRepoRoot: string, itemName: string, value: string) {
-  if (!isGenerateTestDataEnabled()) {
-    return;
-  }
-  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');
-  if (!regex.exec(contents)) {
-    throw new Error(`Test data marker for ${itemName} not found in ${targetFile}`);
-  }
-
-  const updatedContents = contents.replaceAll(regex, `let ${itemName} = ${value};`);
-  writeFileSync(targetFile, updatedContents);
-  logger(`Updated test data in ${targetFile} for ${itemName} to ${value}`);
-}
-
-/**
- * Updates the sample Prover.toml files in noir-projects/noir-protocol-circuits/crates/.
- * @remarks Requires AZTEC_GENERATE_TEST_DATA=1 & generateProtocolCircuitTestData=true to be set
- * To re-gen, run 'AZTEC_GENERATE_TEST_DATA=1 FAKE_PROOFS=1 yarn workspace @aztec/end-to-end test full.test'
- */
-export function updateProtocolCircuitSampleInputs(circuitName: string, value: string) {
-  if (!isGenerateTestDataEnabled() || !generateProtocolCircuitTestData) {
-    return;
-  }
-  const logger = createConsoleLogger('aztec:testing:test_data');
-  const targetFileFromRepoRoot = `noir-projects/noir-protocol-circuits/crates/${circuitName}/Prover.toml`;
-  const targetFile = getPathToFile(targetFileFromRepoRoot);
-  writeFileSync(targetFile, value);
-  logger(`Updated test data in ${targetFile} for ${circuitName}`);
-}
-
-function getPathToFile(targetFileFromRepoRoot: string) {
-  const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../');
-  if (!existsSync(join(repoRoot, 'CODEOWNERS'))) {
-    throw new Error(`Path to repo root is incorrect (got ${repoRoot})`);
-  }
-
-  return join(repoRoot, targetFileFromRepoRoot);
-}

package/src/timer/date.ts

@@ -0,0 +1,24 @@
+import { createLogger } from '../log/pino-logger.js';
+
+/** Returns current datetime. */
+export class DateProvider {
+  public now(): number {
+    return Date.now();
+  }
+}
+
+/** Returns current datetime and allows to override it. */
+export class TestDateProvider implements DateProvider {
+  private offset = 0;
+
+  constructor(private readonly logger = createLogger('foundation:test-date-provider')) {}
+
+  public now(): number {
+    return Date.now() + this.offset;
+  }
+
+  public setTime(timeMs: number) {
+    this.offset = timeMs - Date.now();
+    this.logger.warn(`Time set to ${new Date(timeMs).toISOString()}`, { offset: this.offset, timeMs });
+  }
+}

package/src/timer/index.ts

@@ -1,3 +1,4 @@
-export { TimeoutTask, executeTimeoutWithCustomError } from './timeout.js';
-export { Timer } from './timer.js';
+export * from './date.js';
 export { elapsed, elapsedSync } from './elapsed.js';
+export { TimeoutTask, executeTimeout } from './timeout.js';
+export { Timer } from './timer.js';

package/src/timer/timeout.ts

@@ -1,3 +1,5 @@
+import { TimeoutError } from '../error/index.js';
+
 /**
  * TimeoutTask class creates an instance for managing and executing a given asynchronous function with a specified timeout duration.
  * The task will be automatically interrupted if it exceeds the given timeout duration, and will throw a custom error message.
@@ -10,14 +12,9 @@ export class TimeoutTask<T> {
   private interrupt = () => {};
   private totalTime = 0;
 
-  constructor(
-    private fn: () => Promise<T>,
-    private timeout = 0,
-    fnName = '',
-    error = () => new Error(`Timeout${fnName ? ` running ${fnName}` : ''} after ${timeout}ms.`),
-  ) {
+  constructor(private fn: () => Promise<T>, private timeout: number, errorFn: () => any) {
     this.interruptPromise = new Promise<T>((_, reject) => {
-      this.interrupt = () => reject(error());
+      this.interrupt = () => reject(errorFn());
     });
   }
 
@@ -63,17 +60,11 @@ export class TimeoutTask<T> {
   }
 }
 
-export const executeTimeout = async <T>(fn: () => Promise<T>, timeout = 0, fnName = '') => {
-  const task = new TimeoutTask(fn, timeout, fnName);
-  return await task.exec();
-};
-
-export const executeTimeoutWithCustomError = async <T>(
-  fn: () => Promise<T>,
-  timeout = 0,
-  error = () => new Error('No custom error provided'),
-  fnName = '',
-) => {
-  const task = new TimeoutTask(fn, timeout, fnName, error);
+export async function executeTimeout<T>(fn: () => Promise<T>, timeout: number, errorOrFnName?: string | (() => any)) {
+  const errorFn =
+    typeof errorOrFnName === 'function'
+      ? errorOrFnName
+      : () => new TimeoutError(`Timeout running ${errorOrFnName ?? 'function'} after ${timeout}ms.`);
+  const task = new TimeoutTask(fn, timeout, errorFn);
   return await task.exec();
-};
+}