for Builtin {
@@ -108,14 +109,13 @@ struct Sha256;
struct Ripemd160;
impl Impl for Identity {
- fn execute(&self, input: &[u8], output: &mut [u8]) {
- let len = min(input.len(), output.len());
- output[..len].copy_from_slice(&input[..len]);
+ fn execute(&self, input: &[u8], output: &mut BytesRef) {
+ output.write(0, input);
}
}
impl Impl for EcRecover {
- fn execute(&self, i: &[u8], output: &mut [u8]) {
+ fn execute(&self, i: &[u8], output: &mut BytesRef) {
let len = min(i.len(), 128);
let mut input = [0; 128];
@@ -135,58 +135,34 @@ impl Impl for EcRecover {
if s.is_valid() {
if let Ok(p) = ec_recover(&s, &hash) {
let r = p.sha3();
-
- let out_len = min(output.len(), 32);
-
- for x in &mut output[0.. min(12, out_len)] {
- *x = 0;
- }
-
- if out_len > 12 {
- output[12..out_len].copy_from_slice(&r[12..out_len]);
- }
+ output.write(0, &[0; 12]);
+ output.write(12, &r[12..r.len()]);
}
}
}
}
impl Impl for Sha256 {
- fn execute(&self, input: &[u8], output: &mut [u8]) {
- let out_len = min(output.len(), 32);
-
+ fn execute(&self, input: &[u8], output: &mut BytesRef) {
let mut sha = Sha256Digest::new();
sha.input(input);
- if out_len == 32 {
- sha.result(&mut output[0..32]);
- } else {
- let mut out = [0; 32];
- sha.result(&mut out);
+ let mut out = [0; 32];
+ sha.result(&mut out);
- output.copy_from_slice(&out[..out_len])
- }
+ output.write(0, &out);
}
}
impl Impl for Ripemd160 {
- fn execute(&self, input: &[u8], output: &mut [u8]) {
- let out_len = min(output.len(), 32);
-
+ fn execute(&self, input: &[u8], output: &mut BytesRef) {
let mut sha = Ripemd160Digest::new();
sha.input(input);
- for x in &mut output[0.. min(12, out_len)] {
- *x = 0;
- }
+ let mut out = [0; 32];
+ sha.result(&mut out[12..32]);
- if out_len >= 32 {
- sha.result(&mut output[12..32]);
- } else if out_len > 12 {
- let mut out = [0; 20];
- sha.result(&mut out);
-
- output.copy_from_slice(&out[12..out_len])
- }
+ output.write(0, &out);
}
}
@@ -194,7 +170,7 @@ impl Impl for Ripemd160 {
mod tests {
use super::{Builtin, Linear, ethereum_builtin, Pricer};
use ethjson;
- use util::U256;
+ use util::{U256, BytesRef};
#[test]
fn identity() {
@@ -203,15 +179,15 @@ mod tests {
let i = [0u8, 1, 2, 3];
let mut o2 = [255u8; 2];
- f.execute(&i[..], &mut o2[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o2[..]));
assert_eq!(i[0..2], o2);
let mut o4 = [255u8; 4];
- f.execute(&i[..], &mut o4[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o4[..]));
assert_eq!(i, o4);
let mut o8 = [255u8; 8];
- f.execute(&i[..], &mut o8[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o8[..]));
assert_eq!(i, o8[..4]);
assert_eq!([255u8; 4], o8[4..]);
}
@@ -224,16 +200,20 @@ mod tests {
let i = [0u8; 0];
let mut o = [255u8; 32];
- f.execute(&i[..], &mut o[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o[..]));
assert_eq!(&o[..], &(FromHex::from_hex("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855").unwrap())[..]);
let mut o8 = [255u8; 8];
- f.execute(&i[..], &mut o8[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o8[..]));
assert_eq!(&o8[..], &(FromHex::from_hex("e3b0c44298fc1c14").unwrap())[..]);
let mut o34 = [255u8; 34];
- f.execute(&i[..], &mut o34[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o34[..]));
assert_eq!(&o34[..], &(FromHex::from_hex("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855ffff").unwrap())[..]);
+
+ let mut ov = vec![];
+ f.execute(&i[..], &mut BytesRef::Flexible(&mut ov));
+ assert_eq!(&ov[..], &(FromHex::from_hex("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855").unwrap())[..]);
}
#[test]
@@ -244,15 +224,15 @@ mod tests {
let i = [0u8; 0];
let mut o = [255u8; 32];
- f.execute(&i[..], &mut o[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o[..]));
assert_eq!(&o[..], &(FromHex::from_hex("0000000000000000000000009c1185a5c5e9fc54612808977ee8f548b2258d31").unwrap())[..]);
let mut o8 = [255u8; 8];
- f.execute(&i[..], &mut o8[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o8[..]));
assert_eq!(&o8[..], &(FromHex::from_hex("0000000000000000").unwrap())[..]);
let mut o34 = [255u8; 34];
- f.execute(&i[..], &mut o34[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o34[..]));
assert_eq!(&o34[..], &(FromHex::from_hex("0000000000000000000000009c1185a5c5e9fc54612808977ee8f548b2258d31ffff").unwrap())[..]);
}
@@ -272,46 +252,46 @@ mod tests {
let i = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b650acf9d3f5f0a2c799776a1254355d5f4061762a237396a99a0e0e3fc2bcd6729514a0dacb2e623ac4abd157cb18163ff942280db4d5caad66ddf941ba12e03").unwrap();
let mut o = [255u8; 32];
- f.execute(&i[..], &mut o[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o[..]));
assert_eq!(&o[..], &(FromHex::from_hex("000000000000000000000000c08b5542d177ac6686946920409741463a15dddb").unwrap())[..]);
let mut o8 = [255u8; 8];
- f.execute(&i[..], &mut o8[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o8[..]));
assert_eq!(&o8[..], &(FromHex::from_hex("0000000000000000").unwrap())[..]);
let mut o34 = [255u8; 34];
- f.execute(&i[..], &mut o34[..]);
+ f.execute(&i[..], &mut BytesRef::Fixed(&mut o34[..]));
assert_eq!(&o34[..], &(FromHex::from_hex("000000000000000000000000c08b5542d177ac6686946920409741463a15dddbffff").unwrap())[..]);
let i_bad = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001a650acf9d3f5f0a2c799776a1254355d5f4061762a237396a99a0e0e3fc2bcd6729514a0dacb2e623ac4abd157cb18163ff942280db4d5caad66ddf941ba12e03").unwrap();
let mut o = [255u8; 32];
- f.execute(&i_bad[..], &mut o[..]);
+ f.execute(&i_bad[..], &mut BytesRef::Fixed(&mut o[..]));
assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]);
let i_bad = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b000000000000000000000000000000000000000000000000000000000000001b0000000000000000000000000000000000000000000000000000000000000000").unwrap();
let mut o = [255u8; 32];
- f.execute(&i_bad[..], &mut o[..]);
+ f.execute(&i_bad[..], &mut BytesRef::Fixed(&mut o[..]));
assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]);
let i_bad = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001b").unwrap();
let mut o = [255u8; 32];
- f.execute(&i_bad[..], &mut o[..]);
+ f.execute(&i_bad[..], &mut BytesRef::Fixed(&mut o[..]));
assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]);
let i_bad = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000000000000000000000000000000000000000000000000000001b").unwrap();
let mut o = [255u8; 32];
- f.execute(&i_bad[..], &mut o[..]);
+ f.execute(&i_bad[..], &mut BytesRef::Fixed(&mut o[..]));
assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]);
let i_bad = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b000000000000000000000000000000000000000000000000000000000000001bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
let mut o = [255u8; 32];
- f.execute(&i_bad[..], &mut o[..]);
+ f.execute(&i_bad[..], &mut BytesRef::Fixed(&mut o[..]));
assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]);
// TODO: Should this (corrupted version of the above) fail rather than returning some address?
/* let i_bad = FromHex::from_hex("48173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b650acf9d3f5f0a2c799776a1254355d5f4061762a237396a99a0e0e3fc2bcd6729514a0dacb2e623ac4abd157cb18163ff942280db4d5caad66ddf941ba12e03").unwrap();
let mut o = [255u8; 32];
- f.execute(&i_bad[..], &mut o[..]);
+ f.execute(&i_bad[..], &mut BytesRef::Fixed(&mut o[..]));
assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]);*/
}
@@ -336,7 +316,7 @@ mod tests {
let i = [0u8, 1, 2, 3];
let mut o = [255u8; 4];
- b.execute(&i[..], &mut o[..]);
+ b.execute(&i[..], &mut BytesRef::Fixed(&mut o[..]));
assert_eq!(i, o);
}
@@ -357,7 +337,7 @@ mod tests {
let i = [0u8, 1, 2, 3];
let mut o = [255u8; 4];
- b.execute(&i[..], &mut o[..]);
+ b.execute(&i[..], &mut BytesRef::Fixed(&mut o[..]));
assert_eq!(i, o);
}
-}
\ No newline at end of file
+}
diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs
index 863130699..445ec37f7 100644
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@@ -144,7 +144,9 @@ pub struct Client {
factories: Factories,
}
-const HISTORY: u64 = 1200;
+/// The pruning constant -- how old blocks must be before we
+/// assume finality of a given candidate.
+pub const HISTORY: u64 = 1200;
/// Append a path element to the given path and return the string.
pub fn append_path(path: P, item: &str) -> String where P: AsRef {
@@ -168,7 +170,7 @@ impl Client {
let db = Arc::new(try!(Database::open(&db_config, &path.to_str().unwrap()).map_err(ClientError::Database)));
let chain = Arc::new(BlockChain::new(config.blockchain.clone(), &gb, db.clone()));
- let tracedb = RwLock::new(try!(TraceDB::new(config.tracing.clone(), db.clone(), chain.clone())));
+ let tracedb = RwLock::new(TraceDB::new(config.tracing.clone(), db.clone(), chain.clone()));
let mut state_db = journaldb::new(db.clone(), config.pruning, ::db::COL_STATE);
if state_db.is_empty() && try!(spec.ensure_db_good(state_db.as_hashdb_mut())) {
@@ -685,7 +687,7 @@ impl snapshot::DatabaseRestore for Client {
*state_db = journaldb::new(db.clone(), self.pruning, ::db::COL_STATE);
*chain = Arc::new(BlockChain::new(self.config.blockchain.clone(), &[], db.clone()));
- *tracedb = try!(TraceDB::new(self.config.tracing.clone(), db.clone(), chain.clone()).map_err(ClientError::from));
+ *tracedb = TraceDB::new(self.config.tracing.clone(), db.clone(), chain.clone());
Ok(())
}
}
@@ -957,7 +959,7 @@ impl BlockChainClient for Client {
}
}
- fn logs(&self, filter: Filter, limit: Option) -> Vec {
+ fn logs(&self, filter: Filter) -> Vec {
let blocks = filter.bloom_possibilities().iter()
.filter_map(|bloom| self.blocks_with_bloom(bloom, filter.from_block.clone(), filter.to_block.clone()))
.flat_map(|m| m)
@@ -966,7 +968,7 @@ impl BlockChainClient for Client {
.into_iter()
.collect::>();
- self.chain.read().logs(blocks, |entry| filter.matches(entry), limit)
+ self.chain.read().logs(blocks, |entry| filter.matches(entry), filter.limit)
}
fn filter_traces(&self, filter: TraceFilter) -> Option> {
diff --git a/ethcore/src/client/config.rs b/ethcore/src/client/config.rs
index bb70de6cd..0146293df 100644
--- a/ethcore/src/client/config.rs
+++ b/ethcore/src/client/config.rs
@@ -18,7 +18,7 @@ use std::str::FromStr;
pub use std::time::Duration;
pub use block_queue::BlockQueueConfig;
pub use blockchain::Config as BlockChainConfig;
-pub use trace::{Config as TraceConfig, Switch};
+pub use trace::Config as TraceConfig;
pub use evm::VMType;
pub use verification::VerifierType;
use util::{journaldb, CompactionProfile};
@@ -102,7 +102,7 @@ pub struct ClientConfig {
/// State db compaction profile
pub db_compaction: DatabaseCompactionProfile,
/// Should db have WAL enabled?
- pub db_wal: bool,
+ pub db_wal: bool,
/// Operating mode
pub mode: Mode,
/// Type of block verifier used by client.
diff --git a/ethcore/src/client/mod.rs b/ethcore/src/client/mod.rs
index 32582ddf2..a5ff89c47 100644
--- a/ethcore/src/client/mod.rs
+++ b/ethcore/src/client/mod.rs
@@ -23,7 +23,7 @@ mod trace;
mod client;
pub use self::client::*;
-pub use self::config::{Mode, ClientConfig, DatabaseCompactionProfile, BlockQueueConfig, BlockChainConfig, Switch, VMType};
+pub use self::config::{Mode, ClientConfig, DatabaseCompactionProfile, BlockQueueConfig, BlockChainConfig, VMType};
pub use self::error::Error;
pub use types::ids::*;
pub use self::test_client::{TestBlockChainClient, EachBlockWith};
diff --git a/ethcore/src/client/test_client.rs b/ethcore/src/client/test_client.rs
index 0c0a443d6..c0d7e35ba 100644
--- a/ethcore/src/client/test_client.rs
+++ b/ethcore/src/client/test_client.rs
@@ -67,6 +67,8 @@ pub struct TestBlockChainClient {
pub execution_result: RwLock>>,
/// Transaction receipts.
pub receipts: RwLock>,
+ /// Logs
+ pub logs: RwLock>,
/// Block queue size.
pub queue_size: AtomicUsize,
/// Miner
@@ -114,6 +116,7 @@ impl TestBlockChainClient {
code: RwLock::new(HashMap::new()),
execution_result: RwLock::new(None),
receipts: RwLock::new(HashMap::new()),
+ logs: RwLock::new(Vec::new()),
queue_size: AtomicUsize::new(0),
miner: Arc::new(Miner::with_spec(&spec)),
spec: spec,
@@ -165,6 +168,11 @@ impl TestBlockChainClient {
*self.latest_block_timestamp.write() = ts;
}
+ /// Set logs to return for each logs call.
+ pub fn set_logs(&self, logs: Vec) {
+ *self.logs.write() = logs;
+ }
+
/// Add blocks to test client.
pub fn add_blocks(&self, count: usize, with: EachBlockWith) {
let len = self.numbers.read().len();
@@ -390,8 +398,13 @@ impl BlockChainClient for TestBlockChainClient {
unimplemented!();
}
- fn logs(&self, _filter: Filter, _limit: Option) -> Vec {
- Vec::new()
+ fn logs(&self, filter: Filter) -> Vec {
+ let mut logs = self.logs.read().clone();
+ let len = logs.len();
+ match filter.limit {
+ Some(limit) if limit <= len => logs.split_off(len - limit),
+ _ => logs,
+ }
}
fn last_hashes(&self) -> LastHashes {
diff --git a/ethcore/src/client/traits.rs b/ethcore/src/client/traits.rs
index f262aabbd..45f7322fd 100644
--- a/ethcore/src/client/traits.rs
+++ b/ethcore/src/client/traits.rs
@@ -156,7 +156,7 @@ pub trait BlockChainClient : Sync + Send {
fn blocks_with_bloom(&self, bloom: &H2048, from_block: BlockID, to_block: BlockID) -> Option>;
/// Returns logs matching given filter.
- fn logs(&self, filter: Filter, limit: Option) -> Vec;
+ fn logs(&self, filter: Filter) -> Vec;
/// Makes a non-persistent transaction call.
fn call(&self, t: &SignedTransaction, block: BlockID, analytics: CallAnalytics) -> Result;
@@ -215,8 +215,11 @@ pub trait BlockChainClient : Sync + Send {
/// Extended client interface used for mining
pub trait MiningBlockChainClient : BlockChainClient {
/// Returns OpenBlock prepared for closing.
- fn prepare_open_block(&self, author: Address, gas_range_target: (U256, U256), extra_data: Bytes)
- -> OpenBlock;
+ fn prepare_open_block(&self,
+ author: Address,
+ gas_range_target: (U256, U256),
+ extra_data: Bytes
+ ) -> OpenBlock;
/// Returns EvmFactory.
fn vm_factory(&self) -> &EvmFactory;
diff --git a/ethcore/src/engines/mod.rs b/ethcore/src/engines/mod.rs
index 599721f86..5234553ef 100644
--- a/ethcore/src/engines/mod.rs
+++ b/ethcore/src/engines/mod.rs
@@ -45,7 +45,7 @@ pub trait Engine : Sync + Send {
fn extra_info(&self, _header: &Header) -> HashMap { HashMap::new() }
/// Additional information.
- fn additional_params(&self) -> HashMap { HashMap::new() }
+ fn additional_params(&self) -> HashMap { HashMap::new() }
/// Get the general parameters of the chain.
fn params(&self) -> &CommonParams;
@@ -126,7 +126,7 @@ pub trait Engine : Sync + Send {
fn cost_of_builtin(&self, a: &Address, input: &[u8]) -> U256 { self.builtins().get(a).unwrap().cost(input.len()) }
/// Execution the builtin contract `a` on `input` and return `output`.
/// Panics if `is_builtin(a)` is not true.
- fn execute_builtin(&self, a: &Address, input: &[u8], output: &mut [u8]) { self.builtins().get(a).unwrap().execute(input, output); }
+ fn execute_builtin(&self, a: &Address, input: &[u8], output: &mut BytesRef) { self.builtins().get(a).unwrap().execute(input, output); }
// TODO: sealing stuff - though might want to leave this for later.
}
diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs
index 216ebed17..734acb758 100644
--- a/ethcore/src/ethereum/ethash.rs
+++ b/ethcore/src/ethereum/ethash.rs
@@ -167,9 +167,7 @@ impl Engine for Ethash {
for u in fields.uncles.iter() {
fields.state.add_balance(u.author(), &(reward * U256::from(8 + u.number() - current_number) / U256::from(8)));
}
- if let Err(e) = fields.state.commit() {
- warn!("Encountered error on state commit: {}", e);
- }
+
}
fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
diff --git a/ethcore/src/evm/evm.rs b/ethcore/src/evm/evm.rs
index 813819250..8d2202480 100644
--- a/ethcore/src/evm/evm.rs
+++ b/ethcore/src/evm/evm.rs
@@ -113,7 +113,10 @@ impl<'a> Finalize for Result> {
}
/// Cost calculation type. For low-gas usage we calculate costs using usize instead of U256
-pub trait CostType: ops::Mul + ops::Div + ops::Add + ops::Sub + ops::Shr + ops::Shl + cmp::Ord + Sized + From + Copy {
+pub trait CostType: Sized + From + Copy
+ + ops::Mul + ops::Div + ops::Add +ops::Sub
+ + ops::Shr + ops::Shl
+ + cmp::Ord + fmt::Debug {
/// Converts this cost into `U256`
fn as_u256(&self) -> U256;
/// Tries to fit `U256` into this `Cost` type
diff --git a/ethcore/src/evm/ext.rs b/ethcore/src/evm/ext.rs
index 0db789507..2bbc7035b 100644
--- a/ethcore/src/evm/ext.rs
+++ b/ethcore/src/evm/ext.rs
@@ -83,6 +83,9 @@ pub trait Ext {
/// Returns code at given address
fn extcode(&self, address: &Address) -> Bytes;
+ /// Returns code size at given address
+ fn extcodesize(&self, address: &Address) -> usize;
+
/// Creates log entry with given topics and data
fn log(&mut self, topics: Vec, data: &[u8]);
diff --git a/ethcore/src/evm/interpreter/mod.rs b/ethcore/src/evm/interpreter/mod.rs
index d1b9b18bc..ad2d5cd34 100644
--- a/ethcore/src/evm/interpreter/mod.rs
+++ b/ethcore/src/evm/interpreter/mod.rs
@@ -53,6 +53,17 @@ fn color(instruction: Instruction, name: &'static str) -> String {
type CodePosition = usize;
type ProgramCounter = usize;
+const ONE: U256 = U256([1, 0, 0, 0]);
+const TWO: U256 = U256([2, 0, 0, 0]);
+const TWO_POW_5: U256 = U256([0x20, 0, 0, 0]);
+const TWO_POW_8: U256 = U256([0x100, 0, 0, 0]);
+const TWO_POW_16: U256 = U256([0x10000, 0, 0, 0]);
+const TWO_POW_24: U256 = U256([0x1000000, 0, 0, 0]);
+const TWO_POW_64: U256 = U256([0, 0x1, 0, 0]); // 0x1 00000000 00000000
+const TWO_POW_96: U256 = U256([0, 0x100000000, 0, 0]); //0x1 00000000 00000000 00000000
+const TWO_POW_224: U256 = U256([0, 0, 0, 0x100000000]); //0x1 00000000 00000000 00000000 00000000 00000000 00000000 00000000
+const TWO_POW_248: U256 = U256([0, 0, 0, 0x100000000000000]); //0x1 00000000 00000000 00000000 00000000 00000000 00000000 00000000 000000
+
/// Abstraction over raw vector of Bytes. Easier state management of PC.
struct CodeReader<'a> {
position: ProgramCounter,
@@ -126,7 +137,7 @@ impl evm::Evm for Interpreter {
gasometer.current_gas = gasometer.current_gas - gas_cost;
evm_debug!({
- println!("[0x{:x}][{}(0x{:x}) Gas: {:x}\n Gas Before: {:x}",
+ println!("[0x{:x}][{}(0x{:x}) Gas: {:?}\n Gas Before: {:?}",
reader.position,
color(instruction, info.name),
instruction,
@@ -471,7 +482,7 @@ impl Interpreter {
},
instructions::EXTCODESIZE => {
let address = u256_to_address(&stack.pop_back());
- let len = ext.extcode(&address).len();
+ let len = ext.extcodesize(&address);
stack.push(U256::from(len));
},
instructions::CALLDATACOPY => {
@@ -599,7 +610,19 @@ impl Interpreter {
let a = stack.pop_back();
let b = stack.pop_back();
stack.push(if !self.is_zero(&b) {
- a.overflowing_div(b).0
+ match b {
+ ONE => a,
+ TWO => a >> 1,
+ TWO_POW_5 => a >> 5,
+ TWO_POW_8 => a >> 8,
+ TWO_POW_16 => a >> 16,
+ TWO_POW_24 => a >> 24,
+ TWO_POW_64 => a >> 64,
+ TWO_POW_96 => a >> 96,
+ TWO_POW_224 => a >> 224,
+ TWO_POW_248 => a >> 248,
+ _ => a.overflowing_div(b).0,
+ }
} else {
U256::zero()
});
diff --git a/ethcore/src/evm/jit.rs b/ethcore/src/evm/jit.rs
index 4f43d327b..c62f87ab7 100644
--- a/ethcore/src/evm/jit.rs
+++ b/ethcore/src/evm/jit.rs
@@ -18,6 +18,7 @@
use common::*;
use evmjit;
use evm::{self, GasLeft};
+use types::executed::CallType;
/// Should be used to convert jit types to ethcore
trait FromJit: Sized {
@@ -77,10 +78,11 @@ impl IntoJit for U256 {
impl IntoJit for H256 {
fn into_jit(self) -> evmjit::I256 {
let mut ret = [0; 4];
- for i in 0..self.bytes().len() {
- let rev = self.bytes().len() - 1 - i;
+ let len = self.len();
+ for i in 0..len {
+ let rev = len - 1 - i;
let pos = rev / 8;
- ret[pos] += (self.bytes()[i] as u64) << ((rev % 8) * 8);
+ ret[pos] += (self[i] as u64) << ((rev % 8) * 8);
}
evmjit::I256 { words: ret }
}
@@ -206,6 +208,7 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
let sender_address = unsafe { Address::from_jit(&*sender_address) };
let receive_address = unsafe { Address::from_jit(&*receive_address) };
let code_address = unsafe { Address::from_jit(&*code_address) };
+ // TODO Is it always safe in case of DELEGATE_CALL?
let transfer_value = unsafe { U256::from_jit(&*transfer_value) };
let value = Some(transfer_value);
@@ -239,6 +242,12 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
}
}
+ // TODO [ToDr] Any way to detect DelegateCall?
+ let call_type = match is_callcode {
+ true => CallType::CallCode,
+ false => CallType::Call,
+ };
+
match self.ext.call(
&call_gas,
&sender_address,
@@ -246,7 +255,9 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
value,
unsafe { slice::from_raw_parts(in_beg, in_size as usize) },
&code_address,
- unsafe { slice::from_raw_parts_mut(out_beg, out_size as usize) }) {
+ unsafe { slice::from_raw_parts_mut(out_beg, out_size as usize) },
+ call_type,
+ ) {
evm::MessageCallResult::Success(gas_left) => unsafe {
*io_gas = (gas + gas_left).low_u64();
true
diff --git a/ethcore/src/evm/tests.rs b/ethcore/src/evm/tests.rs
index bdb1f1ddb..ec217b6c5 100644
--- a/ethcore/src/evm/tests.rs
+++ b/ethcore/src/evm/tests.rs
@@ -140,6 +140,10 @@ impl Ext for FakeExt {
self.codes.get(address).unwrap_or(&Bytes::new()).clone()
}
+ fn extcodesize(&self, address: &Address) -> usize {
+ self.codes.get(address).map(|v| v.len()).unwrap_or(0)
+ }
+
fn log(&mut self, topics: Vec, data: &[u8]) {
self.logs.push(FakeLogEntry {
topics: topics,
diff --git a/ethcore/src/executive.rs b/ethcore/src/executive.rs
index 332eda190..8f8b534ee 100644
--- a/ethcore/src/executive.rs
+++ b/ethcore/src/executive.rs
@@ -193,7 +193,6 @@ impl<'a> Executive<'a> {
data: Some(t.data.clone()),
call_type: CallType::Call,
};
- // TODO: move output upstream
let mut out = vec![];
(self.call(params, &mut substate, BytesRef::Flexible(&mut out), &mut tracer, &mut vm_tracer), out)
}
diff --git a/ethcore/src/externalities.rs b/ethcore/src/externalities.rs
index 09c4b4e11..7395522c3 100644
--- a/ethcore/src/externalities.rs
+++ b/ethcore/src/externalities.rs
@@ -205,6 +205,11 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
self.state.code(address).unwrap_or_else(|| vec![])
}
+ fn extcodesize(&self, address: &Address) -> usize {
+ self.state.code_size(address).unwrap_or(0)
+ }
+
+
#[cfg_attr(feature="dev", allow(match_ref_pats))]
fn ret(mut self, gas: &U256, data: &[u8]) -> evm::Result
where Self: Sized {
diff --git a/ethcore/src/json_tests/executive.rs b/ethcore/src/json_tests/executive.rs
index 7304f5931..1fe98acdb 100644
--- a/ethcore/src/json_tests/executive.rs
+++ b/ethcore/src/json_tests/executive.rs
@@ -131,6 +131,10 @@ impl<'a, T, V> Ext for TestExt<'a, T, V> where T: Tracer, V: VMTracer {
self.ext.extcode(address)
}
+ fn extcodesize(&self, address: &Address) -> usize {
+ self.ext.extcodesize(address)
+ }
+
fn log(&mut self, topics: Vec, data: &[u8]) {
self.ext.log(topics, data)
}
diff --git a/ethcore/src/miner/miner.rs b/ethcore/src/miner/miner.rs
index 73c1c9cf9..182234280 100644
--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@@ -292,6 +292,7 @@ impl Miner {
};
let mut invalid_transactions = HashSet::new();
+ let mut transactions_to_penalize = HashSet::new();
let block_number = open_block.block().fields().header.number();
// TODO: push new uncles, too.
for tx in transactions {
@@ -299,6 +300,12 @@ impl Miner {
match open_block.push_transaction(tx, None) {
Err(Error::Execution(ExecutionError::BlockGasLimitReached { gas_limit, gas_used, gas })) => {
debug!(target: "miner", "Skipping adding transaction to block because of gas limit: {:?} (limit: {:?}, used: {:?}, gas: {:?})", hash, gas_limit, gas_used, gas);
+
+ // Penalize transaction if it's above current gas limit
+ if gas > gas_limit {
+ transactions_to_penalize.insert(hash);
+ }
+
// Exit early if gas left is smaller then min_tx_gas
let min_tx_gas: U256 = 21000.into(); // TODO: figure this out properly.
if gas_limit - gas_used < min_tx_gas {
@@ -334,6 +341,9 @@ impl Miner {
for hash in invalid_transactions.into_iter() {
queue.remove_invalid(&hash, &fetch_account);
}
+ for hash in transactions_to_penalize {
+ queue.penalize(&hash);
+ }
}
(block, original_work_hash)
}
diff --git a/ethcore/src/miner/transaction_queue.rs b/ethcore/src/miner/transaction_queue.rs
index af054aa98..7db65eacb 100644
--- a/ethcore/src/miner/transaction_queue.rs
+++ b/ethcore/src/miner/transaction_queue.rs
@@ -134,6 +134,8 @@ struct TransactionOrder {
hash: H256,
/// Origin of the transaction
origin: TransactionOrigin,
+ /// Penalties
+ penalties: usize,
}
@@ -144,6 +146,7 @@ impl TransactionOrder {
gas_price: tx.transaction.gas_price,
hash: tx.hash(),
origin: tx.origin,
+ penalties: 0,
}
}
@@ -151,6 +154,11 @@ impl TransactionOrder {
self.nonce_height = nonce - base_nonce;
self
}
+
+ fn penalize(mut self) -> Self {
+ self.penalties = self.penalties.saturating_add(1);
+ self
+ }
}
impl Eq for TransactionOrder {}
@@ -167,6 +175,11 @@ impl PartialOrd for TransactionOrder {
impl Ord for TransactionOrder {
fn cmp(&self, b: &TransactionOrder) -> Ordering {
+ // First check number of penalties
+ if self.penalties != b.penalties {
+ return self.penalties.cmp(&b.penalties);
+ }
+
// First check nonce_height
if self.nonce_height != b.nonce_height {
return self.nonce_height.cmp(&b.nonce_height);
@@ -387,7 +400,7 @@ pub struct AccountDetails {
}
/// Transactions with `gas > (gas_limit + gas_limit * Factor(in percents))` are not imported to the queue.
-const GAS_LIMIT_HYSTERESIS: usize = 10; // %
+const GAS_LIMIT_HYSTERESIS: usize = 10; // (100/GAS_LIMIT_HYSTERESIS) %
/// `TransactionQueue` implementation
pub struct TransactionQueue {
@@ -506,8 +519,6 @@ impl TransactionQueue {
pub fn add(&mut self, tx: SignedTransaction, fetch_account: &T, origin: TransactionOrigin) -> Result
where T: Fn(&Address) -> AccountDetails {
- trace!(target: "txqueue", "Importing: {:?}", tx.hash());
-
if tx.gas_price < self.minimal_gas_price && origin != TransactionOrigin::Local {
trace!(target: "txqueue",
"Dropping transaction below minimal gas price threshold: {:?} (gp: {} < {})",
@@ -593,6 +604,39 @@ impl TransactionQueue {
assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
}
+ /// Penalize transactions from sender of transaction with given hash.
+ /// I.e. it should change the priority of the transaction in the queue.
+ ///
+ /// NOTE: We need to penalize all transactions from particular sender
+ /// to avoid breaking invariants in queue (ordered by nonces).
+ /// Consecutive transactions from this sender would fail otherwise (because of invalid nonce).
+ pub fn penalize(&mut self, transaction_hash: &H256) {
+ let transaction = match self.by_hash.get(transaction_hash) {
+ None => return,
+ Some(t) => t,
+ };
+ let sender = transaction.sender();
+
+ // Penalize all transactions from this sender
+ let nonces_from_sender = match self.current.by_address.row(&sender) {
+ Some(row_map) => row_map.keys().cloned().collect::>(),
+ None => vec![],
+ };
+ for k in nonces_from_sender {
+ let order = self.current.drop(&sender, &k).unwrap();
+ self.current.insert(sender, k, order.penalize());
+ }
+ // Same thing for future
+ let nonces_from_sender = match self.future.by_address.row(&sender) {
+ Some(row_map) => row_map.keys().cloned().collect::>(),
+ None => vec![],
+ };
+ for k in nonces_from_sender {
+ let order = self.future.drop(&sender, &k).unwrap();
+ self.current.insert(sender, k, order.penalize());
+ }
+ }
+
/// Removes invalid transaction identified by hash from queue.
/// Assumption is that this transaction nonce is not related to client nonce,
/// so transactions left in queue are processed according to client nonce.
@@ -764,6 +808,7 @@ impl TransactionQueue {
let address = tx.sender();
let nonce = tx.nonce();
+ let hash = tx.hash();
let next_nonce = self.last_nonces
.get(&address)
@@ -785,6 +830,9 @@ impl TransactionQueue {
try!(check_too_cheap(Self::replace_transaction(tx, state_nonce, &mut self.future, &mut self.by_hash)));
// Return an error if this transaction is not imported because of limit.
try!(check_if_removed(&address, &nonce, self.future.enforce_limit(&mut self.by_hash)));
+
+ debug!(target: "txqueue", "Importing transaction to future: {:?}", hash);
+ debug!(target: "txqueue", "status: {:?}", self.status());
return Ok(TransactionImportResult::Future);
}
try!(check_too_cheap(Self::replace_transaction(tx, state_nonce, &mut self.current, &mut self.by_hash)));
@@ -811,7 +859,8 @@ impl TransactionQueue {
// Trigger error if the transaction we are importing was removed.
try!(check_if_removed(&address, &nonce, removed));
- trace!(target: "txqueue", "status: {:?}", self.status());
+ debug!(target: "txqueue", "Imported transaction to current: {:?}", hash);
+ debug!(target: "txqueue", "status: {:?}", self.status());
Ok(TransactionImportResult::Current)
}
@@ -945,6 +994,17 @@ mod test {
(tx1.sign(secret), tx2.sign(secret))
}
+ /// Returns two consecutive transactions, both with increased gas price
+ fn new_tx_pair_with_gas_price_increment(gas_price_increment: U256) -> (SignedTransaction, SignedTransaction) {
+ let gas = default_gas_price() + gas_price_increment;
+ let tx1 = new_unsigned_tx(default_nonce(), gas);
+ let tx2 = new_unsigned_tx(default_nonce() + 1.into(), gas);
+
+ let keypair = Random.generate().unwrap();
+ let secret = &keypair.secret();
+ (tx1.sign(secret), tx2.sign(secret))
+ }
+
fn new_tx_pair_default(nonce_increment: U256, gas_price_increment: U256) -> (SignedTransaction, SignedTransaction) {
new_tx_pair(default_nonce(), default_gas_price(), nonce_increment, gas_price_increment)
}
@@ -1332,6 +1392,39 @@ mod test {
assert_eq!(top.len(), 2);
}
+ #[test]
+ fn should_penalize_transactions_from_sender() {
+ // given
+ let mut txq = TransactionQueue::new();
+ // txa, txb - slightly bigger gas price to have consistent ordering
+ let (txa, txb) = new_tx_pair_default(1.into(), 0.into());
+ let (tx1, tx2) = new_tx_pair_with_gas_price_increment(3.into());
+
+ // insert everything
+ txq.add(txa.clone(), &default_account_details, TransactionOrigin::External).unwrap();
+ txq.add(txb.clone(), &default_account_details, TransactionOrigin::External).unwrap();
+ txq.add(tx1.clone(), &default_account_details, TransactionOrigin::External).unwrap();
+ txq.add(tx2.clone(), &default_account_details, TransactionOrigin::External).unwrap();
+
+ let top = txq.top_transactions();
+ assert_eq!(top[0], tx1);
+ assert_eq!(top[1], txa);
+ assert_eq!(top[2], tx2);
+ assert_eq!(top[3], txb);
+ assert_eq!(top.len(), 4);
+
+ // when
+ txq.penalize(&tx1.hash());
+
+ // then
+ let top = txq.top_transactions();
+ assert_eq!(top[0], txa);
+ assert_eq!(top[1], txb);
+ assert_eq!(top[2], tx1);
+ assert_eq!(top[3], tx2);
+ assert_eq!(top.len(), 4);
+ }
+
#[test]
fn should_return_pending_hashes() {
// given
diff --git a/ethcore/src/snapshot/account.rs b/ethcore/src/snapshot/account.rs
index 16c59db2e..8cfc4c96b 100644
--- a/ethcore/src/snapshot/account.rs
+++ b/ethcore/src/snapshot/account.rs
@@ -92,7 +92,8 @@ impl Account {
let mut pairs = Vec::new();
- for (k, v) in db.iter() {
+ for item in try!(db.iter()) {
+ let (k, v) = try!(item);
pairs.push((k, v));
}
diff --git a/ethcore/src/snapshot/block.rs b/ethcore/src/snapshot/block.rs
index 05b3281c8..4f7f912ca 100644
--- a/ethcore/src/snapshot/block.rs
+++ b/ethcore/src/snapshot/block.rs
@@ -21,10 +21,10 @@ use header::Header;
use views::BlockView;
use rlp::{DecoderError, RlpStream, Stream, UntrustedRlp, View};
-use rlp::{Compressible, RlpType};
use util::{Bytes, Hashable, H256};
+use util::triehash::ordered_trie_root;
-const HEADER_FIELDS: usize = 10;
+const HEADER_FIELDS: usize = 8;
const BLOCK_FIELDS: usize = 2;
pub struct AbridgedBlock {
@@ -61,8 +61,6 @@ impl AbridgedBlock {
stream
.append(&header.author())
.append(&header.state_root())
- .append(&header.transactions_root())
- .append(&header.receipts_root())
.append(&header.log_bloom())
.append(&header.difficulty())
.append(&header.gas_limit())
@@ -79,33 +77,35 @@ impl AbridgedBlock {
}
AbridgedBlock {
- rlp: UntrustedRlp::new(stream.as_raw()).compress(RlpType::Blocks).to_vec(),
+ rlp: stream.out(),
}
}
/// Flesh out an abridged block view with the provided parent hash and block number.
///
/// Will fail if contains invalid rlp.
- pub fn to_block(&self, parent_hash: H256, number: u64) -> Result {
- let rlp = UntrustedRlp::new(&self.rlp).decompress(RlpType::Blocks);
- let rlp = UntrustedRlp::new(&rlp);
+ pub fn to_block(&self, parent_hash: H256, number: u64, receipts_root: H256) -> Result {
+ let rlp = UntrustedRlp::new(&self.rlp);
let mut header: Header = Default::default();
header.set_parent_hash(parent_hash);
header.set_author(try!(rlp.val_at(0)));
header.set_state_root(try!(rlp.val_at(1)));
- header.set_transactions_root(try!(rlp.val_at(2)));
- header.set_receipts_root(try!(rlp.val_at(3)));
- header.set_log_bloom(try!(rlp.val_at(4)));
- header.set_difficulty(try!(rlp.val_at(5)));
+ header.set_log_bloom(try!(rlp.val_at(2)));
+ header.set_difficulty(try!(rlp.val_at(3)));
header.set_number(number);
- header.set_gas_limit(try!(rlp.val_at(6)));
- header.set_gas_used(try!(rlp.val_at(7)));
- header.set_timestamp(try!(rlp.val_at(8)));
- header.set_extra_data(try!(rlp.val_at(9)));
+ header.set_gas_limit(try!(rlp.val_at(4)));
+ header.set_gas_used(try!(rlp.val_at(5)));
+ header.set_timestamp(try!(rlp.val_at(6)));
+ header.set_extra_data(try!(rlp.val_at(7)));
- let transactions = try!(rlp.val_at(10));
- let uncles: Vec = try!(rlp.val_at(11));
+ let transactions = try!(rlp.val_at(8));
+ let uncles: Vec = try!(rlp.val_at(9));
+
+ header.set_transactions_root(ordered_trie_root(
+ try!(rlp.at(8)).iter().map(|r| r.as_raw().to_owned())
+ ));
+ header.set_receipts_root(receipts_root);
let mut uncles_rlp = RlpStream::new();
uncles_rlp.append(&uncles);
@@ -143,20 +143,22 @@ mod tests {
#[test]
fn empty_block_abridging() {
let b = Block::default();
+ let receipts_root = b.header.receipts_root().clone();
let encoded = encode_block(&b);
let abridged = AbridgedBlock::from_block_view(&BlockView::new(&encoded));
- assert_eq!(abridged.to_block(H256::new(), 0).unwrap(), b);
+ assert_eq!(abridged.to_block(H256::new(), 0, receipts_root).unwrap(), b);
}
#[test]
#[should_panic]
fn wrong_number() {
let b = Block::default();
+ let receipts_root = b.header.receipts_root().clone();
let encoded = encode_block(&b);
let abridged = AbridgedBlock::from_block_view(&BlockView::new(&encoded));
- assert_eq!(abridged.to_block(H256::new(), 2).unwrap(), b);
+ assert_eq!(abridged.to_block(H256::new(), 2, receipts_root).unwrap(), b);
}
#[test]
@@ -184,9 +186,14 @@ mod tests {
b.transactions.push(t1);
b.transactions.push(t2);
+ let receipts_root = b.header.receipts_root().clone();
+ b.header.set_transactions_root(::util::triehash::ordered_trie_root(
+ b.transactions.iter().map(::rlp::encode).map(|out| out.to_vec())
+ ));
+
let encoded = encode_block(&b);
let abridged = AbridgedBlock::from_block_view(&BlockView::new(&encoded[..]));
- assert_eq!(abridged.to_block(H256::new(), 0).unwrap(), b);
+ assert_eq!(abridged.to_block(H256::new(), 0, receipts_root).unwrap(), b);
}
}
diff --git a/ethcore/src/snapshot/mod.rs b/ethcore/src/snapshot/mod.rs
index 43622fc51..2074f8174 100644
--- a/ethcore/src/snapshot/mod.rs
+++ b/ethcore/src/snapshot/mod.rs
@@ -15,6 +15,9 @@
// along with Parity. If not, see .
//! Snapshot creation, restoration, and network service.
+//!
+//! Documentation of the format can be found at
+//! https://github.com/ethcore/parity/wiki/%22PV64%22-Snapshot-Format
use std::collections::{HashMap, HashSet, VecDeque};
use std::sync::Arc;
@@ -34,7 +37,7 @@ use util::journaldb::{self, Algorithm, JournalDB};
use util::kvdb::Database;
use util::trie::{TrieDB, TrieDBMut, Trie, TrieMut};
use util::sha3::SHA3_NULL_RLP;
-use rlp::{RlpStream, Stream, UntrustedRlp, View, Compressible, RlpType};
+use rlp::{RlpStream, Stream, UntrustedRlp, View};
use self::account::Account;
use self::block::AbridgedBlock;
@@ -358,15 +361,15 @@ pub fn chunk_state<'a>(db: &HashDB, root: &H256, writer: &Mutex Result {
use basic_types::Seal::With;
use util::U256;
+ use util::triehash::ordered_trie_root;
let rlp = UntrustedRlp::new(chunk);
let item_count = rlp.item_count();
@@ -585,7 +588,11 @@ impl BlockRebuilder {
let abridged_rlp = try!(pair.at(0)).as_raw().to_owned();
let abridged_block = AbridgedBlock::from_raw(abridged_rlp);
let receipts: Vec<::receipt::Receipt> = try!(pair.val_at(1));
- let block = try!(abridged_block.to_block(parent_hash, cur_number));
+ let receipts_root = ordered_trie_root(
+ try!(pair.at(1)).iter().map(|r| r.as_raw().to_owned())
+ );
+
+ let block = try!(abridged_block.to_block(parent_hash, cur_number, receipts_root));
let block_bytes = block.rlp_bytes(With);
if self.rng.gen::() <= POW_VERIFY_RATE {
diff --git a/ethcore/src/snapshot/service.rs b/ethcore/src/snapshot/service.rs
index 78a065958..5243a4792 100644
--- a/ethcore/src/snapshot/service.rs
+++ b/ethcore/src/snapshot/service.rs
@@ -27,7 +27,7 @@ use super::{ManifestData, StateRebuilder, BlockRebuilder, RestorationStatus, Sna
use super::io::{SnapshotReader, LooseReader, SnapshotWriter, LooseWriter};
use blockchain::BlockChain;
-use client::Client;
+use client::{BlockChainClient, Client};
use engines::Engine;
use error::Error;
use ids::BlockID;
@@ -345,7 +345,17 @@ impl Service {
let res = client.take_snapshot(writer, BlockID::Number(num), &self.progress);
self.taking_snapshot.store(false, Ordering::SeqCst);
- try!(res);
+ if let Err(e) = res {
+ if client.chain_info().best_block_number >= num + ::client::HISTORY {
+ // "Cancelled" is mincing words a bit -- what really happened
+ // is that the state we were snapshotting got pruned out
+ // before we could finish.
+ info!("Cancelled prematurely-started periodic snapshot.");
+ return Ok(())
+ } else {
+ return Err(e);
+ }
+ }
info!("Finished taking snapshot at #{}", num);
diff --git a/ethcore/src/snapshot/tests/helpers.rs b/ethcore/src/snapshot/tests/helpers.rs
index 42fb68220..cb928346e 100644
--- a/ethcore/src/snapshot/tests/helpers.rs
+++ b/ethcore/src/snapshot/tests/helpers.rs
@@ -52,8 +52,9 @@ impl StateProducer {
// modify existing accounts.
let mut accounts_to_modify: Vec<_> = {
let trie = TrieDB::new(&*db, &self.state_root).unwrap();
- let temp = trie.iter() // binding required due to complicated lifetime stuff
+ let temp = trie.iter().unwrap() // binding required due to complicated lifetime stuff
.filter(|_| rng.gen::() < ACCOUNT_CHURN)
+ .map(Result::unwrap)
.map(|(k, v)| (H256::from_slice(&k), v.to_owned()))
.collect();
diff --git a/ethcore/src/state/mod.rs b/ethcore/src/state/mod.rs
index 8c7e49ba3..e1299d1dc 100644
--- a/ethcore/src/state/mod.rs
+++ b/ethcore/src/state/mod.rs
@@ -191,10 +191,16 @@ impl State {
}))
}
- /// Mutate storage of account `a` so that it is `value` for `key`.
+ /// Get the code of account `a`.
pub fn code(&self, a: &Address) -> Option {
self.ensure_cached(a, true,
- |a| a.as_ref().map_or(None, |a|a.code().map(|x|x.to_vec())))
+ |a| a.as_ref().map_or(None, |a| a.code().map(|x| x.to_vec())))
+ }
+
+ /// Get the code size of account `a`.
+ pub fn code_size(&self, a: &Address) -> Option {
+ self.ensure_cached(a, true,
+ |a| a.as_ref().map_or(None, |a| a.code().map(|x| x.len())))
}
/// Add `incr` to the balance of account `a`.
@@ -420,10 +426,27 @@ impl fmt::Debug for State {
impl Clone for State {
fn clone(&self) -> State {
+ let cache = {
+ let mut cache = HashMap::new();
+ for (key, val) in self.cache.borrow().iter() {
+ let key = key.clone();
+ match *val {
+ Some(ref acc) if acc.is_dirty() => {
+ cache.insert(key, Some(acc.clone()));
+ },
+ None => {
+ cache.insert(key, None);
+ },
+ _ => {},
+ }
+ }
+ cache
+ };
+
State {
db: self.db.boxed_clone(),
root: self.root.clone(),
- cache: RefCell::new(self.cache.borrow().clone()),
+ cache: RefCell::new(cache),
snapshots: RefCell::new(self.snapshots.borrow().clone()),
account_start_nonce: self.account_start_nonce.clone(),
factories: self.factories.clone(),
diff --git a/ethcore/src/tests/client.rs b/ethcore/src/tests/client.rs
index b10b56d95..dc95e8267 100644
--- a/ethcore/src/tests/client.rs
+++ b/ethcore/src/tests/client.rs
@@ -142,7 +142,8 @@ fn returns_logs() {
to_block: BlockID::Latest,
address: None,
topics: vec![],
- }, None);
+ limit: None,
+ });
assert_eq!(logs.len(), 0);
}
@@ -156,7 +157,8 @@ fn returns_logs_with_limit() {
to_block: BlockID::Latest,
address: None,
topics: vec![],
- }, Some(2));
+ limit: Some(2),
+ });
assert_eq!(logs.len(), 0);
}
diff --git a/ethcore/src/trace/config.rs b/ethcore/src/trace/config.rs
index ff96cea74..9dab7524d 100644
--- a/ethcore/src/trace/config.rs
+++ b/ethcore/src/trace/config.rs
@@ -15,57 +15,14 @@
// along with Parity. If not, see .
//! Traces config.
-use std::str::FromStr;
use bloomchain::Config as BloomConfig;
-use trace::Error;
-
-/// 3-value enum.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Switch {
- /// True.
- On,
- /// False.
- Off,
- /// Auto.
- Auto,
-}
-
-impl Default for Switch {
- fn default() -> Self {
- Switch::Auto
- }
-}
-
-impl FromStr for Switch {
- type Err = String;
-
- fn from_str(s: &str) -> Result {
- match s {
- "on" => Ok(Switch::On),
- "off" => Ok(Switch::Off),
- "auto" => Ok(Switch::Auto),
- other => Err(format!("Invalid switch value: {}", other))
- }
- }
-}
-
-impl Switch {
- /// Tries to turn old switch to new value.
- pub fn turn_to(&self, to: Switch) -> Result {
- match (*self, to) {
- (Switch::On, Switch::On) | (Switch::On, Switch::Auto) | (Switch::Auto, Switch::On) => Ok(true),
- (Switch::Off, Switch::On) => Err(Error::ResyncRequired),
- _ => Ok(false),
- }
- }
-}
/// Traces config.
#[derive(Debug, PartialEq, Clone)]
pub struct Config {
/// Indicates if tracing should be enabled or not.
/// If it's None, it will be automatically configured.
- pub enabled: Switch,
+ pub enabled: bool,
/// Traces blooms configuration.
pub blooms: BloomConfig,
/// Preferef cache-size.
@@ -77,7 +34,7 @@ pub struct Config {
impl Default for Config {
fn default() -> Self {
Config {
- enabled: Switch::default(),
+ enabled: false,
blooms: BloomConfig {
levels: 3,
elements_per_index: 16,
@@ -87,20 +44,3 @@ impl Default for Config {
}
}
}
-
-#[cfg(test)]
-mod tests {
- use super::Switch;
-
- #[test]
- fn test_switch_parsing() {
- assert_eq!(Switch::On, "on".parse().unwrap());
- assert_eq!(Switch::Off, "off".parse().unwrap());
- assert_eq!(Switch::Auto, "auto".parse().unwrap());
- }
-
- #[test]
- fn test_switch_default() {
- assert_eq!(Switch::default(), Switch::Auto);
- }
-}
diff --git a/ethcore/src/trace/db.rs b/ethcore/src/trace/db.rs
index e7bd7c825..b608ad685 100644
--- a/ethcore/src/trace/db.rs
+++ b/ethcore/src/trace/db.rs
@@ -22,7 +22,7 @@ use bloomchain::{Number, Config as BloomConfig};
use bloomchain::group::{BloomGroupDatabase, BloomGroupChain, GroupPosition, BloomGroup};
use util::{H256, H264, Database, DBTransaction, RwLock, HeapSizeOf};
use header::BlockNumber;
-use trace::{LocalizedTrace, Config, Switch, Filter, Database as TraceDatabase, ImportRequest, DatabaseExtras, Error};
+use trace::{LocalizedTrace, Config, Filter, Database as TraceDatabase, ImportRequest, DatabaseExtras};
use db::{self, Key, Writable, Readable, CacheUpdatePolicy};
use blooms;
use super::flat::{FlatTrace, FlatBlockTraces, FlatTransactionTraces};
@@ -126,38 +126,20 @@ impl BloomGroupDatabase for TraceDB where T: DatabaseExtras {
impl TraceDB where T: DatabaseExtras {
/// Creates new instance of `TraceDB`.
- pub fn new(config: Config, tracesdb: Arc, extras: Arc) -> Result {
- // check if in previously tracing was enabled
- let old_tracing = match tracesdb.get(db::COL_TRACE, b"enabled").unwrap() {
- Some(ref value) if value as &[u8] == &[0x1] => Switch::On,
- Some(ref value) if value as &[u8] == &[0x0] => Switch::Off,
- Some(_) => { panic!("tracesdb is corrupted") },
- None => Switch::Auto,
- };
-
- let enabled = try!(old_tracing.turn_to(config.enabled));
-
- let encoded_tracing = match enabled {
- true => [0x1],
- false => [0x0]
- };
-
+ pub fn new(config: Config, tracesdb: Arc, extras: Arc) -> Self {
let mut batch = DBTransaction::new(&tracesdb);
- batch.put(db::COL_TRACE, b"enabled", &encoded_tracing);
batch.put(db::COL_TRACE, b"version", TRACE_DB_VER);
tracesdb.write(batch).unwrap();
- let db = TraceDB {
+ TraceDB {
traces: RwLock::new(HashMap::new()),
blooms: RwLock::new(HashMap::new()),
cache_manager: RwLock::new(CacheManager::new(config.pref_cache_size, config.max_cache_size, 10 * 1024)),
tracesdb: tracesdb,
bloom_config: config.blooms,
- enabled: enabled,
+ enabled: config.enabled,
extras: extras,
- };
-
- Ok(db)
+ }
}
fn cache_size(&self) -> usize {
@@ -419,7 +401,7 @@ mod tests {
use util::{Address, U256, H256, Database, DatabaseConfig, DBTransaction};
use devtools::RandomTempPath;
use header::BlockNumber;
- use trace::{Config, Switch, TraceDB, Database as TraceDatabase, DatabaseExtras, ImportRequest};
+ use trace::{Config, TraceDB, Database as TraceDatabase, DatabaseExtras, ImportRequest};
use trace::{Filter, LocalizedTrace, AddressesFilter, TraceError};
use trace::trace::{Call, Action, Res};
use trace::flat::{FlatTrace, FlatBlockTraces, FlatTransactionTraces};
@@ -474,22 +456,10 @@ mod tests {
let mut config = Config::default();
// set autotracing
- config.enabled = Switch::Auto;
+ config.enabled = false;
{
- let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(NoopExtras)).unwrap();
- assert_eq!(tracedb.tracing_enabled(), false);
- }
-
- {
- let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(NoopExtras)).unwrap();
- assert_eq!(tracedb.tracing_enabled(), false);
- }
-
- config.enabled = Switch::Off;
-
- {
- let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(NoopExtras)).unwrap();
+ let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(NoopExtras));
assert_eq!(tracedb.tracing_enabled(), false);
}
}
@@ -501,50 +471,12 @@ mod tests {
let mut config = Config::default();
// set tracing on
- config.enabled = Switch::On;
+ config.enabled = true;
{
- let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(NoopExtras)).unwrap();
+ let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(NoopExtras));
assert_eq!(tracedb.tracing_enabled(), true);
}
-
- {
- let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(NoopExtras)).unwrap();
- assert_eq!(tracedb.tracing_enabled(), true);
- }
-
- config.enabled = Switch::Auto;
-
- {
- let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(NoopExtras)).unwrap();
- assert_eq!(tracedb.tracing_enabled(), true);
- }
-
- config.enabled = Switch::Off;
-
- {
- let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(NoopExtras)).unwrap();
- assert_eq!(tracedb.tracing_enabled(), false);
- }
- }
-
- #[test]
- #[should_panic]
- fn test_invalid_reopening_db() {
- let temp = RandomTempPath::new();
- let db = new_db(temp.as_str());
- let mut config = Config::default();
-
- // set tracing on
- config.enabled = Switch::Off;
-
- {
- let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(NoopExtras)).unwrap();
- assert_eq!(tracedb.tracing_enabled(), true);
- }
-
- config.enabled = Switch::On;
- TraceDB::new(config.clone(), db.clone(), Arc::new(NoopExtras)).unwrap(); // should panic!
}
fn create_simple_import_request(block_number: BlockNumber, block_hash: H256) -> ImportRequest {
@@ -595,7 +527,7 @@ mod tests {
let temp = RandomTempPath::new();
let db = Arc::new(Database::open(&DatabaseConfig::with_columns(::db::NUM_COLUMNS), temp.as_str()).unwrap());
let mut config = Config::default();
- config.enabled = Switch::On;
+ config.enabled = true;
let block_0 = H256::from(0xa1);
let block_1 = H256::from(0xa2);
let tx_0 = H256::from(0xff);
@@ -607,7 +539,7 @@ mod tests {
extras.transaction_hashes.insert(0, vec![tx_0.clone()]);
extras.transaction_hashes.insert(1, vec![tx_1.clone()]);
- let tracedb = TraceDB::new(config, db.clone(), Arc::new(extras)).unwrap();
+ let tracedb = TraceDB::new(config, db.clone(), Arc::new(extras));
// import block 0
let request = create_simple_import_request(0, block_0.clone());
@@ -679,10 +611,10 @@ mod tests {
extras.transaction_hashes.insert(0, vec![tx_0.clone()]);
// set tracing on
- config.enabled = Switch::On;
+ config.enabled = true;
{
- let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(extras.clone())).unwrap();
+ let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(extras.clone()));
// import block 0
let request = create_simple_import_request(0, block_0.clone());
@@ -692,7 +624,7 @@ mod tests {
}
{
- let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(extras)).unwrap();
+ let tracedb = TraceDB::new(config.clone(), db.clone(), Arc::new(extras));
let traces = tracedb.transaction_traces(0, 0);
assert_eq!(traces.unwrap(), vec![create_simple_localized_trace(0, block_0, tx_0)]);
}
diff --git a/ethcore/src/trace/mod.rs b/ethcore/src/trace/mod.rs
index 06604450f..da3bbc02b 100644
--- a/ethcore/src/trace/mod.rs
+++ b/ethcore/src/trace/mod.rs
@@ -26,7 +26,7 @@ mod noop_tracer;
pub use types::trace_types::{filter, flat, localized, trace};
pub use types::trace_types::error::Error as TraceError;
-pub use self::config::{Config, Switch};
+pub use self::config::Config;
pub use self::db::TraceDB;
pub use self::error::Error;
pub use types::trace_types::trace::{VMTrace, VMOperation, VMExecutedOperation, MemoryDiff, StorageDiff};
diff --git a/ethcore/src/types/filter.rs b/ethcore/src/types/filter.rs
index 91338899f..6274d63f4 100644
--- a/ethcore/src/types/filter.rs
+++ b/ethcore/src/types/filter.rs
@@ -41,6 +41,12 @@ pub struct Filter {
/// If None, match all.
/// If specified, log must contain one of these topics.
pub topics: Vec>>,
+
+ /// Logs limit
+ ///
+ /// If None, return all logs
+ /// If specified, should only return *last* `n` logs.
+ pub limit: Option,
}
impl Clone for Filter {
@@ -59,7 +65,8 @@ impl Clone for Filter {
from_block: self.from_block.clone(),
to_block: self.to_block.clone(),
address: self.address.clone(),
- topics: topics[..].to_vec()
+ topics: topics[..].to_vec(),
+ limit: self.limit,
}
}
}
@@ -117,6 +124,7 @@ mod tests {
to_block: BlockID::Latest,
address: None,
topics: vec![None, None, None, None],
+ limit: None,
};
let possibilities = none_filter.bloom_possibilities();
@@ -136,7 +144,8 @@ mod tests {
None,
None,
None,
- ]
+ ],
+ limit: None,
};
let possibilities = filter.bloom_possibilities();
@@ -154,7 +163,8 @@ mod tests {
Some(vec!["ff74e91598aed6ae5d2fdcf8b24cd2c7be49a0808112a305069355b7160f23f9".into()]),
None,
None,
- ]
+ ],
+ limit: None,
};
let possibilities = filter.bloom_possibilities();
@@ -181,7 +191,8 @@ mod tests {
]),
Some(vec!["ff74e91598aed6ae5d2fdcf8b24cd2c7be49a0808112a305069355b7160f23f9".into()]),
None
- ]
+ ],
+ limit: None,
};
// number of possibilites should be equal 2 * 2 * 2 * 1 = 8
@@ -201,7 +212,8 @@ mod tests {
Some(vec!["ff74e91598aed6ae5d2fdcf8b24cd2c7be49a0808112a305069355b7160f23fa".into()]),
None,
None,
- ]
+ ],
+ limit: None,
};
let entry0 = LogEntry {
diff --git a/ethcore/src/types/transaction.rs b/ethcore/src/types/transaction.rs
index f7e582f11..386b85f7e 100644
--- a/ethcore/src/types/transaction.rs
+++ b/ethcore/src/types/transaction.rs
@@ -21,7 +21,7 @@ use std::cell::*;
use rlp::*;
use util::sha3::Hashable;
use util::{H256, Address, U256, Bytes};
-use ethkey::{Signature, sign, Secret, recover, public_to_address, Error as EthkeyError};
+use ethkey::{Signature, sign, Secret, Public, recover, public_to_address, Error as EthkeyError};
use error::*;
use evm::Schedule;
use header::BlockNumber;
@@ -305,13 +305,18 @@ impl SignedTransaction {
match sender {
Some(s) => Ok(s),
None => {
- let s = public_to_address(&try!(recover(&self.signature(), &self.unsigned.hash())));
+ let s = public_to_address(&try!(self.public_key()));
self.sender.set(Some(s));
Ok(s)
}
}
}
+ /// Returns the public key of the sender.
+ pub fn public_key(&self) -> Result {
+ Ok(try!(recover(&self.signature(), &self.unsigned.hash())))
+ }
+
/// Do basic validation, checking for valid signature and minimum gas,
// TODO: consider use in block validation.
#[cfg(test)]
diff --git a/ethcore/src/verification/verification.rs b/ethcore/src/verification/verification.rs
index 86d3623c2..4e1305a33 100644
--- a/ethcore/src/verification/verification.rs
+++ b/ethcore/src/verification/verification.rs
@@ -215,7 +215,7 @@ fn verify_parent(header: &Header, parent: &Header) -> Result<(), Error> {
fn verify_block_integrity(block: &[u8], transactions_root: &H256, uncles_hash: &H256) -> Result<(), Error> {
let block = UntrustedRlp::new(block);
let tx = try!(block.at(1));
- let expected_root = &ordered_trie_root(tx.iter().map(|r| r.as_raw().to_vec()).collect()); //TODO: get rid of vectors here
+ let expected_root = &ordered_trie_root(tx.iter().map(|r| r.as_raw().to_vec())); //TODO: get rid of vectors here
if expected_root != transactions_root {
return Err(From::from(BlockError::InvalidTransactionsRoot(Mismatch { expected: expected_root.clone(), found: transactions_root.clone() })))
}
@@ -422,7 +422,7 @@ mod tests {
let mut uncles_rlp = RlpStream::new();
uncles_rlp.append(&good_uncles);
let good_uncles_hash = uncles_rlp.as_raw().sha3();
- let good_transactions_root = ordered_trie_root(good_transactions.iter().map(|t| ::rlp::encode::(t).to_vec()).collect());
+ let good_transactions_root = ordered_trie_root(good_transactions.iter().map(|t| ::rlp::encode::(t).to_vec()));
let mut parent = good.clone();
parent.set_number(9);
diff --git a/ethcrypto/src/lib.rs b/ethcrypto/src/lib.rs
index 680718d12..7a1aba48c 100644
--- a/ethcrypto/src/lib.rs
+++ b/ethcrypto/src/lib.rs
@@ -22,6 +22,7 @@ extern crate crypto as rcrypto;
extern crate secp256k1;
extern crate ethkey;
+use std::fmt;
use tiny_keccak::Keccak;
use rcrypto::pbkdf2::pbkdf2;
use rcrypto::scrypt::{scrypt, ScryptParams};
@@ -39,6 +40,17 @@ pub enum Error {
InvalidMessage,
}
+impl fmt::Display for Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ let s = match *self {
+ Error::Secp(ref err) => err.to_string(),
+ Error::InvalidMessage => "Invalid message".into(),
+ };
+
+ write!(f, "{}", s)
+ }
+}
+
impl From for Error {
fn from(e: SecpError) -> Self {
Error::Secp(e)
diff --git a/ethkey/Cargo.toml b/ethkey/Cargo.toml
index 8e95d8519..319a38b20 100644
--- a/ethkey/Cargo.toml
+++ b/ethkey/Cargo.toml
@@ -1,7 +1,7 @@
[package]
name = "ethkey"
version = "0.2.0"
-authors = ["debris "]
+authors = ["Ethcore "]
[dependencies]
rand = "0.3.14"
diff --git a/ethstore/src/account/safe_account.rs b/ethstore/src/account/safe_account.rs
index 56e8494f7..38069a718 100644
--- a/ethstore/src/account/safe_account.rs
+++ b/ethstore/src/account/safe_account.rs
@@ -16,7 +16,7 @@
use ethkey::{KeyPair, sign, Address, Secret, Signature, Message};
use {json, Error, crypto};
-use crypto::Keccak256;
+use crypto::{Keccak256};
use random::Random;
use account::{Version, Cipher, Kdf, Aes128Ctr, Pbkdf2, Prf};
@@ -170,6 +170,11 @@ impl SafeAccount {
sign(&secret, message).map_err(From::from)
}
+ pub fn decrypt(&self, password: &str, shared_mac: &[u8], message: &[u8]) -> Result, Error> {
+ let secret = try!(self.crypto.secret(password));
+ crypto::ecies::decrypt(&secret, shared_mac, message).map_err(From::from)
+ }
+
pub fn change_password(&self, old_password: &str, new_password: &str, iterations: u32) -> Result {
let secret = try!(self.crypto.secret(old_password));
let result = SafeAccount {
diff --git a/ethstore/src/error.rs b/ethstore/src/error.rs
index a5d3de745..cee689b24 100644
--- a/ethstore/src/error.rs
+++ b/ethstore/src/error.rs
@@ -17,6 +17,7 @@
use std::fmt;
use std::io::Error as IoError;
use ethkey::Error as EthKeyError;
+use crypto::Error as EthCryptoError;
#[derive(Debug)]
pub enum Error {
@@ -28,6 +29,7 @@ pub enum Error {
InvalidKeyFile(String),
CreationFailed,
EthKey(EthKeyError),
+ EthCrypto(EthCryptoError),
Custom(String),
}
@@ -42,6 +44,7 @@ impl fmt::Display for Error {
Error::InvalidKeyFile(ref reason) => format!("Invalid key file: {}", reason),
Error::CreationFailed => "Account creation failed".into(),
Error::EthKey(ref err) => err.to_string(),
+ Error::EthCrypto(ref err) => err.to_string(),
Error::Custom(ref s) => s.clone(),
};
@@ -60,3 +63,9 @@ impl From for Error {
Error::EthKey(err)
}
}
+
+impl From for Error {
+ fn from(err: EthCryptoError) -> Self {
+ Error::EthCrypto(err)
+ }
+}
diff --git a/ethstore/src/ethstore.rs b/ethstore/src/ethstore.rs
index 29f4c757c..8de988b9a 100644
--- a/ethstore/src/ethstore.rs
+++ b/ethstore/src/ethstore.rs
@@ -144,6 +144,11 @@ impl SecretStore for EthStore {
account.sign(password, message)
}
+ fn decrypt(&self, account: &Address, password: &str, shared_mac: &[u8], message: &[u8]) -> Result, Error> {
+ let account = try!(self.get(account));
+ account.decrypt(password, shared_mac, message)
+ }
+
fn uuid(&self, address: &Address) -> Result {
let account = try!(self.get(address));
Ok(account.id.into())
diff --git a/ethstore/src/secret_store.rs b/ethstore/src/secret_store.rs
index 90ed79fb5..aa79cb8b6 100644
--- a/ethstore/src/secret_store.rs
+++ b/ethstore/src/secret_store.rs
@@ -20,33 +20,24 @@ use json::UUID;
pub trait SecretStore: Send + Sync {
fn insert_account(&self, secret: Secret, password: &str) -> Result;
-
fn import_presale(&self, json: &[u8], password: &str) -> Result;
-
fn import_wallet(&self, json: &[u8], password: &str) -> Result;
-
- fn accounts(&self) -> Result, Error>;
-
fn change_password(&self, account: &Address, old_password: &str, new_password: &str) -> Result<(), Error>;
-
fn remove_account(&self, account: &Address, password: &str) -> Result<(), Error>;
fn sign(&self, account: &Address, password: &str, message: &Message) -> Result;
+ fn decrypt(&self, account: &Address, password: &str, shared_mac: &[u8], message: &[u8]) -> Result, Error>;
+ fn accounts(&self) -> Result, Error>;
fn uuid(&self, account: &Address) -> Result;
-
fn name(&self, account: &Address) -> Result;
-
fn meta(&self, account: &Address) -> Result;
fn set_name(&self, address: &Address, name: String) -> Result<(), Error>;
-
fn set_meta(&self, address: &Address, meta: String) -> Result<(), Error>;
fn local_path(&self) -> String;
-
fn list_geth_accounts(&self, testnet: bool) -> Vec;
-
fn import_geth_accounts(&self, desired: Vec, testnet: bool) -> Result, Error>;
}
diff --git a/parity/blockchain.rs b/parity/blockchain.rs
index 72215ca59..3dfdac804 100644
--- a/parity/blockchain.rs
+++ b/parity/blockchain.rs
@@ -26,15 +26,16 @@ use io::{PanicHandler, ForwardPanic};
use util::{ToPretty, Uint};
use rlp::PayloadInfo;
use ethcore::service::ClientService;
-use ethcore::client::{Mode, DatabaseCompactionProfile, Switch, VMType, BlockImportError, BlockChainClient, BlockID};
+use ethcore::client::{Mode, DatabaseCompactionProfile, VMType, BlockImportError, BlockChainClient, BlockID};
use ethcore::error::ImportError;
use ethcore::miner::Miner;
use cache::CacheConfig;
+use params::{SpecType, Pruning, Switch, tracing_switch_to_bool};
use informant::{Informant, MillisecondDuration};
use io_handler::ImportIoHandler;
-use params::{SpecType, Pruning};
use helpers::{to_client_config, execute_upgrades};
use dir::Directories;
+use user_defaults::UserDefaults;
use fdlimit;
#[derive(Debug, PartialEq)]
@@ -113,29 +114,44 @@ fn execute_import(cmd: ImportBlockchain) -> Result {
// Setup panic handler
let panic_handler = PanicHandler::new_in_arc();
+ // Setup logging
+ let _logger = setup_log(&cmd.logger_config);
+
+ // create dirs used by parity
+ try!(cmd.dirs.create_dirs());
+
// load spec file
let spec = try!(cmd.spec.spec());
// load genesis hash
let genesis_hash = spec.genesis_header().hash();
- // Setup logging
- let _logger = setup_log(&cmd.logger_config);
+ // database paths
+ let db_dirs = cmd.dirs.database(genesis_hash, spec.fork_name.clone());
+
+ // user defaults path
+ let user_defaults_path = db_dirs.user_defaults_path();
+
+ // load user defaults
+ let mut user_defaults = try!(UserDefaults::load(&user_defaults_path));
+
+ // check if tracing is on
+ let tracing = try!(tracing_switch_to_bool(cmd.tracing, &user_defaults));
fdlimit::raise_fd_limit();
// select pruning algorithm
- let algorithm = cmd.pruning.to_algorithm(&cmd.dirs, genesis_hash, spec.fork_name.as_ref());
+ let algorithm = cmd.pruning.to_algorithm(&user_defaults);
// prepare client and snapshot paths.
- let client_path = cmd.dirs.client_path(genesis_hash, spec.fork_name.as_ref(), algorithm);
- let snapshot_path = cmd.dirs.snapshot_path(genesis_hash, spec.fork_name.as_ref());
+ let client_path = db_dirs.client_path(algorithm);
+ let snapshot_path = db_dirs.snapshot_path();
// execute upgrades
- try!(execute_upgrades(&cmd.dirs, genesis_hash, spec.fork_name.as_ref(), algorithm, cmd.compaction.compaction_profile()));
+ try!(execute_upgrades(&db_dirs, algorithm, cmd.compaction.compaction_profile()));
// prepare client config
- let client_config = to_client_config(&cmd.cache_config, &cmd.dirs, genesis_hash, cmd.mode, cmd.tracing, cmd.pruning, cmd.compaction, cmd.wal, cmd.vm_type, "".into(), spec.fork_name.as_ref());
+ let client_config = to_client_config(&cmd.cache_config, cmd.mode, tracing, cmd.compaction, cmd.wal, cmd.vm_type, "".into(), algorithm);
// build client
let service = try!(ClientService::start(
@@ -220,6 +236,12 @@ fn execute_import(cmd: ImportBlockchain) -> Result {
}
}
client.flush_queue();
+
+ // save user defaults
+ user_defaults.pruning = algorithm;
+ user_defaults.tracing = tracing;
+ try!(user_defaults.save(&user_defaults_path));
+
let report = client.report();
let ms = timer.elapsed().as_milliseconds();
@@ -238,6 +260,12 @@ fn execute_export(cmd: ExportBlockchain) -> Result {
// Setup panic handler
let panic_handler = PanicHandler::new_in_arc();
+ // Setup logging
+ let _logger = setup_log(&cmd.logger_config);
+
+ // create dirs used by parity
+ try!(cmd.dirs.create_dirs());
+
let format = cmd.format.unwrap_or_default();
// load spec file
@@ -246,23 +274,32 @@ fn execute_export(cmd: ExportBlockchain) -> Result {
// load genesis hash
let genesis_hash = spec.genesis_header().hash();
- // Setup logging
- let _logger = setup_log(&cmd.logger_config);
+ // database paths
+ let db_dirs = cmd.dirs.database(genesis_hash, spec.fork_name.clone());
+
+ // user defaults path
+ let user_defaults_path = db_dirs.user_defaults_path();
+
+ // load user defaults
+ let user_defaults = try!(UserDefaults::load(&user_defaults_path));
+
+ // check if tracing is on
+ let tracing = try!(tracing_switch_to_bool(cmd.tracing, &user_defaults));
fdlimit::raise_fd_limit();
// select pruning algorithm
- let algorithm = cmd.pruning.to_algorithm(&cmd.dirs, genesis_hash, spec.fork_name.as_ref());
+ let algorithm = cmd.pruning.to_algorithm(&user_defaults);
// prepare client and snapshot paths.
- let client_path = cmd.dirs.client_path(genesis_hash, spec.fork_name.as_ref(), algorithm);
- let snapshot_path = cmd.dirs.snapshot_path(genesis_hash, spec.fork_name.as_ref());
+ let client_path = db_dirs.client_path(algorithm);
+ let snapshot_path = db_dirs.snapshot_path();
// execute upgrades
- try!(execute_upgrades(&cmd.dirs, genesis_hash, spec.fork_name.as_ref(), algorithm, cmd.compaction.compaction_profile()));
+ try!(execute_upgrades(&db_dirs, algorithm, cmd.compaction.compaction_profile()));
// prepare client config
- let client_config = to_client_config(&cmd.cache_config, &cmd.dirs, genesis_hash, cmd.mode, cmd.tracing, cmd.pruning, cmd.compaction, cmd.wal, VMType::default(), "".into(), spec.fork_name.as_ref());
+ let client_config = to_client_config(&cmd.cache_config, cmd.mode, tracing, cmd.compaction, cmd.wal, VMType::default(), "".into(), algorithm);
let service = try!(ClientService::start(
client_config,
diff --git a/parity/cli/mod.rs b/parity/cli/mod.rs
index aa7b460db..b8b10ec1d 100644
--- a/parity/cli/mod.rs
+++ b/parity/cli/mod.rs
@@ -32,6 +32,8 @@ usage! {
cmd_snapshot: bool,
cmd_restore: bool,
cmd_ui: bool,
+ cmd_tools: bool,
+ cmd_hash: bool,
// Arguments
arg_pid_file: String,
@@ -441,6 +443,8 @@ mod tests {
cmd_snapshot: false,
cmd_restore: false,
cmd_ui: false,
+ cmd_tools: false,
+ cmd_hash: false,
// Arguments
arg_pid_file: "".into(),
diff --git a/parity/cli/usage.txt b/parity/cli/usage.txt
index 1749cd4b7..a94f55a8d 100644
--- a/parity/cli/usage.txt
+++ b/parity/cli/usage.txt
@@ -14,6 +14,7 @@ Usage:
parity signer new-token [options]
parity snapshot [options]
parity restore [ ] [options]
+ parity tools hash
Operating Options:
--mode MODE Set the operating mode. MODE can be one of:
@@ -283,4 +284,3 @@ Miscellaneous Options:
--no-color Don't use terminal color codes in output. (default: {flag_no_color})
-v --version Show information about version.
-h --help Show this screen.
-
diff --git a/parity/configuration.rs b/parity/configuration.rs
index 6ee89eb35..1aa338c26 100644
--- a/parity/configuration.rs
+++ b/parity/configuration.rs
@@ -51,6 +51,7 @@ pub enum Cmd {
Blockchain(BlockchainCmd),
SignerToken(String),
Snapshot(SnapshotCommand),
+ Hash(Option),
}
#[derive(Debug, PartialEq)]
@@ -94,8 +95,10 @@ impl Configuration {
let cmd = if self.args.flag_version {
Cmd::Version
- } else if self.args.cmd_signer {
+ } else if self.args.cmd_signer && self.args.cmd_new_token {
Cmd::SignerToken(dirs.signer)
+ } else if self.args.cmd_tools && self.args.cmd_hash {
+ Cmd::Hash(self.args.arg_file)
} else if self.args.cmd_account {
let account_cmd = if self.args.cmd_new {
let new_acc = NewAccount {
diff --git a/parity/dir.rs b/parity/dir.rs
index d31e81e2c..158b5b2c5 100644
--- a/parity/dir.rs
+++ b/parity/dir.rs
@@ -52,32 +52,13 @@ impl Directories {
Ok(())
}
- /// Get the chain's root path.
- pub fn chain_path(&self, genesis_hash: H256, fork_name: Option<&String>) -> PathBuf {
- let mut dir = Path::new(&self.db).to_path_buf();
- dir.push(format!("{:?}{}", H64::from(genesis_hash), fork_name.map(|f| format!("-{}", f)).unwrap_or_default()));
- dir
- }
-
- /// Get the root path for database
- pub fn db_version_path(&self, genesis_hash: H256, fork_name: Option<&String>, pruning: Algorithm) -> PathBuf {
- let mut dir = self.chain_path(genesis_hash, fork_name);
- dir.push(format!("v{}-sec-{}", LEGACY_CLIENT_DB_VER_STR, pruning.as_internal_name_str()));
- dir
- }
-
- /// Get the path for the databases given the genesis_hash and information on the databases.
- pub fn client_path(&self, genesis_hash: H256, fork_name: Option<&String>, pruning: Algorithm) -> PathBuf {
- let mut dir = self.db_version_path(genesis_hash, fork_name, pruning);
- dir.push("db");
- dir
- }
-
- /// Get the path for the snapshot directory given the genesis hash and fork name.
- pub fn snapshot_path(&self, genesis_hash: H256, fork_name: Option<&String>) -> PathBuf {
- let mut dir = self.chain_path(genesis_hash, fork_name);
- dir.push("snapshot");
- dir
+ /// Database paths.
+ pub fn database(&self, genesis_hash: H256, fork_name: Option) -> DatabaseDirectories {
+ DatabaseDirectories {
+ path: self.db.clone(),
+ genesis_hash: genesis_hash,
+ fork_name: fork_name,
+ }
}
/// Get the ipc sockets path
@@ -88,6 +69,49 @@ impl Directories {
}
}
+#[derive(Debug, PartialEq)]
+pub struct DatabaseDirectories {
+ pub path: String,
+ pub genesis_hash: H256,
+ pub fork_name: Option,
+}
+
+impl DatabaseDirectories {
+ fn fork_path(&self) -> PathBuf {
+ let mut dir = Path::new(&self.path).to_path_buf();
+ dir.push(format!("{:?}{}", H64::from(self.genesis_hash), self.fork_name.as_ref().map(|f| format!("-{}", f)).unwrap_or_default()));
+ dir
+ }
+
+ /// Get the root path for database
+ pub fn version_path(&self, pruning: Algorithm) -> PathBuf {
+ let mut dir = self.fork_path();
+ dir.push(format!("v{}-sec-{}", LEGACY_CLIENT_DB_VER_STR, pruning.as_internal_name_str()));
+ dir
+ }
+
+ /// Get the path for the databases given the genesis_hash and information on the databases.
+ pub fn client_path(&self, pruning: Algorithm) -> PathBuf {
+ let mut dir = self.version_path(pruning);
+ dir.push("db");
+ dir
+ }
+
+ /// Get user defaults path
+ pub fn user_defaults_path(&self) -> PathBuf {
+ let mut dir = self.fork_path();
+ dir.push("user_defaults");
+ dir
+ }
+
+ /// Get the path for the snapshot directory given the genesis hash and fork name.
+ pub fn snapshot_path(&self) -> PathBuf {
+ let mut dir = self.fork_path();
+ dir.push("snapshot");
+ dir
+ }
+}
+
#[cfg(test)]
mod tests {
use super::Directories;
diff --git a/parity/helpers.rs b/parity/helpers.rs
index 778dc1265..0649e7fe9 100644
--- a/parity/helpers.rs
+++ b/parity/helpers.rs
@@ -19,13 +19,12 @@ use std::io::{Write, Read, BufReader, BufRead};
use std::time::Duration;
use std::path::Path;
use std::fs::File;
-use util::{clean_0x, U256, Uint, Address, path, H256, CompactionProfile};
+use util::{clean_0x, U256, Uint, Address, path, CompactionProfile};
use util::journaldb::Algorithm;
-use ethcore::client::{Mode, BlockID, Switch, VMType, DatabaseCompactionProfile, ClientConfig};
+use ethcore::client::{Mode, BlockID, VMType, DatabaseCompactionProfile, ClientConfig};
use ethcore::miner::PendingSet;
use cache::CacheConfig;
-use dir::Directories;
-use params::Pruning;
+use dir::DatabaseDirectories;
use upgrade::upgrade;
use migration::migrate;
use ethsync::is_valid_node_url;
@@ -190,16 +189,13 @@ pub fn default_network_config() -> ::ethsync::NetworkConfiguration {
#[cfg_attr(feature = "dev", allow(too_many_arguments))]
pub fn to_client_config(
cache_config: &CacheConfig,
- dirs: &Directories,
- genesis_hash: H256,
mode: Mode,
- tracing: Switch,
- pruning: Pruning,
+ tracing: bool,
compaction: DatabaseCompactionProfile,
wal: bool,
vm_type: VMType,
name: String,
- fork_name: Option<&String>,
+ pruning: Algorithm,
) -> ClientConfig {
let mut client_config = ClientConfig::default();
@@ -221,7 +217,7 @@ pub fn to_client_config(
client_config.mode = mode;
client_config.tracing.enabled = tracing;
- client_config.pruning = pruning.to_algorithm(dirs, genesis_hash, fork_name);
+ client_config.pruning = pruning;
client_config.db_compaction = compaction;
client_config.db_wal = wal;
client_config.vm_type = vm_type;
@@ -230,14 +226,12 @@ pub fn to_client_config(
}
pub fn execute_upgrades(
- dirs: &Directories,
- genesis_hash: H256,
- fork_name: Option<&String>,
+ dirs: &DatabaseDirectories,
pruning: Algorithm,
compaction_profile: CompactionProfile
) -> Result<(), String> {
- match upgrade(Some(&dirs.db)) {
+ match upgrade(Some(&dirs.path)) {
Ok(upgrades_applied) if upgrades_applied > 0 => {
debug!("Executed {} upgrade scripts - ok", upgrades_applied);
},
@@ -247,7 +241,7 @@ pub fn execute_upgrades(
_ => {},
}
- let client_path = dirs.db_version_path(genesis_hash, fork_name, pruning);
+ let client_path = dirs.version_path(pruning);
migrate(&client_path, pruning, compaction_profile).map_err(|e| format!("{}", e))
}
diff --git a/parity/main.rs b/parity/main.rs
index 8cb348958..b74af7b3d 100644
--- a/parity/main.rs
+++ b/parity/main.rs
@@ -39,6 +39,8 @@ extern crate semver;
extern crate ethcore_io as io;
extern crate ethcore_ipc as ipc;
extern crate ethcore_ipc_nano as nanoipc;
+extern crate serde;
+extern crate serde_json;
extern crate rlp;
extern crate json_ipc_server as jsonipc;
@@ -106,15 +108,29 @@ mod run;
mod sync;
#[cfg(feature="ipc")]
mod boot;
+mod user_defaults;
#[cfg(feature="stratum")]
mod stratum;
use std::{process, env};
+use std::io::BufReader;
+use std::fs::File;
+use util::sha3::sha3;
use cli::Args;
use configuration::{Cmd, Configuration};
use deprecated::find_deprecated;
+fn print_hash_of(maybe_file: Option) -> Result {
+ if let Some(file) = maybe_file {
+ let mut f = BufReader::new(try!(File::open(&file).map_err(|_| "Unable to open file".to_owned())));
+ let hash = try!(sha3(&mut f).map_err(|_| "Unable to read from file".to_owned()));
+ Ok(hash.hex())
+ } else {
+ Err("Streaming from standard input not yet supported. Specify a file.".to_owned())
+ }
+}
+
fn execute(command: Cmd) -> Result {
match command {
Cmd::Run(run_cmd) => {
@@ -122,6 +138,7 @@ fn execute(command: Cmd) -> Result {
Ok("".into())
},
Cmd::Version => Ok(Args::print_version()),
+ Cmd::Hash(maybe_file) => print_hash_of(maybe_file),
Cmd::Account(account_cmd) => account::execute(account_cmd),
Cmd::ImportPresaleWallet(presale_cmd) => presale::execute(presale_cmd),
Cmd::Blockchain(blockchain_cmd) => blockchain::execute(blockchain_cmd),
diff --git a/parity/params.rs b/parity/params.rs
index c67520aa1..71f702cfb 100644
--- a/parity/params.rs
+++ b/parity/params.rs
@@ -14,15 +14,14 @@
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see .
-use std::str::FromStr;
-use std::fs;
+use std::{str, fs};
use std::time::Duration;
-use util::{H256, Address, U256, version_data};
+use util::{Address, U256, version_data};
use util::journaldb::Algorithm;
use ethcore::spec::Spec;
use ethcore::ethereum;
use ethcore::miner::{GasPricer, GasPriceCalibratorOptions};
-use dir::Directories;
+use user_defaults::UserDefaults;
#[derive(Debug, PartialEq)]
pub enum SpecType {
@@ -39,7 +38,7 @@ impl Default for SpecType {
}
}
-impl FromStr for SpecType {
+impl str::FromStr for SpecType {
type Err = String;
fn from_str(s: &str) -> Result {
@@ -81,7 +80,7 @@ impl Default for Pruning {
}
}
-impl FromStr for Pruning {
+impl str::FromStr for Pruning {
type Err = String;
fn from_str(s: &str) -> Result {
@@ -93,24 +92,12 @@ impl FromStr for Pruning {
}
impl Pruning {
- pub fn to_algorithm(&self, dirs: &Directories, genesis_hash: H256, fork_name: Option<&String>) -> Algorithm {
+ pub fn to_algorithm(&self, user_defaults: &UserDefaults) -> Algorithm {
match *self {
Pruning::Specific(algo) => algo,
- Pruning::Auto => Self::find_best_db(dirs, genesis_hash, fork_name),
+ Pruning::Auto => user_defaults.pruning,
}
}
-
- fn find_best_db(dirs: &Directories, genesis_hash: H256, fork_name: Option<&String>) -> Algorithm {
- let mut algo_types = Algorithm::all_types();
- // if all dbs have the same modification time, the last element is the default one
- algo_types.push(Algorithm::default());
-
- algo_types.into_iter().max_by_key(|i| {
- let mut client_path = dirs.client_path(genesis_hash, fork_name, *i);
- client_path.push("CURRENT");
- fs::metadata(&client_path).and_then(|m| m.modified()).ok()
- }).unwrap()
- }
}
#[derive(Debug, PartialEq)]
@@ -128,7 +115,7 @@ impl Default for ResealPolicy {
}
}
-impl FromStr for ResealPolicy {
+impl str::FromStr for ResealPolicy {
type Err = String;
fn from_str(s: &str) -> Result {
@@ -223,10 +210,50 @@ impl Default for MinerExtras {
}
}
+/// 3-value enum.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Switch {
+ /// True.
+ On,
+ /// False.
+ Off,
+ /// Auto.
+ Auto,
+}
+
+impl Default for Switch {
+ fn default() -> Self {
+ Switch::Auto
+ }
+}
+
+impl str::FromStr for Switch {
+ type Err = String;
+
+ fn from_str(s: &str) -> Result {
+ match s {
+ "on" => Ok(Switch::On),
+ "off" => Ok(Switch::Off),
+ "auto" => Ok(Switch::Auto),
+ other => Err(format!("Invalid switch value: {}", other))
+ }
+ }
+}
+
+pub fn tracing_switch_to_bool(switch: Switch, user_defaults: &UserDefaults) -> Result {
+ match (user_defaults.is_first_launch, switch, user_defaults.tracing) {
+ (false, Switch::On, false) => Err("TraceDB resync required".into()),
+ (_, Switch::On, _) => Ok(true),
+ (_, Switch::Off, _) => Ok(false),
+ (_, Switch::Auto, def) => Ok(def),
+ }
+}
+
#[cfg(test)]
mod tests {
use util::journaldb::Algorithm;
- use super::{SpecType, Pruning, ResealPolicy};
+ use user_defaults::UserDefaults;
+ use super::{SpecType, Pruning, ResealPolicy, Switch, tracing_switch_to_bool};
#[test]
fn test_spec_type_parsing() {
@@ -274,4 +301,36 @@ mod tests {
let all = ResealPolicy { own: true, external: true };
assert_eq!(all, ResealPolicy::default());
}
+
+ #[test]
+ fn test_switch_parsing() {
+ assert_eq!(Switch::On, "on".parse().unwrap());
+ assert_eq!(Switch::Off, "off".parse().unwrap());
+ assert_eq!(Switch::Auto, "auto".parse().unwrap());
+ }
+
+ #[test]
+ fn test_switch_default() {
+ assert_eq!(Switch::default(), Switch::Auto);
+ }
+
+ fn user_defaults_with_tracing(first_launch: bool, tracing: bool) -> UserDefaults {
+ let mut ud = UserDefaults::default();
+ ud.is_first_launch = first_launch;
+ ud.tracing = tracing;
+ ud
+ }
+
+ #[test]
+ fn test_switch_to_bool() {
+ assert!(!tracing_switch_to_bool(Switch::Off, &user_defaults_with_tracing(true, true)).unwrap());
+ assert!(!tracing_switch_to_bool(Switch::Off, &user_defaults_with_tracing(true, false)).unwrap());
+ assert!(!tracing_switch_to_bool(Switch::Off, &user_defaults_with_tracing(false, true)).unwrap());
+ assert!(!tracing_switch_to_bool(Switch::Off, &user_defaults_with_tracing(false, false)).unwrap());
+
+ assert!(tracing_switch_to_bool(Switch::On, &user_defaults_with_tracing(true, true)).unwrap());
+ assert!(tracing_switch_to_bool(Switch::On, &user_defaults_with_tracing(true, false)).unwrap());
+ assert!(tracing_switch_to_bool(Switch::On, &user_defaults_with_tracing(false, true)).unwrap());
+ assert!(tracing_switch_to_bool(Switch::On, &user_defaults_with_tracing(false, false)).is_err());
+ }
}
diff --git a/parity/rpc_apis.rs b/parity/rpc_apis.rs
index 624c6b3f4..29b33b844 100644
--- a/parity/rpc_apis.rs
+++ b/parity/rpc_apis.rs
@@ -25,7 +25,7 @@ use ethcore::client::Client;
use ethcore::account_provider::AccountProvider;
use ethsync::{ManageNetwork, SyncProvider};
use ethcore_rpc::{Extendable, NetworkSettings};
-pub use ethcore_rpc::ConfirmationsQueue;
+pub use ethcore_rpc::SignerService;
#[derive(Debug, PartialEq, Clone, Eq, Hash)]
@@ -94,7 +94,7 @@ impl FromStr for ApiSet {
pub struct Dependencies {
pub signer_port: Option,
- pub signer_queue: Arc,
+ pub signer_service: Arc,
pub client: Arc,
pub sync: Arc,
pub net: Arc,
@@ -173,7 +173,7 @@ pub fn setup_rpc(server: T, deps: Arc, apis: ApiSet
server.add_delegate(filter_client.to_delegate());
if deps.signer_port.is_some() {
- server.add_delegate(EthSigningQueueClient::new(&deps.signer_queue, &deps.client, &deps.miner, &deps.secret_store).to_delegate());
+ server.add_delegate(EthSigningQueueClient::new(&deps.signer_service, &deps.client, &deps.miner, &deps.secret_store).to_delegate());
} else {
server.add_delegate(EthSigningUnsafeClient::new(&deps.client, &deps.secret_store, &deps.miner).to_delegate());
}
@@ -182,11 +182,11 @@ pub fn setup_rpc(server: T, deps: Arc, apis: ApiSet
server.add_delegate(PersonalClient::new(&deps.secret_store, &deps.client, &deps.miner, deps.signer_port, deps.geth_compatibility).to_delegate());
},
Api::Signer => {
- server.add_delegate(SignerClient::new(&deps.secret_store, &deps.client, &deps.miner, &deps.signer_queue).to_delegate());
+ server.add_delegate(SignerClient::new(&deps.secret_store, &deps.client, &deps.miner, &deps.signer_service).to_delegate());
},
Api::Ethcore => {
- let queue = deps.signer_port.map(|_| deps.signer_queue.clone());
- server.add_delegate(EthcoreClient::new(&deps.client, &deps.miner, &deps.sync, &deps.net_service, deps.logger.clone(), deps.settings.clone(), queue).to_delegate())
+ let signer = deps.signer_port.map(|_| deps.signer_service.clone());
+ server.add_delegate(EthcoreClient::new(&deps.client, &deps.miner, &deps.sync, &deps.net_service, deps.logger.clone(), deps.settings.clone(), signer).to_delegate())
},
Api::EthcoreSet => {
server.add_delegate(EthcoreSetClient::new(&deps.client, &deps.miner, &deps.net_service).to_delegate())
diff --git a/parity/run.rs b/parity/run.rs
index cefd8bb21..e95b5c9f5 100644
--- a/parity/run.rs
+++ b/parity/run.rs
@@ -23,7 +23,7 @@ use ethcore_rpc::NetworkSettings;
use ethsync::NetworkConfiguration;
use util::{Colour, version, U256};
use io::{MayPanic, ForwardPanic, PanicHandler};
-use ethcore::client::{Mode, Switch, DatabaseCompactionProfile, VMType, ChainNotify};
+use ethcore::client::{Mode, DatabaseCompactionProfile, VMType, ChainNotify};
use ethcore::service::ClientService;
use ethcore::account_provider::AccountProvider;
use ethcore::miner::{Miner, MinerService, ExternalMiner, MinerOptions};
@@ -35,10 +35,11 @@ use rpc::{HttpServer, IpcServer, HttpConfiguration, IpcConfiguration};
use signer::SignerServer;
use dapps::WebappServer;
use io_handler::ClientIoHandler;
-use params::{SpecType, Pruning, AccountsConfig, GasPricerConfig, MinerExtras};
+use params::{SpecType, Pruning, AccountsConfig, GasPricerConfig, MinerExtras, Switch, tracing_switch_to_bool};
use helpers::{to_client_config, execute_upgrades, passwords_from_files};
use dir::Directories;
use cache::CacheConfig;
+use user_defaults::UserDefaults;
use dapps;
use signer;
use modules;
@@ -87,34 +88,45 @@ pub struct RunCmd {
}
pub fn execute(cmd: RunCmd) -> Result<(), String> {
- // increase max number of open files
- raise_fd_limit();
+ // set up panic handler
+ let panic_handler = PanicHandler::new_in_arc();
// set up logger
let logger = try!(setup_log(&cmd.logger_config));
- // set up panic handler
- let panic_handler = PanicHandler::new_in_arc();
+ // increase max number of open files
+ raise_fd_limit();
// create dirs used by parity
try!(cmd.dirs.create_dirs());
// load spec
let spec = try!(cmd.spec.spec());
- let fork_name = spec.fork_name.clone();
// load genesis hash
let genesis_hash = spec.genesis_header().hash();
+ // database paths
+ let db_dirs = cmd.dirs.database(genesis_hash, spec.fork_name.clone());
+
+ // user defaults path
+ let user_defaults_path = db_dirs.user_defaults_path();
+
+ // load user defaults
+ let mut user_defaults = try!(UserDefaults::load(&user_defaults_path));
+
+ // check if tracing is on
+ let tracing = try!(tracing_switch_to_bool(cmd.tracing, &user_defaults));
+
// select pruning algorithm
- let algorithm = cmd.pruning.to_algorithm(&cmd.dirs, genesis_hash, fork_name.as_ref());
+ let algorithm = cmd.pruning.to_algorithm(&user_defaults);
// prepare client and snapshot paths.
- let client_path = cmd.dirs.client_path(genesis_hash, fork_name.as_ref(), algorithm);
- let snapshot_path = cmd.dirs.snapshot_path(genesis_hash, fork_name.as_ref());
+ let client_path = db_dirs.client_path(algorithm);
+ let snapshot_path = db_dirs.snapshot_path();
// execute upgrades
- try!(execute_upgrades(&cmd.dirs, genesis_hash, fork_name.as_ref(), algorithm, cmd.compaction.compaction_profile()));
+ try!(execute_upgrades(&db_dirs, algorithm, cmd.compaction.compaction_profile()));
// run in daemon mode
if let Some(pid_file) = cmd.daemon {
@@ -152,16 +164,13 @@ pub fn execute(cmd: RunCmd) -> Result<(), String> {
// create client config
let client_config = to_client_config(
&cmd.cache_config,
- &cmd.dirs,
- genesis_hash,
cmd.mode,
- cmd.tracing,
- cmd.pruning,
+ tracing,
cmd.compaction,
cmd.wal,
cmd.vm_type,
cmd.name,
- fork_name.as_ref(),
+ algorithm,
);
// set up bootnodes
@@ -206,9 +215,10 @@ pub fn execute(cmd: RunCmd) -> Result<(), String> {
}
// set up dependencies for rpc servers
+ let signer_path = cmd.signer_conf.signer_path.clone();
let deps_for_rpc_apis = Arc::new(rpc_apis::Dependencies {
signer_port: cmd.signer_port,
- signer_queue: Arc::new(rpc_apis::ConfirmationsQueue::default()),
+ signer_service: Arc::new(rpc_apis::SignerService::new(move || signer::new_token(signer_path.clone()))),
client: client.clone(),
sync: sync_provider.clone(),
net: manage_network.clone(),
@@ -287,6 +297,11 @@ pub fn execute(cmd: RunCmd) -> Result<(), String> {
url::open(&format!("http://{}:{}/", cmd.dapps_conf.interface, cmd.dapps_conf.port));
}
+ // save user defaults
+ user_defaults.pruning = algorithm;
+ user_defaults.tracing = tracing;
+ try!(user_defaults.save(&user_defaults_path));
+
// Handle exit
wait_for_exit(panic_handler, http_server, ipc_server, dapps_server, signer_server);
diff --git a/parity/signer.rs b/parity/signer.rs
index e6924dcef..b60bc7211 100644
--- a/parity/signer.rs
+++ b/parity/signer.rs
@@ -90,7 +90,7 @@ fn do_start(conf: Configuration, deps: Dependencies) -> Result.
+
+use std::fs::File;
+use std::io::Write;
+use std::path::Path;
+use std::collections::BTreeMap;
+use serde::{Serialize, Serializer, Error, Deserialize, Deserializer};
+use serde::de::{Visitor, MapVisitor};
+use serde::de::impls::BTreeMapVisitor;
+use serde_json::Value;
+use serde_json::de::from_reader;
+use serde_json::ser::to_string;
+use util::journaldb::Algorithm;
+
+pub struct UserDefaults {
+ pub is_first_launch: bool,
+ pub pruning: Algorithm,
+ pub tracing: bool,
+}
+
+impl Serialize for UserDefaults {
+ fn serialize(&self, serializer: &mut S) -> Result<(), S::Error>
+ where S: Serializer {
+ let mut map: BTreeMap = BTreeMap::new();
+ map.insert("pruning".into(), Value::String(self.pruning.as_str().into()));
+ map.insert("tracing".into(), Value::Bool(self.tracing));
+ map.serialize(serializer)
+ }
+}
+
+struct UserDefaultsVisitor;
+
+impl Deserialize for UserDefaults {
+ fn deserialize(deserializer: &mut D) -> Result
+ where D: Deserializer {
+ deserializer.deserialize(UserDefaultsVisitor)
+ }
+}
+
+impl Visitor for UserDefaultsVisitor {
+ type Value = UserDefaults;
+
+ fn visit_map(&mut self, visitor: V) -> Result
+ where V: MapVisitor {
+ let mut map: BTreeMap = try!(BTreeMapVisitor::new().visit_map(visitor));
+ let pruning: Value = try!(map.remove("pruning".into()).ok_or_else(|| Error::custom("missing pruning")));
+ let pruning = try!(pruning.as_str().ok_or_else(|| Error::custom("invalid pruning value")));
+ let pruning = try!(pruning.parse().map_err(|_| Error::custom("invalid pruning method")));
+ let tracing: Value = try!(map.remove("tracing".into()).ok_or_else(|| Error::custom("missing tracing")));
+ let tracing = try!(tracing.as_bool().ok_or_else(|| Error::custom("invalid tracing value")));
+
+ let user_defaults = UserDefaults {
+ is_first_launch: false,
+ pruning: pruning,
+ tracing: tracing,
+ };
+
+ Ok(user_defaults)
+ }
+}
+
+impl Default for UserDefaults {
+ fn default() -> Self {
+ UserDefaults {
+ is_first_launch: true,
+ pruning: Algorithm::default(),
+ tracing: false,
+ }
+ }
+}
+
+impl UserDefaults {
+ pub fn load(path: P) -> Result where P: AsRef {
+ match File::open(path) {
+ Ok(file) => from_reader(file).map_err(|e| e.to_string()),
+ _ => Ok(UserDefaults::default()),
+ }
+ }
+
+ pub fn save(self, path: P) -> Result<(), String> where P: AsRef {
+ let mut file: File = try!(File::create(path).map_err(|_| "Cannot create user defaults file".to_owned()));
+ file.write_all(to_string(&self).unwrap().as_bytes()).map_err(|_| "Failed to save user defaults".to_owned())
+ }
+}
diff --git a/rpc/Cargo.toml b/rpc/Cargo.toml
index 440e41fc9..c3f9cddbd 100644
--- a/rpc/Cargo.toml
+++ b/rpc/Cargo.toml
@@ -17,6 +17,7 @@ jsonrpc-http-server = { git = "https://github.com/ethcore/jsonrpc-http-server.gi
ethcore-io = { path = "../util/io" }
ethcore-util = { path = "../util" }
ethcore = { path = "../ethcore" }
+ethcrypto = { path = "../ethcrypto" }
ethkey = { path = "../ethkey" }
ethstore = { path = "../ethstore" }
ethash = { path = "../ethash" }
diff --git a/rpc/src/lib.rs b/rpc/src/lib.rs
index 17d1837ae..7f2f11400 100644
--- a/rpc/src/lib.rs
+++ b/rpc/src/lib.rs
@@ -28,6 +28,7 @@ extern crate jsonrpc_http_server;
extern crate ethcore_io as io;
extern crate ethcore;
extern crate ethkey;
+extern crate ethcrypto as crypto;
extern crate ethstore;
extern crate ethsync;
extern crate transient_hashmap;
@@ -53,7 +54,7 @@ use self::jsonrpc_core::{IoHandler, IoDelegate};
pub use jsonrpc_http_server::{ServerBuilder, Server, RpcServerError};
pub mod v1;
-pub use v1::{SigningQueue, ConfirmationsQueue, NetworkSettings};
+pub use v1::{SigningQueue, SignerService, ConfirmationsQueue, NetworkSettings};
/// An object that can be extended with `IoDelegates`
pub trait Extendable {
diff --git a/rpc/src/v1/helpers/auto_args.rs b/rpc/src/v1/helpers/auto_args.rs
new file mode 100644
index 000000000..c7deb0436
--- /dev/null
+++ b/rpc/src/v1/helpers/auto_args.rs
@@ -0,0 +1,171 @@
+// 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 .
+
+//! Automatically serialize and deserialize parameters around a strongly-typed function.
+
+// because we reuse the type names as idents in the macros as a dirty hack to
+// work around `concat_idents!` being unstable.
+#![allow(non_snake_case)]
+
+use super::errors;
+
+use jsonrpc_core::{Error, Params, Value, from_params, to_value};
+use serde::{Serialize, Deserialize};
+
+/// Auto-generates an RPC trait from trait definition.
+///
+/// This just copies out all the methods, docs, and adds another
+/// function `to_delegate` which will automatically wrap each strongly-typed
+/// function in a wrapper which handles parameter and output type serialization.
+///
+/// Every function must have a `#[name("rpc_nameHere")]` attribute after
+/// its documentation, and no other attributes. All function names are
+/// allowed except for `to_delegate`, which is auto-generated.
+macro_rules! build_rpc_trait {
+ (
+ $(#[$t_attr: meta])*
+ pub trait $name: ident {
+ $(
+ $(#[doc=$m_doc: expr])* #[name($rpc_name: expr)]
+ fn $method: ident (&self $(, $param: ty)*) -> $out: ty;
+ )*
+ }
+ ) => {
+ $(#[$t_attr])*
+ pub trait $name: Sized + Send + Sync + 'static {
+ $(
+ $(#[doc=$m_doc])*
+ fn $method(&self $(, $param)*) -> $out;
+ )*
+
+ /// Transform this into an `IoDelegate`, automatically wrapping
+ /// the parameters.
+ fn to_delegate(self) -> ::jsonrpc_core::IoDelegate {
+ let mut del = ::jsonrpc_core::IoDelegate::new(self.into());
+ $(
+ del.add_method($rpc_name, move |base, params| {
+ ($name::$method as fn(&_ $(, $param)*) -> $out).wrap_rpc(base, params)
+ });
+ )*
+ del
+ }
+ }
+ }
+}
+
+/// A wrapper type without an implementation of `Deserialize`
+/// which allows a special implementation of `Wrap` for functions
+/// that take a trailing default parameter.
+pub struct Trailing(pub T);
+
+/// Wrapper trait for synchronous RPC functions.
+pub trait Wrap {
+ fn wrap_rpc(&self, base: &B, params: Params) -> Result;
+}
+
+// special impl for no parameters.
+impl Wrap for fn(&B) -> Result
+ where B: Send + Sync + 'static, OUT: Serialize
+{
+ fn wrap_rpc(&self, base: &B, params: Params) -> Result {
+ ::v1::helpers::params::expect_no_params(params)
+ .and_then(|()| (self)(base))
+ .map(to_value)
+ }
+}
+
+// creates a wrapper implementation which deserializes the parameters,
+// calls the function with concrete type, and serializes the output.
+macro_rules! wrap {
+ ($($x: ident),+) => {
+ impl <
+ BASE: Send + Sync + 'static,
+ OUT: Serialize,
+ $($x: Deserialize,)+
+ > Wrap for fn(&BASE, $($x,)+) -> Result {
+ fn wrap_rpc(&self, base: &BASE, params: Params) -> Result {
+ from_params::<($($x,)+)>(params).and_then(|($($x,)+)| {
+ (self)(base, $($x,)+)
+ }).map(to_value)
+ }
+ }
+ }
+}
+
+// special impl for no parameters other than block parameter.
+impl Wrap for fn(&B, Trailing) -> Result
+ where B: Send + Sync + 'static, OUT: Serialize, T: Default + Deserialize
+{
+ fn wrap_rpc(&self, base: &B, params: Params) -> Result {
+ let len = match params {
+ Params::Array(ref v) => v.len(),
+ Params::None => 0,
+ _ => return Err(errors::invalid_params("not an array", "")),
+ };
+
+ let (id,) = match len {
+ 0 => (T::default(),),
+ 1 => try!(from_params::<(T,)>(params)),
+ _ => return Err(Error::invalid_params()),
+ };
+
+ (self)(base, Trailing(id)).map(to_value)
+ }
+}
+
+// similar to `wrap!`, but handles a single default trailing parameter
+// accepts an additional argument indicating the number of non-trailing parameters.
+macro_rules! wrap_with_trailing {
+ ($num: expr, $($x: ident),+) => {
+ impl <
+ BASE: Send + Sync + 'static,
+ OUT: Serialize,
+ $($x: Deserialize,)+
+ TRAILING: Default + Deserialize,
+ > Wrap for fn(&BASE, $($x,)+ Trailing) -> Result {
+ fn wrap_rpc(&self, base: &BASE, params: Params) -> Result {
+ let len = match params {
+ Params::Array(ref v) => v.len(),
+ Params::None => 0,
+ _ => return Err(errors::invalid_params("not an array", "")),
+ };
+
+ let params = match len - $num {
+ 0 => from_params::<($($x,)+)>(params)
+ .map(|($($x,)+)| ($($x,)+ TRAILING::default())),
+ 1 => from_params::<($($x,)+ TRAILING)>(params)
+ .map(|($($x,)+ id)| ($($x,)+ id)),
+ _ => Err(Error::invalid_params()),
+ };
+
+ let ($($x,)+ id) = try!(params);
+ (self)(base, $($x,)+ Trailing(id)).map(to_value)
+ }
+ }
+ }
+}
+
+wrap!(A, B, C, D, E);
+wrap!(A, B, C, D);
+wrap!(A, B, C);
+wrap!(A, B);
+wrap!(A);
+
+wrap_with_trailing!(5, A, B, C, D, E);
+wrap_with_trailing!(4, A, B, C, D);
+wrap_with_trailing!(3, A, B, C);
+wrap_with_trailing!(2, A, B);
+wrap_with_trailing!(1, A);
\ No newline at end of file
diff --git a/rpc/src/v1/helpers/dispatch.rs b/rpc/src/v1/helpers/dispatch.rs
index 5587673d8..df2d8cbd3 100644
--- a/rpc/src/v1/helpers/dispatch.rs
+++ b/rpc/src/v1/helpers/dispatch.rs
@@ -41,7 +41,7 @@ fn prepare_transaction(client: &C, miner: &M, request: TransactionRequest)
}
}
-pub fn dispatch_transaction(client: &C, miner: &M, signed_transaction: SignedTransaction) -> Result
+pub fn dispatch_transaction(client: &C, miner: &M, signed_transaction: SignedTransaction) -> Result
where C: MiningBlockChainClient, M: MinerService {
let hash = RpcH256::from(signed_transaction.hash());
@@ -49,7 +49,7 @@ pub fn dispatch_transaction(client: &C, miner: &M, signed_transaction: Sig
import
.map_err(errors::from_transaction_error)
- .map(|_| to_value(&hash))
+ .map(|_| hash)
}
pub fn signature_with_password(accounts: &AccountProvider, address: Address, hash: H256, pass: String) -> Result {
@@ -70,7 +70,7 @@ pub fn unlock_sign_and_dispatch(client: &C, miner: &M, request: Transactio
};
trace!(target: "miner", "send_transaction: dispatching tx: {}", ::rlp::encode(&signed_transaction).to_vec().pretty());
- dispatch_transaction(&*client, &*miner, signed_transaction)
+ dispatch_transaction(&*client, &*miner, signed_transaction).map(to_value)
}
pub fn sign_and_dispatch(client: &C, miner: &M, request: TransactionRequest, account_provider: &AccountProvider, address: Address) -> Result
@@ -84,7 +84,7 @@ pub fn sign_and_dispatch(client: &C, miner: &M, request: TransactionReques
};
trace!(target: "miner", "send_transaction: dispatching tx: {}", ::rlp::encode(&signed_transaction).to_vec().pretty());
- dispatch_transaction(&*client, &*miner, signed_transaction)
+ dispatch_transaction(&*client, &*miner, signed_transaction).map(to_value)
}
pub fn default_gas_price(client: &C, miner: &M) -> U256 where C: MiningBlockChainClient, M: MinerService {
diff --git a/rpc/src/v1/helpers/errors.rs b/rpc/src/v1/helpers/errors.rs
index 8a11f2466..18e369208 100644
--- a/rpc/src/v1/helpers/errors.rs
+++ b/rpc/src/v1/helpers/errors.rs
@@ -139,6 +139,13 @@ pub fn no_author() -> Error {
}
}
+pub fn token(e: String) -> Error {
+ Error {
+ code: ErrorCode::ServerError(codes::UNKNOWN_ERROR),
+ message: "There was an error when saving your authorization tokens.".into(),
+ data: Some(Value::String(e)),
+ }
+}
pub fn signer_disabled() -> Error {
Error {
diff --git a/rpc/src/v1/helpers/mod.rs b/rpc/src/v1/helpers/mod.rs
index d71eaac41..e6ada3379 100644
--- a/rpc/src/v1/helpers/mod.rs
+++ b/rpc/src/v1/helpers/mod.rs
@@ -14,18 +14,25 @@
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see .
+#[macro_use]
+pub mod auto_args;
+
#[macro_use]
pub mod errors;
+
pub mod dispatch;
pub mod params;
+
mod poll_manager;
mod poll_filter;
mod requests;
+mod signer;
mod signing_queue;
mod network_settings;
pub use self::poll_manager::PollManager;
-pub use self::poll_filter::PollFilter;
+pub use self::poll_filter::{PollFilter, limit_logs};
pub use self::requests::{TransactionRequest, FilledTransactionRequest, ConfirmationRequest, ConfirmationPayload, CallRequest};
pub use self::signing_queue::{ConfirmationsQueue, ConfirmationPromise, ConfirmationResult, SigningQueue, QueueEvent};
+pub use self::signer::SignerService;
pub use self::network_settings::NetworkSettings;
diff --git a/rpc/src/v1/helpers/params.rs b/rpc/src/v1/helpers/params.rs
index 4a6abf542..f56c500fc 100644
--- a/rpc/src/v1/helpers/params.rs
+++ b/rpc/src/v1/helpers/params.rs
@@ -36,14 +36,6 @@ pub fn params_len(params: &Params) -> usize {
}
}
-/// Deserialize request parameters with optional second parameter `BlockNumber` defaulting to `BlockNumber::Latest`.
-pub fn from_params_default_second(params: Params) -> Result<(F, BlockNumber, ), Error> where F: serde::de::Deserialize {
- match params_len(¶ms) {
- 1 => from_params::<(F, )>(params).map(|(f,)| (f, BlockNumber::Latest)),
- _ => from_params::<(F, BlockNumber)>(params),
- }
-}
-
/// Deserialize request parameters with optional third parameter `BlockNumber` defaulting to `BlockNumber::Latest`.
pub fn from_params_default_third(params: Params) -> Result<(F1, F2, BlockNumber, ), Error> where F1: serde::de::Deserialize, F2: serde::de::Deserialize {
match params_len(¶ms) {
diff --git a/rpc/src/v1/helpers/poll_filter.rs b/rpc/src/v1/helpers/poll_filter.rs
index 31bbf47fe..faae75c98 100644
--- a/rpc/src/v1/helpers/poll_filter.rs
+++ b/rpc/src/v1/helpers/poll_filter.rs
@@ -13,6 +13,15 @@ pub enum PollFilter {
Block(BlockNumber),
/// Hashes of all transactions which client was notified about.
PendingTransaction(Vec),
- /// Number of From block number, pending logs and log filter iself.
+ /// Number of From block number, pending logs and log filter itself.
Logs(BlockNumber, HashSet, Filter)
}
+
+/// Returns only last `n` logs
+pub fn limit_logs(mut logs: Vec, limit: Option) -> Vec {
+ let len = logs.len();
+ match limit {
+ Some(limit) if len >= limit => logs.split_off(len - limit),
+ _ => logs,
+ }
+}
diff --git a/rpc/src/v1/helpers/signer.rs b/rpc/src/v1/helpers/signer.rs
new file mode 100644
index 000000000..2cebc8261
--- /dev/null
+++ b/rpc/src/v1/helpers/signer.rs
@@ -0,0 +1,61 @@
+// 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 .
+
+use std::sync::Arc;
+use std::ops::Deref;
+use v1::helpers::signing_queue::{ConfirmationsQueue};
+
+/// Manages communication with Signer crate
+pub struct SignerService {
+ queue: Arc,
+ generate_new_token: Box Result + Send + Sync + 'static>,
+}
+
+impl SignerService {
+
+ /// Creates new Signer Service given function to generate new tokens.
+ pub fn new(new_token: F) -> Self
+ where F: Fn() -> Result + Send + Sync + 'static {
+ SignerService {
+ queue: Arc::new(ConfirmationsQueue::default()),
+ generate_new_token: Box::new(new_token),
+ }
+ }
+
+ /// Generates new token.
+ pub fn generate_token(&self) -> Result {
+ (self.generate_new_token)()
+ }
+
+ /// Returns a reference to `ConfirmationsQueue`
+ pub fn queue(&self) -> Arc {
+ self.queue.clone()
+ }
+
+ #[cfg(test)]
+ /// Creates new Signer Service for tests.
+ pub fn new_test() -> Self {
+ SignerService::new(|| Ok("new_token".into()))
+ }
+}
+
+impl Deref for SignerService {
+ type Target = ConfirmationsQueue;
+ fn deref(&self) -> &Self::Target {
+ &self.queue
+ }
+}
+
diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs
index d3bf68735..755539ebd 100644
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -42,10 +42,14 @@ use ethcore::log_entry::LogEntry;
use ethcore::filter::Filter as EthcoreFilter;
use self::ethash::SeedHashCompute;
use v1::traits::Eth;
-use v1::types::{Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo, Transaction, CallRequest, Index, Filter, Log, Receipt, H64 as RpcH64, H256 as RpcH256, H160 as RpcH160, U256 as RpcU256};
-use v1::helpers::{CallRequest as CRequest, errors};
+use v1::types::{
+ Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo,
+ Transaction, CallRequest, Index, Filter, Log, Receipt, Work,
+ H64 as RpcH64, H256 as RpcH256, H160 as RpcH160, U256 as RpcU256,
+};
+use v1::helpers::{CallRequest as CRequest, errors, limit_logs};
use v1::helpers::dispatch::{default_gas_price, dispatch_transaction};
-use v1::helpers::params::{expect_no_params, params_len, from_params_default_second, from_params_default_third};
+use v1::helpers::auto_args::Trailing;
/// Eth RPC options
pub struct EthClientOptions {
@@ -100,7 +104,7 @@ impl EthClient where
}
}
- fn block(&self, id: BlockID, include_txs: bool) -> Result {
+ fn block(&self, id: BlockID, include_txs: bool) -> Result, Error> {
let client = take_weak!(self.client);
match (client.block(id.clone()), client.block_total_difficulty(id)) {
(Some(bytes), Some(total_difficulty)) => {
@@ -131,28 +135,28 @@ impl EthClient where
},
extra_data: Bytes::new(view.extra_data())
};
- Ok(to_value(&block))
+ Ok(Some(block))
},
- _ => Ok(Value::Null)
+ _ => Ok(None)
}
}
- fn transaction(&self, id: TransactionID) -> Result {
+ fn transaction(&self, id: TransactionID) -> Result, Error> {
match take_weak!(self.client).transaction(id) {
- Some(t) => Ok(to_value(&Transaction::from(t))),
- None => Ok(Value::Null)
+ Some(t) => Ok(Some(Transaction::from(t))),
+ None => Ok(None),
}
}
- fn uncle(&self, id: UncleID) -> Result {
+ fn uncle(&self, id: UncleID) -> Result, Error> {
let client = take_weak!(self.client);
let uncle: BlockHeader = match client.uncle(id) {
Some(rlp) => rlp::decode(&rlp),
- None => { return Ok(Value::Null); }
+ None => { return Ok(None); }
};
let parent_difficulty = match client.block_total_difficulty(BlockID::Hash(uncle.parent_hash().clone())) {
Some(difficulty) => difficulty,
- None => { return Ok(Value::Null); }
+ None => { return Ok(None); }
};
let block = Block {
@@ -177,7 +181,7 @@ impl EthClient where
uncles: vec![],
transactions: BlockTransactions::Hashes(vec![]),
};
- Ok(to_value(&block))
+ Ok(Some(block))
}
fn sign_call(&self, request: CRequest) -> Result {
@@ -240,20 +244,19 @@ impl Eth for EthClient where
M: MinerService + 'static,
EM: ExternalMinerService + 'static {
- fn protocol_version(&self, params: Params) -> Result {
+ fn protocol_version(&self) -> Result {
try!(self.active());
- try!(expect_no_params(params));
- Ok(Value::String(format!("{}", take_weak!(self.sync).status().protocol_version).to_owned()))
+ let version = take_weak!(self.sync).status().protocol_version.to_owned();
+ Ok(format!("{}", version))
}
- fn syncing(&self, params: Params) -> Result {
+ fn syncing(&self) -> Result {
try!(self.active());
- try!(expect_no_params(params));
let status = take_weak!(self.sync).status();
- let res = match status.state {
- SyncState::Idle => SyncStatus::None,
+ match status.state {
+ SyncState::Idle => Ok(SyncStatus::None),
SyncState::Waiting | SyncState::Blocks | SyncState::NewBlocks | SyncState::ChainHead
| SyncState::SnapshotManifest | SyncState::SnapshotData | SyncState::SnapshotWaiting => {
let current_block = U256::from(take_weak!(self.client).chain_info().best_block_number);
@@ -265,271 +268,242 @@ impl Eth for EthClient where
current_block: current_block.into(),
highest_block: highest_block.into(),
};
- SyncStatus::Info(info)
+ Ok(SyncStatus::Info(info))
} else {
- SyncStatus::None
+ Ok(SyncStatus::None)
}
}
- };
- Ok(to_value(&res))
+ }
}
- fn author(&self, params: Params) -> Result {
+ fn author(&self) -> Result {
try!(self.active());
- try!(expect_no_params(params));
- Ok(to_value(&RpcH160::from(take_weak!(self.miner).author())))
+ Ok(RpcH160::from(take_weak!(self.miner).author()))
}
- fn is_mining(&self, params: Params) -> Result {
+ fn is_mining(&self) -> Result {
try!(self.active());
- try!(expect_no_params(params));
- Ok(to_value(&(take_weak!(self.miner).is_sealing())))
+ Ok(take_weak!(self.miner).is_sealing())
}
- fn hashrate(&self, params: Params) -> Result {
+ fn hashrate(&self) -> Result {
try!(self.active());
- try!(expect_no_params(params));
- Ok(to_value(&RpcU256::from(self.external_miner.hashrate())))
+ Ok(RpcU256::from(self.external_miner.hashrate()))
}
- fn gas_price(&self, params: Params) -> Result {
+ fn gas_price(&self) -> Result {
try!(self.active());
- try!(expect_no_params(params));
let (client, miner) = (take_weak!(self.client), take_weak!(self.miner));
- Ok(to_value(&RpcU256::from(default_gas_price(&*client, &*miner))))
+ Ok(RpcU256::from(default_gas_price(&*client, &*miner)))
}
- fn accounts(&self, params: Params) -> Result {
+ fn accounts(&self) -> Result, Error> {
try!(self.active());
- try!(expect_no_params(params));
let store = take_weak!(self.accounts);
let accounts = try!(store.accounts().map_err(|e| errors::internal("Could not fetch accounts.", e)));
- Ok(to_value(&accounts.into_iter().map(Into::into).collect::>()))
+ Ok(accounts.into_iter().map(Into::into).collect())
}
- fn block_number(&self, params: Params) -> Result {
+ fn block_number(&self) -> Result {
try!(self.active());
- try!(expect_no_params(params));
- Ok(to_value(&RpcU256::from(take_weak!(self.client).chain_info().best_block_number)))
+ Ok(RpcU256::from(take_weak!(self.client).chain_info().best_block_number))
}
- fn balance(&self, params: Params) -> Result