Sync protocol optimization

CHANGELOG.md

@@ -9,6 +9,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - [\#353](https://github.com/Manta-Network/manta-rs/pull/353) Restore Merkle tree pruning for the wallet.
 
 ### Changed
+- [\#357](https://github.com/Manta-Network/manta-rs/pull/357) Sync protocol optimization.
 - [\#356](https://github.com/Manta-Network/manta-rs/pull/356) Signer ToPublic optimization.
 
 ### Deprecated

manta-crypto/src/merkle_tree/node.rs

@@ -568,7 +568,7 @@ impl NodeRange {
             }
         };
         for i in range {
-            result.push(Node(i).join_leaves(parameters, &leaves[i], &leaves[i + 1]))
+            result.push(parameters.join_leaves(&leaves[i], &leaves[i + 1]));
         }
         if dual_parity.final_parity().is_left() {
             result.push(self.last_node().join_leaves(

manta-crypto/src/merkle_tree/partial.rs

@@ -385,15 +385,23 @@ where
         let marked_leaf_digests = marked_leaf_digests.into_iter();
         if matches!(marked_leaf_digests.size_hint().1, Some(max) if max <= capacity::<C, _>() - self.len())
         {
+            let mut marked_inserts = Vec::new();
             for (marking, leaf_digest) in marked_leaf_digests {
                 if marking {
-                    assert!(self.push_digest(parameters, || leaf_digest),
-                    "Unable to push digest even though the tree should have enough capacity to do so.");
+                    marked_inserts.push(leaf_digest);
                 } else {
+                    if !marked_inserts.is_empty() {
+                        assert!(self.batch_push_digest(parameters, || marked_inserts.drain(..).collect::<Vec<_>>()),
+                        "Unable to push digest even though the tree should have enough capacity to do so.");
+                    }
                     assert!(self.push_provable_digest(parameters, move || leaf_digest),
                     "Unable to push digest even though the tree should have enough capacity to do so.");
                 }
             }
+            if !marked_inserts.is_empty() {
+                assert!(self.batch_push_digest(parameters, || marked_inserts.drain(..).collect::<Vec<_>>()),
+                "Unable to push digest even though the tree should have enough capacity to do so.");
+            }
             return Ok(());
         }
         Err(marked_leaf_digests)

manta-crypto/src/merkle_tree/test/batch_insertion.rs

@@ -114,3 +114,45 @@ fn test_batch_insertion_forest() {
         |forest, _, leaves| forest.batch_insert(leaves),
     )
 }
+
+/// Tests that [`merge_fork_partial`] returns the same root as [`merge_fork`].
+///
+/// [`merge_fork`]: ForkedTree::merge_fork
+/// [`merge_fork_partial`]: ForkedTree::merge_fork_partial
+#[inline]
+fn branch_and_merge_test() {
+    let mut rng = OsRng;
+    let parameters = Parameters::sample(Default::default(), &mut rng);
+    let mut tree = ForkedTree::new(Partial::new(&parameters), &parameters);
+    let number_of_insertions = rng.gen_range(1..(1 << (HEIGHT - 1)) / 2);
+    let insertions = (0..number_of_insertions)
+        .map(|_| rng.gen())
+        .collect::<Vec<_>>();
+    for leaf in insertions {
+        Tree::push(&mut tree, &parameters, &leaf);
+    }
+    tree.merge_fork(&parameters);
+    let second_number_of_insertions = rng.gen_range(number_of_insertions..(1 << (HEIGHT - 1)));
+    let insertions = (number_of_insertions..second_number_of_insertions)
+        .map(|_| rng.gen())
+        .collect::<Vec<_>>();
+    for leaf in insertions {
+        Tree::push(&mut tree, &parameters, &leaf);
+    }
+    let mut cloned_tree = tree.clone();
+    tree.merge_fork_partial(&parameters);
+    cloned_tree.merge_fork(&parameters);
+    assert_eq!(
+        tree.root(),
+        cloned_tree.root(),
+        "Merge fork and merge fork partial should return the same Merkle root"
+    );
+}
+
+/// Runs [`branch_and_merge_test`] 10 times.
+#[test]
+fn branch_and_merge_test_10_times() {
+    for _ in 0..10 {
+        branch_and_merge_test();
+    }
+}