Merge pull request #17 from yangby-cryptape/pr/release-v0.4.0

chore: bump version to v0.4.0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ckb-merkle-mountain-range"
-version = "0.3.1"
+version = "0.4.0"
 authors = ["Nervos Core Dev <dev@nervos.org>"]
 edition = "2018"
 license = "MIT"

README.md

@@ -38,7 +38,7 @@ For example, we insert a leaf to the example MMR:
 3. insert parent node to position `20`.
 4. the node `20` also has a left sibling `17`, calculate parent node: `merge(mmr[17], mmr[20])`.
 5. insert new node to next position `21`.
-6. the node `20` have no left sibling, complete the insertion.
+6. the node `21` have no left sibling, complete the insertion.
 
 Example MMR after insertion of a new leaf:
 

benches/mmr_benchmark.rs

@@ -1,7 +1,7 @@
 #[macro_use]
 extern crate criterion;
 
-use criterion::Criterion;
+use criterion::{BenchmarkId, Criterion};
 
 use bytes::Bytes;
 use ckb_merkle_mountain_range::{util::MemStore, Error, MMRStore, Merge, Result, MMR};
@@ -31,13 +31,13 @@ struct MergeNumberHash;
 
 impl Merge for MergeNumberHash {
     type Item = NumberHash;
-    fn merge(lhs: &Self::Item, rhs: &Self::Item) -> Self::Item {
+    fn merge(lhs: &Self::Item, rhs: &Self::Item) -> Result<Self::Item> {
         let mut hasher = new_blake2b();
         let mut hash = [0u8; 32];
         hasher.update(&lhs.0);
         hasher.update(&rhs.0);
         hasher.finalize(&mut hash);
-        NumberHash(hash.to_vec().into())
+        Ok(NumberHash(hash.to_vec().into()))
     }
 }
 
@@ -53,13 +53,15 @@ fn prepare_mmr(count: u32) -> (u64, MemStore<NumberHash>, Vec<u64>) {
 }
 
 fn bench(c: &mut Criterion) {
-    c.bench_function_over_inputs(
-        "MMR insert",
-        |b, &&size| {
-            b.iter(|| prepare_mmr(size));
-        },
-        &[10_000, 100_000, 100_0000],
-    );
+    {
+        let mut group = c.benchmark_group("MMR insertion");
+        let inputs = [10_000, 100_000, 100_0000];
+        for input in inputs.iter() {
+            group.bench_with_input(BenchmarkId::new("times", input), &input, |b, &&size| {
+                b.iter(|| prepare_mmr(size));
+            });
+        }
+    }
 
     c.bench_function("MMR gen proof", |b| {
         let (mmr_size, store, positions) = prepare_mmr(100_0000);

src/error.rs

@@ -9,6 +9,9 @@ pub enum Error {
     CorruptedProof,
     /// The leaves is an empty list, or beyond the mmr range
     GenProofForInvalidLeaves,
+
+    /// The two nodes couldn't merge into one.
+    MergeError(crate::string::String),
 }
 
 impl core::fmt::Display for Error {
@@ -20,6 +23,7 @@ impl core::fmt::Display for Error {
             StoreError(msg) => write!(f, "Store error {}", msg)?,
             CorruptedProof => write!(f, "Corrupted proof")?,
             GenProofForInvalidLeaves => write!(f, "Generate proof ofr invalid leaves")?,
+            MergeError(msg) => write!(f, "Merge error {}", msg)?,
         }
         Ok(())
     }

src/lib.rs

@@ -1,7 +1,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 mod error;
-mod helper;
+pub mod helper;
 mod merge;
 mod mmr;
 mod mmr_store;

src/merge.rs

@@ -1,4 +1,11 @@
+use crate::Result;
+
 pub trait Merge {
     type Item;
-    fn merge(left: &Self::Item, right: &Self::Item) -> Self::Item;
+
+    fn merge(left: &Self::Item, right: &Self::Item) -> Result<Self::Item>;
+
+    fn merge_peaks(peak1: &Self::Item, peak2: &Self::Item) -> Result<Self::Item> {
+        Self::merge(peak1, peak2)
+    }
 }

src/mmr.rs

@@ -14,6 +14,7 @@ use crate::{Error, Merge, Result};
 use core::fmt::Debug;
 use core::marker::PhantomData;
 
+#[allow(clippy::upper_case_acronyms)]
 pub struct MMR<T, M, S: MMRStore<T>> {
     mmr_size: u64,
     batch: MMRBatch<T, S>,
@@ -62,7 +63,7 @@ impl<'a, T: Clone + PartialEq + Debug, M: Merge<Item = T>, S: MMRStore<T>> MMR<T
             let right_pos = left_pos + sibling_offset(height);
             let left_elem = self.find_elem(left_pos, &elems)?;
             let right_elem = self.find_elem(right_pos, &elems)?;
-            let parent_elem = M::merge(&left_elem, &right_elem);
+            let parent_elem = M::merge(&left_elem, &right_elem)?;
             elems.push(parent_elem);
             height += 1
         }
@@ -95,7 +96,7 @@ impl<'a, T: Clone + PartialEq + Debug, M: Merge<Item = T>, S: MMRStore<T>> MMR<T
         while rhs_peaks.len() > 1 {
             let right_peak = rhs_peaks.pop().expect("pop");
             let left_peak = rhs_peaks.pop().expect("pop");
-            rhs_peaks.push(M::merge(&right_peak, &left_peak));
+            rhs_peaks.push(M::merge_peaks(&right_peak, &left_peak)?);
         }
         Ok(rhs_peaks.pop())
     }
@@ -319,7 +320,7 @@ fn calculate_peak_root<
             M::merge(&sibling_item, &item)
         } else {
             M::merge(&item, &sibling_item)
-        };
+        }?;
 
         if parent_pos < peak_pos {
             queue.push_back((parent_pos, parent_item, height + 1));
@@ -393,7 +394,7 @@ fn bagging_peaks_hashes<'a, T: 'a + PartialEq + Debug + Clone, M: Merge<Item = T
     while peaks_hashes.len() > 1 {
         let right_peak = peaks_hashes.pop().expect("pop");
         let left_peak = peaks_hashes.pop().expect("pop");
-        peaks_hashes.push(M::merge(&right_peak, &left_peak));
+        peaks_hashes.push(M::merge_peaks(&right_peak, &left_peak)?);
     }
     peaks_hashes.pop().ok_or(Error::CorruptedProof)
 }

src/tests/mod.rs

@@ -1,8 +1,9 @@
 mod test_accumulate_headers;
 mod test_helper;
 mod test_mmr;
+mod test_sequence;
 
-use crate::Merge;
+use crate::{Merge, Result};
 use blake2b_rs::{Blake2b, Blake2bBuilder};
 use bytes::Bytes;
 
@@ -26,12 +27,12 @@ struct MergeNumberHash;
 
 impl Merge for MergeNumberHash {
     type Item = NumberHash;
-    fn merge(lhs: &Self::Item, rhs: &Self::Item) -> Self::Item {
+    fn merge(lhs: &Self::Item, rhs: &Self::Item) -> Result<Self::Item> {
         let mut hasher = new_blake2b();
         let mut hash = [0u8; 32];
         hasher.update(&lhs.0);
         hasher.update(&rhs.0);
         hasher.finalize(&mut hash);
-        NumberHash(hash.to_vec().into())
+        Ok(NumberHash(hash.to_vec().into()))
     }
 }

src/tests/test_accumulate_headers.rs

@@ -72,17 +72,17 @@ struct MergeHashWithTD;
 
 impl Merge for MergeHashWithTD {
     type Item = HashWithTD;
-    fn merge(lhs: &Self::Item, rhs: &Self::Item) -> Self::Item {
+    fn merge(lhs: &Self::Item, rhs: &Self::Item) -> Result<Self::Item> {
         let mut hasher = new_blake2b();
         let mut hash = [0u8; 32];
         hasher.update(&lhs.serialize());
         hasher.update(&rhs.serialize());
         hasher.finalize(&mut hash);
         let td = lhs.td + rhs.td;
-        HashWithTD {
+        Ok(HashWithTD {
             hash: hash.to_vec().into(),
             td,
-        }
+        })
     }
 }
 

src/tests/test_sequence.rs

@@ -0,0 +1,98 @@
+use std::fmt;
+
+use proptest::proptest;
+use rand::{prelude::*, thread_rng};
+
+use crate::{util::MemStore, Merge, Result, MMR};
+
+#[derive(Eq, PartialEq, Clone, Default)]
+struct NumberRange {
+    start: u32,
+    end: u32,
+}
+
+struct MergeNumberRange;
+
+impl fmt::Debug for NumberRange {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "NumberRange({}, {})", self.start, self.end)
+    }
+}
+
+impl fmt::Debug for MergeNumberRange {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "MergeNumberRange")
+    }
+}
+
+impl From<u32> for NumberRange {
+    fn from(num: u32) -> Self {
+        Self {
+            start: num,
+            end: num,
+        }
+    }
+}
+
+impl NumberRange {
+    fn is_normalized(&self) -> bool {
+        self.start <= self.end
+    }
+}
+
+impl Merge for MergeNumberRange {
+    type Item = NumberRange;
+    fn merge(lhs: &Self::Item, rhs: &Self::Item) -> Result<Self::Item> {
+        Ok(Self::Item {
+            start: lhs.start,
+            end: rhs.end,
+        })
+    }
+    fn merge_peaks(lhs: &Self::Item, rhs: &Self::Item) -> Result<Self::Item> {
+        Self::merge(rhs, lhs)
+    }
+}
+
+fn test_sequence_sub_func(count: u32, proof_elem: Vec<u32>) {
+    let store = MemStore::default();
+    let mut mmr = MMR::<_, MergeNumberRange, _>::new(0, &store);
+    let positions = (0..count)
+        .map(|i| mmr.push(NumberRange::from(i)).expect("push"))
+        .collect::<Vec<_>>();
+    let root = mmr.get_root().expect("get_root");
+    assert!(root.is_normalized());
+    let proof = mmr
+        .gen_proof(
+            proof_elem
+                .iter()
+                .map(|elem| positions[*elem as usize])
+                .collect(),
+        )
+        .expect("gen_proof");
+    for item in proof.proof_items() {
+        assert!(item.is_normalized())
+    }
+    mmr.commit().expect("commit");
+    let result = proof
+        .verify(
+            root,
+            proof_elem
+                .iter()
+                .map(|elem| (positions[*elem as usize], NumberRange::from(*elem)))
+                .collect(),
+        )
+        .expect("verify");
+    assert!(result);
+}
+
+proptest! {
+    #[test]
+    fn test_sequence(count in 10u32..500u32) {
+        let mut leaves: Vec<u32> = (0..count).collect();
+        let mut rng = thread_rng();
+        leaves.shuffle(&mut rng);
+        let leaves_count = rng.gen_range(1, count - 1);
+        leaves.truncate(leaves_count as usize);
+        test_sequence_sub_func(count, leaves);
+    }
+}