Merge branch 'master' into jg-external-dapps

This commit is contained in:
Jaco Greeff 2016-11-16 12:36:43 +01:00
commit d14801f4ea
55 changed files with 8720 additions and 7653 deletions

2
Cargo.lock generated
View File

@ -1249,7 +1249,7 @@ dependencies = [
[[package]] [[package]]
name = "parity-ui-precompiled" name = "parity-ui-precompiled"
version = "1.4.0" version = "1.4.0"
source = "git+https://github.com/ethcore/js-precompiled.git#b4df3bd592651729716ec38577410f7c1e767007" source = "git+https://github.com/ethcore/js-precompiled.git#985a6d9cf9aa4621172fcb8e4bf6955f33d5e2a3"
dependencies = [ dependencies = [
"parity-dapps-glue 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)", "parity-dapps-glue 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
] ]

View File

@ -0,0 +1,42 @@
{
"name": "TestAuthorityRound",
"engine": {
"AuthorityRound": {
"params": {
"gasLimitBoundDivisor": "0x0400",
"stepDuration": "1",
"authorities" : [
"0x7d577a597b2742b498cb5cf0c26cdcd726d39e6e",
"0x82a978b3f5962a5b0957d9ee9eef472ee55b42f1"
]
}
}
},
"params": {
"accountStartNonce": "0x0",
"maximumExtraDataSize": "0x20",
"minGasLimit": "0x1388",
"networkID" : "0x69"
},
"genesis": {
"seal": {
"generic": {
"fields": 1,
"rlp": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa"
}
},
"difficulty": "0x20000",
"author": "0x0000000000000000000000000000000000000000",
"timestamp": "0x00",
"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
"extraData": "0x",
"gasLimit": "0x2fefd8"
},
"accounts": {
"0000000000000000000000000000000000000001": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
"0000000000000000000000000000000000000002": { "balance": "1", "nonce": "1048576", "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
"0000000000000000000000000000000000000003": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
"0000000000000000000000000000000000000004": { "balance": "1", "nonce": "1048576", "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } },
"9cce34f7ab185c7aba1b7c8140d620b4bda941d6": { "balance": "1606938044258990275541962092341162602522202993782792835301376", "nonce": "1048576" }
}
}

View File

@ -1,5 +1,5 @@
{ {
"name": "TestAuthority", "name": "TestBasicAuthority",
"engine": { "engine": {
"BasicAuthority": { "BasicAuthority": {
"params": { "params": {

View File

@ -131,10 +131,11 @@
"0x807640a13483f8ac783c557fcdf27be11ea4ac7a" "0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
], ],
"eip150Transition": "0x259518", "eip150Transition": "0x259518",
"eip155Transition": "0x7fffffffffffffff", "eip155Transition": 2675000,
"eip160Transition": "0x7fffffffffffffff", "eip160Transition": 2675000,
"eip161abcTransition": "0x7fffffffffffffff", "eip161abcTransition": 2675000,
"eip161dTransition": "0x7fffffffffffffff" "eip161dTransition": 2675000,
"maxCodeSize": 24576
} }
} }
}, },

View File

@ -11,10 +11,10 @@
"registrar": "0x52dff57a8a1532e6afb3dc07e2af58bb9eb05b3d", "registrar": "0x52dff57a8a1532e6afb3dc07e2af58bb9eb05b3d",
"homesteadTransition": "0x789b0", "homesteadTransition": "0x789b0",
"eip150Transition": "0x1b34d8", "eip150Transition": "0x1b34d8",
"eip155Transition": "0x7fffffffffffffff", "eip155Transition": 1885000,
"eip160Transition": "0x7fffffffffffffff", "eip160Transition": 1885000,
"eip161abcTransition": "0x7fffffffffffffff", "eip161abcTransition": 1885000,
"eip161dTransition": "0x7fffffffffffffff" "eip161dTransition": 1885000
} }
} }
}, },

View File

