Export the codechain-merkle module to the merkle-trie package

Cargo.toml

@@ -23,7 +23,6 @@ codechain-discovery = { path = "discovery" }
 codechain-logger = { path = "util/logger" }
 codechain-key = { path = "key" }
 codechain-keystore = { path = "keystore" }
-codechain-merkle = { path = "util/merkle" }
 codechain-network = { path = "network" }
 codechain-rpc = { path = "rpc" }
 codechain-state = { path = "state" }

core/Cargo.toml

@@ -12,7 +12,6 @@ codechain-json = { path = "../json" }
 codechain-key = { path = "../key" }
 codechain-keystore = { path="../keystore" }
 codechain-logger = { path = "../util/logger" }
-codechain-merkle = { path = "../util/merkle" }
 codechain-network = { path = "../network" }
 codechain-state = { path = "../state" }
 codechain-timer = { path = "../util/timer" }
@@ -28,6 +27,7 @@ kvdb-memorydb = "0.1"
 linked-hash-map = "0.5"
 log = "0.4.6"
 lru-cache = "0.1.2"
+merkle-trie = { git = "https://github.com/CodeChain-io/rust-merkle-trie.git", version = "0.1" }
 num-rational = "0.2.1"
 parking_lot = "0.6.0"
 primitives = { git = "https://github.com/CodeChain-io/rust-codechain-primitives.git", version = "0.4" }

core/src/block.rs

@@ -18,13 +18,13 @@ use std::collections::HashSet;
 
 use ccrypto::BLAKE_NULL_RLP;
 use ckey::Address;
-use cmerkle::skewed_merkle_root;
 use cstate::{FindActionHandler, StateDB, StateError, StateWithCache, TopLevelState};
 use ctypes::errors::HistoryError;
 use ctypes::header::{Header, Seal};
 use ctypes::util::unexpected::Mismatch;
 use ctypes::{BlockNumber, CommonParams, TxHash};
 use cvm::ChainTimeInfo;
+use merkle_trie::skewed_merkle_root;
 use primitives::{Bytes, H256};
 use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream};
 

core/src/client/client.rs

@@ -21,7 +21,6 @@ use std::sync::{Arc, Weak};
 use cdb::{new_journaldb, Algorithm, AsHashDB, DatabaseError};
 use cio::IoChannel;
 use ckey::{Address, NetworkId, PlatformAddress, Public};
