Batch insert

CHANGELOG.md

@@ -5,6 +5,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 ### Added
+- [\#330](https://github.com/Manta-Network/manta-rs/pull/330) Merkle tree batch insertions.
 
 ### Changed
 

manta-accounting/src/wallet/signer/functions.rs

@@ -42,7 +42,9 @@ use crate::{
 };
 use alloc::{vec, vec::Vec};
 use manta_crypto::{
-    accumulator::{Accumulator, FromItemsAndWitnesses, ItemHashFunction, OptimizedAccumulator},
+    accumulator::{
+        Accumulator, BatchInsertion, FromItemsAndWitnesses, ItemHashFunction, OptimizedAccumulator,
+    },
     rand::Rand,
 };
 use manta_util::{
@@ -216,9 +218,14 @@ where
     let mut deposit = Vec::new();
     let mut withdraw = Vec::new();
     let decryption_key = parameters.derive_decryption_key(authorization_context);
+    let mut nonprovable_inserts = Vec::new();
     for (utxo, note) in inserts {
         if let Some((identifier, asset)) = parameters.open_with_check(&decryption_key, &utxo, note)
         {
+            if !nonprovable_inserts.is_empty() {
+                utxo_accumulator.batch_insert_nonprovable(&nonprovable_inserts);
+                nonprovable_inserts.clear();
+            }
             insert_next_item::<C>(
                 authorization_context,
                 utxo_accumulator,
@@ -231,9 +238,12 @@ where
                 rng,
             );
         } else {
-            utxo_accumulator.insert_nonprovable(&item_hash::<C>(parameters, &utxo));
+            nonprovable_inserts.push(item_hash::<C>(parameters, &utxo));
         }
     }
+    if !nonprovable_inserts.is_empty() {
+        utxo_accumulator.batch_insert_nonprovable(&nonprovable_inserts);
+    }
     assets.retain(|identifier, assets| {
         assets.retain(|asset| {
             is_asset_unspent::<C>(

manta-accounting/src/wallet/signer/mod.rs

@@ -41,7 +41,7 @@ use alloc::{boxed::Box, vec::Vec};
 use core::{convert::Infallible, fmt::Debug, hash::Hash};
 use manta_crypto::{
     accumulator::{
-        Accumulator, ExactSizeAccumulator, FromItemsAndWitnesses, ItemHashFunction,
+        Accumulator, BatchInsertion, ExactSizeAccumulator, FromItemsAndWitnesses, ItemHashFunction,
         OptimizedAccumulator,
     },
     rand::{CryptoRng, FromEntropy, RngCore},
@@ -867,7 +867,8 @@ pub trait Configuration: transfer::Configuration {
             Item = UtxoAccumulatorItem<Self>,
             Model = UtxoAccumulatorModel<Self>,
             Witness = UtxoAccumulatorWitness<Self>,
-        > + ExactSizeAccumulator
+        > + BatchInsertion
+        + ExactSizeAccumulator
         + FromItemsAndWitnesses
         + OptimizedAccumulator
         + Rollback;
@@ -1074,6 +1075,19 @@ where
         self.accounts = None
     }
 
+    /// Tries to load `authorization_context_option` to `self`.
+    #[inline]
+    pub fn try_load_authorization_context(
+        &mut self,
+        authorization_context_option: Option<AuthorizationContext<C>>,
+    ) -> bool {
+        if let Some(authorization_context) = authorization_context_option {
+            self.load_authorization_context(authorization_context);
+            return true;
+        }
+        false
+    }
+
     /// Loads `authorization_context` to `self`.
     #[inline]
     pub fn load_authorization_context(&mut self, authorization_context: AuthorizationContext<C>) {
@@ -1088,14 +1102,14 @@ where
 
     /// Returns the [`AccountTable`].
     #[inline]
-    pub fn accounts(&self) -> &Option<AccountTable<C>> {
-        &self.accounts
+    pub fn accounts(&self) -> Option<&AccountTable<C>> {
+        self.accounts.as_ref()
     }
 
     /// Returns the [`AuthorizationContext`].
     #[inline]
-    pub fn authorization_context(&self) -> &Option<AuthorizationContext<C>> {
-        &self.authorization_context
+    pub fn authorization_context(&self) -> Option<&AuthorizationContext<C>> {
+        self.authorization_context.as_ref()
     }
 
     /// Returns the default account for `self`.
@@ -1232,6 +1246,16 @@ where
         self.state.drop_accounts()
     }
 
+    /// Tries to load `authorization_context_option` to `self`.
+    #[inline]
+    pub fn try_load_authorization_context(
+        &mut self,
+        authorization_context_option: Option<AuthorizationContext<C>>,
+    ) -> bool {
+        self.state
+            .try_load_authorization_context(authorization_context_option)
+    }
+
     /// Loads `authorization_context` to `self`.
     #[inline]
     pub fn load_authorization_context(&mut self, authorization_context: AuthorizationContext<C>) {
@@ -1359,6 +1383,12 @@ where
         ))
     }
 
+    /// Returns the [`AuthorizationContext`] corresponding to `self`.
+    #[inline]
+    pub fn authorization_context(&self) -> Option<&AuthorizationContext<C>> {
+        self.state.authorization_context.as_ref()
+    }
+
     /// Returns the associated [`TransactionData`] of `post`, namely the [`Asset`] and the
     /// [`Identifier`]. Returns `None` if `post` has an invalid shape, or if `self` doesn't own the
     /// underlying assets in `post`.

manta-crypto/src/accumulator.rs

@@ -203,6 +203,57 @@ pub trait OptimizedAccumulator: Accumulator {
     }
 }
 
+/// Batch Insertion
+pub trait BatchInsertion: OptimizedAccumulator {
+    /// Inserts `items` in `self` provably, see [`insert`] for more details.
+    /// Returns `true` if all the insertions succeed and `false` otherwise.
+    ///
+    /// # Implementation Note
+    ///
+    /// By default, this method calls [`insert`] individually for each item in `items`
+    /// till failure. Custom implementations of this method to improve performance
+    /// may insert a subset of `items` in case of failure.
+    ///
+    /// [`insert`]: Accumulator::insert
+    #[inline]
+    fn batch_insert<'a, I>(&mut self, items: I) -> bool
+    where
+        Self::Item: 'a,
+        I: IntoIterator<Item = &'a Self::Item>,
+    {
+        for item in items {
+            if !self.insert(item) {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// Inserts `items` in `self` nonprovably, see [`insert_nonprovable`] for more details.
+    /// Returns `true` if all the insertions succeed and `false` otherwise.
+    ///
+    /// # Implementation Note
+    ///
+    /// By default, this method calls [`insert_nonprovable`] individually for each item
+    /// in `items` till failure. Custom implementations of this method to improve performance
+    /// may insert a subset of `items` in case of failure.
+    ///
+    /// [`insert_nonprovable`]: OptimizedAccumulator::insert_nonprovable
+    #[inline]
+    fn batch_insert_nonprovable<'a, I>(&mut self, items: I) -> bool
+    where
+        Self::Item: 'a,
+        I: IntoIterator<Item = &'a Self::Item>,
+    {
+        for item in items {
+            if !self.insert_nonprovable(item) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
 /// From Items and Witnesses
 pub trait FromItemsAndWitnesses: Accumulator {
     /// Number of Subaccumulators

manta-crypto/src/merkle_tree/forest.rs

@@ -24,7 +24,7 @@
 
 use crate::{
     accumulator::{
-        self, Accumulator, ConstantCapacityAccumulator, ExactSizeAccumulator,
+        self, Accumulator, BatchInsertion, ConstantCapacityAccumulator, ExactSizeAccumulator,
         FromItemsAndWitnesses, MembershipProof, OptimizedAccumulator,
     },
     merkle_tree::{
@@ -37,7 +37,7 @@ use crate::{
     },
 };
 use alloc::{boxed::Box, vec::Vec};
-use core::{fmt::Debug, hash::Hash, marker::PhantomData};
+use core::{fmt::Debug, hash::Hash, iter::Iterator, marker::PhantomData};
 use manta_util::{persistence::Rollback, BoxArray};
 
 #[cfg(feature = "serde")]
@@ -593,6 +593,50 @@ macro_rules! impl_from_items_and_witnesses {
                 result
             }
         }
+
+        impl<C, const N: usize> BatchInsertion for $forest
+        where
+            C: Configuration + ?Sized,
+            C::Index: FixedIndex<N>,
+            Parameters<C>: Clone,
+            Leaf<C>: Clone,
+            LeafDigest<C>: Clone + Default + PartialEq,
+            InnerDigest<C>: Clone + Default + PartialEq,
+        {
+            #[inline]
+            fn batch_insert<'a, I>(&mut self, items: I) -> bool
+            where
+                Self::Item: 'a,
+                I: IntoIterator<Item = &'a Self::Item>,
+            {
+                let mut result = true;
+                for (index, group) in Self::sort_items(items.into_iter().cloned().collect())
+                    .into_iter()
+                    .enumerate()
+                {
+                    let tree = self.forest.get_mut(C::Index::from_index(index));
+                    result &= tree.batch_push_provable(&self.parameters, &group);
+                }
+                result
+            }
+
+            #[inline]
+            fn batch_insert_nonprovable<'a, I>(&mut self, items: I) -> bool
+            where
+                Self::Item: 'a,
+                I: IntoIterator<Item = &'a Self::Item>,
+            {
+                let mut result = true;
+                for (index, group) in Self::sort_items(items.into_iter().cloned().collect())
+                    .into_iter()
+                    .enumerate()
+                {
+                    let tree = self.forest.get_mut(C::Index::from_index(index));
+                    result &= tree.batch_push(&self.parameters, &group);
+                }
+                result
+            }
+        }
     };
 }
 

manta-crypto/src/merkle_tree/fork.rs

@@ -521,6 +521,20 @@ where
         self.data.push(parameters, leaf)
     }
 
+    /// Appends `leaf_digests` onto this branch.
+    #[inline]
+    fn batch_maybe_push_digest<F>(
+        &mut self,
+        parameters: &Parameters<C>,
+        leaf_digests: F,
+    ) -> Option<bool>
+    where
+        F: FnOnce() -> Vec<LeafDigest<C>>,
+        LeafDigest<C>: Default,
+    {
+        self.data.batch_maybe_push_digest(parameters, leaf_digests)
+    }
+
     /// Appends a new `leaf_digest` onto this branch.
     #[inline]
     fn maybe_push_digest<F>(&mut self, parameters: &Parameters<C>, leaf_digest: F) -> Option<bool>
@@ -758,6 +772,25 @@ where
         self.check_attachment()?;
         self.branch.maybe_push_digest(parameters, leaf_digest)
     }
+
+    /// Appends `leaf_digests` onto this fork.
+    ///
+    /// Returns `None` if this fork has been detached from its trunk. Use [`attach`](Self::attach)
+    /// to re-associate a trunk to this fork.
+    #[inline]
+    pub fn batch_maybe_push_digest<F>(
+        &mut self,
+        parameters: &Parameters<C>,
+        leaf_digests: F,
+    ) -> Option<bool>
+    where
+        F: FnOnce() -> Vec<LeafDigest<C>>,
+        LeafDigest<C>: Default,
+    {
+        self.check_attachment()?;
+        self.branch
+            .batch_maybe_push_digest(parameters, leaf_digests)
+    }
 }
 
 /// Forked Tree
@@ -908,6 +941,21 @@ where
         self.branch.maybe_push_digest(parameters, leaf_digest)
     }
 
+    /// Appends `leaf_digests` onto this forked tree.
+    #[inline]
+    fn batch_maybe_push_digest<F>(
+        &mut self,
+        parameters: &Parameters<C>,
+        leaf_digests: F,
+    ) -> Option<bool>
+    where
+        F: FnOnce() -> Vec<LeafDigest<C>>,
+        LeafDigest<C>: Default,
+    {
+        self.branch
+            .batch_maybe_push_digest(parameters, leaf_digests)
+    }
+
     /// Resets the fork of the base tree back to the trunk.
     #[inline]
     pub fn reset_fork(&mut self, parameters: &Parameters<C>)
@@ -992,6 +1040,18 @@ where
     {
         self.maybe_push_digest(parameters, leaf_digest)
     }
+
+    #[inline]
+    fn batch_maybe_push_digest<F>(
+        &mut self,
+        parameters: &Parameters<C>,
+        leaf_digests: F,
+    ) -> Option<bool>
+    where
+        F: FnOnce() -> Vec<LeafDigest<C>>,
+    {
+        self.batch_maybe_push_digest(parameters, leaf_digests)
+    }
 }
 
 impl<C, T, M> WithProofs<C> for ForkedTree<C, T, M>
@@ -1028,4 +1088,16 @@ where
     fn path(&self, parameters: &Parameters<C>, index: usize) -> Result<Path<C>, PathError> {
         self.path(parameters, index)
     }
+
+    #[inline]
+    fn batch_maybe_push_provable_digest<F>(
+        &mut self,
+        parameters: &Parameters<C>,
+        leaf_digests: F,
+    ) -> Option<bool>
+    where
+        F: FnOnce() -> Vec<LeafDigest<C>>,
+    {
+        self.batch_maybe_push_digest(parameters, leaf_digests)
+    }
 }