@ -554,6 +554,7 @@ impl Client {
/// Import transactions from the IO queue /// Import transactions from the IO queue
pub fn import_queued_transactions(&self, transactions: &[Bytes]) -> usize { pub fn import_queued_transactions(&self, transactions: &[Bytes]) -> usize {
trace!(target: "external_tx", "Importing queued");
let _timer = PerfTimer::new("import_queued_transactions"); let _timer = PerfTimer::new("import_queued_transactions");
self.queue_transactions.fetch_sub(transactions.len(), AtomicOrdering::SeqCst); self.queue_transactions.fetch_sub(transactions.len(), AtomicOrdering::SeqCst);
let txs = transactions.iter().filter_map(|bytes| UntrustedRlp::new(bytes).as_val().ok()).collect(); let txs = transactions.iter().filter_map(|bytes| UntrustedRlp::new(bytes).as_val().ok()).collect();
@ -561,6 +562,11 @@ impl Client {
results.len() results.len()
} }
/// Used by PoA to try sealing on period change.
pub fn update_sealing(&self) {
self.miner.update_sealing(self)
}
/// Attempt to get a copy of a specific block's final state. /// Attempt to get a copy of a specific block's final state.
/// ///
/// This will not fail if given BlockID::Latest. /// This will not fail if given BlockID::Latest.
@ -1193,7 +1199,9 @@ impl BlockChainClient for Client {
} }
fn queue_transactions(&self, transactions: Vec<Bytes>) { fn queue_transactions(&self, transactions: Vec<Bytes>) {
if self.queue_transactions.load(AtomicOrdering::Relaxed) > MAX_TX_QUEUE_SIZE { let queue_size = self.queue_transactions.load(AtomicOrdering::Relaxed);
trace!(target: "external_tx", "Queue size: {}", queue_size);
if queue_size > MAX_TX_QUEUE_SIZE {
debug!("Ignoring {} transactions: queue is full", transactions.len()); debug!("Ignoring {} transactions: queue is full", transactions.len());
} else { } else {
let len = transactions.len(); let len = transactions.len();

View File

@ -119,6 +119,16 @@ impl TestBlockChainClient {
/// Creates new test client with specified extra data for each block /// Creates new test client with specified extra data for each block
pub fn new_with_extra_data(extra_data: Bytes) -> Self { pub fn new_with_extra_data(extra_data: Bytes) -> Self {
let spec = Spec::new_test(); let spec = Spec::new_test();
TestBlockChainClient::new_with_spec_and_extra(spec, extra_data)
}
/// Create test client with custom spec.
pub fn new_with_spec(spec: Spec) -> Self {
TestBlockChainClient::new_with_spec_and_extra(spec, Bytes::new())
}
/// Create test client with custom spec and extra data.
pub fn new_with_spec_and_extra(spec: Spec, extra_data: Bytes) -> Self {
let mut client = TestBlockChainClient { let mut client = TestBlockChainClient {
blocks: RwLock::new(HashMap::new()), blocks: RwLock::new(HashMap::new()),
numbers: RwLock::new(HashMap::new()), numbers: RwLock::new(HashMap::new()),
@ -315,7 +325,7 @@ pub fn get_temp_state_db() -> GuardedTempResult<StateDB> {
impl MiningBlockChainClient for TestBlockChainClient { impl MiningBlockChainClient for TestBlockChainClient {
fn latest_schedule(&self) -> Schedule { fn latest_schedule(&self) -> Schedule {
Schedule::new_post_eip150(true, true, true) Schedule::new_post_eip150(24576, true, true, true)
} }
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 {

View File

@ -0,0 +1,429 @@
// Copyright 2015, 2016 Ethcore (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
//! A blockchain engine that supports a non-instant BFT proof-of-authority.
use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering as AtomicOrdering};
use std::sync::Weak;
use std::time::{UNIX_EPOCH, Duration};
use util::*;
use ethkey::{verify_address, Signature};
use rlp::{UntrustedRlp, View, encode};
use account_provider::AccountProvider;
use block::*;
use spec::CommonParams;
use engines::Engine;
use header::Header;
use error::{Error, BlockError};
use evm::Schedule;
use ethjson;
use io::{IoContext, IoHandler, TimerToken, IoService, IoChannel};
use service::ClientIoMessage;
use transaction::SignedTransaction;
use env_info::EnvInfo;
use builtin::Builtin;
/// `AuthorityRound` params.
#[derive(Debug, PartialEq)]
pub struct AuthorityRoundParams {
/// Gas limit divisor.
pub gas_limit_bound_divisor: U256,
/// Time to wait before next block or authority switching.
pub step_duration: Duration,
/// Valid authorities.
pub authorities: Vec<Address>,
/// Number of authorities.
pub authority_n: usize,
}
impl From<ethjson::spec::AuthorityRoundParams> for AuthorityRoundParams {
fn from(p: ethjson::spec::AuthorityRoundParams) -> Self {
AuthorityRoundParams {
gas_limit_bound_divisor: p.gas_limit_bound_divisor.into(),
step_duration: Duration::from_secs(p.step_duration.into()),
authority_n: p.authorities.len(),
authorities: p.authorities.into_iter().map(Into::into).collect::<Vec<_>>(),
}
}
}
/// Engine using `AuthorityRound` proof-of-work consensus algorithm, suitable for Ethereum
/// mainnet chains in the Olympic, Frontier and Homestead eras.
pub struct AuthorityRound {
params: CommonParams,
our_params: AuthorityRoundParams,
builtins: BTreeMap<Address, Builtin>,
transition_service: IoService<BlockArrived>,
message_channel: Mutex<Option<IoChannel<ClientIoMessage>>>,
step: AtomicUsize,
proposed: AtomicBool,
}
fn header_step(header: &Header) -> Result<usize, ::rlp::DecoderError> {
UntrustedRlp::new(&header.seal()[0]).as_val()
}
fn header_signature(header: &Header) -> Result<Signature, ::rlp::DecoderError> {
UntrustedRlp::new(&header.seal()[1]).as_val::<H520>().map(Into::into)
}
trait AsMillis {
fn as_millis(&self) -> u64;
}
impl AsMillis for Duration {
fn as_millis(&self) -> u64 {
self.as_secs()*1_000 + (self.subsec_nanos()/1_000_000) as u64
}
}
impl AuthorityRound {
/// Create a new instance of AuthorityRound engine.
pub fn new(params: CommonParams, our_params: AuthorityRoundParams, builtins: BTreeMap<Address, Builtin>) -> Result<Arc<Self>, Error> {
let initial_step = (unix_now().as_secs() / our_params.step_duration.as_secs()) as usize;
let engine = Arc::new(
AuthorityRound {
params: params,
our_params: our_params,
builtins: builtins,
transition_service: try!(IoService::<BlockArrived>::start()),
message_channel: Mutex::new(None),
step: AtomicUsize::new(initial_step),
proposed: AtomicBool::new(false)
});
let handler = TransitionHandler { engine: Arc::downgrade(&engine) };
try!(engine.transition_service.register_handler(Arc::new(handler)));
Ok(engine)
}
fn step(&self) -> usize {
self.step.load(AtomicOrdering::SeqCst)
}
fn remaining_step_duration(&self) -> Duration {
let now = unix_now();
let step_end = self.our_params.step_duration * (self.step() as u32 + 1);
if step_end > now {
step_end - now
} else {
Duration::from_secs(0)
}
}
fn step_proposer(&self, step: usize) -> &Address {
let ref p = self.our_params;
p.authorities.get(step % p.authority_n).expect("There are authority_n authorities; taking number modulo authority_n gives number in authority_n range; qed")
}
fn is_step_proposer(&self, step: usize, address: &Address) -> bool {
self.step_proposer(step) == address
}
}
fn unix_now() -> Duration {
UNIX_EPOCH.elapsed().expect("Valid time has to be set in your system.")
}
struct TransitionHandler {
engine: Weak<AuthorityRound>,
}
#[derive(Clone)]
struct BlockArrived;
const ENGINE_TIMEOUT_TOKEN: TimerToken = 23;
impl IoHandler<BlockArrived> for TransitionHandler {
fn initialize(&self, io: &IoContext<BlockArrived>) {
if let Some(engine) = self.engine.upgrade() {
io.register_timer_once(ENGINE_TIMEOUT_TOKEN, engine.remaining_step_duration().as_millis())
.unwrap_or_else(|e| warn!(target: "poa", "Failed to start consensus step timer: {}.", e))
}
}
fn timeout(&self, io: &IoContext<BlockArrived>, timer: TimerToken) {
if timer == ENGINE_TIMEOUT_TOKEN {
if let Some(engine) = self.engine.upgrade() {
engine.step.fetch_add(1, AtomicOrdering::SeqCst);
engine.proposed.store(false, AtomicOrdering::SeqCst);
if let Some(ref channel) = *engine.message_channel.lock() {
match channel.send(ClientIoMessage::UpdateSealing) {
Ok(_) => trace!(target: "poa", "timeout: UpdateSealing message sent for step {}.", engine.step.load(AtomicOrdering::Relaxed)),
Err(err) => trace!(target: "poa", "timeout: Could not send a sealing message {} for step {}.", err, engine.step.load(AtomicOrdering::Relaxed)),
}
}
io.register_timer_once(ENGINE_TIMEOUT_TOKEN, engine.remaining_step_duration().as_millis())
.unwrap_or_else(|e| warn!(target: "poa", "Failed to restart consensus step timer: {}.", e))
}
}
}
}
impl Engine for AuthorityRound {
fn name(&self) -> &str { "AuthorityRound" }
fn version(&self) -> SemanticVersion { SemanticVersion::new(1, 0, 0) }
/// Two fields - consensus step and the corresponding proposer signature.
fn seal_fields(&self) -> usize { 2 }
fn params(&self) -> &CommonParams { &self.params }
fn builtins(&self) -> &BTreeMap<Address, Builtin> { &self.builtins }
/// Additional engine-specific information for the user/developer concerning `header`.
fn extra_info(&self, header: &Header) -> BTreeMap<String, String> {
map![
"step".into() => header_step(header).as_ref().map(ToString::to_string).unwrap_or("".into()),
"signature".into() => header_signature(header).as_ref().map(ToString::to_string).unwrap_or("".into())
]
}
fn schedule(&self, _env_info: &EnvInfo) -> Schedule {
Schedule::new_post_eip150(usize::max_value(), true, true, true)
}
fn populate_from_parent(&self, header: &mut Header, parent: &Header, gas_floor_target: U256, _gas_ceil_target: U256) {
header.set_difficulty(parent.difficulty().clone());
header.set_gas_limit({
let gas_limit = parent.gas_limit().clone();
let bound_divisor = self.our_params.gas_limit_bound_divisor;
if gas_limit < gas_floor_target {
min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
} else {
max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
}
});
}
/// Apply the block reward on finalisation of the block.
/// This assumes that all uncles are valid uncles (i.e. of at least one generation before the current).
fn on_close_block(&self, _block: &mut ExecutedBlock) {}
fn is_sealer(&self, author: &Address) -> Option<bool> {
let ref p = self.our_params;
Some(p.authorities.contains(author))
}
/// Attempt to seal the block internally.
///
/// This operation is synchronous and may (quite reasonably) not be available, in which `false` will
/// be returned.
fn generate_seal(&self, block: &ExecutedBlock, accounts: Option<&AccountProvider>) -> Option<Vec<Bytes>> {
if self.proposed.load(AtomicOrdering::SeqCst) { return None; }
let header = block.header();
let step = self.step();
if self.is_step_proposer(step, header.author()) {
if let Some(ap) = accounts {
// Account should be permanently unlocked, otherwise sealing will fail.
if let Ok(signature) = ap.sign(*header.author(), None, header.bare_hash()) {
trace!(target: "poa", "generate_seal: Issuing a block for step {}.", step);
self.proposed.store(true, AtomicOrdering::SeqCst);
return Some(vec![encode(&step).to_vec(), encode(&(&*signature as &[u8])).to_vec()]);
} else {
warn!(target: "poa", "generate_seal: FAIL: Accounts secret key unavailable.");
}
} else {
warn!(target: "poa", "generate_seal: FAIL: Accounts not provided.");
}
}
None
}
/// Check the number of seal fields.
fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
if header.seal().len() != self.seal_fields() {
trace!(target: "poa", "verify_block_basic: wrong number of seal fields");
Err(From::from(BlockError::InvalidSealArity(
Mismatch { expected: self.seal_fields(), found: header.seal().len() }
)))
} else {
Ok(())
}
}
/// Check if the signature belongs to the correct proposer.
fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
let header_step = try!(header_step(header));
// Give one step slack if step is lagging, double vote is still not possible.
if header_step <= self.step() + 1 {
let proposer_signature = try!(header_signature(header));
let ok_sig = try!(verify_address(self.step_proposer(header_step), &proposer_signature, &header.bare_hash()));
if ok_sig {
Ok(())
} else {
trace!(target: "poa", "verify_block_unordered: invalid seal signature");
try!(Err(BlockError::InvalidSeal))
}
} else {
trace!(target: "poa", "verify_block_unordered: block from the future");
try!(Err(BlockError::InvalidSeal))
}
}
fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
// Don't calculate difficulty for genesis blocks.
if header.number() == 0 {
return Err(From::from(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() })));
}
let step = try!(header_step(header));
// Check if parent is from a previous step.
if step == try!(header_step(parent)) {
trace!(target: "poa", "Multiple blocks proposed for step {}.", step);
try!(Err(BlockError::DoubleVote(header.author().clone())));
}
// Check difficulty is correct given the two timestamps.
if header.difficulty() != parent.difficulty() {
return Err(From::from(BlockError::InvalidDifficulty(Mismatch { expected: *parent.difficulty(), found: *header.difficulty() })))
}
let gas_limit_divisor = self.our_params.gas_limit_bound_divisor;
let min_gas = parent.gas_limit().clone() - parent.gas_limit().clone() / gas_limit_divisor;
let max_gas = parent.gas_limit().clone() + parent.gas_limit().clone() / gas_limit_divisor;
if header.gas_limit() <= &min_gas || header.gas_limit() >= &max_gas {
return Err(From::from(BlockError::InvalidGasLimit(OutOfBounds { min: Some(min_gas), max: Some(max_gas), found: header.gas_limit().clone() })));
}
Ok(())
}
fn verify_transaction_basic(&self, t: &SignedTransaction, _header: &Header) -> Result<(), Error> {
try!(t.check_low_s());
Ok(())
}
fn verify_transaction(&self, t: &SignedTransaction, _header: &Header) -> Result<(), Error> {
t.sender().map(|_|()) // Perform EC recovery and cache sender
}
fn register_message_channel(&self, message_channel: IoChannel<ClientIoMessage>) {
let mut guard = self.message_channel.lock();
*guard = Some(message_channel);
}
}
#[cfg(test)]
mod tests {
use util::*;
use env_info::EnvInfo;
use header::Header;
use error::{Error, BlockError};
use rlp::encode;
use block::*;
use tests::helpers::*;
use account_provider::AccountProvider;
use spec::Spec;
use std::time::UNIX_EPOCH;
#[test]
fn has_valid_metadata() {
let engine = Spec::new_test_round().engine;
assert!(!engine.name().is_empty());
assert!(engine.version().major >= 1);
}
#[test]
fn can_return_schedule() {
let engine = Spec::new_test_round().engine;
let schedule = engine.schedule(&EnvInfo {
number: 10000000,
author: 0.into(),
timestamp: 0,
difficulty: 0.into(),
last_hashes: Arc::new(vec![]),
gas_used: 0.into(),
gas_limit: 0.into(),
});
assert!(schedule.stack_limit > 0);
}
#[test]
fn verification_fails_on_short_seal() {
let engine = Spec::new_test_round().engine;
let header: Header = Header::default();
let verify_result = engine.verify_block_basic(&header, None);
match verify_result {
Err(Error::Block(BlockError::InvalidSealArity(_))) => {},
Err(_) => { panic!("should be block seal-arity mismatch error (got {:?})", verify_result); },
_ => { panic!("Should be error, got Ok"); },
}
}
#[test]
fn can_do_signature_verification_fail() {
let engine = Spec::new_test_round().engine;
let mut header: Header = Header::default();
header.set_seal(vec![encode(&H520::default()).to_vec()]);
let verify_result = engine.verify_block_unordered(&header, None);
assert!(verify_result.is_err());
}
#[test]
fn generates_seal_and_does_not_double_propose() {
let tap = AccountProvider::transient_provider();
let addr1 = tap.insert_account("1".sha3(), "1").unwrap();
tap.unlock_account_permanently(addr1, "1".into()).unwrap();
let addr2 = tap.insert_account("2".sha3(), "2").unwrap();
tap.unlock_account_permanently(addr2, "2".into()).unwrap();
let spec = Spec::new_test_round();
let engine = &*spec.engine;
let genesis_header = spec.genesis_header();
let mut db1 = get_temp_state_db().take();
spec.ensure_db_good(&mut db1).unwrap();
let mut db2 = get_temp_state_db().take();
spec.ensure_db_good(&mut db2).unwrap();
let last_hashes = Arc::new(vec![genesis_header.hash()]);
let b1 = OpenBlock::new(engine, Default::default(), false, db1, &genesis_header, last_hashes.clone(), addr1, (3141562.into(), 31415620.into()), vec![]).unwrap();
let b1 = b1.close_and_lock();
let b2 = OpenBlock::new(engine, Default::default(), false, db2, &genesis_header, last_hashes, addr2, (3141562.into(), 31415620.into()), vec![]).unwrap();
let b2 = b2.close_and_lock();
if let Some(seal) = engine.generate_seal(b1.block(), Some(&tap)) {
assert!(b1.clone().try_seal(engine, seal).is_ok());
// Second proposal is forbidden.
assert!(engine.generate_seal(b1.block(), Some(&tap)).is_none());
}
if let Some(seal) = engine.generate_seal(b2.block(), Some(&tap)) {
assert!(b2.clone().try_seal(engine, seal).is_ok());
// Second proposal is forbidden.
assert!(engine.generate_seal(b2.block(), Some(&tap)).is_none());
}
}
#[test]
fn proposer_switching() {
let mut header: Header = Header::default();
let tap = AccountProvider::transient_provider();
let addr = tap.insert_account("0".sha3(), "0").unwrap();
header.set_author(addr);
let engine = Spec::new_test_round().engine;
let signature = tap.sign(addr, Some("0".into()), header.bare_hash()).unwrap();
let mut step = UNIX_EPOCH.elapsed().unwrap().as_secs();
header.set_seal(vec![encode(&step).to_vec(), encode(&(&*signature as &[u8])).to_vec()]);
let first_ok = engine.verify_block_seal(&header).is_ok();
step = step + 1;
header.set_seal(vec![encode(&step).to_vec(), encode(&(&*signature as &[u8])).to_vec()]);
let second_ok = engine.verify_block_seal(&header).is_ok();
assert!(first_ok ^ second_ok);
}
}

View File

@ -181,13 +181,6 @@ impl Engine for BasicAuthority {
} }
} }
impl Header {
/// Get the none field of the header.
pub fn signature(&self) -> H520 {
::rlp::decode(&self.seal()[0])
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use util::*; use util::*;
@ -201,7 +194,7 @@ mod tests {
/// Create a new test chain spec with `BasicAuthority` consensus engine. /// Create a new test chain spec with `BasicAuthority` consensus engine.
fn new_test_authority() -> Spec { fn new_test_authority() -> Spec {
let bytes: &[u8] = include_bytes!("../../res/test_authority.json"); let bytes: &[u8] = include_bytes!("../../res/basic_authority.json");
Spec::load(bytes).expect("invalid chain spec") Spec::load(bytes).expect("invalid chain spec")
} }

View File

@ -55,7 +55,7 @@ impl Engine for InstantSeal {
} }
fn schedule(&self, _env_info: &EnvInfo) -> Schedule { fn schedule(&self, _env_info: &EnvInfo) -> Schedule {
Schedule::new_post_eip150(false, false, false) Schedule::new_post_eip150(usize::max_value(), false, false, false)
} }
fn is_sealer(&self, _author: &Address) -> Option<bool> { Some(true) } fn is_sealer(&self, _author: &Address) -> Option<bool> { Some(true) }

View File

@ -19,10 +19,12 @@
mod null_engine; mod null_engine;
mod instant_seal; mod instant_seal;
mod basic_authority; mod basic_authority;
mod authority_round;
pub use self::null_engine::NullEngine; pub use self::null_engine::NullEngine;
pub use self::instant_seal::InstantSeal; pub use self::instant_seal::InstantSeal;
pub use self::basic_authority::BasicAuthority; pub use self::basic_authority::BasicAuthority;
pub use self::authority_round::AuthorityRound;
use util::*; use util::*;
use account_provider::AccountProvider; use account_provider::AccountProvider;
@ -32,6 +34,8 @@ use env_info::EnvInfo;
use error::Error; use error::Error;
use spec::CommonParams; use spec::CommonParams;
use evm::Schedule; use evm::Schedule;
use io::IoChannel;
use service::ClientIoMessage;
use header::Header; use header::Header;
use transaction::SignedTransaction; use transaction::SignedTransaction;
@ -140,5 +144,7 @@ pub trait Engine : Sync + Send {
self.builtins().get(a).expect("attempted to execute nonexistent builtin").execute(input, output); self.builtins().get(a).expect("attempted to execute nonexistent builtin").execute(input, output);
} }
/// Add a channel for communication with Client which can be used for sealing.
fn register_message_channel(&self, _message_channel: IoChannel<ClientIoMessage>) {}
// TODO: sealing stuff - though might want to leave this for later. // TODO: sealing stuff - though might want to leave this for later.
} }

View File

@ -167,6 +167,8 @@ pub enum BlockError {
UnknownParent(H256), UnknownParent(H256),
/// Uncle parent given is unknown. /// Uncle parent given is unknown.
UnknownUncleParent(H256), UnknownUncleParent(H256),
/// The same author issued different votes at the same step.
DoubleVote(H160),
} }
impl fmt::Display for BlockError { impl fmt::Display for BlockError {
@ -200,6 +202,7 @@ impl fmt::Display for BlockError {
RidiculousNumber(ref oob) => format!("Implausible block number. {}", oob), RidiculousNumber(ref oob) => format!("Implausible block number. {}", oob),
UnknownParent(ref hash) => format!("Unknown parent: {}", hash), UnknownParent(ref hash) => format!("Unknown parent: {}", hash),
UnknownUncleParent(ref hash) => format!("Unknown uncle parent: {}", hash), UnknownUncleParent(ref hash) => format!("Unknown uncle parent: {}", hash),
DoubleVote(ref address) => format!("Author {} issued too many blocks.", address),
}; };
f.write_fmt(format_args!("Block error ({})", msg)) f.write_fmt(format_args!("Block error ({})", msg))

View File

@ -73,7 +73,9 @@ pub struct EthashParams {
/// Number of first block where ECIP-1010 begins. /// Number of first block where ECIP-1010 begins.
pub ecip1010_pause_transition: u64, pub ecip1010_pause_transition: u64,
/// Number of first block where ECIP-1010 ends. /// Number of first block where ECIP-1010 ends.
pub ecip1010_continue_transition: u64 pub ecip1010_continue_transition: u64,
/// Maximum amount of code that can be deploying into a contract.
pub max_code_size: u64,
} }
impl From<ethjson::spec::EthashParams> for EthashParams { impl From<ethjson::spec::EthashParams> for EthashParams {
@ -87,19 +89,20 @@ impl From<ethjson::spec::EthashParams> for EthashParams {
block_reward: p.block_reward.into(), block_reward: p.block_reward.into(),
registrar: p.registrar.map_or_else(Address::new, Into::into), registrar: p.registrar.map_or_else(Address::new, Into::into),
homestead_transition: p.homestead_transition.map_or(0, Into::into), homestead_transition: p.homestead_transition.map_or(0, Into::into),
dao_hardfork_transition: p.dao_hardfork_transition.map_or(0x7fffffffffffffff, Into::into), dao_hardfork_transition: p.dao_hardfork_transition.map_or(u64::max_value(), Into::into),
dao_hardfork_beneficiary: p.dao_hardfork_beneficiary.map_or_else(Address::new, Into::into), dao_hardfork_beneficiary: p.dao_hardfork_beneficiary.map_or_else(Address::new, Into::into),
dao_hardfork_accounts: p.dao_hardfork_accounts.unwrap_or_else(Vec::new).into_iter().map(Into::into).collect(), dao_hardfork_accounts: p.dao_hardfork_accounts.unwrap_or_else(Vec::new).into_iter().map(Into::into).collect(),
difficulty_hardfork_transition: p.difficulty_hardfork_transition.map_or(0x7fffffffffffffff, Into::into), difficulty_hardfork_transition: p.difficulty_hardfork_transition.map_or(u64::max_value(), Into::into),
difficulty_hardfork_bound_divisor: p.difficulty_hardfork_bound_divisor.map_or(p.difficulty_bound_divisor.into(), Into::into), difficulty_hardfork_bound_divisor: p.difficulty_hardfork_bound_divisor.map_or(p.difficulty_bound_divisor.into(), Into::into),
bomb_defuse_transition: p.bomb_defuse_transition.map_or(0x7fffffffffffffff, Into::into), bomb_defuse_transition: p.bomb_defuse_transition.map_or(u64::max_value(), Into::into),
eip150_transition: p.eip150_transition.map_or(0, Into::into), eip150_transition: p.eip150_transition.map_or(0, Into::into),
eip155_transition: p.eip155_transition.map_or(0, Into::into), eip155_transition: p.eip155_transition.map_or(0, Into::into),
eip160_transition: p.eip160_transition.map_or(0, Into::into), eip160_transition: p.eip160_transition.map_or(0, Into::into),
eip161abc_transition: p.eip161abc_transition.map_or(0, Into::into), eip161abc_transition: p.eip161abc_transition.map_or(0, Into::into),
eip161d_transition: p.eip161d_transition.map_or(0x7fffffffffffffff, Into::into), eip161d_transition: p.eip161d_transition.map_or(u64::max_value(), Into::into),
ecip1010_pause_transition: p.ecip1010_pause_transition.map_or(0x7fffffffffffffff, Into::into), ecip1010_pause_transition: p.ecip1010_pause_transition.map_or(u64::max_value(), Into::into),
ecip1010_continue_transition: p.ecip1010_continue_transition.map_or(0x7fffffffffffffff, Into::into), ecip1010_continue_transition: p.ecip1010_continue_transition.map_or(u64::max_value(), Into::into),
max_code_size: p.max_code_size.map_or(u64::max_value(), Into::into),
} }
} }
} }
@ -152,6 +155,7 @@ impl Engine for Ethash {
Schedule::new_homestead() Schedule::new_homestead()
} else { } else {
Schedule::new_post_eip150( Schedule::new_post_eip150(
self.ethash_params.max_code_size as usize,
env_info.number >= self.ethash_params.eip160_transition, env_info.number >= self.ethash_params.eip160_transition,
env_info.number >= self.ethash_params.eip161abc_transition, env_info.number >= self.ethash_params.eip161abc_transition,
env_info.number >= self.ethash_params.eip161d_transition env_info.number >= self.ethash_params.eip161d_transition

View File

@ -70,6 +70,8 @@ pub struct Schedule {
pub quad_coeff_div: usize, pub quad_coeff_div: usize,
/// Cost for contract length when executing `CREATE` /// Cost for contract length when executing `CREATE`
pub create_data_gas: usize, pub create_data_gas: usize,
/// Maximum code size when creating a contract.
pub create_data_limit: usize,
/// Transaction cost /// Transaction cost
pub tx_gas: usize, pub tx_gas: usize,
/// `CREATE` transaction cost /// `CREATE` transaction cost
@ -111,7 +113,7 @@ impl Schedule {
} }
/// Schedule for the post-EIP-150-era of the Ethereum main net. /// Schedule for the post-EIP-150-era of the Ethereum main net.
pub fn new_post_eip150(fix_exp: bool, no_empty: bool, kill_empty: bool) -> Schedule { pub fn new_post_eip150(max_code_size: usize, fix_exp: bool, no_empty: bool, kill_empty: bool) -> Schedule {
Schedule { Schedule {
exceptional_failed_code_deposit: true, exceptional_failed_code_deposit: true,
have_delegate_call: true, have_delegate_call: true,
@ -139,6 +141,7 @@ impl Schedule {
memory_gas: 3, memory_gas: 3,
quad_coeff_div: 512, quad_coeff_div: 512,
create_data_gas: 200, create_data_gas: 200,
create_data_limit: max_code_size,
tx_gas: 21000, tx_gas: 21000,
tx_create_gas: 53000, tx_create_gas: 53000,
tx_data_zero_gas: 4, tx_data_zero_gas: 4,
@ -183,6 +186,7 @@ impl Schedule {
memory_gas: 3, memory_gas: 3,
quad_coeff_div: 512, quad_coeff_div: 512,
create_data_gas: 200, create_data_gas: 200,
create_data_limit: usize::max_value(),
tx_gas: 21000, tx_gas: 21000,
tx_create_gas: tcg, tx_create_gas: tcg,
tx_data_zero_gas: 4, tx_data_zero_gas: 4,

View File

@ -242,7 +242,7 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
}, },
OutputPolicy::InitContract(ref mut copy) => { OutputPolicy::InitContract(ref mut copy) => {
let return_cost = U256::from(data.len()) * U256::from(self.schedule.create_data_gas); let return_cost = U256::from(data.len()) * U256::from(self.schedule.create_data_gas);
if return_cost > *gas { if return_cost > *gas || data.len() > self.schedule.create_data_limit {
return match self.schedule.exceptional_failed_code_deposit { return match self.schedule.exceptional_failed_code_deposit {
true => Err(evm::Error::OutOfGas), true => Err(evm::Error::OutOfGas),
false => Ok(*gas) false => Ok(*gas)

View File

@ -212,7 +212,8 @@ pub struct Miner {
sealing_block_last_request: Mutex<u64>, sealing_block_last_request: Mutex<u64>,
// for sealing... // for sealing...
options: MinerOptions, options: MinerOptions,
seals_internally: bool, /// Does the node perform internal (without work) sealing.
pub seals_internally: bool,
gas_range_target: RwLock<(U256, U256)>, gas_range_target: RwLock<(U256, U256)>,
author: RwLock<Address>, author: RwLock<Address>,
@ -267,6 +268,11 @@ impl Miner {
} }
} }
/// Creates new instance of miner with accounts and with given spec.
pub fn with_spec_and_accounts(spec: &Spec, accounts: Option<Arc<AccountProvider>>) -> Miner {
Miner::new_raw(Default::default(), GasPricer::new_fixed(20_000_000_000u64.into()), spec, accounts)
}
/// Creates new instance of miner without accounts, but with given spec. /// Creates new instance of miner without accounts, but with given spec.
pub fn with_spec(spec: &Spec) -> Miner { pub fn with_spec(spec: &Spec) -> Miner {
Miner::new_raw(Default::default(), GasPricer::new_fixed(20_000_000_000u64.into()), spec, None) Miner::new_raw(Default::default(), GasPricer::new_fixed(20_000_000_000u64.into()), spec, None)
@ -429,6 +435,7 @@ impl Miner {
let last_request = *self.sealing_block_last_request.lock(); let last_request = *self.sealing_block_last_request.lock();
let should_disable_sealing = !self.forced_sealing() let should_disable_sealing = !self.forced_sealing()
&& !has_local_transactions && !has_local_transactions
&& !self.seals_internally
&& best_block > last_request && best_block > last_request
&& best_block - last_request > SEALING_TIMEOUT_IN_BLOCKS; && best_block - last_request > SEALING_TIMEOUT_IN_BLOCKS;
@ -472,9 +479,10 @@ impl Miner {
/// Uses Engine to seal the block internally and then imports it to chain. /// Uses Engine to seal the block internally and then imports it to chain.
fn seal_and_import_block_internally(&self, chain: &MiningBlockChainClient, block: ClosedBlock) -> bool { fn seal_and_import_block_internally(&self, chain: &MiningBlockChainClient, block: ClosedBlock) -> bool {
if !block.transactions().is_empty() { if !block.transactions().is_empty() || self.forced_sealing() {
if let Ok(sealed) = self.seal_block_internally(block) { if let Ok(sealed) = self.seal_block_internally(block) {
if chain.import_block(sealed.rlp_bytes()).is_ok() { if chain.import_block(sealed.rlp_bytes()).is_ok() {
trace!(target: "miner", "import_block_internally: imported internally sealed block");
return true return true
} }
} }
@ -773,7 +781,7 @@ impl MinerService for Miner {
chain: &MiningBlockChainClient, chain: &MiningBlockChainClient,
transactions: Vec<SignedTransaction> transactions: Vec<SignedTransaction>
) -> Vec<Result<TransactionImportResult, Error>> { ) -> Vec<Result<TransactionImportResult, Error>> {
trace!(target: "external_tx", "Importing external transactions");
let results = { let results = {
let mut transaction_queue = self.transaction_queue.lock(); let mut transaction_queue = self.transaction_queue.lock();
self.add_transactions_to_queue( self.add_transactions_to_queue(

View File

@ -48,6 +48,8 @@ pub enum ClientIoMessage {
FeedBlockChunk(H256, Bytes), FeedBlockChunk(H256, Bytes),
/// Take a snapshot for the block with given number. /// Take a snapshot for the block with given number.
TakeSnapshot(u64), TakeSnapshot(u64),
/// Trigger sealing update (useful for internal sealing).
UpdateSealing,
} }
/// Client service setup. Creates and registers client and network services with the IO subsystem. /// Client service setup. Creates and registers client and network services with the IO subsystem.
@ -111,6 +113,8 @@ impl ClientService {
}); });
try!(io_service.register_handler(client_io)); try!(io_service.register_handler(client_io));
spec.engine.register_message_channel(io_service.channel());
let stop_guard = ::devtools::StopGuard::new(); let stop_guard = ::devtools::StopGuard::new();
run_ipc(ipc_path, client.clone(), snapshot.clone(), stop_guard.share()); run_ipc(ipc_path, client.clone(), snapshot.clone(), stop_guard.share());
@ -213,8 +217,11 @@ impl IoHandler<ClientIoMessage> for ClientIoHandler {
if let Err(e) = res { if let Err(e) = res {
debug!(target: "snapshot", "Failed to initialize periodic snapshot thread: {:?}", e); debug!(target: "snapshot", "Failed to initialize periodic snapshot thread: {:?}", e);
} }
},
} ClientIoMessage::UpdateSealing => {
trace!(target: "authorityround", "message: UpdateSealing");
self.client.update_sealing()
},
_ => {} // ignore other messages _ => {} // ignore other messages
} }
} }

View File

@ -18,7 +18,7 @@
use util::*; use util::*;
use builtin::Builtin; use builtin::Builtin;
use engines::{Engine, NullEngine, InstantSeal, BasicAuthority}; use engines::{Engine, NullEngine, InstantSeal, BasicAuthority, AuthorityRound};
use pod_state::*; use pod_state::*;
use account_db::*; use account_db::*;
use header::{BlockNumber, Header}; use header::{BlockNumber, Header};
@ -150,6 +150,7 @@ impl Spec {
ethjson::spec::Engine::InstantSeal => Arc::new(InstantSeal::new(params, builtins)), ethjson::spec::Engine::InstantSeal => Arc::new(InstantSeal::new(params, builtins)),
ethjson::spec::Engine::Ethash(ethash) => Arc::new(ethereum::Ethash::new(params, From::from(ethash.params), builtins)), ethjson::spec::Engine::Ethash(ethash) => Arc::new(ethereum::Ethash::new(params, From::from(ethash.params), builtins)),
ethjson::spec::Engine::BasicAuthority(basic_authority) => Arc::new(BasicAuthority::new(params, From::from(basic_authority.params), builtins)), ethjson::spec::Engine::BasicAuthority(basic_authority) => Arc::new(BasicAuthority::new(params, From::from(basic_authority.params), builtins)),
ethjson::spec::Engine::AuthorityRound(authority_round) => AuthorityRound::new(params, From::from(authority_round.params), builtins).expect("Consensus engine could not be started."),
} }
} }
@ -280,6 +281,10 @@ impl Spec {
/// Create a new Spec with InstantSeal consensus which does internal sealing (not requiring work). /// Create a new Spec with InstantSeal consensus which does internal sealing (not requiring work).
pub fn new_instant() -> Spec { load_bundled!("instant_seal") } pub fn new_instant() -> Spec { load_bundled!("instant_seal") }
/// Create a new Spec with AuthorityRound consensus which does internal sealing (not requiring work).
/// Accounts with secrets "1".sha3() and "2".sha3() are the authorities.
pub fn new_test_round() -> Self { load_bundled!("authority_round") }
} }
#[cfg(test)] #[cfg(test)]

View File

@ -433,18 +433,19 @@ pub fn get_default_ethash_params() -> EthashParams{
block_reward: U256::from(0), block_reward: U256::from(0),
registrar: "0000000000000000000000000000000000000001".into(), registrar: "0000000000000000000000000000000000000001".into(),
homestead_transition: 1150000, homestead_transition: 1150000,
dao_hardfork_transition: 0x7fffffffffffffff, dao_hardfork_transition: u64::max_value(),
dao_hardfork_beneficiary: "0000000000000000000000000000000000000001".into(), dao_hardfork_beneficiary: "0000000000000000000000000000000000000001".into(),
dao_hardfork_accounts: vec![], dao_hardfork_accounts: vec![],
difficulty_hardfork_transition: 0x7fffffffffffffff, difficulty_hardfork_transition: u64::max_value(),
difficulty_hardfork_bound_divisor: U256::from(0), difficulty_hardfork_bound_divisor: U256::from(0),
bomb_defuse_transition: 0x7fffffffffffffff, bomb_defuse_transition: u64::max_value(),
eip150_transition: 0x7fffffffffffffff, eip150_transition: u64::max_value(),
eip155_transition: 0x7fffffffffffffff, eip155_transition: u64::max_value(),
eip160_transition: 0x7fffffffffffffff, eip160_transition: u64::max_value(),
eip161abc_transition: 0x7fffffffffffffff, eip161abc_transition: u64::max_value(),
eip161d_transition: 0x7fffffffffffffff, eip161d_transition: u64::max_value(),
ecip1010_pause_transition: 0x7fffffffffffffff, ecip1010_pause_transition: u64::max_value(),
ecip1010_continue_transition: 0x7fffffffffffffff ecip1010_continue_transition: u64::max_value(),
max_code_size: u64::max_value(),
} }
} }

File diff suppressed because it is too large Load Diff

View File

@ -1,6 +1,6 @@
{ {
"name": "parity.js", "name": "parity.js",
"version": "0.2.46", "version": "0.2.48",
"main": "release/index.js", "main": "release/index.js",
"jsnext:main": "src/index.js", "jsnext:main": "src/index.js",
"author": "Parity Team <admin@parity.io>", "author": "Parity Team <admin@parity.io>",

View File

@ -40,9 +40,12 @@ export default class Contract {
this._events.forEach((evt) => { this._events.forEach((evt) => {
this._instance[evt.name] = evt; this._instance[evt.name] = evt;
this._instance[evt.signature] = evt;
}); });
this._functions.forEach((fn) => { this._functions.forEach((fn) => {
this._instance[fn.name] = fn; this._instance[fn.name] = fn;
this._instance[fn.signature] = fn;
}); });
this._sendSubscriptionChanges(); this._sendSubscriptionChanges();

View File

@ -20,6 +20,7 @@ import sinon from 'sinon';
import { TEST_HTTP_URL, mockHttp } from '../../../test/mockRpc'; import { TEST_HTTP_URL, mockHttp } from '../../../test/mockRpc';
import Abi from '../../abi'; import Abi from '../../abi';
import { sha3 } from '../util/sha3';
import Api from '../api'; import Api from '../api';
import Contract from './contract'; import Contract from './contract';
@ -113,7 +114,13 @@ describe('api/contract/Contract', () => {
]); ]);
contract.at('6789'); contract.at('6789');
expect(Object.keys(contract.instance)).to.deep.equal(['Drained', 'balanceOf', 'address']); expect(Object.keys(contract.instance)).to.deep.equal([
'Drained',
/^(?:0x)(.+)$/.exec(sha3('Drained(uint256)'))[1],
'balanceOf',
/^(?:0x)(.+)$/.exec(sha3('balanceOf(address)'))[1].substr(0, 8),
'address'
]);
expect(contract.address).to.equal('6789'); expect(contract.address).to.equal('6789');
}); });
}); });

View File

@ -46,11 +46,22 @@ a.link, a.link:hover, a.link:visited {
} }
.address { .address {
max-width: 250px;
text-align: left; text-align: left;
div {
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
} }
.description { .description {
text-align: left; text-align: left;
div {
white-space: nowrap;
}
} }
.center { .center {

View File

@ -58,6 +58,7 @@ export default class Event extends Component {
<td className={ styles.description }> <td className={ styles.description }>
<div>{ isPending ? '' : coin.tla }</div> <div>{ isPending ? '' : coin.tla }</div>
<div>{ isPending ? '' : coin.name }</div> <div>{ isPending ? '' : coin.name }</div>
<div>{ this.renderAddress(event.params.coin) }</div>
</td> </td>
<td className={ styles.address }> <td className={ styles.address }>
{ this.renderAddress(event.params.owner) } { this.renderAddress(event.params.owner) }

View File

@ -46,3 +46,9 @@
.icon { .icon {
margin: 0 0 -4px 1em; margin: 0 0 -4px 1em;
} }
.byline {
opacity: 0.75;
font-size: 0.75em;
padding-top: 0.25em;
}

View File

@ -68,6 +68,9 @@ export default class Owner extends Component {
<Token <Token
address={ token.address } address={ token.address }
tokenreg={ token.tokenreg } /> tokenreg={ token.tokenreg } />
<div className={ styles.byline }>
{ token.address }
</div>
</div> </div>
)); ));
} }

