@aztec/foundation 0.69.0-devnet → 0.69.1-devnet

package/src/blob/index.ts

@@ -3,7 +3,7 @@ import type { Blob as BlobBuffer } from 'c-kzg';
 
 import { poseidon2Hash, sha256 } from '../crypto/index.js';
 import { Fr } from '../fields/index.js';
-import { serializeToBuffer } from '../serialize/index.js';
+import { BufferReader, serializeToBuffer } from '../serialize/index.js';
 
 // Importing directly from 'c-kzg' does not work, ignoring import/no-named-as-default-member err:
 /* eslint-disable import/no-named-as-default-member */
@@ -36,48 +36,47 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
  * A class to create, manage, and prove EVM blobs.
  */
 export class Blob {
-  /** The blob to be broadcast on L1 in bytes form. */
-  public readonly data: BlobBuffer;
-  /** The hash of all tx effects inside the blob. Used in generating the challenge z and proving that we have included all required effects. */
-  public readonly fieldsHash: Fr;
-  /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y. */
-  public readonly challengeZ: Fr;
-  /** Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts. */
-  public readonly evaluationY: Buffer;
-  /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */
-  public readonly commitment: Buffer;
-  /** KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes). */
-  public readonly proof: Buffer;
-
   constructor(
-    /** All fields to be broadcast in the blob. */
-    fields: Fr[],
-    /** If we want to broadcast more fields than fit into a blob, we hash those and used it as the fieldsHash across all blobs.
-     * This is much simpler and cheaper in the circuit to do, but MUST BE CHECKED before injecting here.
-     */
-    multiBlobFieldsHash?: Fr,
-  ) {
+    /** The blob to be broadcast on L1 in bytes form. */
+    public readonly data: BlobBuffer,
+    /** The hash of all tx effects inside the blob. Used in generating the challenge z and proving that we have included all required effects. */
+    public readonly fieldsHash: Fr,
+    /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y. */
+    public readonly challengeZ: Fr,
+    /** Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts. */
+    public readonly evaluationY: Buffer,
+    /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */
+    public readonly commitment: Buffer,
+    /** KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes). */
+    public readonly proof: Buffer,
+  ) {}
+
+  static fromFields(fields: Fr[], multiBlobFieldsHash?: Fr): Blob {
     if (fields.length > FIELD_ELEMENTS_PER_BLOB) {
       throw new Error(
         `Attempted to overfill blob with ${fields.length} elements. The maximum is ${FIELD_ELEMENTS_PER_BLOB}`,
       );
     }
-    this.data = Buffer.concat([serializeToBuffer(fields)], BYTES_PER_BLOB);
+    const dataWithoutZeros = serializeToBuffer(fields);
+    const data = Buffer.concat([dataWithoutZeros], BYTES_PER_BLOB);
+
     // This matches the output of SpongeBlob.squeeze() in the blob circuit
-    this.fieldsHash = multiBlobFieldsHash ? multiBlobFieldsHash : poseidon2Hash(fields);
-    this.commitment = Buffer.from(blobToKzgCommitment(this.data));
-    this.challengeZ = poseidon2Hash([this.fieldsHash, ...this.commitmentToFields()]);
-    const res = computeKzgProof(this.data, this.challengeZ.toBuffer());
-    if (!verifyKzgProof(this.commitment, this.challengeZ.toBuffer(), res[1], res[0])) {
+    const fieldsHash = multiBlobFieldsHash ? multiBlobFieldsHash : poseidon2Hash(fields);
+    const commitment = Buffer.from(blobToKzgCommitment(data));
+    const challengeZ = poseidon2Hash([fieldsHash, ...commitmentToFields(commitment)]);
+    const res = computeKzgProof(data, challengeZ.toBuffer());
+    if (!verifyKzgProof(commitment, challengeZ.toBuffer(), res[1], res[0])) {
       throw new Error(`KZG proof did not verify.`);
     }
-    this.proof = Buffer.from(res[0]);
-    this.evaluationY = Buffer.from(res[1]);
+    const proof = Buffer.from(res[0]);
+    const evaluationY = Buffer.from(res[1]);
+
+    return new Blob(dataWithoutZeros, fieldsHash, challengeZ, evaluationY, commitment, proof);
   }
 
   // 48 bytes encoded in fields as [Fr, Fr] = [0->31, 31->48]
   commitmentToFields(): [Fr, Fr] {
-    return [new Fr(this.commitment.subarray(0, 31)), new Fr(this.commitment.subarray(31, 48))];
+    return commitmentToFields(this.commitment);
   }
 
   // Returns ethereum's versioned blob hash, following kzg_to_versioned_hash: https://eips.ethereum.org/EIPS/eip-4844#helpers
@@ -93,6 +92,49 @@ export class Blob {
     return hash;
   }
 
+  toBuffer(): Buffer {
+    return Buffer.from(
+      serializeToBuffer(
+        this.data.length,
+        this.data,
+        this.fieldsHash,
+        this.challengeZ,
+        this.evaluationY.length,
+        this.evaluationY,
+        this.commitment.length,
+        this.commitment,
+        this.proof.length,
+        this.proof,
+      ),
+    );
+  }
+
+  static fromBuffer(buf: Buffer | BufferReader): Blob {
+    const reader = BufferReader.asReader(buf);
+    return new Blob(
+      reader.readUint8Array(),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readBuffer(),
+      reader.readBuffer(),
+      reader.readBuffer(),
+    );
+  }
+
+  /**
+   * Pad the blob data to it's full size before posting
+   */
+  get dataWithZeros(): BlobBuffer {
+    return Buffer.concat([this.data], BYTES_PER_BLOB);
+  }
+
+  /**
+   * Get the size of the blob in bytes
+   */
+  getSize() {
+    return this.data.length;
+  }
+
   // Returns a proof of opening of the blob to verify on L1 using the point evaluation precompile:
   //  * input[:32]     - versioned_hash
   //  * input[32:64]   - z
@@ -145,8 +187,13 @@ export class Blob {
     const res = [];
     for (let i = 0; i < numBlobs; i++) {
       const end = fields.length < (i + 1) * FIELD_ELEMENTS_PER_BLOB ? fields.length : (i + 1) * FIELD_ELEMENTS_PER_BLOB;
-      res.push(new Blob(fields.slice(i * FIELD_ELEMENTS_PER_BLOB, end), multiBlobFieldsHash));
+      res.push(Blob.fromFields(fields.slice(i * FIELD_ELEMENTS_PER_BLOB, end), multiBlobFieldsHash));
     }
     return res;
   }
 }
+
+// 48 bytes encoded in fields as [Fr, Fr] = [0->31, 31->48]
+function commitmentToFields(commitment: Buffer): [Fr, Fr] {
+  return [new Fr(commitment.subarray(0, 31)), new Fr(commitment.subarray(31, 48))];
+}

package/src/config/env_var.ts

@@ -100,6 +100,7 @@ export type EnvVar =
   | 'P2P_UDP_ANNOUNCE_ADDR'
   | 'P2P_UDP_LISTEN_ADDR'
   | 'PEER_ID_PRIVATE_KEY'
+  | 'PROVER_BLOB_SINK_URL'
   | 'PROOF_VERIFIER_L1_START_BLOCK'
   | 'PROOF_VERIFIER_POLL_INTERVAL_MS'
   | 'PROVER_AGENT_ENABLED'
@@ -112,7 +113,6 @@ export type EnvVar =
   | 'PROVER_BROKER_JOB_TIMEOUT_MS'
   | 'PROVER_BROKER_POLL_INTERVAL_MS'
   | 'PROVER_BROKER_JOB_MAX_RETRIES'
-  | 'PROVER_BROKER_DATA_DIRECTORY'
   | 'PROVER_COORDINATION_NODE_URL'
   | 'PROVER_DISABLED'
   | 'PROVER_ID'
@@ -121,6 +121,9 @@ export type EnvVar =
   | 'PROVER_NODE_POLLING_INTERVAL_MS'
   | 'PROVER_NODE_MAX_PENDING_JOBS'
   | 'PROVER_NODE_MAX_PARALLEL_BLOCKS_PER_EPOCH'
+  | 'PROVER_NODE_TX_GATHERING_TIMEOUT_MS'
+  | 'PROVER_NODE_TX_GATHERING_INTERVAL_MS'
+  | 'PROVER_NODE_TX_GATHERING_MAX_PARALLEL_REQUESTS'
   | 'PROVER_PUBLISH_RETRY_INTERVAL_MS'
   | 'PROVER_PUBLISHER_PRIVATE_KEY'
   | 'PROVER_REAL_PROOFS'
@@ -136,9 +139,12 @@ export type EnvVar =
   | 'REGISTRY_CONTRACT_ADDRESS'
   | 'ROLLUP_CONTRACT_ADDRESS'
   | 'SEQ_ALLOWED_SETUP_FN'
+  | 'SEQ_BLOB_SINK_URL'
   | 'SEQ_MAX_BLOCK_SIZE_IN_BYTES'
   | 'SEQ_MAX_TX_PER_BLOCK'
   | 'SEQ_MIN_TX_PER_BLOCK'
+  | 'SEQ_MAX_DA_BLOCK_GAS'
+  | 'SEQ_MAX_L2_BLOCK_GAS'
   | 'SEQ_PUBLISH_RETRY_INTERVAL_MS'
   | 'SEQ_PUBLISHER_PRIVATE_KEY'
   | 'SEQ_REQUIRED_CONFIRMATIONS'
@@ -182,8 +188,10 @@ export type EnvVar =
   | 'L1_GAS_LIMIT_BUFFER_FIXED'
   | 'L1_GAS_PRICE_MIN'
   | 'L1_GAS_PRICE_MAX'
+  | 'L1_BLOB_FEE_PER_GAS_MAX'
   | 'L1_PRIORITY_FEE_BUMP_PERCENTAGE'
   | 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE'
+  | 'L1_FIXED_PRIORITY_FEE_PER_GAS'
   | 'L1_TX_MONITOR_MAX_ATTEMPTS'
   | 'L1_TX_MONITOR_CHECK_INTERVAL_MS'
   | 'L1_TX_MONITOR_STALL_TIME_MS'

package/src/fields/point.ts

@@ -10,6 +10,7 @@ import { Fr } from './fields.js';
  * Represents a Point on an elliptic curve with x and y coordinates.
  * The Point class provides methods for creating instances from different input types,
  * converting instances to various output formats, and checking the equality of points.
+ * TODO(#7386): Clean up this class.
  */
 export class Point {
   static ZERO = new Point(Fr.ZERO, Fr.ZERO, false);

package/src/json-rpc/server/safe_json_rpc_server.ts

@@ -24,6 +24,11 @@ export class SafeJsonRpcServer {
   constructor(
     /** The proxy object to delegate requests to. */
     private readonly proxy: Proxy,
+    /**
+     *  Return an HTTP 200 status code on errors, but include an error object
+     *  as per the JSON RPC spec
+     */
+    private http200OnError = false,
     /** Health check function */
     private readonly healthCheck: StatusCheckFn = () => true,
     /** Logger */
@@ -105,9 +110,17 @@ export class SafeJsonRpcServer {
         ctx.status = 400;
         ctx.body = { jsonrpc, id, error: { code: -32601, message: `Method not found: ${method}` } };
       } else {
-        const result = await this.proxy.call(method, params);
-        ctx.body = { jsonrpc, id, result };
         ctx.status = 200;
+        try {
+          const result = await this.proxy.call(method, params);
+          ctx.body = { jsonrpc, id, result };
+        } catch (err: any) {
+          if (this.http200OnError) {
+            ctx.body = { jsonrpc, id, error: { code: err.code || -32600, data: err.data, message: err.message } };
+          } else {
+            throw err;
+          }
+        }
       }
     });
 
@@ -259,20 +272,22 @@ function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: Lo
  */
 export function createNamespacedSafeJsonRpcServer(
   handlers: NamespacedApiHandlers,
+  http200OnError = false,
   log = createLogger('json-rpc:server'),
 ): SafeJsonRpcServer {
   const proxy = new NamespacedSafeJsonProxy(handlers);
   const healthCheck = makeAggregateHealthcheck(handlers, log);
-  return new SafeJsonRpcServer(proxy, healthCheck, log);
+  return new SafeJsonRpcServer(proxy, http200OnError, healthCheck, log);
 }
 
 export function createSafeJsonRpcServer<T extends object = any>(
   handler: T,
   schema: ApiSchemaFor<T>,
+  http200OnError = false,
   healthCheck?: StatusCheckFn,
 ) {
   const proxy = new SafeJsonProxy(handler, schema);
-  return new SafeJsonRpcServer(proxy, healthCheck);
+  return new SafeJsonRpcServer(proxy, http200OnError, healthCheck);
 }
 
 /**

package/src/promise/running-promise.ts

@@ -23,6 +23,10 @@ export class RunningPromise {
    * Starts the running promise.
    */
   public start() {
+    if (this.running) {
+      this.logger.warn(`Attempted to start running promise that was already started`);
+      return;
+    }
     this.running = true;
 
     const poll = async () => {
@@ -54,6 +58,10 @@ export class RunningPromise {
    * and waits for the currently executing function to complete.
    */
   async stop(): Promise<void> {
+    if (!this.running) {
+      this.logger.warn(`Running promise was not started`);
+      return;
+    }
     this.running = false;
     this.interruptibleSleep.interrupt();
     await this.runningPromise;

package/src/queue/serial_queue.ts

@@ -6,6 +6,7 @@ import { FifoMemoryQueue } from './fifo_memory_queue.js';
 export class SerialQueue {
   private readonly queue = new FifoMemoryQueue<() => Promise<void>>();
   private runningPromise!: Promise<void>;
+  private started = false;
 
   /**
    * Initializes the execution of enqueued functions in the serial queue.
@@ -14,7 +15,11 @@ export class SerialQueue {
    * This method should be called once to start processing the queue.
    */
   public start() {
+    if (this.started) {
+      return;
+    }
     this.runningPromise = this.queue.process(fn => fn());
+    this.started = true;
   }
 
   /**

package/src/retry/index.ts

@@ -1,3 +1,4 @@
+import { TimeoutError } from '../error/index.js';
 import { createLogger } from '../log/index.js';
 import { sleep } from '../sleep/index.js';
 import { Timer } from '../timer/index.js';
@@ -93,7 +94,7 @@ export async function retryUntil<T>(fn: () => Promise<T | undefined>, name = '',
     await sleep(interval * 1000);
 
     if (timeout && timer.s() > timeout) {
-      throw new Error(name ? `Timeout awaiting ${name}` : 'Timeout');
+      throw new TimeoutError(name ? `Timeout awaiting ${name}` : 'Timeout');
     }
   }
 }

package/src/serialize/buffer_reader.ts

@@ -307,6 +307,20 @@ export class BufferReader {
     return this.readBytes(size);
   }
 
+  /**
+   * Reads a buffer from the current position of the reader and advances the index.
+   * The method first reads the size (number) of bytes to be read, and then returns
+   * a Buffer with that size containing the bytes. Useful for reading variable-length
+   * binary data encoded as (size, data) format.
+   *
+   * @returns A Buffer containing the read bytes.
+   */
+  public readUint8Array(): Uint8Array {
+    const size = this.readNumber();
+    this.#rangeCheck(size);
+    return this.readBytes(size);
+  }
+
   /**
    * Reads and constructs a map object from the current buffer using the provided deserializer.
    * The method reads the number of entries in the map, followed by iterating through each key-value pair.

package/src/serialize/serialize.ts

@@ -109,6 +109,7 @@ export function deserializeField(buf: Buffer, offset = 0) {
 export type Bufferable =
   | boolean
   | Buffer
+  | Uint8Array
   | number
   | bigint
   | string

package/src/testing/files/index.ts

@@ -43,7 +43,7 @@ export function updateInlineTestData(targetFileFromRepoRoot: string, itemName: s
 /**
  * Updates the sample Prover.toml files in noir-projects/noir-protocol-circuits/crates/.
  * @remarks Requires AZTEC_GENERATE_TEST_DATA=1 to be set
- * To re-gen, run 'AZTEC_GENERATE_TEST_DATA=1 FAKE_PROOFS=1 yarn test:e2e-no-docker full.test '
+ * To re-gen, run 'AZTEC_GENERATE_TEST_DATA=1 FAKE_PROOFS=1 yarn test:e2e full.test '
  */
 export function updateProtocolCircuitSampleInputs(circuitName: string, value: string) {
   const logger = createConsoleLogger('aztec:testing:test_data');

package/src/trees/index.ts

@@ -1,4 +1,5 @@
-export * from './unbalanced_merkle_root.js';
+export * from './unbalanced_merkle_tree.js';
+export * from './unbalanced_tree_store.js';
 
 /**
  * A leaf of an indexed merkle tree.

package/src/trees/unbalanced_merkle_tree.ts

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

package/src/trees/unbalanced_tree_store.ts

@@ -0,0 +1,102 @@
+import { findLeafLevelAndIndex } from './unbalanced_merkle_tree.js';
+
+export interface TreeNodeLocation {
+  level: number;
+  index: number;
+}
+
+interface TreeNode<T> {
+  value: T;
+  location: TreeNodeLocation;
+}
+
+export class UnbalancedTreeStore<T> {
+  #nodeMapping: Map<string, TreeNode<T>> = new Map();
+  readonly #numLeaves: number;
+
+  constructor(numLeaves: number) {
+    this.#numLeaves = numLeaves;
+  }
+
+  setLeaf(leafIndex: number, value: T): TreeNodeLocation {
+    if (leafIndex >= this.#numLeaves) {
+      throw new Error(`Expected at most ${this.#numLeaves} leaves. Received a leaf at index ${leafIndex}.`);
+    }
+
+    const { level, indexAtLevel } = findLeafLevelAndIndex(this.#numLeaves, leafIndex);
+    const location = {
+      level,
+      index: indexAtLevel,
+    };
+    this.#nodeMapping.set(this.#getKey(location), {
+      location,
+      value,
+    });
+    return location;
+  }
+
+  setNode({ level, index }: TreeNodeLocation, value: T) {
+    const location = {
+      level,
+      index,
+    };
+    this.#nodeMapping.set(this.#getKey(location), {
+      location,
+      value,
+    });
+  }
+
+  getParentLocation({ level, index }: TreeNodeLocation): TreeNodeLocation {
+    if (level === 0) {
+      throw new Error('Tree root does not have a parent.');
+    }
+
+    return { level: level - 1, index: Math.floor(index / 2) };
+  }
+
+  getSiblingLocation({ level, index }: TreeNodeLocation): TreeNodeLocation {
+    if (level === 0) {
+      throw new Error('Tree root does not have a sibling.');
+    }
+
+    return { level, index: index % 2 ? index - 1 : index + 1 };
+  }
+
+  getChildLocations({ level, index }: TreeNodeLocation): [TreeNodeLocation, TreeNodeLocation] {
+    const left = { level: level + 1, index: index * 2 };
+    const right = { level: level + 1, index: index * 2 + 1 };
+    return [left, right];
+  }
+
+  getLeaf(leafIndex: number) {
+    const { level, indexAtLevel } = findLeafLevelAndIndex(this.#numLeaves, leafIndex);
+    const location = {
+      level,
+      index: indexAtLevel,
+    };
+    return this.getNode(location);
+  }
+
+  getNode(location: TreeNodeLocation): T | undefined {
+    return this.#nodeMapping.get(this.#getKey(location))?.value;
+  }
+
+  getParent(location: TreeNodeLocation): T | undefined {
+    const parentLocation = this.getParentLocation(location);
+    return this.getNode(parentLocation);
+  }
+
+  getSibling(location: TreeNodeLocation): T | undefined {
+    const siblingLocation = this.getSiblingLocation(location);
+    return this.getNode(siblingLocation);
+  }
+
+  getChildren(location: TreeNodeLocation): [T | undefined, T | undefined] {
+    const [left, right] = this.getChildLocations(location);
+    return [this.getNode(left), this.getNode(right)];
+  }
+
+  #getKey(location: TreeNodeLocation) {
+    return `${location.level}-${location.index}`;
+  }
+}

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

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

package/src/trees/unbalanced_merkle_root.ts

@@ -1,52 +0,0 @@
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { sha256Trunc } from '@aztec/foundation/crypto';
-
-/**
- * Computes the merkle root for an unbalanced tree.
- *
- * @dev Adapted from proving-state.ts -> findMergeLevel and unbalanced_tree.ts.
- * Calculates the tree upwards layer by layer until we reach the root.
- * The L1 calculation instead computes the tree from right to left (slightly cheaper gas).
- * TODO: A more thorough investigation of which method is cheaper, then use that method everywhere.
- */
-export function computeUnbalancedMerkleRoot(leaves: 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);
-    }
-  }
-
-  const depth = Math.ceil(Math.log2(leaves.length));
-  let [layerWidth, nodeToShift] =
-    leaves.length & 1 ? [leaves.length - 1, leaves[leaves.length - 1]] : [leaves.length, Buffer.alloc(0)];
-  // Allocate this layer's leaves and init the next layer up
-  let thisLayer = leaves.slice(0, layerWidth);
-  let nextLayer = [];
-  for (let i = 0; i < depth; i++) {
-    for (let j = 0; j < layerWidth; j += 2) {
-      // Store the hash of each pair one layer up
-      nextLayer[j / 2] = hasher(Buffer.concat([thisLayer[j], thisLayer[j + 1]]));
-    }
-    layerWidth /= 2;
-    if (layerWidth & 1) {
-      if (nodeToShift.length) {
-        // If the next layer has odd length, and we have a node that needs to be shifted up, add it here
-        nextLayer.push(nodeToShift);
-        layerWidth += 1;
-        nodeToShift = Buffer.alloc(0);
-      } else {
-        // If we don't have a node waiting to be shifted, store the next layer's final node to be shifted
-        layerWidth -= 1;
-        nodeToShift = nextLayer[layerWidth];
-      }
-    }
-    // reset the layers
-    thisLayer = nextLayer;
-    nextLayer = [];
-  }
-  // return the root
-  return thisLayer[0];
-}