feat: circuit optimized indexed tree batch insertion (#3367)

Changes the batch insertion algorithm for indexed trees to a
circuit-optimized one.

yarn-project/circuits.js/src/structs/rollup/base_rollup.ts

@@ -144,6 +144,14 @@ export class BaseRollupInputs {
      */
     public startHistoricBlocksTreeSnapshot: AppendOnlyTreeSnapshot,
 
+    /**
+     * The nullifiers to be inserted in the tree, sorted high to low.
+     */
+    public sortedNewNullifiers: Tuple<Fr, typeof MAX_NEW_NULLIFIERS_PER_BASE_ROLLUP>,
+    /**
+     * The indexes of the sorted nullifiers to the original ones.
+     */
+    public sortednewNullifiersIndexes: Tuple<UInt32, typeof MAX_NEW_NULLIFIERS_PER_BASE_ROLLUP>,
     /**
      * The nullifiers which need to be updated to perform the batch insertion of the new nullifiers.
      * See `StandardIndexedTree.batchInsert` function for more details.
@@ -210,6 +218,8 @@ export class BaseRollupInputs {
       fields.startContractTreeSnapshot,
       fields.startPublicDataTreeRoot,
       fields.startHistoricBlocksTreeSnapshot,
+      fields.sortedNewNullifiers,
+      fields.sortednewNullifiersIndexes,
       fields.lowNullifierLeafPreimages,
       fields.lowNullifierMembershipWitness,
       fields.newCommitmentsSubtreeSiblingPath,

yarn-project/circuits.js/src/tests/factories.ts

@@ -920,20 +920,23 @@ export function makeBaseRollupInputs(seed = 0): BaseRollupInputs {
   const newNullifiersSubtreeSiblingPath = makeTuple(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, fr, seed + 0x4000);
   const newContractsSubtreeSiblingPath = makeTuple(CONTRACT_SUBTREE_SIBLING_PATH_LENGTH, fr, seed + 0x5000);
 
+  const sortedNewNullifiers = makeTuple(MAX_NEW_NULLIFIERS_PER_BASE_ROLLUP, fr, seed + 0x6000);
+  const sortednewNullifiersIndexes = makeTuple(MAX_NEW_NULLIFIERS_PER_BASE_ROLLUP, i => i, seed + 0x7000);
+
   const newPublicDataUpdateRequestsSiblingPaths = makeTuple(
     MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_BASE_ROLLUP,
     x => makeTuple(PUBLIC_DATA_TREE_HEIGHT, fr, x),
-    seed + 0x6000,
+    seed + 0x8000,
   );
 
   const newPublicDataReadsSiblingPaths = makeTuple(
     MAX_PUBLIC_DATA_READS_PER_BASE_ROLLUP,
     x => makeTuple(PUBLIC_DATA_TREE_HEIGHT, fr, x),
-    seed + 0x6000,
+    seed + 0x8000,
   );
 
   const historicBlocksTreeRootMembershipWitnesses = makeTuple(KERNELS_PER_BASE_ROLLUP, x =>
-    makeMembershipWitness(HISTORIC_BLOCKS_TREE_HEIGHT, seed + x * 0x1000 + 0x7000),
+    makeMembershipWitness(HISTORIC_BLOCKS_TREE_HEIGHT, seed + x * 0x1000 + 0x9000),
   );
 
   const constants = makeConstantBaseRollupData(0x100);
@@ -946,6 +949,8 @@ export function makeBaseRollupInputs(seed = 0): BaseRollupInputs {
     startContractTreeSnapshot,
     startPublicDataTreeRoot,
     startHistoricBlocksTreeSnapshot,
+    sortedNewNullifiers,
+    sortednewNullifiersIndexes,
     lowNullifierLeafPreimages,
     newCommitmentsSubtreeSiblingPath,
     newNullifiersSubtreeSiblingPath,

yarn-project/merkle-tree/src/interfaces/indexed_tree.ts

@@ -3,6 +3,28 @@ import { LeafData, SiblingPath } from '@aztec/types';
 import { LowLeafWitnessData } from '../index.js';
 import { AppendOnlyTree } from './append_only_tree.js';
 
+/**
+ * The result of a batch insertion in an indexed merkle tree.
+ */
+export interface BatchInsertionResult<TreeHeight extends number, SubtreeSiblingPathHeight extends number> {
+  /**
+   * Data for the leaves to be updated when inserting the new ones.
+   */
+  lowLeavesWitnessData?: LowLeafWitnessData<TreeHeight>[];
+  /**
+   * Sibling path "pointing to" where the new subtree should be inserted into the tree.
+   */
+  newSubtreeSiblingPath: SiblingPath<SubtreeSiblingPathHeight>;
+  /**
+   * The new leaves being inserted in high to low order. This order corresponds with the order of the low leaves witness.
+   */
+  sortedNewLeaves: Buffer[];
+  /**
+   * The indexes of the sorted new leaves to the original ones.
+   */
+  sortedNewLeavesIndexes: number[];
+}
+
 /**
  * Indexed merkle tree.
  */
@@ -45,8 +67,5 @@ export interface IndexedTree extends AppendOnlyTree {
     leaves: Buffer[],
     subtreeHeight: SubtreeHeight,
     includeUncommitted: boolean,
-  ): Promise<
-    | [LowLeafWitnessData<TreeHeight>[], SiblingPath<SubtreeSiblingPathHeight>]
-    | [undefined, SiblingPath<SubtreeSiblingPathHeight>]
-  >;
+  ): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>>;
 }