Merge pull request #1827 from ethcore/move_hash
moved hash.rs to bigint library
This commit is contained in:
commit
3b6bc974f3
1
Cargo.lock
generated
1
Cargo.lock
generated
@ -75,6 +75,7 @@ name = "bigint"
|
|||||||
version = "0.1.0"
|
version = "0.1.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"heapsize 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
|
"heapsize 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
|
"rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
|
"rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
|
"rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
]
|
]
|
||||||
|
@ -14,8 +14,7 @@
|
|||||||
// You should have received a copy of the GNU General Public License
|
// You should have received a copy of the GNU General Public License
|
||||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
use util::bytes::Bytes;
|
use util::{Bytes, U256, H256};
|
||||||
use util::numbers::{U256,H256};
|
|
||||||
use header::BlockNumber;
|
use header::BlockNumber;
|
||||||
|
|
||||||
/// Best block info.
|
/// Best block info.
|
||||||
|
@ -14,7 +14,7 @@
|
|||||||
// You should have received a copy of the GNU General Public License
|
// You should have received a copy of the GNU General Public License
|
||||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
use util::numbers::{U256,H256};
|
use util::{U256,H256};
|
||||||
use header::BlockNumber;
|
use header::BlockNumber;
|
||||||
|
|
||||||
/// Brief info about inserted block.
|
/// Brief info about inserted block.
|
||||||
|
@ -14,9 +14,7 @@
|
|||||||
// You should have received a copy of the GNU General Public License
|
// You should have received a copy of the GNU General Public License
|
||||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
use util::hash::H2048;
|
use util::{U256, H2048, Bytes};
|
||||||
use util::numbers::U256;
|
|
||||||
use util::bytes::Bytes;
|
|
||||||
use header::BlockNumber;
|
use header::BlockNumber;
|
||||||
use super::fork::Fork;
|
use super::fork::Fork;
|
||||||
use super::bloom::Bloom;
|
use super::bloom::Bloom;
|
||||||
|
@ -16,7 +16,7 @@
|
|||||||
|
|
||||||
//! Import route.
|
//! Import route.
|
||||||
|
|
||||||
use util::hash::H256;
|
use util::H256;
|
||||||
use blockchain::block_info::{BlockInfo, BlockLocation};
|
use blockchain::block_info::{BlockInfo, BlockLocation};
|
||||||
|
|
||||||
/// Import route for newly inserted block.
|
/// Import route for newly inserted block.
|
||||||
@ -67,8 +67,7 @@ impl From<BlockInfo> for ImportRoute {
|
|||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use util::hash::H256;
|
use util::{U256, H256};
|
||||||
use util::numbers::U256;
|
|
||||||
use blockchain::block_info::{BlockInfo, BlockLocation, BranchBecomingCanonChainData};
|
use blockchain::block_info::{BlockInfo, BlockLocation, BranchBecomingCanonChainData};
|
||||||
use blockchain::ImportRoute;
|
use blockchain::ImportRoute;
|
||||||
|
|
||||||
|
@ -1,5 +1,5 @@
|
|||||||
use std::collections::HashMap;
|
use std::collections::HashMap;
|
||||||
use util::numbers::H256;
|
use util::H256;
|
||||||
use header::BlockNumber;
|
use header::BlockNumber;
|
||||||
use blockchain::block_info::BlockInfo;
|
use blockchain::block_info::BlockInfo;
|
||||||
use blooms::BloomGroup;
|
use blooms::BloomGroup;
|
||||||
|
@ -102,7 +102,7 @@ pub fn new_builtin_exec(name: &str) -> Box<Fn(&[u8], &mut [u8])> {
|
|||||||
let mut it: InType = InType { hash: H256::new(), v: H256::new(), r: H256::new(), s: H256::new() };
|
let mut it: InType = InType { hash: H256::new(), v: H256::new(), r: H256::new(), s: H256::new() };
|
||||||
it.copy_raw(input);
|
it.copy_raw(input);
|
||||||
if it.v == H256::from(&U256::from(27)) || it.v == H256::from(&U256::from(28)) {
|
if it.v == H256::from(&U256::from(27)) || it.v == H256::from(&U256::from(28)) {
|
||||||
let s = Signature::from_rsv(&it.r, &it.s, it.v[31] - 27);
|
let s = signature_from_rsv(&it.r, &it.s, it.v[31] - 27);
|
||||||
if ec::is_valid(&s) {
|
if ec::is_valid(&s) {
|
||||||
if let Ok(p) = ec::recover(&s, &it.hash) {
|
if let Ok(p) = ec::recover(&s, &it.hash) {
|
||||||
let r = p.as_slice().sha3();
|
let r = p.as_slice().sha3();
|
||||||
|
@ -14,10 +14,10 @@
|
|||||||
// You should have received a copy of the GNU General Public License
|
// You should have received a copy of the GNU General Public License
|
||||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
use util::numbers::*;
|
|
||||||
use ipc::{IpcConfig, BinaryConvertError};
|
|
||||||
use std::collections::VecDeque;
|
use std::collections::VecDeque;
|
||||||
use std::mem;
|
use std::mem;
|
||||||
|
use ipc::{IpcConfig, BinaryConvertError};
|
||||||
|
use util::H256;
|
||||||
|
|
||||||
/// Represents what has to be handled by actor listening to chain events
|
/// Represents what has to be handled by actor listening to chain events
|
||||||
#[derive(Ipc)]
|
#[derive(Ipc)]
|
||||||
|
@ -25,7 +25,7 @@ use time::precise_time_ns;
|
|||||||
use util::{journaldb, rlp, Bytes, View, PerfTimer, Itertools, Mutex, RwLock};
|
use util::{journaldb, rlp, Bytes, View, PerfTimer, Itertools, Mutex, RwLock};
|
||||||
use util::journaldb::JournalDB;
|
use util::journaldb::JournalDB;
|
||||||
use util::rlp::{UntrustedRlp};
|
use util::rlp::{UntrustedRlp};
|
||||||
use util::numbers::*;
|
use util::{U256, H256, Address, H2048, Uint};
|
||||||
use util::sha3::*;
|
use util::sha3::*;
|
||||||
use util::kvdb::*;
|
use util::kvdb::*;
|
||||||
|
|
||||||
@ -255,7 +255,7 @@ impl Client {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
let mut last_hashes = LastHashes::new();
|
let mut last_hashes = LastHashes::new();
|
||||||
last_hashes.resize(256, H256::new());
|
last_hashes.resize(256, H256::default());
|
||||||
last_hashes[0] = parent_hash;
|
last_hashes[0] = parent_hash;
|
||||||
for i in 0..255 {
|
for i in 0..255 {
|
||||||
match self.chain.block_details(&last_hashes[i]) {
|
match self.chain.block_details(&last_hashes[i]) {
|
||||||
@ -727,7 +727,7 @@ impl BlockChainClient for Client {
|
|||||||
timestamp: view.timestamp(),
|
timestamp: view.timestamp(),
|
||||||
difficulty: view.difficulty(),
|
difficulty: view.difficulty(),
|
||||||
last_hashes: last_hashes,
|
last_hashes: last_hashes,
|
||||||
gas_used: U256::zero(),
|
gas_used: U256::default(),
|
||||||
gas_limit: view.gas_limit(),
|
gas_limit: view.gas_limit(),
|
||||||
};
|
};
|
||||||
for t in txs.iter().take(address.index) {
|
for t in txs.iter().take(address.index) {
|
||||||
@ -953,7 +953,7 @@ impl BlockChainClient for Client {
|
|||||||
entry: log,
|
entry: log,
|
||||||
block_hash: hash.clone(),
|
block_hash: hash.clone(),
|
||||||
block_number: number,
|
block_number: number,
|
||||||
transaction_hash: hashes.get(index).cloned().unwrap_or_else(H256::new),
|
transaction_hash: hashes.get(index).cloned().unwrap_or_else(H256::default),
|
||||||
transaction_index: index,
|
transaction_index: index,
|
||||||
log_index: log_index + i
|
log_index: log_index + i
|
||||||
})
|
})
|
||||||
|
@ -14,10 +14,7 @@
|
|||||||
// You should have received a copy of the GNU General Public License
|
// You should have received a copy of the GNU General Public License
|
||||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
use util::bytes::Bytes;
|
use util::{U256, Address, H256, H2048, Bytes, Itertools};
|
||||||
use util::hash::{Address, H256, H2048};
|
|
||||||
use util::numbers::U256;
|
|
||||||
use util::Itertools;
|
|
||||||
use blockchain::TreeRoute;
|
use blockchain::TreeRoute;
|
||||||
use block_queue::BlockQueueInfo;
|
use block_queue::BlockQueueInfo;
|
||||||
use block::{OpenBlock, SealedBlock};
|
use block::{OpenBlock, SealedBlock};
|
||||||
|
@ -14,7 +14,9 @@
|
|||||||
// You should have received a copy of the GNU General Public License
|
// You should have received a copy of the GNU General Public License
|
||||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
use util::*;
|
use std::cmp;
|
||||||
|
use std::sync::Arc;
|
||||||
|
use util::{U256, Address, H256, Hashable};
|
||||||
use header::BlockNumber;
|
use header::BlockNumber;
|
||||||
use ethjson;
|
use ethjson;
|
||||||
|
|
||||||
@ -45,7 +47,7 @@ impl Default for EnvInfo {
|
|||||||
fn default() -> Self {
|
fn default() -> Self {
|
||||||
EnvInfo {
|
EnvInfo {
|
||||||
number: 0,
|
number: 0,
|
||||||
author: Address::new(),
|
author: Address::default(),
|
||||||
timestamp: 0,
|
timestamp: 0,
|
||||||
difficulty: 0.into(),
|
difficulty: 0.into(),
|
||||||
gas_limit: 0.into(),
|
gas_limit: 0.into(),
|
||||||
@ -65,7 +67,7 @@ impl From<ethjson::vm::Env> for EnvInfo {
|
|||||||
gas_limit: e.gas_limit.into(),
|
gas_limit: e.gas_limit.into(),
|
||||||
timestamp: e.timestamp.into(),
|
timestamp: e.timestamp.into(),
|
||||||
last_hashes: Arc::new((1..cmp::min(number + 1, 257)).map(|i| format!("{}", number - i).as_bytes().sha3()).collect()),
|
last_hashes: Arc::new((1..cmp::min(number + 1, 257)).map(|i| format!("{}", number - i).as_bytes().sha3()).collect()),
|
||||||
gas_used: U256::zero(),
|
gas_used: U256::default(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -74,10 +76,9 @@ impl From<ethjson::vm::Env> for EnvInfo {
|
|||||||
mod tests {
|
mod tests {
|
||||||
extern crate rustc_serialize;
|
extern crate rustc_serialize;
|
||||||
|
|
||||||
use super::*;
|
|
||||||
use util::hash::*;
|
|
||||||
use util::numbers::U256;
|
|
||||||
use std::str::FromStr;
|
use std::str::FromStr;
|
||||||
|
use super::*;
|
||||||
|
use util::{U256, Address};
|
||||||
use ethjson;
|
use ethjson;
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
@ -374,13 +374,13 @@ mod tests {
|
|||||||
let vm_factory = Default::default();
|
let vm_factory = Default::default();
|
||||||
let mut b = OpenBlock::new(engine.deref(), &vm_factory, Default::default(), false, db, &genesis_header, last_hashes, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
|
let mut b = OpenBlock::new(engine.deref(), &vm_factory, Default::default(), false, db, &genesis_header, last_hashes, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
|
||||||
let mut uncle = Header::new();
|
let mut uncle = Header::new();
|
||||||
let uncle_author = address_from_hex("ef2d6d194084c2de36e0dabfce45d046b37d1106");
|
let uncle_author: Address = "ef2d6d194084c2de36e0dabfce45d046b37d1106".into();
|
||||||
uncle.author = uncle_author.clone();
|
uncle.author = uncle_author.clone();
|
||||||
b.push_uncle(uncle).unwrap();
|
b.push_uncle(uncle).unwrap();
|
||||||
|
|
||||||
let b = b.close();
|
let b = b.close();
|
||||||
assert_eq!(b.state().balance(&Address::zero()), U256::from_str("478eae0e571ba000").unwrap());
|
assert_eq!(b.state().balance(&Address::zero()), "478eae0e571ba000".into());
|
||||||
assert_eq!(b.state().balance(&uncle_author), U256::from_str("3cb71f51fc558000").unwrap());
|
assert_eq!(b.state().balance(&uncle_author), "3cb71f51fc558000".into());
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
@ -69,21 +69,21 @@ mod tests {
|
|||||||
let mut db = db_result.take();
|
let mut db = db_result.take();
|
||||||
spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
|
spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
|
||||||
let s = State::from_existing(db, genesis_header.state_root.clone(), engine.account_start_nonce(), Default::default()).unwrap();
|
let s = State::from_existing(db, genesis_header.state_root.clone(), engine.account_start_nonce(), Default::default()).unwrap();
|
||||||
assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000001")), U256::from(1u64));
|
assert_eq!(s.balance(&"0000000000000000000000000000000000000001".into()), 1u64.into());
|
||||||
assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000002")), U256::from(1u64));
|
assert_eq!(s.balance(&"0000000000000000000000000000000000000002".into()), 1u64.into());
|
||||||
assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000003")), U256::from(1u64));
|
assert_eq!(s.balance(&"0000000000000000000000000000000000000003".into()), 1u64.into());
|
||||||
assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000004")), U256::from(1u64));
|
assert_eq!(s.balance(&"0000000000000000000000000000000000000004".into()), 1u64.into());
|
||||||
assert_eq!(s.balance(&address_from_hex("102e61f5d8f9bc71d0ad4a084df4e65e05ce0e1c")), U256::from(1u64) << 200);
|
assert_eq!(s.balance(&"102e61f5d8f9bc71d0ad4a084df4e65e05ce0e1c".into()), U256::from(1u64) << 200);
|
||||||
assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000000")), U256::from(0u64));
|
assert_eq!(s.balance(&"0000000000000000000000000000000000000000".into()), 0u64.into());
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn morden() {
|
fn morden() {
|
||||||
let morden = new_morden();
|
let morden = new_morden();
|
||||||
|
|
||||||
assert_eq!(morden.state_root(), H256::from_str("f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9").unwrap());
|
assert_eq!(morden.state_root(), "f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9".into());
|
||||||
let genesis = morden.genesis_block();
|
let genesis = morden.genesis_block();
|
||||||
assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303").unwrap());
|
assert_eq!(BlockView::new(&genesis).header_view().sha3(), "0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303".into());
|
||||||
|
|
||||||
let _ = morden.engine;
|
let _ = morden.engine;
|
||||||
}
|
}
|
||||||
@ -92,9 +92,9 @@ mod tests {
|
|||||||
fn frontier() {
|
fn frontier() {
|
||||||
let frontier = new_frontier();
|
let frontier = new_frontier();
|
||||||
|
|
||||||
assert_eq!(frontier.state_root(), H256::from_str("d7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544").unwrap());
|
assert_eq!(frontier.state_root(), "d7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544".into());
|
||||||
let genesis = frontier.genesis_block();
|
let genesis = frontier.genesis_block();
|
||||||
assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3").unwrap());
|
assert_eq!(BlockView::new(&genesis).header_view().sha3(), "d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3".into());
|
||||||
|
|
||||||
let _ = frontier.engine;
|
let _ = frontier.engine;
|
||||||
}
|
}
|
||||||
|
@ -29,8 +29,7 @@
|
|||||||
//! extern crate rustc_serialize;
|
//! extern crate rustc_serialize;
|
||||||
//!
|
//!
|
||||||
//! use util::crypto::KeyPair;
|
//! use util::crypto::KeyPair;
|
||||||
//! use util::hash::Address;
|
//! use util::{Uint, U256, Address};
|
||||||
//! use util::numbers::{Uint, U256};
|
|
||||||
//! use ethcore::miner::{TransactionQueue, AccountDetails, TransactionOrigin};
|
//! use ethcore::miner::{TransactionQueue, AccountDetails, TransactionOrigin};
|
||||||
//! use ethcore::transaction::*;
|
//! use ethcore::transaction::*;
|
||||||
//! use rustc_serialize::hex::FromHex;
|
//! use rustc_serialize::hex::FromHex;
|
||||||
@ -81,12 +80,10 @@
|
|||||||
//! - It removes all transactions (either from `current` or `future`) with nonce < client nonce
|
//! - It removes all transactions (either from `current` or `future`) with nonce < client nonce
|
||||||
//! - It moves matching `future` transactions to `current`
|
//! - It moves matching `future` transactions to `current`
|
||||||
|
|
||||||
use std::default::Default;
|
use std::cmp::Ordering;
|
||||||
use std::cmp::{Ordering};
|
|
||||||
use std::cmp;
|
use std::cmp;
|
||||||
use std::collections::{HashMap, BTreeSet};
|
use std::collections::{HashMap, BTreeSet};
|
||||||
use util::numbers::{Uint, U256};
|
use util::{Address, H256, Uint, U256};
|
||||||
use util::hash::{Address, H256};
|
|
||||||
use util::table::Table;
|
use util::table::Table;
|
||||||
use transaction::*;
|
use transaction::*;
|
||||||
use error::{Error, TransactionError};
|
use error::{Error, TransactionError};
|
||||||
|
@ -17,12 +17,9 @@
|
|||||||
//! Account state encoding and decoding
|
//! Account state encoding and decoding
|
||||||
|
|
||||||
use account_db::{AccountDB, AccountDBMut};
|
use account_db::{AccountDB, AccountDBMut};
|
||||||
use snapshot::Error;
|
use util::{U256, FixedHash, H256, Bytes, HashDB, SHA3_EMPTY, TrieDB};
|
||||||
|
|
||||||
use util::{Bytes, HashDB, SHA3_EMPTY, TrieDB};
|
|
||||||
use util::hash::{FixedHash, H256};
|
|
||||||
use util::numbers::U256;
|
|
||||||
use util::rlp::{Rlp, RlpStream, Stream, UntrustedRlp, View};
|
use util::rlp::{Rlp, RlpStream, Stream, UntrustedRlp, View};
|
||||||
|
use snapshot::Error;
|
||||||
|
|
||||||
// An alternate account structure from ::account::Account.
|
// An alternate account structure from ::account::Account.
|
||||||
#[derive(PartialEq, Clone, Debug)]
|
#[derive(PartialEq, Clone, Debug)]
|
||||||
|
@ -133,9 +133,7 @@ mod tests {
|
|||||||
use super::AbridgedBlock;
|
use super::AbridgedBlock;
|
||||||
use types::transaction::{Action, Transaction};
|
use types::transaction::{Action, Transaction};
|
||||||
|
|
||||||
use util::numbers::U256;
|
use util::{Address, H256, FixedHash, U256, Bytes};
|
||||||
use util::hash::{Address, H256, FixedHash};
|
|
||||||
use util::Bytes;
|
|
||||||
|
|
||||||
fn encode_block(b: &Block) -> Bytes {
|
fn encode_block(b: &Block) -> Bytes {
|
||||||
b.rlp_bytes(::basic_types::Seal::With)
|
b.rlp_bytes(::basic_types::Seal::With)
|
||||||
|
@ -15,8 +15,7 @@
|
|||||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
use util::rlp::*;
|
use util::rlp::*;
|
||||||
use util::numbers::{Uint, U256};
|
use util::{Address, H256, Uint, U256};
|
||||||
use util::hash::{Address, H256};
|
|
||||||
use ethjson;
|
use ethjson;
|
||||||
use super::seal::Seal;
|
use super::seal::Seal;
|
||||||
|
|
||||||
|
@ -1393,7 +1393,7 @@ fn alter_balance() {
|
|||||||
let mut state_result = get_temp_state();
|
let mut state_result = get_temp_state();
|
||||||
let mut state = state_result.reference_mut();
|
let mut state = state_result.reference_mut();
|
||||||
let a = Address::zero();
|
let a = Address::zero();
|
||||||
let b = address_from_u64(1u64);
|
let b = 1u64.into();
|
||||||
state.add_balance(&a, &U256::from(69u64));
|
state.add_balance(&a, &U256::from(69u64));
|
||||||
assert_eq!(state.balance(&a), U256::from(69u64));
|
assert_eq!(state.balance(&a), U256::from(69u64));
|
||||||
state.commit().unwrap();
|
state.commit().unwrap();
|
||||||
|
@ -16,13 +16,11 @@
|
|||||||
|
|
||||||
//! Diff between two accounts.
|
//! Diff between two accounts.
|
||||||
|
|
||||||
use util::numbers::*;
|
|
||||||
use std::cmp::*;
|
use std::cmp::*;
|
||||||
use std::fmt;
|
use std::{fmt, mem};
|
||||||
use ipc::binary::{BinaryConvertError, BinaryConvertable};
|
|
||||||
use util::Bytes;
|
|
||||||
use std::collections::{VecDeque, BTreeMap};
|
use std::collections::{VecDeque, BTreeMap};
|
||||||
use std::mem;
|
use util::{U256, H256, Uint, Bytes};
|
||||||
|
use ipc::binary::{BinaryConvertError, BinaryConvertable};
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, Eq, Clone, Binary)]
|
#[derive(Debug, PartialEq, Eq, Clone, Binary)]
|
||||||
/// Diff type for specifying a change (or not).
|
/// Diff type for specifying a change (or not).
|
||||||
|
@ -16,11 +16,11 @@
|
|||||||
|
|
||||||
//! Blockhain info type definition
|
//! Blockhain info type definition
|
||||||
|
|
||||||
use util::numbers::*;
|
|
||||||
use header::BlockNumber;
|
|
||||||
use ipc::binary::BinaryConvertError;
|
|
||||||
use std::mem;
|
use std::mem;
|
||||||
use std::collections::VecDeque;
|
use std::collections::VecDeque;
|
||||||
|
use util::{U256, H256};
|
||||||
|
use ipc::binary::BinaryConvertError;
|
||||||
|
use header::BlockNumber;
|
||||||
|
|
||||||
/// Information about the blockchain gathered together.
|
/// Information about the blockchain gathered together.
|
||||||
#[derive(Clone, Debug, Binary)]
|
#[derive(Clone, Debug, Binary)]
|
||||||
|
@ -16,8 +16,7 @@
|
|||||||
|
|
||||||
//! Transaction execution format module.
|
//! Transaction execution format module.
|
||||||
|
|
||||||
use util::numbers::*;
|
use util::{Bytes, U256, Address, U512};
|
||||||
use util::Bytes;
|
|
||||||
use util::rlp::*;
|
use util::rlp::*;
|
||||||
use trace::{VMTrace, FlatTrace};
|
use trace::{VMTrace, FlatTrace};
|
||||||
use types::log_entry::LogEntry;
|
use types::log_entry::LogEntry;
|
||||||
|
@ -18,6 +18,7 @@
|
|||||||
|
|
||||||
use util::hash::*;
|
use util::hash::*;
|
||||||
use util::sha3::*;
|
use util::sha3::*;
|
||||||
|
use util::bloom::Bloomable;
|
||||||
use client::BlockID;
|
use client::BlockID;
|
||||||
use log_entry::LogEntry;
|
use log_entry::LogEntry;
|
||||||
use ipc::binary::BinaryConvertError;
|
use ipc::binary::BinaryConvertError;
|
||||||
|
@ -16,18 +16,16 @@
|
|||||||
|
|
||||||
//! Log entry type definition.
|
//! Log entry type definition.
|
||||||
|
|
||||||
use util::numbers::*;
|
use std::mem;
|
||||||
use std::ops::Deref;
|
use std::ops::Deref;
|
||||||
|
use std::collections::VecDeque;
|
||||||
|
use util::{H256, Address, Bytes, HeapSizeOf, Hashable};
|
||||||
use util::rlp::*;
|
use util::rlp::*;
|
||||||
use util::Bytes;
|
use util::bloom::Bloomable;
|
||||||
use util::HeapSizeOf;
|
use ipc::binary::BinaryConvertError;
|
||||||
use util::sha3::*;
|
|
||||||
use basic_types::LogBloom;
|
use basic_types::LogBloom;
|
||||||
use header::BlockNumber;
|
use header::BlockNumber;
|
||||||
use ethjson;
|
use ethjson;
|
||||||
use ipc::binary::BinaryConvertError;
|
|
||||||
use std::mem;
|
|
||||||
use std::collections::VecDeque;
|
|
||||||
|
|
||||||
/// A record of execution for a `LOG` operation.
|
/// A record of execution for a `LOG` operation.
|
||||||
#[derive(Default, Debug, Clone, PartialEq, Eq, Binary)]
|
#[derive(Default, Debug, Clone, PartialEq, Eq, Binary)]
|
||||||
|
@ -16,15 +16,15 @@
|
|||||||
|
|
||||||
//! Receipt
|
//! Receipt
|
||||||
|
|
||||||
use util::numbers::*;
|
use std::mem;
|
||||||
|
use std::collections::VecDeque;
|
||||||
|
use util::{H256, U256, Address};
|
||||||
use util::rlp::*;
|
use util::rlp::*;
|
||||||
use util::HeapSizeOf;
|
use util::HeapSizeOf;
|
||||||
use basic_types::LogBloom;
|
use basic_types::LogBloom;
|
||||||
use header::BlockNumber;
|
use header::BlockNumber;
|
||||||
use log_entry::{LogEntry, LocalizedLogEntry};
|
use log_entry::{LogEntry, LocalizedLogEntry};
|
||||||
use ipc::binary::BinaryConvertError;
|
use ipc::binary::BinaryConvertError;
|
||||||
use std::mem;
|
|
||||||
use std::collections::VecDeque;
|
|
||||||
|
|
||||||
/// Information describing execution of a transaction.
|
/// Information describing execution of a transaction.
|
||||||
#[derive(Default, Debug, Clone, Binary)]
|
#[derive(Default, Debug, Clone, Binary)]
|
||||||
@ -45,7 +45,7 @@ impl Receipt {
|
|||||||
Receipt {
|
Receipt {
|
||||||
state_root: state_root,
|
state_root: state_root,
|
||||||
gas_used: gas_used,
|
gas_used: gas_used,
|
||||||
log_bloom: logs.iter().fold(LogBloom::new(), |mut b, l| { b = &b | &l.bloom(); b }), //TODO: use |= operator
|
log_bloom: logs.iter().fold(LogBloom::default(), |mut b, l| { b = &b | &l.bloom(); b }), //TODO: use |= operator
|
||||||
logs: logs,
|
logs: logs,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -16,13 +16,12 @@
|
|||||||
|
|
||||||
//! State diff module.
|
//! State diff module.
|
||||||
|
|
||||||
use util::numbers::*;
|
use std::{mem, fmt};
|
||||||
use account_diff::*;
|
|
||||||
use ipc::binary::BinaryConvertError;
|
|
||||||
use std::mem;
|
|
||||||
use std::fmt;
|
|
||||||
use std::ops::*;
|
use std::ops::*;
|
||||||
use std::collections::{VecDeque, BTreeMap};
|
use std::collections::{VecDeque, BTreeMap};
|
||||||
|
use util::Address;
|
||||||
|
use account_diff::*;
|
||||||
|
use ipc::binary::BinaryConvertError;
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, Eq, Clone, Binary)]
|
#[derive(Debug, PartialEq, Eq, Clone, Binary)]
|
||||||
/// Expression for the delta between two system states. Encoded the
|
/// Expression for the delta between two system states. Encoded the
|
||||||
|
@ -17,15 +17,16 @@
|
|||||||
//! Trace filters type definitions
|
//! Trace filters type definitions
|
||||||
|
|
||||||
use std::ops::Range;
|
use std::ops::Range;
|
||||||
|
use std::mem;
|
||||||
|
use std::collections::VecDeque;
|
||||||
use bloomchain::{Filter as BloomFilter, Bloom, Number};
|
use bloomchain::{Filter as BloomFilter, Bloom, Number};
|
||||||
use util::{Address, FixedHash};
|
use util::Address;
|
||||||
use util::sha3::Hashable;
|
use util::sha3::Hashable;
|
||||||
|
use util::bloom::Bloomable;
|
||||||
use basic_types::LogBloom;
|
use basic_types::LogBloom;
|
||||||
use trace::flat::FlatTrace;
|
use trace::flat::FlatTrace;
|
||||||
use types::trace_types::trace::{Action, Res};
|
use types::trace_types::trace::{Action, Res};
|
||||||
use ipc::binary::BinaryConvertError;
|
use ipc::binary::BinaryConvertError;
|
||||||
use std::mem;
|
|
||||||
use std::collections::VecDeque;
|
|
||||||
|
|
||||||
/// Addresses filter.
|
/// Addresses filter.
|
||||||
///
|
///
|
||||||
@ -55,7 +56,7 @@ impl AddressesFilter {
|
|||||||
/// Returns blooms of this addresses filter.
|
/// Returns blooms of this addresses filter.
|
||||||
pub fn blooms(&self) -> Vec<LogBloom> {
|
pub fn blooms(&self) -> Vec<LogBloom> {
|
||||||
match self.list.is_empty() {
|
match self.list.is_empty() {
|
||||||
true => vec![LogBloom::new()],
|
true => vec![LogBloom::default()],
|
||||||
false => self.list.iter()
|
false => self.list.iter()
|
||||||
.map(|address| LogBloom::from_bloomed(&address.sha3()))
|
.map(|address| LogBloom::from_bloomed(&address.sha3()))
|
||||||
.collect(),
|
.collect(),
|
||||||
@ -137,12 +138,12 @@ impl Filter {
|
|||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use util::{FixedHash, Address};
|
use util::Address;
|
||||||
use util::sha3::Hashable;
|
use util::sha3::Hashable;
|
||||||
|
use util::bloom::Bloomable;
|
||||||
use trace::trace::{Action, Call, Res, Create, CreateResult, Suicide};
|
use trace::trace::{Action, Call, Res, Create, CreateResult, Suicide};
|
||||||
use trace::flat::FlatTrace;
|
use trace::flat::FlatTrace;
|
||||||
use trace::{Filter, AddressesFilter};
|
use trace::{Filter, AddressesFilter};
|
||||||
use basic_types::LogBloom;
|
|
||||||
use types::executed::CallType;
|
use types::executed::CallType;
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
@ -154,7 +155,7 @@ mod tests {
|
|||||||
};
|
};
|
||||||
|
|
||||||
let blooms = filter.bloom_possibilities();
|
let blooms = filter.bloom_possibilities();
|
||||||
assert_eq!(blooms, vec![LogBloom::new()]);
|
assert_eq!(blooms, vec![Default::default()]);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
@ -16,9 +16,10 @@
|
|||||||
|
|
||||||
//! Tracing datatypes.
|
//! Tracing datatypes.
|
||||||
|
|
||||||
use util::{U256, Bytes, Address, FixedHash};
|
use util::{U256, Bytes, Address};
|
||||||
use util::rlp::*;
|
use util::rlp::*;
|
||||||
use util::sha3::Hashable;
|
use util::sha3::Hashable;
|
||||||
|
use util::bloom::Bloomable;
|
||||||
use action_params::ActionParams;
|
use action_params::ActionParams;
|
||||||
use basic_types::LogBloom;
|
use basic_types::LogBloom;
|
||||||
use types::executed::CallType;
|
use types::executed::CallType;
|
||||||
|
@ -16,19 +16,20 @@
|
|||||||
|
|
||||||
//! Transaction data structure.
|
//! Transaction data structure.
|
||||||
|
|
||||||
use util::numbers::*;
|
use std::mem;
|
||||||
|
use std::collections::VecDeque;
|
||||||
|
use util::{H256, Address, U256, H520};
|
||||||
use std::ops::Deref;
|
use std::ops::Deref;
|
||||||
use util::rlp::*;
|
use util::rlp::*;
|
||||||
use util::sha3::*;
|
use util::sha3::*;
|
||||||
use util::{UtilError, CryptoError, Bytes, Signature, Secret, ec};
|
use util::{UtilError, CryptoError, Bytes, Signature, Secret, ec};
|
||||||
|
use util::crypto::{signature_from_rsv, signature_to_rsv};
|
||||||
use std::cell::*;
|
use std::cell::*;
|
||||||
use error::*;
|
use error::*;
|
||||||
use evm::Schedule;
|
use evm::Schedule;
|
||||||
use header::BlockNumber;
|
use header::BlockNumber;
|
||||||
use ethjson;
|
use ethjson;
|
||||||
use ipc::binary::BinaryConvertError;
|
use ipc::binary::BinaryConvertError;
|
||||||
use std::mem;
|
|
||||||
use std::collections::VecDeque;
|
|
||||||
|
|
||||||
#[derive(Debug, Clone, PartialEq, Eq, Binary)]
|
#[derive(Debug, Clone, PartialEq, Eq, Binary)]
|
||||||
/// Transaction action type.
|
/// Transaction action type.
|
||||||
@ -146,7 +147,7 @@ impl Transaction {
|
|||||||
|
|
||||||
/// Signs the transaction with signature.
|
/// Signs the transaction with signature.
|
||||||
pub fn with_signature(self, sig: H520) -> SignedTransaction {
|
pub fn with_signature(self, sig: H520) -> SignedTransaction {
|
||||||
let (r, s, v) = sig.to_rsv();
|
let (r, s, v) = signature_to_rsv(&sig);
|
||||||
SignedTransaction {
|
SignedTransaction {
|
||||||
unsigned: self,
|
unsigned: self,
|
||||||
r: r,
|
r: r,
|
||||||
@ -162,8 +163,8 @@ impl Transaction {
|
|||||||
pub fn invalid_sign(self) -> SignedTransaction {
|
pub fn invalid_sign(self) -> SignedTransaction {
|
||||||
SignedTransaction {
|
SignedTransaction {
|
||||||
unsigned: self,
|
unsigned: self,
|
||||||
r: U256::zero(),
|
r: U256::default(),
|
||||||
s: U256::zero(),
|
s: U256::default(),
|
||||||
v: 0,
|
v: 0,
|
||||||
hash: Cell::new(None),
|
hash: Cell::new(None),
|
||||||
sender: Cell::new(None),
|
sender: Cell::new(None),
|
||||||
@ -174,8 +175,8 @@ impl Transaction {
|
|||||||
pub fn fake_sign(self, from: Address) -> SignedTransaction {
|
pub fn fake_sign(self, from: Address) -> SignedTransaction {
|
||||||
SignedTransaction {
|
SignedTransaction {
|
||||||
unsigned: self,
|
unsigned: self,
|
||||||
r: U256::zero(),
|
r: U256::default(),
|
||||||
s: U256::zero(),
|
s: U256::default(),
|
||||||
v: 0,
|
v: 0,
|
||||||
hash: Cell::new(None),
|
hash: Cell::new(None),
|
||||||
sender: Cell::new(Some(from)),
|
sender: Cell::new(Some(from)),
|
||||||
@ -290,7 +291,7 @@ impl SignedTransaction {
|
|||||||
pub fn standard_v(&self) -> u8 { match self.v { 27 => 0, 28 => 1, _ => 4 } }
|
pub fn standard_v(&self) -> u8 { match self.v { 27 => 0, 28 => 1, _ => 4 } }
|
||||||
|
|
||||||
/// Construct a signature object from the sig.
|
/// Construct a signature object from the sig.
|
||||||
pub fn signature(&self) -> Signature { Signature::from_rsv(&From::from(&self.r), &From::from(&self.s), self.standard_v()) }
|
pub fn signature(&self) -> Signature { signature_from_rsv(&From::from(&self.r), &From::from(&self.s), self.standard_v()) }
|
||||||
|
|
||||||
/// Checks whether the signature has a low 's' value.
|
/// Checks whether the signature has a low 's' value.
|
||||||
pub fn check_low_s(&self) -> Result<(), Error> {
|
pub fn check_low_s(&self) -> Result<(), Error> {
|
||||||
@ -360,10 +361,10 @@ fn sender_test() {
|
|||||||
assert_eq!(t.gas_price, U256::from(0x01u64));
|
assert_eq!(t.gas_price, U256::from(0x01u64));
|
||||||
assert_eq!(t.nonce, U256::from(0x00u64));
|
assert_eq!(t.nonce, U256::from(0x00u64));
|
||||||
if let Action::Call(ref to) = t.action {
|
if let Action::Call(ref to) = t.action {
|
||||||
assert_eq!(*to, address_from_hex("095e7baea6a6c7c4c2dfeb977efac326af552d87"));
|
assert_eq!(*to, "095e7baea6a6c7c4c2dfeb977efac326af552d87".into());
|
||||||
} else { panic!(); }
|
} else { panic!(); }
|
||||||
assert_eq!(t.value, U256::from(0x0au64));
|
assert_eq!(t.value, U256::from(0x0au64));
|
||||||
assert_eq!(t.sender().unwrap(), address_from_hex("0f65fe9276bc9a24ae7083ae28e2660ef72df99e"));
|
assert_eq!(t.sender().unwrap(), "0f65fe9276bc9a24ae7083ae28e2660ef72df99e".into());
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
@ -16,10 +16,10 @@
|
|||||||
|
|
||||||
//! Tree route info type definition
|
//! Tree route info type definition
|
||||||
|
|
||||||
use util::numbers::H256;
|
|
||||||
use ipc::BinaryConvertError;
|
|
||||||
use std::collections::VecDeque;
|
use std::collections::VecDeque;
|
||||||
use std::mem;
|
use std::mem;
|
||||||
|
use ipc::BinaryConvertError;
|
||||||
|
use util::H256;
|
||||||
|
|
||||||
/// Represents a tree route between `from` block and `to` block:
|
/// Represents a tree route between `from` block and `to` block:
|
||||||
#[derive(Debug, Binary)]
|
#[derive(Debug, Binary)]
|
||||||
|
@ -17,7 +17,7 @@
|
|||||||
//! Binary representation of types
|
//! Binary representation of types
|
||||||
|
|
||||||
use util::bytes::Populatable;
|
use util::bytes::Populatable;
|
||||||
use util::numbers::{U256, U512, H256, H2048, Address};
|
use util::{U256, U512, H256, H2048, Address};
|
||||||
use std::mem;
|
use std::mem;
|
||||||
use std::collections::{VecDeque, BTreeMap};
|
use std::collections::{VecDeque, BTreeMap};
|
||||||
use std::ops::Range;
|
use std::ops::Range;
|
||||||
|
@ -44,7 +44,7 @@ impl Account {
|
|||||||
mod tests {
|
mod tests {
|
||||||
use serde_json;
|
use serde_json;
|
||||||
use spec::account::Account;
|
use spec::account::Account;
|
||||||
use util::numbers::U256;
|
use util::U256;
|
||||||
use uint::Uint;
|
use uint::Uint;
|
||||||
use bytes::Bytes;
|
use bytes::Bytes;
|
||||||
|
|
||||||
|
@ -19,7 +19,7 @@
|
|||||||
use std::str::FromStr;
|
use std::str::FromStr;
|
||||||
use serde::{Deserialize, Deserializer, Error};
|
use serde::{Deserialize, Deserializer, Error};
|
||||||
use serde::de::Visitor;
|
use serde::de::Visitor;
|
||||||
use util::numbers::{U256, Uint as U};
|
use util::{U256, Uint as U};
|
||||||
|
|
||||||
/// Lenient uint json deserialization for test json files.
|
/// Lenient uint json deserialization for test json files.
|
||||||
#[derive(Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
|
#[derive(Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
|
||||||
@ -88,7 +88,7 @@ impl Visitor for UintVisitor {
|
|||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod test {
|
mod test {
|
||||||
use serde_json;
|
use serde_json;
|
||||||
use util::numbers::U256;
|
use util::U256;
|
||||||
use uint::Uint;
|
use uint::Uint;
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
@ -39,7 +39,7 @@ pub struct Call {
|
|||||||
mod tests {
|
mod tests {
|
||||||
use serde_json;
|
use serde_json;
|
||||||
use vm::Call;
|
use vm::Call;
|
||||||
use util::numbers::U256;
|
use util::U256;
|
||||||
use uint::Uint;
|
use uint::Uint;
|
||||||
use util::hash::Address as Hash160;
|
use util::hash::Address as Hash160;
|
||||||
use hash::Address;
|
use hash::Address;
|
||||||
|
@ -14,7 +14,7 @@
|
|||||||
// You should have received a copy of the GNU General Public License
|
// You should have received a copy of the GNU General Public License
|
||||||
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
use util::numbers::*;
|
use util::{Address, H256, U256, Uint};
|
||||||
use util::rlp::encode;
|
use util::rlp::encode;
|
||||||
use util::bytes::ToPretty;
|
use util::bytes::ToPretty;
|
||||||
use ethcore::miner::MinerService;
|
use ethcore::miner::MinerService;
|
||||||
|
@ -27,7 +27,7 @@ use std::ops::Deref;
|
|||||||
use ethsync::{SyncProvider, SyncState};
|
use ethsync::{SyncProvider, SyncState};
|
||||||
use ethcore::miner::{MinerService, ExternalMinerService};
|
use ethcore::miner::{MinerService, ExternalMinerService};
|
||||||
use jsonrpc_core::*;
|
use jsonrpc_core::*;
|
||||||
use util::numbers::*;
|
use util::{H256, Address, FixedHash, U256, H64, Uint};
|
||||||
use util::sha3::*;
|
use util::sha3::*;
|
||||||
use util::rlp::{encode, decode, UntrustedRlp, View};
|
use util::rlp::{encode, decode, UntrustedRlp, View};
|
||||||
use util::{FromHex, Mutex};
|
use util::{FromHex, Mutex};
|
||||||
|
@ -48,4 +48,3 @@ pub use self::ethcore::EthcoreClient;
|
|||||||
pub use self::ethcore_set::EthcoreSetClient;
|
pub use self::ethcore_set::EthcoreSetClient;
|
||||||
pub use self::traces::TracesClient;
|
pub use self::traces::TracesClient;
|
||||||
pub use self::rpc::RpcClient;
|
pub use self::rpc::RpcClient;
|
||||||
|
|
||||||
|
@ -20,7 +20,7 @@ use std::sync::Arc;
|
|||||||
use std::time::{Instant, Duration};
|
use std::time::{Instant, Duration};
|
||||||
use jsonrpc_core::IoHandler;
|
use jsonrpc_core::IoHandler;
|
||||||
use util::hash::{Address, H256, FixedHash};
|
use util::hash::{Address, H256, FixedHash};
|
||||||
use util::numbers::{Uint, U256};
|
use util::{Uint, U256};
|
||||||
use util::Mutex;
|
use util::Mutex;
|
||||||
use ethcore::account_provider::AccountProvider;
|
use ethcore::account_provider::AccountProvider;
|
||||||
use ethcore::client::{TestBlockChainClient, EachBlockWith, Executed, TransactionID};
|
use ethcore::client::{TestBlockChainClient, EachBlockWith, Executed, TransactionID};
|
||||||
|
@ -22,8 +22,7 @@ use v1::impls::EthSigningQueueClient;
|
|||||||
use v1::traits::EthSigning;
|
use v1::traits::EthSigning;
|
||||||
use v1::helpers::{ConfirmationsQueue, SigningQueue};
|
use v1::helpers::{ConfirmationsQueue, SigningQueue};
|
||||||
use v1::tests::helpers::TestMinerService;
|
use v1::tests::helpers::TestMinerService;
|
||||||
use util::{Address, FixedHash};
|
use util::{Address, FixedHash, Uint, U256, H256};
|
||||||
use util::numbers::{Uint, U256, H256};
|
|
||||||
use ethcore::account_provider::AccountProvider;
|
use ethcore::account_provider::AccountProvider;
|
||||||
use ethcore::client::TestBlockChainClient;
|
use ethcore::client::TestBlockChainClient;
|
||||||
use ethcore::transaction::{Transaction, Action};
|
use ethcore::transaction::{Transaction, Action};
|
||||||
|
@ -21,7 +21,7 @@ use v1::{EthcoreSet, EthcoreSetClient};
|
|||||||
use ethcore::miner::MinerService;
|
use ethcore::miner::MinerService;
|
||||||
use ethcore::client::TestBlockChainClient;
|
use ethcore::client::TestBlockChainClient;
|
||||||
use v1::tests::helpers::TestMinerService;
|
use v1::tests::helpers::TestMinerService;
|
||||||
use util::numbers::*;
|
use util::{U256, Address};
|
||||||
use rustc_serialize::hex::FromHex;
|
use rustc_serialize::hex::FromHex;
|
||||||
use super::manage_network::TestManageNetwork;
|
use super::manage_network::TestManageNetwork;
|
||||||
use ethsync::ManageNetwork;
|
use ethsync::ManageNetwork;
|
||||||
|
@ -18,11 +18,10 @@ use std::sync::Arc;
|
|||||||
use jsonrpc_core::IoHandler;
|
use jsonrpc_core::IoHandler;
|
||||||
use v1::{Net, NetClient};
|
use v1::{Net, NetClient};
|
||||||
use v1::tests::helpers::{Config, TestSyncProvider};
|
use v1::tests::helpers::{Config, TestSyncProvider};
|
||||||
use util::numbers::*;
|
|
||||||
|
|
||||||
fn sync_provider() -> Arc<TestSyncProvider> {
|
fn sync_provider() -> Arc<TestSyncProvider> {
|
||||||
Arc::new(TestSyncProvider::new(Config {
|
Arc::new(TestSyncProvider::new(Config {
|
||||||
network_id: U256::from(3),
|
network_id: 3.into(),
|
||||||
num_peers: 120,
|
num_peers: 120,
|
||||||
}))
|
}))
|
||||||
}
|
}
|
||||||
|
@ -17,7 +17,7 @@
|
|||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
use std::str::FromStr;
|
use std::str::FromStr;
|
||||||
use jsonrpc_core::IoHandler;
|
use jsonrpc_core::IoHandler;
|
||||||
use util::numbers::*;
|
use util::{U256, Uint, Address};
|
||||||
use ethcore::account_provider::AccountProvider;
|
use ethcore::account_provider::AccountProvider;
|
||||||
use v1::{PersonalClient, Personal};
|
use v1::{PersonalClient, Personal};
|
||||||
use v1::tests::helpers::TestMinerService;
|
use v1::tests::helpers::TestMinerService;
|
||||||
|
@ -17,7 +17,7 @@
|
|||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
use std::str::FromStr;
|
use std::str::FromStr;
|
||||||
use jsonrpc_core::IoHandler;
|
use jsonrpc_core::IoHandler;
|
||||||
use util::numbers::*;
|
use util::{U256, Uint, Address};
|
||||||
use ethcore::account_provider::AccountProvider;
|
use ethcore::account_provider::AccountProvider;
|
||||||
use ethcore::client::TestBlockChainClient;
|
use ethcore::client::TestBlockChainClient;
|
||||||
use ethcore::transaction::{Transaction, Action};
|
use ethcore::transaction::{Transaction, Action};
|
||||||
|
@ -28,7 +28,7 @@ extern crate ethcore_util;
|
|||||||
extern crate rand;
|
extern crate rand;
|
||||||
|
|
||||||
use test::{Bencher, black_box};
|
use test::{Bencher, black_box};
|
||||||
use ethcore_util::numbers::*;
|
use ethcore_util::U256;
|
||||||
|
|
||||||
#[bench]
|
#[bench]
|
||||||
fn u256_add(b: &mut Bencher) {
|
fn u256_add(b: &mut Bencher) {
|
||||||
|
@ -28,7 +28,7 @@ extern crate ethcore_util;
|
|||||||
use test::Bencher;
|
use test::Bencher;
|
||||||
use std::str::FromStr;
|
use std::str::FromStr;
|
||||||
use ethcore_util::rlp::*;
|
use ethcore_util::rlp::*;
|
||||||
use ethcore_util::numbers::U256;
|
use ethcore_util::U256;
|
||||||
|
|
||||||
#[bench]
|
#[bench]
|
||||||
fn bench_stream_u64_value(b: &mut Bencher) {
|
fn bench_stream_u64_value(b: &mut Bencher) {
|
||||||
|
@ -13,6 +13,7 @@ rustc_version = "0.1"
|
|||||||
[dependencies]
|
[dependencies]
|
||||||
rustc-serialize = "0.3"
|
rustc-serialize = "0.3"
|
||||||
heapsize = "0.3"
|
heapsize = "0.3"
|
||||||
|
rand = "0.3.12"
|
||||||
|
|
||||||
[features]
|
[features]
|
||||||
x64asm_arithmetic=[]
|
x64asm_arithmetic=[]
|
||||||
|
@ -16,24 +16,19 @@
|
|||||||
|
|
||||||
//! General hash types, a fixed-size raw-data type used as the output of hash functions.
|
//! General hash types, a fixed-size raw-data type used as the output of hash functions.
|
||||||
|
|
||||||
use rustc_serialize::hex::FromHex;
|
|
||||||
use std::{ops, fmt, cmp};
|
use std::{ops, fmt, cmp};
|
||||||
use std::cmp::*;
|
use std::cmp::*;
|
||||||
use std::ops::*;
|
use std::ops::*;
|
||||||
use std::hash::{Hash, Hasher, BuildHasherDefault};
|
use std::hash::{Hash, Hasher, BuildHasherDefault};
|
||||||
use std::collections::{HashMap, HashSet};
|
use std::collections::{HashMap, HashSet};
|
||||||
use std::str::FromStr;
|
use std::str::FromStr;
|
||||||
use math::log2;
|
|
||||||
use error::UtilError;
|
|
||||||
use rand::Rng;
|
use rand::Rng;
|
||||||
use rand::os::OsRng;
|
use rand::os::OsRng;
|
||||||
use bytes::{BytesConvertable,Populatable};
|
use rustc_serialize::hex::{FromHex, FromHexError};
|
||||||
use bigint::uint::{Uint, U256};
|
use uint::{Uint, U256};
|
||||||
|
|
||||||
/// Trait for a fixed-size byte array to be used as the output of hash functions.
|
/// Trait for a fixed-size byte array to be used as the output of hash functions.
|
||||||
///
|
pub trait FixedHash: Sized {
|
||||||
/// Note: types implementing `FixedHash` must be also `BytesConvertable`.
|
|
||||||
pub trait FixedHash: Sized + BytesConvertable + Populatable + FromStr + Default {
|
|
||||||
/// Create a new, zero-initialised, instance.
|
/// Create a new, zero-initialised, instance.
|
||||||
fn new() -> Self;
|
fn new() -> Self;
|
||||||
/// Synonym for `new()`. Prefer to new as it's more readable.
|
/// Synonym for `new()`. Prefer to new as it's more readable.
|
||||||
@ -50,14 +45,6 @@ pub trait FixedHash: Sized + BytesConvertable + Populatable + FromStr + Default
|
|||||||
fn clone_from_slice(&mut self, src: &[u8]) -> usize;
|
fn clone_from_slice(&mut self, src: &[u8]) -> usize;
|
||||||
/// Copy the data of this object into some mutable slice of length `len()`.
|
/// Copy the data of this object into some mutable slice of length `len()`.
|
||||||
fn copy_to(&self, dest: &mut [u8]);
|
fn copy_to(&self, dest: &mut [u8]);
|
||||||
/// When interpreting self as a bloom output, augment (bit-wise OR) with the a bloomed version of `b`.
|
|
||||||
fn shift_bloomed<'a, T>(&'a mut self, b: &T) -> &'a mut Self where T: FixedHash;
|
|
||||||
/// Same as `shift_bloomed` except that `self` is consumed and a new value returned.
|
|
||||||
fn with_bloomed<T>(mut self, b: &T) -> Self where T: FixedHash { self.shift_bloomed(b); self }
|
|
||||||
/// Bloom the current value using the bloom parameter `m`.
|
|
||||||
fn bloom_part<T>(&self, m: usize) -> T where T: FixedHash;
|
|
||||||
/// Check to see whether this hash, interpreted as a bloom, contains the value `b` when bloomed.
|
|
||||||
fn contains_bloomed<T>(&self, b: &T) -> bool where T: FixedHash;
|
|
||||||
/// Returns `true` if all bits set in `b` are also set in `self`.
|
/// Returns `true` if all bits set in `b` are also set in `self`.
|
||||||
fn contains<'a>(&'a self, b: &'a Self) -> bool;
|
fn contains<'a>(&'a self, b: &'a Self) -> bool;
|
||||||
/// Returns `true` if no bits are set.
|
/// Returns `true` if no bits are set.
|
||||||
@ -153,54 +140,6 @@ macro_rules! impl_hash {
|
|||||||
dest[..min].copy_from_slice(&self.0[..min]);
|
dest[..min].copy_from_slice(&self.0[..min]);
|
||||||
}
|
}
|
||||||
|
|
||||||
fn shift_bloomed<'a, T>(&'a mut self, b: &T) -> &'a mut Self where T: FixedHash {
|
|
||||||
let bp: Self = b.bloom_part($size);
|
|
||||||
let new_self = &bp | self;
|
|
||||||
|
|
||||||
self.0 = new_self.0;
|
|
||||||
self
|
|
||||||
}
|
|
||||||
|
|
||||||
fn bloom_part<T>(&self, m: usize) -> T where T: FixedHash {
|
|
||||||
// numbers of bits
|
|
||||||
// TODO: move it to some constant
|
|
||||||
let p = 3;
|
|
||||||
|
|
||||||
let bloom_bits = m * 8;
|
|
||||||
let mask = bloom_bits - 1;
|
|
||||||
let bloom_bytes = (log2(bloom_bits) + 7) / 8;
|
|
||||||
|
|
||||||
// must be a power of 2
|
|
||||||
assert_eq!(m & (m - 1), 0);
|
|
||||||
// out of range
|
|
||||||
assert!(p * bloom_bytes <= $size);
|
|
||||||
|
|
||||||
// return type
|
|
||||||
let mut ret = T::new();
|
|
||||||
|
|
||||||
// 'ptr' to out slice
|
|
||||||
let mut ptr = 0;
|
|
||||||
|
|
||||||
// set p number of bits,
|
|
||||||
// p is equal 3 according to yellowpaper
|
|
||||||
for _ in 0..p {
|
|
||||||
let mut index = 0 as usize;
|
|
||||||
for _ in 0..bloom_bytes {
|
|
||||||
index = (index << 8) | self.0[ptr] as usize;
|
|
||||||
ptr += 1;
|
|
||||||
}
|
|
||||||
index &= mask;
|
|
||||||
ret.as_slice_mut()[m - 1 - index / 8] |= 1 << (index % 8);
|
|
||||||
}
|
|
||||||
|
|
||||||
ret
|
|
||||||
}
|
|
||||||
|
|
||||||
fn contains_bloomed<T>(&self, b: &T) -> bool where T: FixedHash {
|
|
||||||
let bp: Self = b.bloom_part($size);
|
|
||||||
self.contains(&bp)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn contains<'a>(&'a self, b: &'a Self) -> bool {
|
fn contains<'a>(&'a self, b: &'a Self) -> bool {
|
||||||
&(b & self) == b
|
&(b & self) == b
|
||||||
}
|
}
|
||||||
@ -219,15 +158,17 @@ macro_rules! impl_hash {
|
|||||||
}
|
}
|
||||||
|
|
||||||
impl FromStr for $from {
|
impl FromStr for $from {
|
||||||
type Err = UtilError;
|
type Err = FromHexError;
|
||||||
fn from_str(s: &str) -> Result<$from, UtilError> {
|
|
||||||
|
fn from_str(s: &str) -> Result<$from, FromHexError> {
|
||||||
let a = try!(s.from_hex());
|
let a = try!(s.from_hex());
|
||||||
if a.len() != $size { return Err(UtilError::BadSize); }
|
if a.len() != $size {
|
||||||
let mut ret = $from([0;$size]);
|
return Err(FromHexError::InvalidHexLength);
|
||||||
for i in 0..$size {
|
|
||||||
ret.0[i] = a[i];
|
|
||||||
}
|
}
|
||||||
Ok(ret)
|
|
||||||
|
let mut ret = [0;$size];
|
||||||
|
ret.copy_from_slice(&a);
|
||||||
|
Ok($from(ret))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -408,9 +349,6 @@ macro_rules! impl_hash {
|
|||||||
pub fn hex(&self) -> String {
|
pub fn hex(&self) -> String {
|
||||||
format!("{:?}", self)
|
format!("{:?}", self)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Construct new instance equal to the bloomed value of `b`.
|
|
||||||
pub fn from_bloomed<T>(b: &T) -> Self where T: FixedHash { b.bloom_part($size) }
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Default for $from {
|
impl Default for $from {
|
||||||
@ -461,13 +399,13 @@ impl<'a> From<&'a U256> for H256 {
|
|||||||
|
|
||||||
impl From<H256> for U256 {
|
impl From<H256> for U256 {
|
||||||
fn from(value: H256) -> U256 {
|
fn from(value: H256) -> U256 {
|
||||||
U256::from(value.as_slice())
|
U256::from(&value)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> From<&'a H256> for U256 {
|
impl<'a> From<&'a H256> for U256 {
|
||||||
fn from(value: &'a H256) -> U256 {
|
fn from(value: &'a H256) -> U256 {
|
||||||
U256::from(value.as_slice())
|
U256::from(value.as_ref() as &[u8])
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -503,32 +441,6 @@ impl<'a> From<&'a Address> for H256 {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Convert string `s` to an `H256`. Will panic if `s` is not 64 characters long or if any of
|
|
||||||
/// those characters are not 0-9, a-z or A-Z.
|
|
||||||
pub fn h256_from_hex(s: &str) -> H256 {
|
|
||||||
use std::str::FromStr;
|
|
||||||
H256::from_str(s).unwrap()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert `n` to an `H256`, setting the rightmost 8 bytes.
|
|
||||||
pub fn h256_from_u64(n: u64) -> H256 {
|
|
||||||
use bigint::uint::U256;
|
|
||||||
H256::from(&U256::from(n))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert string `s` to an `Address`. Will panic if `s` is not 40 characters long or if any of
|
|
||||||
/// those characters are not 0-9, a-z or A-Z.
|
|
||||||
pub fn address_from_hex(s: &str) -> Address {
|
|
||||||
use std::str::FromStr;
|
|
||||||
Address::from_str(s).unwrap()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert `n` to an `Address`, setting the rightmost 8 bytes.
|
|
||||||
pub fn address_from_u64(n: u64) -> Address {
|
|
||||||
let h256 = h256_from_u64(n);
|
|
||||||
From::from(h256)
|
|
||||||
}
|
|
||||||
|
|
||||||
impl_hash!(H32, 4);
|
impl_hash!(H32, 4);
|
||||||
impl_hash!(H64, 8);
|
impl_hash!(H64, 8);
|
||||||
impl_hash!(H128, 16);
|
impl_hash!(H128, 16);
|
||||||
@ -540,6 +452,7 @@ impl_hash!(H520, 65);
|
|||||||
impl_hash!(H1024, 128);
|
impl_hash!(H1024, 128);
|
||||||
impl_hash!(H2048, 256);
|
impl_hash!(H2048, 256);
|
||||||
|
|
||||||
|
known_heap_size!(0, H32, H64, H128, Address, H256, H264, H512, H520, H1024, H2048);
|
||||||
// Specialized HashMap and HashSet
|
// Specialized HashMap and HashSet
|
||||||
|
|
||||||
/// Hasher that just takes 8 bytes of the provided value.
|
/// Hasher that just takes 8 bytes of the provided value.
|
||||||
@ -585,7 +498,7 @@ pub type H256FastSet = HashSet<H256, BuildHasherDefault<PlainHasher>>;
|
|||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use hash::*;
|
use hash::*;
|
||||||
use bigint::uint::*;
|
use uint::*;
|
||||||
use std::str::FromStr;
|
use std::str::FromStr;
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
@ -620,28 +533,6 @@ mod tests {
|
|||||||
assert_eq!(a | b, c);
|
assert_eq!(a | b, c);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn shift_bloomed() {
|
|
||||||
use sha3::Hashable;
|
|
||||||
|
|
||||||
let bloom = H2048::from_str("00000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002020000000000000000000000000000000000000000000008000000001000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
|
|
||||||
let address = Address::from_str("ef2d6d194084c2de36e0dabfce45d046b37d1106").unwrap();
|
|
||||||
let topic = H256::from_str("02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc").unwrap();
|
|
||||||
|
|
||||||
let mut my_bloom = H2048::new();
|
|
||||||
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()));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn from_and_to_address() {
|
fn from_and_to_address() {
|
||||||
let address = Address::from_str("ef2d6d194084c2de36e0dabfce45d046b37d1106").unwrap();
|
let address = Address::from_str("ef2d6d194084c2de36e0dabfce45d046b37d1106").unwrap();
|
@ -16,7 +16,9 @@
|
|||||||
|
|
||||||
#![cfg_attr(asm_available, feature(asm))]
|
#![cfg_attr(asm_available, feature(asm))]
|
||||||
|
|
||||||
|
extern crate rand;
|
||||||
extern crate rustc_serialize;
|
extern crate rustc_serialize;
|
||||||
#[macro_use] extern crate heapsize;
|
#[macro_use] extern crate heapsize;
|
||||||
|
|
||||||
pub mod uint;
|
pub mod uint;
|
||||||
|
pub mod hash;
|
||||||
|
@ -1129,6 +1129,12 @@ macro_rules! construct_uint {
|
|||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl From<&'static str> for $name {
|
||||||
|
fn from(s: &'static str) -> Self {
|
||||||
|
s.parse().unwrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1150,7 +1150,7 @@ fn key_save_load() {
|
|||||||
#[test]
|
#[test]
|
||||||
fn host_client_url() {
|
fn host_client_url() {
|
||||||
let mut config = NetworkConfiguration::new();
|
let mut config = NetworkConfiguration::new();
|
||||||
let key = h256_from_hex("6f7b0d801bc7b5ce7bbd930b84fd0369b3eb25d09be58d64ba811091046f3aa2");
|
let key = "6f7b0d801bc7b5ce7bbd930b84fd0369b3eb25d09be58d64ba811091046f3aa2".into();
|
||||||
config.use_secret = Some(key);
|
config.use_secret = Some(key);
|
||||||
let host: Host = Host::new(config, Arc::new(NetworkStats::new())).unwrap();
|
let host: Host = Host::new(config, Arc::new(NetworkStats::new())).unwrap();
|
||||||
assert!(host.local_url().starts_with("enode://101b3ef5a4ea7a1c7928e24c4c75fd053c235d7b80c22ae5c03d145d0ac7396e2a4ffff9adee3133a7b05044a5cee08115fd65145e5165d646bde371010d803c@"));
|
assert!(host.local_url().starts_with("enode://101b3ef5a4ea7a1c7928e24c4c75fd053c235d7b80c22ae5c03d145d0ac7396e2a4ffff9adee3133a7b05044a5cee08115fd65145e5165d646bde371010d803c@"));
|
||||||
|
@ -27,6 +27,7 @@ use std::fs;
|
|||||||
use std::io::{Read, Write};
|
use std::io::{Read, Write};
|
||||||
use util::hash::*;
|
use util::hash::*;
|
||||||
use util::rlp::*;
|
use util::rlp::*;
|
||||||
|
use util::UtilError;
|
||||||
use time::Tm;
|
use time::Tm;
|
||||||
use error::NetworkError;
|
use error::NetworkError;
|
||||||
use discovery::{TableUpdates, NodeEntry};
|
use discovery::{TableUpdates, NodeEntry};
|
||||||
@ -164,7 +165,7 @@ impl FromStr for Node {
|
|||||||
type Err = NetworkError;
|
type Err = NetworkError;
|
||||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||||
let (id, endpoint) = if s.len() > 136 && &s[0..8] == "enode://" && &s[136..137] == "@" {
|
let (id, endpoint) = if s.len() > 136 && &s[0..8] == "enode://" && &s[136..137] == "@" {
|
||||||
(try!(NodeId::from_str(&s[8..136])), try!(NodeEndpoint::from_str(&s[137..])))
|
(try!(s[8..136].parse().map_err(UtilError::from)), try!(NodeEndpoint::from_str(&s[137..])))
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
(NodeId::new(), try!(NodeEndpoint::from_str(s)))
|
(NodeId::new(), try!(NodeEndpoint::from_str(s)))
|
||||||
|
145
util/src/bloom.rs
Normal file
145
util/src/bloom.rs
Normal file
@ -0,0 +1,145 @@
|
|||||||
|
// Copyright 2015, 2016 Ethcore (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/>.
|
||||||
|
|
||||||
|
//! Bloom operations.
|
||||||
|
|
||||||
|
use std::mem;
|
||||||
|
use std::ops::DerefMut;
|
||||||
|
use {H64, Address, H256, H512, H520, H2048, FixedHash};
|
||||||
|
|
||||||
|
/// Returns log2.
|
||||||
|
pub fn log2(x: usize) -> u32 {
|
||||||
|
if x <= 1 {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
let n = x.leading_zeros();
|
||||||
|
mem::size_of::<usize>() as u32 * 8 - n
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Bloom operations.
|
||||||
|
pub trait Bloomable: Sized + Default + DerefMut<Target = [u8]> {
|
||||||
|
/// When interpreting self as a bloom output, augment (bit-wise OR) with the a bloomed version of `b`.
|
||||||
|
fn shift_bloomed<'a, T>(&'a mut self, b: &T) -> &'a mut Self where T: Bloomable;
|
||||||
|
|
||||||
|
/// Same as `shift_bloomed` except that `self` is consumed and a new value returned.
|
||||||
|
fn with_bloomed<T>(mut self, b: &T) -> Self where T: Bloomable {
|
||||||
|
self.shift_bloomed(b);
|
||||||
|
self
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct new instance equal to the bloomed value of `b`.
|
||||||
|
fn from_bloomed<T>(b: &T) -> Self where T: Bloomable;
|
||||||
|
|
||||||
|
/// Bloom the current value using the bloom parameter `m`.
|
||||||
|
fn bloom_part<T>(&self, m: usize) -> T where T: Bloomable;
|
||||||
|
|
||||||
|
/// Check to see whether this hash, interpreted as a bloom, contains the value `b` when bloomed.
|
||||||
|
fn contains_bloomed<T>(&self, b: &T) -> bool where T: Bloomable;
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! impl_bloomable_for_hash {
|
||||||
|
($name: ident, $size: expr) => {
|
||||||
|
impl Bloomable for $name {
|
||||||
|
fn shift_bloomed<'a, T>(&'a mut self, b: &T) -> &'a mut Self where T: Bloomable {
|
||||||
|
let bp: Self = b.bloom_part($size);
|
||||||
|
let new_self = &bp | self;
|
||||||
|
|
||||||
|
self.0 = new_self.0;
|
||||||
|
self
|
||||||
|
}
|
||||||
|
|
||||||
|
fn bloom_part<T>(&self, m: usize) -> T where T: Bloomable + Default {
|
||||||
|
// numbers of bits
|
||||||
|
// TODO: move it to some constant
|
||||||
|
let p = 3;
|
||||||
|
|
||||||
|
let bloom_bits = m * 8;
|
||||||
|
let mask = bloom_bits - 1;
|
||||||
|
let bloom_bytes = (log2(bloom_bits) + 7) / 8;
|
||||||
|
|
||||||
|
// must be a power of 2
|
||||||
|
assert_eq!(m & (m - 1), 0);
|
||||||
|
// out of range
|
||||||
|
assert!(p * bloom_bytes <= $size);
|
||||||
|
|
||||||
|
// return type
|
||||||
|
let mut ret = T::default();
|
||||||
|
|
||||||
|
// 'ptr' to out slice
|
||||||
|
let mut ptr = 0;
|
||||||
|
|
||||||
|
// set p number of bits,
|
||||||
|
// p is equal 3 according to yellowpaper
|
||||||
|
for _ in 0..p {
|
||||||
|
let mut index = 0 as usize;
|
||||||
|
for _ in 0..bloom_bytes {
|
||||||
|
index = (index << 8) | self.0[ptr] as usize;
|
||||||
|
ptr += 1;
|
||||||
|
}
|
||||||
|
index &= mask;
|
||||||
|
ret[m - 1 - index / 8] |= 1 << (index % 8);
|
||||||
|
}
|
||||||
|
|
||||||
|
ret
|
||||||
|
}
|
||||||
|
|
||||||
|
fn contains_bloomed<T>(&self, b: &T) -> bool where T: Bloomable {
|
||||||
|
let bp: Self = b.bloom_part($size);
|
||||||
|
self.contains(&bp)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn from_bloomed<T>(b: &T) -> Self where T: Bloomable {
|
||||||
|
b.bloom_part($size)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_bloomable_for_hash!(H64, 8);
|
||||||
|
impl_bloomable_for_hash!(Address, 20);
|
||||||
|
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 {Address, H256, H2048};
|
||||||
|
use sha3::Hashable;
|
||||||
|
use super::Bloomable;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn shift_bloomed() {
|
||||||
|
let bloom: H2048 = "00000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002020000000000000000000000000000000000000000000008000000001000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into();
|
||||||
|
let address: Address = "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()));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -232,11 +232,12 @@ fn fax_raw_dyn() {
|
|||||||
#[test]
|
#[test]
|
||||||
fn populate_big_types() {
|
fn populate_big_types() {
|
||||||
use hash::*;
|
use hash::*;
|
||||||
let a = address_from_hex("ffffffffffffffffffffffffffffffffffffffff");
|
let a: Address = "ffffffffffffffffffffffffffffffffffffffff".into();
|
||||||
let mut h = h256_from_u64(0x69);
|
let mut h: H256 = 0x69.into();
|
||||||
h.populate_raw_from(&a);
|
h.populate_raw_from(&a);
|
||||||
assert_eq!(h, h256_from_hex("ffffffffffffffffffffffffffffffffffffffff000000000000000000000000"));
|
assert_eq!(h, "ffffffffffffffffffffffffffffffffffffffff000000000000000000000000".into());
|
||||||
let mut h = h256_from_u64(0x69);
|
|
||||||
|
let mut h: H256 = 0x69.into();
|
||||||
h.copy_raw_from(&a);
|
h.copy_raw_from(&a);
|
||||||
assert_eq!(h, h256_from_hex("ffffffffffffffffffffffffffffffffffffffff000000000000000000000069"));
|
assert_eq!(h, "ffffffffffffffffffffffffffffffffffffffff000000000000000000000069".into());
|
||||||
}
|
}
|
||||||
|
@ -21,8 +21,10 @@ pub use from_json::*;
|
|||||||
pub use error::*;
|
pub use error::*;
|
||||||
pub use bytes::*;
|
pub use bytes::*;
|
||||||
pub use vector::*;
|
pub use vector::*;
|
||||||
pub use numbers::*;
|
|
||||||
pub use sha3::*;
|
pub use sha3::*;
|
||||||
|
pub use bigint::hash::*;
|
||||||
|
pub use bigint::uint::*;
|
||||||
|
pub use bigint::hash;
|
||||||
|
|
||||||
#[macro_export]
|
#[macro_export]
|
||||||
macro_rules! vec_into {
|
macro_rules! vec_into {
|
||||||
|
@ -16,7 +16,8 @@
|
|||||||
|
|
||||||
//! Ethcore crypto.
|
//! Ethcore crypto.
|
||||||
|
|
||||||
use numbers::*;
|
use bigint::uint::*;
|
||||||
|
use bigint::hash::*;
|
||||||
use bytes::*;
|
use bytes::*;
|
||||||
use secp256k1::{key, Secp256k1};
|
use secp256k1::{key, Secp256k1};
|
||||||
use rand::os::OsRng;
|
use rand::os::OsRng;
|
||||||
@ -35,21 +36,19 @@ lazy_static! {
|
|||||||
static ref SECP256K1: Secp256k1 = Secp256k1::new();
|
static ref SECP256K1: Secp256k1 = Secp256k1::new();
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Signature {
|
/// Create a new signature from the R, S and V componenets.
|
||||||
/// Create a new signature from the R, S and V componenets.
|
pub fn signature_from_rsv(r: &H256, s: &H256, v: u8) -> Signature {
|
||||||
pub fn from_rsv(r: &H256, s: &H256, v: u8) -> Signature {
|
|
||||||
let mut ret: Signature = Signature::new();
|
let mut ret: Signature = Signature::new();
|
||||||
(&mut ret[0..32]).copy_from_slice(r);
|
(&mut ret[0..32]).copy_from_slice(r);
|
||||||
(&mut ret[32..64]).copy_from_slice(s);
|
(&mut ret[32..64]).copy_from_slice(s);
|
||||||
|
|
||||||
ret[64] = v;
|
ret[64] = v;
|
||||||
ret
|
ret
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Convert transaction to R, S and V components.
|
/// Convert transaction to R, S and V components.
|
||||||
pub fn to_rsv(&self) -> (U256, U256, u8) {
|
pub fn signature_to_rsv(s: &Signature) -> (U256, U256, u8) {
|
||||||
(U256::from(&self.as_slice()[0..32]), U256::from(&self.as_slice()[32..64]), self[64])
|
(U256::from(&s.as_slice()[0..32]), U256::from(&s.as_slice()[32..64]), s[64])
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
@ -174,7 +173,8 @@ impl KeyPair {
|
|||||||
/// EC functions
|
/// EC functions
|
||||||
#[cfg_attr(feature="dev", allow(similar_names))]
|
#[cfg_attr(feature="dev", allow(similar_names))]
|
||||||
pub mod ec {
|
pub mod ec {
|
||||||
use numbers::*;
|
use bigint::hash::*;
|
||||||
|
use bigint::uint::*;
|
||||||
use standard::*;
|
use standard::*;
|
||||||
use crypto::*;
|
use crypto::*;
|
||||||
use crypto::{self};
|
use crypto::{self};
|
||||||
@ -204,10 +204,10 @@ pub mod ec {
|
|||||||
signature.clone_from_slice(&data);
|
signature.clone_from_slice(&data);
|
||||||
signature[64] = rec_id.to_i32() as u8;
|
signature[64] = rec_id.to_i32() as u8;
|
||||||
|
|
||||||
let (_, s, v) = signature.to_rsv();
|
let (_, s, v) = signature_to_rsv(&signature);
|
||||||
let secp256k1n = U256::from_str("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141").unwrap();
|
let secp256k1n = U256::from_str("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141").unwrap();
|
||||||
if !is_low_s(&s) {
|
if !is_low_s(&s) {
|
||||||
signature = super::Signature::from_rsv(&H256::from_slice(&signature[0..32]), &H256::from(secp256k1n - s), v ^ 1);
|
signature = super::signature_from_rsv(&H256::from_slice(&signature[0..32]), &H256::from(secp256k1n - s), v ^ 1);
|
||||||
}
|
}
|
||||||
Ok(signature)
|
Ok(signature)
|
||||||
}
|
}
|
||||||
@ -235,7 +235,7 @@ pub mod ec {
|
|||||||
|
|
||||||
/// Check if this is a "low" signature.
|
/// Check if this is a "low" signature.
|
||||||
pub fn is_low(sig: &Signature) -> bool {
|
pub fn is_low(sig: &Signature) -> bool {
|
||||||
H256::from_slice(&sig[32..64]) <= h256_from_hex("7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0")
|
H256::from_slice(&sig[32..64]) <= "7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0".into()
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Check if this is a "low" signature.
|
/// Check if this is a "low" signature.
|
||||||
@ -246,10 +246,10 @@ pub mod ec {
|
|||||||
/// Check if each component of the signature is in range.
|
/// Check if each component of the signature is in range.
|
||||||
pub fn is_valid(sig: &Signature) -> bool {
|
pub fn is_valid(sig: &Signature) -> bool {
|
||||||
sig[64] <= 1 &&
|
sig[64] <= 1 &&
|
||||||
H256::from_slice(&sig[0..32]) < h256_from_hex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141") &&
|
H256::from_slice(&sig[0..32]) < "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141".into() &&
|
||||||
H256::from_slice(&sig[32..64]) < h256_from_hex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141") &&
|
H256::from_slice(&sig[32..64]) < "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141".into() &&
|
||||||
H256::from_slice(&sig[32..64]) >= h256_from_u64(1) &&
|
H256::from_slice(&sig[32..64]) >= 1.into() &&
|
||||||
H256::from_slice(&sig[0..32]) >= h256_from_u64(1)
|
H256::from_slice(&sig[0..32]) >= 1.into()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -432,14 +432,14 @@ mod tests {
|
|||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_invalid_key() {
|
fn test_invalid_key() {
|
||||||
assert!(KeyPair::from_secret(h256_from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).is_err());
|
assert!(KeyPair::from_secret("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff".into()).is_err());
|
||||||
assert!(KeyPair::from_secret(h256_from_hex("0000000000000000000000000000000000000000000000000000000000000000")).is_err());
|
assert!(KeyPair::from_secret("0000000000000000000000000000000000000000000000000000000000000000".into()).is_err());
|
||||||
assert!(KeyPair::from_secret(h256_from_hex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141")).is_err());
|
assert!(KeyPair::from_secret("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141".into()).is_err());
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_key() {
|
fn test_key() {
|
||||||
let pair = KeyPair::from_secret(h256_from_hex("6f7b0d801bc7b5ce7bbd930b84fd0369b3eb25d09be58d64ba811091046f3aa2")).unwrap();
|
let pair = KeyPair::from_secret("6f7b0d801bc7b5ce7bbd930b84fd0369b3eb25d09be58d64ba811091046f3aa2".into()).unwrap();
|
||||||
assert_eq!(pair.public().hex(), "101b3ef5a4ea7a1c7928e24c4c75fd053c235d7b80c22ae5c03d145d0ac7396e2a4ffff9adee3133a7b05044a5cee08115fd65145e5165d646bde371010d803c");
|
assert_eq!(pair.public().hex(), "101b3ef5a4ea7a1c7928e24c4c75fd053c235d7b80c22ae5c03d145d0ac7396e2a4ffff9adee3133a7b05044a5cee08115fd65145e5165d646bde371010d803c");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1,22 +0,0 @@
|
|||||||
// Copyright 2015, 2016 Ethcore (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/>.
|
|
||||||
|
|
||||||
//! Calculates heapsize of util types.
|
|
||||||
|
|
||||||
use hash::*;
|
|
||||||
|
|
||||||
known_heap_size!(0, H32, H64, H128, Address, H256, H264, H512, H520, H1024, H2048);
|
|
||||||
|
|
@ -111,14 +111,13 @@ pub extern crate using_queue;
|
|||||||
pub extern crate table;
|
pub extern crate table;
|
||||||
extern crate ansi_term;
|
extern crate ansi_term;
|
||||||
|
|
||||||
|
pub mod bloom;
|
||||||
pub mod standard;
|
pub mod standard;
|
||||||
#[macro_use]
|
#[macro_use]
|
||||||
pub mod from_json;
|
pub mod from_json;
|
||||||
#[macro_use]
|
#[macro_use]
|
||||||
pub mod common;
|
pub mod common;
|
||||||
pub mod numbers;
|
|
||||||
pub mod error;
|
pub mod error;
|
||||||
pub mod hash;
|
|
||||||
pub mod bytes;
|
pub mod bytes;
|
||||||
pub mod rlp;
|
pub mod rlp;
|
||||||
pub mod misc;
|
pub mod misc;
|
||||||
@ -130,13 +129,11 @@ pub mod migration;
|
|||||||
pub mod overlaydb;
|
pub mod overlaydb;
|
||||||
pub mod journaldb;
|
pub mod journaldb;
|
||||||
pub mod kvdb;
|
pub mod kvdb;
|
||||||
mod math;
|
|
||||||
pub mod crypto;
|
pub mod crypto;
|
||||||
pub mod triehash;
|
pub mod triehash;
|
||||||
pub mod trie;
|
pub mod trie;
|
||||||
pub mod nibbleslice;
|
pub mod nibbleslice;
|
||||||
pub mod nibblevec;
|
pub mod nibblevec;
|
||||||
mod heapsizeof;
|
|
||||||
pub mod semantic_version;
|
pub mod semantic_version;
|
||||||
pub mod log;
|
pub mod log;
|
||||||
pub mod path;
|
pub mod path;
|
||||||
@ -150,7 +147,6 @@ pub use hashdb::*;
|
|||||||
pub use memorydb::*;
|
pub use memorydb::*;
|
||||||
pub use overlaydb::*;
|
pub use overlaydb::*;
|
||||||
pub use journaldb::JournalDB;
|
pub use journaldb::JournalDB;
|
||||||
pub use math::*;
|
|
||||||
pub use crypto::*;
|
pub use crypto::*;
|
||||||
pub use triehash::*;
|
pub use triehash::*;
|
||||||
pub use trie::{Trie, TrieMut, TrieDB, TrieDBMut, TrieFactory, TrieError, SecTrieDB, SecTrieDBMut};
|
pub use trie::{Trie, TrieMut, TrieDB, TrieDBMut, TrieFactory, TrieError, SecTrieDB, SecTrieDBMut};
|
||||||
@ -162,8 +158,8 @@ pub use timer::*;
|
|||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::numbers::*;
|
|
||||||
use std::str::FromStr;
|
use std::str::FromStr;
|
||||||
|
use {U256, H256, Uint};
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn u256_multi_muls() {
|
fn u256_multi_muls() {
|
||||||
|
@ -1,27 +0,0 @@
|
|||||||
// Copyright 2015, 2016 Ethcore (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/>.
|
|
||||||
|
|
||||||
//! Common math functions.
|
|
||||||
|
|
||||||
/// Returns log2.
|
|
||||||
pub fn log2(x: usize) -> u32 {
|
|
||||||
if x <= 1 {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
let n = x.leading_zeros();
|
|
||||||
::std::mem::size_of::<usize>() as u32 * 8 - n
|
|
||||||
}
|
|
@ -1,20 +0,0 @@
|
|||||||
// Copyright 2015, 2016 Ethcore (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/>.
|
|
||||||
|
|
||||||
//! Utils number types.
|
|
||||||
|
|
||||||
pub use hash::*;
|
|
||||||
pub use bigint::uint::*;
|
|
Loading…
Reference in New Issue
Block a user