grassrootseconomics/openethereum
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

util reexports less std

Browse Source
This commit is contained in:
debris 2017-07-29 17:12:07 +02:00
parent e84f308264
commit eecd823d32
74 changed files with 255 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
Cargo.lock generated
View File

@ -181,6 +181,14 @@ name = "blastfig"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "bloomable"
version = "0.1.0"
dependencies = [
"ethcore-bigint 0.1.3",
"tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "bloomchain"
version = "0.1.0"
@ -271,6 +279,7 @@ dependencies = [
name = "common-types"
version = "0.1.0"
dependencies = [
"bloomable 0.1.0",
"ethcore-util 1.8.0",
"ethjson 0.1.0",
"rlp 0.2.0",
@ -462,6 +471,7 @@ name = "ethcore"
version = "1.8.0"
dependencies = [
"bit-set 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"bloomable 0.1.0",
"bloomchain 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"bn 0.4.4 (git+https://github.com/paritytech/bn)",
"byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -502,8 +512,10 @@ dependencies = [
"rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"semver 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
"stats 0.1.0",
"table 0.1.0",
"time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
"transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"using_queue 0.1.0",
]
[[package]]
@ -751,11 +763,9 @@ dependencies = [
"rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"sha3 0.1.0",
"table 0.1.0",
"target_info 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
"tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"using_queue 0.1.0",
"vergen 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]

3
ethcore/Cargo.toml
View File

@ -53,6 +53,9 @@ semver = "0.6"
stats = { path = "../util/stats" }
time = "0.1"
transient-hashmap = "0.4"
using_queue = { path = "../util/using_queue" }
table = { path = "../util/table" }
bloomable = { path = "../util/bloomable" }
[dev-dependencies]
native-contracts = { path = "native_contracts", features = ["test_contracts"] }

3
ethcore/evm/src/interpreter/gasometer.rs
View File

@ -14,6 +14,7 @@
// 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::cmp;
use util::*;
use super::u256_to_address;
@ -82,7 +83,7 @@ impl<Gas: evm::CostType> Gasometer<Gas> {
};
if let Some(Ok(r)) = requested {
Ok(min(r, max_gas_provided))
Ok(cmp::min(r, max_gas_provided))
} else {
Ok(max_gas_provided)
}

3
ethcore/evm/src/interpreter/mod.rs
View File

@ -23,12 +23,13 @@ mod stack;
mod memory;
mod shared_cache;
use std::marker::PhantomData;
use std::{cmp, mem};
use self::gasometer::Gasometer;
use self::stack::{Stack, VecStack};
use self::memory::Memory;
pub use self::shared_cache::SharedCache;
use std::marker::PhantomData;
use action_params::{ActionParams, ActionValue};
use call_type::CallType;
use instructions::{self, Instruction, InstructionInfo};

2
ethcore/evm/src/tests.rs
View File

@ -15,6 +15,8 @@
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
use std::fmt::Debug;
use std::str::FromStr;
use std::collections::{HashMap, HashSet};
use rustc_hex::FromHex;
use util::*;
use action_params::{ActionParams, ActionValue};

1
ethcore/src/account_db.rs
View File

@ -15,6 +15,7 @@
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
//! DB backend wrapper for Account trie
use std::collections::HashMap;
use util::*;
use rlp::NULL_RLP;

2
ethcore/src/blockchain/blockchain.rs
View File

@ -16,6 +16,8 @@
//! Blockchain database.
use std::collections::{HashMap, HashSet};
use std::mem;
use bloomchain as bc;
use util::*;
use rlp::*;

9
ethcore/src/blockchain/extras.rs
View File

@ -16,6 +16,8 @@
//! Blockchain DB extras.
use std::ops;
use std::io::Write;
use bloomchain;
use blooms::{GroupPosition, BloomGroup};
use db::Key;
@ -56,7 +58,7 @@ fn with_index(hash: &H256, i: ExtrasIndex) -> H264 {
pub struct BlockNumberKey([u8; 5]);
impl Deref for BlockNumberKey {
impl ops::Deref for BlockNumberKey {
type Target = [u8];
fn deref(&self) -> &Self::Target {
@ -88,7 +90,7 @@ impl Key<BlockDetails> for H256 {
pub struct LogGroupKey([u8; 6]);
impl Deref for LogGroupKey {
impl ops::Deref for LogGroupKey {
type Target = [u8];
fn deref(&self) -> &Self::Target {
@ -160,7 +162,8 @@ pub const EPOCH_KEY_PREFIX: &'static [u8; DB_PREFIX_LEN] = &[
];
pub struct EpochTransitionsKey([u8; EPOCH_KEY_LEN]);
impl Deref for EpochTransitionsKey {
impl ops::Deref for EpochTransitionsKey {
type Target = [u8];
fn deref(&self) -> &[u8] { &self.0[..] }

2
ethcore/src/client/test_client.rs
View File

@ -17,6 +17,8 @@
//! Test client.
use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder};
use std::collections::{HashMap, BTreeMap};
use std::mem;
use rustc_hex::FromHex;
use util::*;
use rlp::*;

9
ethcore/src/engines/authority_round/mod.rs
View File

@ -19,6 +19,8 @@
use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering as AtomicOrdering};
use std::sync::Weak;
use std::time::{UNIX_EPOCH, Duration};
use std::collections::{BTreeMap, HashSet, HashMap};
use std::cmp;
use account_provider::AccountProvider;
use block::*;
@ -463,9 +465,9 @@ impl Engine for AuthorityRound {
let gas_limit = parent.gas_limit().clone();
let bound_divisor = self.gas_limit_bound_divisor;
if gas_limit < gas_floor_target {
min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
cmp::min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
} else {
max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
cmp::max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
}
});
}
@ -815,7 +817,7 @@ impl Engine for AuthorityRound {
}
}
fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> result::Result<(), Error> {
fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> Result<(), Error> {
t.check_low_s()?;
if let Some(n) = t.network_id() {
@ -852,6 +854,7 @@ impl Engine for AuthorityRound {
#[cfg(test)]
mod tests {
use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
use std::str::FromStr;
use util::*;
use header::Header;
use error::{Error, BlockError};

12
ethcore/src/engines/basic_authority.rs
View File

@ -17,6 +17,8 @@
//! A blockchain engine that supports a basic, non-BFT proof-of-authority.
use std::sync::Weak;
use std::collections::BTreeMap;
use std::cmp;
use util::*;
use ethkey::{recover, public_to_address, Signature};
use account_provider::AccountProvider;
@ -121,9 +123,9 @@ impl Engine for BasicAuthority {
let gas_limit = parent.gas_limit().clone();
let bound_divisor = self.gas_limit_bound_divisor;
if gas_limit < gas_floor_target {
min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
cmp::min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
} else {
max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
cmp::max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
}
});
}
@ -147,7 +149,7 @@ impl Engine for BasicAuthority {
Seal::None
}
fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
// check the seal fields.
// TODO: pull this out into common code.
if header.seal().len() != self.seal_fields() {
@ -158,11 +160,11 @@ impl Engine for BasicAuthority {
Ok(())
}
fn verify_block_unordered(&self, _header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
fn verify_block_unordered(&self, _header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
Ok(())
}
fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
// Do not calculate difficulty for genesis blocks.
if header.number() == 0 {
return Err(From::from(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() })));

4
ethcore/src/engines/instant_seal.rs
View File

@ -14,8 +14,8 @@
// 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::collections::BTreeMap;
use util::{Address, HashMap};
use std::collections::{BTreeMap, HashMap};
use util::Address;
use builtin::Builtin;
use engines::{Engine, Seal};
use spec::CommonParams;

2
ethcore/src/engines/mod.rs
View File

@ -36,6 +36,8 @@ pub use self::null_engine::NullEngine;
pub use self::tendermint::Tendermint;
use std::sync::Weak;
use std::collections::{BTreeMap, HashMap};
use std::fmt;
use self::epoch::PendingTransition;

5
ethcore/src/engines/tendermint/message.rs
View File

@ -16,6 +16,7 @@
//! Tendermint message handling.
use std::cmp;
use util::*;
use super::{Height, View, BlockHash, Step};
use error::Error;
@ -110,13 +111,13 @@ impl Default for VoteStep {
}
impl PartialOrd for VoteStep {
fn partial_cmp(&self, m: &VoteStep) -> Option<Ordering> {
fn partial_cmp(&self, m: &VoteStep) -> Option<cmp::Ordering> {
Some(self.cmp(m))
}
}
impl Ord for VoteStep {
fn cmp(&self, m: &VoteStep) -> Ordering {
fn cmp(&self, m: &VoteStep) -> cmp::Ordering {
if self.height != m.height {
self.height.cmp(&m.height)
} else if self.view != m.view {

7
ethcore/src/engines/tendermint/mod.rs
View File

@ -27,6 +27,8 @@ mod params;
use std::sync::Weak;
use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
use std::collections::{HashSet, BTreeMap, HashMap};
use std::cmp;
use util::*;
use client::{Client, EngineClient};
use error::{Error, BlockError};
@ -473,9 +475,9 @@ impl Engine for Tendermint {
let gas_limit = parent.gas_limit().clone();
let bound_divisor = self.gas_limit_bound_divisor;
if gas_limit < gas_floor_target {
min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
cmp::min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
} else {
max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
cmp::max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
}
});
}
@ -771,6 +773,7 @@ impl Engine for Tendermint {
#[cfg(test)]
mod tests {
use std::str::FromStr;
use rustc_hex::FromHex;
use util::*;
use block::*;

8
ethcore/src/engines/validator_set/contract.rs
View File

@ -142,11 +142,11 @@ mod tests {
#[test]
fn fetches_validators() {
let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_contract, None);
let vc = Arc::new(ValidatorContract::new(Address::from_str("0000000000000000000000000000000000000005").unwrap()));
let vc = Arc::new(ValidatorContract::new("0000000000000000000000000000000000000005".parse::<Address>().unwrap()));
vc.register_contract(Arc::downgrade(&client));
let last_hash = client.best_block_header().hash();
assert!(vc.contains(&last_hash, &Address::from_str("7d577a597b2742b498cb5cf0c26cdcd726d39e6e").unwrap()));
assert!(vc.contains(&last_hash, &Address::from_str("82a978b3f5962a5b0957d9ee9eef472ee55b42f1").unwrap()));
assert!(vc.contains(&last_hash, &"7d577a597b2742b498cb5cf0c26cdcd726d39e6e".parse::<Address>().unwrap()));
assert!(vc.contains(&last_hash, &"82a978b3f5962a5b0957d9ee9eef472ee55b42f1".parse::<Address>().unwrap()));
}
#[test]
@ -155,7 +155,7 @@ mod tests {
let v1 = tap.insert_account("1".sha3().into(), "").unwrap();
let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_contract, Some(tap.clone()));
client.engine().register_client(Arc::downgrade(&client));
let validator_contract = Address::from_str("0000000000000000000000000000000000000005").unwrap();
let validator_contract = "0000000000000000000000000000000000000005".parse::<Address>().unwrap();
// Make sure reporting can be done.
client.miner().set_gas_floor_target(1_000_000.into());

1
ethcore/src/engines/validator_set/multi.rs
View File

@ -142,6 +142,7 @@ impl ValidatorSet for Multi {
#[cfg(test)]
mod tests {
use std::collections::BTreeMap;
use account_provider::AccountProvider;
use client::{BlockChainClient, EngineClient};
use engines::EpochChange;

10
ethcore/src/engines/validator_set/safe_contract.rs
View File

@ -438,11 +438,11 @@ mod tests {
#[test]
fn fetches_validators() {
let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, None);
let vc = Arc::new(ValidatorSafeContract::new(Address::from_str("0000000000000000000000000000000000000005").unwrap()));
let vc = Arc::new(ValidatorSafeContract::new("0000000000000000000000000000000000000005".parse::<Address>().unwrap()));
vc.register_contract(Arc::downgrade(&client));
let last_hash = client.best_block_header().hash();
assert!(vc.contains(&last_hash, &Address::from_str("7d577a597b2742b498cb5cf0c26cdcd726d39e6e").unwrap()));
assert!(vc.contains(&last_hash, &Address::from_str("82a978b3f5962a5b0957d9ee9eef472ee55b42f1").unwrap()));
assert!(vc.contains(&last_hash, &"7d577a597b2742b498cb5cf0c26cdcd726d39e6e".parse::<Address>().unwrap()));
assert!(vc.contains(&last_hash, &"82a978b3f5962a5b0957d9ee9eef472ee55b42f1".parse::<Address>().unwrap()));
}
#[test]
@ -454,7 +454,7 @@ mod tests {
let network_id = Spec::new_validator_safe_contract().network_id();
let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, Some(tap));
client.engine().register_client(Arc::downgrade(&client));
let validator_contract = Address::from_str("0000000000000000000000000000000000000005").unwrap();
let validator_contract = "0000000000000000000000000000000000000005".parse::<Address>().unwrap();
client.miner().set_engine_signer(v1, "".into()).unwrap();
// Remove "1" validator.
@ -520,7 +520,7 @@ mod tests {
let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, None);
let engine = client.engine().clone();
let validator_contract = Address::from_str("0000000000000000000000000000000000000005").unwrap();
let validator_contract = "0000000000000000000000000000000000000005".parse::<Address>().unwrap();
let last_hash = client.best_block_header().hash();
let mut new_header = Header::default();

1
ethcore/src/engines/vote_collector.rs
View File

@ -17,6 +17,7 @@
//! Collects votes on hashes at each Message::Round.
use std::fmt::Debug;
use std::collections::{BTreeMap, HashSet, HashMap};
use util::*;
use rlp::{Encodable, RlpStream};

1
ethcore/src/error.rs
View File

@ -16,6 +16,7 @@
//! General error types for use in ethcore.
use std::fmt;
use util::*;
use io::*;
use header::BlockNumber;

32
ethcore/src/ethereum/ethash.rs
View File

@ -15,6 +15,8 @@
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
use std::path::Path;
use std::cmp;
use std::collections::{BTreeMap, HashMap};
use ethash::{quick_get_difficulty, slow_get_seedhash, EthashManager};
use util::*;
use block::*;
@ -235,15 +237,15 @@ impl Engine for Arc<Ethash> {
let lower_limit = gas_limit - gas_limit / bound_divisor + 1.into();
let upper_limit = gas_limit + gas_limit / bound_divisor - 1.into();
let gas_limit = if gas_limit < gas_floor_target {
let gas_limit = min(gas_floor_target, upper_limit);
let gas_limit = cmp::min(gas_floor_target, upper_limit);
round_block_gas_limit(gas_limit, lower_limit, upper_limit)
} else if gas_limit > gas_ceil_target {
let gas_limit = max(gas_ceil_target, lower_limit);
let gas_limit = cmp::max(gas_ceil_target, lower_limit);
round_block_gas_limit(gas_limit, lower_limit, upper_limit)
} else {
let total_lower_limit = max(lower_limit, gas_floor_target);
let total_upper_limit = min(upper_limit, gas_ceil_target);
let gas_limit = max(gas_floor_target, min(total_upper_limit,
let total_lower_limit = cmp::max(lower_limit, gas_floor_target);
let total_upper_limit = cmp::min(upper_limit, gas_ceil_target);
let gas_limit = cmp::max(gas_floor_target, cmp::min(total_upper_limit,
lower_limit + (header.gas_used().clone() * 6.into() / 5.into()) / bound_divisor));
round_block_gas_limit(gas_limit, total_lower_limit, total_upper_limit)
};
@ -319,7 +321,7 @@ impl Engine for Arc<Ethash> {
Ok(())
}
fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
// check the seal fields.
if header.seal().len() != self.seal_fields() {
return Err(From::from(BlockError::InvalidSealArity(
@ -357,7 +359,7 @@ impl Engine for Arc<Ethash> {
Ok(())
}
fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
if header.seal().len() != self.seal_fields() {
return Err(From::from(BlockError::InvalidSealArity(
Mismatch { expected: self.seal_fields(), found: header.seal().len() }
@ -376,7 +378,7 @@ impl Engine for Arc<Ethash> {
Ok(())
}
fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
// we should not calculate difficulty for genesis blocks
if header.number() == 0 {
return Err(From::from(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() })));
@ -400,7 +402,7 @@ impl Engine for Arc<Ethash> {
Ok(())
}
fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> result::Result<(), Error> {
fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> Result<(), Error> {
if header.number() >= self.ethash_params.min_gas_price_transition && t.gas_price < self.ethash_params.min_gas_price {
return Err(TransactionError::InsufficientGasPrice { minimal: self.ethash_params.min_gas_price, got: t.gas_price }.into());
}
@ -493,28 +495,28 @@ impl Ethash {
if diff_inc <= threshold {
*parent.difficulty() + *parent.difficulty() / difficulty_bound_divisor * (threshold - diff_inc).into()
} else {
let multiplier = min(diff_inc - threshold, 99).into();
let multiplier = cmp::min(diff_inc - threshold, 99).into();
parent.difficulty().saturating_sub(
*parent.difficulty() / difficulty_bound_divisor * multiplier
)
}
};
target = max(min_difficulty, target);
target = cmp::max(min_difficulty, target);
if header.number() < self.ethash_params.bomb_defuse_transition {
if header.number() < self.ethash_params.ecip1010_pause_transition {
let period = ((parent.number() + 1) / EXP_DIFF_PERIOD) as usize;
if period > 1 {
target = max(min_difficulty, target + (U256::from(1) << (period - 2)));
target = cmp::max(min_difficulty, target + (U256::from(1) << (period - 2)));
}
}
else if header.number() < self.ethash_params.ecip1010_continue_transition {
let fixed_difficulty = ((self.ethash_params.ecip1010_pause_transition / EXP_DIFF_PERIOD) - 2) as usize;
target = max(min_difficulty, target + (U256::from(1) << fixed_difficulty));
target = cmp::max(min_difficulty, target + (U256::from(1) << fixed_difficulty));
}
else {
let period = ((parent.number() + 1) / EXP_DIFF_PERIOD) as usize;
let delay = ((self.ethash_params.ecip1010_continue_transition - self.ethash_params.ecip1010_pause_transition) / EXP_DIFF_PERIOD) as usize;
target = max(min_difficulty, target + (U256::from(1) << (period - delay - 2)));
target = cmp::max(min_difficulty, target + (U256::from(1) << (period - delay - 2)));
}
}
target
@ -559,6 +561,8 @@ impl Header {
#[cfg(test)]
mod tests {
use std::str::FromStr;
use std::collections::BTreeMap;
use util::*;
use block::*;
use tests::helpers::*;

6
ethcore/src/executive.rs
View File

@ -15,6 +15,7 @@
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
//! Transaction Execution environment.
use std::cmp;
use util::*;
use evm::action_params::{ActionParams, ActionValue};
use state::{Backend as StateBackend, State, Substate, CleanupMode};
@ -74,7 +75,7 @@ pub struct TransactOptions {
pub check_nonce: bool,
}
pub fn executor<E>(engine: &E, vm_factory: &Factory, params: &ActionParams)
pub fn executor<E>(engine: &E, vm_factory: &Factory, params: &ActionParams)
-> Box<evm::Evm> where E: Engine + ?Sized
{
if engine.supports_wasm() && params.code.as_ref().map_or(false, |code| code.len() > 4 && &code[0..4] == WASM_MAGIC_NUMBER) {
@ -597,10 +598,11 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
#[allow(dead_code)]
mod tests {
use std::sync::Arc;
use std::str::FromStr;
use rustc_hex::FromHex;
use ethkey::{Generator, Random};
use super::*;
use util::{H256, U256, U512, Address, FromStr};
use util::{H256, U256, U512, Address};
use util::bytes::BytesRef;
use evm::action_params::{ActionParams, ActionValue};
use evm::env_info::EnvInfo;

9
ethcore/src/externalities.rs
View File

@ -15,6 +15,7 @@
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
//! Transaction Execution environment.
use std::cmp;
use util::*;
use evm::action_params::{ActionParams, ActionValue};
use state::{Backend as StateBackend, State, Substate, CleanupMode};
@ -470,7 +471,7 @@ mod tests {
let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer, &mut vm_tracer, false);
let hash = ext.blockhash(&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap());
let hash = ext.blockhash(&"0000000000000000000000000000000000000000000000000000000000120000".parse::<U256>().unwrap());
assert_eq!(hash, H256::zero());
}
@ -494,7 +495,7 @@ mod tests {
let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer, &mut vm_tracer, false);
let hash = ext.blockhash(&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap());
let hash = ext.blockhash(&"0000000000000000000000000000000000000000000000000000000000120000".parse::<U256>().unwrap());
assert_eq!(test_hash, hash);
}
@ -513,10 +514,10 @@ mod tests {
// this should panic because we have no balance on any account
ext.call(
&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap(),
&"0000000000000000000000000000000000000000000000000000000000120000".parse::<U256>().unwrap(),
&Address::new(),
&Address::new(),
Some(U256::from_str("0000000000000000000000000000000000000000000000000000000000150000").unwrap()),
Some("0000000000000000000000000000000000000000000000000000000000150000".parse::<U256>().unwrap()),
&[],
&Address::new(),
&mut output,

8
ethcore/src/header.rs
View File

@ -16,13 +16,13 @@
//! Block header.
use std::cmp;
use std::cell::RefCell;
use util::*;
use basic_types::{LogBloom, ZERO_LOGBLOOM};
use time::get_time;
use rlp::*;
use std::cell::RefCell;
pub use basic_types::Seal;
pub use types::BlockNumber;
@ -175,7 +175,7 @@ impl Header {
/// Set the timestamp field of the header.
pub fn set_timestamp(&mut self, a: u64) { self.timestamp = a; self.note_dirty(); }
/// Set the timestamp field of the header to the current time.
pub fn set_timestamp_now(&mut self, but_later_than: u64) { self.timestamp = max(get_time().sec as u64, but_later_than + 1); self.note_dirty(); }
pub fn set_timestamp_now(&mut self, but_later_than: u64) { self.timestamp = cmp::max(get_time().sec as u64, but_later_than + 1); self.note_dirty(); }
/// Set the number field of the header.
pub fn set_number(&mut self, a: BlockNumber) { self.number = a; self.note_dirty(); }
/// Set the author field of the header.
@ -275,7 +275,7 @@ impl Decodable for Header {
number: r.val_at(8)?,
gas_limit: r.val_at(9)?,
gas_used: r.val_at(10)?,
timestamp: min(r.val_at::<U256>(11)?, u64::max_value().into()).as_u64(),
timestamp: cmp::min(r.val_at::<U256>(11)?, u64::max_value().into()).as_u64(),
extra_data: r.val_at(12)?,
seal: vec![],
hash: RefCell::new(Some(r.as_raw().sha3())),

3
ethcore/src/lib.rs
View File

@ -106,6 +106,9 @@ extern crate semver;
extern crate stats;
extern crate time;
extern crate transient_hashmap;
extern crate using_queue;
extern crate table;
extern crate bloomable;
#[macro_use]
extern crate log;

3
ethcore/src/miner/miner.rs
View File

@ -15,9 +15,10 @@
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
use std::time::{Instant, Duration};
use std::collections::{BTreeMap, HashSet};
use util::*;
use util::using_queue::{UsingQueue, GetAction};
use using_queue::{UsingQueue, GetAction};
use account_provider::{AccountProvider, SignError as AccountError};
use state::{State, CleanupMode};
use client::{MiningBlockChainClient, Executive, Executed, EnvInfo, TransactOptions, BlockId, CallAnalytics, TransactionId};

4
ethcore/src/miner/transaction_queue.rs
View File

@ -106,7 +106,7 @@ use std::cmp;
use std::collections::{HashSet, HashMap, BTreeSet, BTreeMap};
use linked_hash_map::LinkedHashMap;
use util::{Address, H256, U256, HeapSizeOf};
use util::table::Table;
use table::Table;
use transaction::*;
use error::{Error, TransactionError};
use client::TransactionImportResult;
@ -1447,7 +1447,7 @@ fn check_if_removed(sender: &Address, nonce: &U256, dropped: Option<HashMap<Addr
#[cfg(test)]
pub mod test {
use rustc_hex::FromHex;
use util::table::*;
use table::Table;
use util::*;
use ethkey::{Random, Generator};
use error::{Error, TransactionError};

1
ethcore/src/miner/work_notify.rs
View File

@ -16,6 +16,7 @@
extern crate hyper;
use std::io::Write;
use hyper::header::ContentType;
use hyper::method::Method;
use hyper::client::{Request, Response, Client};

4
ethcore/src/pod_account.rs
View File

@ -14,6 +14,8 @@
// 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::fmt;
use std::collections::BTreeMap;
use util::*;
use state::Account;
use ethjson;
@ -166,7 +168,7 @@ pub fn diff_pod(pre: Option<&PodAccount>, post: Option<&PodAccount>) -> Option<A
#[cfg(test)]
mod test {
use util::*;
use std::collections::BTreeMap;
use types::account_diff::*;
use super::{PodAccount, diff_pod};

4
ethcore/src/pod_state.rs
View File

@ -16,6 +16,8 @@
//! State of all accounts in the system expressed in Plain Old Data.
use std::fmt;
use std::collections::BTreeMap;
use util::*;
use pod_account::{self, PodAccount};
use types::state_diff::StateDiff;
@ -77,7 +79,7 @@ pub fn diff_pod(pre: &PodState, post: &PodState) -> StateDiff {
#[cfg(test)]
mod test {
use util::*;
use std::collections::BTreeMap;
use types::state_diff::*;
use types::account_diff::*;
use pod_account::PodAccount;

3
ethcore/src/spec/spec.rs
View File

@ -16,6 +16,8 @@
//! Parameters for a block chain.
use std::io::Read;
use std::collections::BTreeMap;
use rustc_hex::FromHex;
use super::genesis::Genesis;
use super::seal::Generic as GenericSeal;
@ -484,6 +486,7 @@ impl Spec {
#[cfg(test)]
mod tests {
use std::str::FromStr;
use util::*;
use views::*;
use tests::helpers::get_temp_state_db;

2
ethcore/src/state/account.rs
View File

@ -16,6 +16,8 @@
//! Single account in the system.
use std::fmt;
use std::collections::HashMap;
use util::*;
use pod_account::*;
use rlp::*;

2
ethcore/src/state/mod.rs
View File

@ -21,6 +21,8 @@
use std::cell::{RefCell, RefMut};
use std::collections::hash_map::Entry;
use std::collections::{HashMap, BTreeMap, HashSet};
use std::fmt;
use receipt::Receipt;
use engines::Engine;

1
ethcore/src/tests/client.rs
View File

@ -14,6 +14,7 @@
// 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::str::FromStr;
use io::IoChannel;
use client::{BlockChainClient, MiningBlockChainClient, Client, ClientConfig, BlockId};
use state::{self, State, CleanupMode};

3
ethcore/src/tests/helpers.rs
View File

@ -14,6 +14,7 @@
// 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::collections::BTreeMap;
use ethkey::KeyPair;
use io::*;
use client::{BlockChainClient, Client, ClientConfig};
@ -347,7 +348,7 @@ pub fn get_good_dummy_block_fork_seq(start_number: usize, count: usize, parent_h
for i in start_number .. start_number + count + 1 {
let mut block_header = Header::new();
block_header.set_gas_limit(test_engine.params().min_gas_limit);
block_header.set_difficulty(U256::from(i).mul(U256([0, 1, 0, 0])));
block_header.set_difficulty(U256::from(i) * U256([0, 1, 0, 0]));
block_header.set_timestamp(rolling_timestamp);
block_header.set_number(i as u64);
block_header.set_parent_hash(parent);

4
ethcore/src/trace/types/filter.rs
View File

@ -20,7 +20,7 @@ use std::ops::Range;
use bloomchain::{Filter as BloomFilter, Bloom, Number};
use util::Address;
use util::sha3::Hashable;
use util::bloom::Bloomable;
use bloomable::Bloomable;
use basic_types::LogBloom;
use trace::flat::FlatTrace;
use super::trace::{Action, Res};
@ -137,7 +137,7 @@ impl Filter {
mod tests {
use util::Address;
use util::sha3::Hashable;
use util::bloom::Bloomable;
use bloomable::Bloomable;
use trace::trace::{Action, Call, Res, Create, CreateResult, Suicide};
use trace::flat::FlatTrace;
use trace::{Filter, AddressesFilter, TraceError};

2
ethcore/src/trace/types/trace.rs
View File

@ -18,7 +18,7 @@
use util::{U256, Bytes, Address};
use util::sha3::Hashable;
use util::bloom::Bloomable;
use bloomable::Bloomable;
use rlp::*;
use evm::action_params::ActionParams;

17
ethcore/src/verification/queue/mod.rs
View File

@ -20,6 +20,8 @@
use std::thread::{self, JoinHandle};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering};
use std::sync::{Condvar as SCondvar, Mutex as SMutex};
use std::cmp;
use std::collections::{VecDeque, HashSet, HashMap};
use util::*;
use io::*;
use error::*;
@ -234,8 +236,8 @@ impl<K: Kind> VerificationQueue<K> {
let scale_verifiers = config.verifier_settings.scale_verifiers;
let num_cpus = ::num_cpus::get();
let max_verifiers = min(num_cpus, MAX_VERIFIERS);
let default_amount = max(1, min(max_verifiers, config.verifier_settings.num_verifiers));
let max_verifiers = cmp::min(num_cpus, MAX_VERIFIERS);
let default_amount = cmp::max(1, cmp::min(max_verifiers, config.verifier_settings.num_verifiers));
let state = Arc::new((Mutex::new(State::Work(default_amount)), Condvar::new()));
let mut verifier_handles = Vec::with_capacity(max_verifiers);
@ -278,8 +280,8 @@ impl<K: Kind> VerificationQueue<K> {
processing: RwLock::new(HashMap::new()),
empty: empty,
ticks_since_adjustment: AtomicUsize::new(0),
max_queue_size: max(config.max_queue_size, MIN_QUEUE_LIMIT),
max_mem_use: max(config.max_mem_use, MIN_MEM_LIMIT),
max_queue_size: cmp::max(config.max_queue_size, MIN_QUEUE_LIMIT),
max_mem_use: cmp::max(config.max_mem_use, MIN_MEM_LIMIT),
scale_verifiers: scale_verifiers,
verifier_handles: verifier_handles,
state: state,
@ -567,7 +569,7 @@ impl<K: Kind> VerificationQueue<K> {
/// Removes up to `max` verified items from the queue
pub fn drain(&self, max: usize) -> Vec<K::Verified> {
let mut verified = self.verification.verified.lock();
let count = min(max, verified.len());
let count = cmp::min(max, verified.len());
let result = verified.drain(..count).collect::<Vec<_>>();
let drained_size = result.iter().map(HeapSizeOf::heap_size_of_children).fold(0, |a, c| a + c);
@ -687,8 +689,8 @@ impl<K: Kind> VerificationQueue<K> {
// or below 1.
fn scale_verifiers(&self, target: usize) {
let current = self.num_verifiers();
let target = min(self.verifier_handles.len(), target);
let target = max(1, target);
let target = cmp::min(self.verifier_handles.len(), target);
let target = cmp::max(1, target);
debug!(target: "verification", "Scaling from {} to {} verifiers", current, target);
@ -725,7 +727,6 @@ impl<K: Kind> Drop for VerificationQueue<K> {
#[cfg(test)]
mod tests {
use util::*;
use io::*;
use spec::*;
use super::{BlockQueue, Config, State};

2
ethcore/src/verification/verification.rs
View File

@ -21,6 +21,7 @@
//! 2. Signatures verification done in the queue.
//! 3. Final verification against the blockchain done before enactment.
use std::collections::HashSet;
use util::*;
use engines::Engine;
use error::{BlockError, Error};
@ -264,6 +265,7 @@ fn verify_block_integrity(block: &[u8], transactions_root: &H256, uncles_hash: &
#[cfg(test)]
mod tests {
use std::collections::{BTreeMap, HashMap};
use util::*;
use ethkey::{Random, Generator};
use header::*;

1
ethcore/types/Cargo.toml
View File

@ -8,6 +8,7 @@ authors = ["Parity Technologies <admin@parity.io>"]
rlp = { path = "../../util/rlp" }
ethcore-util = { path = "../../util" }
ethjson = { path = "../../json" }
bloomable = { path = "../../util/bloomable" }
[dev-dependencies]
rustc-hex= "1.0"

2
ethcore/types/src/filter.rs
View File

@ -17,7 +17,7 @@
//! Blockchain filter
use util::{Address, H256, Hashable, H2048};
use util::bloom::Bloomable;
use bloomable::Bloomable;
use ids::BlockId;
use log_entry::LogEntry;

1
ethcore/types/src/lib.rs
View File

@ -19,6 +19,7 @@
extern crate ethcore_util as util;
extern crate ethjson;
extern crate rlp;
extern crate bloomable;
#[cfg(test)]
extern crate rustc_hex;

6
ethcore/types/src/log_entry.rs
View File

@ -18,7 +18,7 @@
use std::ops::Deref;
use util::{H256, Address, Bytes, HeapSizeOf, Hashable};
use util::bloom::Bloomable;
use bloomable::Bloomable;
use rlp::*;
use {BlockNumber};
@ -114,8 +114,8 @@ mod tests {
#[test]
fn test_empty_log_bloom() {
let bloom = H2048::from_str("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
let bloom = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".parse::<H2048>().unwrap();
let address = "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6".parse::<Address>().unwrap();
let log = LogEntry {
address: address,
topics: vec![],

16
ethkey/cli/src/main.rs
View File

@ -25,7 +25,7 @@ extern crate panic_hook;
use std::{env, fmt, process};
use std::num::ParseIntError;
use docopt::Docopt;
use rustc_hex::{FromHex, FromHexError};
use rustc_hex::{ToHex, FromHex, FromHexError};
use ethkey::{KeyPair, Random, Brain, Prefix, Error as EthkeyError, Generator, sign, verify_public, verify_address};
use std::io;
@ -170,7 +170,7 @@ fn main() {
fn display(keypair: KeyPair, mode: DisplayMode) -> String {
match mode {
DisplayMode::KeyPair => format!("{}", keypair),
DisplayMode::Secret => format!("{:?}", keypair.secret()),
DisplayMode::Secret => format!("{}", keypair.secret().to_hex()),
DisplayMode::Public => format!("{:?}", keypair.public()),
DisplayMode::Address => format!("{:?}", keypair.address()),
}
@ -248,9 +248,9 @@ address: 26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
.collect::<Vec<String>>();
let expected =
"secret: 17d08f5fe8c77af811caa0c9a187e668ce3b74a99acc3f6d976f075fa8e0be55
public: 689268c0ff57a20cd299fa60d3fb374862aff565b20b5f1767906a99e6e09f3ff04ca2b2a5cd22f62941db103c0356df1a8ed20ce322cab2483db67685afd124
address: 26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
"secret: aa22b54c0cb43ee30a014afe5ef3664b1cde299feabca46cd3167a85a57c39f2
public: c4c5398da6843632c123f543d714d2d2277716c11ff612b2a2f23c6bda4d6f0327c31cd58c55a9572c3cc141dade0c32747a13b7ef34c241b26c84adbb28fcf4
address: 006e27b6a72e1f34c626762f3c4761547aff1421".to_owned();
assert_eq!(execute(command).unwrap(), expected);
}
@ -261,7 +261,7 @@ address: 26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
.map(Into::into)
.collect::<Vec<String>>();
let expected = "17d08f5fe8c77af811caa0c9a187e668ce3b74a99acc3f6d976f075fa8e0be55".to_owned();
let expected = "aa22b54c0cb43ee30a014afe5ef3664b1cde299feabca46cd3167a85a57c39f2".to_owned();
assert_eq!(execute(command).unwrap(), expected);
}
@ -272,7 +272,7 @@ address: 26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
.map(Into::into)
.collect::<Vec<String>>();
let expected = "689268c0ff57a20cd299fa60d3fb374862aff565b20b5f1767906a99e6e09f3ff04ca2b2a5cd22f62941db103c0356df1a8ed20ce322cab2483db67685afd124".to_owned();
let expected = "c4c5398da6843632c123f543d714d2d2277716c11ff612b2a2f23c6bda4d6f0327c31cd58c55a9572c3cc141dade0c32747a13b7ef34c241b26c84adbb28fcf4".to_owned();
assert_eq!(execute(command).unwrap(), expected);
}
@ -283,7 +283,7 @@ address: 26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
.map(Into::into)
.collect::<Vec<String>>();
let expected = "26d1ec50b4e62c1d1a40d16e7cacc6a6580757d5".to_owned();
let expected = "006e27b6a72e1f34c626762f3c4761547aff1421".to_owned();
assert_eq!(execute(command).unwrap(), expected);
}

7
ethkey/src/secret.rs
View File

@ -17,6 +17,7 @@
use std::fmt;
use std::ops::Deref;
use std::str::FromStr;
use rustc_hex::ToHex;
use secp256k1::key;
use bigint::hash::H256;
use {Error, SECP256K1};
@ -26,6 +27,12 @@ pub struct Secret {
inner: H256,
}
impl ToHex for Secret {
fn to_hex(&self) -> String {
self.inner.to_hex()
}
}
impl fmt::Debug for Secret {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "Secret: 0x{:x}{:x}..{:x}{:x}", self.inner[0], self.inner[1], self.inner[30], self.inner[31])

3
hash-fetch/src/client.rs
View File

@ -188,8 +188,9 @@ fn random_temp_path() -> PathBuf {
#[cfg(test)]
mod tests {
use rustc_hex::FromHex;
use std::sync::{Arc, mpsc};
use util::{Mutex, FromHex};
use util::Mutex;
use futures::future;
use fetch::{self, Fetch};
use parity_reactor::Remote;

2
ipc/hypervisor/src/lib.rs
View File

@ -260,7 +260,7 @@ mod tests {
let client = nanoipc::fast_client::<HypervisorServiceClient<_>>(url).unwrap();
client.handshake().unwrap();
client.module_ready(test_module_id);
client.module_ready(test_module_id, url.to_owned());
});
let hypervisor = Hypervisor::with_url(url).local_module(test_module_id);

4
ipfs/src/lib.rs
View File

@ -233,7 +233,7 @@ mod tests {
let _ = write_chunk(&mut transport, &mut progress, b"foobar");
assert_eq!(b"foobar".into_vec(), transport);
assert_eq!(b"foobar".to_vec(), transport);
assert_eq!(6, progress);
}
@ -244,7 +244,7 @@ mod tests {
let _ = write_chunk(&mut transport, &mut progress, b"foobar");
assert_eq!(b"bar".into_vec(), transport);
assert_eq!(b"bar".to_vec(), transport);
assert_eq!(6, progress);
}

3
ipfs/src/route.rs
View File

@ -119,7 +119,8 @@ mod tests {
use ethcore::client::TestBlockChainClient;
fn get_mocked_handler() -> IpfsHandler {
IpfsHandler::new(None, None, Arc::new(TestBlockChainClient::new()))
//IpfsHandler::new(None, None, Arc::new(TestBlockChainClient::new()))
unimplemented!();
}
#[test]

2
js/src/lib.rs.in
View File

@ -51,5 +51,5 @@ impl WebApp for App {
#[test]
fn test_js() {
parity_dapps_glue::js::build(env!("CARGO_MANIFEST_DIR"));
parity_dapps_glue::js::build(env!("CARGO_MANIFEST_DIR"), "build");
}

1
rpc/src/v1/tests/helpers/miner_service.rs
View File

@ -16,6 +16,7 @@
//! Test implementation of miner service.
use std::collections::{BTreeMap, HashMap};
use std::collections::hash_map::Entry;
use util::{Address, H256, Bytes, U256};
use util::standard::*;

8
stratum/src/lib.rs
View File

@ -342,7 +342,7 @@ mod tests {
let mut core = Core::new().expect("Tokio Core should be created with no errors");
let mut buffer = vec![0u8; 2048];
let mut data_vec = data.as_bytes().into_vec();
let mut data_vec = data.as_bytes().to_vec();
data_vec.extend(b"\n");
let stream = TcpStream::connect(addr, &core.handle())
@ -353,7 +353,7 @@ mod tests {
io::read(stream, &mut buffer)
})
.and_then(|(_, read_buf, len)| {
future::ok(read_buf[0..len].into_vec())
future::ok(read_buf[0..len].to_vec())
});
let result = core.run(stream).expect("Core should run with no errors");
@ -454,7 +454,7 @@ mod tests {
let mut auth_request =
r#"{"jsonrpc": "2.0", "method": "mining.authorize", "params": ["miner1", ""], "id": 1}"#
.as_bytes()
.into_vec();
.to_vec();
auth_request.extend(b"\n");
let mut core = Core::new().expect("Tokio Core should be created with no errors");
@ -487,7 +487,7 @@ mod tests {
})
.and_then(|(_, read_buf, len)| {
trace!(target: "stratum", "Received work from server");
future::ok(read_buf[0..len].into_vec())
future::ok(read_buf[0..len].to_vec())
});
let response = String::from_utf8(
core.run(stream).expect("Core should run with no errors")

4
sync/src/block_sync.rs
View File

@ -18,6 +18,8 @@
/// Blockchain downloader
///
use std::collections::{HashSet, VecDeque};
use std::cmp;
use util::*;
use rlp::*;
use ethcore::views::{BlockView};
@ -386,7 +388,7 @@ impl BlockDownloader {
debug!(target: "sync", "Could not revert to previous ancient block, last: {} ({})", start, start_hash);
self.reset();
} else {
let n = start - min(self.retract_step, start);
let n = start - cmp::min(self.retract_step, start);
self.retract_step *= 2;
match io.chain().block_hash(BlockId::Number(n)) {
Some(h) => {

1
sync/src/blocks.rs
View File

@ -14,6 +14,7 @@
// 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::collections::{HashSet, HashMap};
use std::collections::hash_map::Entry;
use smallvec::SmallVec;
use util::*;

28
sync/src/chain.rs
View File

@ -89,6 +89,8 @@
/// All other messages are ignored.
///
use std::collections::{HashSet, HashMap};
use std::cmp;
use util::*;
use rlp::*;
use network::*;
@ -421,7 +423,7 @@ impl ChainSync {
start_block_number: self.starting_block,
last_imported_block_number: Some(last_imported_number),
last_imported_old_block_number: self.old_blocks.as_ref().map(|d| d.last_imported_block_number()),
highest_block_number: self.highest_block.map(|n| max(n, last_imported_number)),
highest_block_number: self.highest_block.map(|n| cmp::max(n, last_imported_number)),
blocks_received: if last_imported_number > self.starting_block { last_imported_number - self.starting_block } else { 0 },
blocks_total: match self.highest_block { Some(x) if x > self.starting_block => x - self.starting_block, _ => 0 },
num_peers: self.peers.values().filter(|p| p.is_allowed()).count(),
@ -961,7 +963,7 @@ impl ChainSync {
}
if self.state != SyncState::Idle {
trace!(target: "sync", "Ignoring new hashes since we're already downloading.");
let max = r.iter().take(MAX_NEW_HASHES).map(|item| item.val_at::<BlockNumber>(1).unwrap_or(0)).fold(0u64, max);
let max = r.iter().take(MAX_NEW_HASHES).map(|item| item.val_at::<BlockNumber>(1).unwrap_or(0)).fold(0u64, cmp::max);
if max > self.highest_block.unwrap_or(0) {
self.highest_block = Some(max);
}
@ -1473,7 +1475,7 @@ impl ChainSync {
let mut item_count = r.item_count()?;
trace!(target: "sync", "{:02} -> Transactions ({} entries)", peer_id, item_count);
item_count = min(item_count, MAX_TX_TO_IMPORT);
item_count = cmp::min(item_count, MAX_TX_TO_IMPORT);
let mut transactions = Vec::with_capacity(item_count);
for i in 0 .. item_count {
let rlp = r.at(i)?;
@ -1549,11 +1551,11 @@ impl ChainSync {
};
let mut number = if reverse {
min(last, number)
cmp::min(last, number)
} else {
max(0, number)
cmp::max(0, number)
};
let max_count = min(MAX_HEADERS_TO_SEND, max_headers);
let max_count = cmp::min(MAX_HEADERS_TO_SEND, max_headers);
let mut count = 0;
let mut data = Bytes::new();
let inc = (skip + 1) as BlockNumber;
@ -1594,7 +1596,7 @@ impl ChainSync {
debug!(target: "sync", "Empty GetBlockBodies request, ignoring.");
return Ok(None);
}
count = min(count, MAX_BODIES_TO_SEND);
count = cmp::min(count, MAX_BODIES_TO_SEND);
let mut added = 0usize;
let mut data = Bytes::new();
for i in 0..count {
@ -1617,7 +1619,7 @@ impl ChainSync {
debug!(target: "sync", "Empty GetNodeData request, ignoring.");
return Ok(None);
}
count = min(count, MAX_NODE_DATA_TO_SEND);
count = cmp::min(count, MAX_NODE_DATA_TO_SEND);
let mut added = 0usize;
let mut data = Vec::new();
for i in 0..count {
@ -1641,7 +1643,7 @@ impl ChainSync {
debug!(target: "sync", "Empty GetReceipts request, ignoring.");
return Ok(None);
}
count = min(count, MAX_RECEIPTS_HEADERS_TO_SEND);
count = cmp::min(count, MAX_RECEIPTS_HEADERS_TO_SEND);
let mut added_headers = 0usize;
let mut added_receipts = 0usize;
let mut data = Bytes::new();
@ -1915,8 +1917,8 @@ impl ChainSync {
// take sqrt(x) peers
let mut peers = peers.to_vec();
let mut count = (peers.len() as f64).powf(0.5).round() as usize;
count = min(count, MAX_PEERS_PROPAGATION);
count = max(count, MIN_PEERS_PROPAGATION);
count = cmp::min(count, MAX_PEERS_PROPAGATION);
count = cmp::max(count, MIN_PEERS_PROPAGATION);
random::new().shuffle(&mut peers);
peers.truncate(count);
peers
@ -2006,7 +2008,7 @@ impl ChainSync {
fn select_peers_for_transactions<F>(&self, filter: F) -> Vec<PeerId>
where F: Fn(&PeerId) -> bool {
// sqrt(x)/x scaled to max u32
let fraction = (self.peers.len() as f64).powf(-0.5).mul(u32::max_value() as f64).round() as u32;
let fraction = ((self.peers.len() as f64).powf(-0.5) * (u32::max_value() as f64).round()) as u32;
let small = self.peers.len() < MIN_PEERS_PROPAGATION;
let mut random = random::new();
@ -2112,7 +2114,7 @@ impl ChainSync {
peers.insert(peer_id);
self.send_packet(io, peer_id, TRANSACTIONS_PACKET, rlp);
trace!(target: "sync", "{:02} <- Transactions ({} entries)", peer_id, sent);
max_sent = max(max_sent, sent);
max_sent = cmp::max(max_sent, sent);
}
debug!(target: "sync", "Sent up to {} transactions to {} peers.", max_sent, lucky_peers_len);
}

1
sync/src/tests/helpers.rs
View File

@ -14,6 +14,7 @@
// 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::collections::{VecDeque, HashSet, HashMap};
use util::*;
use network::*;
use tests::snapshot::*;

1
sync/src/tests/snapshot.rs
View File

@ -14,6 +14,7 @@
// 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::collections::HashMap;
use util::*;
use ethcore::snapshot::{SnapshotService, ManifestData, RestorationStatus};
use ethcore::header::BlockNumber;

2
util/Cargo.toml
View File

@ -28,8 +28,6 @@ vergen = "0.1"
target_info = "0.1"
ethcore-bigint = { path = "bigint", features = ["heapsizeof"] }
parking_lot = "0.4"
using_queue = { path = "using_queue" }
table = { path = "table" }
ansi_term = "0.9"
tiny-keccak= "1.0"
ethcore-bloom-journal = { path = "bloom" }

10
util/bloomable/Cargo.toml Normal file
View File

@ -0,0 +1,10 @@
[package]
name = "bloomable"
version = "0.1.0"
authors = ["debris <marek.kotewicz@gmail.com>"]
[dependencies]
ethcore-bigint = { path = "../bigint" }
[dev-dependencies]
tiny-keccak = "1.2.1"

32
util/src/bloom.rs → util/bloomable/src/lib.rs
View File

@ -16,9 +16,11 @@
//! Bloom operations.
extern crate ethcore_bigint;
use std::mem;
use std::ops::DerefMut;
use {H64, H160, H256, H512, H520, H2048};
use ethcore_bigint::hash::{H64, H160, H256, H512, H520, H2048};
/// Returns log2.
pub fn log2(x: usize) -> u32 {
@ -115,31 +117,3 @@ impl_bloomable_for_hash!(H256, 32);
impl_bloomable_for_hash!(H512, 64);
impl_bloomable_for_hash!(H520, 65);
impl_bloomable_for_hash!(H2048, 256);
#[cfg(test)]
mod tests {
use {H160, H256, H2048};
use sha3::Hashable;
use super::Bloomable;
#[test]
fn shift_bloomed() {
let bloom: H2048 = "00000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002020000000000000000000000000000000000000000000008000000001000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into();
let address: H160 = "ef2d6d194084c2de36e0dabfce45d046b37d1106".into();
let topic: H256 = "02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc".into();
let mut my_bloom = H2048::default();
assert!(!my_bloom.contains_bloomed(&address.sha3()));
assert!(!my_bloom.contains_bloomed(&topic.sha3()));
my_bloom.shift_bloomed(&address.sha3());
assert!(my_bloom.contains_bloomed(&address.sha3()));
assert!(!my_bloom.contains_bloomed(&topic.sha3()));
my_bloom.shift_bloomed(&topic.sha3());
assert_eq!(my_bloom, bloom);
assert!(my_bloom.contains_bloomed(&address.sha3()));
assert!(my_bloom.contains_bloomed(&topic.sha3()));
}
}

31
util/bloomable/tests/test.rs Normal file
View File

@ -0,0 +1,31 @@
extern crate tiny_keccak;
extern crate ethcore_bigint;
extern crate bloomable;
use ethcore_bigint::hash::{H160, H256, H2048};
use bloomable::Bloomable;
use tiny_keccak::keccak256;
fn sha3(input: &[u8]) -> H256 {
keccak256(input).into()
}
#[test]
fn shift_bloomed() {
let bloom: H2048 = "00000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002020000000000000000000000000000000000000000000008000000001000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into();
let address: H160 = "ef2d6d194084c2de36e0dabfce45d046b37d1106".into();
let topic: H256 = "02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc".into();
let mut my_bloom = H2048::default();
assert!(!my_bloom.contains_bloomed(&sha3(&address)));
assert!(!my_bloom.contains_bloomed(&sha3(&topic)));
my_bloom.shift_bloomed(&sha3(&address));
assert!(my_bloom.contains_bloomed(&sha3(&address)));
assert!(!my_bloom.contains_bloomed(&sha3(&topic)));
my_bloom.shift_bloomed(&sha3(&topic));
assert_eq!(my_bloom, bloom);
assert!(my_bloom.contains_bloomed(&sha3(&address)));
assert!(my_bloom.contains_bloomed(&sha3(&topic)));
}

5
util/src/common.rs
View File

@ -16,6 +16,7 @@
//! Utils common types and macros global reexport.
use std::io;
pub use standard::*;
pub use error::*;
pub use bytes::*;
@ -100,8 +101,8 @@ macro_rules! flushln {
#[doc(hidden)]
pub fn flush(s: String) {
let _ = ::std::io::stdout().write(s.as_bytes());
let _ = ::std::io::stdout().flush();
let _ = io::Write::write(&mut io::stdout(), s.as_bytes());
let _ = io::Write::flush(&mut io::stdout());
}
#[test]

1
util/src/journaldb/archivedb.rs
View File

@ -16,6 +16,7 @@
//! Disk-backed `HashDB` implementation.
use std::collections::HashMap;
use common::*;
use rlp::*;
use hashdb::*;

2
util/src/journaldb/earlymergedb.rs
View File

@ -16,6 +16,8 @@
//! Disk-backed `HashDB` implementation.
use std::fmt;
use std::collections::HashMap;
use common::*;
use rlp::*;
use hashdb::*;

3
util/src/journaldb/mod.rs
View File

@ -16,6 +16,7 @@
//! `JournalDB` interface and implementation.
use std::{fmt, str};
use common::*;
/// Export the journaldb module.
@ -59,7 +60,7 @@ impl Default for Algorithm {
fn default() -> Algorithm { Algorithm::OverlayRecent }
}
impl FromStr for Algorithm {
impl str::FromStr for Algorithm {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {

1
util/src/journaldb/overlayrecentdb.rs
View File

@ -16,6 +16,7 @@
//! `JournalDB` over in-memory overlay
use std::collections::HashMap;
use common::*;
use rlp::*;
use hashdb::*;

1
util/src/journaldb/refcounteddb.rs
View File

@ -16,6 +16,7 @@
//! Disk-backed, ref-counted `JournalDB` implementation.
use std::collections::HashMap;
use common::*;
use rlp::*;
use hashdb::*;

2
util/src/kvdb.rs
View File

@ -16,6 +16,8 @@
//! Key-Value store abstraction with `RocksDB` backend.
use std::{mem, fs};
use std::collections::{HashMap, BTreeMap};
use std::io::ErrorKind;
use std::marker::PhantomData;
use std::path::PathBuf;

5
util/src/lib.rs
View File

@ -112,10 +112,6 @@ extern crate ethcore_logger;
#[macro_use]
extern crate log as rlog;
pub extern crate using_queue;
pub extern crate table;
pub mod bloom;
pub mod standard;
#[macro_use]
pub mod common;
@ -147,7 +143,6 @@ pub use overlaydb::*;
pub use journaldb::JournalDB;
pub use triehash::*;
pub use trie::{Trie, TrieMut, TrieDB, TrieDBMut, TrieFactory, TrieError, SecTrieDB, SecTrieDBMut};
pub use nibbleslice::*;
pub use semantic_version::*;
pub use kvdb::*;
pub use timer::*;

1
util/src/migration/tests.rs
View File

@ -18,6 +18,7 @@
//! A random temp directory is created. A database is created within it, and migrations
//! are performed in temp sub-directories.
use std::collections::BTreeMap;
use common::*;
use migration::{Batch, Config, Error, SimpleMigration, Migration, Manager};
use kvdb::Database;

6
util/src/misc.rs
View File

@ -60,9 +60,9 @@ pub fn version() -> String {
pub fn version_data() -> Bytes {
let mut s = RlpStream::new_list(4);
let v =
(u32::from_str(env!("CARGO_PKG_VERSION_MAJOR")).expect("Environment variables are known to be valid; qed") << 16) +
(u32::from_str(env!("CARGO_PKG_VERSION_MINOR")).expect("Environment variables are known to be valid; qed") << 8) +
u32::from_str(env!("CARGO_PKG_VERSION_PATCH")).expect("Environment variables are known to be valid; qed");
(env!("CARGO_PKG_VERSION_MAJOR").parse::<u32>().expect("Environment variables are known to be valid; qed") << 16) +
(env!("CARGO_PKG_VERSION_MINOR").parse::<u32>().expect("Environment variables are known to be valid; qed") << 8) +
env!("CARGO_PKG_VERSION_PATCH").parse::<u32>().expect("Environment variables are known to be valid; qed");
s.append(&v);
s.append(&"Parity");
s.append(&rustc_version());

2
util/src/nibblevec.rs
View File

@ -17,7 +17,7 @@
//! An owning, nibble-oriented byte vector.
use ::NibbleSlice;
use nibbleslice::NibbleSlice;
use elastic_array::ElasticArray36;
/// Owning, nibble-oriented byte vector. Counterpart to `NibbleSlice`.

18
util/src/standard.rs
View File

@ -16,28 +16,10 @@
//! Std lib global reexports.
pub use std::io;
pub use std::fs;
pub use std::str;
pub use std::fmt;
pub use std::cmp;
pub use std::ptr;
pub use std::mem;
pub use std::ops;
pub use std::slice;
pub use std::result;
pub use std::option;
pub use std::path::Path;
pub use std::str::{FromStr};
pub use std::io::{Read,Write};
pub use std::hash::{Hash, Hasher};
pub use std::error::Error as StdError;
pub use std::ops::*;
pub use std::cmp::*;
pub use std::sync::Arc;
pub use std::collections::*;
pub use heapsize::HeapSizeOf;
pub use itertools::Itertools;

1
util/src/trie/triedb.rs
View File

@ -14,6 +14,7 @@
// 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::fmt;
use common::*;
use hashdb::*;
use nibbleslice::*;