@aztec/foundation 0.0.0-test.0

package/dest/transport/node/node_listener.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import type { Listener } from '../interface/listener.js';
+/**
+ * NodeListener is an event-driven class that extends EventEmitter and implements the Listener interface.
+ * It provides methods to open and close communication with a worker thread using the NodeListenerSocket.
+ * The 'new_socket' event is emitted when a new NodeListenerSocket instance is created, allowing for
+ * efficient processing of incoming messages from the parent thread.
+ */
+export declare class NodeListener extends EventEmitter implements Listener {
+    constructor();
+    /**
+     * Opens a new connection to a parent worker thread and emits an event with the created NodeListenerSocket instance.
+     * The 'new_socket' event can be listened for, providing access to the newly created NodeListenerSocket.
+     *
+     * Fires NodeListener#new_socket.
+     */
+    open(): void;
+    /**
+     * Closes the NodeListener instance.
+     * This method currently has no implementation, as there is no need to perform any actions
+     * when closing a NodeListener. It exists for compatibility with the Listener interface.
+     */
+    close(): void;
+}
+//# sourceMappingURL=node_listener.d.ts.map

package/dest/transport/node/node_listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node_listener.d.ts","sourceRoot":"","sources":["../../../src/transport/node/node_listener.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAGlC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzD;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,YAAa,YAAW,QAAQ;;IAKhE;;;;;OAKG;IACH,IAAI;IAIJ;;;;OAIG;IACH,KAAK;CACN"}

package/dest/transport/node/node_listener.js

@@ -0,0 +1,26 @@
+import EventEmitter from 'events';
+import { parentPort } from 'worker_threads';
+import { NodeListenerSocket } from './node_listener_socket.js';
+/**
+ * NodeListener is an event-driven class that extends EventEmitter and implements the Listener interface.
+ * It provides methods to open and close communication with a worker thread using the NodeListenerSocket.
+ * The 'new_socket' event is emitted when a new NodeListenerSocket instance is created, allowing for
+ * efficient processing of incoming messages from the parent thread.
+ */ export class NodeListener extends EventEmitter {
+    constructor(){
+        super();
+    }
+    /**
+   * Opens a new connection to a parent worker thread and emits an event with the created NodeListenerSocket instance.
+   * The 'new_socket' event can be listened for, providing access to the newly created NodeListenerSocket.
+   *
+   * Fires NodeListener#new_socket.
+   */ open() {
+        this.emit('new_socket', new NodeListenerSocket(parentPort));
+    }
+    /**
+   * Closes the NodeListener instance.
+   * This method currently has no implementation, as there is no need to perform any actions
+   * when closing a NodeListener. It exists for compatibility with the Listener interface.
+   */ close() {}
+}

package/dest/transport/node/node_listener_socket.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { MessagePort } from 'worker_threads';
+import type { Socket } from '../interface/socket.js';
+/**
+ * An implementation of a TransportSocket using MessagePorts.
+ */
+export declare class NodeListenerSocket implements Socket {
+    private port;
+    constructor(port: MessagePort);
+    /**
+     * Sends a message through the MessagePort along with any provided Transferables.
+     * The transfer list allows for efficient sending of certain types of data,
+     * such as ArrayBuffer, ImageBitmap, and MessagePort.
+     * The Promise resolves once the message has been successfully sent.
+     *
+     * @param msg - The message to be sent through the MessagePort.
+     * @param transfer - An optional array of Transferable objects to be transferred.
+     * @returns A Promise that resolves once the message has been sent.
+     */
+    send(msg: any, transfer?: Transferable[]): Promise<void>;
+    /**
+     * Registers a callback function to handle incoming messages from the MessagePort.
+     * When a message is received, the provided callback function will be invoked with
+     * the received message as its argument. This method allows for efficient and
+     * dynamic handling of incoming data in a NodeListenerSocket instance.
+     *
+     * @param cb - The callback function to process incoming messages.
+     */
+    registerHandler(cb: (msg: any) => any): void;
+    /**
+     * Closes the NodeListenerSocket instance, removing all listeners and closing the underlying MessagePort.
+     * Sends an undefined message to notify any connected ports about the closure before removing event listeners
+     * and cleaning up resources. This method should be called when the socket is no longer needed to avoid memory leaks.
+     */
+    close(): void;
+}
+//# sourceMappingURL=node_listener_socket.d.ts.map

