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

package/src/transport/interface/listener.ts

@@ -7,10 +7,9 @@ import type { Socket } from './socket.js';
  * Possible implementations could include MessageChannels or WebSockets.
  */
 export interface Listener extends EventEmitter {
-  // eslint-disable-next-line jsdoc/require-jsdoc
   open(): void;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   close(): void;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   on(name: 'new_socket', cb: (client: Socket) => void): this;
 }

package/src/transport/interface/socket.ts

@@ -6,10 +6,9 @@
  * If `registerHandler` callback receives `undefined` that signals the other end closed.
  */
 export interface Socket {
-  // eslint-disable-next-line jsdoc/require-jsdoc
   send(msg: any, transfer?: Transferable[]): Promise<void>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   registerHandler(cb: (msg: any) => any): void;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   close(): void;
 }

package/src/transport/transport_client.ts

@@ -18,9 +18,9 @@ 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;
 }
 
@@ -30,9 +30,8 @@ interface PendingRequest {
  * 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;
 }
 

package/src/transport/transport_server.ts

@@ -9,7 +9,10 @@ import { isTransferDescriptor } from './interface/transferable.js';
 export class TransportServer<Payload> {
   private sockets: Socket[] = [];
 
-  constructor(private listener: Listener, private msgHandlerFn: (msg: Payload) => Promise<any>) {}
+  constructor(
+    private listener: Listener,
+    private msgHandlerFn: (msg: Payload) => Promise<any>,
+  ) {}
 
   /**
    * Starts the TransportServer, allowing it to accept new connections and handle incoming messages.

package/src/trees/hasher.ts

@@ -8,14 +8,14 @@ export interface Hasher {
    * @param rhs - The second array.
    * @returns The new 32-byte hash.
    */
-  hash(lhs: Uint8Array, rhs: Uint8Array): Buffer;
+  hash(lhs: Uint8Array, rhs: Uint8Array): Buffer<ArrayBuffer>;
 
   /**
    * Hashes an array of buffers.
    * @param inputs - The array of buffers to hash.
    * @returns The resulting 32-byte hash.
    */
-  hashInputs(inputs: Buffer[]): Buffer;
+  hashInputs(inputs: Buffer[]): Buffer<ArrayBuffer>;
 }
 
 /**
@@ -28,12 +28,12 @@ export interface AsyncHasher {
    * @param rhs - The second array.
    * @returns The new 32-byte hash.
    */
-  hash(lhs: Uint8Array, rhs: Uint8Array): Promise<Buffer>;
+  hash(lhs: Uint8Array, rhs: Uint8Array): Promise<Buffer<ArrayBuffer>>;
 
   /**
    * Hashes an array of buffers.
    * @param inputs - The array of buffers to hash.
    * @returns The resulting 32-byte hash.
    */
-  hashInputs(inputs: Buffer[]): Promise<Buffer>;
+  hashInputs(inputs: Buffer[]): Promise<Buffer<ArrayBuffer>>;
 }

package/src/trees/index.ts

@@ -8,3 +8,4 @@ export * from './sibling_path.js';
 export * from './membership_witness.js';
 export * from './hasher.js';
 export * from './indexed_tree_leaf.js';
+export * from './unbalanced_merkle_tree_calculator.js';

package/src/trees/indexed_merkle_tree.ts

@@ -6,7 +6,11 @@ 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[]) {
+  constructor(
+    height: N,
+    nodes: Buffer[],
+    public readonly leafPreimages: T[],
+  ) {
     super(height, nodes);
   }
 

package/src/trees/indexed_merkle_tree_calculator.ts

@@ -28,7 +28,7 @@ export class IndexedMerkleTreeCalculator<T extends IndexedTreeLeafPreimage, N ex
   ) {
     const zeroHashes = [zeroLeaf];
     for (let i = 0; i < height; i++) {
-      zeroHashes.push(await hasher.hash(zeroHashes[i], zeroHashes[i]));
+      zeroHashes.push((await hasher.hash(zeroHashes[i], zeroHashes[i])) as Buffer<ArrayBuffer>);
     }
     return new IndexedMerkleTreeCalculator(height, zeroHashes, hasher, factory);
   }
