Merge branch 'master' into feature/cleanups

Author: Seulgi Kim

Cargo.lock

@@ -35,8 +35,8 @@ parking_lot = "0.6.0"
 primitives = { git = "https://github.com/CodeChain-io/rust-codechain-primitives.git", version = "0.4" }
 rand = "0.6.1"
 rlp = { git = "https://github.com/CodeChain-io/rlp.git", version = "0.4" }
-rlp_compress = { path = "../util/rlp_compress" }
-rlp_derive = { path = "../util/rlp_derive" }
+rlp_compress = { git = "https://github.com/CodeChain-io/rlp.git", version = "0.2" }
+rlp_derive = { git = "https://github.com/CodeChain-io/rlp.git", version = "0.2" }
 snap = "0.2"
 table = { path = "../util/table" }
 util-error = { path = "../util/error" }

core/Cargo.toml

@@ -201,6 +201,7 @@ pub trait ConsensusEngine: Sync + Send {
     }
 
     /// Phase 3 verification. Check block information against parent. Returns either a null `Ok` or a general error detailing the problem with import.
+    /// The verification must be conducted only with the two headers' information because it does not guarantee whether the two corresponding bodies have been imported.
     fn verify_block_family(&self, _header: &Header, _parent: &Header) -> Result<(), Error> {
         Ok(())
     }

core/src/consensus/mod.rs

@@ -20,7 +20,7 @@ use std::sync::Arc;
 use ccrypto::{blake256, BLAKE_NULL_RLP};
 use cjson;
 use ckey::Address;
-use cmerkle::TrieFactory;
+use cmerkle::{TrieFactory, TrieMut};
 use cstate::{Metadata, MetadataAddress, Shard, ShardAddress, StateDB, StateResult, StateWithCache, TopLevelState};
 use ctypes::errors::SyntaxError;
 use ctypes::{BlockHash, CommonParams, Header, ShardId};

core/src/scheme/scheme.rs

@@ -20,7 +20,7 @@ never-type = "0.1.0"
 parking_lot = "0.6.0"
 rand = "0.6.1"
 rlp = { git = "https://github.com/CodeChain-io/rlp.git", version = "0.4" }
-rlp_derive = { path = "../util/rlp_derive" }
+rlp_derive = { git = "https://github.com/CodeChain-io/rlp.git", version = "0.2" }
 table = { path = "../util/table" }
 time = "0.1"
 token-generator = "0.1.0"

network/Cargo.toml

@@ -20,6 +20,6 @@ lru-cache = "0.1.1"
 parking_lot = "0.6.0"
 primitives = { git = "https://github.com/CodeChain-io/rust-codechain-primitives.git", version = "0.4" }
 rlp = { git = "https://github.com/CodeChain-io/rlp.git", version = "0.4" }
-rlp_derive = { path = "../util/rlp_derive" }
+rlp_derive = { git = "https://github.com/CodeChain-io/rlp.git", version = "0.2" }
 rustc-hex = "1.0"
 util-error = { path = "../util/error" }

state/Cargo.toml

@@ -16,7 +16,7 @@
 
 use std::cell::RefMut;
 
-use cmerkle::{Result as TrieResult, TrieDB, TrieMut};
+use cmerkle::{Result as TrieResult, Trie, TrieMut};
 
 use super::WriteBack;
 use crate::{AssetScheme, AssetSchemeAddress, OwnedAsset, OwnedAssetAddress};
@@ -58,11 +58,11 @@ impl ShardCache {
         Ok(())
     }
 
