Merge pull request #20 from yangby-cryptape/pr/release-v0.5.0

chore: bump version to v0.5.0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ckb-merkle-mountain-range"
-version = "0.3.1"
+version = "0.5.0"
 authors = ["Nervos Core Dev <dev@nervos.org>"]
 edition = "2018"
 license = "MIT"
@@ -12,15 +12,15 @@ default = ["std"]
 std = []
 
 [dependencies]
-cfg-if = "0.1"
+cfg-if = "1.0"
 
 [dev-dependencies]
-faster-hex = "0.3"
+faster-hex = "0.6.1"
 criterion = "0.3"
-rand = "0.6"
-proptest = "0.9.4"
+rand = "0.8.5"
+proptest = "1.0.0"
 lazy_static = "1.3.0"
-bytes = "0.4"
+bytes = "1.2.0"
 blake2b-rs = "0.1.4"
 
 [[bench]]

README.md

@@ -3,8 +3,6 @@
 
 A generalized merkle mountain range implementation.
 
-**Notice** this library is not stable yet, API and proof format may changes. Make sure you know what you do before using this library.
-
 ## Features
 
 * Leaves accumulation
@@ -38,7 +36,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/helper_benchmark.rs

@@ -10,7 +10,7 @@ fn bench(c: &mut Criterion) {
     c.bench_function("left_index_to_pos", |b| {
         let mut rng = thread_rng();
         b.iter(|| {
-            let leaf_index = rng.gen_range(50_000_000_000, 70_000_000_000);
+            let leaf_index = rng.gen_range(50_000_000_000..70_000_000_000);
             leaf_index_to_pos(leaf_index);
         });
     });
@@ -18,7 +18,7 @@ fn bench(c: &mut Criterion) {
     c.bench_function("left_index_to_mmr_size", |b| {
         let mut rng = thread_rng();
         b.iter(|| {
-            let leaf_index = rng.gen_range(50_000_000_000, 70_000_000_000);
+            let leaf_index = rng.gen_range(50_000_000_000..70_000_000_000);
             leaf_index_to_mmr_size(leaf_index);
         });
     });

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,7 +14,8 @@ use crate::{Error, Merge, Result};
 use core::fmt::Debug;
 use core::marker::PhantomData;
 
-pub struct MMR<T, M, S: MMRStore<T>> {
+#[allow(clippy::upper_case_acronyms)]
+pub struct MMR<T, M, S> {
     mmr_size: u64,
     batch: MMRBatch<T, S>,
     merge: PhantomData<M>,
@@ -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/mmr_store.rs

@@ -1,7 +1,7 @@
 use crate::{vec::Vec, Result};
 
 #[derive(Default)]
-pub struct MMRBatch<Elem, Store: MMRStore<Elem>> {
+pub struct MMRBatch<Elem, Store> {
     memory_batch: Vec<(u64, Vec<Elem>)>,
     store: Store,
 }

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

@@ -1,7 +1,7 @@
 use super::new_blake2b;
 use crate::{leaf_index_to_pos, util::MemStore, MMRStore, Merge, MerkleProof, Result, MMR};
-use bytes::Bytes;
-use std::fmt::{self, Debug};
+use bytes::{Bytes, BytesMut};
+use std::fmt;
 
 #[derive(Clone)]
 struct Header {
@@ -42,9 +42,9 @@ struct HashWithTD {
 
 impl HashWithTD {
     fn serialize(&self) -> Bytes {
-        let mut data = self.hash.clone();
+        let mut data = BytesMut::from(self.hash.as_ref());
         data.extend(&self.td.to_le_bytes());
-        data
+        data.into()
     }
 
     fn deserialize(mut data: Bytes) -> Self {
@@ -57,12 +57,12 @@ impl HashWithTD {
     }
 }
 
-impl Debug for HashWithTD {
+impl fmt::Debug for HashWithTD {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
             "HashWithTD {{ hash: {}, td: {} }}",
-            faster_hex::hex_string(&self.hash).unwrap(),
+            faster_hex::hex_string(&self.hash),
             self.td
         )
     }
@@ -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_mmr.rs

@@ -64,7 +64,7 @@ fn test_mmr_root() {
         mmr.push(NumberHash::from(i)).unwrap();
     });
     let root = mmr.get_root().expect("get root");
-    let hex_root = hex_string(&root.0).unwrap();
+    let hex_root = hex_string(&root.0);
     assert_eq!(
         "f6794677f37a57df6a5ec36ce61036e43a36c1a009d05c81c9aa685dde1fd6e3",
         hex_root
@@ -154,7 +154,7 @@ proptest! {
         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);
+        let leaves_count = rng.gen_range(1..count - 1);
         leaves.truncate(leaves_count as usize);
         test_mmr(count, leaves);
     }

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);
+    }
+}