@@ -59,7 +59,7 @@ export class IndexedMerkleTreeCalculator<T extends IndexedTreeLeafPreimage, N ex
 
     for (let i = 0; i < this.height; ++i) {
       const numLeaves = 2 ** (this.height - i);
-      const newLeaves: Buffer[] = [];
+      const newLeaves: Buffer<ArrayBuffer>[] = [];
       for (let j = 0; j < leaves.length / 2; ++j) {
         const l = leaves[j * 2];
         const r = leaves[j * 2 + 1] || this.zeroHashes[i];

package/src/trees/membership_witness.ts

@@ -1,6 +1,7 @@
 import { assertMemberLength } from '../array/array.js';
 import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
 import { Fr } from '../fields/fields.js';
+import { schemas } from '../schemas/schemas.js';
 import { BufferReader, type Tuple, serializeToBuffer } from '../serialize/index.js';
 import type { SiblingPath } from './sibling_path.js';
 
@@ -29,6 +30,18 @@ export class MembershipWitness<N extends number> {
     return serializeToBuffer(toBufferBE(this.leafIndex, 32), ...this.siblingPath);
   }
 
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  toFields(): Fr[] {
+    return [new Fr(this.leafIndex), ...this.siblingPath];
+  }
+
+  static schemaFor<N extends number>(size: N) {
+    return schemas.Buffer.transform(b => MembershipWitness.fromBuffer(b, size));
+  }
+
   /**
    * Creates a random membership witness. Used for testing purposes.
    * @param pathSize - Number of fields in the sibling path.

package/src/trees/merkle_tree.ts

@@ -1,6 +1,9 @@
 /** 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[]) {
+  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}`);

package/src/trees/merkle_tree_calculator.ts

@@ -1,4 +1,4 @@
-import { pedersenHash } from '@aztec/foundation/crypto';
+import { pedersenHash, sha256Trunc } from '@aztec/foundation/crypto';
 
 import type { AsyncHasher } from './hasher.js';
 import { MerkleTree } from './merkle_tree.js';
@@ -7,18 +7,23 @@ import { MerkleTree } from './merkle_tree.js';
  * Merkle tree calculator.
  */
 export class MerkleTreeCalculator {
-  private constructor(private height: number, private zeroHashes: Buffer[], private hasher: AsyncHasher['hash']) {
+  private constructor(
+    private height: number,
+    private zeroHashes: Buffer[],
+    private hasher: AsyncHasher['hash'],
+  ) {
     this.hasher = hasher;
   }
 
   static async create(
     height: number,
-    zeroLeaf = Buffer.alloc(32),
-    hasher = async (left: Buffer, right: Buffer) => (await pedersenHash([left, right])).toBuffer(),
+    zeroLeaf: Buffer = Buffer.alloc(32),
+    hasher = async (left: Buffer, right: Buffer) =>
+      (await pedersenHash([left, right])).toBuffer() as Buffer<ArrayBuffer>,
   ) {
     const zeroHashes = [zeroLeaf];
     for (let i = 0; i < height; i++) {
-      zeroHashes.push(await hasher(zeroHashes[i], zeroHashes[i]));
+      zeroHashes.push((await hasher(zeroHashes[i], zeroHashes[i])) as Buffer<ArrayBuffer>);
     }
     return new MerkleTreeCalculator(height, zeroHashes, hasher);
   }
@@ -64,4 +69,37 @@ export class MerkleTreeCalculator {
 
     return leaves[0];
   }
+
+  /**
+   * Computes the Merkle root with the provided leaves **synchronously**.
+   *
+   * This method uses a synchronous hash function (defaults to `sha256Trunc`) and **does not** allow for padding.
+   * If the number of leaves is not a power of two, it throws an error.
+   * This contrasts with the above non-static async method `computeTreeRoot`, which can handle any number of leaves by
+   * padding with zero hashes.
+   */
+  static computeTreeRootSync(leaves: Buffer[], hasher = sha256Trunc): Buffer {
+    if (leaves.length === 0) {
+      throw new Error('Cannot compute a Merkle root with no leaves');
+    }
+
+    const height = Math.log2(leaves.length);
+    if (!Number.isInteger(height)) {
+      throw new Error('Cannot compute a Merkle root with a non-power-of-two number of leaves');
+    }
+
+    let nodes = leaves.slice();
+
+    for (let i = 0; i < height; ++i) {
+      let j = 0;
+      for (; j < nodes.length / 2; ++j) {
+        const l = nodes[j * 2];
+        const r = nodes[j * 2 + 1];
+        nodes[j] = hasher(Buffer.concat([l, r]));
+      }
+      nodes = nodes.slice(0, j);
+    }
+
+    return nodes[0];
+  }
 }

package/src/trees/unbalanced_merkle_tree.ts

@@ -1,60 +1,68 @@
-import { padArrayEnd } from '../collection/array.js';
 import { sha256Trunc } from '../crypto/sha256/index.js';
+import { MerkleTreeCalculator } from './merkle_tree_calculator.js';
 
 /**
- * Computes the merkle root for an unbalanced tree.
+ * Computes the Merkle root of 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.
+ * Unlike a balanced Merkle tree, which requires the number of leaves to be a power of two, an unbalanced tree can have
+ * any number of leaves.
+ *
+ * The tree is constructed by iteratively extracting the smallest power-of-two-sized subtrees from **right to left**.
+ * For each such subtree, it computes the subtree root and then combines all subtree roots (again from right to left)
+ * into a single root using the provided hash function.
+ *
+ * Note: We need the final tree to be as shallow as possible, to minimize the size of the sibling path required to prove
+ * membership of a leaf. Therefor, the computation proceeds from right to left - smaller subtrees must always be
+ * combined before being merged with a larger sibling on their left.
+ *
+ * For example, consider an unbalanced tree made of three subtrees of sizes 2, 4, and 8. If we combine the size-2 and
+ * size-4 subtrees first (producing a subtree of depth 3), and then merge it with the size-8 subtree (also depth 3), the
+ * resulting tree has a maximum depth of 4.
+ *
+ * But if we instead combine the size-4 and size-8 subtrees first (depth 4), and then merge with the size-2 subtree
+ * (depth 1), the final tree has a depth of 5.
  */
-export function computeUnbalancedMerkleRoot(leaves: Buffer[], emptyLeaf?: Buffer, hasher = sha256Trunc): Buffer {
-  // 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);
-    }
+export function computeUnbalancedMerkleTreeRoot(leaves: Buffer[], hasher = sha256Trunc): Buffer {
+  if (!leaves.length) {
+    throw new Error('Cannot compute a Merkle root with no leaves');
   }
 
-  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);
+  if (leaves.length === 1) {
+    return leaves[0];
+  }
+
+  let numRemainingLeaves = leaves.length;
+  let subtreeSize = 1;
+  let root: Buffer | undefined;
+  while (numRemainingLeaves > 1) {
+    if ((numRemainingLeaves & subtreeSize) !== 0) {
+      const subtreeLeaves = leaves.slice(numRemainingLeaves - subtreeSize, numRemainingLeaves);
+      const subtreeRoot = MerkleTreeCalculator.computeTreeRootSync(subtreeLeaves, hasher);
+      if (!root) {
+        root = subtreeRoot;
       } 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];
+        root = hasher(Buffer.concat([subtreeRoot, root]));
       }
+
+      numRemainingLeaves -= subtreeSize;
     }
-    // reset the layers
-    thisLayer = nextLayer;
-    nextLayer = [];
+
+    subtreeSize *= 2;
   }
-  // return the root
-  return thisLayer[0];
+
+  return root!;
 }
 