-use cmerkle::Result as TrieResult;
 use cnetwork::NodeId;
 use cstate::{
     ActionHandler, AssetScheme, FindActionHandler, OwnedAsset, StateDB, StateResult, Text, TopLevelState, TopStateView,
@@ -31,6 +30,7 @@ use ctypes::transaction::{AssetTransferInput, PartialHashing, ShardTransaction};
 use ctypes::{BlockHash, BlockNumber, CommonParams, ShardId, Tracker, TxHash};
 use cvm::{decode, execute, ChainTimeInfo, ScriptResult, VMConfig};
 use kvdb::{DBTransaction, KeyValueDB};
+use merkle_trie::Result as TrieResult;
 use parking_lot::{Mutex, RwLock, RwLockReadGuard};
 use primitives::{Bytes, H160, H256, U256};
 use rlp::Rlp;

core/src/client/mod.rs

@@ -32,13 +32,13 @@ use std::sync::Arc;
 
 use cdb::DatabaseError;
 use ckey::{Address, NetworkId, PlatformAddress, Public};
-use cmerkle::Result as TrieResult;
 use cnetwork::NodeId;
 use cstate::{AssetScheme, FindActionHandler, OwnedAsset, StateResult, Text, TopLevelState, TopStateView};
 use ctypes::transaction::{AssetTransferInput, PartialHashing, ShardTransaction};
 use ctypes::{BlockHash, BlockNumber, CommonParams, ShardId, Tracker, TxHash};
 use cvm::ChainTimeInfo;
 use kvdb::KeyValueDB;
+use merkle_trie::Result as TrieResult;
 use primitives::{Bytes, H160, H256, U256};
 
 use crate::block::{ClosedBlock, OpenBlock, SealedBlock};

core/src/client/test_client.rs

@@ -38,7 +38,6 @@ use std::sync::Arc;
 
 use cdb;
 use ckey::{public_to_address, Address, Generator, KeyPair, NetworkId, PlatformAddress, Private, Public, Random};
-use cmerkle::skewed_merkle_root;
 use cnetwork::NodeId;
 use cstate::tests::helpers::empty_top_state;
 use cstate::{FindActionHandler, StateDB, TopLevelState};
@@ -48,6 +47,7 @@ use ctypes::{BlockHash, BlockNumber, CommonParams, Header as BlockHeader, Tracke
 use cvm::ChainTimeInfo;
 use kvdb::KeyValueDB;
 use kvdb_memorydb;
+use merkle_trie::skewed_merkle_root;
 use parking_lot::RwLock;
 use primitives::{Bytes, H256, U256};
 use rlp::*;

core/src/error.rs

@@ -20,11 +20,11 @@ use std::io::Error as StdIoError;
 use cdb::DatabaseError;
 use cio::IoError;
 use ckey::{Address, Error as KeyError};
-use cmerkle::TrieError;
 use cstate::StateError;
 use ctypes::errors::{HistoryError, RuntimeError, SyntaxError};
 use ctypes::util::unexpected::{Mismatch, OutOfBounds};
 use ctypes::{BlockHash, BlockNumber};
+use merkle_trie::TrieError;
 use primitives::{H256, U256};
 use rlp::DecoderError;
 

core/src/lib.rs

@@ -24,7 +24,6 @@ extern crate codechain_key as ckey;
 extern crate codechain_keystore as ckeystore;
 #[macro_use]
 extern crate codechain_logger as clogger;
-extern crate codechain_merkle as cmerkle;
 extern crate codechain_network as cnetwork;
 extern crate codechain_state as cstate;
 extern crate codechain_stratum as cstratum;

core/src/scheme/scheme.rs

@@ -21,10 +21,10 @@ use ccrypto::{blake256, BLAKE_NULL_RLP};
 use cdb::{AsHashDB, HashDB};
 use cjson;
 use ckey::Address;
-use cmerkle::{TrieFactory, TrieMut};
 use cstate::{Metadata, MetadataAddress, Shard, ShardAddress, StateDB, StateResult, StateWithCache, TopLevelState};
 use ctypes::errors::SyntaxError;
 use ctypes::{BlockHash, CommonParams, Header, ShardId};
+use merkle_trie::{TrieFactory, TrieMut};
 use parking_lot::RwLock;
 use primitives::{Bytes, H256, U256};
 use rlp::{Encodable, Rlp, RlpStream};

core/src/verification/verification.rs

@@ -16,9 +16,9 @@
 
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use cmerkle::skewed_merkle_root;
 use ctypes::util::unexpected::{Mismatch, OutOfBounds};
 use ctypes::{BlockNumber, CommonParams, Header};
+use merkle_trie::skewed_merkle_root;
 use primitives::{Bytes, H256};
 use rlp::Rlp;
 

state/Cargo.toml

@@ -8,14 +8,14 @@ edition = "2018"
 codechain-crypto = { git = "https://github.com/CodeChain-io/rust-codechain-crypto.git", version = "0.1" }
 codechain-db = { git = "https://github.com/CodeChain-io/rust-codechain-db.git", version = "0.1" }
 codechain-logger = { path = "../util/logger" }
-codechain-merkle = { path = "../util/merkle" }
 codechain-key = { path = "../key" }
 codechain-types = { path = "../types" }
 codechain-vm = { path = "../vm" }
 kvdb = "0.1"
 kvdb-memorydb = "0.1"
 log = "0.4.6"
 lru-cache = "0.1.1"
+merkle-trie = { git = "https://github.com/CodeChain-io/rust-merkle-trie.git", version = "0.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" }

state/src/cache/shard_cache.rs

@@ -16,7 +16,7 @@
 
 use std::cell::RefMut;
 
-use cmerkle::{Result as TrieResult, Trie, TrieMut};
+use merkle_trie::{Result as TrieResult, Trie, TrieMut};
 
 use super::WriteBack;
 use crate::{AssetScheme, AssetSchemeAddress, OwnedAsset, OwnedAssetAddress};

state/src/cache/top_cache.rs

@@ -17,7 +17,7 @@
 use std::cell::RefMut;
 
 use ckey::Address;
-use cmerkle::{Result as TrieResult, Trie, TrieMut};
+use merkle_trie::{Result as TrieResult, Trie, TrieMut};
 use primitives::H256;
 
 use super::WriteBack;

state/src/cache/write_back.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, TrieMut};
+use merkle_trie::{Result as TrieResult, Trie, TrieMut};
 
 use super::CacheableItem;
 
@@ -195,7 +195,7 @@ 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: &dyn Trie) -> cmerkle::Result<Option<Item>> {
+    pub fn get(&self, a: &Item::Address, db: &dyn Trie) -> TrieResult<Option<Item>> {
         // check local cache first
         if let Some(cached_item) = self.cache.borrow_mut().get_mut(a) {
             cached_item.touched = touched_count();
@@ -210,7 +210,7 @@ where
 
     /// 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: &dyn Trie) -> cmerkle::Result<RefMut<Item>> {
+    pub fn get_mut(&self, a: &Item::Address, db: &dyn Trie) -> TrieResult<RefMut<Item>> {
         let contains_key = self.cache.borrow().contains_key(a);
         if !contains_key {
             let maybe_item = db.get(a.as_ref())?.map(|bytes| ::rlp::decode::<Item>(&bytes).unwrap());
@@ -234,7 +234,7 @@ where
         }))
     }
 
-    pub fn create<F: FnOnce() -> Item>(&self, a: &Item::Address, f: F) -> cmerkle::Result<Item> {
+    pub fn create<F: FnOnce() -> Item>(&self, a: &Item::Address, f: F) -> TrieResult<Item> {
         if let Some(cached) = self.cache.borrow().get(a) {
             assert!(cached.item.is_none());
         }

state/src/error.rs

@@ -16,8 +16,8 @@
 
 use std::fmt;
 
-use cmerkle::TrieError;
 use ctypes::errors::RuntimeError;
+use merkle_trie::TrieError;
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Error {

state/src/impls/shard_level.rs

@@ -21,7 +21,6 @@ use std::iter::{once, FromIterator};
 use ccrypto::{Blake, BLAKE_NULL_RLP};
 use cdb::AsHashDB;
 use ckey::Address;
-use cmerkle::{self, TrieError, TrieFactory};
 use ctypes::errors::{RuntimeError, UnlockFailureReason};
 use ctypes::transaction::{
     AssetMintOutput, AssetOutPoint, AssetTransferInput, AssetTransferOutput, AssetWrapCCCOutput, PartialHashing,
@@ -30,6 +29,7 @@ use ctypes::transaction::{
 use ctypes::util::unexpected::Mismatch;
 use ctypes::{BlockNumber, ShardId, Tracker};
 use cvm::{decode, execute, ChainTimeInfo, ScriptResult, VMConfig};
+use merkle_trie::{Result as TrieResult, TrieError, TrieFactory};
 use primitives::{Bytes, H160, H256};
 
 use crate::cache::ShardCache;
@@ -65,7 +65,7 @@ impl<'db> ShardLevelState<'db> {
         db: &'db mut RefCell<StateDB>,
         root: H256,
         cache: &'db mut ShardCache,
-    ) -> cmerkle::Result<Self> {
+    ) -> TrieResult<Self> {
         if !db.borrow().as_hashdb().contains(&root) {
             return Err(TrieError::InvalidStateRoot(root))
         }
@@ -85,7 +85,7 @@ impl<'db> ShardLevelState<'db> {
         db: &RefCell<StateDB>,
         root: H256,
         cache: ShardCache,
-    ) -> cmerkle::Result<ReadOnlyShardLevelState> {
+    ) -> TrieResult<ReadOnlyShardLevelState> {
         if !db.borrow().as_hashdb().contains(&root) {
             return Err(TrieError::InvalidStateRoot(root))
         }
@@ -661,13 +661,13 @@ impl<'db> ShardLevelState<'db> {
         registrar: Option<Address>,
         allowed_script_hashes: Vec<H160>,
         pool: Vec<Asset>,
-    ) -> cmerkle::Result<AssetScheme> {
+    ) -> TrieResult<AssetScheme> {
         self.cache.create_asset_scheme(&AssetSchemeAddress::new(asset_type, shard_id), || {
             AssetScheme::new_with_pool(metadata, supply, approver, registrar, allowed_script_hashes, pool)
         })
     }
 
-    fn get_asset_scheme_mut(&self, shard_id: ShardId, asset_type: H160) -> cmerkle::Result<RefMut<AssetScheme>> {
+    fn get_asset_scheme_mut(&self, shard_id: ShardId, asset_type: H160) -> TrieResult<RefMut<AssetScheme>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
         self.cache.asset_scheme_mut(&AssetSchemeAddress::new(asset_type, shard_id), &trie)
@@ -681,7 +681,7 @@ impl<'db> ShardLevelState<'db> {
         lock_script_hash: H160,
         parameters: Vec<Bytes>,
         quantity: u64,
-    ) -> cmerkle::Result<OwnedAsset> {
+    ) -> TrieResult<OwnedAsset> {
         self.cache.create_asset(&OwnedAssetAddress::new(tracker, index, self.shard_id), || {
             OwnedAsset::new(asset_type, lock_script_hash, parameters, quantity)
         })
@@ -694,7 +694,7 @@ impl<'db> ShardLevelState<'db> {
 }
 
 impl<'db> ShardStateView for ShardLevelState<'db> {
-    fn asset_scheme(&self, asset_type: H160) -> cmerkle::Result<Option<AssetScheme>> {
+    fn asset_scheme(&self, asset_type: H160) -> TrieResult<Option<AssetScheme>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
         self.cache.asset_scheme(&AssetSchemeAddress::new(asset_type, self.shard_id), &trie)
@@ -777,7 +777,7 @@ pub struct ReadOnlyShardLevelState<'db> {
 }
 
 impl<'db> ShardStateView for ReadOnlyShardLevelState<'db> {
-    fn asset_scheme(&self, asset_type: H160) -> cmerkle::Result<Option<AssetScheme>> {
+    fn asset_scheme(&self, asset_type: H160) -> TrieResult<Option<AssetScheme>> {
         let db = self.db.borrow();
         let trie = TrieFactory::readonly(db.as_hashdb(), &self.root)?;
         self.cache.asset_scheme(&AssetSchemeAddress::new(asset_type, self.shard_id), &trie)