Merge branch 'master' into new-jsonrpc
This commit is contained in:
Tomasz Drwięga
commit
958a8f66a0
13
Cargo.lock
generated
13
Cargo.lock
generated
@ -423,7 +423,7 @@ dependencies = [
|
||||
"semver 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"stats 0.1.0",
|
||||
"time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"transient-hashmap 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@ -647,7 +647,7 @@ dependencies = [
|
||||
"serde_json 0.9.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"stats 0.1.0",
|
||||
"time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"transient-hashmap 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@ -1416,7 +1416,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "nanomsg"
|
||||
version = "0.5.1"
|
||||
source = "git+https://github.com/ethcore/nanomsg.rs.git?branch=parity-1.7#26ec71ecbdb284d7a5d596bdb3d0fde02c55d0bc"
|
||||
source = "git+https://github.com/ethcore/nanomsg.rs.git?branch=parity-1.7#673b79beef6e149273899850d7692335a481a920"
|
||||
dependencies = [
|
||||
"libc 0.2.21 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"nanomsg-sys 0.5.0 (git+https://github.com/ethcore/nanomsg.rs.git?branch=parity-1.7)",
|
||||
@ -1425,7 +1425,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "nanomsg-sys"
|
||||
version = "0.5.0"
|
||||
source = "git+https://github.com/ethcore/nanomsg.rs.git?branch=parity-1.7#26ec71ecbdb284d7a5d596bdb3d0fde02c55d0bc"
|
||||
source = "git+https://github.com/ethcore/nanomsg.rs.git?branch=parity-1.7#673b79beef6e149273899850d7692335a481a920"
|
||||
dependencies = [
|
||||
"gcc 0.3.43 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"libc 0.2.21 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -1966,6 +1966,7 @@ dependencies = [
|
||||
name = "rlp"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"elastic-array 0.6.0 (git+https://github.com/ethcore/elastic-array)",
|
||||
"ethcore-bigint 0.1.2",
|
||||
"lazy_static 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -2500,7 +2501,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
|
||||
[[package]]
|
||||
name = "transient-hashmap"
|
||||
version = "0.1.0"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -2874,7 +2875,7 @@ dependencies = [
|
||||
"checksum toml 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a442dfc13508e603c3f763274361db7f79d7469a0e95c411cde53662ab30fc72"
|
||||
"checksum traitobject 0.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "07eaeb7689bb7fca7ce15628319635758eda769fed481ecfe6686ddef2600616"
|
||||
"checksum traitobject 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "efd1f82c56340fdf16f2a953d7bda4f8fdffba13d93b00844c25572110b26079"
|
||||
"checksum transient-hashmap 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "15f7cc7116182edca1ed08f6f8c4da92104555ca77addbabea4eaa59b20373d0"
|
||||
"checksum transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "715254c8f0811be1a79ad3ea5e6fa3c8eddec2b03d7f5ba78cf093e56d79c24f"
|
||||
"checksum typeable 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1410f6f91f21d1612654e7cc69193b0334f909dcf2c790c4826254fbb86f8887"
|
||||
"checksum unicase 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "13a5906ca2b98c799f4b1ab4557b76367ebd6ae5ef14930ec841c74aed5f3764"
|
||||
"checksum unicode-bidi 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c1f7ceb96afdfeedee42bade65a0d585a6a0106f681b6749c8ff4daa8df30b3f"
|
||||
|
||||
@ -24,7 +24,7 @@ bit-set = "0.4"
|
||||
time = "0.1"
|
||||
rand = "0.3"
|
||||
byteorder = "1.0"
|
||||
transient-hashmap = "0.1"
|
||||
transient-hashmap = "0.4"
|
||||
linked-hash-map = "0.3.0"
|
||||
lru-cache = "0.1.0"
|
||||
ethabi = "1.0.0"
|
||||
|
||||
@ -23,7 +23,7 @@
|
||||
use ethcore::ids::BlockId;
|
||||
use util::{Bytes, H256, U256, HashDB, MemoryDB};
|
||||
use util::trie::{self, TrieMut, TrieDBMut, Trie, TrieDB, Recorder};
|
||||
use rlp::{Stream, RlpStream, UntrustedRlp, View};
|
||||
use rlp::{RlpStream, UntrustedRlp, View};
|
||||
|
||||
// encode a key.
|
||||
macro_rules! key {
|
||||
|
||||
@ -24,7 +24,7 @@ use ethcore::receipt::Receipt;
|
||||
|
||||
use io::TimerToken;
|
||||
use network::{NetworkProtocolHandler, NetworkContext, PeerId};
|
||||
use rlp::{RlpStream, Stream, UntrustedRlp, View};
|
||||
use rlp::{RlpStream, UntrustedRlp, View};
|
||||
use util::hash::H256;
|
||||
use util::{Bytes, DBValue, Mutex, RwLock, U256};
|
||||
use time::{Duration, SteadyTime};
|
||||
|
||||
@ -105,7 +105,7 @@ impl Default for CostTable {
|
||||
}
|
||||
}
|
||||
|
||||
impl RlpEncodable for CostTable {
|
||||
impl Encodable for CostTable {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
fn append_cost(s: &mut RlpStream, msg_id: u8, cost: &Cost) {
|
||||
s.begin_list(3)
|
||||
|
||||
@ -16,7 +16,7 @@
|
||||
|
||||
//! Peer status and capabilities.
|
||||
|
||||
use rlp::{DecoderError, RlpDecodable, RlpEncodable, RlpStream, Stream, UntrustedRlp, View};
|
||||
use rlp::{DecoderError, RlpDecodable, Encodable, RlpStream, UntrustedRlp, View};
|
||||
use util::{H256, U256};
|
||||
|
||||
use super::request_credits::FlowParams;
|
||||
@ -126,7 +126,7 @@ impl<'a> Parser<'a> {
|
||||
}
|
||||
|
||||
// Helper for encoding a key-value pair
|
||||
fn encode_pair<T: RlpEncodable>(key: Key, val: &T) -> Vec<u8> {
|
||||
fn encode_pair<T: Encodable>(key: Key, val: &T) -> Vec<u8> {
|
||||
let mut s = RlpStream::new_list(2);
|
||||
s.append(&key.as_str()).append(val);
|
||||
s.out()
|
||||
@ -374,7 +374,7 @@ mod tests {
|
||||
use super::*;
|
||||
use super::super::request_credits::FlowParams;
|
||||
use util::{U256, H256};
|
||||
use rlp::{RlpStream, Stream ,UntrustedRlp, View};
|
||||
use rlp::{RlpStream, UntrustedRlp, View};
|
||||
|
||||
#[test]
|
||||
fn full_handshake() {
|
||||
|
||||
@ -33,7 +33,7 @@ use ethcore::executed::{Executed, ExecutionError};
|
||||
use futures::{Async, Poll, Future};
|
||||
use futures::sync::oneshot::{self, Sender, Receiver};
|
||||
use network::PeerId;
|
||||
use rlp::{RlpStream, Stream};
|
||||
use rlp::RlpStream;
|
||||
use util::{Bytes, DBValue, RwLock, Mutex, U256};
|
||||
use util::sha3::{SHA3_NULL_RLP, SHA3_EMPTY_LIST_RLP};
|
||||
|
||||
|
||||
@ -26,7 +26,7 @@ use ethcore::receipt::Receipt;
|
||||
use ethcore::state::{self, ProvedExecution};
|
||||
use ethcore::transaction::SignedTransaction;
|
||||
|
||||
use rlp::{RlpStream, Stream, UntrustedRlp, View};
|
||||
use rlp::{RlpStream, UntrustedRlp, View};
|
||||
use util::{Address, Bytes, DBValue, HashDB, H256, U256};
|
||||
use util::memorydb::MemoryDB;
|
||||
use util::sha3::Hashable;
|
||||
@ -323,7 +323,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn check_body() {
|
||||
use rlp::{RlpStream, Stream};
|
||||
use rlp::RlpStream;
|
||||
|
||||
let header = Header::new();
|
||||
let mut body_stream = RlpStream::new_list(2);
|
||||
@ -360,7 +360,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn check_state_proof() {
|
||||
use rlp::{RlpStream, Stream};
|
||||
use rlp::RlpStream;
|
||||
|
||||
let mut root = H256::default();
|
||||
let mut db = MemoryDB::new();
|
||||
|
||||
@ -128,7 +128,7 @@ pub trait Provider: Send + Sync {
|
||||
///
|
||||
/// Returns a vector of RLP-encoded lists satisfying the requests.
|
||||
fn proofs(&self, req: request::StateProofs) -> Vec<Bytes> {
|
||||
use rlp::{RlpStream, Stream};
|
||||
use rlp::RlpStream;
|
||||
|
||||
let mut results = Vec::with_capacity(req.requests.len());
|
||||
|
||||
@ -166,7 +166,7 @@ pub trait Provider: Send + Sync {
|
||||
/// The first element is a block header and the second a merkle proof of
|
||||
/// the header in a requested CHT.
|
||||
fn header_proofs(&self, req: request::HeaderProofs) -> Vec<Bytes> {
|
||||
use rlp::{self, RlpStream, Stream};
|
||||
use rlp::{self, RlpStream};
|
||||
|
||||
req.requests.into_iter()
|
||||
.map(|req| self.header_proof(req))
|
||||
|
||||
@ -20,7 +20,7 @@ use std::cmp;
|
||||
use std::sync::Arc;
|
||||
use std::collections::HashSet;
|
||||
|
||||
use rlp::{UntrustedRlp, RlpStream, Encodable, Decodable, Decoder, DecoderError, View, Stream};
|
||||
use rlp::{UntrustedRlp, RlpStream, Encodable, Decodable, Decoder, DecoderError, View};
|
||||
use util::{Bytes, Address, Uint, Hashable, U256, H256, ordered_trie_root, SHA3_NULL_RLP};
|
||||
use util::error::{Mismatch, OutOfBounds};
|
||||
|
||||
@ -59,8 +59,8 @@ impl Block {
|
||||
pub fn rlp_bytes(&self, seal: Seal) -> Bytes {
|
||||
let mut block_rlp = RlpStream::new_list(3);
|
||||
self.header.stream_rlp(&mut block_rlp, seal);
|
||||
block_rlp.append(&self.transactions);
|
||||
block_rlp.append(&self.uncles);
|
||||
block_rlp.append_list(&self.transactions);
|
||||
block_rlp.append_list(&self.uncles);
|
||||
block_rlp.out()
|
||||
}
|
||||
}
|
||||
@ -507,7 +507,7 @@ impl SealedBlock {
|
||||
pub fn rlp_bytes(&self) -> Bytes {
|
||||
let mut block_rlp = RlpStream::new_list(3);
|
||||
self.block.header.stream_rlp(&mut block_rlp, Seal::With);
|
||||
block_rlp.append(&self.block.transactions);
|
||||
block_rlp.append_list(&self.block.transactions);
|
||||
block_rlp.append_raw(&self.uncle_bytes, 1);
|
||||
block_rlp.out()
|
||||
}
|
||||
|
||||
@ -172,7 +172,7 @@ impl Encodable for BlockDetails {
|
||||
s.append(&self.number);
|
||||
s.append(&self.total_difficulty);
|
||||
s.append(&self.parent);
|
||||
s.append(&self.children);
|
||||
s.append_list(&self.children);
|
||||
}
|
||||
}
|
||||
|
||||
@ -233,7 +233,7 @@ impl Decodable for BlockReceipts {
|
||||
|
||||
impl Encodable for BlockReceipts {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
Encodable::rlp_append(&self.receipts, s);
|
||||
s.append_list(&self.receipts);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -37,8 +37,8 @@ impl Encodable for Block {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.begin_list(3);
|
||||
s.append(&self.header);
|
||||
s.append(&self.transactions);
|
||||
s.append(&self.uncles);
|
||||
s.append_list(&self.transactions);
|
||||
s.append_list(&self.uncles);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -63,7 +63,7 @@ impl Decodable for BloomGroup {
|
||||
|
||||
impl Encodable for BloomGroup {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
Encodable::rlp_append(&self.blooms, s)
|
||||
s.append_list(&self.blooms);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -20,7 +20,7 @@ use util::*;
|
||||
use super::{Height, View, BlockHash, Step};
|
||||
use error::Error;
|
||||
use header::Header;
|
||||
use rlp::{Rlp, UntrustedRlp, RlpStream, Stream, RlpEncodable, Encodable, Decodable, Decoder, DecoderError, View as RlpView};
|
||||
use rlp::{Rlp, UntrustedRlp, RlpStream, Encodable, Decodable, Decoder, DecoderError, View as RlpView};
|
||||
use ethkey::{recover, public_to_address};
|
||||
use super::super::vote_collector::Message;
|
||||
|
||||
@ -162,7 +162,7 @@ impl Decodable for Step {
|
||||
|
||||
impl Encodable for Step {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
RlpEncodable::rlp_append(&self.number(), s);
|
||||
s.append_internal(&self.number());
|
||||
}
|
||||
}
|
||||
|
||||
@ -278,6 +278,7 @@ mod tests {
|
||||
::rlp::encode(&H520::default()).to_vec(),
|
||||
Vec::new()
|
||||
];
|
||||
|
||||
header.set_seal(seal);
|
||||
let message = ConsensusMessage::new_proposal(&header).unwrap();
|
||||
assert_eq!(
|
||||
|
||||
@ -243,7 +243,7 @@ impl Tendermint {
|
||||
let seal = vec![
|
||||
::rlp::encode(&view).to_vec(),
|
||||
::rlp::encode(&seal.proposal).to_vec(),
|
||||
::rlp::encode(&seal.votes).to_vec()
|
||||
::rlp::encode_list(&seal.votes).to_vec()
|
||||
];
|
||||
self.submit_seal(block_hash, seal);
|
||||
self.to_next_height(height);
|
||||
@ -825,7 +825,7 @@ mod tests {
|
||||
let vote_info = message_info_rlp(&VoteStep::new(2, 0, Step::Precommit), Some(header.bare_hash()));
|
||||
let signature1 = tap.sign(proposer, None, vote_info.sha3()).unwrap();
|
||||
|
||||
seal[2] = ::rlp::encode(&vec![H520::from(signature1.clone())]).to_vec();
|
||||
seal[2] = ::rlp::encode_list(&vec![H520::from(signature1.clone())]).to_vec();
|
||||
header.set_seal(seal.clone());
|
||||
|
||||
// One good signature is not enough.
|
||||
@ -837,7 +837,7 @@ mod tests {
|
||||
let voter = insert_and_unlock(&tap, "0");
|
||||
let signature0 = tap.sign(voter, None, vote_info.sha3()).unwrap();
|
||||
|
||||
seal[2] = ::rlp::encode(&vec![H520::from(signature1.clone()), H520::from(signature0.clone())]).to_vec();
|
||||
seal[2] = ::rlp::encode_list(&vec![H520::from(signature1.clone()), H520::from(signature0.clone())]).to_vec();
|
||||
header.set_seal(seal.clone());
|
||||
|
||||
assert!(engine.verify_block_family(&header, &parent_header, None).is_ok());
|
||||
@ -845,7 +845,7 @@ mod tests {
|
||||
let bad_voter = insert_and_unlock(&tap, "101");
|
||||
let bad_signature = tap.sign(bad_voter, None, vote_info.sha3()).unwrap();
|
||||
|
||||
seal[2] = ::rlp::encode(&vec![H520::from(signature1), H520::from(bad_signature)]).to_vec();
|
||||
seal[2] = ::rlp::encode_list(&vec![H520::from(signature1), H520::from(bad_signature)]).to_vec();
|
||||
header.set_seal(seal);
|
||||
|
||||
// One good and one bad signature.
|
||||
|
||||
@ -36,7 +36,7 @@ const STACK_SIZE_PER_DEPTH: usize = 24*1024;
|
||||
|
||||
/// Returns new address created from address and given nonce.
|
||||
pub fn contract_address(address: &Address, nonce: &U256) -> Address {
|
||||
use rlp::{RlpStream, Stream};
|
||||
use rlp::RlpStream;
|
||||
|
||||
let mut stream = RlpStream::new_list(2);
|
||||
stream.append(address);
|
||||
|
||||
@ -26,7 +26,7 @@ use util::migration::{Batch, Config, Error, Migration, SimpleMigration, Progress
|
||||
use util::sha3::Hashable;
|
||||
use std::sync::Arc;
|
||||
|
||||
use rlp::{decode, Rlp, RlpStream, Stream, View};
|
||||
use rlp::{decode, Rlp, RlpStream, View};
|
||||
|
||||
|
||||
// attempt to migrate a key, value pair. None if migration not possible.
|
||||
@ -199,7 +199,7 @@ impl OverlayRecentV7 {
|
||||
stream.begin_list(2).append(&k).append(&v);
|
||||
}
|
||||
|
||||
stream.append(&deleted_keys);
|
||||
stream.append_list(&deleted_keys);
|
||||
|
||||
// and insert it into the new database.
|
||||
batch.insert(entry_key, stream.out(), dest)?;
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
|
||||
//! This migration consolidates all databases into single one using Column Families.
|
||||
|
||||
use rlp::{Rlp, RlpStream, View, Stream};
|
||||
use rlp::{Rlp, RlpStream, View};
|
||||
use util::kvdb::Database;
|
||||
use util::migration::{Batch, Config, Error, Migration, Progress};
|
||||
use std::sync::Arc;
|
||||
|
||||
@ -19,7 +19,6 @@
|
||||
|
||||
use std::time::Duration;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
use std::cell::Cell;
|
||||
use transaction::{SignedTransaction, Action};
|
||||
use transient_hashmap::TransientHashMap;
|
||||
use miner::{TransactionQueue, TransactionQueueDetailsProvider, TransactionImportResult, TransactionOrigin};
|
||||
@ -47,15 +46,15 @@ impl Default for Threshold {
|
||||
pub struct BanningTransactionQueue {
|
||||
queue: TransactionQueue,
|
||||
ban_threshold: Threshold,
|
||||
senders_bans: TransientHashMap<Address, Cell<Count>>,
|
||||
recipients_bans: TransientHashMap<Address, Cell<Count>>,
|
||||
codes_bans: TransientHashMap<H256, Cell<Count>>,
|
||||
senders_bans: TransientHashMap<Address, Count>,
|
||||
recipients_bans: TransientHashMap<Address, Count>,
|
||||
codes_bans: TransientHashMap<H256, Count>,
|
||||
}
|
||||
|
||||
impl BanningTransactionQueue {
|
||||
/// Creates new banlisting transaction queue
|
||||
pub fn new(queue: TransactionQueue, ban_threshold: Threshold, ban_lifetime: Duration) -> Self {
|
||||
let ban_lifetime_sec = ban_lifetime.as_secs();
|
||||
let ban_lifetime_sec = ban_lifetime.as_secs() as u32;
|
||||
assert!(ban_lifetime_sec > 0, "Lifetime has to be specified in seconds.");
|
||||
BanningTransactionQueue {
|
||||
queue: queue,
|
||||
@ -87,7 +86,7 @@ impl BanningTransactionQueue {
|
||||
|
||||
// Check sender
|
||||
let sender = transaction.sender();
|
||||
let count = self.senders_bans.direct().get(&sender).map(|v| v.get()).unwrap_or(0);
|
||||
let count = self.senders_bans.direct().get(&sender).cloned().unwrap_or(0);
|
||||
if count > threshold {
|
||||
debug!(target: "txqueue", "Ignoring transaction {:?} because sender is banned.", transaction.hash());
|
||||
return Err(Error::Transaction(TransactionError::SenderBanned));
|
||||
@ -95,7 +94,7 @@ impl BanningTransactionQueue {
|
||||
|
||||
// Check recipient
|
||||
if let Action::Call(recipient) = transaction.action {
|
||||
let count = self.recipients_bans.direct().get(&recipient).map(|v| v.get()).unwrap_or(0);
|
||||
let count = self.recipients_bans.direct().get(&recipient).cloned().unwrap_or(0);
|
||||
if count > threshold {
|
||||
debug!(target: "txqueue", "Ignoring transaction {:?} because recipient is banned.", transaction.hash());
|
||||
return Err(Error::Transaction(TransactionError::RecipientBanned));
|
||||
@ -105,7 +104,7 @@ impl BanningTransactionQueue {
|
||||
// Check code
|
||||
if let Action::Create = transaction.action {
|
||||
let code_hash = transaction.data.sha3();
|
||||
let count = self.codes_bans.direct().get(&code_hash).map(|v| v.get()).unwrap_or(0);
|
||||
let count = self.codes_bans.direct().get(&code_hash).cloned().unwrap_or(0);
|
||||
if count > threshold {
|
||||
debug!(target: "txqueue", "Ignoring transaction {:?} because code is banned.", transaction.hash());
|
||||
return Err(Error::Transaction(TransactionError::CodeBanned));
|
||||
@ -147,9 +146,9 @@ impl BanningTransactionQueue {
|
||||
/// queue.
|
||||
fn ban_sender(&mut self, address: Address) -> bool {
|
||||
let count = {
|
||||
let mut count = self.senders_bans.entry(address).or_insert_with(|| Cell::new(0));
|
||||
*count.get_mut() = count.get().saturating_add(1);
|
||||
count.get()
|
||||
let mut count = self.senders_bans.entry(address).or_insert_with(|| 0);
|
||||
*count = count.saturating_add(1);
|
||||
*count
|
||||
};
|
||||
match self.ban_threshold {
|
||||
Threshold::BanAfter(threshold) if count > threshold => {
|
||||
@ -167,9 +166,9 @@ impl BanningTransactionQueue {
|
||||
/// Returns true if bans threshold has been reached.
|
||||
fn ban_recipient(&mut self, address: Address) -> bool {
|
||||
let count = {
|
||||
let mut count = self.recipients_bans.entry(address).or_insert_with(|| Cell::new(0));
|
||||
*count.get_mut() = count.get().saturating_add(1);
|
||||
count.get()
|
||||
let mut count = self.recipients_bans.entry(address).or_insert_with(|| 0);
|
||||
*count = count.saturating_add(1);
|
||||
*count
|
||||
};
|
||||
match self.ban_threshold {
|
||||
// TODO [ToDr] Consider removing other transactions to the same recipient from the queue?
|
||||
@ -183,12 +182,12 @@ impl BanningTransactionQueue {
|
||||
/// If bans threshold is reached all subsequent transactions to contracts with this codehash will be rejected.
|
||||
/// Returns true if bans threshold has been reached.
|
||||
fn ban_codehash(&mut self, code_hash: H256) -> bool {
|
||||
let mut count = self.codes_bans.entry(code_hash).or_insert_with(|| Cell::new(0));
|
||||
*count.get_mut() = count.get().saturating_add(1);
|
||||
let mut count = self.codes_bans.entry(code_hash).or_insert_with(|| 0);
|
||||
*count = count.saturating_add(1);
|
||||
|
||||
match self.ban_threshold {
|
||||
// TODO [ToDr] Consider removing other transactions with the same code from the queue?
|
||||
Threshold::BanAfter(threshold) if count.get() > threshold => true,
|
||||
Threshold::BanAfter(threshold) if *count > threshold => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
@ -212,7 +212,7 @@ struct SealingWork {
|
||||
/// Handles preparing work for "work sealing" or seals "internally" if Engine does not require work.
|
||||
pub struct Miner {
|
||||
// NOTE [ToDr] When locking always lock in this order!
|
||||
transaction_queue: Arc<Mutex<BanningTransactionQueue>>,
|
||||
transaction_queue: Arc<RwLock<BanningTransactionQueue>>,
|
||||
sealing_work: Mutex<SealingWork>,
|
||||
next_allowed_reseal: Mutex<Instant>,
|
||||
next_mandatory_reseal: RwLock<Instant>,
|
||||
@ -271,7 +271,7 @@ impl Miner {
|
||||
};
|
||||
|
||||
Miner {
|
||||
transaction_queue: Arc::new(Mutex::new(txq)),
|
||||
transaction_queue: Arc::new(RwLock::new(txq)),
|
||||
next_allowed_reseal: Mutex::new(Instant::now()),
|
||||
next_mandatory_reseal: RwLock::new(Instant::now() + options.reseal_max_period),
|
||||
sealing_block_last_request: Mutex::new(0),
|
||||
@ -304,9 +304,7 @@ impl Miner {
|
||||
}
|
||||
|
||||
fn forced_sealing(&self) -> bool {
|
||||
self.options.force_sealing
|
||||
|| !self.notifiers.read().is_empty()
|
||||
|| Instant::now() > *self.next_mandatory_reseal.read()
|
||||
self.options.force_sealing || !self.notifiers.read().is_empty()
|
||||
}
|
||||
|
||||
/// Clear all pending block states
|
||||
@ -330,7 +328,7 @@ impl Miner {
|
||||
let _timer = PerfTimer::new("prepare_block");
|
||||
let chain_info = chain.chain_info();
|
||||
let (transactions, mut open_block, original_work_hash) = {
|
||||
let transactions = {self.transaction_queue.lock().top_transactions_at(chain_info.best_block_number, chain_info.best_block_timestamp)};
|
||||
let transactions = {self.transaction_queue.read().top_transactions_at(chain_info.best_block_number, chain_info.best_block_timestamp)};
|
||||
let mut sealing_work = self.sealing_work.lock();
|
||||
let last_work_hash = sealing_work.queue.peek_last_ref().map(|pb| pb.block().fields().header.hash());
|
||||
let best_hash = chain_info.best_block_hash;
|
||||
@ -377,7 +375,7 @@ impl Miner {
|
||||
// Check for heavy transactions
|
||||
match self.options.tx_queue_banning {
|
||||
Banning::Enabled { ref offend_threshold, .. } if &took > offend_threshold => {
|
||||
match self.transaction_queue.lock().ban_transaction(&hash) {
|
||||
match self.transaction_queue.write().ban_transaction(&hash) {
|
||||
true => {
|
||||
warn!(target: "miner", "Detected heavy transaction. Banning the sender and recipient/code.");
|
||||
},
|
||||
@ -430,7 +428,7 @@ impl Miner {
|
||||
let fetch_nonce = |a: &Address| chain.latest_nonce(a);
|
||||
|
||||
{
|
||||
let mut queue = self.transaction_queue.lock();
|
||||
let mut queue = self.transaction_queue.write();
|
||||
for hash in invalid_transactions {
|
||||
queue.remove_invalid(&hash, &fetch_nonce);
|
||||
}
|
||||
@ -447,13 +445,13 @@ impl Miner {
|
||||
let txq = self.transaction_queue.clone();
|
||||
self.gas_pricer.lock().recalibrate(move |price| {
|
||||
debug!(target: "miner", "minimal_gas_price: Got gas price! {}", price);
|
||||
txq.lock().set_minimal_gas_price(price);
|
||||
txq.write().set_minimal_gas_price(price);
|
||||
});
|
||||
}
|
||||
|
||||
/// Check is reseal is allowed and necessary.
|
||||
fn requires_reseal(&self, best_block: BlockNumber) -> bool {
|
||||
let has_local_transactions = self.transaction_queue.lock().has_local_pending_transactions();
|
||||
let has_local_transactions = self.transaction_queue.read().has_local_pending_transactions();
|
||||
let mut sealing_work = self.sealing_work.lock();
|
||||
if sealing_work.enabled {
|
||||
trace!(target: "miner", "requires_reseal: sealing enabled");
|
||||
@ -484,7 +482,7 @@ impl Miner {
|
||||
|
||||
/// Attempts to perform internal sealing (one that does not require work) and handles the result depending on the type of Seal.
|
||||
fn seal_and_import_block_internally(&self, chain: &MiningBlockChainClient, block: ClosedBlock) -> bool {
|
||||
if !block.transactions().is_empty() || self.forced_sealing() {
|
||||
if !block.transactions().is_empty() || self.forced_sealing() || Instant::now() > *self.next_mandatory_reseal.read() {
|
||||
trace!(target: "miner", "seal_block_internally: attempting internal seal.");
|
||||
match self.engine.generate_seal(block.block()) {
|
||||
// Save proposal for later seal submission and broadcast it.
|
||||
@ -559,7 +557,7 @@ impl Miner {
|
||||
|
||||
fn update_gas_limit(&self, client: &MiningBlockChainClient) {
|
||||
let gas_limit = client.best_block_header().gas_limit();
|
||||
let mut queue = self.transaction_queue.lock();
|
||||
let mut queue = self.transaction_queue.write();
|
||||
queue.set_gas_limit(gas_limit);
|
||||
if let GasLimit::Auto = self.options.tx_queue_gas_limit {
|
||||
// Set total tx queue gas limit to be 20x the block gas limit.
|
||||
@ -681,7 +679,7 @@ const SEALING_TIMEOUT_IN_BLOCKS : u64 = 5;
|
||||
impl MinerService for Miner {
|
||||
|
||||
fn clear_and_reset(&self, chain: &MiningBlockChainClient) {
|
||||
self.transaction_queue.lock().clear();
|
||||
self.transaction_queue.write().clear();
|
||||
// --------------------------------------------------------------------------
|
||||
// | NOTE Code below requires transaction_queue and sealing_work locks. |
|
||||
// | Make sure to release the locks before calling that method. |
|
||||
@ -690,7 +688,7 @@ impl MinerService for Miner {
|
||||
}
|
||||
|
||||
fn status(&self) -> MinerStatus {
|
||||
let status = self.transaction_queue.lock().status();
|
||||
let status = self.transaction_queue.read().status();
|
||||
let sealing_work = self.sealing_work.lock();
|
||||
MinerStatus {
|
||||
transactions_in_pending_queue: status.pending,
|
||||
@ -820,16 +818,16 @@ impl MinerService for Miner {
|
||||
}
|
||||
|
||||
fn set_minimal_gas_price(&self, min_gas_price: U256) {
|
||||
self.transaction_queue.lock().set_minimal_gas_price(min_gas_price);
|
||||
self.transaction_queue.write().set_minimal_gas_price(min_gas_price);
|
||||
}
|
||||
|
||||
fn minimal_gas_price(&self) -> U256 {
|
||||
*self.transaction_queue.lock().minimal_gas_price()
|
||||
*self.transaction_queue.read().minimal_gas_price()
|
||||
}
|
||||
|
||||
fn sensible_gas_price(&self) -> U256 {
|
||||
// 10% above our minimum.
|
||||
*self.transaction_queue.lock().minimal_gas_price() * 110.into() / 100.into()
|
||||
*self.transaction_queue.read().minimal_gas_price() * 110.into() / 100.into()
|
||||
}
|
||||
|
||||
fn sensible_gas_limit(&self) -> U256 {
|
||||
@ -837,15 +835,15 @@ impl MinerService for Miner {
|
||||
}
|
||||
|
||||
fn transactions_limit(&self) -> usize {
|
||||
self.transaction_queue.lock().limit()
|
||||
self.transaction_queue.read().limit()
|
||||
}
|
||||
|
||||
fn set_transactions_limit(&self, limit: usize) {
|
||||
self.transaction_queue.lock().set_limit(limit)
|
||||
self.transaction_queue.write().set_limit(limit)
|
||||
}
|
||||
|
||||
fn set_tx_gas_limit(&self, limit: U256) {
|
||||
self.transaction_queue.lock().set_tx_gas_limit(limit)
|
||||
self.transaction_queue.write().set_tx_gas_limit(limit)
|
||||
}
|
||||
|
||||
/// Get the author that we will seal blocks as.
|
||||
@ -875,7 +873,7 @@ impl MinerService for Miner {
|
||||
) -> Vec<Result<TransactionImportResult, Error>> {
|
||||
trace!(target: "external_tx", "Importing external transactions");
|
||||
let results = {
|
||||
let mut transaction_queue = self.transaction_queue.lock();
|
||||
let mut transaction_queue = self.transaction_queue.write();
|
||||
self.add_transactions_to_queue(
|
||||
chain, transactions, TransactionOrigin::External, None, &mut transaction_queue
|
||||
)
|
||||
@ -902,7 +900,7 @@ impl MinerService for Miner {
|
||||
|
||||
let imported = {
|
||||
// Be sure to release the lock before we call prepare_work_sealing
|
||||
let mut transaction_queue = self.transaction_queue.lock();
|
||||
let mut transaction_queue = self.transaction_queue.write();
|
||||
// We need to re-validate transactions
|
||||
let import = self.add_transactions_to_queue(
|
||||
chain, vec![pending.transaction.into()], TransactionOrigin::Local, pending.condition, &mut transaction_queue
|
||||
@ -939,12 +937,12 @@ impl MinerService for Miner {
|
||||
}
|
||||
|
||||
fn pending_transactions(&self) -> Vec<PendingTransaction> {
|
||||
let queue = self.transaction_queue.lock();
|
||||
let queue = self.transaction_queue.read();
|
||||
queue.pending_transactions(BlockNumber::max_value(), u64::max_value())
|
||||
}
|
||||
|
||||
fn local_transactions(&self) -> BTreeMap<H256, LocalTransactionStatus> {
|
||||
let queue = self.transaction_queue.lock();
|
||||
let queue = self.transaction_queue.read();
|
||||
queue.local_transactions()
|
||||
.iter()
|
||||
.map(|(hash, status)| (*hash, status.clone()))
|
||||
@ -952,11 +950,11 @@ impl MinerService for Miner {
|
||||
}
|
||||
|
||||
fn future_transactions(&self) -> Vec<PendingTransaction> {
|
||||
self.transaction_queue.lock().future_transactions()
|
||||
self.transaction_queue.read().future_transactions()
|
||||
}
|
||||
|
||||
fn ready_transactions(&self, best_block: BlockNumber, best_block_timestamp: u64) -> Vec<PendingTransaction> {
|
||||
let queue = self.transaction_queue.lock();
|
||||
let queue = self.transaction_queue.read();
|
||||
match self.options.pending_set {
|
||||
PendingSet::AlwaysQueue => queue.pending_transactions(best_block, best_block_timestamp),
|
||||
PendingSet::SealingOrElseQueue => {
|
||||
@ -977,7 +975,7 @@ impl MinerService for Miner {
|
||||
}
|
||||
|
||||
fn pending_transactions_hashes(&self, best_block: BlockNumber) -> Vec<H256> {
|
||||
let queue = self.transaction_queue.lock();
|
||||
let queue = self.transaction_queue.read();
|
||||
match self.options.pending_set {
|
||||
PendingSet::AlwaysQueue => queue.pending_hashes(),
|
||||
PendingSet::SealingOrElseQueue => {
|
||||
@ -998,7 +996,7 @@ impl MinerService for Miner {
|
||||
}
|
||||
|
||||
fn transaction(&self, best_block: BlockNumber, hash: &H256) -> Option<PendingTransaction> {
|
||||
let queue = self.transaction_queue.lock();
|
||||
let queue = self.transaction_queue.read();
|
||||
match self.options.pending_set {
|
||||
PendingSet::AlwaysQueue => queue.find(hash),
|
||||
PendingSet::SealingOrElseQueue => {
|
||||
@ -1019,7 +1017,7 @@ impl MinerService for Miner {
|
||||
}
|
||||
|
||||
fn remove_pending_transaction(&self, chain: &MiningBlockChainClient, hash: &H256) -> Option<PendingTransaction> {
|
||||
let mut queue = self.transaction_queue.lock();
|
||||
let mut queue = self.transaction_queue.write();
|
||||
let tx = queue.find(hash);
|
||||
if tx.is_some() {
|
||||
let fetch_nonce = |a: &Address| chain.latest_nonce(a);
|
||||
@ -1079,7 +1077,7 @@ impl MinerService for Miner {
|
||||
}
|
||||
|
||||
fn last_nonce(&self, address: &Address) -> Option<U256> {
|
||||
self.transaction_queue.lock().last_nonce(address)
|
||||
self.transaction_queue.read().last_nonce(address)
|
||||
}
|
||||
|
||||
/// Update sealing if required.
|
||||
@ -1169,7 +1167,7 @@ impl MinerService for Miner {
|
||||
// Then import all transactions...
|
||||
{
|
||||
|
||||
let mut transaction_queue = self.transaction_queue.lock();
|
||||
let mut transaction_queue = self.transaction_queue.write();
|
||||
for hash in retracted {
|
||||
let block = chain.block(BlockId::Hash(*hash))
|
||||
.expect("Client is sending message after commit to db and inserting to chain; the block is available; qed");
|
||||
@ -1187,7 +1185,7 @@ impl MinerService for Miner {
|
||||
balance: chain.latest_balance(a),
|
||||
};
|
||||
let time = chain.chain_info().best_block_number;
|
||||
let mut transaction_queue = self.transaction_queue.lock();
|
||||
let mut transaction_queue = self.transaction_queue.write();
|
||||
transaction_queue.remove_old(&fetch_account, time);
|
||||
}
|
||||
|
||||
|
||||
@ -19,7 +19,7 @@ use state::Account;
|
||||
use account_db::AccountDBMut;
|
||||
use ethjson;
|
||||
use types::account_diff::*;
|
||||
use rlp::{self, RlpStream, Stream};
|
||||
use rlp::{self, RlpStream};
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
/// An account, expressed as Plain-Old-Data (hence the name).
|
||||
|
||||
@ -22,7 +22,7 @@ use snapshot::Error;
|
||||
|
||||
use util::{U256, H256, Bytes, HashDB, SHA3_EMPTY, SHA3_NULL_RLP};
|
||||
use util::trie::{TrieDB, Trie};
|
||||
use rlp::{RlpStream, Stream, UntrustedRlp, View};
|
||||
use rlp::{RlpStream, UntrustedRlp, View};
|
||||
|
||||
use std::collections::HashSet;
|
||||
|
||||
|
||||
@ -20,7 +20,7 @@ use block::Block;
|
||||
use header::Header;
|
||||
|
||||
use views::BlockView;
|
||||
use rlp::{DecoderError, RlpStream, Stream, UntrustedRlp, View};
|
||||
use rlp::{DecoderError, RlpStream, UntrustedRlp, View};
|
||||
use util::{Bytes, Hashable, H256};
|
||||
use util::triehash::ordered_trie_root;
|
||||
|
||||
@ -69,7 +69,9 @@ impl AbridgedBlock {
|
||||
.append(&header.extra_data());
|
||||
|
||||
// write block values.
|
||||
stream.append(&block_view.transactions()).append(&block_view.uncles());
|
||||
stream
|
||||
.append_list(&block_view.transactions())
|
||||
.append_list(&block_view.uncles());
|
||||
|
||||
// write seal fields.
|
||||
for field in seal_fields {
|
||||
@ -108,7 +110,7 @@ impl AbridgedBlock {
|
||||
header.set_receipts_root(receipts_root);
|
||||
|
||||
let mut uncles_rlp = RlpStream::new();
|
||||
uncles_rlp.append(&uncles);
|
||||
uncles_rlp.append_list(&uncles);
|
||||
header.set_uncles_hash(uncles_rlp.as_raw().sha3());
|
||||
|
||||
let mut seal_fields = Vec::new();
|
||||
|
||||
@ -27,7 +27,7 @@ use std::path::{Path, PathBuf};
|
||||
|
||||
use util::Bytes;
|
||||
use util::hash::H256;
|
||||
use rlp::{self, Encodable, RlpStream, UntrustedRlp, Stream, View};
|
||||
use rlp::{self, Encodable, RlpStream, UntrustedRlp, View};
|
||||
|
||||
use super::ManifestData;
|
||||
|
||||
@ -122,8 +122,8 @@ impl SnapshotWriter for PackedWriter {
|
||||
// they are consistent with ours.
|
||||
let mut stream = RlpStream::new_list(5);
|
||||
stream
|
||||
.append(&self.state_hashes)
|
||||
.append(&self.block_hashes)
|
||||
.append_list(&self.state_hashes)
|
||||
.append_list(&self.block_hashes)
|
||||
.append(&manifest.state_root)
|
||||
.append(&manifest.block_number)
|
||||
.append(&manifest.block_hash);
|
||||
|
||||
@ -37,7 +37,7 @@ use util::journaldb::{self, Algorithm, JournalDB};
|
||||
use util::kvdb::Database;
|
||||
use util::trie::{TrieDB, TrieDBMut, Trie, TrieMut};
|
||||
use util::sha3::SHA3_NULL_RLP;
|
||||
use rlp::{RlpStream, Stream, UntrustedRlp, View};
|
||||
use rlp::{RlpStream, UntrustedRlp, View};
|
||||
use bloom_journal::Bloom;
|
||||
|
||||
use self::block::AbridgedBlock;
|
||||
|
||||
@ -99,7 +99,7 @@ fn chunk_and_restore_40k() { chunk_and_restore(40000) }
|
||||
|
||||
#[test]
|
||||
fn checks_flag() {
|
||||
use ::rlp::{RlpStream, Stream};
|
||||
use rlp::RlpStream;
|
||||
use util::H256;
|
||||
|
||||
let mut stream = RlpStream::new_list(5);
|
||||
|
||||
@ -95,7 +95,7 @@ fn snap_and_restore() {
|
||||
#[test]
|
||||
fn get_code_from_prev_chunk() {
|
||||
use std::collections::HashSet;
|
||||
use rlp::{RlpStream, Stream};
|
||||
use rlp::RlpStream;
|
||||
use util::{HashDB, H256, U256, Hashable};
|
||||
|
||||
use account_db::{AccountDBMut, AccountDB};
|
||||
|
||||
@ -64,9 +64,12 @@ impl Into<Generic> for AuthorityRound {
|
||||
|
||||
impl Into<Generic> for Tendermint {
|
||||
fn into(self) -> Generic {
|
||||
let mut s = RlpStream::new_list(3);
|
||||
s.append(&self.round).append(&self.proposal).append(&self.precommits);
|
||||
Generic(s.out())
|
||||
let mut stream = RlpStream::new_list(3);
|
||||
stream
|
||||
.append(&self.round)
|
||||
.append(&self.proposal)
|
||||
.append_list(&self.precommits);
|
||||
Generic(stream.out())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -34,7 +34,7 @@ use super::genesis::Genesis;
|
||||
use super::seal::Generic as GenericSeal;
|
||||
use ethereum;
|
||||
use ethjson;
|
||||
use rlp::{Rlp, RlpStream, View, Stream};
|
||||
use rlp::{Rlp, RlpStream, View};
|
||||
|
||||
/// Parameters common to all engines.
|
||||
#[derive(Debug, PartialEq, Clone, Default)]
|
||||
|
||||
@ -34,7 +34,7 @@ use devtools::*;
|
||||
use miner::Miner;
|
||||
use header::Header;
|
||||
use transaction::{Action, Transaction, SignedTransaction};
|
||||
use rlp::{self, RlpStream, Stream};
|
||||
use rlp::{self, RlpStream};
|
||||
use views::BlockView;
|
||||
|
||||
#[cfg(feature = "json-tests")]
|
||||
@ -129,7 +129,7 @@ pub fn create_test_block_with_data(header: &Header, transactions: &[SignedTransa
|
||||
for t in transactions {
|
||||
rlp.append_raw(&rlp::encode(t).to_vec(), 1);
|
||||
}
|
||||
rlp.append(&uncles);
|
||||
rlp.append_list(&uncles);
|
||||
rlp.out()
|
||||
}
|
||||
|
||||
|
||||
@ -83,7 +83,7 @@ impl Decodable for BlockTracesBloomGroup {
|
||||
|
||||
impl Encodable for BlockTracesBloomGroup {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
Encodable::rlp_append(&self.blooms, s)
|
||||
s.append_list(&self.blooms);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -41,7 +41,7 @@ impl Encodable for LogEntry {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.begin_list(3);
|
||||
s.append(&self.address);
|
||||
s.append(&self.topics);
|
||||
s.append_list(&self.topics);
|
||||
s.append(&self.data);
|
||||
}
|
||||
}
|
||||
|
||||
@ -60,7 +60,7 @@ impl Encodable for Receipt {
|
||||
}
|
||||
s.append(&self.gas_used);
|
||||
s.append(&self.log_bloom);
|
||||
s.append(&self.logs);
|
||||
s.append_list(&self.logs);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -40,8 +40,8 @@ impl ManifestData {
|
||||
/// Encode the manifest data to rlp.
|
||||
pub fn into_rlp(self) -> Bytes {
|
||||
let mut stream = RlpStream::new_list(5);
|
||||
stream.append(&self.state_hashes);
|
||||
stream.append(&self.block_hashes);
|
||||
stream.append_list(&self.state_hashes);
|
||||
stream.append_list(&self.block_hashes);
|
||||
stream.append(&self.state_root);
|
||||
stream.append(&self.block_number);
|
||||
stream.append(&self.block_hash);
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
//! Trace errors.
|
||||
|
||||
use std::fmt;
|
||||
use rlp::{RlpEncodable, Encodable, RlpStream, Decodable, Decoder, DecoderError, View};
|
||||
use rlp::{Encodable, RlpStream, Decodable, Decoder, DecoderError, View};
|
||||
use evm::Error as EvmError;
|
||||
|
||||
/// Trace evm errors.
|
||||
@ -85,7 +85,8 @@ impl Encodable for Error {
|
||||
OutOfStack => 4,
|
||||
Internal => 5,
|
||||
};
|
||||
RlpEncodable::rlp_append(&value, s);
|
||||
|
||||
s.append_internal(&value);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -59,7 +59,7 @@ impl Encodable for FlatTrace {
|
||||
s.append(&self.action);
|
||||
s.append(&self.result);
|
||||
s.append(&self.subtraces);
|
||||
s.append(&self.trace_address.clone().into_iter().collect::<Vec<_>>());
|
||||
s.append_list::<usize, &usize>(&self.trace_address.iter().collect::<Vec<_>>());
|
||||
}
|
||||
}
|
||||
|
||||
@ -103,7 +103,7 @@ impl FlatTransactionTraces {
|
||||
|
||||
impl Encodable for FlatTransactionTraces {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
Encodable::rlp_append(&self.0, s);
|
||||
s.append_list(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
@ -144,7 +144,7 @@ impl FlatBlockTraces {
|
||||
|
||||
impl Encodable for FlatBlockTraces {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
Encodable::rlp_append(&self.0, s);
|
||||
s.append_list(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -475,7 +475,7 @@ impl Encodable for VMExecutedOperation {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.begin_list(4);
|
||||
s.append(&self.gas_used);
|
||||
s.append(&self.stack_push);
|
||||
s.append_list(&self.stack_push);
|
||||
s.append(&self.mem_diff);
|
||||
s.append(&self.store_diff);
|
||||
}
|
||||
@ -551,8 +551,8 @@ impl Encodable for VMTrace {
|
||||
s.begin_list(4);
|
||||
s.append(&self.parent_step);
|
||||
s.append(&self.code);
|
||||
s.append(&self.operations);
|
||||
s.append(&self.subs);
|
||||
s.append_list(&self.operations);
|
||||
s.append_list(&self.subs);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -395,7 +395,7 @@ mod tests {
|
||||
#[test]
|
||||
#[cfg_attr(feature="dev", allow(similar_names))]
|
||||
fn test_verify_block() {
|
||||
use rlp::{RlpStream, Stream};
|
||||
use rlp::RlpStream;
|
||||
|
||||
// Test against morden
|
||||
let mut good = Header::new();
|
||||
@ -460,7 +460,7 @@ mod tests {
|
||||
|
||||
let good_uncles = vec![ good_uncle1.clone(), good_uncle2.clone() ];
|
||||
let mut uncles_rlp = RlpStream::new();
|
||||
uncles_rlp.append(&good_uncles);
|
||||
uncles_rlp.append_list(&good_uncles);
|
||||
let good_uncles_hash = uncles_rlp.as_raw().sha3();
|
||||
let good_transactions_root = ordered_trie_root(good_transactions.iter().map(|t| ::rlp::encode::<UnverifiedTransaction>(t).to_vec()));
|
||||
|
||||
|
||||
@ -79,7 +79,7 @@ impl IpfsHandler {
|
||||
fn block_list(&self, hash: H256) -> Result<Out> {
|
||||
let uncles = self.client().find_uncles(&hash).ok_or(Error::BlockNotFound)?;
|
||||
|
||||
Ok(Out::OctetStream(rlp::encode(&uncles).to_vec()))
|
||||
Ok(Out::OctetStream(rlp::encode_list(&uncles).to_vec()))
|
||||
}
|
||||
|
||||
/// Get transaction by hash and return as raw binary.
|
||||
|
||||
@ -120,20 +120,22 @@ export default class HardwareStore {
|
||||
});
|
||||
}
|
||||
|
||||
createAccountInfo (entry) {
|
||||
createAccountInfo (entry, original = {}) {
|
||||
const { address, manufacturer, name } = entry;
|
||||
|
||||
return Promise
|
||||
.all([
|
||||
this._api.parity.setAccountName(address, name),
|
||||
this._api.parity.setAccountMeta(address, {
|
||||
original.name
|
||||
? Promise.resolve(true)
|
||||
: this._api.parity.setAccountName(address, name),
|
||||
this._api.parity.setAccountMeta(address, Object.assign({
|
||||
description: `${manufacturer} ${name}`,
|
||||
hardware: {
|
||||
manufacturer
|
||||
},
|
||||
tags: ['hardware'],
|
||||
timestamp: Date.now()
|
||||
})
|
||||
}, original.meta || {}))
|
||||
])
|
||||
.catch((error) => {
|
||||
console.warn('HardwareStore::createEntry', error);
|
||||
|
||||
@ -130,6 +130,7 @@ describe('mobx/HardwareStore', () => {
|
||||
|
||||
describe('operations', () => {
|
||||
describe('createAccountInfo', () => {
|
||||
describe('when not existing', () => {
|
||||
beforeEach(() => {
|
||||
return store.createAccountInfo({
|
||||
address: 'testAddr',
|
||||
@ -147,11 +148,43 @@ describe('mobx/HardwareStore', () => {
|
||||
description: 'testMfg testName',
|
||||
hardware: {
|
||||
manufacturer: 'testMfg'
|
||||
}
|
||||
},
|
||||
tags: ['hardware']
|
||||
}));
|
||||
});
|
||||
});
|
||||
|
||||
describe('when already exists', () => {
|
||||
beforeEach(() => {
|
||||
return store.createAccountInfo({
|
||||
address: 'testAddr',
|
||||
manufacturer: 'testMfg',
|
||||
name: 'testName'
|
||||
}, {
|
||||
name: 'originalName',
|
||||
meta: {
|
||||
description: 'originalDescription',
|
||||
tags: ['tagA', 'tagB']
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it('does not call into parity_setAccountName', () => {
|
||||
expect(api.parity.setAccountName).not.to.have.been.called;
|
||||
});
|
||||
|
||||
it('calls into parity_setAccountMeta', () => {
|
||||
expect(api.parity.setAccountMeta).to.have.been.calledWith('testAddr', sinon.match({
|
||||
description: 'originalDescription',
|
||||
hardware: {
|
||||
manufacturer: 'testMfg'
|
||||
},
|
||||
tags: ['tagA', 'tagB']
|
||||
}));
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('scanLedger', () => {
|
||||
beforeEach(() => {
|
||||
return store.scanLedger();
|
||||
|
||||
@ -394,8 +394,12 @@ class Accounts extends Component {
|
||||
|
||||
Object
|
||||
.keys(wallets)
|
||||
.filter((address) => !accountsInfo[address])
|
||||
.forEach((address) => this.hwstore.createAccountInfo(wallets[address]));
|
||||
.filter((address) => {
|
||||
const account = accountsInfo[address];
|
||||
|
||||
return !account || !account.meta || !account.meta.hardware;
|
||||
})
|
||||
.forEach((address) => this.hwstore.createAccountInfo(wallets[address], accountsInfo[address]));
|
||||
|
||||
this.setVisibleAccounts();
|
||||
}
|
||||
|
||||
122
js/src/views/Accounts/accounts.spec.js
Normal file
122
js/src/views/Accounts/accounts.spec.js
Normal file
@ -0,0 +1,122 @@
|
||||
// Copyright 2015-2017 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Parity.
|
||||
|
||||
// Parity is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Parity is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
import { shallow } from 'enzyme';
|
||||
import React from 'react';
|
||||
import sinon from 'sinon';
|
||||
|
||||
import Accounts from './';
|
||||
|
||||
let api;
|
||||
let component;
|
||||
let hwstore;
|
||||
let instance;
|
||||
let redux;
|
||||
|
||||
function createApi () {
|
||||
api = {};
|
||||
|
||||
return api;
|
||||
}
|
||||
|
||||
function createHwStore (walletAddress = '0x456') {
|
||||
hwstore = {
|
||||
wallets: {
|
||||
[walletAddress]: {
|
||||
address: walletAddress
|
||||
}
|
||||
},
|
||||
createAccountInfo: sinon.stub()
|
||||
};
|
||||
|
||||
return hwstore;
|
||||
}
|
||||
|
||||
function createRedux () {
|
||||
redux = {
|
||||
dispatch: sinon.stub(),
|
||||
subscribe: sinon.stub(),
|
||||
getState: () => {
|
||||
return {
|
||||
personal: {
|
||||
accounts: {},
|
||||
accountsInfo: {
|
||||
'0x123': { meta: '1' },
|
||||
'0x999': { meta: { hardware: {} } }
|
||||
}
|
||||
},
|
||||
balances: {
|
||||
balances: {}
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
return redux;
|
||||
}
|
||||
|
||||
function render (props = {}) {
|
||||
component = shallow(
|
||||
<Accounts { ...props } />,
|
||||
{
|
||||
context: {
|
||||
store: createRedux()
|
||||
}
|
||||
}
|
||||
).find('Accounts').shallow({
|
||||
context: {
|
||||
api: createApi()
|
||||
}
|
||||
});
|
||||
instance = component.instance();
|
||||
|
||||
return component;
|
||||
}
|
||||
|
||||
describe('views/Accounts', () => {
|
||||
beforeEach(() => {
|
||||
render();
|
||||
});
|
||||
|
||||
it('renders defaults', () => {
|
||||
expect(component).to.be.ok;
|
||||
});
|
||||
|
||||
describe('instance event methods', () => {
|
||||
describe('onHardwareChange', () => {
|
||||
it('detects completely new entries', () => {
|
||||
instance.hwstore = createHwStore();
|
||||
instance.onHardwareChange();
|
||||
|
||||
expect(hwstore.createAccountInfo).to.have.been.calledWith({ address: '0x456' });
|
||||
});
|
||||
|
||||
it('detects addressbook entries', () => {
|
||||
instance.hwstore = createHwStore('0x123');
|
||||
instance.onHardwareChange();
|
||||
|
||||
expect(hwstore.createAccountInfo).to.have.been.calledWith({ address: '0x123' }, { meta: '1' });
|
||||
});
|
||||
|
||||
it('ignores existing hardware entries', () => {
|
||||
instance.hwstore = createHwStore('0x999');
|
||||
instance.onHardwareChange();
|
||||
|
||||
expect(hwstore.createAccountInfo).not.to.have.been.called;
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@ -17,7 +17,7 @@ serde = "0.9"
|
||||
serde_derive = "0.9"
|
||||
serde_json = "0.9"
|
||||
time = "0.1"
|
||||
transient-hashmap = "0.1"
|
||||
transient-hashmap = "0.4"
|
||||
|
||||
jsonrpc-core = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.7" }
|
||||
jsonrpc-http-server = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.7" }
|
||||
|
||||
@ -25,7 +25,7 @@ use light::cache::Cache as LightDataCache;
|
||||
use light::client::LightChainClient;
|
||||
use light::on_demand::{request, OnDemand};
|
||||
use light::TransactionQueue as LightTransactionQueue;
|
||||
use rlp::{self, Stream as StreamRlp};
|
||||
use rlp;
|
||||
use util::{Address, H520, H256, U256, Uint, Bytes, Mutex, RwLock};
|
||||
use util::sha3::Hashable;
|
||||
use stats::Corpus;
|
||||
|
||||
@ -19,7 +19,7 @@
|
||||
use transient_hashmap::{TransientHashMap, Timer, StandardTimer};
|
||||
|
||||
/// Lifetime of poll (in seconds).
|
||||
const POLL_LIFETIME: u64 = 60;
|
||||
const POLL_LIFETIME: u32 = 60;
|
||||
|
||||
pub type PollId = usize;
|
||||
|
||||
|
||||
@ -23,7 +23,7 @@ use ethstore::random_string;
|
||||
|
||||
use v1::helpers::signing_queue::{ConfirmationsQueue};
|
||||
|
||||
const TOKEN_LIFETIME_SECS: u64 = 3600;
|
||||
const TOKEN_LIFETIME_SECS: u32 = 3600;
|
||||
|
||||
/// Manages communication with Signer crate
|
||||
pub struct SignerService {
|
||||
|
||||
@ -43,7 +43,7 @@ use v1::types::{
|
||||
};
|
||||
|
||||
/// After 60s entries that are not queried with `check_request` will get garbage collected.
|
||||
const MAX_PENDING_DURATION_SEC: u64 = 60;
|
||||
const MAX_PENDING_DURATION_SEC: u32 = 60;
|
||||
/// Max number of total requests pending and completed, before we start garbage collecting them.
|
||||
const MAX_TOTAL_REQUESTS: usize = SIGNING_QUEUE_LIMIT;
|
||||
|
||||
|
||||
@ -2177,7 +2177,7 @@ mod tests {
|
||||
use util::sha3::Hashable;
|
||||
use util::hash::H256;
|
||||
use util::bytes::Bytes;
|
||||
use rlp::{Rlp, RlpStream, UntrustedRlp, View, Stream};
|
||||
use rlp::{Rlp, RlpStream, UntrustedRlp, View};
|
||||
use super::*;
|
||||
use ::SyncConfig;
|
||||
use super::{PeerInfo, PeerAsking};
|
||||
|
||||
@ -213,7 +213,7 @@ impl Discovery {
|
||||
let nearest = Discovery::nearest_node_entries(&self.discovery_id, &self.node_buckets).into_iter();
|
||||
let nearest = nearest.filter(|x| !self.discovery_nodes.contains(&x.id)).take(ALPHA).collect::<Vec<_>>();
|
||||
for r in nearest {
|
||||
let rlp = encode(&(&[self.discovery_id.clone()][..]));
|
||||
let rlp = encode_list(&(&[self.discovery_id.clone()][..]));
|
||||
self.send_packet(PACKET_FIND_NODE, &r.endpoint.udp_address(), &rlp);
|
||||
self.discovery_nodes.insert(r.id.clone());
|
||||
tried_count += 1;
|
||||
|
||||
@ -463,7 +463,7 @@ impl Session {
|
||||
rlp.begin_list(5)
|
||||
.append(&host.protocol_version)
|
||||
.append(&host.client_version)
|
||||
.append(&host.capabilities)
|
||||
.append_list(&host.capabilities)
|
||||
.append(&host.local_endpoint.address.port())
|
||||
.append(host.id());
|
||||
self.send(io, rlp)
|
||||
|
||||
@ -10,3 +10,4 @@ elastic-array = { git = "https://github.com/ethcore/elastic-array" }
|
||||
ethcore-bigint = { path = "../bigint" }
|
||||
lazy_static = "0.2"
|
||||
rustc-serialize = "0.3"
|
||||
byteorder = "1.0"
|
||||
|
||||
@ -17,152 +17,9 @@
|
||||
//! Unified interfaces for RLP bytes operations on basic types
|
||||
//!
|
||||
|
||||
use std::mem;
|
||||
use std::fmt;
|
||||
use std::cmp::Ordering;
|
||||
use std::{mem, fmt, cmp};
|
||||
use std::error::Error as StdError;
|
||||
use bigint::prelude::{Uint, U128, U256, H64, H128, H160, H256, H512, H520, H2048};
|
||||
use elastic_array::*;
|
||||
|
||||
/// Vector like object
|
||||
pub trait VecLike<T> {
|
||||
/// Add an element to the collection
|
||||
fn vec_push(&mut self, value: T);
|
||||
|
||||
/// Add a slice to the collection
|
||||
fn vec_extend(&mut self, slice: &[T]);
|
||||
}
|
||||
|
||||
impl<T> VecLike<T> for Vec<T> where T: Copy {
|
||||
fn vec_push(&mut self, value: T) {
|
||||
Vec::<T>::push(self, value)
|
||||
}
|
||||
|
||||
fn vec_extend(&mut self, slice: &[T]) {
|
||||
Vec::<T>::extend_from_slice(self, slice)
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_veclike_for_elastic_array {
|
||||
($from: ident) => {
|
||||
impl<T> VecLike<T> for $from<T> where T: Copy {
|
||||
fn vec_push(&mut self, value: T) {
|
||||
$from::<T>::push(self, value)
|
||||
}
|
||||
fn vec_extend(&mut self, slice: &[T]) {
|
||||
$from::<T>::append_slice(self, slice)
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl_veclike_for_elastic_array!(ElasticArray16);
|
||||
impl_veclike_for_elastic_array!(ElasticArray32);
|
||||
impl_veclike_for_elastic_array!(ElasticArray1024);
|
||||
|
||||
/// Converts given type to its shortest representation in bytes
|
||||
///
|
||||
/// TODO: optimise some conversations
|
||||
pub trait ToBytes {
|
||||
/// Serialize self to byte array
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V);
|
||||
/// Get length of serialized data in bytes
|
||||
fn to_bytes_len(&self) -> usize;
|
||||
}
|
||||
|
||||
impl <'a> ToBytes for &'a str {
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V) {
|
||||
out.vec_extend(self.as_bytes());
|
||||
}
|
||||
|
||||
fn to_bytes_len(&self) -> usize {
|
||||
self.as_bytes().len()
|
||||
}
|
||||
}
|
||||
|
||||
impl ToBytes for String {
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V) {
|
||||
out.vec_extend(self.as_bytes());
|
||||
}
|
||||
|
||||
fn to_bytes_len(&self) -> usize {
|
||||
self.len()
|
||||
}
|
||||
}
|
||||
|
||||
impl ToBytes for u64 {
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V) {
|
||||
let count = self.to_bytes_len();
|
||||
for i in 0..count {
|
||||
let j = count - 1 - i;
|
||||
out.vec_push((*self >> (j * 8)) as u8);
|
||||
}
|
||||
}
|
||||
|
||||
fn to_bytes_len(&self) -> usize { 8 - self.leading_zeros() as usize / 8 }
|
||||
}
|
||||
|
||||
impl ToBytes for bool {
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V) {
|
||||
out.vec_push(if *self { 1u8 } else { 0u8 })
|
||||
}
|
||||
|
||||
fn to_bytes_len(&self) -> usize { 1 }
|
||||
}
|
||||
|
||||
macro_rules! impl_map_to_bytes {
|
||||
($from: ident, $to: ty) => {
|
||||
impl ToBytes for $from {
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V) {
|
||||
(*self as $to).to_bytes(out)
|
||||
}
|
||||
|
||||
fn to_bytes_len(&self) -> usize { (*self as $to).to_bytes_len() }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl_map_to_bytes!(usize, u64);
|
||||
impl_map_to_bytes!(u16, u64);
|
||||
impl_map_to_bytes!(u32, u64);
|
||||
|
||||
macro_rules! impl_uint_to_bytes {
|
||||
($name: ident) => {
|
||||
impl ToBytes for $name {
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V) {
|
||||
let count = self.to_bytes_len();
|
||||
for i in 0..count {
|
||||
let j = count - 1 - i;
|
||||
out.vec_push(self.byte(j));
|
||||
}
|
||||
}
|
||||
fn to_bytes_len(&self) -> usize { (self.bits() + 7) / 8 }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl_uint_to_bytes!(U256);
|
||||
impl_uint_to_bytes!(U128);
|
||||
|
||||
macro_rules! impl_hash_to_bytes {
|
||||
($name: ident) => {
|
||||
impl ToBytes for $name {
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V) {
|
||||
out.vec_extend(&self);
|
||||
}
|
||||
fn to_bytes_len(&self) -> usize { self.len() }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl_hash_to_bytes!(H64);
|
||||
impl_hash_to_bytes!(H128);
|
||||
impl_hash_to_bytes!(H160);
|
||||
impl_hash_to_bytes!(H256);
|
||||
impl_hash_to_bytes!(H512);
|
||||
impl_hash_to_bytes!(H520);
|
||||
impl_hash_to_bytes!(H2048);
|
||||
use bigint::prelude::{U128, U256, H64, H128, H160, H256, H512, H520, H2048};
|
||||
|
||||
/// Error returned when `FromBytes` conversation goes wrong
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
@ -268,9 +125,9 @@ macro_rules! impl_hash_from_bytes {
|
||||
impl FromBytes for $name {
|
||||
fn from_bytes(bytes: &[u8]) -> FromBytesResult<$name> {
|
||||
match bytes.len().cmp(&$size) {
|
||||
Ordering::Less => Err(FromBytesError::DataIsTooShort),
|
||||
Ordering::Greater => Err(FromBytesError::DataIsTooLong),
|
||||
Ordering::Equal => {
|
||||
cmp::Ordering::Less => Err(FromBytesError::DataIsTooShort),
|
||||
cmp::Ordering::Greater => Err(FromBytesError::DataIsTooLong),
|
||||
cmp::Ordering::Equal => {
|
||||
let mut t = [0u8; $size];
|
||||
t.copy_from_slice(bytes);
|
||||
Ok($name(t))
|
||||
|
||||
@ -16,7 +16,7 @@
|
||||
|
||||
//! Contains RLPs used for compression.
|
||||
|
||||
use rlpcompression::InvalidRlpSwapper;
|
||||
use compression::InvalidRlpSwapper;
|
||||
|
||||
lazy_static! {
|
||||
/// Swapper for snapshot compression.
|
||||
@ -14,11 +14,10 @@
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
use ::{UntrustedRlp, View, Compressible, encode, Stream, RlpStream};
|
||||
use commonrlps::{BLOCKS_RLP_SWAPPER, SNAPSHOT_RLP_SWAPPER};
|
||||
|
||||
use std::collections::HashMap;
|
||||
use elastic_array::ElasticArray1024;
|
||||
use common::{BLOCKS_RLP_SWAPPER, SNAPSHOT_RLP_SWAPPER};
|
||||
use {UntrustedRlp, View, Compressible, encode, RlpStream};
|
||||
|
||||
/// Stores RLPs used for compression
|
||||
pub struct InvalidRlpSwapper<'a> {
|
||||
@ -149,8 +148,6 @@ fn deep_decompress(rlp: &UntrustedRlp, swapper: &InvalidRlpSwapper) -> Option<El
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
impl<'a> Compressible for UntrustedRlp<'a> {
|
||||
type DataType = RlpType;
|
||||
|
||||
@ -171,8 +168,8 @@ impl<'a> Compressible for UntrustedRlp<'a> {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use ::{UntrustedRlp, Compressible, View, RlpType};
|
||||
use rlpcompression::InvalidRlpSwapper;
|
||||
use compression::InvalidRlpSwapper;
|
||||
use {UntrustedRlp, Compressible, View, RlpType};
|
||||
|
||||
#[test]
|
||||
fn invalid_rlp_swapper() {
|
||||
120
util/rlp/src/impls.rs
Normal file
120
util/rlp/src/impls.rs
Normal file
@ -0,0 +1,120 @@
|
||||
use byteorder::{ByteOrder, BigEndian};
|
||||
use bigint::prelude::{Uint, U128, U256, H64, H128, H160, H256, H512, H520, H2048};
|
||||
use traits::Encodable;
|
||||
use stream::RlpStream;
|
||||
|
||||
impl Encodable for bool {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
if *self {
|
||||
s.encoder().encode_value(&[1]);
|
||||
} else {
|
||||
s.encoder().encode_value(&[0]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Encodable for &'a [u8] {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.encoder().encode_value(self);
|
||||
}
|
||||
}
|
||||
|
||||
impl Encodable for Vec<u8> {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.encoder().encode_value(self);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Encodable for Option<T> where T: Encodable {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
match *self {
|
||||
None => {
|
||||
s.begin_list(0);
|
||||
},
|
||||
Some(ref value) => {
|
||||
s.begin_list(1);
|
||||
s.append(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Encodable for u8 {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
if *self != 0 {
|
||||
s.encoder().encode_value(&[*self]);
|
||||
} else {
|
||||
s.encoder().encode_value(&[]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_encodable_for_u {
|
||||
($name: ident, $func: ident, $size: expr) => {
|
||||
impl Encodable for $name {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
let leading_empty_bytes = self.leading_zeros() as usize / 8;
|
||||
let mut buffer = [0u8; $size];
|
||||
BigEndian::$func(&mut buffer, *self);
|
||||
s.encoder().encode_value(&buffer[leading_empty_bytes..]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl_encodable_for_u!(u16, write_u16, 2);
|
||||
impl_encodable_for_u!(u32, write_u32, 4);
|
||||
impl_encodable_for_u!(u64, write_u64, 8);
|
||||
|
||||
impl Encodable for usize {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
(*self as u64).rlp_append(s);
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_encodable_for_hash {
|
||||
($name: ident) => {
|
||||
impl Encodable for $name {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.encoder().encode_value(self);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl_encodable_for_hash!(H64);
|
||||
impl_encodable_for_hash!(H128);
|
||||
impl_encodable_for_hash!(H160);
|
||||
impl_encodable_for_hash!(H256);
|
||||
impl_encodable_for_hash!(H512);
|
||||
impl_encodable_for_hash!(H520);
|
||||
impl_encodable_for_hash!(H2048);
|
||||
|
||||
macro_rules! impl_encodable_for_uint {
|
||||
($name: ident, $size: expr) => {
|
||||
impl Encodable for $name {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
let leading_empty_bytes = $size - (self.bits() + 7) / 8;
|
||||
let mut buffer = [0u8; $size];
|
||||
self.to_big_endian(&mut buffer);
|
||||
s.encoder().encode_value(&buffer[leading_empty_bytes..]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl_encodable_for_uint!(U256, 32);
|
||||
impl_encodable_for_uint!(U128, 16);
|
||||
|
||||
impl<'a> Encodable for &'a str {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.encoder().encode_value(self.as_bytes());
|
||||
}
|
||||
}
|
||||
|
||||
impl Encodable for String {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.encoder().encode_value(self.as_bytes());
|
||||
}
|
||||
}
|
||||
|
||||
@ -46,25 +46,7 @@
|
||||
//! * You want to get view onto rlp-slice.
|
||||
//! * You don't want to decode whole rlp at once.
|
||||
|
||||
pub mod rlptraits;
|
||||
mod rlperrors;
|
||||
mod rlpin;
|
||||
mod untrusted_rlp;
|
||||
mod rlpstream;
|
||||
mod rlpcompression;
|
||||
mod commonrlps;
|
||||
mod bytes;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
pub use self::rlperrors::DecoderError;
|
||||
pub use self::rlptraits::{Decoder, Decodable, View, Stream, Encodable, Encoder, RlpEncodable, RlpDecodable, Compressible};
|
||||
pub use self::untrusted_rlp::{UntrustedRlp, UntrustedRlpIterator, PayloadInfo, Prototype};
|
||||
pub use self::rlpin::{Rlp, RlpIterator};
|
||||
pub use self::rlpstream::RlpStream;
|
||||
pub use self::rlpcompression::RlpType;
|
||||
|
||||
extern crate byteorder;
|
||||
extern crate ethcore_bigint as bigint;
|
||||
extern crate elastic_array;
|
||||
extern crate rustc_serialize;
|
||||
@ -72,8 +54,29 @@ extern crate rustc_serialize;
|
||||
#[macro_use]
|
||||
extern crate lazy_static;
|
||||
|
||||
mod traits;
|
||||
mod error;
|
||||
mod rlpin;
|
||||
mod untrusted_rlp;
|
||||
mod stream;
|
||||
mod compression;
|
||||
mod common;
|
||||
mod bytes;
|
||||
mod impls;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
use std::borrow::Borrow;
|
||||
use elastic_array::ElasticArray1024;
|
||||
|
||||
pub use error::DecoderError;
|
||||
pub use traits::{Decoder, Decodable, View, Encodable, RlpDecodable, Compressible};
|
||||
pub use untrusted_rlp::{UntrustedRlp, UntrustedRlpIterator, PayloadInfo, Prototype};
|
||||
pub use rlpin::{Rlp, RlpIterator};
|
||||
pub use stream::RlpStream;
|
||||
pub use compression::RlpType;
|
||||
|
||||
/// The RLP encoded empty data (used to mean "null value").
|
||||
pub const NULL_RLP: [u8; 1] = [0x80; 1];
|
||||
/// The RLP encoded empty list.
|
||||
@ -106,8 +109,14 @@ pub fn decode<T>(bytes: &[u8]) -> T where T: RlpDecodable {
|
||||
/// assert_eq!(out, vec![0x83, b'c', b'a', b't']);
|
||||
/// }
|
||||
/// ```
|
||||
pub fn encode<E>(object: &E) -> ElasticArray1024<u8> where E: RlpEncodable {
|
||||
pub fn encode<E>(object: &E) -> ElasticArray1024<u8> where E: Encodable {
|
||||
let mut stream = RlpStream::new();
|
||||
stream.append(object);
|
||||
stream.drain()
|
||||
}
|
||||
|
||||
pub fn encode_list<E, K>(object: &[K]) -> ElasticArray1024<u8> where E: Encodable, K: Borrow<E> {
|
||||
let mut stream = RlpStream::new();
|
||||
stream.append_list(object);
|
||||
stream.drain()
|
||||
}
|
||||
|
||||
@ -16,7 +16,7 @@
|
||||
|
||||
use std::fmt;
|
||||
use rustc_serialize::hex::ToHex;
|
||||
use ::{View, DecoderError, UntrustedRlp, PayloadInfo, Prototype, RlpDecodable};
|
||||
use {View, DecoderError, UntrustedRlp, PayloadInfo, Prototype, RlpDecodable};
|
||||
|
||||
impl<'a> From<UntrustedRlp<'a>> for Rlp<'a> {
|
||||
fn from(rlp: UntrustedRlp<'a>) -> Rlp<'a> {
|
||||
|
||||
@ -1,357 +0,0 @@
|
||||
// Copyright 2015-2017 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Parity.
|
||||
|
||||
// Parity is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Parity is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
use elastic_array::*;
|
||||
|
||||
use ::{Stream, Encoder, Encodable};
|
||||
use bytes::{ToBytes, VecLike};
|
||||
use rlptraits::{ByteEncodable, RlpEncodable};
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
struct ListInfo {
|
||||
position: usize,
|
||||
current: usize,
|
||||
max: usize,
|
||||
}
|
||||
|
||||
impl ListInfo {
|
||||
fn new(position: usize, max: usize) -> ListInfo {
|
||||
ListInfo {
|
||||
position: position,
|
||||
current: 0,
|
||||
max: max,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Appendable rlp encoder.
|
||||
pub struct RlpStream {
|
||||
unfinished_lists: ElasticArray16<ListInfo>,
|
||||
encoder: BasicEncoder,
|
||||
finished_list: bool,
|
||||
}
|
||||
|
||||
impl Default for RlpStream {
|
||||
fn default() -> Self {
|
||||
RlpStream::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl Stream for RlpStream {
|
||||
fn new() -> Self {
|
||||
RlpStream {
|
||||
unfinished_lists: ElasticArray16::new(),
|
||||
encoder: BasicEncoder::new(),
|
||||
finished_list: false,
|
||||
}
|
||||
}
|
||||
|
||||
fn new_list(len: usize) -> Self {
|
||||
let mut stream = RlpStream::new();
|
||||
stream.begin_list(len);
|
||||
stream
|
||||
}
|
||||
|
||||
fn append<'a, E>(&'a mut self, value: &E) -> &'a mut Self where E: RlpEncodable {
|
||||
self.finished_list = false;
|
||||
value.rlp_append(self);
|
||||
if !self.finished_list {
|
||||
self.note_appended(1);
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
fn begin_list(&mut self, len: usize) -> &mut RlpStream {
|
||||
self.finished_list = false;
|
||||
match len {
|
||||
0 => {
|
||||
// we may finish, if the appended list len is equal 0
|
||||
self.encoder.bytes.push(0xc0u8);
|
||||
self.note_appended(1);
|
||||
self.finished_list = true;
|
||||
},
|
||||
_ => {
|
||||
let position = self.encoder.bytes.len();
|
||||
self.unfinished_lists.push(ListInfo::new(position, len));
|
||||
},
|
||||
}
|
||||
|
||||
// return chainable self
|
||||
self
|
||||
}
|
||||
|
||||
fn append_empty_data(&mut self) -> &mut RlpStream {
|
||||
// self push raw item
|
||||
self.encoder.bytes.push(0x80);
|
||||
|
||||
// try to finish and prepend the length
|
||||
self.note_appended(1);
|
||||
|
||||
// return chainable self
|
||||
self
|
||||
}
|
||||
|
||||
fn append_raw<'a>(&'a mut self, bytes: &[u8], item_count: usize) -> &'a mut RlpStream {
|
||||
// push raw items
|
||||
self.encoder.bytes.append_slice(bytes);
|
||||
|
||||
// try to finish and prepend the length
|
||||
self.note_appended(item_count);
|
||||
|
||||
// return chainable self
|
||||
self
|
||||
}
|
||||
|
||||
fn clear(&mut self) {
|
||||
// clear bytes
|
||||
self.encoder.bytes.clear();
|
||||
|
||||
// clear lists
|
||||
self.unfinished_lists.clear();
|
||||
}
|
||||
|
||||
fn is_finished(&self) -> bool {
|
||||
self.unfinished_lists.len() == 0
|
||||
}
|
||||
|
||||
fn as_raw(&self) -> &[u8] {
|
||||
&self.encoder.bytes
|
||||
}
|
||||
|
||||
fn out(self) -> Vec<u8> {
|
||||
match self.is_finished() {
|
||||
true => self.encoder.out().to_vec(),
|
||||
false => panic!()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl RlpStream {
|
||||
|
||||
/// Appends primitive value to the end of stream
|
||||
fn append_value<E>(&mut self, object: &E) where E: ByteEncodable {
|
||||
// encode given value and add it at the end of the stream
|
||||
self.encoder.emit_value(object);
|
||||
}
|
||||
|
||||
fn append_internal<'a, E>(&'a mut self, value: &E) -> &'a mut Self where E: Encodable {
|
||||
self.finished_list = false;
|
||||
value.rlp_append(self);
|
||||
if !self.finished_list {
|
||||
self.note_appended(1);
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
/// Try to finish lists
|
||||
fn note_appended(&mut self, inserted_items: usize) -> () {
|
||||
if self.unfinished_lists.len() == 0 {
|
||||
return;
|
||||
}
|
||||
|
||||
let back = self.unfinished_lists.len() - 1;
|
||||
let should_finish = match self.unfinished_lists.get_mut(back) {
|
||||
None => false,
|
||||
Some(ref mut x) => {
|
||||
x.current += inserted_items;
|
||||
if x.current > x.max {
|
||||
panic!("You cannot append more items then you expect!");
|
||||
}
|
||||
x.current == x.max
|
||||
}
|
||||
};
|
||||
|
||||
if should_finish {
|
||||
let x = self.unfinished_lists.pop().unwrap();
|
||||
let len = self.encoder.bytes.len() - x.position;
|
||||
self.encoder.insert_list_len_at_pos(len, x.position);
|
||||
self.note_appended(1);
|
||||
}
|
||||
self.finished_list = should_finish;
|
||||
}
|
||||
|
||||
/// Drain the object and return the underlying ElasticArray.
|
||||
pub fn drain(self) -> ElasticArray1024<u8> {
|
||||
match self.is_finished() {
|
||||
true => self.encoder.bytes,
|
||||
false => panic!()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct BasicEncoder {
|
||||
bytes: ElasticArray1024<u8>,
|
||||
}
|
||||
|
||||
impl Default for BasicEncoder {
|
||||
fn default() -> Self {
|
||||
BasicEncoder::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl BasicEncoder {
|
||||
fn new() -> Self {
|
||||
BasicEncoder { bytes: ElasticArray1024::new() }
|
||||
}
|
||||
|
||||
/// inserts list prefix at given position
|
||||
/// TODO: optimise it further?
|
||||
fn insert_list_len_at_pos(&mut self, len: usize, pos: usize) -> () {
|
||||
let mut res = ElasticArray16::new();
|
||||
match len {
|
||||
0...55 => res.push(0xc0u8 + len as u8),
|
||||
_ => {
|
||||
res.push(0xf7u8 + len.to_bytes_len() as u8);
|
||||
ToBytes::to_bytes(&len, &mut res);
|
||||
}
|
||||
};
|
||||
|
||||
self.bytes.insert_slice(pos, &res);
|
||||
}
|
||||
|
||||
/// get encoded value
|
||||
fn out(self) -> ElasticArray1024<u8> {
|
||||
self.bytes
|
||||
}
|
||||
}
|
||||
|
||||
impl Encoder for BasicEncoder {
|
||||
fn emit_value<E: ByteEncodable>(&mut self, value: &E) {
|
||||
match value.bytes_len() {
|
||||
// just 0
|
||||
0 => self.bytes.push(0x80u8),
|
||||
// byte is its own encoding if < 0x80
|
||||
1 => {
|
||||
value.to_bytes(&mut self.bytes);
|
||||
let len = self.bytes.len();
|
||||
let last_byte = self.bytes[len - 1];
|
||||
if last_byte >= 0x80 {
|
||||
self.bytes.push(last_byte);
|
||||
self.bytes[len - 1] = 0x81;
|
||||
}
|
||||
}
|
||||
// (prefix + length), followed by the string
|
||||
len @ 2 ... 55 => {
|
||||
self.bytes.push(0x80u8 + len as u8);
|
||||
value.to_bytes(&mut self.bytes);
|
||||
}
|
||||
// (prefix + length of length), followed by the length, followd by the string
|
||||
len => {
|
||||
self.bytes.push(0xb7 + len.to_bytes_len() as u8);
|
||||
ToBytes::to_bytes(&len, &mut self.bytes);
|
||||
value.to_bytes(&mut self.bytes);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_raw(&mut self, bytes: &[u8]) -> () {
|
||||
self.bytes.append_slice(bytes);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> ByteEncodable for T where T: ToBytes {
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V) {
|
||||
ToBytes::to_bytes(self, out)
|
||||
}
|
||||
|
||||
fn bytes_len(&self) -> usize {
|
||||
ToBytes::to_bytes_len(self)
|
||||
}
|
||||
}
|
||||
|
||||
struct U8Slice<'a>(&'a [u8]);
|
||||
|
||||
impl<'a> ByteEncodable for U8Slice<'a> {
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V) {
|
||||
out.vec_extend(self.0)
|
||||
}
|
||||
|
||||
fn bytes_len(&self) -> usize {
|
||||
self.0.len()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Encodable for &'a[u8] {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.append_value(&U8Slice(self))
|
||||
}
|
||||
}
|
||||
|
||||
impl Encodable for Vec<u8> {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.append_value(&U8Slice(self))
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Encodable for T where T: ByteEncodable {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.append_value(self)
|
||||
}
|
||||
}
|
||||
|
||||
struct EncodableU8 (u8);
|
||||
|
||||
impl ByteEncodable for EncodableU8 {
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V) {
|
||||
if self.0 != 0 {
|
||||
out.vec_push(self.0)
|
||||
}
|
||||
}
|
||||
|
||||
fn bytes_len(&self) -> usize {
|
||||
match self.0 { 0 => 0, _ => 1 }
|
||||
}
|
||||
}
|
||||
|
||||
impl RlpEncodable for u8 {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.append_value(&EncodableU8(*self))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T> Encodable for &'a[T] where T: Encodable {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
s.begin_list(self.len());
|
||||
for el in self.iter() {
|
||||
s.append_internal(el);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Encodable for Vec<T> where T: Encodable {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
Encodable::rlp_append(&self.as_slice(), s);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Encodable for Option<T> where T: Encodable {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
match *self {
|
||||
None => { s.begin_list(0); },
|
||||
Some(ref x) => {
|
||||
s.begin_list(1);
|
||||
s.append_internal(x);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> RlpEncodable for T where T: Encodable {
|
||||
fn rlp_append(&self, s: &mut RlpStream) {
|
||||
Encodable::rlp_append(self, s)
|
||||
}
|
||||
}
|
||||
|
||||
335
util/rlp/src/stream.rs
Normal file
335
util/rlp/src/stream.rs
Normal file
@ -0,0 +1,335 @@
|
||||
// Copyright 2015-2017 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Parity.
|
||||
|
||||
// Parity is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Parity is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
use std::borrow::Borrow;
|
||||
use byteorder::{ByteOrder, BigEndian};
|
||||
use elastic_array::{ElasticArray16, ElasticArray1024};
|
||||
use traits::Encodable;
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
struct ListInfo {
|
||||
position: usize,
|
||||
current: usize,
|
||||
max: usize,
|
||||
}
|
||||
|
||||
impl ListInfo {
|
||||
fn new(position: usize, max: usize) -> ListInfo {
|
||||
ListInfo {
|
||||
position: position,
|
||||
current: 0,
|
||||
max: max,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Appendable rlp encoder.
|
||||
pub struct RlpStream {
|
||||
unfinished_lists: ElasticArray16<ListInfo>,
|
||||
buffer: ElasticArray1024<u8>,
|
||||
finished_list: bool,
|
||||
}
|
||||
|
||||
impl Default for RlpStream {
|
||||
fn default() -> Self {
|
||||
RlpStream::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl RlpStream {
|
||||
/// Initializes instance of empty `Stream`.
|
||||
pub fn new() -> Self {
|
||||
RlpStream {
|
||||
unfinished_lists: ElasticArray16::new(),
|
||||
buffer: ElasticArray1024::new(),
|
||||
finished_list: false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Initializes the `Stream` as a list.
|
||||
pub fn new_list(len: usize) -> Self {
|
||||
let mut stream = RlpStream::new();
|
||||
stream.begin_list(len);
|
||||
stream
|
||||
}
|
||||
|
||||
/// Appends value to the end of stream, chainable.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate rlp;
|
||||
/// use rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.append(&"cat").append(&"dog");
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);
|
||||
/// }
|
||||
/// ```
|
||||
pub fn append<'a, E>(&'a mut self, value: &E) -> &'a mut Self where E: Encodable {
|
||||
self.finished_list = false;
|
||||
value.rlp_append(self);
|
||||
if !self.finished_list {
|
||||
self.note_appended(1);
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
/// Appends list of values to the end of stream, chainable.
|
||||
pub fn append_list<'a, E, K>(&'a mut self, values: &[K]) -> &'a mut Self where E: Encodable, K: Borrow<E> {
|
||||
self.begin_list(values.len());
|
||||
for value in values {
|
||||
self.append(value.borrow());
|
||||
}
|
||||
self
|
||||
}
|
||||
|
||||
/// Appends value to the end of stream, but do not count it as an appended item.
|
||||
/// It's useful for wrapper types
|
||||
pub fn append_internal<'a, E>(&'a mut self, value: &E) -> &'a mut Self where E: Encodable {
|
||||
value.rlp_append(self);
|
||||
self
|
||||
}
|
||||
|
||||
/// Declare appending the list of given size, chainable.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate rlp;
|
||||
/// use rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.begin_list(2).append(&"cat").append(&"dog");
|
||||
/// stream.append(&"");
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xca, 0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g', 0x80]);
|
||||
/// }
|
||||
/// ```
|
||||
pub fn begin_list(&mut self, len: usize) -> &mut RlpStream {
|
||||
self.finished_list = false;
|
||||
match len {
|
||||
0 => {
|
||||
// we may finish, if the appended list len is equal 0
|
||||
self.buffer.push(0xc0u8);
|
||||
self.note_appended(1);
|
||||
self.finished_list = true;
|
||||
},
|
||||
_ => {
|
||||
// payload is longer than 1 byte only for lists > 55 bytes
|
||||
// by pushing always this 1 byte we may avoid unnecessary shift of data
|
||||
self.buffer.push(0);
|
||||
|
||||
let position = self.buffer.len();
|
||||
self.unfinished_lists.push(ListInfo::new(position, len));
|
||||
},
|
||||
}
|
||||
|
||||
// return chainable self
|
||||
self
|
||||
}
|
||||
|
||||
/// Apends null to the end of stream, chainable.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate rlp;
|
||||
/// use rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.append_empty_data().append_empty_data();
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xc2, 0x80, 0x80]);
|
||||
/// }
|
||||
/// ```
|
||||
pub fn append_empty_data(&mut self) -> &mut RlpStream {
|
||||
// self push raw item
|
||||
self.buffer.push(0x80);
|
||||
|
||||
// try to finish and prepend the length
|
||||
self.note_appended(1);
|
||||
|
||||
// return chainable self
|
||||
self
|
||||
}
|
||||
|
||||
/// Appends raw (pre-serialised) RLP data. Use with caution. Chainable.
|
||||
pub fn append_raw<'a>(&'a mut self, bytes: &[u8], item_count: usize) -> &'a mut RlpStream {
|
||||
// push raw items
|
||||
self.buffer.append_slice(bytes);
|
||||
|
||||
// try to finish and prepend the length
|
||||
self.note_appended(item_count);
|
||||
|
||||
// return chainable self
|
||||
self
|
||||
}
|
||||
|
||||
/// Clear the output stream so far.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate rlp;
|
||||
/// use rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(3);
|
||||
/// stream.append(&"cat");
|
||||
/// stream.clear();
|
||||
/// stream.append(&"dog");
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0x83, b'd', b'o', b'g']);
|
||||
/// }
|
||||
pub fn clear(&mut self) {
|
||||
// clear bytes
|
||||
self.buffer.clear();
|
||||
|
||||
// clear lists
|
||||
self.unfinished_lists.clear();
|
||||
}
|
||||
|
||||
/// Returns true if stream doesnt expect any more items.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate rlp;
|
||||
/// use rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.append(&"cat");
|
||||
/// assert_eq!(stream.is_finished(), false);
|
||||
/// stream.append(&"dog");
|
||||
/// assert_eq!(stream.is_finished(), true);
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);
|
||||
/// }
|
||||
pub fn is_finished(&self) -> bool {
|
||||
self.unfinished_lists.len() == 0
|
||||
}
|
||||
|
||||
/// Get raw encoded bytes
|
||||
pub fn as_raw(&self) -> &[u8] {
|
||||
//&self.encoder.bytes
|
||||
&self.buffer
|
||||
}
|
||||
|
||||
/// Streams out encoded bytes.
|
||||
///
|
||||
/// panic! if stream is not finished.
|
||||
pub fn out(self) -> Vec<u8> {
|
||||
match self.is_finished() {
|
||||
//true => self.encoder.out().to_vec(),
|
||||
true => self.buffer.to_vec(),
|
||||
false => panic!()
|
||||
}
|
||||
}
|
||||
|
||||
/// Try to finish lists
|
||||
fn note_appended(&mut self, inserted_items: usize) -> () {
|
||||
if self.unfinished_lists.len() == 0 {
|
||||
return;
|
||||
}
|
||||
|
||||
let back = self.unfinished_lists.len() - 1;
|
||||
let should_finish = match self.unfinished_lists.get_mut(back) {
|
||||
None => false,
|
||||
Some(ref mut x) => {
|
||||
x.current += inserted_items;
|
||||
if x.current > x.max {
|
||||
panic!("You cannot append more items then you expect!");
|
||||
}
|
||||
x.current == x.max
|
||||
}
|
||||
};
|
||||
|
||||
if should_finish {
|
||||
let x = self.unfinished_lists.pop().unwrap();
|
||||
let len = self.buffer.len() - x.position;
|
||||
self.encoder().insert_list_payload(len, x.position);
|
||||
self.note_appended(1);
|
||||
}
|
||||
self.finished_list = should_finish;
|
||||
}
|
||||
|
||||
pub fn encoder(&mut self) -> BasicEncoder {
|
||||
BasicEncoder::new(self)
|
||||
}
|
||||
|
||||
/// Drain the object and return the underlying ElasticArray.
|
||||
pub fn drain(self) -> ElasticArray1024<u8> {
|
||||
match self.is_finished() {
|
||||
true => self.buffer,
|
||||
false => panic!()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct BasicEncoder<'a> {
|
||||
buffer: &'a mut ElasticArray1024<u8>,
|
||||
}
|
||||
|
||||
impl<'a> BasicEncoder<'a> {
|
||||
fn new(stream: &'a mut RlpStream) -> Self {
|
||||
BasicEncoder {
|
||||
buffer: &mut stream.buffer
|
||||
}
|
||||
}
|
||||
|
||||
fn insert_size(&mut self, size: usize, position: usize) -> u8 {
|
||||
let size = size as u32;
|
||||
let leading_empty_bytes = size.leading_zeros() as usize / 8;
|
||||
let size_bytes = 4 - leading_empty_bytes as u8;
|
||||
let mut buffer = [0u8; 4];
|
||||
BigEndian::write_u32(&mut buffer, size);
|
||||
self.buffer.insert_slice(position, &buffer[leading_empty_bytes..]);
|
||||
size_bytes as u8
|
||||
}
|
||||
|
||||
/// Inserts list prefix at given position
|
||||
fn insert_list_payload(&mut self, len: usize, pos: usize) {
|
||||
// 1 byte was already reserved for payload earlier
|
||||
match len {
|
||||
0...55 => {
|
||||
self.buffer[pos - 1] = 0xc0u8 + len as u8;
|
||||
},
|
||||
_ => {
|
||||
let inserted_bytes = self.insert_size(len, pos);
|
||||
self.buffer[pos - 1] = 0xf7u8 + inserted_bytes;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Pushes encoded value to the end of buffer
|
||||
pub fn encode_value(&mut self, value: &[u8]) {
|
||||
match value.len() {
|
||||
// just 0
|
||||
0 => self.buffer.push(0x80u8),
|
||||
// byte is its own encoding if < 0x80
|
||||
1 if value[0] < 0x80 => self.buffer.push(value[0]),
|
||||
// (prefix + length), followed by the string
|
||||
len @ 1 ... 55 => {
|
||||
self.buffer.push(0x80u8 + len as u8);
|
||||
self.buffer.append_slice(value);
|
||||
}
|
||||
// (prefix + length of length), followed by the length, followd by the string
|
||||
len => {
|
||||
self.buffer.push(0);
|
||||
let position = self.buffer.len();
|
||||
let inserted_bytes = self.insert_size(len, position);
|
||||
self.buffer[position - 1] = 0xb7 + inserted_bytes;
|
||||
self.buffer.append_slice(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -15,9 +15,8 @@
|
||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
use std::{fmt, cmp};
|
||||
use std::str::FromStr;
|
||||
use ::{Encodable, RlpDecodable, UntrustedRlp, RlpStream, View, Stream, DecoderError};
|
||||
use bigint::prelude::U256;
|
||||
use {Encodable, RlpDecodable, UntrustedRlp, RlpStream, View, DecoderError};
|
||||
|
||||
#[test]
|
||||
fn rlp_at() {
|
||||
@ -95,6 +94,17 @@ fn run_encode_tests<T>(tests: Vec<ETestPair<T>>)
|
||||
}
|
||||
}
|
||||
|
||||
struct VETestPair<T>(Vec<T>, Vec<u8>) where T: Encodable;
|
||||
|
||||
fn run_encode_tests_list<T>(tests: Vec<VETestPair<T>>)
|
||||
where T: Encodable
|
||||
{
|
||||
for t in &tests {
|
||||
let res = super::encode_list(&t.0);
|
||||
assert_eq!(&res[..], &t.1[..]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_u16() {
|
||||
let tests = vec![
|
||||
@ -131,9 +141,8 @@ fn encode_u256() {
|
||||
ETestPair(U256::from(0x1000000u64), vec![0x84, 0x01, 0x00, 0x00, 0x00]),
|
||||
ETestPair(U256::from(0xffffffffu64),
|
||||
vec![0x84, 0xff, 0xff, 0xff, 0xff]),
|
||||
ETestPair(U256::from_str("8090a0b0c0d0e0f00910203040506077000000000000\
|
||||
000100000000000012f0")
|
||||
.unwrap(),
|
||||
ETestPair(("8090a0b0c0d0e0f00910203040506077000000000000\
|
||||
000100000000000012f0").into(),
|
||||
vec![0xa0, 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,
|
||||
0x09, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x77, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
|
||||
@ -186,19 +195,19 @@ fn encode_vector_u8() {
|
||||
#[test]
|
||||
fn encode_vector_u64() {
|
||||
let tests = vec![
|
||||
ETestPair(vec![], vec![0xc0]),
|
||||
ETestPair(vec![15u64], vec![0xc1, 0x0f]),
|
||||
ETestPair(vec![1, 2, 3, 7, 0xff], vec![0xc6, 1, 2, 3, 7, 0x81, 0xff]),
|
||||
ETestPair(vec![0xffffffff, 1, 2, 3, 7, 0xff], vec![0xcb, 0x84, 0xff, 0xff, 0xff, 0xff, 1, 2, 3, 7, 0x81, 0xff]),
|
||||
VETestPair(vec![], vec![0xc0]),
|
||||
VETestPair(vec![15u64], vec![0xc1, 0x0f]),
|
||||
VETestPair(vec![1, 2, 3, 7, 0xff], vec![0xc6, 1, 2, 3, 7, 0x81, 0xff]),
|
||||
VETestPair(vec![0xffffffff, 1, 2, 3, 7, 0xff], vec![0xcb, 0x84, 0xff, 0xff, 0xff, 0xff, 1, 2, 3, 7, 0x81, 0xff]),
|
||||
];
|
||||
run_encode_tests(tests);
|
||||
run_encode_tests_list(tests);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encode_vector_str() {
|
||||
let tests = vec![ETestPair(vec!["cat", "dog"],
|
||||
let tests = vec![VETestPair(vec!["cat", "dog"],
|
||||
vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g'])];
|
||||
run_encode_tests(tests);
|
||||
run_encode_tests_list(tests);
|
||||
}
|
||||
|
||||
struct DTestPair<T>(T, Vec<u8>) where T: RlpDecodable + fmt::Debug + cmp::Eq;
|
||||
@ -265,9 +274,8 @@ fn decode_untrusted_u256() {
|
||||
DTestPair(U256::from(0x1000000u64), vec![0x84, 0x01, 0x00, 0x00, 0x00]),
|
||||
DTestPair(U256::from(0xffffffffu64),
|
||||
vec![0x84, 0xff, 0xff, 0xff, 0xff]),
|
||||
DTestPair(U256::from_str("8090a0b0c0d0e0f00910203040506077000000000000\
|
||||
000100000000000012f0")
|
||||
.unwrap(),
|
||||
DTestPair(("8090a0b0c0d0e0f00910203040506077000000000000\
|
||||
000100000000000012f0").into(),
|
||||
vec![0xa0, 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,
|
||||
0x09, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x77, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
|
||||
@ -335,7 +343,7 @@ fn decode_untrusted_vector_of_vectors_str() {
|
||||
#[test]
|
||||
fn test_decoding_array() {
|
||||
let v = vec![5u16, 2u16];
|
||||
let res = super::encode(&v);
|
||||
let res = super::encode_list(&v);
|
||||
let arr: [u16; 2] = super::decode(&res);
|
||||
assert_eq!(arr[0], 5);
|
||||
assert_eq!(arr[1], 2);
|
||||
@ -396,7 +404,7 @@ fn test_rlp_2bytes_data_length_check()
|
||||
#[test]
|
||||
fn test_rlp_nested_empty_list_encode() {
|
||||
let mut stream = RlpStream::new_list(2);
|
||||
stream.append(&(Vec::new() as Vec<u32>));
|
||||
stream.append_list(&(Vec::new() as Vec<u32>));
|
||||
stream.append(&40u32);
|
||||
assert_eq!(stream.drain()[..], [0xc2u8, 0xc0u8, 40u8][..]);
|
||||
}
|
||||
|
||||
@ -15,11 +15,9 @@
|
||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
//! Common RLP traits
|
||||
use ::{DecoderError, UntrustedRlp};
|
||||
use bytes::VecLike;
|
||||
use rlpstream::RlpStream;
|
||||
|
||||
use elastic_array::ElasticArray1024;
|
||||
use stream::RlpStream;
|
||||
use {DecoderError, UntrustedRlp};
|
||||
|
||||
/// Type is able to decode RLP.
|
||||
pub trait Decoder: Sized {
|
||||
@ -226,23 +224,7 @@ pub trait View<'a, 'view>: Sized {
|
||||
fn val_at<T>(&self, index: usize) -> Result<T, DecoderError> where T: RlpDecodable;
|
||||
}
|
||||
|
||||
/// Raw RLP encoder
|
||||
pub trait Encoder {
|
||||
/// Write a value represented as bytes
|
||||
fn emit_value<E: ByteEncodable>(&mut self, value: &E);
|
||||
/// Write raw preencoded data to the output
|
||||
fn emit_raw(&mut self, bytes: &[u8]) -> ();
|
||||
}
|
||||
|
||||
/// Primitive data type encodable to RLP
|
||||
pub trait ByteEncodable {
|
||||
/// Serialize this object to given byte container
|
||||
fn to_bytes<V: VecLike<u8>>(&self, out: &mut V);
|
||||
/// Get size of serialised data in bytes
|
||||
fn bytes_len(&self) -> usize;
|
||||
}
|
||||
|
||||
/// Structure encodable to RLP. Implement this trait for
|
||||
/// Structure encodable to RLP
|
||||
pub trait Encodable {
|
||||
/// Append a value to the stream
|
||||
fn rlp_append(&self, s: &mut RlpStream);
|
||||
@ -255,112 +237,6 @@ pub trait Encodable {
|
||||
}
|
||||
}
|
||||
|
||||
/// Encodable wrapper trait required to handle special case of encoding a &[u8] as string and not as list
|
||||
pub trait RlpEncodable {
|
||||
/// Append a value to the stream
|
||||
fn rlp_append(&self, s: &mut RlpStream);
|
||||
}
|
||||
|
||||
/// RLP encoding stream
|
||||
pub trait Stream: Sized {
|
||||
|
||||
/// Initializes instance of empty `Stream`.
|
||||
fn new() -> Self;
|
||||
|
||||
/// Initializes the `Stream` as a list.
|
||||
fn new_list(len: usize) -> Self;
|
||||
|
||||
/// Apends value to the end of stream, chainable.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate rlp;
|
||||
/// use rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.append(&"cat").append(&"dog");
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);
|
||||
/// }
|
||||
/// ```
|
||||
fn append<'a, E>(&'a mut self, value: &E) -> &'a mut Self where E: RlpEncodable;
|
||||
|
||||
/// Declare appending the list of given size, chainable.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate rlp;
|
||||
/// use rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.begin_list(2).append(&"cat").append(&"dog");
|
||||
/// stream.append(&"");
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xca, 0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g', 0x80]);
|
||||
/// }
|
||||
/// ```
|
||||
fn begin_list(&mut self, len: usize) -> &mut Self;
|
||||
|
||||
/// Apends null to the end of stream, chainable.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate rlp;
|
||||
/// use rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.append_empty_data().append_empty_data();
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xc2, 0x80, 0x80]);
|
||||
/// }
|
||||
/// ```
|
||||
fn append_empty_data(&mut self) -> &mut Self;
|
||||
|
||||
/// Appends raw (pre-serialised) RLP data. Use with caution. Chainable.
|
||||
fn append_raw<'a>(&'a mut self, bytes: &[u8], item_count: usize) -> &'a mut Self;
|
||||
|
||||
/// Clear the output stream so far.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate rlp;
|
||||
/// use rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(3);
|
||||
/// stream.append(&"cat");
|
||||
/// stream.clear();
|
||||
/// stream.append(&"dog");
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0x83, b'd', b'o', b'g']);
|
||||
/// }
|
||||
fn clear(&mut self);
|
||||
|
||||
/// Returns true if stream doesnt expect any more items.
|
||||
///
|
||||
/// ```rust
|
||||
/// extern crate rlp;
|
||||
/// use rlp::*;
|
||||
///
|
||||
/// fn main () {
|
||||
/// let mut stream = RlpStream::new_list(2);
|
||||
/// stream.append(&"cat");
|
||||
/// assert_eq!(stream.is_finished(), false);
|
||||
/// stream.append(&"dog");
|
||||
/// assert_eq!(stream.is_finished(), true);
|
||||
/// let out = stream.out();
|
||||
/// assert_eq!(out, vec![0xc8, 0x83, b'c', b'a', b't', 0x83, b'd', b'o', b'g']);
|
||||
/// }
|
||||
fn is_finished(&self) -> bool;
|
||||
|
||||
/// Get raw encoded bytes
|
||||
fn as_raw(&self) -> &[u8];
|
||||
|
||||
/// Streams out encoded bytes.
|
||||
///
|
||||
/// panic! if stream is not finished.
|
||||
fn out(self) -> Vec<u8>;
|
||||
}
|
||||
|
||||
/// Trait for compressing and decompressing RLP by replacement of common terms.
|
||||
pub trait Compressible: Sized {
|
||||
/// Indicates the origin of RLP to be compressed.
|
||||
@ -427,7 +427,7 @@ impl JournalDB for EarlyMergeDB {
|
||||
|
||||
r.begin_list(inserts.len());
|
||||
inserts.iter().foreach(|&(k, _)| {r.append(&k);});
|
||||
r.append(&removes);
|
||||
r.append_list(&removes);
|
||||
Self::insert_keys(&inserts, &*self.backing, self.column, &mut refs, batch, trace);
|
||||
|
||||
let ins = inserts.iter().map(|&(k, _)| k).collect::<Vec<_>>();
|
||||
|
||||
@ -278,7 +278,7 @@ impl JournalDB for OverlayRecentDB {
|
||||
|
||||
journal_overlay.backing_overlay.emplace(short_key, v);
|
||||
}
|
||||
r.append(&removed_keys);
|
||||
r.append_list(&removed_keys);
|
||||
|
||||
let mut k = RlpStream::new_list(3);
|
||||
let index = journal_overlay.journal.get(&now).map_or(0, |j| j.len());
|
||||
|
||||
@ -136,8 +136,8 @@ impl JournalDB for RefCountedDB {
|
||||
|
||||
let mut r = RlpStream::new_list(3);
|
||||
r.append(id);
|
||||
r.append(&self.inserts);
|
||||
r.append(&self.removes);
|
||||
r.append_list(&self.inserts);
|
||||
r.append_list(&self.removes);
|
||||
batch.put(self.column, &last, r.as_raw());
|
||||
|
||||
let ops = self.inserts.len() + self.removes.len();
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
//! Diff misc.
|
||||
|
||||
use common::*;
|
||||
use rlp::{Stream, RlpStream};
|
||||
use rlp::RlpStream;
|
||||
use target_info::Target;
|
||||
|
||||
include!(concat!(env!("OUT_DIR"), "/version.rs"));
|
||||
|
||||
@ -24,7 +24,7 @@ use super::node::NodeKey;
|
||||
use ::{HashDB, H256};
|
||||
use ::bytes::ToPretty;
|
||||
use ::nibbleslice::NibbleSlice;
|
||||
use ::rlp::{Rlp, RlpStream, View, Stream};
|
||||
use ::rlp::{Rlp, RlpStream, View};
|
||||
use ::sha3::SHA3_NULL_RLP;
|
||||
use hashdb::DBValue;
|
||||
|
||||
@ -931,7 +931,6 @@ impl<'a> Drop for TrieDBMut<'a> {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use triehash::trie_root;
|
||||
use hash::*;
|
||||
use hashdb::*;
|
||||
use memorydb::*;
|
||||
use super::*;
|
||||
|
||||
@ -23,7 +23,7 @@ use std::cmp;
|
||||
use hash::*;
|
||||
use sha3::*;
|
||||
use rlp;
|
||||
use rlp::{RlpStream, Stream};
|
||||
use rlp::RlpStream;
|
||||
use vector::SharedPrefix;
|
||||
|
||||
/// Generates a trie root hash for a vector of values
|
||||
|
||||
Loading…
Reference in New Issue
Block a user