View File

@ -227,6 +227,7 @@ export default class AddContract extends Component {
onEditAbi = (abiIn) => { onEditAbi = (abiIn) => {
const { api } = this.context; const { api } = this.context;
const { abi, abiError, abiParsed } = validateAbi(abiIn, api); const { abi, abiError, abiParsed } = validateAbi(abiIn, api);
this.setState({ abi, abiError, abiParsed }); this.setState({ abi, abiError, abiParsed });
} }

View File

@ -314,7 +314,7 @@ export default class Transfer extends Component {
} }
const token = balance.tokens.find((balance) => balance.token.tag === tag).token; const token = balance.tokens.find((balance) => balance.token.tag === tag).token;
const s = new BigNumber(num).mul(token.format || 1).toString(); const s = new BigNumber(num).mul(token.format || 1).toFixed();
if (s.indexOf('.') !== -1) { if (s.indexOf('.') !== -1) {
return ERRORS.invalidDecimals; return ERRORS.invalidDecimals;
@ -516,6 +516,13 @@ export default class Transfer extends Component {
} }
recalculateGas = () => { recalculateGas = () => {
if (!this.isValid()) {
this.setState({
gas: '0'
}, this.recalculate);
return;
}
(this.state.isEth (this.state.isEth
? this._estimateGasEth() ? this._estimateGasEth()
: this._estimateGasToken() : this._estimateGasToken()

View File

@ -15,6 +15,7 @@
// along with Parity. If not, see <http://www.gnu.org/licenses/>. // along with Parity. If not, see <http://www.gnu.org/licenses/>.
import React, { Component, PropTypes } from 'react'; import React, { Component, PropTypes } from 'react';
import FileSaver from 'file-saver'; import FileSaver from 'file-saver';
import FileDownloadIcon from 'material-ui/svg-icons/file/file-download'; import FileDownloadIcon from 'material-ui/svg-icons/file/file-download';
@ -38,19 +39,18 @@ class ActionbarExport extends Component {
className={ className } className={ className }
icon={ <FileDownloadIcon /> } icon={ <FileDownloadIcon /> }
label='export' label='export'
onClick={ this.onDownloadBackup } /> onClick={ this.handleExport }
/>
); );
} }
onDownloadBackup = () => { handleExport = () => {
const { filename, content } = this.props; const { filename, content } = this.props;
const text = (typeof content === 'string') const text = JSON.stringify(content, null, 4);
? content
: JSON.stringify(content, null, 4);
const blob = new Blob([ text ], { type: 'text/plain;charset=utf-8' }); const blob = new Blob([ text ], { type: 'application/json' });
FileSaver.saveAs(blob, filename); FileSaver.saveAs(blob, `${filename}.json`);
} }
} }