-function getMaxBalancedTreeDepth(numLeaves: number) {
+/// Get the depth of the maximum balanced tree that can be created with the given number of leaves. The subtree will be
+/// the left most subtree of the wonky tree with a total of `numLeaves` leaves.
+///
+/// Note: All the leaves may not be used to form the tree. For example, if there are 5 leaves, the maximum depth is 2,
+/// only 4 leaves are used to form a balanced tree.
+function getMaxBalancedSubtreeDepth(numLeaves: number) {
   return Math.floor(Math.log2(numLeaves));
 }
 
+/// Get the maximum depth of an unbalanced tree that can be created with the given number of leaves.
 function getMaxUnbalancedTreeDepth(numLeaves: number) {
   return Math.ceil(Math.log2(numLeaves));
 }
@@ -72,7 +80,7 @@ function findPosition(
   }
 
   // The largest balanced tree that can be created with the given number of leaves.
-  const maxBalancedTreeDepth = getMaxBalancedTreeDepth(numLeaves);
+  const maxBalancedTreeDepth = getMaxBalancedSubtreeDepth(numLeaves);
   const numBalancedLeaves = 2 ** maxBalancedTreeDepth;
   const numRemainingLeaves = numLeaves - numBalancedLeaves;
 

package/src/trees/unbalanced_merkle_tree_calculator.ts

@@ -0,0 +1,194 @@
+import { sha256Trunc } from '../crypto/index.js';
+import type { Hasher } from './hasher.js';
+import { SiblingPath } from './sibling_path.js';
+import { type TreeNodeLocation, UnbalancedTreeStore } from './unbalanced_tree_store.js';
+
+export function computeCompressedUnbalancedMerkleTreeRoot(
+  leaves: Buffer[],
+  valueToCompress = Buffer.alloc(32),
+  hasher?: Hasher['hash'],
+): Buffer {
+  const calculator = UnbalancedMerkleTreeCalculator.create(leaves, valueToCompress, hasher);
+  return calculator.getRoot();
+}
+
+interface TreeNode {
+  value: Buffer;
+  leafIndex?: number;
+}
+
+/**
+ * An ephemeral unbalanced Merkle tree implementation.
+ * Follows the rollup implementation which greedily hashes pairs of nodes up the tree.
+ * Remaining rightmost nodes are shifted up until they can be paired.
+ * The values that match the `valueToCompress` are skipped and the sibling of the compressed leaf are shifted up until
+ * they can be paired.
+ * If there is only one leaf, the root is the leaf.
+ */
+export class UnbalancedMerkleTreeCalculator {
+  private store: UnbalancedTreeStore<TreeNode>;
+  private leafLocations: TreeNodeLocation[] = [];
+
+  public constructor(
+    private readonly leaves: Buffer[],
+    private readonly valueToCompress: Buffer,
+    private readonly hasher: Hasher['hash'],
+  ) {
+    if (leaves.length === 0) {
+      throw Error('Cannot create a compressed unbalanced tree with 0 leaves.');
+    }
+
+    this.store = new UnbalancedTreeStore(leaves.length);
+    this.buildTree();
+  }
+
+  static create(
+    leaves: Buffer[],
+    valueToCompress = Buffer.alloc(0),
+    hasher = (left: Buffer, right: Buffer) => sha256Trunc(Buffer.concat([left, right])) as Buffer<ArrayBuffer>,
+  ) {
+    return new UnbalancedMerkleTreeCalculator(leaves, valueToCompress, hasher);
+  }
+
+  /**
+   * Returns the root of the tree.
+   * @returns The root of the tree.
+   */
+  public getRoot(): Buffer {
+    return this.store.getRoot()!.value;
+  }
+
+  /**
+   * Returns a sibling path for the element.
+   * @param value - The value of the element.
+   * @returns A sibling path for the element.
+   * Note: The sibling path is an array of sibling hashes, with the lowest hash (leaf hash) first, and the highest hash last.
+   */
+  public getSiblingPath<N extends number>(value: Buffer): SiblingPath<N> {
+    const leafIndex = this.leaves.findIndex(leaf => leaf.equals(value));
+    if (leafIndex === -1) {
+      throw Error(`Leaf value ${value.toString('hex')} not found in tree.`);
+    }
+
+    return this.getSiblingPathByLeafIndex(leafIndex);
+  }
+
+  /**
+   * Returns a sibling path for the leaf at the given index.
+   * @param leafIndex - The index of the leaf.
+   * @returns A sibling path for the leaf.
+   */
+  public getSiblingPathByLeafIndex<N extends number>(leafIndex: number): SiblingPath<N> {
+    if (leafIndex >= this.leaves.length) {
+      throw Error(`Leaf index ${leafIndex} out of bounds. Tree has ${this.leaves.length} leaves.`);
+    }
+
+    const leaf = this.leaves[leafIndex];
+    if (leaf.equals(this.valueToCompress)) {
+      throw Error(`Leaf at index ${leafIndex} has been compressed.`);
+    }
+
+    const path: Buffer[] = [];
+    let location = this.leafLocations[leafIndex];
+    while (location.level > 0) {
+      const sibling = this.store.getSibling(location)!;
+      path.push(sibling.value);
+      location = this.store.getParentLocation(location);
+    }
+
+    return new SiblingPath<N>(path.length as N, path);
+  }
+
+  public getLeafLocation(leafIndex: number) {
+    return this.leafLocations[leafIndex];
+  }
+
+  /**
+   * Adds leaves and nodes to the store. Updates the leafLocations.
+   * @param leaves - The leaves of the tree.
+   */
+  private buildTree() {
+    this.leafLocations = this.leaves.map((value, i) => this.store.setLeaf(i, { value, leafIndex: i }));
+
+    // Start with the leaves that are not compressed.
+    let toProcess = this.leafLocations.filter((_, i) => !this.leaves[i].equals(this.valueToCompress));
+    if (!toProcess.length) {
+      // All leaves are compressed. Set 0 to the root.
+      this.store.setNode({ level: 0, index: 0 }, { value: Buffer.alloc(32) });
+      return;
+    }
+
+    const level = toProcess[0].level;
+    for (let i = level; i > 0; i--) {
+      const toProcessNext = [];
+      for (const location of toProcess) {
+        if (location.level !== i) {
+          toProcessNext.push(location);
+          continue;
+        }
+
+        const parentLocation = this.store.getParentLocation(location);
+        if (this.store.getNode(parentLocation)) {
+          // Parent has been updated by its (left) sibling.
+          continue;
+        }
+
+        const sibling = this.store.getSibling(location);
+        // If sibling is undefined, all its children are compressed.
+        const shouldShiftUp = !sibling || sibling.value.equals(this.valueToCompress);
+        if (shouldShiftUp) {
+          // The node becomes the parent if the sibling is a compressed leaf.
+          const isLeaf = this.shiftNodeUp(location, parentLocation);
+          if (!isLeaf) {
+            this.shiftChildrenUp(location);
+          }
+        } else {
+          // Hash the value with the (right) sibling and update the parent node.
+          const node = this.store.getNode(location)!;
+          const parentValue = this.hasher(node.value, sibling.value);
+          this.store.setNode(parentLocation, { value: parentValue });
+        }
+
+        // Add the parent location to be processed next.
+        toProcessNext.push(parentLocation);
+      }
+
+      toProcess = toProcessNext;
+    }
+  }
+
+  private shiftNodeUp(fromLocation: TreeNodeLocation, toLocation: TreeNodeLocation): boolean {
+    const node = this.store.getNode(fromLocation)!;
+
+    this.store.setNode(toLocation, node);
+
+    const isLeaf = node.leafIndex !== undefined;
+    if (isLeaf) {
+      // Update the location if the node is a leaf.
+      this.leafLocations[node.leafIndex!] = toLocation;
+    }
+
+    return isLeaf;
+  }
+
+  private shiftChildrenUp(parent: TreeNodeLocation) {
+    const [left, right] = this.store.getChildLocations(parent);
+
+    const level = parent.level;
+    const groupSize = 2 ** level;
+    const computeNewLocation = (index: number) => ({
+      level,
+      index: Math.floor(index / (groupSize * 2)) * groupSize + (index % groupSize),
+    });
+
+    const isLeftLeaf = this.shiftNodeUp(left, computeNewLocation(left.index));
+    const isRightLeaf = this.shiftNodeUp(right, computeNewLocation(right.index));
+
+    if (!isLeftLeaf) {
+      this.shiftChildrenUp(left);
+    }
+    if (!isRightLeaf) {
+      this.shiftChildrenUp(right);
+    }
+  }
+}

package/src/trees/unbalanced_tree_store.ts

@@ -68,7 +68,7 @@ export class UnbalancedTreeStore<T> {
     return [left, right];
   }
 
-  getLeaf(leafIndex: number) {
+  getLeaf(leafIndex: number): T | undefined {
     const { level, indexAtLevel } = findLeafLevelAndIndex(this.#numLeaves, leafIndex);
     const location = {
       level,
@@ -81,6 +81,10 @@ export class UnbalancedTreeStore<T> {
     return this.#nodeMapping.get(this.#getKey(location))?.value;
   }
 
+  getRoot(): T | undefined {
+    return this.getNode({ level: 0, index: 0 });
+  }
+
   getParent(location: TreeNodeLocation): T | undefined {
     const parentLocation = this.getParentLocation(location);
     return this.getNode(parentLocation);

package/src/types/index.ts

@@ -1,12 +1,10 @@
 /** Strips methods of a type. */
 export type FieldsOf<T> = {
-  // eslint-disable-next-line @typescript-eslint/ban-types
   [P in keyof T as T[P] extends Function ? never : P]: T[P];
 };
 
 /** Extracts methods of a type. */
 export type FunctionsOf<T> = {
-  // eslint-disable-next-line @typescript-eslint/ban-types
   [P in keyof T as T[P] extends Function ? P : never]: T[P];
 };
 
@@ -21,5 +19,28 @@ export function unfreeze<T>(obj: T): Writeable<T> {
   return obj as Writeable<T>;
 }
 
-/** Maybe exists, maybe not. */
-export type Maybe<T extends object> = T | unknown;
+/** Resolves a record-like type. Lifted from viem. */
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+/**
+ * Type-safe Event Emitter type
+ * @example
+ * export type ArchiverEmitter = TypedEventEmitter<{
+ *  [L2BlockSourceEvents.L2PruneDetected]: (args: L2BlockSourceEvent) => void;
+ *  [L2BlockSourceEvents.L2BlockProven]: (args: L2BlockSourceEvent) => void;
+ * }>;
+ * class Archiver extends (EventEmitter as new () => ArchiverEmitter) {
+ *  // ...
+ * }
+ */
+export interface TypedEventEmitter<TEventMap extends { [key in keyof TEventMap]: (...args: any[]) => void }> {
+  once<K extends keyof TEventMap>(event: K, listener: TEventMap[K]): this;
+  on<K extends keyof TEventMap>(event: K, listener: TEventMap[K]): this;
+  off<K extends keyof TEventMap>(event: K, listener: TEventMap[K]): this;
+  emit<K extends keyof TEventMap>(event: K, ...args: Parameters<TEventMap[K]>): boolean;
+  removeListener<K extends keyof TEventMap>(event: K, listener: TEventMap[K]): this;
+  removeAllListeners<K extends keyof TEventMap>(event: K): this;
+  // Can add other EventEmitter methods if needed, like once(), listenerCount(), etc.
+}

package/src/url/index.ts

@@ -1,4 +1,3 @@
-/* eslint-disable */
 // Copyright (c) 2014 Nathan Rajlich <nathan@tootallnate.net>
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the

package/dest/crypto/pedersen/pedersen.elliptic.d.ts

@@ -1,13 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/**
- * Create a pedersen commitment (point) from an array of input fields.
- * Left pads any inputs less than 32 bytes.
- */
-export declare function pedersenCommit(input: Buffer[], generatorOffset?: number): Buffer[];
-/**
- * Create a pedersen hash (field) from an array of input fields.
- * Left pads any inputs less than 32 bytes.
- */
-export declare function pedersenHash(input: Buffer[], index?: number): Buffer;
-//# sourceMappingURL=pedersen.elliptic.d.ts.map

package/dest/crypto/pedersen/pedersen.elliptic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pedersen.elliptic.d.ts","sourceRoot":"","sources":["../../../src/crypto/pedersen/pedersen.elliptic.ts"],"names":[],"mappings":";;AA+iBA;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,eAAe,SAAI,YAOlE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,SAAI,UAOtD"}