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

package/src/trees/balanced_merkle_tree_root.ts

@@ -0,0 +1,68 @@
+import { poseidonMerkleHash, shaMerkleHash } from './hasher.js';
+
+export const computeBalancedShaRoot = (leaves: Buffer[]) => computeBalancedMerkleTreeRoot(leaves);
+
+export const computeBalancedPoseidonRoot = async (leaves: Buffer[]) =>
+  await computeBalancedMerkleTreeRootAsync(leaves, poseidonMerkleHash);
+
+/**
+ * Computes the Merkle root with the provided leaves **synchronously**.
+ * This method uses a synchronous hash function (defaults to `sha256Trunc`).
+ *
+ * @throws If the number of leaves is not a power of two.
+ */
+export function computeBalancedMerkleTreeRoot(leaves: Buffer[], hasher = shaMerkleHash): Buffer {
+  const height = getTreeHeight(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(l, r);
+    }
+    nodes = nodes.slice(0, j);
+  }
+
+  return nodes[0];
+}
+
+/**
+ * Computes the Merkle root with the provided leaves **asynchronously**.
+ * This method uses an asynchronous hash function (defaults to `poseidon2Hash`).
+ *
+ * @throws If the number of leaves is not a power of two.
+ */
+export async function computeBalancedMerkleTreeRootAsync(
+  leaves: Buffer[],
+  hasher = poseidonMerkleHash,
+): Promise<Buffer> {
+  const height = getTreeHeight(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] = await hasher(l, r);
+    }
+    nodes = nodes.slice(0, j);
+  }
+
+  return nodes[0];
+}
+
+function getTreeHeight(leaves: 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');
+  }
+
+  return height;
+}

package/src/trees/hasher.ts

@@ -1,3 +1,6 @@
+import { poseidon2Hash } from '../crypto/poseidon/index.js';
+import { sha256Trunc } from '../crypto/sha256/index.js';
+
 /**
  * Defines hasher interface used by Merkle trees.
  */
@@ -8,14 +11,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 +31,18 @@ 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>>;
 }
+
+export const shaMerkleHash: Hasher['hash'] = (left: Buffer, right: Buffer) =>
+  sha256Trunc(Buffer.concat([left, right])) as Buffer<ArrayBuffer>;
+
+export const poseidonMerkleHash: AsyncHasher['hash'] = async (left: Buffer, right: Buffer) =>
+  (await poseidon2Hash([left, right])).toBuffer() as Buffer<ArrayBuffer>;

package/src/trees/index.ts

@@ -1,5 +1,4 @@
-export * from './unbalanced_merkle_tree.js';
-export * from './unbalanced_tree_store.js';
+export * from './balanced_merkle_tree_root.js';
 export * from './merkle_tree_calculator.js';
 export * from './merkle_tree.js';
 export * from './indexed_merkle_tree_calculator.js';
@@ -8,3 +7,6 @@ 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';
+export * from './unbalanced_merkle_tree_root.js';
+export * from './unbalanced_tree_store.js';

package/src/trees/indexed_merkle_tree.ts

@@ -1,4 +1,4 @@
-import { Fr } from '../fields/index.js';
+import { Fr } from '../curves/bn254/index.js';
 import { assertLength } from '../serialize/index.js';
 import type { IndexedTreeLeafPreimage } from './indexed_tree_leaf.js';
 import { MembershipWitness } from './membership_witness.js';
