@aztec/foundation 0.83.1 → 0.84.0

package/src/log/debug.ts

@@ -1,104 +0,0 @@
-import debug from 'debug';
-
-import type { LogFn } from './log_fn.js';
-
-let preLogHook: ((...args: any[]) => void) | undefined;
-let postLogHook: ((...args: any[]) => void) | undefined;
-
-/**
- * Process and handle the logging of messages through custom hooks and the given logger.
- * This function checks if the logger's namespace is enabled, executes any preLogHook functions, logs the message using the provided logger, and then executes any postLogHook functions.
- *
- * @param logger - The debug logger instance to be used for logging.
- * @param args - The arguments to be passed to the logger and any hook functions.
- */
-function theFunctionThroughWhichAllLogsPass(logger: any, ...args: any[]) {
-  if (!debug.enabled(logger.namespace)) {
-    return;
-  }
-  if (preLogHook) {
-    preLogHook(logger.namespace, ...args);
-  }
-  logger(...args);
-  if (postLogHook) {
-    postLogHook(logger.namespace, ...args);
-  }
-}
-
-/**
- * Return a logger, meant to be silent by default and verbose during debugging.
- * @param name - The module name of the logger.
- * @returns A callable log function.
- */
-export function createDebugOnlyLogger(name: string): LogFn {
-  const logger = debug(name);
-  return (...args: any[]) => theFunctionThroughWhichAllLogsPass(logger, ...args);
-}
-
-/**
- * Set a function to be called before each log message is handled by the debug logger.
- * The hook function will receive the logger namespace and any arguments passed to the logger.
- * This can be useful for adding additional context, filtering logs, or performing side-effects
- * based on logged messages.
- *
- * @param fn - The function to be called before each log message.
- */
-export function setPreDebugLogHook(fn: (...args: any[]) => void) {
-  preLogHook = fn;
-}
-
-/**
- * Set a callback function to be executed after each log is written by the debug logger.
- * This allows additional behavior or side effects to occur after a log has been written,
- * such as sending logs to external services, formatting output, or triggering events.
- *
- * @param fn - The callback function to be executed after each log. It receives the same arguments as the original log function call.
- */
-export function setPostDebugLogHook(fn: (...args: any[]) => void) {
-  postLogHook = fn;
-}
-
-/**
- * Enable logs for the specified namespace(s) or wildcard pattern(s).
- * This function activates the logging functionality for the given
- * namespace(s) or pattern(s), allowing developers to selectively display
- * debug logs that match the provided string(s).
- *
- * @param str - The namespace(s) or wildcard pattern(s) for which logs should be enabled.
- */
-export function enableLogs(str: string) {
-  debug.enable(str);
-}
-
-/**
- * Check if the logging is enabled for a given namespace.
- * The input 'str' represents the namespace for which the log status is being checked.
- * Returns true if the logging is enabled, otherwise false.
- *
- * @param str - The namespace string used to determine if logging is enabled.
- * @returns A boolean indicating whether logging is enabled for the given namespace.
- */
-export function isLogEnabled(str: string) {
-  return debug.enabled(str);
-}
-
-/**
- * Format a debug string filling in `'{0}'` entries with their
- * corresponding values from the args array, amd `'{}'` with the whole array.
- *
- * @param formatStr - str of form `'this is a string with some entries like {0} and {1}'`
- * @param args - array of fields to fill in the string format entries with
- * @returns formatted string
- */
-interface Printable {
-  toString(): string;
-}
-export function applyStringFormatting(formatStr: string, args: Printable[]): string {
-  return formatStr
-    .replace(/{(\d+)}/g, (match, index) => {
-      return typeof args[index] === 'undefined' ? match : args[index].toString();
-    })
-    .replace(/{}/g, (_match, _index) => {
-      return args.toString();
-    });
-}

package/src/log/log_history.ts