-    pub fn asset_scheme(&self, a: &AssetSchemeAddress, db: &TrieDB) -> TrieResult<Option<AssetScheme>> {
+    pub fn asset_scheme(&self, a: &AssetSchemeAddress, db: &dyn Trie) -> TrieResult<Option<AssetScheme>> {
         self.asset_scheme.get(a, db)
     }
 
-    pub fn asset_scheme_mut(&self, a: &AssetSchemeAddress, db: &TrieDB) -> TrieResult<RefMut<AssetScheme>> {
+    pub fn asset_scheme_mut(&self, a: &AssetSchemeAddress, db: &dyn Trie) -> TrieResult<RefMut<AssetScheme>> {
         self.asset_scheme.get_mut(a, db)
     }
 
@@ -72,7 +72,7 @@ impl ShardCache {
         self.asset_scheme.create(a, f)
     }
 
-    pub fn asset(&self, a: &OwnedAssetAddress, db: &TrieDB) -> TrieResult<Option<OwnedAsset>> {
+    pub fn asset(&self, a: &OwnedAssetAddress, db: &dyn Trie) -> TrieResult<Option<OwnedAsset>> {
         self.asset.get(a, db)
     }
 

state/src/cache/shard_cache.rs

@@ -17,7 +17,7 @@
 use std::cell::RefMut;
 
 use ckey::Address;
-use cmerkle::{Result as TrieResult, TrieDB, TrieMut};
+use cmerkle::{Result as TrieResult, Trie, TrieMut};
 use primitives::H256;
 
 use super::WriteBack;
@@ -90,43 +90,43 @@ impl TopCache {
         Ok(())
     }
 
-    pub fn account(&self, a: &Address, db: &TrieDB) -> TrieResult<Option<Account>> {
+    pub fn account(&self, a: &Address, db: &dyn Trie) -> TrieResult<Option<Account>> {
         self.account.get(a, db)
     }
 
-    pub fn account_mut(&self, a: &Address, db: &TrieDB) -> TrieResult<RefMut<Account>> {
+    pub fn account_mut(&self, a: &Address, db: &dyn Trie) -> TrieResult<RefMut<Account>> {
         self.account.get_mut(a, db)
     }
 
     pub fn remove_account(&self, address: &Address) {
         self.account.remove(address)
     }
 
-    pub fn regular_account(&self, a: &RegularAccountAddress, db: &TrieDB) -> TrieResult<Option<RegularAccount>> {
+    pub fn regular_account(&self, a: &RegularAccountAddress, db: &dyn Trie) -> TrieResult<Option<RegularAccount>> {
         self.regular_account.get(a, db)
     }
 
-    pub fn regular_account_mut(&self, a: &RegularAccountAddress, db: &TrieDB) -> TrieResult<RefMut<RegularAccount>> {
+    pub fn regular_account_mut(&self, a: &RegularAccountAddress, db: &dyn Trie) -> TrieResult<RefMut<RegularAccount>> {
         self.regular_account.get_mut(a, db)
     }
 
     pub fn remove_regular_account(&self, address: &RegularAccountAddress) {
         self.regular_account.remove(address)
     }
 
-    pub fn metadata(&self, a: &MetadataAddress, db: &TrieDB) -> TrieResult<Option<Metadata>> {
+    pub fn metadata(&self, a: &MetadataAddress, db: &dyn Trie) -> TrieResult<Option<Metadata>> {
         self.metadata.get(a, db)
     }
 
-    pub fn metadata_mut(&self, a: &MetadataAddress, db: &TrieDB) -> TrieResult<RefMut<Metadata>> {
+    pub fn metadata_mut(&self, a: &MetadataAddress, db: &dyn Trie) -> TrieResult<RefMut<Metadata>> {
         self.metadata.get_mut(a, db)
     }
 
-    pub fn shard(&self, a: &ShardAddress, db: &TrieDB) -> TrieResult<Option<Shard>> {
+    pub fn shard(&self, a: &ShardAddress, db: &dyn Trie) -> TrieResult<Option<Shard>> {
         self.shard.get(a, db)
     }
 
-    pub fn shard_mut(&self, a: &ShardAddress, db: &TrieDB) -> TrieResult<RefMut<Shard>> {
+    pub fn shard_mut(&self, a: &ShardAddress, db: &dyn Trie) -> TrieResult<RefMut<Shard>> {
         self.shard.get_mut(a, db)
     }
 
@@ -135,23 +135,23 @@ impl TopCache {
         self.shard.remove(address)
     }
 
-    pub fn text(&self, a: &H256, db: &TrieDB) -> TrieResult<Option<Text>> {
+    pub fn text(&self, a: &H256, db: &dyn Trie) -> TrieResult<Option<Text>> {
         self.text.get(a, db)
     }
 
-    pub fn text_mut(&self, a: &H256, db: &TrieDB) -> TrieResult<RefMut<Text>> {
+    pub fn text_mut(&self, a: &H256, db: &dyn Trie) -> TrieResult<RefMut<Text>> {
         self.text.get_mut(a, db)
     }
 
     pub fn remove_text(&self, address: &H256) {
         self.text.remove(address);
     }
 
-    pub fn action_data(&self, a: &H256, db: &TrieDB) -> TrieResult<Option<ActionData>> {
+    pub fn action_data(&self, a: &H256, db: &dyn Trie) -> TrieResult<Option<ActionData>> {
         self.action_data.get(a, db)
     }
 
-    pub fn action_data_mut(&self, a: &H256, db: &TrieDB) -> TrieResult<RefMut<ActionData>> {
+    pub fn action_data_mut(&self, a: &H256, db: &dyn Trie) -> TrieResult<RefMut<ActionData>> {
         self.action_data.get_mut(a, db)
     }
 

state/src/cache/top_cache.rs

@@ -22,7 +22,7 @@ use std::fmt;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::vec::Vec;
 
-use cmerkle::{self, Result as TrieResult, Trie, TrieDB, TrieMut};
+use cmerkle::{self, Result as TrieResult, Trie, TrieMut};
 
 use super::CacheableItem;
 
@@ -195,25 +195,25 @@ where
     /// Check caches for required data
     /// First searches for account in the local, then the shared cache.
     /// Populates local cache if nothing found.
-    pub fn get(&self, a: &Item::Address, db: &TrieDB) -> cmerkle::Result<Option<Item>> {
+    pub fn get(&self, a: &Item::Address, db: &dyn Trie) -> cmerkle::Result<Option<Item>> {
         // check local cache first
         if let Some(cached_item) = self.cache.borrow_mut().get_mut(a) {
             cached_item.touched = touched_count();
             return Ok(cached_item.item.clone())
         }
 
         // not found in the cache, get from the DB and insert into cache
-        let maybe_item = db.get_with(a.as_ref(), &|bytes| ::rlp::decode::<Item>(bytes).unwrap())?;
+        let maybe_item = db.get(a.as_ref())?.map(|bytes| ::rlp::decode::<Item>(&bytes).unwrap());
         self.insert(a, Entry::<Item>::new_clean(maybe_item.clone()));
         Ok(maybe_item)
     }
 
     /// Pull item `a` in our cache from the trie DB.
     /// If it doesn't exist, make item equal the evaluation of `default`.
-    pub fn get_mut(&self, a: &Item::Address, db: &TrieDB) -> cmerkle::Result<RefMut<Item>> {
+    pub fn get_mut(&self, a: &Item::Address, db: &dyn Trie) -> cmerkle::Result<RefMut<Item>> {
         let contains_key = self.cache.borrow().contains_key(a);
         if !contains_key {
-            let maybe_item = db.get_with(a.as_ref(), &|bytes| ::rlp::decode::<Item>(bytes).unwrap())?;
+            let maybe_item = db.get(a.as_ref())?.map(|bytes| ::rlp::decode::<Item>(&bytes).unwrap());
             self.insert(a, Entry::<Item>::new_clean(maybe_item));
         }
         self.note(a);

state/src/cache/write_back.rs

@@ -173,14 +173,14 @@ impl StateWithCache for TopLevelState {
 
                 let shard_cache = self.shard_caches.get_mut(&shard_id).expect("Shard must exist");
 
-                shard_cache.commit(&mut *trie)?;
+                shard_cache.commit(&mut trie)?;
             }
             self.set_shard_root(shard_id, shard_root)?;
         }
         {
             let mut db = self.db.borrow_mut();
             let mut trie = TrieFactory::from_existing(db.as_hashdb_mut(), &mut self.root)?;
-            self.top_cache.commit(&mut *trie)?;
+            self.top_cache.commit(&mut trie)?;
         }
         Ok(self.root)
     }