package/dest/transport/node/node_listener_socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node_listener_socket.d.ts","sourceRoot":"","sources":["../../../src/transport/node/node_listener_socket.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,gBAAgB,CAAC;AAEpE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD;;GAEG;AACH,qBAAa,kBAAmB,YAAW,MAAM;IACnC,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;;;;OAIG;IACH,KAAK;CAKN"}

package/dest/transport/node/node_listener_socket.js

@@ -0,0 +1,40 @@
+/**
+ * An implementation of a TransportSocket using MessagePorts.
+ */ export class NodeListenerSocket {
+    port;
+    constructor(port){
+        this.port = port;
+    }
+    /**
+   * Sends a message through the MessagePort along with any provided Transferables.
+   * The transfer list allows for efficient sending of certain types of data,
+   * such as ArrayBuffer, ImageBitmap, and MessagePort.
+   * The Promise resolves once the message has been successfully sent.
+   *
+   * @param msg - The message to be sent through the MessagePort.
+   * @param transfer - An optional array of Transferable objects to be transferred.
+   * @returns A Promise that resolves once the message has been sent.
+   */ send(msg, transfer = []) {
+        this.port.postMessage(msg, transfer);
+        return Promise.resolve();
+    }
+    /**
+   * Registers a callback function to handle incoming messages from the MessagePort.
+   * When a message is received, the provided callback function will be invoked with
+   * the received message as its argument. This method allows for efficient and
+   * dynamic handling of incoming data in a NodeListenerSocket instance.
+   *
+   * @param cb - The callback function to process incoming messages.
+   */ registerHandler(cb) {
+        this.port.on('message', cb);
+    }
+    /**
+   * Closes the NodeListenerSocket instance, removing all listeners and closing the underlying MessagePort.
+   * Sends an undefined message to notify any connected ports about the closure before removing event listeners
+   * and cleaning up resources. This method should be called when the socket is no longer needed to avoid memory leaks.
+   */ close() {
+        void this.send(undefined);
+        this.port.removeAllListeners();
+        this.port.close();
+    }
+}

package/dest/transport/transport_client.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import type { Connector } from './interface/connector.js';
+/**
+ * Represents a transport client for communication between TransportServer and clients.
+ * Provides request/response functionality, event handling, and multiplexing support
+ * for efficient and concurrent communication with a corresponding TransportServer.
+ */
+export interface ITransportClient<Payload> extends EventEmitter {
+    on(name: 'event_msg', handler: (payload: Payload) => void): this;
+    emit(name: 'event_msg', payload: Payload): boolean;
+}
+/**
+ * A TransportClient provides a request/response and event api to a corresponding TransportServer.
+ * If `broadcast` is called on TransportServer, TransportClients will emit an `event_msg`.
+ * The `request` method will block until a response is returned from the TransportServer's dispatch function.
+ * Request multiplexing is supported.
+ */
+export declare class TransportClient<Payload> extends EventEmitter {
+    private transportConnect;
+    private msgId;
+    private pendingRequests;
+    private socket?;
+    constructor(transportConnect: Connector);
+    /**
+     * Initializes and opens the socket connection for the TransportClient.
+     * This method creates a new Socket instance using the provided Connector,
+     * registers a handler for incoming messages, and establishes the connection.
+     * It should be called before making any requests or handling events.
+     *
+     * @throws An error if the socket is already open or there's an issue opening the connection.
+     * @returns A Promise that resolves when the socket connection is successfully opened.
+     */
+    open(): Promise<void>;
+    /**
+     * Close the transport client's socket connection and remove all event listeners.
+     * This method should be called when the client is no longer needed to ensure proper cleanup
+     * and prevent potential memory leaks. Once closed, the client cannot be reused and a new
+     * instance must be created if another connection is needed.
+     */
+    close(): void;
+    /**
+     * Sends a request to the TransportServer with the given payload and transferable objects.
+     * The method will block until a response from the TransportServer's dispatch function is returned.
+     * Request multiplexing is supported, allowing multiple requests to be sent concurrently.
+     *
+     * @param payload - The message payload to send to the server.
+     * @param transfer - An optional array of ArrayBuffer, MessagePort, or ImageBitmap objects to transfer ownership.
+     * @returns A Promise that resolves with the server's response data or rejects with an error message.
+     */
+    request(payload: Payload, transfer?: Transferable[]): Promise<any>;
+    /**
+     * Handles incoming socket messages from the TransportServer, such as ResponseMessage and EventMessage.
+     * If it's an EventMessage, emits an 'event_msg' event with the payload.
+     * If it's a ResponseMessage, resolves or rejects the corresponding pending request based on the message content.
+     *
+     * @param msg - The ResponseMessage or EventMessage received from the TransportServer, or undefined if the remote socket closed.
+     */
+    private handleSocketMessage;
+}
+//# sourceMappingURL=transport_client.d.ts.map