@@ -1,44 +0,0 @@
-import { setPreDebugLogHook } from './debug.js';
-
-/**
- * LogHistory is a utility class that provides the ability to store and manage debug logs.
- * It can be enabled to record logs along with their timestamps, retrieve a specified number
- * of recent logs, or clear stored logs based on a given count. This can be useful for debugging
- * purposes, monitoring application activities, and maintaining log history.
- */
-export class LogHistory {
-  private logs: any[][] = [];
-
-  /**
-   * Enables the logging of debug messages with timestamps.
-   * Hooks into the pre-debug log and stores each log entry along with its timestamp in the logs array.
-   */
-  public enable() {
-    setPreDebugLogHook((...args: any[]) => {
-      this.logs.push([new Date().toISOString(), ...args]);
-    });
-  }
-
-  /**
-   * Retrieves a specified number of logs from the end of the log history or all logs if no argument is provided.
-   * The logs are ordered chronologically, with the oldest logs at the beginning of the array.
-   *
-   * @param last - Optional number representing the amount of recent logs to return. Defaults to 0, which returns all logs.
-   * @returns An array of log arrays, each containing a timestamp and log arguments.
-   */
-  public getLogs(last = 0) {
-    return last ? this.logs.slice(-last) : this.logs;
-  }
-
-  /**
-   * Clear a specified number of logs from the beginning of the logs array.
-   * If no count is provided, it will clear all logs.
-   *
-   * @param count - The number of logs to be removed (default: total logs length).
-   */
-  public clear(count = this.logs.length) {
-    this.logs = this.logs.slice(count);
-  }
-}
-
-export const logHistory = new LogHistory();

package/src/transport/browser/index.ts

@@ -1,4 +0,0 @@
-export * from './worker_connector.js';
-export * from './worker_listener.js';
-export * from './shared_worker_connector.js';
-export * from './shared_worker_listener.js';

package/src/transport/browser/message_port_socket.ts

@@ -1,48 +0,0 @@
-import type { Socket } from '../interface/socket.js';
-
-/**
- * An implementation of a TransportSocket using MessagePorts.
- */
-export class MessagePortSocket implements Socket {
-  constructor(private port: MessagePort) {}
-
-  /**
-   * Send a message to the connected MessagePort, optionally transferring ownership of certain objects.
-   * The 'msg' parameter can be any structured data type and will be sent to the other end of the MessagePort.
-   * The optional 'transfer' parameter is an array of Transferable objects whose ownership will be transferred,
-   * making them inaccessible on the sending side. This can improve performance for large data transfers.
-   *
-   * @param msg - The message to be sent through the MessagePort.
-   * @param transfer - An optional array of Transferable objects to transfer ownership.
-   * @returns A Promise that resolves when the message has been sent.
-   */
-  send(msg: any, transfer: Transferable[] = []): Promise<void> {
-    this.port.postMessage(msg, transfer);
-    return Promise.resolve();
-  }
-
-  /**
-   * Register a callback function to handle incoming messages from the MessagePort.
-   * The provided callback will be invoked with the message data whenever a new message arrives.
-   * Note that only one callback can be registered at a time. Subsequent calls to this method
-   * will overwrite the previously registered callback.
-   *
-   * @param cb - The callback function to handle incoming messages.
-   */
-  registerHandler(cb: (msg: any) => any): void {
-    this.port.onmessage = event => cb(event.data);
-  }
-
-  /**
-   * Close the MessagePort, unregister the message handler, and send an undefined message.
-   * The 'close' function is useful for gracefully shutting down a connection between two
-   * endpoints by sending an undefined message as an indication of disconnection before
-   * closing the port. After calling this method, the MessagePortSocket instance should not
-   * be used again.
-   */
-  close() {
-    void this.send(undefined);
-    this.port.onmessage = null;
-    this.port.close();
-  }
-}

package/src/transport/browser/shared_worker_connector.ts

@@ -1,21 +0,0 @@
-import type { Connector } from '../interface/connector.js';
-import { MessagePortSocket } from './message_port_socket.js';
-
-/**
- * SharedWorkerConnector is an implementation of the Connector interface, specifically for SharedWorkers.
- * It enables the creation of MessagePortSockets that communicate with a shared worker and allow
- * multiple scripts to communicate with the worker using the same connection.
- */
-export class SharedWorkerConnector implements Connector {
-  constructor(private worker: SharedWorker) {}
-
-  /**
-   * Creates a new MessagePortSocket instance using the SharedWorker's port.
-   * This method allows for easy creation of sockets to communicate with the SharedWorker.
-   *
-   * @returns A Promise that resolves to a new MessagePortSocket instance.
-   */
-  createSocket() {
-    return Promise.resolve(new MessagePortSocket(this.worker.port));
-  }
-}

package/src/transport/browser/shared_worker_listener.ts

