diff --git a/benches/mmr_benchmark.rs b/benches/mmr_benchmark.rs
index 538bc5e..d7c9b19 100644
--- a/benches/mmr_benchmark.rs
+++ b/benches/mmr_benchmark.rs
@@ -4,7 +4,7 @@ extern crate criterion;
 use criterion::{BenchmarkId, Criterion};
 
 use bytes::Bytes;
-use ckb_merkle_mountain_range::{util::MemStore, Error, MMRStore, Merge, Result, MMR};
+use ckb_merkle_mountain_range::{util::MemStore, Error, MMRStoreReadOps, Merge, Result, MMR};
 use rand::{seq::SliceRandom, thread_rng};
 use std::convert::TryFrom;
 
diff --git a/src/lib.rs b/src/lib.rs
index 7d44ab0..96b3fc0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,7 +13,7 @@ pub use error::{Error, Result};
 pub use helper::{leaf_index_to_mmr_size, leaf_index_to_pos};
 pub use merge::Merge;
 pub use mmr::{MerkleProof, MMR};
-pub use mmr_store::MMRStore;
+pub use mmr_store::{MMRStoreReadOps, MMRStoreWriteOps};
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "std")] {
diff --git a/src/mmr.rs b/src/mmr.rs
index 26497ba..b9d5b94 100644
--- a/src/mmr.rs
+++ b/src/mmr.rs
@@ -7,7 +7,7 @@
 use crate::borrow::Cow;
 use crate::collections::VecDeque;
 use crate::helper::{get_peaks, parent_offset, pos_height_in_tree, sibling_offset};
-use crate::mmr_store::{MMRBatch, MMRStore};
+use crate::mmr_store::{MMRBatch, MMRStoreReadOps, MMRStoreWriteOps};
 use crate::vec;
 use crate::vec::Vec;
 use crate::{Error, Merge, Result};
@@ -21,7 +21,7 @@ pub struct MMR<T, M, S> {
     merge: PhantomData<M>,
 }
 
-impl<T: Clone + PartialEq + Debug, M: Merge<Item = T>, S: MMRStore<T>> MMR<T, M, S> {
+impl<T, M, S> MMR<T, M, S> {
     pub fn new(mmr_size: u64, store: S) -> Self {
         MMR {
             mmr_size,
@@ -29,7 +29,9 @@ impl<T: Clone + PartialEq + Debug, M: Merge<Item = T>, S: MMRStore<T>> MMR<T, M,
             merge: PhantomData,
         }
     }
+}
 
+impl<T: Clone + PartialEq, M: Merge<Item = T>, S: MMRStoreReadOps<T>> MMR<T, M, S> {
     // find internal MMR elem, the pos must exists, otherwise a error will return
     fn find_elem<'b>(&self, pos: u64, hashes: &'b [T]) -> Result<Cow<'b, T>> {
         let pos_offset = pos.checked_sub(self.mmr_size);
@@ -214,7 +216,9 @@ impl<T: Clone + PartialEq + Debug, M: Merge<Item = T>, S: MMRStore<T>> MMR<T, M,
 
         Ok(MerkleProof::new(self.mmr_size, proof))
     }
+}
 
