@aztec/foundation 0.0.0-test.0

package/src/transport/transport_client.ts

@@ -0,0 +1,131 @@
+import EventEmitter from 'events';
+import { format } from 'util';
+
+import { createLogger } from '../log/index.js';
+import { type EventMessage, type ResponseMessage, isEventMessage } from './dispatch/messages.js';
+import type { Connector } from './interface/connector.js';
+import type { Socket } from './interface/socket.js';
+
+const log = createLogger('foundation:transport_client');
+
+/**
+ * Represents a pending request in the TransportClient.
+ * Contains information about the message ID, and resolve/reject functions for handling responses.
+ * Used to track and manage asynchronous request/response communication with the TransportServer.
+ */
+interface PendingRequest {
+  /**
+   * The unique message identifier used for tracking and matching request/response pairs.
+   */
+  msgId: number;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  resolve(data: any): void;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  reject(error: Error): void;
+}
+
+/**
+ * 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 {
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  on(name: 'event_msg', handler: (payload: Payload) => void): this;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  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 class TransportClient<Payload> extends EventEmitter {
+  private msgId = 0;
+  private pendingRequests: PendingRequest[] = [];
+  private socket?: Socket;
+
+  constructor(private transportConnect: Connector) {
+    super();
+  }
+
+  /**
+   * 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: Payload, transfer?: Transferable[]) {
+    if (!this.socket) {
+      throw new Error('Socket not open.');
+    }
+    const msgId = this.msgId++;
+    const msg = { msgId, payload };
+    log.debug(format(`->`, msg));
+    return new Promise<any>((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.
+   */
+  private handleSocketMessage(msg: ResponseMessage<Payload> | EventMessage<Payload> | undefined) {
+    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/src/transport/transport_server.ts

@@ -0,0 +1,108 @@
+import type { RequestMessage, ResponseMessage } from './dispatch/messages.js';
+import type { Listener } from './interface/listener.js';
+import type { Socket } from './interface/socket.js';
+import { isTransferDescriptor } from './interface/transferable.js';
+
+/**
+ * Keeps track of clients, providing a broadcast, and request/response api with multiplexing.
+ */
+export class TransportServer<Payload> {
+  private sockets: Socket[] = [];
+
+  constructor(private listener: Listener, private 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() {
+    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: Payload) {
+    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.
+   */
+  private handleNewSocket(socket: 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.
+   */
+  private getPayloadAndTransfers(data: any): [any, Transferable[]] {
+    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.
+   */
+  private async handleSocketMessage(socket: Socket, { msgId, payload }: RequestMessage<Payload>) {
+    try {
+      const data = await this.msgHandlerFn(payload);
+
+      const [respPayload, transferables] = this.getPayloadAndTransfers(data);
+      const rep: ResponseMessage<Payload> = { msgId, payload: respPayload };
+
+      await socket.send(rep, transferables);
+    } catch (err: any) {
+      const rep: ResponseMessage<Payload> = { msgId, error: err.stack };
+      await socket.send(rep);
+    }
+  }
+}

package/src/trees/hasher.ts

@@ -0,0 +1,39 @@
+/**
+ * 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>;
+}

package/src/trees/index.ts

@@ -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/src/trees/indexed_merkle_tree.ts

@@ -0,0 +1,36 @@
+import { Fr } from '../fields/index.js';
+import { assertLength } from '../serialize/index.js';
+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 class IndexedMerkleTree<T extends IndexedTreeLeafPreimage, N extends number> extends MerkleTree {
+  constructor(height: N, nodes: Buffer[], public readonly leafPreimages: T[]) {
+    super(height, nodes);
+  }
+
+  public getLowLeaf(value: bigint): T {
+    let lowLeaf: T | undefined;
+    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;
+  }
+
+  public getMembershipWitness(leafIndexOrLeaf: number | Buffer): MembershipWitness<N> {
+    const index = Buffer.isBuffer(leafIndexOrLeaf) ? this.getIndex(leafIndexOrLeaf) : leafIndexOrLeaf;
+    const siblingPath = this.getSiblingPath(index);
+    return new MembershipWitness<N>(
+      this.height as N,
+      BigInt(index),
+      assertLength<Fr, N>(siblingPath.map(Fr.fromBuffer), this.height as N),
+    );
+  }
+}

package/src/trees/indexed_merkle_tree_calculator.ts

@@ -0,0 +1,94 @@
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { numToUInt32BE } from '@aztec/foundation/serialize';
+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 class IndexedMerkleTreeCalculator<T extends IndexedTreeLeafPreimage, N extends number> {
+  private constructor(
+    private height: N,
+    private zeroHashes: Buffer[],
+    private hasher: AsyncHasher,
+    private factory: LeafPreimageFactory<T>,
+  ) {}
+
+  static async create<T extends IndexedTreeLeafPreimage, N extends number>(
+    height: N,
+    hasher: AsyncHasher,
+    factory: LeafPreimageFactory<T>,
+    zeroLeaf = Buffer.alloc(32),
+  ) {
+    const zeroHashes = [zeroLeaf];
+    for (let i = 0; i < height; i++) {
+      zeroHashes.push(await hasher.hash(zeroHashes[i], zeroHashes[i]));
+    }
+    return new IndexedMerkleTreeCalculator(height, zeroHashes, hasher, factory);
+  }
+
+  async computeTree(values: Buffer[]): Promise<IndexedMerkleTree<T, N>> {
+    if (!values.find(v => toBigIntBE(v) == BigInt(0))) {
+      // If we have no zero value, add one to form the zero leaf
+      values = [Buffer.alloc(32), ...values];
+    }
+    const sorted = values
+      .map((v, i) => ({ value: v, index: i }))
+      .sort((a, b) => Number(toBigIntBE(b.value) - toBigIntBE(a.value)));
+    const indexedLeaves = sorted.map((item, i) => ({
+      leaf: this.factory.fromBuffer(
+        Buffer.concat([
+          item.value,
+          ...(i == 0
+            ? [Buffer.alloc(32), Buffer.alloc(32)]
+            : [sorted[i - 1].value, numToUInt32BE(sorted[i - 1].index, 32)]),
+        ]),
+      ),
+      index: item.index,
+    }));
+    const resortedIndexedLeaves = indexedLeaves.sort((a, b) => a.index - b.index).map(item => item.leaf);
+    let leaves = await Promise.all(resortedIndexedLeaves.map(l => this.hasher.hashInputs(l.toHashInputs())));
+
+    let result = leaves.slice();
+
+    for (let i = 0; i < this.height; ++i) {
+      const numLeaves = 2 ** (this.height - i);
+      const newLeaves: Buffer[] = [];
+      for (let j = 0; j < leaves.length / 2; ++j) {
+        const l = leaves[j * 2];
+        const r = leaves[j * 2 + 1] || this.zeroHashes[i];
+        newLeaves[j] = await this.hasher.hash(l, r);
+      }
+      result = result.concat(new Array(numLeaves - leaves.length).fill(this.zeroHashes[i]), newLeaves);
+      leaves = newLeaves;
+    }
+
+    return new IndexedMerkleTree(this.height, result, resortedIndexedLeaves);
+  }
+
+  async computeTreeRoot(leaves: Buffer[] = []): Promise<Buffer> {
+    if (leaves.length === 0) {
+      return this.zeroHashes[this.zeroHashes.length - 1];
+    }
+
+    leaves = leaves.slice();
+
+    for (let i = 0; i < this.height; ++i) {
+      let j = 0;
+      for (; j < leaves.length / 2; ++j) {
+        const l = leaves[j * 2];
+        const r = leaves[j * 2 + 1] || this.zeroHashes[i];
+        leaves[j] = await this.hasher.hash(l, r);
+      }
+      leaves = leaves.slice(0, j);
+    }
+
+    return leaves[0];
+  }
+}

package/src/trees/indexed_tree_leaf.ts

@@ -0,0 +1,56 @@
+/**
+ * A leaf of an indexed merkle tree.
+ */
+export interface IndexedTreeLeaf {
+  /**
+   * Returns key of the leaf. It's used for indexing.
+   */
+  getKey(): bigint;
+  /**
+   * Serializes the leaf into a buffer.
+   */
+  toBuffer(): Buffer;
+  /**
+   * Returns true if the leaf is empty.
+   */
+  isEmpty(): boolean;
+  /**
+   * Updates the leaf with the data of another leaf.
+   * @param another - The leaf to update to.
+   * @returns The updated leaf.
+   */
+  updateTo(another: IndexedTreeLeaf): IndexedTreeLeaf;
+}
+
+/**
+ * Preimage of a merkle tree leaf.
+ */
+export interface TreeLeafPreimage {
+  /**
+   * Returns key of the leaf corresponding to this preimage.
+   */
+  getKey(): bigint;
+  /**
+   * Returns the preimage as a leaf.
+   */
+  asLeaf(): IndexedTreeLeaf;
+  /**
+   * Serializes the preimage into a buffer.
+   */
+  toBuffer(): Buffer;
+  /**
+   * Serializes the preimage to an array of buffers for hashing.
+   */
+  toHashInputs(): Buffer[];
+}
+
+/**
+ * Preimage of an indexed merkle tree leaf.
+ */
+export interface IndexedTreeLeafPreimage extends TreeLeafPreimage {
+  getNextKey(): bigint;
+  /**
+   * Returns the index of the next leaf.
+   */
+  getNextIndex(): bigint;
+}

package/src/trees/membership_witness.ts

@@ -0,0 +1,99 @@
+import { assertMemberLength } from '../array/array.js';
+import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
+import { Fr } from '../fields/fields.js';
+import { BufferReader, type Tuple, serializeToBuffer } from '../serialize/index.js';
+import type { SiblingPath } from './sibling_path.js';
+
+/**
+ * Contains information which can be used to prove that a leaf is a member of a Merkle tree.
+ */
+export class MembershipWitness<N extends number> {
+  constructor(
+    /**
+     * Size of the sibling path (number of fields it contains).
+     */
+    pathSize: N,
+    /**
+     * Index of a leaf in the Merkle tree.
+     */
+    public leafIndex: bigint,
+    /**
+     * Sibling path of the leaf in the Merkle tree.
+     */
+    public siblingPath: Tuple<Fr, N>,
+  ) {
+    assertMemberLength(this, 'siblingPath', pathSize);
+  }
+
+  toBuffer() {
+    return serializeToBuffer(toBufferBE(this.leafIndex, 32), ...this.siblingPath);
+  }
+
+  /**
+   * Creates a random membership witness. Used for testing purposes.
+   * @param pathSize - Number of fields in the sibling path.
+   * @returns Random membership witness.
+   */
+  public static random<N extends number>(pathSize: N) {
+    return new MembershipWitness<N>(
+      pathSize,
+      0n,
+      Array(pathSize)
+        .fill(0)
+        .map(() => Fr.random()) as Tuple<Fr, N>,
+    );
+  }
+
+  /**
+   * Creates a membership witness whose sibling path is full of zero fields.
+   * @param pathSize - Number of fields in the sibling path.
+   * @param leafIndex - Index of the leaf in the Merkle tree.
+   * @returns Membership witness with zero sibling path.
+   */
+  public static empty<N extends number>(pathSize: N, leafIndex = 0n): MembershipWitness<N> {
+    const arr = Array(pathSize)
+      .fill(0)
+      .map(() => Fr.ZERO) as Tuple<Fr, N>;
+    return new MembershipWitness<N>(pathSize, leafIndex, arr);
+  }
+
+  static fromBufferArray<N extends number>(leafIndex: bigint, siblingPath: Tuple<Buffer, N>): MembershipWitness<N> {
+    return new MembershipWitness<N>(
+      siblingPath.length as N,
+      leafIndex,
+      siblingPath.map(x => Fr.fromBuffer(x)) as Tuple<Fr, N>,
+    );
+  }
+
+  /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer or reader to read from.
+   * @returns The deserialized `MembershipWitness`.
+   */
+  static fromBuffer<N extends number>(buffer: Buffer | BufferReader, size: N): MembershipWitness<N> {
+    const reader = BufferReader.asReader(buffer);
+    const leafIndex = toBigIntBE(reader.readBytes(32));
+    const siblingPath = reader.readArray(size, Fr);
+    return new MembershipWitness(size, leafIndex, siblingPath);
+  }
+
+  /**
+   * Creates a deserializer object for a MembershipWitness with a given size.
+   * @param size - Expected size of the witness.
+   * @returns A deserializer object.
+   */
+  static deserializer<N extends number>(size: N): { fromBuffer(buffer: Buffer | BufferReader): MembershipWitness<N> } {
+    return {
+      fromBuffer: (buffer: Buffer | BufferReader) => {
+        const reader = BufferReader.asReader(buffer);
+        const leafIndex = toBigIntBE(reader.readBytes(32));
+        const siblingPath = reader.readArray(size, Fr);
+        return new MembershipWitness(size, leafIndex, siblingPath);
+      },
+    };
+  }
+
+  static fromSiblingPath<N extends number>(leafIndex: bigint, siblingPath: SiblingPath<N>): MembershipWitness<N> {
+    return new MembershipWitness<N>(siblingPath.pathSize, leafIndex, siblingPath.toFields() as Tuple<Fr, N>);
+  }
+}

package/src/trees/merkle_tree.ts

@@ -0,0 +1,72 @@
+/** A simple immutable Merkle tree container. Use a MerkleTreeCalculator to create a new instance from a set of leaves. */
+export class MerkleTree {
+  constructor(public readonly height: number, public readonly nodes: Buffer[]) {
+    const expectedNodeCount = 2 ** (height + 1) - 1;
+    if (nodes.length !== expectedNodeCount) {
+      throw new Error(`Invalid node count for Merkle tree: got ${nodes.length} but expected ${expectedNodeCount}`);
+    }
+  }
+
+  get root(): Buffer {
+    return this.nodes[this.nodes.length - 1];
+  }
+
+  get leaves(): Buffer[] {
+    return this.nodes.slice(0, 2 ** this.height);
+  }
+
+  /** Returns a sibling path to the given element or to the element in the given index. */
+  public getSiblingPath(leafIndex: number): Buffer[];
+  public getSiblingPath(leaf: Buffer): Buffer[];
+  public getSiblingPath(leafIndexOrLeaf: number | Buffer): Buffer[] {
+    if (Buffer.isBuffer(leafIndexOrLeaf)) {
+      return this.getSiblingPath(this.getIndex(leafIndexOrLeaf));
+    }
+    const leafIndex = leafIndexOrLeaf;
+    if (leafIndex < 0 || leafIndex >= 2 ** this.height) {
+      throw new Error(`Invalid leaf index: got ${leafIndex} but leaves count is ${2 ** this.height}`);
+    }
+    const tree = this.nodes;
+    let rowSize = Math.ceil(tree.length / 2);
+    let rowOffset = 0;
+    let index = leafIndex;
+    const siblingPath: Buffer[] = [];
+    while (rowSize > 1) {
+      const isRight = index & 1;
+      siblingPath.push(tree[rowOffset + index + (isRight ? -1 : 1)]);
+      rowOffset += rowSize;
+      rowSize >>= 1;
+      index >>= 1;
+    }
+    return siblingPath;
+  }
+
+  /** Returns the leaf index for a given element. */
+  public getIndex(element: Buffer) {
+    return this.leaves.findIndex(leaf => leaf.equals(element));
+  }
+
+  /** Returns a nice string representation of the tree, useful for debugging purposes. */
+  public drawTree(elemSize = 8) {
+    const levels: string[][] = [];
+    const tree = this.nodes;
+    const maxRowSize = Math.ceil(tree.length / 2);
+    let paddingSize = 1;
+    let rowSize = maxRowSize;
+    let rowOffset = 0;
+    while (rowSize > 0) {
+      levels.push(
+        tree
+          .slice(rowOffset, rowOffset + rowSize)
+          .map(n => n.toString('hex').slice(0, elemSize) + ' '.repeat((paddingSize - 1) * (elemSize + 1))),
+      );
+      rowOffset += rowSize;
+      paddingSize <<= 1;
+      rowSize >>= 1;
+    }
+    return levels
+      .reverse()
+      .map(row => row.join(' '))
+      .join('\n');
+  }
+}