@@ -1,53 +0,0 @@
-import EventEmitter from 'events';
-
-import type { Listener } from '../interface/listener.js';
-import { MessagePortSocket } from './message_port_socket.js';
-
-/**
- * Represents the global scope of a Shared Worker.
- * Provides functionality to handle incoming connections and manage communication with other scripts
- * running in a shared context, enabling concurrent access and efficient resource sharing among those scripts.
- */
-declare interface SharedWorkerGlobalScope {
-  /**
-   * Event handler for new connections to the Shared Worker.
-   */
-  onconnect: (...args: any) => any;
-}
-
-/**
- * SharedWorkerListener is an extension of the EventEmitter class that implements the Listener interface.
- * It provides functionality to handle incoming messages from a shared worker and emit events for new sockets
- * created in response to these incoming connections. This class is meant to be used in the context of managing
- * MessagePort connections within the SharedWorkerGlobalScope.
- */
-export class SharedWorkerListener extends EventEmitter implements Listener {
-  constructor(private worker: SharedWorkerGlobalScope) {
-    super();
-  }
-
-  /**
-   * Initializes the shared worker listener by assigning the 'handleMessageEvent' method as the event handler
-   * for the 'onconnect' event of the SharedWorkerGlobalScope. The 'handleMessageEvent' function will be called
-   * whenever a new connection is established with the shared worker.
-   */
-  open() {
-    this.worker.onconnect = this.handleMessageEvent;
-  }
-
-  /**
-   * Closes the SharedWorkerListener by detaching the 'onconnect' event handler.
-   * This stops the listener from emitting new sockets on incoming connections.
-   */
-  close() {
-    this.worker.onconnect = () => {};
-  }
-
-  private handleMessageEvent = (event: MessageEvent) => {
-    const [port] = event.ports;
-    if (!port) {
-      return;
-    }
-    this.emit('new_socket', new MessagePortSocket(port));
-  };
-}

package/src/transport/browser/worker_connector.ts

@@ -1,30 +0,0 @@
-import type { Connector } from '../interface/connector.js';
-import { MessagePortSocket } from './message_port_socket.js';
-
-/**
- * WorkerConnector is a class implementing the Connector interface for creating communication sockets
- * with Web Workers. It allows to establish a connection with the worker and create MessagePortSockets
- * using MessageChannels, enabling seamless communication between the main thread and worker threads.
- *
- * @example
- * const worker = new Worker('./myWorker.js');
- * const connector = new WorkerConnector(worker);
- * const socket = await connector.createSocket();
- * socket.send('Hello, worker!');
- */
-export class WorkerConnector implements Connector {
-  constructor(private worker: Worker) {}
-
-  /**
-   * Creates a new MessagePortSocket instance by establishing a connection between the Worker and the main thread.
-   * A MessageChannel is created, and one of its ports is sent to the Worker using postMessage.
-   * The other port is used to create a new MessagePortSocket which is then returned as a Promise.
-   *
-   * @returns A Promise that resolves to a new MessagePortSocket instance.
-   */
-  createSocket() {
-    const channel = new MessageChannel();
-    this.worker.postMessage('', [channel.port2]);
-    return Promise.resolve(new MessagePortSocket(channel.port1));
-  }
-}

package/src/transport/browser/worker_listener.ts

@@ -1,54 +0,0 @@
-import EventEmitter from 'events';
-
-import type { Listener } from '../interface/listener.js';
-import { MessagePortSocket } from './message_port_socket.js';
-
-/**
- * Represents a DedicatedWorkerGlobalScope, which is the global execution context for a dedicated worker.
- * Provides properties and methods to manage the worker's lifecycle and communication with other threads or workers.
- */
-declare interface DedicatedWorkerGlobalScope {
-  /**
-   * Handler for incoming messages from other threads or workers.
-   */
-  onmessage: any;
-}
-
-/**
- * WorkerListener is a class that extends EventEmitter and implements the Listener interface.
- * It listens for incoming connections on a dedicated worker global scope, and emits a 'new_socket' event
- * with a MessagePortSocket instance for each new connection. This allows applications to communicate
- * with other workers or main thread through the MessagePortSocket abstraction.
- *
- * The open() method starts listening for incoming connections, while the close() method stops it.
- */
-export class WorkerListener extends EventEmitter implements Listener {
-  constructor(private worker: DedicatedWorkerGlobalScope) {
-    super();
-  }
-
-  /**
-   * Initializes the WorkerListener by setting the 'onmessage' event handler of the worker.
-   * The 'onmessage' event will be triggered when the worker receives a message, and it will then
-   * call the handleMessageEvent method to handle incoming connections.
-   */
-  open() {
-    this.worker.onmessage = this.handleMessageEvent;
-  }
-
-  /**
-   * Close the worker listener by removing the 'onmessage' event handler.
-   * This method effectively stops the WorkerListener from reacting to new incoming messages.
-   */
-  close() {
-    this.worker.onmessage = () => {};
-  }
-
-  private handleMessageEvent = (event: MessageEvent) => {
-    const [port] = event.ports;
-    if (!port) {
-      return;
-    }
-    this.emit('new_socket', new MessagePortSocket(port));
-  };
-}

