@aztec/merkle-tree 0.1.0-alpha17 → 0.1.0-alpha21

package/dest/tree_base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree_base.d.ts","sourceRoot":"","sources":["../src/tree_base.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAKzD,eAAO,MAAM,cAAc,SAAU,MAAM,SAAS,MAAM,SAAS,MAAM,WAAgC,CAAC;AAO1G,eAAO,MAAM,UAAU,SAAU,MAAM;;;;CAStC,CAAC;AAEF,eAAO,MAAM,YAAY,QAAyF,CAAC;AAEnH;;GAEG;AACH,8BAAsB,QAAS,YAAW,UAAU;IAQhD,SAAS,CAAC,EAAE,EAAE,OAAO;IACrB,SAAS,CAAC,MAAM,EAAE,MAAM;IACxB,SAAS,CAAC,IAAI,EAAE,MAAM;IACtB,SAAS,CAAC,KAAK,EAAE,MAAM;IACvB,SAAS,CAAC,IAAI,EAAE,MAAM;IAXxB,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IACpC,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC9B,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,UAAU,CAAgB;IAClC,SAAS,CAAC,KAAK,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAM;gBAGpC,EAAE,EAAE,OAAO,EACX,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,MAAW,EAC3B,IAAI,CAAC,EAAE,MAAM;IAiBf;;;;OAIG;IACI,OAAO,CAAC,kBAAkB,EAAE,OAAO,GAAG,MAAM;IAInD;;;;OAIG;IACI,YAAY,CAAC,kBAAkB,EAAE,OAAO;IAI/C;;;OAGG;IACI,OAAO,IAAI,MAAM;IAIxB;;;OAGG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;;;;OAMG;IACU,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAalH;;;OAGG;IACU,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAapC;;;OAGG;IACI,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAKhC;;;;;OAKG;IACI,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAI5F;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB;;;;OAIG;cACa,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAkBvE;;;;;;;OAOG;cACa,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAYjH;;;;OAIG;YACW,KAAK;IAInB;;;;OAIG;IAEU,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKvD;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxC;;;OAGG;cACa,SAAS,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC;CAQ/D"}
+{"version":3,"file":"tree_base.d.ts","sourceRoot":"","sources":["../src/tree_base.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAYzD,eAAO,MAAM,UAAU,SAAU,MAAM;;;;CAStC,CAAC;AAEF,eAAO,MAAM,YAAY,QAAyF,CAAC;AAEnH;;GAEG;AACH,8BAAsB,QAAS,YAAW,UAAU;IAQhD,SAAS,CAAC,EAAE,EAAE,OAAO;IACrB,SAAS,CAAC,MAAM,EAAE,MAAM;IACxB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,KAAK;IACb,SAAS,CAAC,IAAI,EAAE,MAAM;IAXxB,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IACpC,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC9B,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,KAAK,CAAiC;gBAGlC,EAAE,EAAE,OAAO,EACX,MAAM,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACX,IAAI,GAAE,MAAW,EAC3B,IAAI,CAAC,EAAE,MAAM;IAiBf;;;;OAIG;IACI,OAAO,CAAC,kBAAkB,EAAE,OAAO,GAAG,MAAM;IAInD;;;;OAIG;IACI,YAAY,CAAC,kBAAkB,EAAE,OAAO;IAI/C;;;OAGG;IACI,OAAO,IAAI,MAAM;IAIxB;;;OAGG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;;;;OAMG;IACU,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAalH;;;OAGG;IACU,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAapC;;;OAGG;IACI,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAKhC;;;;;OAKG;IACI,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAI5F;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB;;;;OAIG;cACa,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAkBvE;;;;;;;OAOG;YACW,qBAAqB;IAYnC;;;;OAIG;YACW,KAAK;IAInB;;;;OAIG;IAEU,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKvD;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxC;;;OAGG;cACa,SAAS,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC;IAS9D;;;;;;;;;;;;;;OAcG;cACa,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CA+B9D"}

package/dest/tree_base.js

@@ -1,7 +1,7 @@
 import { SiblingPath } from './sibling_path/sibling_path.js';
 import { toBigIntLE, toBufferLE } from '@aztec/foundation/bigint-buffer';
 const MAX_DEPTH = 254;
-export const indexToKeyHash = (name, level, index) => `${name}:${level}:${index}`;
+const indexToKeyHash = (name, level, index) => `${name}:${level}:${index}`;
 const encodeMeta = (root, depth, size) => {
     const data = Buffer.alloc(36);
     root.copy(data);
@@ -45,7 +45,7 @@ export class TreeBase {
     }
     /**
      * Returns the root of the tree.
-     * @param includeUncommitted - If true, root incorporating uncomitted changes is returned.
+     * @param includeUncommitted - If true, root incorporating uncommitted changes is returned.
      * @returns The root of the tree.
      */
     getRoot(includeUncommitted) {
@@ -53,7 +53,7 @@ export class TreeBase {
     }
     /**
      * Returns the number of leaves in the tree.
-     * @param includeUncommitted - If true, the returned number of leaves includes uncomitted changes.
+     * @param includeUncommitted - If true, the returned number of leaves includes uncommitted changes.
      * @returns The number of leaves in the tree.
      */
     getNumLeaves(includeUncommitted) {
@@ -195,7 +195,7 @@ export class TreeBase {
      * Initializes the tree from the database.
      */
     async initFromDb() {
-        // Implemented only by Inedexed Tree to populate the leaf cache.
+        // Implemented only by Indexed Tree to populate the leaf cache.
     }
     /**
      * Writes meta data to the provided batch.
@@ -210,5 +210,48 @@ export class TreeBase {
             await this.db.put(this.name, data);
         }
     }
+    /**
+     * Appends the given leaves to the tree.
+     * @param leaves - The leaves to append.
+     * @returns Empty promise.
+     *
+     * @remarks The batch insertion algorithm works as follows:
+     *          1. Insert all the leaves,
+     *          2. start iterating over levels from the bottom up,
+     *          3. on each level iterate over all the affected nodes (i.e. nodes whose preimages have changed),
+     *          4. fetch the preimage, hash it and insert the updated value.
+     * @remarks This algorithm is optimal when it comes to the number of hashing operations. It might not be optimal when
+     *          it comes to the number of database reads, but that should be irrelevant given that most of the time
+     *          `getLatestValueAtIndex` will return a value from cache (because at least one of the 2 children was
+     *          touched in previous iteration).
+     */
+    async appendLeaves(leaves) {
+        const numLeaves = this.getNumLeaves(true);
+        if (numLeaves + BigInt(leaves.length) - 1n > this.maxIndex) {
+            throw Error(`Can't append beyond max index. Max index: ${this.maxIndex}`);
+        }
+        // 1. Insert all the leaves
+        let firstIndex = numLeaves;
+        let level = this.depth;
+        for (let i = 0; i < leaves.length; i++) {
+            const cacheKey = indexToKeyHash(this.name, level, firstIndex + BigInt(i));
+            this.cache[cacheKey] = leaves[i];
+        }
+        let lastIndex = firstIndex + BigInt(leaves.length);
+        // 2. Iterate over all the levels from the bottom up
+        while (level > 0) {
+            firstIndex >>= 1n;
+            lastIndex >>= 1n;
+            // 3.Iterate over all the affected nodes at this level and update them
+            for (let index = firstIndex; index <= lastIndex; index++) {
+                const lhs = await this.getLatestValueAtIndex(level, index * 2n, true);
+                const rhs = await this.getLatestValueAtIndex(level, index * 2n + 1n, true);
+                const cacheKey = indexToKeyHash(this.name, level - 1, index);
+                this.cache[cacheKey] = this.hasher.compress(lhs, rhs);
+            }
+            level -= 1;
+        }
+        this.cachedSize = numLeaves + BigInt(leaves.length);
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree_base.js","sourceRoot":"","sources":["../src/tree_base.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@aztec/merkle-tree",
-  "version": "0.1.0-alpha17",
+  "version": "0.1.0-alpha21",
   "exports": "./dest/index.js",
   "type": "module",
   "dependencies": {
-    "@aztec/circuits.js": "0.1.0-alpha17",
-    "@aztec/foundation": "0.1.0-alpha17",
+    "@aztec/circuits.js": "0.1.0-alpha21",
+    "@aztec/foundation": "0.1.0-alpha21",
     "levelup": "^5.1.1",
     "memdown": "^6.1.1",
     "sha256": "^0.2.0",

package/src/interfaces/indexed_tree.ts

@@ -51,24 +51,14 @@ export interface IndexedTree extends AppendOnlyTree {
    */
   getLatestLeafDataCopy(index: number, includeUncommitted: boolean): LeafData | undefined;
 
-  /**
-   * Exposes the underlying tree's update leaf method.
-   * @param leaf - The hash to set at the leaf.
-   * @param index - The index of the element.
-   */
-  // TODO: remove once the batch insertion functionality is moved to StandardIndexedTree from circuit_block_builder.ts
-  updateLeaf(leaf: LeafData, index: bigint): Promise<void>;
-
   /**
    * Batch insert multiple leaves into the tree.
    * @param leaves - Leaves to insert into the tree.
-   * @param treeHeight - Height of the tree.
    * @param subtreeHeight - Height of the subtree.
    * @param includeUncommitted - If true, the uncommitted changes are included in the search.
    */
   batchInsert<TreeHeight extends number, SubtreeHeight extends number, SubtreeSiblingPathHeight extends number>(
     leaves: Buffer[],
-    treeHeight: TreeHeight,
     subtreeHeight: SubtreeHeight,
     includeUncommitted: boolean,
   ): Promise<

package/src/new_tree.ts

@@ -18,7 +18,7 @@ export async function newTree<T extends TreeBase>(
   hasher: Hasher,
   name: string,
   depth: number,
-  prefilledSize = 0,
+  prefilledSize = 1,
 ): Promise<T> {
   const tree = new c(db, hasher, name, depth, 0n, undefined);
   await tree.init(prefilledSize);

package/src/standard_indexed_tree/standard_indexed_tree.ts

@@ -1,6 +1,5 @@
 import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { createLogger } from '@aztec/foundation/log';
-import { Hasher } from '../hasher.js';
 import { IndexedTree, LeafData } from '../interfaces/indexed_tree.js';
 import { TreeBase } from '../tree_base.js';
 import { SiblingPath } from '../index.js';
@@ -56,10 +55,6 @@ const encodeTreeValue = (leafData: LeafData) => {
   return Buffer.concat([valueAsBuffer, indexAsBuffer, nextValueAsBuffer]);
 };
 
-const hashEncodedTreeValue = (leaf: LeafData, hasher: Hasher) => {
-  return hasher.compressInputs([leaf.value, leaf.nextIndex, leaf.nextValue].map(val => toBufferBE(val, 32)));
-};
-
 const decodeTreeValue = (buf: Buffer) => {
   const value = toBigIntBE(buf.subarray(0, 32));
   const nextIndex = toBigIntBE(buf.subarray(32, 64));
@@ -71,28 +66,21 @@ const decodeTreeValue = (buf: Buffer) => {
   } as LeafData;
 };
 
-const initialLeaf: LeafData = {
-  value: 0n,
-  nextIndex: 0n,
-  nextValue: 0n,
-};
-
 /**
  * Indexed merkle tree.
  */
 export class StandardIndexedTree extends TreeBase implements IndexedTree {
-  private leaves: LeafData[] = [];
-  private cachedLeaves: { [key: number]: LeafData } = {};
+  protected leaves: LeafData[] = [];
+  protected cachedLeaves: { [key: number]: LeafData } = {};
 
   /**
    * Appends the given leaves to the tree.
-   * @param leaves - The leaves to append.
+   * @param _leaves - The leaves to append.
    * @returns Empty promise.
+   * @remarks Use batchInsert method instead.
    */
-  public async appendLeaves(leaves: Buffer[]): Promise<void> {
-    for (const leaf of leaves) {
-      await this.appendLeaf(leaf);
-    }
+  public appendLeaves(_leaves: Buffer[]): Promise<void> {
+    throw new Error('Not implemented');
   }
 
   /**
@@ -183,48 +171,6 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
       : undefined;
   }
 
-  /**
-   * Appends the given leaf to the tree.
-   * @param leaf - The leaf to append.
-   * @returns Empty promise.
-   */
-  private async appendLeaf(leaf: Buffer): Promise<void> {
-    const newValue = toBigIntBE(leaf);
-
-    // Special case when appending zero
-    if (newValue === 0n) {
-      const newSize = (this.cachedSize ?? this.size) + 1n;
-      if (newSize - 1n > this.maxIndex) {
-        throw Error(`Can't append beyond max index. Max index: ${this.maxIndex}`);
-      }
-      this.cachedSize = newSize;
-      return;
-    }
-
-    const indexOfPrevious = this.findIndexOfPreviousValue(newValue, true);
-    const previousLeafCopy = this.getLatestLeafDataCopy(indexOfPrevious.index, true);
-
-    if (previousLeafCopy === undefined) {
-      throw new Error(`Previous leaf not found!`);
-    }
-    const newLeaf = {
-      value: newValue,
-      nextIndex: previousLeafCopy.nextIndex,
-      nextValue: previousLeafCopy.nextValue,
-    } as LeafData;
-    if (indexOfPrevious.alreadyPresent) {
-      return;
-    }
-    // insert a new leaf at the highest index and update the values of our previous leaf copy
-    const currentSize = this.getNumLeaves(true);
-    previousLeafCopy.nextIndex = BigInt(currentSize);
-    previousLeafCopy.nextValue = newLeaf.value;
-    this.cachedLeaves[Number(currentSize)] = newLeaf;
-    this.cachedLeaves[Number(indexOfPrevious.index)] = previousLeafCopy;
-    await this._updateLeaf(hashEncodedTreeValue(previousLeafCopy, this.hasher), BigInt(indexOfPrevious.index));
-    await this._updateLeaf(hashEncodedTreeValue(newLeaf, this.hasher), this.getNumLeaves(true));
-  }
-
   /**
    * Finds the index of the minimum value in an array.
    * @param values - The collection of values to be searched.
@@ -247,15 +193,39 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
    * Initializes the tree.
    * @param prefilledSize - A number of leaves that are prefilled with values.
    * @returns Empty promise.
+   *
+   * @remarks Explanation of pre-filling:
+   *    There needs to be an initial (0,0,0) leaf in the tree, so that when we insert the first 'proper' leaf, we can
+   *    prove that any value greater than 0 doesn't exist in the tree yet. We prefill/pad the tree with "the number of
+   *    leaves that are added by one block" so that the first 'proper' block can insert a full subtree.
+   *
+   *    Without this padding, there would be a leaf (0,0,0) at leaf index 0, making it really difficult to insert e.g.
+   *    1024 leaves for the first block, because there's only neat space for 1023 leaves after 0. By padding with 1023
+   *    more leaves, we can then insert the first block of 1024 leaves into indices 1024:2047.
    */
   public async init(prefilledSize: number): Promise<void> {
-    this.leaves.push(initialLeaf);
-    await this._updateLeaf(hashEncodedTreeValue(initialLeaf, this.hasher), 0n);
+    if (prefilledSize < 1) {
+      throw new Error(`Prefilled size must be at least 1!`);
+    }
 
-    for (let i = 1; i < prefilledSize; i++) {
-      await this.appendLeaf(Buffer.from([i]));
+    const leaves: LeafData[] = [];
+    for (let i = 0n; i < prefilledSize; i++) {
+      const newLeaf = {
+        value: toBigIntBE(Buffer.from([Number(i)])),
+        nextIndex: i + 1n,
+        nextValue: i + 1n,
+      };
+      leaves.push(newLeaf);
     }
 
+    // Make the first leaf have 0 value
+    leaves[0].value = 0n;
+
+    // Make the last leaf point to the first leaf
+    leaves[prefilledSize - 1].nextIndex = 0n;
+    leaves[prefilledSize - 1].nextValue = 0n;
+
+    await this.encodeAndAppendLeaves(leaves, true);
     await this.commit();
   }
 
@@ -315,35 +285,19 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
    * @param leaf - New contents of the leaf.
    * @param index - Index of the leaf to be updated.
    */
-  // TODO: rename back to updateLeaf once the old updateLeaf is removed
-  private async _updateLeaf(leaf: Buffer, index: bigint) {
+  protected async updateLeaf(leaf: LeafData, index: bigint) {
     if (index > this.maxIndex) {
       throw Error(`Index out of bounds. Index ${index}, max index: ${this.maxIndex}.`);
     }
-    await this.addLeafToCacheAndHashToRoot(leaf, index);
+
+    const encodedLeaf = this.encodeLeaf(leaf, true);
+    await this.addLeafToCacheAndHashToRoot(encodedLeaf, index);
     const numLeaves = this.getNumLeaves(true);
     if (index >= numLeaves) {
       this.cachedSize = index + 1n;
     }
   }
 
-  /**
-   * Exposes the underlying tree's update leaf method.
-   * @param leaf - The hash to set at the leaf.
-   * @param index - The index of the element.
-   */
-  // TODO: remove once the batch insertion functionality is moved here from circuit_block_builder.ts
-  public async updateLeaf(leaf: LeafData, index: bigint): Promise<void> {
-    let encodedLeaf;
-    if (leaf.value == 0n) {
-      encodedLeaf = toBufferBE(0n, 32);
-    } else {
-      encodedLeaf = hashEncodedTreeValue(leaf, this.hasher);
-    }
-    this.cachedLeaves[Number(index)] = leaf;
-    await this._updateLeaf(encodedLeaf, index);
-  }
-
   /* eslint-disable jsdoc/require-description-complete-sentence */
   /* The following doc block messes up with complete-sentence, so we just disable it */
 
@@ -366,8 +320,8 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
    *
    * Algorithm overview
    *
-   * In general, if we want to batch insert items, we first to update their low nullifier to point to them,
-   * then batch insert all of the values as at once in the final step.
+   * In general, if we want to batch insert items, we first need to update their low nullifier to point to them,
+   * then batch insert all of the values at once in the final step.
    * To update a low nullifier, we provide an insertion proof that the low nullifier currently exists to the
    * circuit, then update the low nullifier.
    * Updating this low nullifier will in turn change the root of the tree. Therefore future low nullifier insertion proofs
@@ -422,7 +376,7 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
    *  nextVal   2      10      15       0         3       5       -       -
    *
    * Inserting 20: (happy path)
-   * 1. Find the low nullifier (15) - provide inculsion proof
+   * 1. Find the low nullifier (15) - provide inclusion proof
    * 2. Update its pointers
    * 3. Insert 20 into the pending subtree
    *
@@ -454,7 +408,6 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
    *
    * TODO: this implementation will change once the zero value is changed from h(0,0,0). Changes incoming over the next sprint
    * @param leaves - Values to insert into the tree.
-   * @param treeHeight - Height of the tree.
    * @param subtreeHeight - Height of the subtree.
    * @returns The data for the leaves to be updated when inserting the new ones.
    */
@@ -464,7 +417,6 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
     SubtreeSiblingPathHeight extends number,
   >(
     leaves: Buffer[],
-    treeHeight: TreeHeight,
     subtreeHeight: SubtreeHeight,
   ): Promise<
     | [LowLeafWitnessData<TreeHeight>[], SiblingPath<SubtreeSiblingPathHeight>]
@@ -473,7 +425,7 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
     // Keep track of touched low leaves
     const touched = new Map<number, bigint[]>();
 
-    const emptyLowLeafWitness = getEmptyLowLeafWitness(treeHeight);
+    const emptyLowLeafWitness = getEmptyLowLeafWitness(this.getDepth() as TreeHeight);
     // Accumulators
     const lowLeavesWitnesses: LowLeafWitnessData<TreeHeight>[] = [];
     const pendingInsertionSubtree: LeafData[] = [];
@@ -494,7 +446,7 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
 
       const indexOfPrevious = this.findIndexOfPreviousValue(newValue, true);
 
-      // If a touched node has a value that is less greater than the current value
+      // If a touched node has a value that is less than the current value
       const prevNodes = touched.get(indexOfPrevious.index);
       if (prevNodes && prevNodes.some(v => v < newValue)) {
         // check the pending low nullifiers for a low nullifier that works
@@ -561,7 +513,9 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
         lowLeaf.nextValue = newValue;
         lowLeaf.nextIndex = startInsertionIndex + BigInt(i);
 
-        await this.updateLeaf(lowLeaf, BigInt(indexOfPrevious.index));
+        const lowLeafIndex = indexOfPrevious.index;
+        this.cachedLeaves[lowLeafIndex] = lowLeaf;
+        await this.updateLeaf(lowLeaf, BigInt(lowLeafIndex));
       }
     }
 
@@ -571,10 +525,9 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
     );
 
     // Perform batch insertion of new pending values
-    for (let i = 0; i < pendingInsertionSubtree.length; i++) {
-      await this.updateLeaf(pendingInsertionSubtree[i], startInsertionIndex + BigInt(i));
-    }
-
+    // Note: In this case we set `hash0Leaf` param to false because batch insertion algorithm use forced null leaf
+    // inclusion. See {@link encodeLeaf} for  a more through param explanation.
+    await this.encodeAndAppendLeaves(pendingInsertionSubtree, false);
     return [lowLeavesWitnesses, newSubtreeSiblingPath];
   }
 
@@ -588,4 +541,41 @@ export class StandardIndexedTree extends TreeBase implements IndexedTree {
     // Drop the first subtreeHeight items since we only care about the path to the subtree root
     return fullSiblingPath.getSubtreeSiblingPath(subtreeHeight);
   }
+
+  /**
+   * Encodes leaves and appends them to a tree.
+   * @param leaves - Leaves to encode.
+   * @param hash0Leaf - Indicates whether 0 value leaf should be hashed. See {@link encodeLeaf}.
+   * @returns Empty promise
+   */
+  private async encodeAndAppendLeaves(leaves: LeafData[], hash0Leaf: boolean): Promise<void> {
+    const startInsertionIndex = Number(this.getNumLeaves(true));
+
+    const serialisedLeaves = leaves.map((leaf, i) => {
+      this.cachedLeaves[startInsertionIndex + i] = leaf;
+      return this.encodeLeaf(leaf, hash0Leaf);
+    });
+
+    await super.appendLeaves(serialisedLeaves);
+  }
+
+  /**
+   * Encode a leaf into a buffer.
+   * @param leaf - Leaf to encode.
+   * @param hash0Leaf - Indicates whether 0 value leaf should be hashed. Not hashing 0 value can represent a forced
+   *                    null leaf insertion. Detecting this case by checking for 0 value is safe as in the case of
+   *                    nullifier it is improbable that a valid nullifier would be 0.
+   * @returns Leaf encoded in a buffer.
+   */
+  private encodeLeaf(leaf: LeafData, hash0Leaf: boolean): Buffer {
+    let encodedLeaf;
+    if (!hash0Leaf && leaf.value == 0n) {
+      encodedLeaf = toBufferBE(0n, 32);
+    } else {
+      encodedLeaf = this.hasher.compressInputs(
+        [leaf.value, leaf.nextIndex, leaf.nextValue].map(val => toBufferBE(val, 32)),
+      );
+    }
+    return encodedLeaf;
+  }
 }

package/src/standard_indexed_tree/{standard_indexed_tree.test.ts → test/standard_indexed_tree.test.ts}

@@ -1,21 +1,21 @@
 import { default as levelup } from 'levelup';
-import { Hasher, INITIAL_LEAF, MerkleTree, Pedersen, SiblingPath } from '../index.js';
-import { StandardIndexedTree } from './standard_indexed_tree.js';
-import { treeTestSuite } from '../test/test_suite.js';
+import { Hasher, INITIAL_LEAF, MerkleTree, Pedersen, SiblingPath } from '../../index.js';
+import { treeTestSuite } from '../../test/test_suite.js';
 
-import { createMemDown } from '../test/utils/create_mem_down.js';
-import { newTree } from '../new_tree.js';
-import { loadTree } from '../load_tree.js';
+import { createMemDown } from '../../test/utils/create_mem_down.js';
+import { newTree } from '../../new_tree.js';
+import { loadTree } from '../../load_tree.js';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { IWasmModule } from '@aztec/foundation/wasm';
 import { CircuitsWasm } from '@aztec/circuits.js';
+import { StandardIndexedTreeWithAppend } from './standard_indexed_tree_with_append.js';
 
-const createDb = async (levelUp: levelup.LevelUp, hasher: Hasher, name: string, depth: number) => {
-  return await newTree(StandardIndexedTree, levelUp, hasher, name, depth);
+const createDb = async (levelUp: levelup.LevelUp, hasher: Hasher, name: string, depth: number, prefilledSize = 1) => {
+  return await newTree(StandardIndexedTreeWithAppend, levelUp, hasher, name, depth, prefilledSize);
 };
 
 const createFromName = async (levelUp: levelup.LevelUp, hasher: Hasher, name: string) => {
-  return await loadTree(StandardIndexedTree, levelUp, hasher, name);
+  return await loadTree(StandardIndexedTreeWithAppend, levelUp, hasher, name);
 };
 
 const createIndexedTreeLeaf = (value: number, nextIndex: number, nextValue: number) => {
@@ -447,4 +447,30 @@ describe('StandardIndexedTreeSpecific', () => {
       expect(await tree.getSiblingPath(BigInt(i), false)).toEqual(await tree.getSiblingPath(BigInt(i), true));
     }
   });
+
+  // For varying orders of insertions assert the local batch insertion generator creates the correct proofs
+  it.each([
+    // These are arbitrary but it needs to be higher than the constant `INITIAL_NULLIFIER_TREE_SIZE` and `KERNEL_NEW_NULLIFIERS_LENGTH * 2`
+    [[1003, 1002, 1001, 1000, 0, 0, 0, 0]],
+    [[1003, 1004, 1005, 1006, 0, 0, 0, 0]],
+    [[1234, 1098, 0, 0, 99999, 1096, 1054, 0]],
+    [[1970, 1980, 1040, 0, 99999, 1880, 100001, 9000000]],
+  ] as const)('performs nullifier tree batch insertion correctly', async nullifiers => {
+    const leaves = nullifiers.map(i => toBufferBE(BigInt(i), 32));
+
+    const TREE_HEIGHT = 16; // originally from NULLIFIER_TREE_HEIGHT
+    const INITIAL_TREE_SIZE = 8; // originally from INITIAL_NULLIFIER_TREE_SIZE
+    const SUBTREE_HEIGHT = 5; // originally from BaseRollupInputs.NULLIFIER_SUBTREE_HEIGHT
+
+    // Create a depth-3 indexed merkle tree
+    const appendTree = await createDb(levelup(createMemDown()), pedersen, 'test', TREE_HEIGHT, INITIAL_TREE_SIZE);
+    const insertTree = await createDb(levelup(createMemDown()), pedersen, 'test', TREE_HEIGHT, INITIAL_TREE_SIZE);
+
+    await appendTree.appendLeaves(leaves);
+    await insertTree.batchInsert(leaves, SUBTREE_HEIGHT);
+
+    const expectedRoot = appendTree.getRoot(true);
+    const actualRoot = insertTree.getRoot(true);
+    expect(actualRoot).toEqual(expectedRoot);
+  });
 });

package/src/standard_indexed_tree/test/standard_indexed_tree_with_append.ts

@@ -0,0 +1,63 @@
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { LeafData, StandardIndexedTree } from '../../index.js';
+
+/**
+ * A testing utility which is here to store the original implementation of StandardIndexedTree.appendLeaves method
+ * that was replaced by the more efficient batchInsert method. We keep the original implementation around as it useful
+ * for testing that the more complex batchInsert method works correctly.
+ */
+export class StandardIndexedTreeWithAppend extends StandardIndexedTree {
+  /**
+   * Appends the given leaves to the tree.
+   * @param leaves - The leaves to append.
+   * @returns Empty promise.
+   * @remarks This method is inefficient and is here mostly for testing. Use batchInsert instead.
+   */
+  public async appendLeaves(leaves: Buffer[]): Promise<void> {
+    for (const leaf of leaves) {
+      await this.appendLeaf(leaf);
+    }
+  }
+
+  /**
+   * Appends the given leaf to the tree.
+   * @param leaf - The leaf to append.
+   * @returns Empty promise.
+   */
+  private async appendLeaf(leaf: Buffer): Promise<void> {
+    const newValue = toBigIntBE(leaf);
+
+    // Special case when appending zero
+    if (newValue === 0n) {
+      const newSize = (this.cachedSize ?? this.size) + 1n;
+      if (newSize - 1n > this.maxIndex) {
+        throw Error(`Can't append beyond max index. Max index: ${this.maxIndex}`);
+      }
+      this.cachedSize = newSize;
+      return;
+    }
+
+    const indexOfPrevious = this.findIndexOfPreviousValue(newValue, true);
+    const previousLeafCopy = this.getLatestLeafDataCopy(indexOfPrevious.index, true);
+
+    if (previousLeafCopy === undefined) {
+      throw new Error(`Previous leaf not found!`);
+    }
+    const newLeaf = {
+      value: newValue,
+      nextIndex: previousLeafCopy.nextIndex,
+      nextValue: previousLeafCopy.nextValue,
+    } as LeafData;
+    if (indexOfPrevious.alreadyPresent) {
+      return;
+    }
+    // insert a new leaf at the highest index and update the values of our previous leaf copy
+    const currentSize = this.getNumLeaves(true);
+    previousLeafCopy.nextIndex = BigInt(currentSize);
+    previousLeafCopy.nextValue = newLeaf.value;
+    this.cachedLeaves[Number(currentSize)] = newLeaf;
+    this.cachedLeaves[Number(indexOfPrevious.index)] = previousLeafCopy;
+    await this.updateLeaf(previousLeafCopy, BigInt(indexOfPrevious.index));
+    await this.updateLeaf(newLeaf, this.getNumLeaves(true));
+  }
+}