View File

@ -15,6 +15,8 @@
// along with Parity. If not, see <http://www.gnu.org/licenses/>. // along with Parity. If not, see <http://www.gnu.org/licenses/>.
import React, { Component, PropTypes } from 'react'; import React, { Component, PropTypes } from 'react';
import { observer } from 'mobx-react';
import IconMenu from 'material-ui/IconMenu'; import IconMenu from 'material-ui/IconMenu';
import MenuItem from 'material-ui/MenuItem'; import MenuItem from 'material-ui/MenuItem';
@ -22,11 +24,15 @@ import SortIcon from 'material-ui/svg-icons/content/sort';
import { Button } from '../../'; import { Button } from '../../';
import SortStore from './sortStore';
import styles from './sort.css'; import styles from './sort.css';
@observer
export default class ActionbarSort extends Component { export default class ActionbarSort extends Component {
static propTypes = { static propTypes = {
id: PropTypes.string.isRequired,
onChange: PropTypes.func.isRequired, onChange: PropTypes.func.isRequired,
order: PropTypes.string, order: PropTypes.string,
showDefault: PropTypes.bool, showDefault: PropTypes.bool,
metas: PropTypes.array metas: PropTypes.array
@ -37,8 +43,10 @@ export default class ActionbarSort extends Component {
showDefault: true showDefault: true
} }
state = { store = new SortStore(this.props);
menuOpen: false
componentDidMount () {
this.store.restoreSavedOrder();
} }
render () { render () {
@ -51,12 +59,12 @@ export default class ActionbarSort extends Component {
className={ styles.sortButton } className={ styles.sortButton }
label='' label=''
icon={ <SortIcon /> } icon={ <SortIcon /> }
onClick={ this.handleMenuOpen } onClick={ this.store.handleMenuOpen }
/> />
} }
open={ this.state.menuOpen } open={ this.store.menuOpen }
onRequestChange={ this.handleMenuChange } onRequestChange={ this.store.handleMenuChange }
onItemTouchTap={ this.handleSortChange } onItemTouchTap={ this.store.handleSortChange }
targetOrigin={ { horizontal: 'right', vertical: 'top' } } targetOrigin={ { horizontal: 'right', vertical: 'top' } }
anchorOrigin={ { horizontal: 'right', vertical: 'top' } } anchorOrigin={ { horizontal: 'right', vertical: 'top' } }
touchTapCloseDelay={ 0 } touchTapCloseDelay={ 0 }
@ -109,16 +117,4 @@ export default class ActionbarSort extends Component {
); );
} }
handleSortChange = (event, child) => {
const order = child.props.value;
this.props.onChange(order);
}
handleMenuOpen = () => {
this.setState({ menuOpen: true });
}
handleMenuChange = (open) => {
this.setState({ menuOpen: open });
}
} }