package/dest/transport/transport_client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport_client.d.ts","sourceRoot":"","sources":["../../src/transport/transport_client.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAKlC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAqB1D;;;;GAIG;AACH,MAAM,WAAW,gBAAgB,CAAC,OAAO,CAAE,SAAQ,YAAY;IAE7D,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAAC;IAEjE,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC;CACpD;AAED;;;;;GAKG;AACH,qBAAa,eAAe,CAAC,OAAO,CAAE,SAAQ,YAAY;IAK5C,OAAO,CAAC,gBAAgB;IAJpC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,MAAM,CAAC,CAAS;gBAEJ,gBAAgB,EAAE,SAAS;IAI/C;;;;;;;;OAQG;IACG,IAAI;IAKV;;;;;OAKG;IACH,KAAK;IAML;;;;;;;;OAQG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE;IAanD;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;CAsB5B"}

package/dest/transport/transport_client.js

@@ -0,0 +1,96 @@
+import EventEmitter from 'events';
+import { format } from 'util';
+import { createLogger } from '../log/index.js';
+import { isEventMessage } from './dispatch/messages.js';
+const log = createLogger('foundation:transport_client');
+/**
+ * A TransportClient provides a request/response and event api to a corresponding TransportServer.
+ * If `broadcast` is called on TransportServer, TransportClients will emit an `event_msg`.
+ * The `request` method will block until a response is returned from the TransportServer's dispatch function.
+ * Request multiplexing is supported.
+ */ export class TransportClient extends EventEmitter {
+    transportConnect;
+    msgId;
+    pendingRequests;
+    socket;
+    constructor(transportConnect){
+        super(), this.transportConnect = transportConnect, this.msgId = 0, this.pendingRequests = [];
+    }
+    /**
+   * Initializes and opens the socket connection for the TransportClient.
+   * This method creates a new Socket instance using the provided Connector,
+   * registers a handler for incoming messages, and establishes the connection.
+   * It should be called before making any requests or handling events.
+   *
+   * @throws An error if the socket is already open or there's an issue opening the connection.
+   * @returns A Promise that resolves when the socket connection is successfully opened.
+   */ async open() {
+        this.socket = await this.transportConnect.createSocket();
+        this.socket.registerHandler((msg)=>this.handleSocketMessage(msg));
+    }
+    /**
+   * Close the transport client's socket connection and remove all event listeners.
+   * This method should be called when the client is no longer needed to ensure proper cleanup
+   * and prevent potential memory leaks. Once closed, the client cannot be reused and a new
+   * instance must be created if another connection is needed.
+   */ close() {
+        this.socket?.close();
+        this.socket = undefined;
+        this.removeAllListeners();
+    }
+    /**
+   * Sends a request to the TransportServer with the given payload and transferable objects.
+   * The method will block until a response from the TransportServer's dispatch function is returned.
+   * Request multiplexing is supported, allowing multiple requests to be sent concurrently.
+   *
+   * @param payload - The message payload to send to the server.
+   * @param transfer - An optional array of ArrayBuffer, MessagePort, or ImageBitmap objects to transfer ownership.
+   * @returns A Promise that resolves with the server's response data or rejects with an error message.
+   */ request(payload, transfer) {
+        if (!this.socket) {
+            throw new Error('Socket not open.');
+        }
+        const msgId = this.msgId++;
+        const msg = {
+            msgId,
+            payload
+        };
+        log.debug(format(`->`, msg));
+        return new Promise((resolve, reject)=>{
+            this.pendingRequests.push({
+                resolve,
+                reject,
+                msgId
+            });
+            this.socket.send(msg, transfer).catch(reject);
+        });
+    }
+    /**
+   * Handles incoming socket messages from the TransportServer, such as ResponseMessage and EventMessage.
+   * If it's an EventMessage, emits an 'event_msg' event with the payload.
+   * If it's a ResponseMessage, resolves or rejects the corresponding pending request based on the message content.
+   *
+   * @param msg - The ResponseMessage or EventMessage received from the TransportServer, or undefined if the remote socket closed.
+   */ handleSocketMessage(msg) {
+        if (msg === undefined) {
+            // The remote socket closed.
+            this.close();
+            return;
+        }
+        log.debug(format(`<-`, msg));
+        if (isEventMessage(msg)) {
+            this.emit('event_msg', msg.payload);
+            return;
+        }
+        const reqIndex = this.pendingRequests.findIndex((r)=>r.msgId === msg.msgId);
+        if (reqIndex === -1) {
+            return;
+        }
+        const [pending] = this.pendingRequests.splice(reqIndex, 1);
+        if (msg.error) {
+            pending.reject(new Error(msg.error));
+        } else {
+            pending.resolve(msg.payload);
+        }
+    }
+}

