diff --git a/Cargo.lock b/Cargo.lock index 980b2dbf7b9..8cb57f59e36 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -32,6 +32,7 @@ dependencies = [ "num_cpus 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)", "number_prefix 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)", "regex 0.1.68 (registry+https://github.com/rust-lang/crates.io-index)", + "rlp 0.1.0", "rpassword 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)", "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)", @@ -218,8 +219,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "elastic-array" -version = "0.4.0" -source = "git+https://github.com/ethcore/elastic-array#9a9bebd6ea291c58e4d6b44dd5dc18368638fefe" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "env_logger" @@ -291,6 +292,7 @@ dependencies = [ "num_cpus 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)", "rayon 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", + "rlp 0.1.0", "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)", "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)", "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", @@ -428,6 +430,7 @@ dependencies = [ "mio 0.5.1 (git+https://github.com/ethcore/mio?branch=v0.5.x)", "parking_lot 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)", + "rlp 0.1.0", "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)", "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)", "slab 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -454,6 +457,7 @@ dependencies = [ "jsonrpc-core 3.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "jsonrpc-http-server 6.1.0 (git+https://github.com/ethcore/jsonrpc-http-server.git)", "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)", + "rlp 0.1.0", "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)", "serde 0.8.4 (registry+https://github.com/rust-lang/crates.io-index)", "serde_codegen 0.8.4 (registry+https://github.com/rust-lang/crates.io-index)", @@ -505,7 +509,7 @@ dependencies = [ "arrayvec 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)", "bigint 0.1.0", "clippy 0.0.85 (registry+https://github.com/rust-lang/crates.io-index)", - "elastic-array 0.4.0 (git+https://github.com/ethcore/elastic-array)", + "elastic-array 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)", "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)", "eth-secp256k1 0.5.4 (git+https://github.com/ethcore/rust-secp256k1)", "ethcore-devtools 1.4.0", @@ -516,6 +520,7 @@ dependencies = [ "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)", "parking_lot 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)", + "rlp 0.1.0", "rocksdb 0.4.5 (git+https://github.com/ethcore/rust-rocksdb)", "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)", "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)", @@ -599,6 +604,7 @@ dependencies = [ "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)", "parking_lot 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)", + "rlp 0.1.0", "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -1305,6 +1311,16 @@ name = "regex-syntax" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" +[[package]] +name = "rlp" +version = "0.1.0" +dependencies = [ + "bigint 0.1.0", + "elastic-array 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)", + "lazy_static 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", + "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "rocksdb" version = "0.4.5" diff --git a/Cargo.toml b/Cargo.toml index 6615444651b..d8e42bf3af5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -38,6 +38,7 @@ ethcore-ipc-nano = { path = "ipc/nano" } ethcore-ipc = { path = "ipc/rpc" } ethcore-ipc-hypervisor = { path = "ipc/hypervisor" } ethcore-logger = { path = "logger" } +rlp = { path = "util/rlp" } json-ipc-server = { git = "https://github.com/ethcore/json-ipc-server.git" } ethcore-dapps = { path = "dapps", optional = true } clippy = { version = "0.0.85", optional = true} diff --git a/ethcore/Cargo.toml b/ethcore/Cargo.toml index a34116df5bc..8acba22665c 100644 --- a/ethcore/Cargo.toml +++ b/ethcore/Cargo.toml @@ -35,6 +35,7 @@ ethcore-ipc = { path = "../ipc/rpc" } ethstore = { path = "../ethstore" } ethkey = { path = "../ethkey" } ethcore-ipc-nano = { path = "../ipc/nano" } +rlp = { path = "../util/rlp" } rand = "0.3" [dependencies.hyper] diff --git a/ethcore/src/account_db.rs b/ethcore/src/account_db.rs index 15042403d58..a02b670d049 100644 --- a/ethcore/src/account_db.rs +++ b/ethcore/src/account_db.rs @@ -16,6 +16,7 @@ //! DB backend wrapper for Account trie use util::*; +use rlp::NULL_RLP; static NULL_RLP_STATIC: [u8; 1] = [0x80; 1]; diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs index d3b4ac16888..0b42d6838e7 100644 --- a/ethcore/src/block.rs +++ b/ethcore/src/block.rs @@ -22,6 +22,7 @@ use state::*; use verification::PreverifiedBlock; use trace::FlatTrace; use factory::Factories; +use rlp::*; /// A block, encoded as it is on the block chain. #[derive(Default, Debug, Clone, PartialEq)] diff --git a/ethcore/src/blockchain/blockchain.rs b/ethcore/src/blockchain/blockchain.rs index 943dc04c547..ef26a6b0818 100644 --- a/ethcore/src/blockchain/blockchain.rs +++ b/ethcore/src/blockchain/blockchain.rs @@ -18,6 +18,7 @@ use bloomchain as bc; use util::*; +use rlp::*; use header::*; use super::extras::*; use transaction::*; diff --git a/ethcore/src/blockchain/extras.rs b/ethcore/src/blockchain/extras.rs index e2b4e89b320..6dc7aef9863 100644 --- a/ethcore/src/blockchain/extras.rs +++ b/ethcore/src/blockchain/extras.rs @@ -18,6 +18,7 @@ use bloomchain; use util::*; +use rlp::*; use header::BlockNumber; use receipt::Receipt; use db::Key; diff --git a/ethcore/src/blockchain/generator/block.rs b/ethcore/src/blockchain/generator/block.rs index 1fb9c13a162..6b8aa78f28c 100644 --- a/ethcore/src/blockchain/generator/block.rs +++ b/ethcore/src/blockchain/generator/block.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Parity. If not, see . -use util::rlp::*; +use rlp::*; use util::{H256, H2048}; use util::bytes::Bytes; use header::Header; diff --git a/ethcore/src/blooms/bloom.rs b/ethcore/src/blooms/bloom.rs index 83d898ab587..b535bcb2186 100644 --- a/ethcore/src/blooms/bloom.rs +++ b/ethcore/src/blooms/bloom.rs @@ -15,7 +15,7 @@ // along with Parity. If not, see . use bloomchain as bc; -use util::rlp::*; +use rlp::*; use util::HeapSizeOf; use basic_types::LogBloom; diff --git a/ethcore/src/blooms/bloom_group.rs b/ethcore/src/blooms/bloom_group.rs index 8e2b87189e9..9e3b53f18a1 100644 --- a/ethcore/src/blooms/bloom_group.rs +++ b/ethcore/src/blooms/bloom_group.rs @@ -15,7 +15,7 @@ // along with Parity. If not, see . use bloomchain::group as bc; -use util::rlp::*; +use rlp::*; use util::HeapSizeOf; use super::Bloom; diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs index edd671b70c2..554afab38df 100644 --- a/ethcore/src/client/client.rs +++ b/ethcore/src/client/client.rs @@ -22,11 +22,11 @@ use std::time::{Instant}; use time::precise_time_ns; // util -use util::{journaldb, rlp, Bytes, View, PerfTimer, Itertools, Mutex, RwLock}; -use util::journaldb::JournalDB; -use util::rlp::{UntrustedRlp}; +use util::{Bytes, PerfTimer, Itertools, Mutex, RwLock}; +use util::journaldb::{self, JournalDB}; use util::{U256, H256, Address, H2048, Uint}; use util::sha3::*; +use util::TrieFactory; use util::kvdb::*; // other @@ -63,9 +63,10 @@ use trace; use trace::FlatTransactionTraces; use evm::Factory as EvmFactory; use miner::{Miner, MinerService}; -use util::TrieFactory; use snapshot::{self, io as snapshot_io}; use factory::Factories; +use rlp::{View, UntrustedRlp}; + // re-export pub use types::blockchain_info::BlockChainInfo; @@ -877,7 +878,7 @@ impl BlockChainClient for Client { } fn block_receipts(&self, hash: &H256) -> Option { - self.chain.block_receipts(hash).map(|receipts| rlp::encode(&receipts).to_vec()) + self.chain.block_receipts(hash).map(|receipts| ::rlp::encode(&receipts).to_vec()) } fn import_block(&self, bytes: Bytes) -> Result { diff --git a/ethcore/src/client/test_client.rs b/ethcore/src/client/test_client.rs index fb7f9083e07..aa45ed9859f 100644 --- a/ethcore/src/client/test_client.rs +++ b/ethcore/src/client/test_client.rs @@ -18,6 +18,7 @@ use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder}; use util::*; +use rlp::*; use ethkey::{Generator, Random}; use devtools::*; use transaction::{Transaction, LocalizedTransaction, SignedTransaction, Action}; @@ -204,7 +205,7 @@ impl TestBlockChainClient { txs.append(&signed_tx); txs.out() }, - _ => rlp::EMPTY_LIST_RLP.to_vec() + _ => ::rlp::EMPTY_LIST_RLP.to_vec() }; let mut rlp = RlpStream::new_list(3); @@ -222,8 +223,8 @@ impl TestBlockChainClient { header.set_extra_data(b"This extra data is way too long to be considered valid".to_vec()); let mut rlp = RlpStream::new_list(3); rlp.append(&header); - rlp.append_raw(&rlp::NULL_RLP, 1); - rlp.append_raw(&rlp::NULL_RLP, 1); + rlp.append_raw(&::rlp::NULL_RLP, 1); + rlp.append_raw(&::rlp::NULL_RLP, 1); self.blocks.write().insert(hash, rlp.out()); } @@ -234,8 +235,8 @@ impl TestBlockChainClient { header.set_parent_hash(H256::from(42)); let mut rlp = RlpStream::new_list(3); rlp.append(&header); - rlp.append_raw(&rlp::NULL_RLP, 1); - rlp.append_raw(&rlp::NULL_RLP, 1); + rlp.append_raw(&::rlp::NULL_RLP, 1); + rlp.append_raw(&::rlp::NULL_RLP, 1); self.blocks.write().insert(hash, rlp.out()); } diff --git a/ethcore/src/db.rs b/ethcore/src/db.rs index 7fcf30de334..61cd41bd605 100644 --- a/ethcore/src/db.rs +++ b/ethcore/src/db.rs @@ -20,7 +20,8 @@ use std::ops::Deref; use std::hash::Hash; use std::collections::HashMap; use util::{DBTransaction, Database, RwLock}; -use util::rlp::{encode, Encodable, decode, Decodable}; + +use rlp; // database columns /// Column for State @@ -83,12 +84,12 @@ pub trait Key { /// Should be used to write value into database. pub trait Writable { /// Writes the value into the database. - fn write(&mut self, col: Option, key: &Key, value: &T) where T: Encodable, R: Deref; + fn write(&mut self, col: Option, key: &Key, value: &T) where T: rlp::Encodable, R: Deref; /// Writes the value into the database and updates the cache. fn write_with_cache(&mut self, col: Option, cache: &mut Cache, key: K, value: T, policy: CacheUpdatePolicy) where K: Key + Hash + Eq, - T: Encodable, + T: rlp::Encodable, R: Deref { self.write(col, &key, &value); match policy { @@ -104,7 +105,7 @@ pub trait Writable { /// Writes the values into the database and updates the cache. fn extend_with_cache(&mut self, col: Option, cache: &mut Cache, values: HashMap, policy: CacheUpdatePolicy) where K: Key + Hash + Eq, - T: Encodable, + T: rlp::Encodable, R: Deref { match policy { CacheUpdatePolicy::Overwrite => { @@ -127,13 +128,13 @@ pub trait Writable { pub trait Readable { /// Returns value for given key. fn read(&self, col: Option, key: &Key) -> Option where - T: Decodable, + T: rlp::Decodable, R: Deref; /// Returns value for given key either in cache or in database. fn read_with_cache(&self, col: Option, cache: &RwLock, key: &K) -> Option where K: Key + Eq + Hash + Clone, - T: Clone + Decodable, + T: Clone + rlp::Decodable, C: Cache { { let read = cache.read(); @@ -169,17 +170,17 @@ pub trait Readable { } impl Writable for DBTransaction { - fn write(&mut self, col: Option, key: &Key, value: &T) where T: Encodable, R: Deref { - self.put(col, &key.key(), &encode(value)); + fn write(&mut self, col: Option, key: &Key, value: &T) where T: rlp::Encodable, R: Deref { + self.put(col, &key.key(), &rlp::encode(value)); } } impl Readable for Database { - fn read(&self, col: Option, key: &Key) -> Option where T: Decodable, R: Deref { + fn read(&self, col: Option, key: &Key) -> Option where T: rlp::Decodable, R: Deref { let result = self.get(col, &key.key()); match result { - Ok(option) => option.map(|v| decode(&v)), + Ok(option) => option.map(|v| rlp::decode(&v)), Err(err) => { panic!("db get failed, key: {:?}, err: {:?}", &key.key() as &[u8], err); } diff --git a/ethcore/src/engines/basic_authority.rs b/ethcore/src/engines/basic_authority.rs index 332d947c367..eef3df6b15f 100644 --- a/ethcore/src/engines/basic_authority.rs +++ b/ethcore/src/engines/basic_authority.rs @@ -109,7 +109,7 @@ impl Engine for BasicAuthority { let message = header.bare_hash(); // account should be pernamently unlocked, otherwise sealing will fail if let Ok(signature) = ap.sign(*block.header().author(), message) { - return Some(vec![encode(&(&*signature as &[u8])).to_vec()]); + return Some(vec![::rlp::encode(&(&*signature as &[u8])).to_vec()]); } else { trace!(target: "basicauthority", "generate_seal: FAIL: accounts secret key unavailable"); } @@ -131,6 +131,8 @@ impl Engine for BasicAuthority { } fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> { + use rlp::{UntrustedRlp, View}; + // check the signature is legit. let sig = try!(UntrustedRlp::new(&header.seal()[0]).as_val::()); let signer = public_to_address(&try!(recover(&sig.into(), &header.bare_hash()))); @@ -172,7 +174,7 @@ impl Engine for BasicAuthority { impl Header { /// Get the none field of the header. pub fn signature(&self) -> H520 { - decode(&self.seal()[0]) + ::rlp::decode(&self.seal()[0]) } } @@ -228,7 +230,7 @@ mod tests { fn can_do_signature_verification_fail() { let engine = new_test_authority().engine; let mut header: Header = Header::default(); - header.set_seal(vec![rlp::encode(&H520::default()).to_vec()]); + header.set_seal(vec![::rlp::encode(&H520::default()).to_vec()]); let verify_result = engine.verify_block_unordered(&header, None); assert!(verify_result.is_err()); diff --git a/ethcore/src/engines/instant_seal.rs b/ethcore/src/engines/instant_seal.rs index e98e87bf5e6..bdb882ee743 100644 --- a/ethcore/src/engines/instant_seal.rs +++ b/ethcore/src/engines/instant_seal.rs @@ -100,7 +100,7 @@ mod tests { assert!(engine.verify_block_basic(&header, None).is_ok()); - header.set_seal(vec![rlp::encode(&H520::default()).to_vec()]); + header.set_seal(vec![::rlp::encode(&H520::default()).to_vec()]); assert!(engine.verify_block_unordered(&header, None).is_ok()); } diff --git a/ethcore/src/error.rs b/ethcore/src/error.rs index 57fe25c4482..e87aa231fed 100644 --- a/ethcore/src/error.rs +++ b/ethcore/src/error.rs @@ -302,8 +302,8 @@ impl From for Error { } } -impl From for Error { - fn from(err: DecoderError) -> Error { +impl From<::rlp::DecoderError> for Error { + fn from(err: ::rlp::DecoderError) -> Error { Error::Util(UtilError::Decoder(err)) } } diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs index 82a74d9ea02..4d25f812a37 100644 --- a/ethcore/src/ethereum/ethash.rs +++ b/ethcore/src/ethereum/ethash.rs @@ -21,6 +21,7 @@ use spec::CommonParams; use engines::Engine; use evm::Schedule; use ethjson; +use rlp::{self, UntrustedRlp, View}; /// Ethash params. #[derive(Debug, PartialEq)] @@ -328,17 +329,17 @@ impl Ethash { impl Header { /// Get the none field of the header. pub fn nonce(&self) -> H64 { - decode(&self.seal()[1]) + rlp::decode(&self.seal()[1]) } /// Get the mix hash field of the header. pub fn mix_hash(&self) -> H256 { - decode(&self.seal()[0]) + rlp::decode(&self.seal()[0]) } /// Set the nonce and mix hash fields of the header. pub fn set_nonce_and_mix_hash(&mut self, nonce: &H64, mix_hash: &H256) { - self.set_seal(vec![encode(mix_hash).to_vec(), encode(nonce).to_vec()]); + self.set_seal(vec![rlp::encode(mix_hash).to_vec(), rlp::encode(nonce).to_vec()]); } } @@ -349,6 +350,7 @@ mod tests { use tests::helpers::*; use super::super::new_morden; use super::Ethash; + use rlp; #[test] fn on_close_block() { diff --git a/ethcore/src/executive.rs b/ethcore/src/executive.rs index 53d5460ad9d..64771f95d4e 100644 --- a/ethcore/src/executive.rs +++ b/ethcore/src/executive.rs @@ -32,6 +32,8 @@ const MAX_VM_DEPTH_FOR_THREAD: usize = 64; /// Returns new address created from address and given nonce. pub fn contract_address(address: &Address, nonce: &U256) -> Address { + use rlp::{RlpStream, Stream}; + let mut stream = RlpStream::new_list(2); stream.append(address); stream.append(nonce); diff --git a/ethcore/src/header.rs b/ethcore/src/header.rs index 9b0e155f4f8..04581fac9f3 100644 --- a/ethcore/src/header.rs +++ b/ethcore/src/header.rs @@ -19,6 +19,7 @@ use util::*; use basic_types::*; use time::get_time; +use rlp::*; use std::cell::RefCell; @@ -297,7 +298,7 @@ impl Encodable for Header { #[cfg(test)] mod tests { use rustc_serialize::hex::FromHex; - use util::rlp::{decode, encode}; + use rlp; use super::Header; #[test] @@ -307,7 +308,7 @@ mod tests { let mix_hash = "a0a0349d8c3df71f1a48a9df7d03fd5f14aeee7d91332c009ecaff0a71ead405bd".from_hex().unwrap(); let nonce = "88ab4e252a7e8c2a23".from_hex().unwrap(); - let header: Header = decode(&header_rlp); + let header: Header = rlp::decode(&header_rlp); let seal_fields = header.seal; assert_eq!(seal_fields.len(), 2); assert_eq!(seal_fields[0], mix_hash); @@ -319,8 +320,8 @@ mod tests { // that's rlp of block header created with ethash engine. let header_rlp = "f901f9a0d405da4e66f1445d455195229624e133f5baafe72b5cf7b3c36c12c8146e98b7a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a05fb2b4bfdef7b314451cb138a534d225c922fc0e5fbe25e451142732c3e25c25a088d2ec6b9860aae1a2c3b299f72b6a5d70d7f7ba4722c78f2c49ba96273c2158a007c6fdfa8eea7e86b81f5b0fc0f78f90cc19f4aa60d323151e0cac660199e9a1b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302008003832fefba82524d84568e932a80a0a0349d8c3df71f1a48a9df7d03fd5f14aeee7d91332c009ecaff0a71ead405bd88ab4e252a7e8c2a23".from_hex().unwrap(); - let header: Header = decode(&header_rlp); - let encoded_header = encode(&header).to_vec(); + let header: Header = rlp::decode(&header_rlp); + let encoded_header = rlp::encode(&header).to_vec(); assert_eq!(header_rlp, encoded_header); } diff --git a/ethcore/src/json_tests/transaction.rs b/ethcore/src/json_tests/transaction.rs index 7c9a3327e64..a06e3b5dc4f 100644 --- a/ethcore/src/json_tests/transaction.rs +++ b/ethcore/src/json_tests/transaction.rs @@ -17,6 +17,7 @@ use super::test_common::*; use evm; use ethjson; +use rlp::{UntrustedRlp, View}; fn do_json_test(json_data: &[u8]) -> Vec { let tests = ethjson::transaction::Test::load(json_data).unwrap(); diff --git a/ethcore/src/lib.rs b/ethcore/src/lib.rs index b8233ea26e0..5344381f087 100644 --- a/ethcore/src/lib.rs +++ b/ethcore/src/lib.rs @@ -79,12 +79,9 @@ //! cargo build --release //! ``` -#[macro_use] extern crate log; -#[macro_use] extern crate ethcore_util as util; + extern crate ethcore_io as io; -#[macro_use] extern crate lazy_static; extern crate rustc_serialize; -#[macro_use] extern crate heapsize; extern crate crypto; extern crate time; extern crate env_logger; @@ -92,19 +89,32 @@ extern crate num_cpus; extern crate crossbeam; extern crate ethjson; extern crate bloomchain; -#[macro_use] extern crate ethcore_ipc as ipc; extern crate rayon; extern crate hyper; extern crate ethash; extern crate ethkey; -pub extern crate ethstore; extern crate semver; extern crate ethcore_ipc_nano as nanoipc; extern crate ethcore_devtools as devtools; extern crate rand; extern crate bit_set; +extern crate rlp; + +#[macro_use] +extern crate log; +#[macro_use] +extern crate ethcore_util as util; +#[macro_use] +extern crate lazy_static; +#[macro_use] +extern crate heapsize; +#[macro_use] +extern crate ethcore_ipc as ipc; -#[cfg(feature = "jit" )] extern crate evmjit; +#[cfg(feature = "jit" )] +extern crate evmjit; + +pub extern crate ethstore; pub mod account_provider; pub mod engines; diff --git a/ethcore/src/migrations/blocks/v8.rs b/ethcore/src/migrations/blocks/v8.rs index 798be07900c..21024f93d50 100644 --- a/ethcore/src/migrations/blocks/v8.rs +++ b/ethcore/src/migrations/blocks/v8.rs @@ -17,7 +17,7 @@ //! This migration compresses the state db. use util::migration::{SimpleMigration, Progress}; -use util::rlp::{Compressible, UntrustedRlp, View, RlpType}; +use rlp::{Compressible, UntrustedRlp, View, RlpType}; /// Compressing migration. #[derive(Default)] diff --git a/ethcore/src/migrations/state/v7.rs b/ethcore/src/migrations/state/v7.rs index 5395cec0977..9327decefb5 100644 --- a/ethcore/src/migrations/state/v7.rs +++ b/ethcore/src/migrations/state/v7.rs @@ -23,9 +23,11 @@ use util::Bytes; use util::{Address, FixedHash, H256}; use util::kvdb::Database; use util::migration::{Batch, Config, Error, Migration, SimpleMigration, Progress}; -use util::rlp::{decode, Rlp, RlpStream, Stream, View}; use util::sha3::Hashable; +use rlp::{decode, Rlp, RlpStream, Stream, View}; + + // attempt to migrate a key, value pair. None if migration not possible. fn attempt_migrate(mut key_h: H256, val: &[u8]) -> Option { let val_hash = val.sha3(); diff --git a/ethcore/src/migrations/v9.rs b/ethcore/src/migrations/v9.rs index 0c8e7758859..d4070d0c0d0 100644 --- a/ethcore/src/migrations/v9.rs +++ b/ethcore/src/migrations/v9.rs @@ -17,7 +17,7 @@ //! This migration consolidates all databases into single one using Column Families. -use util::{Rlp, RlpStream, View, Stream}; +use rlp::{Rlp, RlpStream, View, Stream}; use util::kvdb::Database; use util::migration::{Batch, Config, Error, Migration, Progress}; diff --git a/ethcore/src/miner/transaction_queue.rs b/ethcore/src/miner/transaction_queue.rs index 5e610da24ab..fb00a8aa86d 100644 --- a/ethcore/src/miner/transaction_queue.rs +++ b/ethcore/src/miner/transaction_queue.rs @@ -1229,6 +1229,8 @@ mod test { #[test] fn should_reject_incorectly_signed_transaction() { + use rlp::{self, RlpStream, Stream}; + // given let mut txq = TransactionQueue::new(); let tx = new_unsigned_tx(123.into(), 1.into()); @@ -1243,7 +1245,7 @@ mod test { s.append(&0u64); // v s.append(&U256::zero()); // r s.append(&U256::zero()); // s - decode(s.as_raw()) + rlp::decode(s.as_raw()) }; // when let res = txq.add(stx, &default_account_details, TransactionOrigin::External); diff --git a/ethcore/src/pod_account.rs b/ethcore/src/pod_account.rs index a65d0249b0d..703d617429e 100644 --- a/ethcore/src/pod_account.rs +++ b/ethcore/src/pod_account.rs @@ -19,6 +19,7 @@ use state::Account; use account_db::AccountDBMut; use ethjson; use types::account_diff::*; +use rlp::{self, RlpStream, Stream}; #[derive(Debug, Clone, PartialEq, Eq)] /// An account, expressed as Plain-Old-Data (hence the name). @@ -57,7 +58,7 @@ impl PodAccount { let mut stream = RlpStream::new_list(4); stream.append(&self.nonce); stream.append(&self.balance); - stream.append(&sec_trie_root(self.storage.iter().map(|(k, v)| (k.to_vec(), encode(&U256::from(&**v)).to_vec())).collect())); + stream.append(&sec_trie_root(self.storage.iter().map(|(k, v)| (k.to_vec(), rlp::encode(&U256::from(&**v)).to_vec())).collect())); stream.append(&self.code.as_ref().unwrap_or(&vec![]).sha3()); stream.out() } @@ -71,7 +72,7 @@ impl PodAccount { let mut r = H256::new(); let mut t = SecTrieDBMut::new(db, &mut r); for (k, v) in &self.storage { - if let Err(e) = t.insert(k, &encode(&U256::from(&**v))) { + if let Err(e) = t.insert(k, &rlp::encode(&U256::from(&**v))) { warn!("Encountered potential DB corruption: {}", e); } } diff --git a/ethcore/src/snapshot/account.rs b/ethcore/src/snapshot/account.rs index fcd7b6abce8..16c59db2e23 100644 --- a/ethcore/src/snapshot/account.rs +++ b/ethcore/src/snapshot/account.rs @@ -17,10 +17,11 @@ //! Account state encoding and decoding use account_db::{AccountDB, AccountDBMut}; +use snapshot::Error; + use util::{U256, FixedHash, H256, Bytes, HashDB, SHA3_EMPTY}; -use util::rlp::{Rlp, RlpStream, Stream, UntrustedRlp, View}; use util::trie::{TrieDB, Trie}; -use snapshot::Error; +use rlp::{Rlp, RlpStream, Stream, UntrustedRlp, View}; use std::collections::{HashMap, HashSet}; @@ -206,9 +207,9 @@ mod tests { use tests::helpers::get_temp_journal_db; use snapshot::tests::helpers::fill_storage; - use util::{SHA3_NULL_RLP, SHA3_EMPTY}; + use util::sha3::{SHA3_EMPTY, SHA3_NULL_RLP}; use util::{Address, FixedHash, H256, HashDB}; - use util::rlp::{UntrustedRlp, View}; + use rlp::{UntrustedRlp, View}; use std::collections::{HashSet, HashMap}; diff --git a/ethcore/src/snapshot/block.rs b/ethcore/src/snapshot/block.rs index 66fc060660e..05b3281c88b 100644 --- a/ethcore/src/snapshot/block.rs +++ b/ethcore/src/snapshot/block.rs @@ -20,8 +20,8 @@ use block::Block; use header::Header; use views::BlockView; -use util::rlp::{DecoderError, RlpStream, Stream, UntrustedRlp, View}; -use util::rlp::{Compressible, RlpType}; +use rlp::{DecoderError, RlpStream, Stream, UntrustedRlp, View}; +use rlp::{Compressible, RlpType}; use util::{Bytes, Hashable, H256}; const HEADER_FIELDS: usize = 10; @@ -103,7 +103,7 @@ impl AbridgedBlock { header.set_gas_used(try!(rlp.val_at(7))); header.set_timestamp(try!(rlp.val_at(8))); header.set_extra_data(try!(rlp.val_at(9))); - + let transactions = try!(rlp.val_at(10)); let uncles: Vec
= try!(rlp.val_at(11)); diff --git a/ethcore/src/snapshot/error.rs b/ethcore/src/snapshot/error.rs index d4587fdba26..acd9409f721 100644 --- a/ethcore/src/snapshot/error.rs +++ b/ethcore/src/snapshot/error.rs @@ -22,7 +22,7 @@ use ids::BlockID; use util::H256; use util::trie::TrieError; -use util::rlp::DecoderError; +use rlp::DecoderError; /// Snapshot-related errors. #[derive(Debug)] diff --git a/ethcore/src/snapshot/io.rs b/ethcore/src/snapshot/io.rs index 7179b97efb4..ae8a83b216c 100644 --- a/ethcore/src/snapshot/io.rs +++ b/ethcore/src/snapshot/io.rs @@ -27,7 +27,7 @@ use std::path::{Path, PathBuf}; use util::Bytes; use util::hash::H256; -use util::rlp::{self, Encodable, RlpStream, UntrustedRlp, Stream, View}; +use rlp::{self, Encodable, RlpStream, UntrustedRlp, Stream, View}; use super::ManifestData; diff --git a/ethcore/src/snapshot/mod.rs b/ethcore/src/snapshot/mod.rs index d1ad077fe7f..89e4ed8baaf 100644 --- a/ethcore/src/snapshot/mod.rs +++ b/ethcore/src/snapshot/mod.rs @@ -32,9 +32,9 @@ use util::Mutex; use util::hash::{FixedHash, H256}; use util::journaldb::{self, Algorithm, JournalDB}; use util::kvdb::Database; -use util::rlp::{DecoderError, RlpStream, Stream, UntrustedRlp, View, Compressible, RlpType}; -use util::rlp::SHA3_NULL_RLP; +use util::sha3::SHA3_NULL_RLP; use util::trie::{TrieDB, TrieDBMut, Trie, TrieMut}; +use rlp::{DecoderError, RlpStream, Stream, UntrustedRlp, View, Compressible, RlpType}; use self::account::Account; use self::block::AbridgedBlock; diff --git a/ethcore/src/snapshot/tests/helpers.rs b/ethcore/src/snapshot/tests/helpers.rs index aa055e8fbc7..bdf6a6a6a2b 100644 --- a/ethcore/src/snapshot/tests/helpers.rs +++ b/ethcore/src/snapshot/tests/helpers.rs @@ -25,7 +25,7 @@ use util::hash::{FixedHash, H256}; use util::hashdb::HashDB; use util::trie::{Alphabet, StandardMap, SecTrieDBMut, TrieMut, ValueMode}; use util::trie::{TrieDB, TrieDBMut, Trie}; -use util::rlp::SHA3_NULL_RLP; +use util::sha3::SHA3_NULL_RLP; // the proportion of accounts we will alter each tick. const ACCOUNT_CHURN: f32 = 0.01; diff --git a/ethcore/src/spec/genesis.rs b/ethcore/src/spec/genesis.rs index 8f472e99665..380c48aba98 100644 --- a/ethcore/src/spec/genesis.rs +++ b/ethcore/src/spec/genesis.rs @@ -14,8 +14,8 @@ // You should have received a copy of the GNU General Public License // along with Parity. If not, see . -use util::rlp::*; use util::{Address, H256, Uint, U256}; +use util::sha3::SHA3_NULL_RLP; use ethjson; use super::seal::Seal; diff --git a/ethcore/src/spec/seal.rs b/ethcore/src/spec/seal.rs index 600de701ae7..e25f174d20f 100644 --- a/ethcore/src/spec/seal.rs +++ b/ethcore/src/spec/seal.rs @@ -16,7 +16,7 @@ //! Spec seal. -use util::rlp::*; +use rlp::*; use util::hash::{H64, H256}; use ethjson; diff --git a/ethcore/src/spec/spec.rs b/ethcore/src/spec/spec.rs index 87a3297401c..d80ac0e330c 100644 --- a/ethcore/src/spec/spec.rs +++ b/ethcore/src/spec/spec.rs @@ -24,6 +24,7 @@ use super::genesis::Genesis; use super::seal::Generic as GenericSeal; use ethereum; use ethjson; +use rlp::{Rlp, RlpStream, View, Stream}; /// Parameters common to all engines. #[derive(Debug, PartialEq, Clone)] diff --git a/ethcore/src/state/account.rs b/ethcore/src/state/account.rs index e34be3e612a..cdd430290d7 100644 --- a/ethcore/src/state/account.rs +++ b/ethcore/src/state/account.rs @@ -19,6 +19,7 @@ use std::collections::hash_map::Entry; use util::*; use pod_account::*; +use rlp::*; use std::cell::{Ref, RefCell, Cell}; @@ -333,6 +334,7 @@ mod tests { use util::*; use super::*; use account_db::*; + use rlp::*; #[test] fn account_compress() { diff --git a/ethcore/src/tests/client.rs b/ethcore/src/tests/client.rs index 26256a760ec..99aae10781c 100644 --- a/ethcore/src/tests/client.rs +++ b/ethcore/src/tests/client.rs @@ -22,6 +22,7 @@ use tests::helpers::*; use common::*; use devtools::*; use miner::Miner; +use rlp::{Rlp, View}; #[test] fn imports_from_empty() { diff --git a/ethcore/src/tests/helpers.rs b/ethcore/src/tests/helpers.rs index f3975a0d0ec..e05c82c556c 100644 --- a/ethcore/src/tests/helpers.rs +++ b/ethcore/src/tests/helpers.rs @@ -27,6 +27,7 @@ use engines::Engine; use ethereum; use devtools::*; use miner::Miner; +use rlp::{self, RlpStream, Stream}; #[cfg(feature = "json-tests")] pub enum ChainEra { @@ -116,7 +117,7 @@ pub fn create_test_block_with_data(header: &Header, transactions: &[SignedTransa rlp.append(header); rlp.begin_list(transactions.len()); for t in transactions { - rlp.append_raw(&encode::(t).to_vec(), 1); + rlp.append_raw(&rlp::encode::(t).to_vec(), 1); } rlp.append(&uncles); rlp.out() diff --git a/ethcore/src/trace/bloom.rs b/ethcore/src/trace/bloom.rs index 8640240df65..9196453fd6d 100644 --- a/ethcore/src/trace/bloom.rs +++ b/ethcore/src/trace/bloom.rs @@ -1,6 +1,6 @@ use bloomchain::Bloom; use bloomchain::group::{BloomGroup, GroupPosition}; -use util::rlp::*; +use rlp::*; use basic_types::LogBloom; /// Helper structure representing bloom of the trace. diff --git a/ethcore/src/types/executed.rs b/ethcore/src/types/executed.rs index b817075815f..b4328b75d07 100644 --- a/ethcore/src/types/executed.rs +++ b/ethcore/src/types/executed.rs @@ -17,7 +17,7 @@ //! Transaction execution format module. use util::{Bytes, U256, Address, U512}; -use util::rlp::*; +use rlp::*; use trace::{VMTrace, FlatTrace}; use types::log_entry::LogEntry; use types::state_diff::StateDiff; @@ -203,7 +203,8 @@ pub type ExecutionResult = Result; #[test] fn should_encode_and_decode_call_type() { - use util::rlp; + use rlp; + let original = CallType::Call; let encoded = rlp::encode(&original); let decoded = rlp::decode(&encoded); diff --git a/ethcore/src/types/log_entry.rs b/ethcore/src/types/log_entry.rs index 5267686bc84..0e5f7d5316c 100644 --- a/ethcore/src/types/log_entry.rs +++ b/ethcore/src/types/log_entry.rs @@ -18,8 +18,9 @@ use std::ops::Deref; use util::{H256, Address, Bytes, HeapSizeOf, Hashable}; -use util::rlp::*; use util::bloom::Bloomable; +use rlp::*; + use basic_types::LogBloom; use header::BlockNumber; use ethjson; diff --git a/ethcore/src/types/receipt.rs b/ethcore/src/types/receipt.rs index c6d4133817f..52e6747e863 100644 --- a/ethcore/src/types/receipt.rs +++ b/ethcore/src/types/receipt.rs @@ -17,8 +17,9 @@ //! Receipt use util::{H256, U256, Address}; -use util::rlp::*; use util::HeapSizeOf; +use rlp::*; + use basic_types::LogBloom; use header::BlockNumber; use log_entry::{LogEntry, LocalizedLogEntry}; diff --git a/ethcore/src/types/trace_types/flat.rs b/ethcore/src/types/trace_types/flat.rs index e5dd9dd8b1b..58983558dc3 100644 --- a/ethcore/src/types/trace_types/flat.rs +++ b/ethcore/src/types/trace_types/flat.rs @@ -17,7 +17,7 @@ //! Flat trace module use std::collections::VecDeque; -use util::rlp::*; +use rlp::*; use util::HeapSizeOf; use basic_types::LogBloom; use super::trace::{Action, Res}; @@ -167,7 +167,6 @@ mod tests { #[test] fn test_trace_serialization() { - use util::rlp; // block #51921 let flat_trace = FlatTrace { @@ -220,8 +219,8 @@ mod tests { FlatTransactionTraces(vec![flat_trace1, flat_trace2]) ]); - let encoded = rlp::encode(&block_traces); - let decoded = rlp::decode(&encoded); + let encoded = ::rlp::encode(&block_traces); + let decoded = ::rlp::decode(&encoded); assert_eq!(block_traces, decoded); } } diff --git a/ethcore/src/types/trace_types/trace.rs b/ethcore/src/types/trace_types/trace.rs index f594dd4bb7e..7261107e60e 100644 --- a/ethcore/src/types/trace_types/trace.rs +++ b/ethcore/src/types/trace_types/trace.rs @@ -17,9 +17,10 @@ //! Tracing datatypes. use util::{U256, Bytes, Address}; -use util::rlp::*; use util::sha3::Hashable; use util::bloom::Bloomable; +use rlp::*; + use action_params::ActionParams; use basic_types::LogBloom; use types::executed::CallType; diff --git a/ethcore/src/types/transaction.rs b/ethcore/src/types/transaction.rs index 02d3da30a1c..f7e582f11d4 100644 --- a/ethcore/src/types/transaction.rs +++ b/ethcore/src/types/transaction.rs @@ -18,7 +18,7 @@ use std::ops::Deref; use std::cell::*; -use util::rlp::*; +use rlp::*; use util::sha3::Hashable; use util::{H256, Address, U256, Bytes}; use ethkey::{Signature, sign, Secret, recover, public_to_address, Error as EthkeyError}; @@ -275,7 +275,7 @@ impl SignedTransaction { match hash { Some(h) => h, None => { - let h = self.rlp_sha3(); + let h = (&*self.rlp_bytes()).sha3(); self.hash.set(Some(h)); h } diff --git a/ethcore/src/verification/verification.rs b/ethcore/src/verification/verification.rs index aa719cf236e..db3a9314c2a 100644 --- a/ethcore/src/verification/verification.rs +++ b/ethcore/src/verification/verification.rs @@ -24,6 +24,7 @@ use common::*; use engines::Engine; use blockchain::*; +use rlp::{UntrustedRlp, View}; /// Preprocessed block data gathered in `verify_block_unordered` call pub struct PreverifiedBlock { @@ -240,6 +241,7 @@ mod tests { use spec::*; use transaction::*; use tests::helpers::*; + use rlp::View; fn check_ok(result: Result<(), Error>) { result.unwrap_or_else(|e| panic!("Block verification failed: {:?}", e)); @@ -346,6 +348,8 @@ mod tests { #[test] #[cfg_attr(feature="dev", allow(similar_names))] fn test_verify_block() { + use rlp::{RlpStream, Stream}; + // Test against morden let mut good = Header::new(); let spec = Spec::new_test(); @@ -411,7 +415,7 @@ mod tests { let mut uncles_rlp = RlpStream::new(); uncles_rlp.append(&good_uncles); let good_uncles_hash = uncles_rlp.as_raw().sha3(); - let good_transactions_root = ordered_trie_root(good_transactions.iter().map(|t| encode::(t).to_vec()).collect()); + let good_transactions_root = ordered_trie_root(good_transactions.iter().map(|t| ::rlp::encode::(t).to_vec()).collect()); let mut parent = good.clone(); parent.set_number(9); diff --git a/ethcore/src/views/block.rs b/ethcore/src/views/block.rs index fdcae383b4e..97cf26441cb 100644 --- a/ethcore/src/views/block.rs +++ b/ethcore/src/views/block.rs @@ -20,6 +20,7 @@ use util::*; use header::*; use transaction::*; use super::{TransactionView, HeaderView}; +use rlp::{Rlp, View}; /// View onto block rlp. pub struct BlockView<'a> { diff --git a/ethcore/src/views/body.rs b/ethcore/src/views/body.rs index 8f1295f31a3..989acd46566 100644 --- a/ethcore/src/views/body.rs +++ b/ethcore/src/views/body.rs @@ -20,6 +20,7 @@ use util::*; use header::*; use transaction::*; use super::{TransactionView, HeaderView}; +use rlp::{Rlp, View}; /// View onto block rlp. pub struct BodyView<'a> { diff --git a/ethcore/src/views/header.rs b/ethcore/src/views/header.rs index 70b59fbfaf0..6c3b14b15e5 100644 --- a/ethcore/src/views/header.rs +++ b/ethcore/src/views/header.rs @@ -16,7 +16,8 @@ //! View onto block header rlp -use util::{Rlp, U256, Bytes, Hashable, H256, Address, H2048, View}; +use util::{U256, Bytes, Hashable, H256, Address, H2048}; +use rlp::{Rlp, View}; use header::BlockNumber; /// View onto block header rlp. diff --git a/ethcore/src/views/transaction.rs b/ethcore/src/views/transaction.rs index d8329090930..df861d9fdb2 100644 --- a/ethcore/src/views/transaction.rs +++ b/ethcore/src/views/transaction.rs @@ -15,7 +15,8 @@ // along with Parity. If not, see . //! View onto transaction rlp -use util::{Rlp, U256, Bytes, Hashable, H256, View}; +use util::{U256, Bytes, Hashable, H256}; +use rlp::{Rlp, View}; /// View onto transaction rlp. pub struct TransactionView<'a> { diff --git a/parity/blockchain.rs b/parity/blockchain.rs index 06e03ae72c8..0dd11b97653 100644 --- a/parity/blockchain.rs +++ b/parity/blockchain.rs @@ -24,7 +24,8 @@ use std::sync::Arc; use rustc_serialize::hex::FromHex; use ethcore_logger::{setup_log, Config as LogConfig}; use io::{PanicHandler, ForwardPanic}; -use util::{PayloadInfo, ToPretty}; +use util::ToPretty; +use rlp::PayloadInfo; use ethcore::service::ClientService; use ethcore::client::{Mode, DatabaseCompactionProfile, Switch, VMType, BlockImportError, BlockChainClient, BlockID}; use ethcore::error::ImportError; diff --git a/parity/main.rs b/parity/main.rs index 406645f066e..86844baa973 100644 --- a/parity/main.rs +++ b/parity/main.rs @@ -26,12 +26,8 @@ extern crate docopt; extern crate num_cpus; extern crate rustc_serialize; extern crate ethcore_devtools as devtools; -#[macro_use] -extern crate ethcore_util as util; extern crate ethcore; extern crate ethsync; -#[macro_use] -extern crate log as rlog; extern crate env_logger; extern crate ethcore_logger; extern crate ctrlc; @@ -43,8 +39,8 @@ extern crate semver; extern crate ethcore_io as io; extern crate ethcore_ipc as ipc; extern crate ethcore_ipc_nano as nanoipc; -#[macro_use] -extern crate hyper; // for price_info.rs +extern crate rlp; + extern crate json_ipc_server as jsonipc; extern crate ethcore_ipc_hypervisor as hypervisor; @@ -52,11 +48,19 @@ extern crate ethcore_rpc; extern crate ethcore_signer; extern crate ansi_term; -#[macro_use] -extern crate lazy_static; + extern crate regex; extern crate isatty; +#[macro_use] +extern crate ethcore_util as util; +#[macro_use] +extern crate log as rlog; +#[macro_use] +extern crate hyper; // for price_info.rs +#[macro_use] +extern crate lazy_static; + #[cfg(feature="stratum")] extern crate ethcore_stratum; diff --git a/rpc/Cargo.toml b/rpc/Cargo.toml index 11dc0bbe32e..8bb16007f72 100644 --- a/rpc/Cargo.toml +++ b/rpc/Cargo.toml @@ -23,6 +23,7 @@ ethash = { path = "../ethash" } ethsync = { path = "../sync" } ethjson = { path = "../json" } ethcore-devtools = { path = "../devtools" } +rlp = { path = "../util/rlp" } rustc-serialize = "0.3" transient-hashmap = "0.1" serde_macros = { version = "0.8.0", optional = true } diff --git a/rpc/src/lib.rs b/rpc/src/lib.rs index 6edc72d41dd..17d1837aed1 100644 --- a/rpc/src/lib.rs +++ b/rpc/src/lib.rs @@ -19,15 +19,12 @@ #![cfg_attr(feature="nightly", feature(custom_derive, custom_attribute, plugin))] #![cfg_attr(feature="nightly", plugin(serde_macros, clippy))] -#[macro_use] -extern crate log; extern crate rustc_serialize; extern crate serde; extern crate serde_json; extern crate jsonrpc_core; extern crate jsonrpc_http_server; -#[macro_use] -extern crate ethcore_util as util; + extern crate ethcore_io as io; extern crate ethcore; extern crate ethkey; @@ -37,6 +34,12 @@ extern crate transient_hashmap; extern crate json_ipc_server as ipc; extern crate ethcore_ipc; extern crate time; +extern crate rlp; + +#[macro_use] +extern crate log; +#[macro_use] +extern crate ethcore_util as util; #[cfg(test)] extern crate ethjson; diff --git a/rpc/src/v1/helpers/dispatch.rs b/rpc/src/v1/helpers/dispatch.rs index f96ba8f0818..5587673d81d 100644 --- a/rpc/src/v1/helpers/dispatch.rs +++ b/rpc/src/v1/helpers/dispatch.rs @@ -15,7 +15,6 @@ // along with Parity. If not, see . use util::{Address, H256, U256, Uint}; -use util::rlp::encode; use util::bytes::ToPretty; use ethcore::miner::MinerService; use ethcore::client::MiningBlockChainClient; @@ -70,7 +69,7 @@ pub fn unlock_sign_and_dispatch(client: &C, miner: &M, request: Transactio t.with_signature(signature) }; - trace!(target: "miner", "send_transaction: dispatching tx: {}", encode(&signed_transaction).to_vec().pretty()); + trace!(target: "miner", "send_transaction: dispatching tx: {}", ::rlp::encode(&signed_transaction).to_vec().pretty()); dispatch_transaction(&*client, &*miner, signed_transaction) } @@ -84,7 +83,7 @@ pub fn sign_and_dispatch(client: &C, miner: &M, request: TransactionReques t.with_signature(signature) }; - trace!(target: "miner", "send_transaction: dispatching tx: {}", encode(&signed_transaction).to_vec().pretty()); + trace!(target: "miner", "send_transaction: dispatching tx: {}", ::rlp::encode(&signed_transaction).to_vec().pretty()); dispatch_transaction(&*client, &*miner, signed_transaction) } diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs index be69a221dfe..7807c01eb9d 100644 --- a/rpc/src/v1/impls/eth.rs +++ b/rpc/src/v1/impls/eth.rs @@ -29,8 +29,8 @@ use ethcore::miner::{MinerService, ExternalMinerService}; use jsonrpc_core::*; use util::{H256, Address, FixedHash, U256, H64, Uint}; use util::sha3::*; -use util::rlp::{encode, decode, UntrustedRlp, View}; use util::{FromHex, Mutex}; +use rlp::{self, UntrustedRlp, View}; use ethcore::account_provider::AccountProvider; use ethcore::client::{MiningBlockChainClient, BlockID, TransactionID, UncleID}; use ethcore::header::Header as BlockHeader; @@ -123,7 +123,7 @@ impl EthClient where timestamp: view.timestamp().into(), difficulty: view.difficulty().into(), total_difficulty: total_difficulty.into(), - seal_fields: view.seal().into_iter().map(|f| decode(&f)).map(Bytes::new).collect(), + seal_fields: view.seal().into_iter().map(|f| rlp::decode(&f)).map(Bytes::new).collect(), uncles: block_view.uncle_hashes().into_iter().map(Into::into).collect(), transactions: match include_txs { true => BlockTransactions::Full(block_view.localized_transactions().into_iter().map(Into::into).collect()), @@ -147,7 +147,7 @@ impl EthClient where fn uncle(&self, id: UncleID) -> Result { let client = take_weak!(self.client); let uncle: BlockHeader = match client.uncle(id) { - Some(rlp) => decode(&rlp), + Some(rlp) => rlp::decode(&rlp), None => { return Ok(Value::Null); } }; let parent_difficulty = match client.block_total_difficulty(BlockID::Hash(uncle.parent_hash().clone())) { @@ -173,7 +173,7 @@ impl EthClient where total_difficulty: (uncle.difficulty().clone() + parent_difficulty).into(), receipts_root: uncle.receipts_root().clone().into(), extra_data: uncle.extra_data().clone().into(), - seal_fields: uncle.seal().clone().into_iter().map(|f| decode(&f)).map(Bytes::new).collect(), + seal_fields: uncle.seal().clone().into_iter().map(|f| rlp::decode(&f)).map(Bytes::new).collect(), uncles: vec![], transactions: BlockTransactions::Hashes(vec![]), }; @@ -566,7 +566,7 @@ impl Eth for EthClient where trace!(target: "miner", "submit_work: Decoded: nonce={}, pow_hash={}, mix_hash={}", nonce, pow_hash, mix_hash); let miner = take_weak!(self.miner); let client = take_weak!(self.client); - let seal = vec![encode(&mix_hash).to_vec(), encode(&nonce).to_vec()]; + let seal = vec![rlp::encode(&mix_hash).to_vec(), rlp::encode(&nonce).to_vec()]; let r = miner.submit_seal(&*client, pow_hash, seal); Ok(to_value(&r.is_ok())) }) diff --git a/rpc/src/v1/impls/traces.rs b/rpc/src/v1/impls/traces.rs index acbedd3c219..e85d961a117 100644 --- a/rpc/src/v1/impls/traces.rs +++ b/rpc/src/v1/impls/traces.rs @@ -18,7 +18,7 @@ use std::sync::{Weak, Arc}; use jsonrpc_core::*; -use util::rlp::{UntrustedRlp, View}; +use rlp::{UntrustedRlp, View}; use ethcore::client::{BlockChainClient, CallAnalytics, TransactionID, TraceId}; use ethcore::miner::MinerService; use ethcore::transaction::{Transaction as EthTransaction, SignedTransaction, Action}; diff --git a/rpc/src/v1/tests/mocked/eth.rs b/rpc/src/v1/tests/mocked/eth.rs index a6b5a1ef7db..21f781160ce 100644 --- a/rpc/src/v1/tests/mocked/eth.rs +++ b/rpc/src/v1/tests/mocked/eth.rs @@ -364,7 +364,7 @@ fn rpc_eth_pending_transaction_by_hash() { let tester = EthTester::default(); { - let tx: SignedTransaction = decode(&FromHex::from_hex("f85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap()); + let tx: SignedTransaction = ::rlp::decode(&FromHex::from_hex("f85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap()); tester.miner.pending_transactions.lock().insert(H256::zero(), tx); } @@ -705,7 +705,7 @@ fn rpc_eth_send_raw_transaction() { let signature = tester.accounts_provider.sign(address, t.hash()).unwrap(); let t = t.with_signature(signature); - let rlp = ::util::rlp::encode(&t).to_vec().to_hex(); + let rlp = ::rlp::encode(&t).to_vec().to_hex(); let req = r#"{ "jsonrpc": "2.0", diff --git a/rpc/src/v1/types/transaction.rs b/rpc/src/v1/types/transaction.rs index 812c006e43e..6ce9eafc3b7 100644 --- a/rpc/src/v1/types/transaction.rs +++ b/rpc/src/v1/types/transaction.rs @@ -14,7 +14,6 @@ // You should have received a copy of the GNU General Public License // along with Parity. If not, see . -use util::rlp::encode; use ethcore::contract_address; use ethcore::transaction::{LocalizedTransaction, Action, SignedTransaction}; use v1::types::{Bytes, H160, H256, U256}; @@ -75,7 +74,7 @@ impl From for Transaction { Action::Create => Some(contract_address(&t.sender().unwrap(), &t.nonce).into()), Action::Call(_) => None, }, - raw: encode(&t.signed).to_vec().into(), + raw: ::rlp::encode(&t.signed).to_vec().into(), } } } @@ -101,7 +100,7 @@ impl From for Transaction { Action::Create => Some(contract_address(&t.sender().unwrap(), &t.nonce).into()), Action::Call(_) => None, }, - raw: encode(&t).to_vec().into(), + raw: ::rlp::encode(&t).to_vec().into(), } } } diff --git a/scripts/targets.sh b/scripts/targets.sh index 5a8d41a3b87..009b8ad1d03 100644 --- a/scripts/targets.sh +++ b/scripts/targets.sh @@ -2,6 +2,7 @@ export TARGETS=" -p bigint\ + -p rlp\ -p ethash \ -p ethcore \ -p ethcore-dapps \ diff --git a/sync/Cargo.toml b/sync/Cargo.toml index 3a2e8aec241..a73077c9cc4 100644 --- a/sync/Cargo.toml +++ b/sync/Cargo.toml @@ -16,6 +16,7 @@ ethcore-util = { path = "../util" } ethcore-network = { path = "../util/network" } ethcore-io = { path = "../util/io" } ethcore = { path = "../ethcore" } +rlp = { path = "../util/rlp" } clippy = { version = "0.0.85", optional = true} log = "0.3" env_logger = "0.3" diff --git a/sync/src/blocks.rs b/sync/src/blocks.rs index 498b35f43e8..753ba711116 100644 --- a/sync/src/blocks.rs +++ b/sync/src/blocks.rs @@ -15,6 +15,7 @@ // along with Parity. If not, see . use util::*; +use rlp::*; use network::NetworkError; use ethcore::header::{ Header as BlockHeader}; @@ -283,11 +284,11 @@ impl BlockCollection { transactions_root: info.transactions_root().clone(), uncles: info.uncles_hash().clone(), }; - if header_id.transactions_root == rlp::SHA3_NULL_RLP && header_id.uncles == rlp::SHA3_EMPTY_LIST_RLP { + if header_id.transactions_root == sha3::SHA3_NULL_RLP && header_id.uncles == sha3::SHA3_EMPTY_LIST_RLP { // empty body, just mark as downloaded let mut body_stream = RlpStream::new_list(2); - body_stream.append_raw(&rlp::EMPTY_LIST_RLP, 1); - body_stream.append_raw(&rlp::EMPTY_LIST_RLP, 1); + body_stream.append_raw(&::rlp::EMPTY_LIST_RLP, 1); + body_stream.append_raw(&::rlp::EMPTY_LIST_RLP, 1); block.body = Some(body_stream.out()); } else { @@ -337,6 +338,7 @@ mod test { use ethcore::views::HeaderView; use ethcore::header::BlockNumber; use util::*; + use rlp::*; fn is_empty(bc: &BlockCollection) -> bool { bc.heads.is_empty() && diff --git a/sync/src/chain.rs b/sync/src/chain.rs index f5a54a0bad2..424c9972b01 100644 --- a/sync/src/chain.rs +++ b/sync/src/chain.rs @@ -88,6 +88,7 @@ /// use util::*; +use rlp::*; use network::*; use std::mem::{replace}; use ethcore::views::{HeaderView, BlockView}; @@ -1531,6 +1532,7 @@ mod tests { use super::*; use ::SyncConfig; use util::*; + use rlp::*; use super::{PeerInfo, PeerAsking}; use ethcore::views::BlockView; use ethcore::header::*; @@ -1548,8 +1550,8 @@ mod tests { let mut rlp = RlpStream::new_list(3); rlp.append(&header); - rlp.append_raw(&rlp::EMPTY_LIST_RLP, 1); - rlp.append_raw(&rlp::EMPTY_LIST_RLP, 1); + rlp.append_raw(&::rlp::EMPTY_LIST_RLP, 1); + rlp.append_raw(&::rlp::EMPTY_LIST_RLP, 1); rlp.out() } diff --git a/sync/src/lib.rs b/sync/src/lib.rs index 69dd03a2aed..c0c240f9dc1 100644 --- a/sync/src/lib.rs +++ b/sync/src/lib.rs @@ -34,7 +34,6 @@ //! extern crate ethcore; //! extern crate ethsync; //! use std::env; -//! use std::sync::Arc; //! use io::IoChannel; //! use ethcore::client::{Client, ClientConfig}; //! use ethsync::{EthSync, SyncConfig, ManageNetwork, NetworkConfiguration}; @@ -62,22 +61,24 @@ //! } //! ``` -#[macro_use] -extern crate log; -#[macro_use] -extern crate ethcore_util as util; extern crate ethcore_network as network; extern crate ethcore_io as io; extern crate ethcore; extern crate env_logger; extern crate time; extern crate rand; +extern crate semver; +extern crate parking_lot; +extern crate rlp; + +#[macro_use] +extern crate log; +#[macro_use] +extern crate ethcore_util as util; #[macro_use] extern crate heapsize; #[macro_use] extern crate ethcore_ipc as ipc; -extern crate semver; -extern crate parking_lot; mod chain; mod blocks; diff --git a/util/Cargo.toml b/util/Cargo.toml index 719e4c25524..106251a3f66 100644 --- a/util/Cargo.toml +++ b/util/Cargo.toml @@ -18,7 +18,8 @@ rocksdb = { git = "https://github.com/ethcore/rust-rocksdb" } lazy_static = "0.2" eth-secp256k1 = { git = "https://github.com/ethcore/rust-secp256k1" } rust-crypto = "0.2.34" -elastic-array = { git = "https://github.com/ethcore/elastic-array" } +elastic-array = "0.5" +rlp = { path = "rlp" } heapsize = { version = "0.3", features = ["unstable"] } itertools = "0.4" sha3 = { path = "sha3" } diff --git a/util/network/Cargo.toml b/util/network/Cargo.toml index caad5c0d5da..50ef6a5e443 100644 --- a/util/network/Cargo.toml +++ b/util/network/Cargo.toml @@ -25,6 +25,7 @@ ethcore-util = { path = ".." } ethcore-devtools = { path = "../../devtools" } ethkey = { path = "../../ethkey" } ethcrypto = { path = "../../ethcrypto" } +rlp = { path = "../rlp" } [features] default = [] diff --git a/util/network/src/connection.rs b/util/network/src/connection.rs index d3e54393bbb..4a7b5a3c737 100644 --- a/util/network/src/connection.rs +++ b/util/network/src/connection.rs @@ -23,7 +23,7 @@ use mio::tcp::*; use util::hash::*; use util::sha3::*; use util::bytes::*; -use util::rlp::*; +use rlp::*; use std::io::{self, Cursor, Read, Write}; use error::*; use io::{IoContext, StreamToken}; diff --git a/util/network/src/discovery.rs b/util/network/src/discovery.rs index 48d16be4842..61eaf4094bc 100644 --- a/util/network/src/discovery.rs +++ b/util/network/src/discovery.rs @@ -24,7 +24,7 @@ use mio::udp::*; use util::sha3::*; use time; use util::hash::*; -use util::rlp::*; +use rlp::*; use node_table::*; use error::NetworkError; use io::{StreamToken, IoContext}; diff --git a/util/network/src/error.rs b/util/network/src/error.rs index 99bfb45006e..a1c4d70a163 100644 --- a/util/network/src/error.rs +++ b/util/network/src/error.rs @@ -15,7 +15,7 @@ // along with Parity. If not, see . use io::IoError; -use util::rlp::*; +use rlp::*; use util::UtilError; use std::fmt; use ethkey::Error as KeyError; diff --git a/util/network/src/handshake.rs b/util/network/src/handshake.rs index 403079de4b4..1456cf80152 100644 --- a/util/network/src/handshake.rs +++ b/util/network/src/handshake.rs @@ -18,9 +18,9 @@ use std::sync::Arc; use rand::random; use mio::tcp::*; use util::hash::*; -use util::rlp::*; use util::sha3::Hashable; use util::bytes::Bytes; +use rlp::*; use connection::{Connection}; use host::{HostInfo}; use node_table::NodeId; diff --git a/util/network/src/host.rs b/util/network/src/host.rs index a1d320c5890..359f54f1af8 100644 --- a/util/network/src/host.rs +++ b/util/network/src/host.rs @@ -29,8 +29,8 @@ use mio::*; use mio::tcp::*; use util::hash::*; use util::Hashable; -use util::rlp::*; use util::version; +use rlp::*; use session::{Session, SessionData}; use error::*; use io::*; diff --git a/util/network/src/lib.rs b/util/network/src/lib.rs index e36861f37c0..bfcd49ceab4 100644 --- a/util/network/src/lib.rs +++ b/util/network/src/lib.rs @@ -54,9 +54,6 @@ //! } //! ``` - -#[macro_use] -extern crate log; extern crate ethcore_io as io; extern crate ethcore_util as util; extern crate parking_lot; @@ -72,6 +69,11 @@ extern crate libc; extern crate slab; extern crate ethkey; extern crate ethcrypto as crypto; +extern crate rlp; + +#[macro_use] +extern crate log; + #[cfg(test)] extern crate ethcore_devtools as devtools; diff --git a/util/network/src/node_table.rs b/util/network/src/node_table.rs index 26f6d9f8ceb..073e9ab763c 100644 --- a/util/network/src/node_table.rs +++ b/util/network/src/node_table.rs @@ -26,8 +26,8 @@ use std::fmt; use std::fs; use std::io::{Read, Write}; use util::hash::*; -use util::rlp::*; use util::UtilError; +use rlp::*; use time::Tm; use error::NetworkError; use discovery::{TableUpdates, NodeEntry}; diff --git a/util/network/src/session.rs b/util/network/src/session.rs index 4e6dd1c8a71..8ebd3709048 100644 --- a/util/network/src/session.rs +++ b/util/network/src/session.rs @@ -19,8 +19,8 @@ use std::io; use std::sync::*; use mio::*; use mio::tcp::*; -use util::rlp::*; use util::hash::*; +use rlp::*; use connection::{EncryptedConnection, Packet, Connection}; use handshake::Handshake; use io::{IoContext, StreamToken}; diff --git a/util/rlp/Cargo.toml b/util/rlp/Cargo.toml new file mode 100644 index 00000000000..eba3a2842e3 --- /dev/null +++ b/util/rlp/Cargo.toml @@ -0,0 +1,12 @@ +[package] +description = "Recursive-length prefix encoding, decoding, and compression" +license = "GPL-3.0" +name = "rlp" +version = "0.1.0" +authors = ["Ethcore "] + +[dependencies] +elastic-array = "0.5" +bigint = { path = "../bigint" } +lazy_static = "0.2" +rustc-serialize = "0.3" \ No newline at end of file diff --git a/util/src/rlp/bytes.rs b/util/rlp/src/bytes.rs similarity index 99% rename from util/src/rlp/bytes.rs rename to util/rlp/src/bytes.rs index 9b98be6c6f2..5940d21d238 100644 --- a/util/src/rlp/bytes.rs +++ b/util/rlp/src/bytes.rs @@ -22,7 +22,7 @@ use std::fmt; use std::cmp::Ordering; use std::error::Error as StdError; use bigint::uint::{Uint, U128, U256}; -use hash::{H64, H128, H160, H256, H512, H520, H2048}; +use bigint::hash::{H64, H128, H160, H256, H512, H520, H2048}; use elastic_array::*; /// Vector like object diff --git a/util/src/rlp/commonrlps.rs b/util/rlp/src/commonrlps.rs similarity index 76% rename from util/src/rlp/commonrlps.rs rename to util/rlp/src/commonrlps.rs index 856c2fc3ab5..23911724559 100644 --- a/util/src/rlp/commonrlps.rs +++ b/util/rlp/src/commonrlps.rs @@ -16,7 +16,7 @@ //! Contains RLPs used for compression. -use rlp::rlpcompression::InvalidRlpSwapper; +use rlpcompression::InvalidRlpSwapper; lazy_static! { /// Swapper for snapshot compression. @@ -47,60 +47,4 @@ static COMMON_RLPS: &'static [&'static [u8]] = &[ &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] ]; -static INVALID_RLPS: &'static [&'static [u8]] = &[&[0x81, 0x0], &[0x81, 0x1], &[0x81, 0x2], &[0x81, 0x3], &[0x81, 0x4], &[0x81, 0x5], &[0x81, 0x6], &[0x81, 0x7], &[0x81, 0x8], &[0x81, 0x9], &[0x81, 0xa], &[0x81, 0xb], &[0x81, 0xc], &[0x81, 0xd], &[0x81, 0xe], &[0x81, 0xf], &[0x81, 0x10], &[0x81, 0x11], &[0x81, 0x12], &[0x81, 0x13], &[0x81, 0x14], &[0x81, 0x15], &[0x81, 0x16], &[0x81, 0x17], &[0x81, 0x18], &[0x81, 0x19], &[0x81, 0x1a], &[0x81, 0x1b], &[0x81, 0x1c], &[0x81, 0x1d], &[0x81, 0x1e], &[0x81, 0x1f], &[0x81, 0x20], &[0x81, 0x21], &[0x81, 0x22], &[0x81, 0x23], &[0x81, 0x24], &[0x81, 0x25], &[0x81, 0x26], &[0x81, 0x27], &[0x81, 0x28], &[0x81, 0x29], &[0x81, 0x2a], &[0x81, 0x2b], &[0x81, 0x2c], &[0x81, 0x2d], &[0x81, 0x2e], &[0x81, 0x2f], &[0x81, 0x30], &[0x81, 0x31], &[0x81, 0x32], &[0x81, 0x33], &[0x81, 0x34], &[0x81, 0x35], &[0x81, 0x36], &[0x81, 0x37], &[0x81, 0x38], &[0x81, 0x39], &[0x81, 0x3a], &[0x81, 0x3b], &[0x81, 0x3c], &[0x81, 0x3d], &[0x81, 0x3e], &[0x81, 0x3f], &[0x81, 0x40], &[0x81, 0x41], &[0x81, 0x42], &[0x81, 0x43], &[0x81, 0x44], &[0x81, 0x45], &[0x81, 0x46], &[0x81, 0x47], &[0x81, 0x48], &[0x81, 0x49], &[0x81, 0x4a], &[0x81, 0x4b], &[0x81, 0x4c], &[0x81, 0x4d], &[0x81, 0x4e], &[0x81, 0x4f], &[0x81, 0x50], &[0x81, 0x51], &[0x81, 0x52], &[0x81, 0x53], &[0x81, 0x54], &[0x81, 0x55], &[0x81, 0x56], &[0x81, 0x57], &[0x81, 0x58], &[0x81, 0x59], &[0x81, 0x5a], &[0x81, 0x5b], &[0x81, 0x5c], &[0x81, 0x5d], &[0x81, 0x5e], &[0x81, 0x5f], &[0x81, 0x60], &[0x81, 0x61], &[0x81, 0x62], &[0x81, 0x63], &[0x81, 0x64], &[0x81, 0x65], &[0x81, 0x66], &[0x81, 0x67], &[0x81, 0x68], &[0x81, 0x69], &[0x81, 0x6a], &[0x81, 0x6b], &[0x81, 0x6c], &[0x81, 0x6d], &[0x81, 0x6e], &[0x81, 0x6f], &[0x81, 0x70], &[0x81, 0x71], &[0x81, 0x72], &[0x81, 0x73], &[0x81, 0x74], &[0x81, 0x75], &[0x81, 0x76], &[0x81, 0x77], &[0x81, 0x78], &[0x81, 0x79], &[0x81, 0x7a], &[0x81, 0x7b], &[0x81, 0x7c], &[0x81, 0x7d], &[0x81, 0x7e]]; - -#[cfg(test)] -mod tests { - #[test] - #[ignore] - fn analyze_db() { - use rlp::{UntrustedRlp, View}; - use std::collections::HashMap; - use kvdb::*; - - let path = "db path".to_string(); - let values: Vec<_> = Database::open_default(&path).unwrap().iter(Some(2)).map(|(_, v)| v).collect(); - let mut rlp_counts: HashMap<_, u32> = HashMap::new(); - let mut rlp_sizes: HashMap<_, u32> = HashMap::new(); - - fn flat_rlp<'a>(acc: &mut Vec>, rlp: UntrustedRlp<'a>) { - match rlp.is_data() { - true => if rlp.size()>=70 { - match rlp.data() { - Ok(x) => flat_rlp(acc, UntrustedRlp::new(x)), - _ => acc.push(rlp), - } - } else { - acc.push(rlp); - }, - false => for r in rlp.iter() { flat_rlp(acc, r); }, - } - } - - fn space_saving(bytes: &[u8]) -> u32 { - let l = bytes.len() as u32; - match l >= 2 { - true => l-2, - false => 0, - } - } - - for v in &values { - let rlp = UntrustedRlp::new(v); - let mut flat = Vec::new(); - flat_rlp(&mut flat, rlp); - for r in &flat { - *rlp_counts.entry(r.as_raw()).or_insert(0) += 1; - *rlp_sizes.entry(r.as_raw()).or_insert(0) += space_saving(r.as_raw()); - } - } - let mut size_vec: Vec<_> = rlp_sizes.iter().collect(); - size_vec.sort_by(|a, b| b.1.cmp(a.1)); - - // Exclude rare large RLPs. - for v in size_vec.iter().filter(|v| rlp_counts.get(v.0).unwrap()>&100).take(20) { - println!("{:?}, {:?}", v, rlp_counts.get(v.0).unwrap()); - } - println!("DONE"); - } -} +static INVALID_RLPS: &'static [&'static [u8]] = &[&[0x81, 0x0], &[0x81, 0x1], &[0x81, 0x2], &[0x81, 0x3], &[0x81, 0x4], &[0x81, 0x5], &[0x81, 0x6], &[0x81, 0x7], &[0x81, 0x8], &[0x81, 0x9], &[0x81, 0xa], &[0x81, 0xb], &[0x81, 0xc], &[0x81, 0xd], &[0x81, 0xe], &[0x81, 0xf], &[0x81, 0x10], &[0x81, 0x11], &[0x81, 0x12], &[0x81, 0x13], &[0x81, 0x14], &[0x81, 0x15], &[0x81, 0x16], &[0x81, 0x17], &[0x81, 0x18], &[0x81, 0x19], &[0x81, 0x1a], &[0x81, 0x1b], &[0x81, 0x1c], &[0x81, 0x1d], &[0x81, 0x1e], &[0x81, 0x1f], &[0x81, 0x20], &[0x81, 0x21], &[0x81, 0x22], &[0x81, 0x23], &[0x81, 0x24], &[0x81, 0x25], &[0x81, 0x26], &[0x81, 0x27], &[0x81, 0x28], &[0x81, 0x29], &[0x81, 0x2a], &[0x81, 0x2b], &[0x81, 0x2c], &[0x81, 0x2d], &[0x81, 0x2e], &[0x81, 0x2f], &[0x81, 0x30], &[0x81, 0x31], &[0x81, 0x32], &[0x81, 0x33], &[0x81, 0x34], &[0x81, 0x35], &[0x81, 0x36], &[0x81, 0x37], &[0x81, 0x38], &[0x81, 0x39], &[0x81, 0x3a], &[0x81, 0x3b], &[0x81, 0x3c], &[0x81, 0x3d], &[0x81, 0x3e], &[0x81, 0x3f], &[0x81, 0x40], &[0x81, 0x41], &[0x81, 0x42], &[0x81, 0x43], &[0x81, 0x44], &[0x81, 0x45], &[0x81, 0x46], &[0x81, 0x47], &[0x81, 0x48], &[0x81, 0x49], &[0x81, 0x4a], &[0x81, 0x4b], &[0x81, 0x4c], &[0x81, 0x4d], &[0x81, 0x4e], &[0x81, 0x4f], &[0x81, 0x50], &[0x81, 0x51], &[0x81, 0x52], &[0x81, 0x53], &[0x81, 0x54], &[0x81, 0x55], &[0x81, 0x56], &[0x81, 0x57], &[0x81, 0x58], &[0x81, 0x59], &[0x81, 0x5a], &[0x81, 0x5b], &[0x81, 0x5c], &[0x81, 0x5d], &[0x81, 0x5e], &[0x81, 0x5f], &[0x81, 0x60], &[0x81, 0x61], &[0x81, 0x62], &[0x81, 0x63], &[0x81, 0x64], &[0x81, 0x65], &[0x81, 0x66], &[0x81, 0x67], &[0x81, 0x68], &[0x81, 0x69], &[0x81, 0x6a], &[0x81, 0x6b], &[0x81, 0x6c], &[0x81, 0x6d], &[0x81, 0x6e], &[0x81, 0x6f], &[0x81, 0x70], &[0x81, 0x71], &[0x81, 0x72], &[0x81, 0x73], &[0x81, 0x74], &[0x81, 0x75], &[0x81, 0x76], &[0x81, 0x77], &[0x81, 0x78], &[0x81, 0x79], &[0x81, 0x7a], &[0x81, 0x7b], &[0x81, 0x7c], &[0x81, 0x7d], &[0x81, 0x7e]]; \ No newline at end of file diff --git a/util/src/rlp/mod.rs b/util/rlp/src/lib.rs similarity index 77% rename from util/src/rlp/mod.rs rename to util/rlp/src/lib.rs index 4dc14c8a391..2cc8c3bd81d 100644 --- a/util/src/rlp/mod.rs +++ b/util/rlp/src/lib.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Parity. If not, see . -//! Rlp serialization module +//! Recursive Length Prefix serialization crate. //! //! Allows encoding, decoding, and view onto rlp-slice //! @@ -64,27 +64,29 @@ pub use self::untrusted_rlp::{UntrustedRlp, UntrustedRlpIterator, PayloadInfo, P pub use self::rlpin::{Rlp, RlpIterator}; pub use self::rlpstream::RlpStream; pub use self::rlpcompression::RlpType; -pub use elastic_array::ElasticArray1024; -use super::hash::H256; + +extern crate bigint; +extern crate elastic_array; +extern crate rustc_serialize; + +#[macro_use] +extern crate lazy_static; + +use elastic_array::ElasticArray1024; /// The RLP encoded empty data (used to mean "null value"). pub const NULL_RLP: [u8; 1] = [0x80; 1]; /// The RLP encoded empty list. pub const EMPTY_LIST_RLP: [u8; 1] = [0xC0; 1]; -/// The SHA3 of the RLP encoding of empty data. -pub const SHA3_NULL_RLP: H256 = H256( [0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e, 0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x01, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21] ); -/// The SHA3 of the RLP encoding of empty list. -pub const SHA3_EMPTY_LIST_RLP: H256 = H256( [0x1d, 0xcc, 0x4d, 0xe8, 0xde, 0xc7, 0x5d, 0x7a, 0xab, 0x85, 0xb5, 0x67, 0xb6, 0xcc, 0xd4, 0x1a, 0xd3, 0x12, 0x45, 0x1b, 0x94, 0x8a, 0x74, 0x13, 0xf0, 0xa1, 0x42, 0xfd, 0x40, 0xd4, 0x93, 0x47] ); /// Shortcut function to decode trusted rlp /// /// ```rust -/// extern crate ethcore_util as util; -/// use util::rlp::*; +/// extern crate rlp; /// /// fn main () { /// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']; -/// let animals: Vec = decode(&data); +/// let animals: Vec = rlp::decode(&data); /// assert_eq!(animals, vec!["cat".to_string(), "dog".to_string()]); /// } /// ``` @@ -96,12 +98,11 @@ pub fn decode(bytes: &[u8]) -> T where T: RlpDecodable { /// Shortcut function to encode structure into rlp. /// /// ```rust -/// extern crate ethcore_util as util; -/// use util::rlp::*; +/// extern crate rlp; /// /// fn main () { /// let animal = "cat"; -/// let out = encode(&animal).to_vec(); +/// let out = rlp::encode(&animal).to_vec(); /// assert_eq!(out, vec![0x83, b'c', b'a', b't']); /// } /// ``` diff --git a/util/src/rlp/rlpcompression.rs b/util/rlp/src/rlpcompression.rs similarity index 91% rename from util/src/rlp/rlpcompression.rs rename to util/rlp/src/rlpcompression.rs index 64f2aac39f5..3113d8b8378 100644 --- a/util/src/rlp/rlpcompression.rs +++ b/util/rlp/src/rlpcompression.rs @@ -14,9 +14,11 @@ // You should have received a copy of the GNU General Public License // along with Parity. If not, see . -use rlp::{UntrustedRlp, View, Compressible, encode, ElasticArray1024, Stream, RlpStream}; -use rlp::commonrlps::{BLOCKS_RLP_SWAPPER, SNAPSHOT_RLP_SWAPPER}; +use ::{UntrustedRlp, View, Compressible, encode, Stream, RlpStream}; +use commonrlps::{BLOCKS_RLP_SWAPPER, SNAPSHOT_RLP_SWAPPER}; + use std::collections::HashMap; +use elastic_array::ElasticArray1024; /// Stores RLPs used for compression pub struct InvalidRlpSwapper<'a> { @@ -169,8 +171,8 @@ impl<'a> Compressible for UntrustedRlp<'a> { #[cfg(test)] mod tests { - use rlp::{UntrustedRlp, Compressible, View, RlpType}; - use rlp::rlpcompression::InvalidRlpSwapper; + use ::{UntrustedRlp, Compressible, View, RlpType}; + use rlpcompression::InvalidRlpSwapper; #[test] fn invalid_rlp_swapper() { @@ -222,24 +224,4 @@ mod tests { let malformed_rlp = UntrustedRlp::new(&malformed); assert_eq!(malformed_rlp.decompress(RlpType::Blocks).to_vec(), malformed); } - - #[test] - #[ignore] - fn test_compression() { - use kvdb::*; - let path = "db to test".to_string(); - let values: Vec<_> = Database::open_default(&path).unwrap().iter(Some(2)).map(|(_, v)| v).collect(); - let mut decomp_size = 0; - let mut comp_size = 0; - - for v in &values { - let rlp = UntrustedRlp::new(v); - let compressed = rlp.compress(RlpType::Blocks).to_vec(); - comp_size += compressed.len(); - let decompressed = rlp.decompress(RlpType::Blocks).to_vec(); - decomp_size += decompressed.len(); - } - println!("Decompressed bytes {:?}, compressed bytes: {:?}", decomp_size, comp_size); - assert!(decomp_size > comp_size); - } } diff --git a/util/src/rlp/rlperrors.rs b/util/rlp/src/rlperrors.rs similarity index 98% rename from util/src/rlp/rlperrors.rs rename to util/rlp/src/rlperrors.rs index 93a82187ee2..dc60afc9a8d 100644 --- a/util/src/rlp/rlperrors.rs +++ b/util/rlp/src/rlperrors.rs @@ -16,7 +16,7 @@ use std::fmt; use std::error::Error as StdError; -use rlp::bytes::FromBytesError; +use bytes::FromBytesError; #[derive(Debug, PartialEq, Eq)] /// Error concerning the RLP decoder. diff --git a/util/src/rlp/rlpin.rs b/util/rlp/src/rlpin.rs similarity index 91% rename from util/src/rlp/rlpin.rs rename to util/rlp/src/rlpin.rs index fb8395c0c17..a096cdbe855 100644 --- a/util/src/rlp/rlpin.rs +++ b/util/rlp/src/rlpin.rs @@ -16,7 +16,7 @@ use std::fmt; use rustc_serialize::hex::ToHex; -use rlp::{View, DecoderError, UntrustedRlp, PayloadInfo, Prototype, RlpDecodable}; +use ::{View, DecoderError, UntrustedRlp, PayloadInfo, Prototype, RlpDecodable}; impl<'a> From> for Rlp<'a> { fn from(rlp: UntrustedRlp<'a>) -> Rlp<'a> { @@ -162,8 +162,10 @@ impl<'a, 'view> Iterator for RlpIterator<'a, 'view> { #[test] fn break_it() { - use common::*; - let h: Bytes = FromHex::from_hex("f84d0589010efbef67941f79b2a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a0c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").unwrap(); + use rustc_serialize::hex::FromHex; + use bigint::uint::U256; + + let h: Vec = FromHex::from_hex("f84d0589010efbef67941f79b2a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a0c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").unwrap(); let r: Rlp = Rlp::new(&h); let u: U256 = r.val_at(1); assert_eq!(format!("{}", u), "19526463837540678066"); diff --git a/util/src/rlp/rlpstream.rs b/util/rlp/src/rlpstream.rs similarity index 98% rename from util/src/rlp/rlpstream.rs rename to util/rlp/src/rlpstream.rs index eb70a7c1332..ec85e8ee500 100644 --- a/util/src/rlp/rlpstream.rs +++ b/util/rlp/src/rlpstream.rs @@ -15,9 +15,10 @@ // along with Parity. If not, see . use elastic_array::*; -use rlp::bytes::{ToBytes, VecLike}; -use rlp::{Stream, Encoder, Encodable}; -use rlp::rlptraits::{ByteEncodable, RlpEncodable}; + +use ::{Stream, Encoder, Encodable}; +use bytes::{ToBytes, VecLike}; +use rlptraits::{ByteEncodable, RlpEncodable}; #[derive(Debug, Copy, Clone)] struct ListInfo { diff --git a/util/src/rlp/rlptraits.rs b/util/rlp/src/rlptraits.rs similarity index 88% rename from util/src/rlp/rlptraits.rs rename to util/rlp/src/rlptraits.rs index 5eca7ca039f..0f3fb35d77e 100644 --- a/util/src/rlp/rlptraits.rs +++ b/util/rlp/src/rlptraits.rs @@ -15,12 +15,11 @@ // along with Parity. If not, see . //! Common RLP traits -use rlp::bytes::VecLike; -use rlp::{DecoderError, UntrustedRlp}; -use rlp::rlpstream::RlpStream; +use ::{DecoderError, UntrustedRlp}; +use bytes::VecLike; +use rlpstream::RlpStream; + use elastic_array::ElasticArray1024; -use hash::H256; -use sha3::*; /// Type is able to decode RLP. pub trait Decoder: Sized { @@ -65,8 +64,8 @@ pub trait View<'a, 'view>: Sized { /// The raw data of the RLP as slice. /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']; @@ -89,8 +88,8 @@ pub trait View<'a, 'view>: Sized { /// Returns number of RLP items. /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']; @@ -105,8 +104,8 @@ pub trait View<'a, 'view>: Sized { /// Returns the number of bytes in the data, or zero if it isn't data. /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']; @@ -124,8 +123,8 @@ pub trait View<'a, 'view>: Sized { /// slices is faster. /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']; @@ -138,8 +137,8 @@ pub trait View<'a, 'view>: Sized { /// No value /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let data = vec![]; @@ -152,8 +151,8 @@ pub trait View<'a, 'view>: Sized { /// Contains a zero-length string or zero-length list. /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let data = vec![0xc0]; @@ -166,8 +165,8 @@ pub trait View<'a, 'view>: Sized { /// List value /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']; @@ -180,8 +179,8 @@ pub trait View<'a, 'view>: Sized { /// String value /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']; @@ -194,8 +193,8 @@ pub trait View<'a, 'view>: Sized { /// Int value /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let data = vec![0xc1, 0x10]; @@ -209,8 +208,8 @@ pub trait View<'a, 'view>: Sized { /// Get iterator over rlp-slices /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let data = vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']; @@ -254,9 +253,6 @@ pub trait Encodable { self.rlp_append(&mut s); s.drain() } - - /// Get the hash or RLP encoded representation - fn rlp_sha3(&self) -> H256 { (&*self.rlp_bytes()).sha3() } } /// Encodable wrapper trait required to handle special case of encoding a &[u8] as string and not as list @@ -277,8 +273,8 @@ pub trait Stream: Sized { /// Apends value to the end of stream, chainable. /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let mut stream = RlpStream::new_list(2); @@ -292,8 +288,8 @@ pub trait Stream: Sized { /// Declare appending the list of given size, chainable. /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let mut stream = RlpStream::new_list(2); @@ -308,8 +304,8 @@ pub trait Stream: Sized { /// Apends null to the end of stream, chainable. /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let mut stream = RlpStream::new_list(2); @@ -326,8 +322,8 @@ pub trait Stream: Sized { /// Clear the output stream so far. /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let mut stream = RlpStream::new_list(3); @@ -342,8 +338,8 @@ pub trait Stream: Sized { /// Returns true if stream doesnt expect any more items. /// /// ```rust - /// extern crate ethcore_util as util; - /// use util::rlp::*; + /// extern crate rlp; + /// use rlp::*; /// /// fn main () { /// let mut stream = RlpStream::new_list(2); diff --git a/util/src/rlp/tests.rs b/util/rlp/src/tests.rs similarity index 92% rename from util/src/rlp/tests.rs rename to util/rlp/src/tests.rs index 5cb8094c6f3..1d98e4972c7 100644 --- a/util/src/rlp/tests.rs +++ b/util/rlp/src/tests.rs @@ -16,8 +16,7 @@ use std::{fmt, cmp}; use std::str::FromStr; -use rlp; -use rlp::{UntrustedRlp, RlpStream, View, Stream, DecoderError}; +use ::{Encodable, RlpDecodable, UntrustedRlp, RlpStream, View, Stream, DecoderError}; use bigint::uint::U256; #[test] @@ -26,26 +25,22 @@ fn rlp_at() { { let rlp = UntrustedRlp::new(&data); assert!(rlp.is_list()); - //let animals = as rlp::RlpDecodable>::decode_untrusted(&rlp).unwrap(); let animals: Vec = rlp.as_val().unwrap(); assert_eq!(animals, vec!["cat".to_owned(), "dog".to_owned()]); let cat = rlp.at(0).unwrap(); assert!(cat.is_data()); assert_eq!(cat.as_raw(), &[0x83, b'c', b'a', b't']); - //assert_eq!(String::decode_untrusted(&cat).unwrap(), "cat".to_owned()); assert_eq!(cat.as_val::().unwrap(), "cat".to_owned()); let dog = rlp.at(1).unwrap(); assert!(dog.is_data()); assert_eq!(dog.as_raw(), &[0x83, b'd', b'o', b'g']); - //assert_eq!(String::decode_untrusted(&dog).unwrap(), "dog".to_owned()); assert_eq!(dog.as_val::().unwrap(), "dog".to_owned()); let cat_again = rlp.at(0).unwrap(); assert!(cat_again.is_data()); assert_eq!(cat_again.as_raw(), &[0x83, b'c', b'a', b't']); - //assert_eq!(String::decode_untrusted(&cat_again).unwrap(), "cat".to_owned()); assert_eq!(cat_again.as_val::().unwrap(), "cat".to_owned()); } } @@ -58,10 +53,10 @@ fn rlp_at_err() { assert!(rlp.is_list()); let cat_err = rlp.at(0).unwrap_err(); - assert_eq!(cat_err, rlp::DecoderError::RlpIsTooShort); + assert_eq!(cat_err, DecoderError::RlpIsTooShort); let dog_err = rlp.at(1).unwrap_err(); - assert_eq!(dog_err, rlp::DecoderError::RlpIsTooShort); + assert_eq!(dog_err, DecoderError::RlpIsTooShort); } } @@ -89,13 +84,13 @@ fn rlp_iter() { } } -struct ETestPair(T, Vec) where T: rlp::Encodable; +struct ETestPair(T, Vec) where T: Encodable; fn run_encode_tests(tests: Vec>) - where T: rlp::Encodable + where T: Encodable { for t in &tests { - let res = rlp::encode(&t.0); + let res = super::encode(&t.0); assert_eq!(&res[..], &t.1[..]); } } @@ -165,7 +160,7 @@ fn encode_str() { #[test] fn encode_address() { - use hash::*; + use bigint::hash::H160; let tests = vec![ ETestPair(H160::from("ef2d6d194084c2de36e0dabfce45d046b37d1106"), @@ -206,11 +201,11 @@ fn encode_vector_str() { run_encode_tests(tests); } -struct DTestPair(T, Vec) where T: rlp::RlpDecodable + fmt::Debug + cmp::Eq; +struct DTestPair(T, Vec) where T: RlpDecodable + fmt::Debug + cmp::Eq; -fn run_decode_tests(tests: Vec>) where T: rlp::RlpDecodable + fmt::Debug + cmp::Eq { +fn run_decode_tests(tests: Vec>) where T: RlpDecodable + fmt::Debug + cmp::Eq { for t in &tests { - let res: T = rlp::decode(&t.1); + let res: T = super::decode(&t.1); assert_eq!(res, t.0); } } @@ -301,7 +296,7 @@ fn decode_untrusted_str() { #[test] fn decode_untrusted_address() { - use hash::*; + use bigint::hash::H160; let tests = vec![ DTestPair(H160::from("ef2d6d194084c2de36e0dabfce45d046b37d1106"), @@ -340,8 +335,8 @@ fn decode_untrusted_vector_of_vectors_str() { #[test] fn test_decoding_array() { let v = vec![5u16, 2u16]; - let res = rlp::encode(&v); - let arr: [u16; 2] = rlp::decode(&res); + let res = super::encode(&v); + let arr: [u16; 2] = super::decode(&res); assert_eq!(arr[0], 5); assert_eq!(arr[1], 2); } diff --git a/util/src/rlp/untrusted_rlp.rs b/util/rlp/src/untrusted_rlp.rs similarity index 98% rename from util/src/rlp/untrusted_rlp.rs rename to util/rlp/src/untrusted_rlp.rs index fdf5842111d..8f954e3e677 100644 --- a/util/src/rlp/untrusted_rlp.rs +++ b/util/rlp/src/untrusted_rlp.rs @@ -17,8 +17,9 @@ use std::cell::Cell; use std::fmt; use rustc_serialize::hex::ToHex; -use rlp::bytes::{FromBytes, FromBytesResult, FromBytesError}; -use rlp::{View, Decoder, Decodable, DecoderError, RlpDecodable}; + +use bytes::{FromBytes, FromBytesResult, FromBytesError}; +use ::{View, Decoder, Decodable, DecoderError, RlpDecodable}; /// rlp offset #[derive(Copy, Clone, Debug)] @@ -490,7 +491,7 @@ impl RlpDecodable for u8 { #[cfg(test)] mod tests { - use rlp::{UntrustedRlp, View}; + use ::{UntrustedRlp, View}; #[test] fn test_rlp_display() { use rustc_serialize::hex::FromHex; diff --git a/util/src/lib.rs b/util/src/lib.rs index f7459615edf..57ea9c152ca 100644 --- a/util/src/lib.rs +++ b/util/src/lib.rs @@ -90,29 +90,32 @@ extern crate rustc_serialize; extern crate rand; extern crate rocksdb; -#[macro_use] -extern crate heapsize; -#[macro_use] -extern crate lazy_static; -#[macro_use] -extern crate itertools; extern crate env_logger; extern crate crypto as rcrypto; extern crate secp256k1; extern crate arrayvec; extern crate elastic_array; -#[macro_use] -extern crate log as rlog; extern crate time; extern crate ethcore_devtools as devtools; extern crate libc; extern crate target_info; extern crate bigint; extern crate parking_lot; -pub extern crate using_queue; -pub extern crate table; extern crate ansi_term; extern crate tiny_keccak; +extern crate rlp; + +#[macro_use] +extern crate heapsize; +#[macro_use] +extern crate lazy_static; +#[macro_use] +extern crate itertools; +#[macro_use] +extern crate log as rlog; + +pub extern crate using_queue; +pub extern crate table; pub mod bloom; pub mod standard; @@ -122,7 +125,6 @@ pub mod from_json; pub mod common; pub mod error; pub mod bytes; -pub mod rlp; pub mod misc; pub mod vector; pub mod sha3; @@ -144,7 +146,6 @@ mod timer; pub use common::*; pub use misc::*; -pub use rlp::*; pub use hashdb::*; pub use memorydb::*; pub use overlaydb::*; diff --git a/util/src/sha3.rs b/util/src/sha3.rs index 7cb730223a4..ecfd6849bd7 100644 --- a/util/src/sha3.rs +++ b/util/src/sha3.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Parity. If not, see . -//! Wrapper around tiny-keccak crate. +//! Wrapper around tiny-keccak crate as well as common hash constants. extern crate sha3 as sha3_ext; use std::io; @@ -25,6 +25,12 @@ use self::sha3_ext::*; /// Get the SHA3 (i.e. Keccak) hash of the empty bytes string. pub const SHA3_EMPTY: H256 = H256( [0xc5, 0xd2, 0x46, 0x01, 0x86, 0xf7, 0x23, 0x3c, 0x92, 0x7e, 0x7d, 0xb2, 0xdc, 0xc7, 0x03, 0xc0, 0xe5, 0x00, 0xb6, 0x53, 0xca, 0x82, 0x27, 0x3b, 0x7b, 0xfa, 0xd8, 0x04, 0x5d, 0x85, 0xa4, 0x70] ); +/// The SHA3 of the RLP encoding of empty data. +pub const SHA3_NULL_RLP: H256 = H256( [0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e, 0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x01, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21] ); + +/// The SHA3 of the RLP encoding of empty list. +pub const SHA3_EMPTY_LIST_RLP: H256 = H256( [0x1d, 0xcc, 0x4d, 0xe8, 0xde, 0xc7, 0x5d, 0x7a, 0xab, 0x85, 0xb5, 0x67, 0xb6, 0xcc, 0xd4, 0x1a, 0xd3, 0x12, 0x45, 0x1b, 0x94, 0x8a, 0x74, 0x13, 0xf0, 0xa1, 0x42, 0xfd, 0x40, 0xd4, 0x93, 0x47] ); + /// Types implementing this trait are sha3able. /// /// ``` diff --git a/util/src/trie/mod.rs b/util/src/trie/mod.rs index 886ccd72496..b71f6a5e2d9 100644 --- a/util/src/trie/mod.rs +++ b/util/src/trie/mod.rs @@ -84,7 +84,7 @@ pub trait Trie { fn root(&self) -> &H256; /// Is the trie empty? - fn is_empty(&self) -> bool { *self.root() == ::rlp::SHA3_NULL_RLP } + fn is_empty(&self) -> bool { *self.root() == ::sha3::SHA3_NULL_RLP } /// Does the trie contain a given key? fn contains(&self, key: &[u8]) -> Result { diff --git a/util/src/trie/triedb.rs b/util/src/trie/triedb.rs index 8e6cb98faae..88a3399e79e 100644 --- a/util/src/trie/triedb.rs +++ b/util/src/trie/triedb.rs @@ -32,11 +32,11 @@ use super::{Trie, TrieItem, TrieError}; /// # Example /// ``` /// extern crate ethcore_util as util; +/// /// use util::trie::*; /// use util::hashdb::*; /// use util::memorydb::*; /// use util::hash::*; -/// use util::rlp::*; /// /// fn main() { /// let mut memdb = MemoryDB::new(); diff --git a/util/src/trie/triedbmut.rs b/util/src/trie/triedbmut.rs index 8d3d7d3d3d3..5e2ef6b793c 100644 --- a/util/src/trie/triedbmut.rs +++ b/util/src/trie/triedbmut.rs @@ -19,10 +19,11 @@ use super::{TrieError, TrieMut}; use super::node::Node as RlpNode; -use ::{Bytes, HashDB, H256, SHA3_NULL_RLP}; +use ::{Bytes, HashDB, H256}; use ::bytes::ToPretty; use ::nibbleslice::NibbleSlice; use ::rlp::{Rlp, RlpStream, View, Stream}; +use ::sha3::SHA3_NULL_RLP; use elastic_array::ElasticArray1024; @@ -261,18 +262,18 @@ impl<'a> Index<&'a StorageHandle> for NodeStorage { /// # Example /// ``` /// extern crate ethcore_util as util; +/// /// use util::trie::*; /// use util::hashdb::*; /// use util::memorydb::*; /// use util::hash::*; -/// use util::rlp::*; /// /// fn main() { /// let mut memdb = MemoryDB::new(); /// let mut root = H256::new(); /// let mut t = TrieDBMut::new(&mut memdb, &mut root); /// assert!(t.is_empty()); -/// assert_eq!(*t.root(), SHA3_NULL_RLP); +/// assert_eq!(*t.root(), ::util::sha3::SHA3_NULL_RLP); /// t.insert(b"foo", b"bar").unwrap(); /// assert!(t.contains(b"foo").unwrap()); /// assert_eq!(t.get(b"foo").unwrap().unwrap(), b"bar"); @@ -951,8 +952,8 @@ mod tests { use hashdb::*; use memorydb::*; use super::*; - use rlp::*; use bytes::ToPretty; + use sha3::SHA3_NULL_RLP; use super::super::TrieMut; use super::super::standardmap::*;