View File

@ -0,0 +1,71 @@
// Copyright 2015, 2016 Ethcore (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
import { action, observable } from 'mobx';
import store from 'store';
const LS_STORE_KEY = '_parity::sortStore';
export default class SortStore {
@observable menuOpen = false;
constructor (props) {
const { id, onChange } = props;
this.onChange = onChange;
this.id = id;
}
@action handleMenuOpen = () => {
this.menuOpen = true;
}
@action handleMenuChange = (open) => {
this.menuOpen = open;
}
@action handleSortChange = (event, child) => {
const order = child.props.value;
this.onChange(order);
this.saveOrder(order);
}
@action restoreSavedOrder = () => {
const order = this.getSavedOrder();
this.onChange(order);
}
getSavedOrder = () => {
return (this.getSavedOrders())[this.id];
}
getSavedOrders = () => {
return store.get(LS_STORE_KEY) || {};
}
setSavedOrders = (orders) => {
store.set(LS_STORE_KEY, orders);
}
saveOrder = (order) => {
const orders = {
...this.getSavedOrders(),
[ this.id ]: order
};
this.setSavedOrders(orders);
}
}

View File

@ -16,6 +16,7 @@
import React, { Component, PropTypes } from 'react'; import React, { Component, PropTypes } from 'react';
import { TextField } from 'material-ui'; import { TextField } from 'material-ui';
import { noop } from 'lodash';
import CopyToClipboard from '../../CopyToClipboard'; import CopyToClipboard from '../../CopyToClipboard';
@ -81,7 +82,7 @@ export default class Input extends Component {
} }
componentWillReceiveProps (newProps) { componentWillReceiveProps (newProps) {
if (newProps.value !== this.props.value) { if ((newProps.value !== this.props.value) && (newProps.value !== this.state.value)) {
this.setValue(newProps.value); this.setValue(newProps.value);
} }
} }
@ -131,6 +132,7 @@ export default class Input extends Component {
onBlur={ this.onBlur } onBlur={ this.onBlur }
onChange={ this.onChange } onChange={ this.onChange }
onKeyDown={ this.onKeyDown } onKeyDown={ this.onKeyDown }
onPaste={ this.onPaste }
inputStyle={ inputStyle } inputStyle={ inputStyle }
min={ min } min={ min }
max={ max } max={ max }
@ -180,9 +182,9 @@ export default class Input extends Component {
} }
onChange = (event, value) => { onChange = (event, value) => {
this.setValue(value); this.setValue(value, () => {
this.props.onChange && this.props.onChange(event, value);
this.props.onChange && this.props.onChange(event, value); });
} }
onBlur = (event) => { onBlur = (event) => {
@ -196,6 +198,14 @@ export default class Input extends Component {
this.props.onBlur && this.props.onBlur(event); this.props.onBlur && this.props.onBlur(event);
} }
onPaste = (event) => {
const value = event.clipboardData.getData('Text');
window.setTimeout(() => {
this.onSubmit(value);
}, 0);
}
onKeyDown = (event) => { onKeyDown = (event) => {
const { value } = event.target; const { value } = event.target;
@ -209,12 +219,12 @@ export default class Input extends Component {
} }
onSubmit = (value) => { onSubmit = (value) => {
this.setValue(value); this.setValue(value, () => {
this.props.onSubmit && this.props.onSubmit(value);
this.props.onSubmit && this.props.onSubmit(value); });
} }
setValue (value) { setValue (value, cb = noop) {
this.setState({ value }); this.setState({ value }, cb);
} }
} }