package/dest/transport/transport_server.d.ts

@@ -0,0 +1,56 @@
+import type { Listener } from './interface/listener.js';
+/**
+ * Keeps track of clients, providing a broadcast, and request/response api with multiplexing.
+ */
+export declare class TransportServer<Payload> {
+    private listener;
+    private msgHandlerFn;
+    private sockets;
+    constructor(listener: Listener, msgHandlerFn: (msg: Payload) => Promise<any>);
+    /**
+     * Starts the TransportServer, allowing it to accept new connections and handle incoming messages.
+     * The server will listen for 'new_socket' events from the underlying listener and invoke the provided message handler function
+     * for each received message. The server remains active until the 'stop' method is called.
+     */
+    start(): void;
+    /**
+     * Stops accepting new connections. It doesn't close existing sockets.
+     * It's expected the clients will gracefully complete by closing their end, sending an `undefined` message.
+     */
+    stop(): void;
+    /**
+     * Sends a broadcast message to all connected clients.
+     * The given payload will be sent to all the clients currently connected to the TransportServer.
+     * It waits for all the messages to be sent and resolves when they are all sent successfully.
+     *
+     * @param msg - The payload to broadcast to all connected clients.
+     * @returns A Promise that resolves when all messages have been sent successfully.
+     */
+    broadcast(msg: Payload): Promise<void>;
+    /**
+     * Handles the addition of a new socket to the server by registering a message handler for the client
+     * and adding the socket to the list of active sockets. The message handler processes incoming messages
+     * from the client, including detecting client disconnection and removing the closed socket.
+     *
+     * @param socket - The new Socket instance that has connected to the server.
+     */
+    private handleNewSocket;
+    /**
+     * Detect the 'transferables' argument to our socket from our message
+     * handler return type.
+     * @param data - The compound payload data.
+     * @returns The split data and transferables.
+     */
+    private getPayloadAndTransfers;
+    /**
+     * Handles incoming socket messages, processing the request and sending back a response.
+     * This function is responsible for invoking the registered message handler function with the received
+     * payload, extracting the result and transferables, and sending a response message back to the client.
+     * In case of an error during message handling, it sends an error response with the stack trace.
+     *
+     * @param socket - The Socket instance from which the message was received.
+     * @param msg - The RequestMessage object containing the message ID and payload.
+     */
+    private handleSocketMessage;
+}
+//# sourceMappingURL=transport_server.d.ts.map