package/src/wasm/README.md

@@ -1,6 +0,0 @@
-# wasm
-
-Functionality to:
-
-1.  Call WebAssembly functions
-2.  Create asynchronous workers that host webassembly.

package/src/wasm/empty_wasi_sdk.ts

@@ -1,166 +0,0 @@
-import { createDebugOnlyLogger } from '../log/index.js';
-
-/**
- * Dummy implementation of a necessary part of the wasi api:
- * https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md
- * We don't use these functions, but the environment expects them.
- * TODO find a way to update off of wasi 12.
- */
-/* eslint-disable camelcase */
-export const getEmptyWasiSdk = (debug = createDebugOnlyLogger('wasm:empty_wasi_sdk')) => ({
-  /**
-   * Retrieves the current time from the system clock.
-   * This function is a dummy implementation of the WASI API's `clock_time_get` method,
-   * which is expected by the environment but not used in this context.
-   *
-   * No input parameters or return values are required, as the purpose of this function
-   * is solely to satisfy the environment expectations and provide debugging information.
-   */
-  clock_time_get() {
-    debug('clock_time_get');
-  },
-  /**
-   * Dummy implementation of WASI's environ_get function.
-   * This function is used to obtain a snapshot of the current environment variables.
-   * In this dummy implementation, no actual actions are performed, but the debug logger logs 'environ_get' when called.
-   * Environment variables are not used in this context, so the real implementation is not required.
-   *
-   * @see https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md#environ_get
-   */
-  environ_get() {
-    debug('environ_get');
-  },
-  /**
-   * Retrieves the environment variable sizes from the WebAssembly environment.
-   * This function is part of the WASI API and provides a dummy implementation to fulfill the expected APIs.
-   * It does not have any actual functionality, but serves as a placeholder in the environment.
-   */
-  environ_sizes_get() {
-    debug('environ_sizes_get');
-  },
-  /**
-   * Closes a file descriptor, releasing any resources associated with it.
-   * This function does not perform any actual closing operation, but exists to
-   * satisfy the requirements of the WebAssembly System Interface (WASI) API,
-   * which expects certain functions to be present for compatibility purposes.
-   *
-   * @see https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md
-   */
-  fd_close() {
-    debug('fd_close');
-  },
-  /**
-   * A dummy implementation of the 'fd_read' function from the WASI API.
-   * This function is required by the environment, but not used in this context.
-   * It would normally read data from a file descriptor into an array buffer,
-   * but here it simply logs the invocation for debugging purposes.
-   */
-  fd_read() {
-    debug('fd_read');
-  },
-  /**
-   * Handles the file descriptor write operation.
-   * This dummy implementation of the WASI 'fd_write' function is part of the wasi API:
-   * https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md
-   * The environment expects this function, but it is not used in the current implementation.
-   * It is used to write data from WebAssembly memory to a file descriptor.
-   */
-  fd_write() {
-    debug('fd_write');
-  },
-  /**
-   * Perform a file seek operation on the given file descriptor to change its current position.
-   * The new position is calculated using the provided offset and whence values.
-   * Throws an error if the file descriptor is invalid or the operation cannot be performed.
-   *
-   * @param fd - The file descriptor of the file to perform the seek operation on.
-   * @param offset - The relative offset to apply, based on the whence value.
-   * @param whence - The reference point from which the offset should be calculated. One of SEEK_SET (start), SEEK_CUR (current), or SEEK_END (end).
-   * @returns The new position in the file after the seek operation has been performed.
-   */
-  fd_seek() {
-    debug('fd_seek');
-  },
-  /**
-   * This function is a dummy implementation of the 'fd_fdstat_get' function in the WebAssembly System Interface (WASI) API.
-   * Although not actually used in this context, it is present due to the environment's expectation of its existence.
-   * The 'fd_fdstat_get' function is typically responsible for obtaining file descriptor status information.
-   */
-  fd_fdstat_get() {
-    debug('fd_fdstat_get');
-  },
-  /**
-   * Sets the file descriptor flags for a given file descriptor.
-   * This function is a dummy implementation of the WASI API function 'fd_fdstat_set_flags'.
-   * It currently does not perform any operation but logs the function call with a debug instance.
-   * This is provided since the environment expects this function to be present.
-   */
-  fd_fdstat_set_flags() {
-    debug('fd_fdstat_set_flags');
-  },
-  /**
-   * Handles the `fd_prestat_get` function call for the dummy WebAssembly System Interface (WASI) implementation.
-   * This function is expected by the WASI environment, although it is not used in this implementation.
-   * The `fd_prestat_get` function retrieves pre-opened file descriptor properties.
-   *
-   * @returns A constant integer value indicating successful completion of the function call.
-   */
-  fd_prestat_get() {
-    debug('fd_prestat_get');
-    return 8;
-  },
-  /**
-   * Provides a dummy implementation for the `fd_prestat_dir_name` function, which is expected to be called by the WASI environment.
-   * This function is intended to retrieve the pre-opened directory's path associated with the given file descriptor. However, since it's a dummy implementation,
-   * it doesn't perform any actual operation and only logs the function call with the provided debug logger.
-   *
-   * @returns A constant number representing a dummy return value for the function call.
-   */
-  fd_prestat_dir_name() {
-    debug('fd_prestat_dir_name');
-    return 28;
-  },
-  /**
-   * Handles the opening of a file path within the WASI environment.
-   * This function is a dummy implementation required for compatibility with
-   * the WebAssembly System Interface (WASI) API, but it does not perform any
-   * actual file opening operation. It is mainly used for debugging purposes.
-   */
-  path_open() {
-    debug('path_open');
-  },
-  /**
-   * Retrieve file system information of the specified path.
-   * This function retrieves statistics, such as size and permissions, associated with the file or directory
-   * identified by the given path. In case of an error or non-existing path, appropriate debug logs will be generated.
-   *
-   * @returns An object containing file statistics like size, permissions, etc.
-   */
-  path_filestat_get() {
-    debug('path_filestat_get');
-  },
-  /**
-   * Terminate the process normally, performing the regular cleanup for terminating programs.
-   * The input 'status' represents the exit code and is used to indicate success or failure
-   * of the program execution. A zero value typically indicates successful execution,
-   * while non-zero values are treated as errors by the operating system.
-   *
-   * @param status - The exit code representing the success or failure of the program execution.
-   * @returns The exit status code.
-   */
-  proc_exit() {
-    debug('proc_exit');
-    return 52;
-  },
-  /**
-   * Generates a random number and returns it.
-   * This dummy implementation of 'random_get' method in the wasi API is expected by the environment.
-   * In this case, the function always returns 1 to maintain consistency with the environment's expectations.
-   *
-   * @returns A random number. In this implementation, always returns 1.
-   */
-  random_get() {
-    debug('random_get');
-    return 1;
-  },
-});

package/src/wasm/fixtures/gcd.wat

@@ -1,27 +0,0 @@
-(module
-  (func $gcd (param i32 i32) (result i32)
-    (local i32)
-    block  ;; label = @1
-      block  ;; label = @2
-        local.get 0
-        br_if 0 (;@2;)
-        local.get 1
-        local.set 2
-        br 1 (;@1;)
-      end
-      loop  ;; label = @2
-        local.get 1
-        local.get 0
-        local.tee 2
-        i32.rem_u
-        local.set 0
-        local.get 2
-        local.set 1
-        local.get 0
-        br_if 0 (;@2;)
-      end
-    end
-    local.get 2
-  )
-  (export "gcd" (func $gcd))
-)

package/src/wasm/index.ts

@@ -1 +0,0 @@
-export { WasmModule, type IWasmModule } from './wasm_module.js';