View File

@ -30,6 +30,10 @@
.iconDisabled { .iconDisabled {
position: absolute; position: absolute;
top: 35px; top: 35px;
&.noLabel {
top: 10px;
}
} }
.icon { .icon {

View File

@ -69,14 +69,19 @@ class InputAddress extends Component {
} }
renderIcon () { renderIcon () {
const { value, disabled } = this.props; const { value, disabled, label } = this.props;
if (!value || !value.length || !util.isAddressValid(value)) { if (!value || !value.length || !util.isAddressValid(value)) {
return null; return null;
} }
const classes = [disabled ? styles.iconDisabled : styles.icon];
if (!label) {
classes.push(styles.noLabel);
}
return ( return (
<div className={ disabled ? styles.iconDisabled : styles.icon }> <div className={ classes.join(' ') }>
<IdentityIcon <IdentityIcon
inline center inline center
address={ value } /> address={ value } />

View File

@ -44,7 +44,7 @@ export function validateAbi (abi, api) {
// Validate each elements of the Array // Validate each elements of the Array
const invalidIndex = abiParsed const invalidIndex = abiParsed
.map((o) => isValidAbiEvent(o, api) || isValidAbiFunction(o, api)) .map((o) => isValidAbiEvent(o, api) || isValidAbiFunction(o, api) || isAbiFallback(o))
.findIndex((valid) => !valid); .findIndex((valid) => !valid);
if (invalidIndex !== -1) { if (invalidIndex !== -1) {
@ -74,6 +74,14 @@ function isValidAbiFunction (object, api) {
(object.inputs && api.util.isArray(object.inputs)); (object.inputs && api.util.isArray(object.inputs));
} }
function isAbiFallback (object) {
if (!object) {
return false;
}
return object.type === 'fallback';
}
function isValidAbiEvent (object, api) { function isValidAbiEvent (object, api) {
if (!object) { if (!object) {
return false; return false;

View File

@ -22,7 +22,7 @@ import { uniq } from 'lodash';
import List from './List'; import List from './List';
import { CreateAccount } from '../../modals'; import { CreateAccount } from '../../modals';
import { Actionbar, ActionbarSearch, ActionbarSort, Button, Page, Tooltip } from '../../ui'; import { Actionbar, ActionbarExport, ActionbarSearch, ActionbarSort, Button, Page, Tooltip } from '../../ui';
import styles from './accounts.css'; import styles from './accounts.css';
@ -90,12 +90,15 @@ class Accounts extends Component {
return ( return (
<ActionbarSort <ActionbarSort
key='sortAccounts' key='sortAccounts'
id='sortAccounts'
order={ this.state.sortOrder } order={ this.state.sortOrder }
onChange={ onChange } /> onChange={ onChange } />
); );
} }
renderActionbar () { renderActionbar () {
const { accounts } = this.props;
const buttons = [ const buttons = [
<Button <Button
key='newAccount' key='newAccount'
@ -103,6 +106,11 @@ class Accounts extends Component {
label='new account' label='new account'
onClick={ this.onNewAccountClick } />, onClick={ this.onNewAccountClick } />,
<ActionbarExport
key='exportAccounts'
content={ accounts }
filename='accounts' />,
this.renderSearchButton(), this.renderSearchButton(),
this.renderSortButton() this.renderSortButton()
]; ];

View File

@ -75,6 +75,7 @@ class Addresses extends Component {
return ( return (
<ActionbarSort <ActionbarSort
key='sortAccounts' key='sortAccounts'
id='sortAddresses'
order={ this.state.sortOrder } order={ this.state.sortOrder }
onChange={ onChange } /> onChange={ onChange } />
); );
@ -106,7 +107,7 @@ class Addresses extends Component {
<ActionbarExport <ActionbarExport
key='exportAddressbook' key='exportAddressbook'
content={ contacts } content={ contacts }
filename='addressbook.json' />, filename='addressbook' />,
<ActionbarImport <ActionbarImport
key='importAddressbook' key='importAddressbook'

View File

@ -19,7 +19,7 @@ import React, { Component, PropTypes } from 'react';
import LinearProgress from 'material-ui/LinearProgress'; import LinearProgress from 'material-ui/LinearProgress';
import { Card, CardActions, CardTitle, CardText } from 'material-ui/Card'; import { Card, CardActions, CardTitle, CardText } from 'material-ui/Card';
import { Button, Input, InputAddressSelect } from '../../../ui'; import { Button, Input, InputAddress, InputAddressSelect } from '../../../ui';
import styles from './queries.css'; import styles from './queries.css';
@ -33,6 +33,7 @@ export default class InputQuery extends Component {
inputs: PropTypes.array.isRequired, inputs: PropTypes.array.isRequired,
outputs: PropTypes.array.isRequired, outputs: PropTypes.array.isRequired,
name: PropTypes.string.isRequired, name: PropTypes.string.isRequired,
signature: PropTypes.string.isRequired,
className: PropTypes.string className: PropTypes.string
} }
@ -95,32 +96,48 @@ export default class InputQuery extends Component {
} }
if (!results || results.length < 1) return null; if (!results || results.length < 1) return null;
return outputs return outputs
.map((out, index) => ({ .map((out, index) => ({
name: out.name, name: out.name,
type: out.type,
value: results[index], value: results[index],
display: this.renderValue(results[index]) display: this.renderValue(results[index])
})) }))
.sort((outA, outB) => outA.display.length - outB.display.length) .sort((outA, outB) => outA.display.length - outB.display.length)
.map((out, index) => ( .map((out, index) => {
<div key={ index }> let input = null;
<div className={ styles.queryResultName }> if (out.type === 'address') {
{ out.name } input = (
</div> <InputAddress
className={ styles.queryValue }
disabled
value={ out.display }
/>
);
} else {
input = (
<Input
className={ styles.queryValue }
readOnly
allowCopy
value={ out.display }
/>
);
}
<Input return (
className={ styles.queryValue } <div key={ index }>
readOnly <div className={ styles.queryResultName }>
allowCopy { out.name }
value={ out.display } </div>
/> { input }
<br /> </div>
</div> );
)); });
} }
renderInput (input) { renderInput (input) {
const { values } = this.state;
const { name, type } = input; const { name, type } = input;
const label = `${name ? `${name}: ` : ''}${type}`; const label = `${name ? `${name}: ` : ''}${type}`;
@ -142,6 +159,7 @@ export default class InputQuery extends Component {
<InputAddressSelect <InputAddressSelect
hint={ type } hint={ type }
label={ label } label={ label }
value={ values[name] }
required required
onChange={ onChange } onChange={ onChange }
/> />
@ -154,6 +172,7 @@ export default class InputQuery extends Component {
<Input <Input
hint={ type } hint={ type }
label={ label } label={ label }
value={ values[name] }
required required
onChange={ onChange } onChange={ onChange }
/> />
@ -177,7 +196,7 @@ export default class InputQuery extends Component {
onClick = () => { onClick = () => {
const { values } = this.state; const { values } = this.state;
const { inputs, contract, name, outputs } = this.props; const { inputs, contract, name, outputs, signature } = this.props;
this.setState({ this.setState({
isLoading: true, isLoading: true,
@ -187,7 +206,7 @@ export default class InputQuery extends Component {
const inputValues = inputs.map(input => values[input.name]); const inputValues = inputs.map(input => values[input.name]);
contract contract
.instance[name] .instance[signature]
.call({}, inputValues) .call({}, inputValues)
.then(results => { .then(results => {
if (outputs.length === 1) { if (outputs.length === 1) {

View File

@ -56,18 +56,10 @@
} }
.methodResults { .methodResults {
display: flex;
flex-wrap: wrap;
max-width: 24rem;
justify-content: space-around;
} }
.methodResults > div { .methodResults > div {
padding: 0.25rem 0.5rem; padding: 0.25rem 0.5rem;
display: flex;
flex-direction: column;
align-items: center;
flex: 1 1 50%;
box-sizing: border-box; box-sizing: border-box;
& > div { & > div {

View File

@ -19,7 +19,7 @@ import React, { Component, PropTypes } from 'react';
import { Card, CardTitle, CardText } from 'material-ui/Card'; import { Card, CardTitle, CardText } from 'material-ui/Card';
import InputQuery from './inputQuery'; import InputQuery from './inputQuery';
import { Container, ContainerTitle, Input } from '../../../ui'; import { Container, ContainerTitle, Input, InputAddress } from '../../../ui';
import styles from './queries.css'; import styles from './queries.css';
@ -70,7 +70,7 @@ export default class Queries extends Component {
} }
renderInputQuery (fn) { renderInputQuery (fn) {
const { abi, name } = fn; const { abi, name, signature } = fn;
const { contract } = this.props; const { contract } = this.props;
return ( return (
@ -80,6 +80,7 @@ export default class Queries extends Component {
inputs={ abi.inputs } inputs={ abi.inputs }
outputs={ abi.outputs } outputs={ abi.outputs }
name={ name } name={ name }
signature={ signature }
contract={ contract } contract={ contract }
/> />
</div> </div>
@ -99,14 +100,14 @@ export default class Queries extends Component {
<CardText <CardText
className={ styles.methodContent } className={ styles.methodContent }
> >
{ this.renderValue(values[fn.name]) } { this.renderValue(values[fn.name], fn.outputs[0].kind.type) }
</CardText> </CardText>
</Card> </Card>
</div> </div>
); );
} }
renderValue (value) { renderValue (value, type) {
if (typeof value === 'undefined') { if (typeof value === 'undefined') {
return null; return null;
} }
@ -124,6 +125,16 @@ export default class Queries extends Component {
valueToDisplay = value.toString(); valueToDisplay = value.toString();
} }
if (type === 'address') {
return (
<InputAddress
className={ styles.queryValue }
value={ valueToDisplay }
disabled
/>
);
}
return ( return (
<Input <Input
className={ styles.queryValue } className={ styles.queryValue }

View File

@ -82,6 +82,7 @@ class Contracts extends Component {
return ( return (
<ActionbarSort <ActionbarSort
key='sortAccounts' key='sortAccounts'
id='sortContracts'
order={ this.state.sortOrder } order={ this.state.sortOrder }
metas={ [ metas={ [
{ key: 'timestamp', label: 'date' } { key: 'timestamp', label: 'date' }

View File

@ -17,6 +17,9 @@
.acc { .acc {
text-align: center; text-align: center;
display: inline-block; display: inline-block;
overflow: hidden;
text-overflow: ellipsis;
width: 100%;
} }
.acc > * { .acc > * {
@ -35,10 +38,13 @@
} }
.name { .name {
text-overflow: ellipsis;
overflow: hidden;
white-space: nowrap; white-space: nowrap;
display: lock; display: block;
vertical-align: middle; vertical-align: middle;
text-transform: uppercase; text-transform: uppercase;
span {
text-overflow: ellipsis;
overflow: hidden;
}
} }

View File

@ -38,7 +38,9 @@
} }
.transactionDetails { .transactionDetails {
margin-right: 321px; padding-right: 321px;
width: 100%;
box-sizing: border-box;
} }
.isConfirmed { .isConfirmed {

View File

@ -19,7 +19,9 @@
} }
.transactionDetails { .transactionDetails {
margin-right: 321px; padding-right: 321px;
width: 100%;
box-sizing: border-box;
} }
.mainContainer { .mainContainer {

View File

@ -15,6 +15,7 @@
/* along with Parity. If not, see <http://www.gnu.org/licenses/>. /* along with Parity. If not, see <http://www.gnu.org/licenses/>.
*/ */
.signer { .signer {
width: 916px;
} }
.pending { .pending {

View File

@ -14,6 +14,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>. // along with Parity. If not, see <http://www.gnu.org/licenses/>.
const HappyPack = require('happypack');
const webpack = require('webpack'); const webpack = require('webpack');
const ENV = process.env.NODE_ENV || 'development'; const ENV = process.env.NODE_ENV || 'development';
@ -22,10 +23,26 @@ const DEST = process.env.BUILD_DEST || '.build';
let modules = [ let modules = [
'babel-polyfill', 'babel-polyfill',
'browserify-aes', 'ethereumjs-tx', 'scryptsy', 'bignumber.js',
'react', 'react-dom', 'react-redux', 'react-router', 'blockies',
'redux', 'redux-thunk', 'react-router-redux', 'brace',
'lodash', 'material-ui', 'moment', 'blockies' 'browserify-aes',
'chart.js',
'ethereumjs-tx',
'lodash',
'material-ui',
'mobx',
'mobx-react',
'moment',
'react',
'react-dom',
'react-redux',
'react-router',
'react-router-redux',
'recharts',
'redux',
'redux-thunk',
'scryptsy'
]; ];
if (!isProd) { if (!isProd) {
@ -44,6 +61,11 @@ module.exports = {
{ {
test: /\.json$/, test: /\.json$/,
loaders: ['json'] loaders: ['json']
},
{
test: /\.js$/,
include: /(ethereumjs-tx)/,
loaders: [ 'happypack/loader?id=js' ]
} }
] ]
}, },
@ -63,6 +85,12 @@ module.exports = {
'process.env': { 'process.env': {
NODE_ENV: JSON.stringify(ENV) NODE_ENV: JSON.stringify(ENV)
} }
}),
new HappyPack({
id: 'js',
threads: 4,
loaders: ['babel']
}) })
]; ];

View File

@ -0,0 +1,59 @@
// Copyright 2015, 2016 Ethcore (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
//! Authority params deserialization.
use uint::Uint;
use hash::Address;
/// Authority params deserialization.
#[derive(Debug, PartialEq, Deserialize)]
pub struct AuthorityRoundParams {
/// Gas limit divisor.
#[serde(rename="gasLimitBoundDivisor")]
pub gas_limit_bound_divisor: Uint,
/// Block duration.
#[serde(rename="stepDuration")]
pub step_duration: Uint,
/// Valid authorities
pub authorities: Vec<Address>,
}
/// Authority engine deserialization.
#[derive(Debug, PartialEq, Deserialize)]
pub struct AuthorityRound {
/// Ethash params.
pub params: AuthorityRoundParams,
}
#[cfg(test)]
mod tests {
use serde_json;
use spec::authority_round::AuthorityRound;
#[test]
fn basic_authority_deserialization() {
let s = r#"{
"params": {
"gasLimitBoundDivisor": "0x0400",
"stepDuration": "0x02",
"authorities" : ["0xc6d9d2cd449a754c494264e1809c50e34d64562b"]
}
}"#;
let _deserialized: AuthorityRound = serde_json::from_str(s).unwrap();
}
}

View File

@ -18,6 +18,7 @@
use spec::Ethash; use spec::Ethash;
use spec::BasicAuthority; use spec::BasicAuthority;
use spec::AuthorityRound;
/// Engine deserialization. /// Engine deserialization.
#[derive(Debug, PartialEq, Deserialize)] #[derive(Debug, PartialEq, Deserialize)]
@ -30,6 +31,8 @@ pub enum Engine {
Ethash(Ethash), Ethash(Ethash),
/// BasicAuthority engine. /// BasicAuthority engine.
BasicAuthority(BasicAuthority), BasicAuthority(BasicAuthority),
/// AuthorityRound engine.
AuthorityRound(AuthorityRound),
} }
#[cfg(test)] #[cfg(test)]

View File

@ -92,6 +92,11 @@ pub struct EthashParams {
/// See main EthashParams docs. /// See main EthashParams docs.
#[serde(rename="ecip1010ContinueTransition")] #[serde(rename="ecip1010ContinueTransition")]
pub ecip1010_continue_transition: Option<Uint>, pub ecip1010_continue_transition: Option<Uint>,
/// See main EthashParams docs.
#[serde(rename="maxCodeSize")]
pub max_code_size: Option<Uint>,
} }
/// Ethash engine deserialization. /// Ethash engine deserialization.

View File

@ -26,6 +26,7 @@ pub mod engine;
pub mod state; pub mod state;
pub mod ethash; pub mod ethash;
pub mod basic_authority; pub mod basic_authority;
pub mod authority_round;
pub use self::account::Account; pub use self::account::Account;
pub use self::builtin::{Builtin, Pricing, Linear}; pub use self::builtin::{Builtin, Pricing, Linear};
@ -37,3 +38,4 @@ pub use self::engine::Engine;
pub use self::state::State; pub use self::state::State;
pub use self::ethash::{Ethash, EthashParams}; pub use self::ethash::{Ethash, EthashParams};
pub use self::basic_authority::{BasicAuthority, BasicAuthorityParams}; pub use self::basic_authority::{BasicAuthority, BasicAuthorityParams};
pub use self::authority_round::{AuthorityRound, AuthorityRoundParams};

View File

@ -165,6 +165,9 @@ fn execute_import(cmd: ImportBlockchain) -> Result<String, String> {
Arc::new(Miner::with_spec(&spec)), Arc::new(Miner::with_spec(&spec)),
).map_err(|e| format!("Client service error: {:?}", e))); ).map_err(|e| format!("Client service error: {:?}", e)));
// free up the spec in memory.
drop(spec);
panic_handler.forward_from(&service); panic_handler.forward_from(&service);
let client = service.client(); let client = service.client();
@ -312,6 +315,8 @@ fn execute_export(cmd: ExportBlockchain) -> Result<String, String> {
Arc::new(Miner::with_spec(&spec)), Arc::new(Miner::with_spec(&spec)),
).map_err(|e| format!("Client service error: {:?}", e))); ).map_err(|e| format!("Client service error: {:?}", e)));
drop(spec);
panic_handler.forward_from(&service); panic_handler.forward_from(&service);
let client = service.client(); let client = service.client();

View File

@ -235,6 +235,9 @@ pub fn execute(cmd: RunCmd, logger: Arc<RotatingLogger>) -> Result<(), String> {
miner.clone(), miner.clone(),
).map_err(|e| format!("Client service error: {:?}", e))); ).map_err(|e| format!("Client service error: {:?}", e)));
// drop the spec to free up genesis state.
drop(spec);
// forward panics from service // forward panics from service
panic_handler.forward_from(&service); panic_handler.forward_from(&service);

View File

@ -183,7 +183,6 @@ impl SnapshotCommand {
Ok((service, panic_handler)) Ok((service, panic_handler))
} }
/// restore from a snapshot /// restore from a snapshot
pub fn restore(self) -> Result<(), String> { pub fn restore(self) -> Result<(), String> {
let file = self.file_path.clone(); let file = self.file_path.clone();

View File

@ -56,6 +56,7 @@ pub enum IoMessage<Message> where Message: Send + Clone + Sized {
handler_id: HandlerId, handler_id: HandlerId,
token: TimerToken, token: TimerToken,
delay: u64, delay: u64,
once: bool,
}, },
RemoveTimer { RemoveTimer {
handler_id: HandlerId, handler_id: HandlerId,
@ -92,12 +93,24 @@ impl<Message> IoContext<Message> where Message: Send + Clone + Sync + 'static {
} }
} }
/// Register a new IO timer. 'IoHandler::timeout' will be called with the token. /// Register a new recurring IO timer. 'IoHandler::timeout' will be called with the token.
pub fn register_timer(&self, token: TimerToken, ms: u64) -> Result<(), IoError> { pub fn register_timer(&self, token: TimerToken, ms: u64) -> Result<(), IoError> {
try!(self.channel.send_io(IoMessage::AddTimer { try!(self.channel.send_io(IoMessage::AddTimer {
token: token, token: token,
delay: ms, delay: ms,
handler_id: self.handler, handler_id: self.handler,
once: false,
}));
Ok(())
}
/// Register a new IO timer once. 'IoHandler::timeout' will be called with the token.
pub fn register_timer_once(&self, token: TimerToken, ms: u64) -> Result<(), IoError> {
try!(self.channel.send_io(IoMessage::AddTimer {
token: token,
delay: ms,
handler_id: self.handler,
once: true,
})); }));
Ok(()) Ok(())
} }
@ -163,6 +176,7 @@ impl<Message> IoContext<Message> where Message: Send + Clone + Sync + 'static {
struct UserTimer { struct UserTimer {
delay: u64, delay: u64,
timeout: Timeout, timeout: Timeout,
once: bool,
} }
/// Root IO handler. Manages user handlers, messages and IO timers. /// Root IO handler. Manages user handlers, messages and IO timers.
@ -235,8 +249,14 @@ impl<Message> Handler for IoManager<Message> where Message: Send + Clone + Sync
let handler_index = token.0 / TOKENS_PER_HANDLER; let handler_index = token.0 / TOKENS_PER_HANDLER;
let token_id = token.0 % TOKENS_PER_HANDLER; let token_id = token.0 % TOKENS_PER_HANDLER;
if let Some(handler) = self.handlers.read().get(handler_index) { if let Some(handler) = self.handlers.read().get(handler_index) {
if let Some(timer) = self.timers.read().get(&token.0) { let maybe_timer = self.timers.read().get(&token.0).cloned();
event_loop.timeout(token, Duration::from_millis(timer.delay)).expect("Error re-registering user timer"); if let Some(timer) = maybe_timer {
if timer.once {
self.timers.write().remove(&token_id);
event_loop.clear_timeout(&timer.timeout);
} else {
event_loop.timeout(token, Duration::from_millis(timer.delay)).expect("Error re-registering user timer");
}
self.worker_channel.push(Work { work_type: WorkType::Timeout, token: token_id, handler: handler.clone(), handler_id: handler_index }); self.worker_channel.push(Work { work_type: WorkType::Timeout, token: token_id, handler: handler.clone(), handler_id: handler_index });
self.work_ready.notify_all(); self.work_ready.notify_all();
} }
@ -264,10 +284,10 @@ impl<Message> Handler for IoManager<Message> where Message: Send + Clone + Sync
event_loop.clear_timeout(&timer.timeout); event_loop.clear_timeout(&timer.timeout);
} }
}, },
IoMessage::AddTimer { handler_id, token, delay } => { IoMessage::AddTimer { handler_id, token, delay, once } => {
let timer_id = token + handler_id * TOKENS_PER_HANDLER; let timer_id = token + handler_id * TOKENS_PER_HANDLER;
let timeout = event_loop.timeout(Token(timer_id), Duration::from_millis(delay)).expect("Error registering user timer"); let timeout = event_loop.timeout(Token(timer_id), Duration::from_millis(delay)).expect("Error registering user timer");
self.timers.write().insert(timer_id, UserTimer { delay: delay, timeout: timeout }); self.timers.write().insert(timer_id, UserTimer { delay: delay, timeout: timeout, once: once });
}, },
IoMessage::RemoveTimer { handler_id, token } => { IoMessage::RemoveTimer { handler_id, token } => {
let timer_id = token + handler_id * TOKENS_PER_HANDLER; let timer_id = token + handler_id * TOKENS_PER_HANDLER;