+impl<T, M, S: MMRStoreWriteOps<T>> MMR<T, M, S> {
     pub fn commit(self) -> Result<()> {
         self.batch.commit()
     }
@@ -227,7 +231,7 @@ pub struct MerkleProof<T, M> {
     merge: PhantomData<M>,
 }
 
-impl<T: PartialEq + Debug + Clone, M: Merge<Item = T>> MerkleProof<T, M> {
+impl<T: Clone + PartialEq, M: Merge<Item = T>> MerkleProof<T, M> {
     pub fn new(mmr_size: u64, proof: Vec<T>) -> Self {
         MerkleProof {
             mmr_size,
@@ -284,12 +288,7 @@ impl<T: PartialEq + Debug + Clone, M: Merge<Item = T>> MerkleProof<T, M> {
     }
 }
 
-fn calculate_peak_root<
-    'a,
-    T: 'a + PartialEq + Debug + Clone,
-    M: Merge<Item = T>,
-    I: Iterator<Item = &'a T>,
->(
+fn calculate_peak_root<'a, T: 'a + Clone, M: Merge<Item = T>, I: Iterator<Item = &'a T>>(
     leaves: Vec<(u64, T)>,
     peak_pos: u64,
     proof_iter: &mut I,
@@ -345,12 +344,7 @@ fn calculate_peak_root<
     Err(Error::CorruptedProof)
 }
 
-fn calculate_peaks_hashes<
-    'a,
-    T: 'a + PartialEq + Debug + Clone,
-    M: Merge<Item = T>,
-    I: Iterator<Item = &'a T>,
->(
+fn calculate_peaks_hashes<'a, T: 'a + Clone, M: Merge<Item = T>, I: Iterator<Item = &'a T>>(
     mut leaves: Vec<(u64, T)>,
     mmr_size: u64,
     mut proof_iter: I,
@@ -405,9 +399,7 @@ fn calculate_peaks_hashes<
     Ok(peaks_hashes)
 }
 
-fn bagging_peaks_hashes<'a, T: 'a + PartialEq + Debug + Clone, M: Merge<Item = T>>(
-    mut peaks_hashes: Vec<T>,
-) -> Result<T> {
+fn bagging_peaks_hashes<T, M: Merge<Item = T>>(mut peaks_hashes: Vec<T>) -> Result<T> {
     // bagging peaks
     // bagging from right to left via hash(right, left).
     while peaks_hashes.len() > 1 {
@@ -422,12 +414,7 @@ fn bagging_peaks_hashes<'a, T: 'a + PartialEq + Debug + Clone, M: Merge<Item = T
 /// 1. sort items by position
 /// 2. calculate root of each peak
 /// 3. bagging peaks
-fn calculate_root<
-    'a,
-    T: 'a + PartialEq + Debug + Clone,
-    M: Merge<Item = T>,
-    I: Iterator<Item = &'a T>,
->(
+fn calculate_root<'a, T: 'a + Clone, M: Merge<Item = T>, I: Iterator<Item = &'a T>>(
     leaves: Vec<(u64, T)>,
     mmr_size: u64,
     proof_iter: I,
diff --git a/src/mmr_store.rs b/src/mmr_store.rs
index d0e1490..1e8d483 100644
--- a/src/mmr_store.rs
+++ b/src/mmr_store.rs
@@ -6,7 +6,7 @@ pub struct MMRBatch<Elem, Store> {
     store: Store,
 }
 
-impl<Elem: Clone, Store: MMRStore<Elem>> MMRBatch<Elem, Store> {
+impl<Elem, Store> MMRBatch<Elem, Store> {
     pub fn new(store: Store) -> Self {
         MMRBatch {
             memory_batch: Vec::new(),
@@ -17,7 +17,9 @@ impl<Elem: Clone, Store: MMRStore<Elem>> MMRBatch<Elem, Store> {
     pub fn append(&mut self, pos: u64, elems: Vec<Elem>) {
         self.memory_batch.push((pos, elems));
     }
+}
 
+impl<Elem: Clone, Store: MMRStoreReadOps<Elem>> MMRBatch<Elem, Store> {
     pub fn get_elem(&self, pos: u64) -> Result<Option<Elem>> {
         for (start_pos, elems) in self.memory_batch.iter().rev() {
             if pos < *start_pos {
@@ -30,7 +32,9 @@ impl<Elem: Clone, Store: MMRStore<Elem>> MMRBatch<Elem, Store> {
         }
         self.store.get_elem(pos)
     }
+}
 
+impl<Elem, Store: MMRStoreWriteOps<Elem>> MMRBatch<Elem, Store> {
     pub fn commit(self) -> Result<()> {
         let Self {
             mut store,
@@ -43,7 +47,7 @@ impl<Elem: Clone, Store: MMRStore<Elem>> MMRBatch<Elem, Store> {
     }
 }
 
-impl<Elem, Store: MMRStore<Elem>> IntoIterator for MMRBatch<Elem, Store> {
+impl<Elem, Store> IntoIterator for MMRBatch<Elem, Store> {
     type Item = (u64, Vec<Elem>);
     type IntoIter = crate::vec::IntoIter<Self::Item>;
 
@@ -52,7 +56,10 @@ impl<Elem, Store: MMRStore<Elem>> IntoIterator for MMRBatch<Elem, Store> {
     }
 }
 
-pub trait MMRStore<Elem> {
+pub trait MMRStoreReadOps<Elem> {
     fn get_elem(&self, pos: u64) -> Result<Option<Elem>>;
+}
+
+pub trait MMRStoreWriteOps<Elem> {
     fn append(&mut self, pos: u64, elems: Vec<Elem>) -> Result<()>;
 }
diff --git a/src/tests/test_accumulate_headers.rs b/src/tests/test_accumulate_headers.rs
index 1366970..ae9ab9e 100644
--- a/src/tests/test_accumulate_headers.rs
+++ b/src/tests/test_accumulate_headers.rs
@@ -1,5 +1,5 @@
 use super::new_blake2b;
-use crate::{leaf_index_to_pos, util::MemStore, MMRStore, Merge, MerkleProof, Result, MMR};
+use crate::{leaf_index_to_pos, util::MemStore, MMRStoreReadOps, Merge, MerkleProof, Result, MMR};
 use bytes::{Bytes, BytesMut};
 use std::fmt;
 
@@ -106,7 +106,7 @@ impl Prover {
         let mut mmr = MMR::<_, MergeHashWithTD, _>::new(self.positions.len() as u64, &self.store);
         // get previous element
         let mut previous = if let Some(pos) = self.positions.last() {
-            MMRStore::<_>::get_elem(&&self.store, *pos)?.expect("exists")
+            MMRStoreReadOps::<_>::get_elem(&&self.store, *pos)?.expect("exists")
         } else {
             let genesis = Header::default();
 
diff --git a/src/tests/test_mmr.rs b/src/tests/test_mmr.rs
index ff92d99..6f0bbf0 100644
--- a/src/tests/test_mmr.rs
+++ b/src/tests/test_mmr.rs
@@ -1,6 +1,6 @@
 use super::{MergeNumberHash, NumberHash};
 use crate::{
-    helper::pos_height_in_tree, leaf_index_to_mmr_size, util::MemStore, Error, MMRStore, MMR,
+    helper::pos_height_in_tree, leaf_index_to_mmr_size, util::MemStore, Error, MMRStoreReadOps, MMR,
 };
 use faster_hex::hex_string;
 use proptest::prelude::*;
diff --git a/src/util.rs b/src/util.rs
index 0828bc4..79dec26 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,7 +1,6 @@
 use crate::collections::BTreeMap;
-use crate::{vec::Vec, MMRStore, Merge, MerkleProof, Result, MMR};
+use crate::{vec::Vec, MMRStoreReadOps, MMRStoreWriteOps, Merge, MerkleProof, Result, MMR};
 use core::cell::RefCell;
-use core::fmt::Debug;
 use core::marker::PhantomData;
 
 #[derive(Clone)]
@@ -19,11 +18,13 @@ impl<T> MemStore<T> {
     }
 }
 
-impl<T: Clone> MMRStore<T> for &MemStore<T> {
+impl<T: Clone> MMRStoreReadOps<T> for &MemStore<T> {
     fn get_elem(&self, pos: u64) -> Result<Option<T>> {
         Ok(self.0.borrow().get(&pos).cloned())
     }
+}
 
+impl<T> MMRStoreWriteOps<T> for &MemStore<T> {
     fn append(&mut self, pos: u64, elems: Vec<T>) -> Result<()> {
         let mut store = self.0.borrow_mut();
         for (i, elem) in elems.into_iter().enumerate() {
@@ -39,13 +40,13 @@ pub struct MemMMR<T, M> {
     merge: PhantomData<M>,
 }
 
-impl<T: Clone + Debug + PartialEq, M: Merge<Item = T>> Default for MemMMR<T, M> {
+impl<T: Clone + PartialEq, M: Merge<Item = T>> Default for MemMMR<T, M> {
     fn default() -> Self {
         Self::new(0, Default::default())
     }
 }
 
-impl<T: Clone + Debug + PartialEq, M: Merge<Item = T>> MemMMR<T, M> {
+impl<T: Clone + PartialEq, M: Merge<Item = T>> MemMMR<T, M> {
     pub fn new(mmr_size: u64, store: MemStore<T>) -> Self {
         MemMMR {
             mmr_size,