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

package/dest/log/log_history.d.ts

@@ -1,31 +0,0 @@
-/**
- * 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 declare class LogHistory {
-    private logs;
-    /**
-     * 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.
-     */
-    enable(): void;
-    /**
-     * 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.
-     */
-    getLogs(last?: number): any[][];
-    /**
-     * 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).
-     */
-    clear(count?: number): void;
-}
-export declare const logHistory: LogHistory;
-//# sourceMappingURL=log_history.d.ts.map

package/dest/log/log_history.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log_history.d.ts","sourceRoot":"","sources":["../../src/log/log_history.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAAe;IAE3B;;;OAGG;IACI,MAAM;IAMb;;;;;;OAMG;IACI,OAAO,CAAC,IAAI,SAAI;IAIvB;;;;;OAKG;IACI,KAAK,CAAC,KAAK,SAAmB;CAGtC;AAED,eAAO,MAAM,UAAU,YAAmB,CAAC"}

package/dest/log/log_history.js

@@ -1,38 +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 {
-    logs = [];
-    /**
-   * 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.
-   */ enable() {
-        setPreDebugLogHook((...args)=>{
-            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.
-   */ 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).
-   */ clear(count = this.logs.length) {
-        this.logs = this.logs.slice(count);
-    }
-}
-export const logHistory = new LogHistory();

package/dest/transport/browser/index.d.ts

@@ -1,5 +0,0 @@
-export * from './worker_connector.js';
-export * from './worker_listener.js';
-export * from './shared_worker_connector.js';
-export * from './shared_worker_listener.js';
-//# sourceMappingURL=index.d.ts.map

package/dest/transport/browser/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC"}

package/dest/transport/browser/index.js

@@ -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/dest/transport/browser/message_port_socket.d.ts

@@ -1,37 +0,0 @@
-import type { Socket } from '../interface/socket.js';
-/**
- * An implementation of a TransportSocket using MessagePorts.
- */
-export declare class MessagePortSocket implements Socket {
-    private port;
-    constructor(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>;
-    /**
-     * 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;
-    /**
-     * 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;
-}
-//# sourceMappingURL=message_port_socket.d.ts.map

package/dest/transport/browser/message_port_socket.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"message_port_socket.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/message_port_socket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD;;GAEG;AACH,qBAAa,iBAAkB,YAAW,MAAM;IAClC,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,WAAW;IAErC;;;;;;;;;OASG;IACH,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,GAAE,YAAY,EAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAK5D;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI;IAI5C;;;;;;OAMG;IACH,KAAK;CAKN"}

package/dest/transport/browser/message_port_socket.js

@@ -1,42 +0,0 @@
-/**
- * An implementation of a TransportSocket using MessagePorts.
- */ export class MessagePortSocket {
-    port;
-    constructor(port){
-        this.port = port;
-    }
-    /**
-   * 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, transfer = []) {
-        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) {
-        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/dest/transport/browser/shared_worker_connector.d.ts

@@ -1,19 +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 declare class SharedWorkerConnector implements Connector {
-    private worker;
-    constructor(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(): Promise<MessagePortSocket>;
-}
-//# sourceMappingURL=shared_worker_connector.d.ts.map

package/dest/transport/browser/shared_worker_connector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared_worker_connector.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/shared_worker_connector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;GAIG;AACH,qBAAa,qBAAsB,YAAW,SAAS;IACzC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,YAAY;IAExC;;;;;OAKG;IACH,YAAY;CAGb"}

package/dest/transport/browser/shared_worker_connector.js

@@ -1,19 +0,0 @@
-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 {
-    worker;
-    constructor(worker){
-        this.worker = worker;
-    }
-    /**
-   * 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/dest/transport/browser/shared_worker_listener.d.ts

@@ -1,38 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import EventEmitter from 'events';
-import type { Listener } from '../interface/listener.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 declare class SharedWorkerListener extends EventEmitter implements Listener {
-    private worker;
-    constructor(worker: SharedWorkerGlobalScope);
-    /**
-     * 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(): void;
-    /**
-     * Closes the SharedWorkerListener by detaching the 'onconnect' event handler.
-     * This stops the listener from emitting new sockets on incoming connections.
-     */
-    close(): void;
-    private handleMessageEvent;
-}
-export {};
-//# sourceMappingURL=shared_worker_listener.d.ts.map

package/dest/transport/browser/shared_worker_listener.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared_worker_listener.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/shared_worker_listener.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAElC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzD;;;;GAIG;AACH,OAAO,WAAW,uBAAuB;IACvC;;OAEG;IACH,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC;CAClC;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,YAAa,YAAW,QAAQ;IAC5D,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,uBAAuB;IAInD;;;;OAIG;IACH,IAAI;IAIJ;;;OAGG;IACH,KAAK;IAIL,OAAO,CAAC,kBAAkB,CAMxB;CACH"}

package/dest/transport/browser/shared_worker_listener.js

@@ -1,33 +0,0 @@
-import EventEmitter from 'events';
-import { MessagePortSocket } from './message_port_socket.js';
-/**
- * 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 {
-    worker;
-    constructor(worker){
-        super(), this.worker = worker, this.handleMessageEvent = (event)=>{
-            const [port] = event.ports;
-            if (!port) {
-                return;
-            }
-            this.emit('new_socket', new MessagePortSocket(port));
-        };
-    }
-    /**
-   * 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 = ()=>{};
-    }
-    handleMessageEvent;
-}

package/dest/transport/browser/worker_connector.d.ts

@@ -1,26 +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 declare class WorkerConnector implements Connector {
-    private worker;
-    constructor(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(): Promise<MessagePortSocket>;
-}
-//# sourceMappingURL=worker_connector.d.ts.map

package/dest/transport/browser/worker_connector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker_connector.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/worker_connector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,YAAW,SAAS;IACnC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAElC;;;;;;OAMG;IACH,YAAY;CAKb"}

package/dest/transport/browser/worker_connector.js

@@ -1,30 +0,0 @@
-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 {
-    worker;
-    constructor(worker){
-        this.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/dest/transport/browser/worker_listener.d.ts

@@ -1,39 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import EventEmitter from 'events';
-import type { Listener } from '../interface/listener.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 declare class WorkerListener extends EventEmitter implements Listener {
-    private worker;
-    constructor(worker: DedicatedWorkerGlobalScope);
-    /**
-     * 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(): void;
-    /**
-     * Close the worker listener by removing the 'onmessage' event handler.
-     * This method effectively stops the WorkerListener from reacting to new incoming messages.
-     */
-    close(): void;
-    private handleMessageEvent;
-}
-export {};
-//# sourceMappingURL=worker_listener.d.ts.map

package/dest/transport/browser/worker_listener.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker_listener.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/worker_listener.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAElC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzD;;;GAGG;AACH,OAAO,WAAW,0BAA0B;IAC1C;;OAEG;IACH,SAAS,EAAE,GAAG,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,qBAAa,cAAe,SAAQ,YAAa,YAAW,QAAQ;IACtD,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,0BAA0B;IAItD;;;;OAIG;IACH,IAAI;IAIJ;;;OAGG;IACH,KAAK;IAIL,OAAO,CAAC,kBAAkB,CAMxB;CACH"}

package/dest/transport/browser/worker_listener.js

@@ -1,35 +0,0 @@
-import EventEmitter from 'events';
-import { MessagePortSocket } from './message_port_socket.js';
-/**
- * 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 {
-    worker;
-    constructor(worker){
-        super(), this.worker = worker, this.handleMessageEvent = (event)=>{
-            const [port] = event.ports;
-            if (!port) {
-                return;
-            }
-            this.emit('new_socket', new MessagePortSocket(port));
-        };
-    }
-    /**
-   * 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 = ()=>{};
-    }
-    handleMessageEvent;
-}

package/dest/transport/dispatch/create_dispatch_fn.d.ts

@@ -1,25 +0,0 @@
-/**
- * Represents a message object for dispatching function calls.
- * Contains the function name ('fn') and an array of arguments ('args') required to call the target method.
- */
-export interface DispatchMsg {
-    /**
-     * Name of the target method to be called.
-     */
-    fn: string;
-    /**
-     * An array of arguments to be passed to the target method.
-     */
-    args: any[];
-}
-/**
- * Creates a dispatch function that calls the target's specified method with provided arguments.
- * The created dispatch function takes a DispatchMsg object as input, which contains the name of
- * the method to be called ('fn') and an array of arguments to be passed to the method ('args').
- *
- * @param targetFn - A function that returns the target object containing the methods to be dispatched.
- * @param log - Optional logging function for debugging purposes.
- * @returns A dispatch function that accepts a DispatchMsg object and calls the target's method with provided arguments.
- */
-export declare function createDispatchFn(targetFn: () => any, log?: import("../../log/pino-logger.js").Logger): ({ fn, args }: DispatchMsg) => Promise<any>;
-//# sourceMappingURL=create_dispatch_fn.d.ts.map

package/dest/transport/dispatch/create_dispatch_fn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create_dispatch_fn.d.ts","sourceRoot":"","sources":["../../../src/transport/dispatch/create_dispatch_fn.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;OAEG;IACH,IAAI,EAAE,GAAG,EAAE,CAAC;CACb;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,GAAG,4CAAsC,kBACjE,WAAW,kBAKxC"}

package/dest/transport/dispatch/create_dispatch_fn.js

@@ -1,17 +0,0 @@
-import { format } from 'util';
-import { createLogger } from '../../log/index.js';
-/**
- * Creates a dispatch function that calls the target's specified method with provided arguments.
- * The created dispatch function takes a DispatchMsg object as input, which contains the name of
- * the method to be called ('fn') and an array of arguments to be passed to the method ('args').
- *
- * @param targetFn - A function that returns the target object containing the methods to be dispatched.
- * @param log - Optional logging function for debugging purposes.
- * @returns A dispatch function that accepts a DispatchMsg object and calls the target's method with provided arguments.
- */ export function createDispatchFn(targetFn, log = createLogger('foundation:dispatch')) {
-    return async ({ fn, args })=>{
-        const target = targetFn();
-        log.debug(format(`dispatching to ${target}: ${fn}`, args));
-        return await target[fn](...args);
-    };
-}

package/dest/trees/unbalanced_merkle_tree.d.ts

@@ -1,17 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import { sha256Trunc } from '../crypto/sha256/index.js';
-/**
- * Computes the merkle root for an unbalanced tree.
- *
- * @dev Adapted from unbalanced_tree.ts.
- * Calculates the tree upwards layer by layer until we reach the root.
- * The L1 calculation instead computes the tree from right to left (slightly cheaper gas).
- * TODO: A more thorough investigation of which method is cheaper, then use that method everywhere.
- */
-export declare function computeUnbalancedMerkleRoot(leaves: Buffer[], emptyLeaf?: Buffer, hasher?: typeof sha256Trunc): Buffer;
-export declare function findLeafLevelAndIndex(numLeaves: number, leafIndex: number): {
-    level: number;
-    indexAtLevel: number;
-};
-//# sourceMappingURL=unbalanced_merkle_tree.d.ts.map

package/dest/trees/unbalanced_merkle_tree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unbalanced_merkle_tree.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_merkle_tree.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,MAAM,qBAAc,GAAG,MAAM,CAwC9G;AAgDD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;EAGzE"}

package/dest/trees/unbalanced_merkle_tree.js

@@ -1,100 +0,0 @@
-import { padArrayEnd } from '../collection/array.js';
-import { sha256Trunc } from '../crypto/sha256/index.js';
-/**
- * Computes the merkle root for an unbalanced tree.
- *
- * @dev Adapted from unbalanced_tree.ts.
- * Calculates the tree upwards layer by layer until we reach the root.
- * The L1 calculation instead computes the tree from right to left (slightly cheaper gas).
- * TODO: A more thorough investigation of which method is cheaper, then use that method everywhere.
- */ export function computeUnbalancedMerkleRoot(leaves, emptyLeaf, hasher = sha256Trunc) {
-    // Pad leaves to 2
-    if (leaves.length < 2) {
-        if (emptyLeaf === undefined) {
-            throw new Error('Cannot compute a Merkle root with less than 2 leaves');
-        } else {
-            leaves = padArrayEnd(leaves, emptyLeaf, 2);
-        }
-    }
-    const depth = Math.ceil(Math.log2(leaves.length));
-    let [layerWidth, nodeToShift] = leaves.length & 1 ? [
-        leaves.length - 1,
-        leaves[leaves.length - 1]
-    ] : [
-        leaves.length,
-        Buffer.alloc(0)
-    ];
-    // Allocate this layer's leaves and init the next layer up
-    let thisLayer = leaves.slice(0, layerWidth);
-    let nextLayer = [];
-    for(let i = 0; i < depth; i++){
-        for(let j = 0; j < layerWidth; j += 2){
-            // Store the hash of each pair one layer up
-            nextLayer[j / 2] = hasher(Buffer.concat([
-                thisLayer[j],
-                thisLayer[j + 1]
-            ]));
-        }
-        layerWidth /= 2;
-        if (layerWidth & 1) {
-            if (nodeToShift.length) {
-                // If the next layer has odd length, and we have a node that needs to be shifted up, add it here
-                nextLayer.push(nodeToShift);
-                layerWidth += 1;
-                nodeToShift = Buffer.alloc(0);
-            } else {
-                // If we don't have a node waiting to be shifted, store the next layer's final node to be shifted
-                layerWidth -= 1;
-                nodeToShift = nextLayer[layerWidth];
-            }
-        }
-        // reset the layers
-        thisLayer = nextLayer;
-        nextLayer = [];
-    }
-    // return the root
-    return thisLayer[0];
-}
-function getMaxBalancedTreeDepth(numLeaves) {
-    return Math.floor(Math.log2(numLeaves));
-}
-function getMaxUnbalancedTreeDepth(numLeaves) {
-    return Math.ceil(Math.log2(numLeaves));
-}
-function findPosition(rootLevel, leafLevel, numLeaves, indexOffset, targetIndex) {
-    if (numLeaves <= 1) {
-        // Single leaf.
-        return {
-            level: rootLevel,
-            indexAtLevel: indexOffset
-        };
-    }
-    // The largest balanced tree that can be created with the given number of leaves.
-    const maxBalancedTreeDepth = getMaxBalancedTreeDepth(numLeaves);
-    const numBalancedLeaves = 2 ** maxBalancedTreeDepth;
-    const numRemainingLeaves = numLeaves - numBalancedLeaves;
-    if (targetIndex < numBalancedLeaves) {
-        // Target is in the balanced tree.
-        // - If numRemainingLeaves is 0: this balanced tree is grown from the current root.
-        // - If numRemainingLeaves is not 0: the remaining leaves will form another tree, which will become the right child of the root.
-        //   And the balanced tree will be the left child of the root.
-        //   There will be an extra level between the root of the balanced tree and the current root.
-        const extraLevel = numRemainingLeaves ? 1 : 0;
-        return {
-            level: rootLevel + maxBalancedTreeDepth + extraLevel,
-            indexAtLevel: indexOffset + targetIndex
-        };
-    } else {
-        // Target is in the right branch.
-        const rightBranchMaxLevel = getMaxUnbalancedTreeDepth(numRemainingLeaves);
-        const shiftedUp = leafLevel - rootLevel - rightBranchMaxLevel - 1;
-        const nextLeafLevel = leafLevel - shiftedUp;
-        const newIndexOffset = indexOffset + numBalancedLeaves >> shiftedUp;
-        const shiftedTargetIndex = targetIndex - numBalancedLeaves;
-        return findPosition(rootLevel + 1, nextLeafLevel, numRemainingLeaves, newIndexOffset, shiftedTargetIndex);
-    }
-}
-export function findLeafLevelAndIndex(numLeaves, leafIndex) {
-    const maxLevel = getMaxUnbalancedTreeDepth(numLeaves);
-    return findPosition(0, maxLevel, numLeaves, 0, leafIndex);
-}