package/dest/transport/transport_server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport_server.d.ts","sourceRoot":"","sources":["../../src/transport/transport_server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAIxD;;GAEG;AACH,qBAAa,eAAe,CAAC,OAAO;IAGtB,OAAO,CAAC,QAAQ;IAAY,OAAO,CAAC,YAAY;IAF5D,OAAO,CAAC,OAAO,CAAgB;gBAEX,QAAQ,EAAE,QAAQ,EAAU,YAAY,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC;IAE5F;;;;OAIG;IACH,KAAK;IAKL;;;OAGG;IACH,IAAI;IAIJ;;;;;;;OAOG;IACG,SAAS,CAAC,GAAG,EAAE,OAAO;IAI5B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAcvB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;;;;;;OAQG;YACW,mBAAmB;CAalC"}

package/dest/transport/transport_server.js

@@ -0,0 +1,114 @@
+import { isTransferDescriptor } from './interface/transferable.js';
+/**
+ * Keeps track of clients, providing a broadcast, and request/response api with multiplexing.
+ */ export class TransportServer {
+    listener;
+    msgHandlerFn;
+    sockets;
+    constructor(listener, msgHandlerFn){
+        this.listener = listener;
+        this.msgHandlerFn = msgHandlerFn;
+        this.sockets = [];
+    }
+    /**
+   * Starts the TransportServer, allowing it to accept new connections and handle incoming messages.
+   * The server will listen for 'new_socket' events from the underlying listener and invoke the provided message handler function
+   * for each received message. The server remains active until the 'stop' method is called.
+   */ start() {
+        this.listener.on('new_socket', (client)=>this.handleNewSocket(client));
+        this.listener.open();
+    }
+    /**
+   * Stops accepting new connections. It doesn't close existing sockets.
+   * It's expected the clients will gracefully complete by closing their end, sending an `undefined` message.
+   */ stop() {
+        this.listener.close();
+    }
+    /**
+   * Sends a broadcast message to all connected clients.
+   * The given payload will be sent to all the clients currently connected to the TransportServer.
+   * It waits for all the messages to be sent and resolves when they are all sent successfully.
+   *
+   * @param msg - The payload to broadcast to all connected clients.
+   * @returns A Promise that resolves when all messages have been sent successfully.
+   */ async broadcast(msg) {
+        await Promise.all(this.sockets.map((s)=>s.send({
+                payload: msg
+            })));
+    }
+    /**
+   * Handles the addition of a new socket to the server by registering a message handler for the client
+   * and adding the socket to the list of active sockets. The message handler processes incoming messages
+   * from the client, including detecting client disconnection and removing the closed socket.
+   *
+   * @param socket - The new Socket instance that has connected to the server.
+   */ handleNewSocket(socket) {
+        socket.registerHandler(async (msg)=>{
+            if (msg === undefined) {
+                // Client socket has closed. Remove it from the list of sockets. Call close on it for any cleanup.
+                const socketIndex = this.sockets.findIndex((s)=>s === socket);
+                const [closingSocket] = this.sockets.splice(socketIndex, 1);
+                closingSocket.close();
+                return;
+            }
+            return await this.handleSocketMessage(socket, msg);
+        });
+        this.sockets.push(socket);
+    }
+    /**
+   * Detect the 'transferables' argument to our socket from our message
+   * handler return type.
+   * @param data - The compound payload data.
+   * @returns The split data and transferables.
+   */ getPayloadAndTransfers(data) {
+        if (isTransferDescriptor(data)) {
+            // We treat PayloadWithTransfers specially so that we're able to
+            // attach transferables while keeping a simple return-type based usage
+            return [
+                data.send,
+                data.transferables
+            ];
+        }
+        if (data instanceof Uint8Array) {
+            // We may want to devise a better solution to this. We maybe given a view over a non cloneable/transferrable
+            // ArrayBuffer (such as a view over wasm memory). In this case we want to take a copy, and then transfer it.
+            const respPayload = data instanceof Uint8Array && ArrayBuffer.isView(data) ? new Uint8Array(data) : data;
+            const transferables = data instanceof Uint8Array ? [
+                respPayload.buffer
+            ] : [];
+            return [
+                respPayload,
+                transferables
+            ];
+        }
+        return [
+            data,
+            []
+        ];
+    }
+    /**
+   * Handles incoming socket messages, processing the request and sending back a response.
+   * This function is responsible for invoking the registered message handler function with the received
+   * payload, extracting the result and transferables, and sending a response message back to the client.
+   * In case of an error during message handling, it sends an error response with the stack trace.
+   *
+   * @param socket - The Socket instance from which the message was received.
+   * @param msg - The RequestMessage object containing the message ID and payload.
+   */ async handleSocketMessage(socket, { msgId, payload }) {
+        try {
+            const data = await this.msgHandlerFn(payload);
+            const [respPayload, transferables] = this.getPayloadAndTransfers(data);
+            const rep = {
+                msgId,
+                payload: respPayload
+            };
+            await socket.send(rep, transferables);
+        } catch (err) {
+            const rep = {
+                msgId,
+                error: err.stack
+            };
+            await socket.send(rep);
+        }
+    }
+}