@@ -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 { Fr } from '../curves/bn254/field.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,26 @@ 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];
+  }
+
+  /**
+   * Returns a representation of the membership witness as expected by intrinsic Noir deserialization.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [new Fr(this.leafIndex).toString() as string, this.siblingPath.map(fr => fr.toString()) as string[]];
+  }
+
+  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 { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
 
 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 poseidon2Hash([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);
   }

package/src/trees/sibling_path.ts

@@ -1,6 +1,6 @@
 import { makeTuple } from '../array/array.js';
-import { pedersenHash } from '../crypto/index.js';
-import { Fr } from '../fields/index.js';
+import { poseidon2Hash } from '../crypto/poseidon/index.js';
+import { Fr } from '../curves/bn254/index.js';
 import { schemas } from '../schemas/index.js';
 import {
   type Tuple,
@@ -172,7 +172,7 @@ export async function computeRootFromSiblingPath(
   leaf: Buffer,
   siblingPath: Buffer[],
   index: number,
-  hasher = async (left: Buffer, right: Buffer) => (await pedersenHash([left, right])).toBuffer(),
+  hasher = async (left: Buffer, right: Buffer) => (await poseidon2Hash([left, right])).toBuffer(),
 ) {
   let result = leaf;
   for (const sibling of siblingPath) {

package/src/trees/unbalanced_merkle_tree_calculator.ts

@@ -0,0 +1,176 @@
+import { type Hasher, shaMerkleHash } from './hasher.js';
+import { SiblingPath } from './sibling_path.js';
+import { type TreeNodeLocation, UnbalancedTreeStore } from './unbalanced_tree_store.js';
+
+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 emptyRoot: Buffer,
+    private readonly hasher: Hasher['hash'],
+  ) {
+    this.store = new UnbalancedTreeStore(leaves.length);
+    this.buildTree();
+  }
+
+  static create(
+    leaves: Buffer[],
+    valueToCompress = Buffer.alloc(0),
+    emptyRoot = Buffer.alloc(32),
+    hasher = shaMerkleHash,
+  ) {
+    return new UnbalancedMerkleTreeCalculator(leaves, valueToCompress, emptyRoot, 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 empty root to the root.
+      this.store.setNode({ level: 0, index: 0 }, { value: this.emptyRoot });
+      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.
+          this.shiftNodeUp(location, parentLocation);
+        } 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(from: TreeNodeLocation, to: TreeNodeLocation) {
+    // Collect all nodes that need to shift.
+    const nodesToShift = this.collectNodesToShift(from, to);
+    // Move all nodes to their new locations.
+    for (const { node, newLocation } of nodesToShift) {
+      this.store.setNode(newLocation, node);
+      if (node.leafIndex !== undefined) {
+        this.leafLocations[node.leafIndex] = newLocation;
+      }
+    }
+  }
+
+  private collectNodesToShift(from: TreeNodeLocation, to: TreeNodeLocation) {
+    const node = this.store.getNode(from);
+    if (!node) {
+      return [];
+    }
+
+    let result = [{ node, newLocation: to }];
+
+    // If not a leaf, collect its children.
+    if (node.leafIndex === undefined) {
+      const [leftChild, rightChild] = this.store.getChildLocations(from);
+      const [leftChildNew, rightChildNew] = this.store.getChildLocations(to);
+      result = result
+        .concat(this.collectNodesToShift(leftChild, leftChildNew))
+        .concat(this.collectNodesToShift(rightChild, rightChildNew));
+    }
+
+    return result;
+  }
+}

package/src/trees/unbalanced_merkle_tree_root.ts

@@ -0,0 +1,115 @@
+import { computeBalancedMerkleTreeRoot, computeBalancedMerkleTreeRootAsync } from './balanced_merkle_tree_root.js';
+import { poseidonMerkleHash, shaMerkleHash } from './hasher.js';
+import { UnbalancedMerkleTreeCalculator } from './unbalanced_merkle_tree_calculator.js';
+
+export const computeUnbalancedShaRoot = (leaves: Buffer[]) => computeUnbalancedMerkleTreeRoot(leaves, shaMerkleHash);
+
+export const computeUnbalancedPoseidonRoot = async (leaves: Buffer[]) =>
+  await computeUnbalancedMerkleTreeRootAsync(leaves, poseidonMerkleHash);
+
+export const computeWonkyShaRoot = (leaves: Buffer[]) => computeWonkyMerkleTreeRoot(leaves);
+
+/**
+ * Computes the Merkle root of an unbalanced tree.
+ *
+ * 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 computeUnbalancedMerkleTreeRoot(
+  leaves: Buffer[],
+  hasher = shaMerkleHash,
+  emptyRoot = Buffer.alloc(32),
+): Buffer {
+  if (!leaves.length) {
+    return emptyRoot;
+  }
+
+  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 = computeBalancedMerkleTreeRoot(subtreeLeaves, hasher);
+      if (!root) {
+        root = subtreeRoot;
+      } else {
+        root = hasher(subtreeRoot, root);
+      }
+
+      numRemainingLeaves -= subtreeSize;
+    }
+
+    subtreeSize *= 2;
+  }
+
+  return root!;
+}
+
+export async function computeUnbalancedMerkleTreeRootAsync(
+  leaves: Buffer[],
+  hasher = poseidonMerkleHash,
+  emptyRoot = Buffer.alloc(32),
+): Promise<Buffer> {
+  if (!leaves.length) {
+    return emptyRoot;
+  }
+
+  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 = await computeBalancedMerkleTreeRootAsync(subtreeLeaves, hasher);
+      if (!root) {
+        root = subtreeRoot;
+      } else {
+        root = await hasher(subtreeRoot, root);
+      }
+
+      numRemainingLeaves -= subtreeSize;
+    }
+
+    subtreeSize *= 2;
+  }
+
+  return root!;
+}
+
+// A **wonky** tree is a "compressed" unbalanced Merkle tree.
+// It is constructed in the same way as an unbalanced tree: by first creating the largest possible left subtree, with
+// the remaining leaves forming a right subtree that follows the same process recursively.
+// During construction, leaves equal to `valueToCompress` are skipped (compressed) and do not contribute to the tree.
+export function computeWonkyMerkleTreeRoot(
+  leaves: Buffer[],
+  valueToCompress = Buffer.alloc(32),
+  emptyRoot = Buffer.alloc(32),
+  hasher = shaMerkleHash,
+): Buffer {
+  const calculator = UnbalancedMerkleTreeCalculator.create(leaves, valueToCompress, emptyRoot, hasher);
+  return calculator.getRoot();
+}

package/src/trees/unbalanced_tree_store.ts

@@ -1,5 +1,3 @@
-import { findLeafLevelAndIndex } from './unbalanced_merkle_tree.js';
-
 export interface TreeNodeLocation {
   level: number;
   index: number;
@@ -68,7 +66,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 +79,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);
@@ -100,3 +102,60 @@ export class UnbalancedTreeStore<T> {
     return `${location.level}-${location.index}`;
   }
 }
+
+/// 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 unbalanced 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));
+}
+
+function findPosition(
+  rootLevel: number,
+  leafLevel: number,
+  numLeaves: number,
+  indexOffset: number,
+  targetIndex: number,
+): { level: number; indexAtLevel: number } {
+  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 = getMaxBalancedSubtreeDepth(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: number, leafIndex: number) {
+  const maxLevel = getMaxUnbalancedTreeDepth(numLeaves);
+  return findPosition(0, maxLevel, numLeaves, 0, leafIndex);
+}