package/dest/trees/hasher.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * Defines hasher interface used by Merkle trees.
+ */
+export interface Hasher {
+    /**
+     * Hash two arrays.
+     * @param lhs - The first array.
+     * @param rhs - The second array.
+     * @returns The new 32-byte hash.
+     */
+    hash(lhs: Uint8Array, rhs: Uint8Array): Buffer;
+    /**
+     * Hashes an array of buffers.
+     * @param inputs - The array of buffers to hash.
+     * @returns The resulting 32-byte hash.
+     */
+    hashInputs(inputs: Buffer[]): Buffer;
+}
+/**
+ * Defines an async hasher interface used by Merkle trees.
+ */
+export interface AsyncHasher {
+    /**
+     * Hash two arrays.
+     * @param lhs - The first array.
+     * @param rhs - The second array.
+     * @returns The new 32-byte hash.
+     */
+    hash(lhs: Uint8Array, rhs: Uint8Array): Promise<Buffer>;
+    /**
+     * Hashes an array of buffers.
+     * @param inputs - The array of buffers to hash.
+     * @returns The resulting 32-byte hash.
+     */
+    hashInputs(inputs: Buffer[]): Promise<Buffer>;
+}
+//# sourceMappingURL=hasher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hasher.d.ts","sourceRoot":"","sources":["../../src/trees/hasher.ts"],"names":[],"mappings":";;AAAA;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,CAAC;IAE/C;;;;OAIG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAExD;;;;OAIG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC/C"}

package/dest/trees/hasher.js

@@ -0,0 +1,5 @@
+/**
+ * Defines hasher interface used by Merkle trees.
+ */ /**
+ * Defines an async hasher interface used by Merkle trees.
+ */ export { };

package/dest/trees/index.d.ts

@@ -0,0 +1,11 @@
+export * from './unbalanced_merkle_tree.js';
+export * from './unbalanced_tree_store.js';
+export * from './merkle_tree_calculator.js';
+export * from './merkle_tree.js';
+export * from './indexed_merkle_tree_calculator.js';
+export * from './indexed_merkle_tree.js';
+export * from './sibling_path.js';
+export * from './membership_witness.js';
+export * from './hasher.js';
+export * from './indexed_tree_leaf.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/trees/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC;AACjC,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC"}

package/dest/trees/index.js

@@ -0,0 +1,10 @@
+export * from './unbalanced_merkle_tree.js';
+export * from './unbalanced_tree_store.js';
+export * from './merkle_tree_calculator.js';
+export * from './merkle_tree.js';
+export * from './indexed_merkle_tree_calculator.js';
+export * from './indexed_merkle_tree.js';
+export * from './sibling_path.js';
+export * from './membership_witness.js';
+export * from './hasher.js';
+export * from './indexed_tree_leaf.js';

package/dest/trees/indexed_merkle_tree.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { IndexedTreeLeafPreimage } from './indexed_tree_leaf.js';
+import { MembershipWitness } from './membership_witness.js';
+import { MerkleTree } from './merkle_tree.js';
+/** A simple immutable indexed merkle tree container. Use a IndexedMerkleTreeCalculator to create a new instance from a set of leaves. */
+export declare class IndexedMerkleTree<T extends IndexedTreeLeafPreimage, N extends number> extends MerkleTree {
+    readonly leafPreimages: T[];
+    constructor(height: N, nodes: Buffer[], leafPreimages: T[]);
+    getLowLeaf(value: bigint): T;
+    getMembershipWitness(leafIndexOrLeaf: number | Buffer): MembershipWitness<N>;
+}
+//# sourceMappingURL=indexed_merkle_tree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"indexed_merkle_tree.d.ts","sourceRoot":"","sources":["../../src/trees/indexed_merkle_tree.ts"],"names":[],"mappings":";;AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,yIAAyI;AACzI,qBAAa,iBAAiB,CAAC,CAAC,SAAS,uBAAuB,EAAE,CAAC,SAAS,MAAM,CAAE,SAAQ,UAAU;aAC5C,aAAa,EAAE,CAAC,EAAE;gBAA9D,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAkB,aAAa,EAAE,CAAC,EAAE;IAInE,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC;IAc5B,oBAAoB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC;CASpF"}

package/dest/trees/indexed_merkle_tree.js

@@ -0,0 +1,27 @@
+import { Fr } from '../fields/index.js';
+import { assertLength } from '../serialize/index.js';
+import { MembershipWitness } from './membership_witness.js';
+import { MerkleTree } from './merkle_tree.js';
+/** A simple immutable indexed merkle tree container. Use a IndexedMerkleTreeCalculator to create a new instance from a set of leaves. */ export class IndexedMerkleTree extends MerkleTree {
+    leafPreimages;
+    constructor(height, nodes, leafPreimages){
+        super(height, nodes), this.leafPreimages = leafPreimages;
+    }
+    getLowLeaf(value) {
+        let lowLeaf;
+        this.leafPreimages.forEach((leaf)=>{
+            if (leaf.getKey() < value && (leaf.getNextKey() > value || leaf.getNextKey() == BigInt(0))) {
+                lowLeaf = leaf;
+            }
+        });
+        if (!lowLeaf) {
+            throw new Error(`Couldn't find low leaf for ${value}`);
+        }
+        return lowLeaf;
+    }
+    getMembershipWitness(leafIndexOrLeaf) {
+        const index = Buffer.isBuffer(leafIndexOrLeaf) ? this.getIndex(leafIndexOrLeaf) : leafIndexOrLeaf;
+        const siblingPath = this.getSiblingPath(index);
+        return new MembershipWitness(this.height, BigInt(index), assertLength(siblingPath.map(Fr.fromBuffer), this.height));
+    }
+}

package/dest/trees/indexed_merkle_tree_calculator.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+import type { AsyncHasher } from './hasher.js';
+import { IndexedMerkleTree } from './indexed_merkle_tree.js';
+interface LeafPreimageFactory<T extends IndexedTreeLeafPreimage> {
+    fromBuffer(buffer: Buffer): T;
+}
+/**
+ * Indexed merkle tree calculator.
+ */
+export declare class IndexedMerkleTreeCalculator<T extends IndexedTreeLeafPreimage, N extends number> {
+    private height;
+    private zeroHashes;
+    private hasher;
+    private factory;
+    private constructor();
+    static create<T extends IndexedTreeLeafPreimage, N extends number>(height: N, hasher: AsyncHasher, factory: LeafPreimageFactory<T>, zeroLeaf?: Buffer): Promise<IndexedMerkleTreeCalculator<T, N>>;
+    computeTree(values: Buffer[]): Promise<IndexedMerkleTree<T, N>>;
+    computeTreeRoot(leaves?: Buffer[]): Promise<Buffer>;
+}
+export {};
+//# sourceMappingURL=indexed_merkle_tree_calculator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"indexed_merkle_tree_calculator.d.ts","sourceRoot":"","sources":["../../src/trees/indexed_merkle_tree_calculator.ts"],"names":[],"mappings":";;AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAEvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,UAAU,mBAAmB,CAAC,CAAC,SAAS,uBAAuB;IAC7D,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,qBAAa,2BAA2B,CAAC,CAAC,SAAS,uBAAuB,EAAE,CAAC,SAAS,MAAM;IAExF,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,OAAO;IAJjB,OAAO;WAOM,MAAM,CAAC,CAAC,SAAS,uBAAuB,EAAE,CAAC,SAAS,MAAM,EACrE,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC/B,QAAQ,SAAmB;IASvB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAuC/D,eAAe,CAAC,MAAM,GAAE,MAAM,EAAO,GAAG,OAAO,CAAC,MAAM,CAAC;CAmB9D"}