Merge remote-tracking branch 'parity/master' into bft

2016-11-16 10:29:54 +00:00 · 2016-11-16 10:29:54 +00:00 · 8ac989cbeb
parent 1c958695c3 df1fbf50d8
commit 8ac989cbeb
74 changed files with 9310 additions and 7902 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -1249,7 +1249,7 @@ dependencies = [
 [[package]]
 name = "parity-ui-precompiled"
 version = "1.4.0"
-source = "git+https://github.com/ethcore/js-precompiled.git#ce7e830d36483dab10419d9105ac39dc520e7a61"
+source = "git+https://github.com/ethcore/js-precompiled.git#985a6d9cf9aa4621172fcb8e4bf6955f33d5e2a3"
 dependencies = [
 "parity-dapps-glue 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
--- a/ethcore/res/authority_round.json
+++ b/ethcore/res/authority_round.json
@ -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" }
+	}
+}
--- a/ethcore/res/basic_authority.json
+++ b/ethcore/res/basic_authority.json
@ -1,5 +1,5 @@
 {
-	"name": "TestAuthority",
+	"name": "TestBasicAuthority",
 	"engine": {
 		"BasicAuthority": {
 			"params": {
--- a/ethcore/res/ethereum/frontier.json
+++ b/ethcore/res/ethereum/frontier.json
@ -131,10 +131,11 @@
 					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
 				],
 				"eip150Transition": "0x259518",
-				"eip155Transition": "0x7fffffffffffffff",
-				"eip160Transition": "0x7fffffffffffffff",
-				"eip161abcTransition": "0x7fffffffffffffff",
-				"eip161dTransition": "0x7fffffffffffffff"
+				"eip155Transition": 2675000,
+				"eip160Transition": 2675000,
+				"eip161abcTransition": 2675000,
+				"eip161dTransition": 2675000,
+				"maxCodeSize": 24576
 			}
 		}
 	},
--- a/ethcore/res/ethereum/morden.json
+++ b/ethcore/res/ethereum/morden.json
@ -11,10 +11,10 @@
 				"registrar": "0x52dff57a8a1532e6afb3dc07e2af58bb9eb05b3d",
 				"homesteadTransition": "0x789b0",
 				"eip150Transition": "0x1b34d8",
-				"eip155Transition": "0x7fffffffffffffff",
-				"eip160Transition": "0x7fffffffffffffff",
-				"eip161abcTransition": "0x7fffffffffffffff",
-				"eip161dTransition": "0x7fffffffffffffff"
+				"eip155Transition": 1885000,
+				"eip160Transition": 1885000,
+				"eip161abcTransition": 1885000,
+				"eip161dTransition": 1885000
 			}
 		}
 	},
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@ -556,6 +556,7 @@ impl Client {

 	/// Import transactions from the IO queue
 	pub fn import_queued_transactions(&self, transactions: &[Bytes]) -> usize {
+		trace!(target: "external_tx", "Importing queued");
 		let _timer = PerfTimer::new("import_queued_transactions");
 		self.queue_transactions.fetch_sub(transactions.len(), AtomicOrdering::SeqCst);
 		let txs = transactions.iter().filter_map(|bytes| UntrustedRlp::new(bytes).as_val().ok()).collect();
@ -563,6 +564,11 @@ impl Client {
 		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.
 	///
 	/// This will not fail if given BlockID::Latest.
@ -1195,7 +1201,9 @@ impl BlockChainClient for Client {
 	}

 	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());
 		} else {
 			let len = transactions.len();
--- a/ethcore/src/client/test_client.rs
+++ b/ethcore/src/client/test_client.rs
@ -119,6 +119,16 @@ impl TestBlockChainClient {
 	/// Creates new test client with specified extra data for each block
 	pub fn new_with_extra_data(extra_data: Bytes) -> Self {
 		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 {
 			blocks: 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 {
 	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 {
--- a/ethcore/src/engines/authority_round.rs
+++ b/ethcore/src/engines/authority_round.rs
@ -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);
+	}
+}
--- a/ethcore/src/engines/basic_authority.rs
+++ b/ethcore/src/engines/basic_authority.rs
@ -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)]
 mod tests {
 	use util::*;
@ -201,7 +194,7 @@ mod tests {

 	/// Create a new test chain spec with `BasicAuthority` consensus engine.
 	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")
 	}

--- a/ethcore/src/engines/instant_seal.rs
+++ b/ethcore/src/engines/instant_seal.rs
@ -55,7 +55,7 @@ impl Engine for InstantSeal {
 	}

 	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) }
--- a/ethcore/src/engines/mod.rs
+++ b/ethcore/src/engines/mod.rs
@ -19,13 +19,16 @@
 mod null_engine;
 mod instant_seal;
 mod basic_authority;
+mod authority_round;
 mod tendermint;
 mod signed_vote;
 mod propose_collect;

+
 pub use self::null_engine::NullEngine;
 pub use self::instant_seal::InstantSeal;
 pub use self::basic_authority::BasicAuthority;
+pub use self::authority_round::AuthorityRound;
 pub use self::tendermint::Tendermint;
 pub use self::signed_vote::SignedVote;
 pub use self::propose_collect::ProposeCollect;
@ -39,6 +42,8 @@ use env_info::EnvInfo;
 use error::Error;
 use spec::CommonParams;
 use evm::Schedule;
+use io::IoChannel;
+use service::ClientIoMessage;
 use header::Header;
 use transaction::SignedTransaction;
 use ethereum::ethash;
@ -171,6 +176,9 @@ pub trait Engine : Sync + Send {
 		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>) {}
+
 	/// Check if new block should be chosen as the one  in chain.
 	fn is_new_best_block(&self, best_total_difficulty: U256, _best_header: HeaderView, parent_details: &BlockDetails, new_header: &HeaderView) -> bool {
 		ethash::is_new_best_block(best_total_difficulty, parent_details, new_header)
--- a/ethcore/src/engines/tendermint/message.rs
+++ b/ethcore/src/engines/tendermint/message.rs
@ -23,19 +23,19 @@ use rlp::{View, DecoderError, Decodable, Decoder, Encodable, RlpStream, Stream};
 #[derive(Debug, PartialEq, Eq)]
 pub struct ConsensusMessage {
 	pub signature: H520,
-	height: Height,
-	round: Round,
+	pub height: Height,
+	pub round: Round,
 	pub step: Step,
-	block_hash: Option<BlockHash>
+	pub block_hash: Option<BlockHash>
 }

 impl ConsensusMessage {
-	fn is_round(&self, height: Height, round: Round) -> bool {
+	pub fn is_round(&self, height: Height, round: Round) -> bool {
 		self.height == height && self.round == round
 	}

-	fn is_step(&self, height: Height, round: Round, step: Step) -> bool {
-		self.height == height && self.round == round && self.step == step
+	pub fn is_step(&self, height: Height, round: Round, step: &Step) -> bool {
+		self.height == height && self.round == round && &self.step == step
 	}

 	pub fn is_aligned(&self, height: Height, round: Round, block_hash: Option<H256>) -> bool {
--- a/ethcore/src/engines/tendermint/mod.rs
+++ b/ethcore/src/engines/tendermint/mod.rs
@ -73,12 +73,12 @@ pub struct Tendermint {
 	round: AtomicUsize,
 	/// Consensus step.
 	step: RwLock<Step>,
-	/// Current step timeout in ms.
-	timeout: AtomicMs,
 	/// Used to swith proposer.
 	proposer_nonce: AtomicUsize,
 	/// Vote accumulator.
-	votes: VoteCollector
+	votes: VoteCollector,
+	/// Channel for updating the sealing.
+	message_channel: Mutex<Option<IoChannel<ClientIoMessage>>>
 }

 impl Tendermint {
@ -87,7 +87,6 @@ impl Tendermint {
 		let engine = Arc::new(
 			Tendermint {
 				params: params,
-				timeout: AtomicUsize::new(our_params.timeouts.propose),
 				our_params: our_params,
 				builtins: builtins,
 				timeout_service: try!(IoService::<NextStep>::start()),
@ -96,7 +95,8 @@ impl Tendermint {
 				round: AtomicUsize::new(0),
 				step: RwLock::new(Step::Propose),
 				proposer_nonce: AtomicUsize::new(0),
-				votes: VoteCollector::new()
+				votes: VoteCollector::new(),
+				message_channel: Mutex::new(None)
 			});
 		let handler = TimerHandler { engine: Arc::downgrade(&engine) };
 		try!(engine.timeout_service.register_handler(Arc::new(handler)));
@ -116,95 +116,21 @@ impl Tendermint {
 		self.our_params.authorities.contains(address)
 	}

-	fn new_vote(&self, proposal: BlockHash) -> ProposeCollect {
-		ProposeCollect::new(proposal,
-							self.our_params.authorities.iter().cloned().collect(),
-							self.threshold())
-	}
-
-	fn to_step(&self, step: Step) {
-		let mut guard = self.step.try_write().unwrap();
-		*guard = step;
-	}
-
-	fn to_propose(&self) {
-		trace!(target: "poa", "step: entering propose");
-		println!("step: entering propose");
-		self.proposer_nonce.fetch_add(1, AtomicOrdering::Relaxed);
-		self.to_step(Step::Propose);
-	}
-
-	fn propose_message(&self, message: UntrustedRlp) -> Result<Bytes, Error> {
-		// Check if message is for correct step.
-		match *self.step.try_read().unwrap() {
-			Step::Propose => (),
-			_ => try!(Err(EngineError::WrongStep)),
-		}
-		let proposal = try!(message.as_val());
-		self.to_prevote(proposal);
-		Ok(message.as_raw().to_vec())
-	}
-
-	fn to_prevote(&self, proposal: BlockHash) {
-		trace!(target: "poa", "step: entering prevote");
-		println!("step: entering prevote");
-		// Proceed to the prevote step.
-		self.to_step(Step::Prevote(self.new_vote(proposal)));
-	}
-
-	fn prevote_message(&self, sender: Address, message: UntrustedRlp) -> Result<Bytes, Error> {
-		// Check if message is for correct step.
-		let hash = match *self.step.try_write().unwrap() {
-			Step::Prevote => {
-				// Vote if message is about the right block.
-				if vote.hash == try!(message.as_val()) {
-					vote.vote(sender);
-					// Move to next step is prevote is won.
-					if vote.is_won() {
-						// If won assign a hash used for precommit.
-						vote.hash.clone()
-					} else {
-						// Just propoagate the message if not won yet.
-						return Ok(message.as_raw().to_vec());
-					}
-				} else {
-					try!(Err(EngineError::WrongVote))
-				}
-			},
-			_ => try!(Err(EngineError::WrongStep)),
-		};
-		self.to_precommit(hash);
-		Ok(message.as_raw().to_vec())
-	}
-
-	fn to_precommit(&self, proposal: BlockHash) {
-		trace!(target: "poa", "step: entering precommit");
-		println!("step: entering precommit");
-		self.to_step(Step::Precommit(self.new_vote(proposal), Vec::new()));
-	}
-
-	/// Move to commit step, when valid block is known and being distributed.
-	pub fn to_commit(&self, block_hash: H256, seal: Vec<Bytes>) {
-		trace!(target: "poa", "step: entering commit");
-		println!("step: entering commit");
-		self.to_step(Step::Commit(block_hash, seal));
-	}
-
 	fn threshold(&self) -> usize {
 		self.our_params.authority_n * 2/3
 	}

-	fn next_timeout(&self) -> u64 {
-		self.timeout.load(AtomicOrdering::Relaxed) as u64
-	}
-
 	/// Round proposer switching.
 	fn is_proposer(&self, address: &Address) -> bool {
 		self.is_nonce_proposer(self.proposer_nonce.load(AtomicOrdering::SeqCst), address)
 	}

 	fn is_current(&self, message: &ConsensusMessage) -> bool {
-		message.is_step(self.height.load(AtomicOrdering::SeqCst), self.round.load(AtomicOrdering::SeqCst), self.step.load(AtomicOrdering::SeqCst)) 
+		message.is_step(self.height.load(AtomicOrdering::SeqCst), self.round.load(AtomicOrdering::SeqCst), &self.step.read()) 
+	}
+
+	fn has_enough_any_votes(&self) -> bool {
+		self.votes.count_step_votes(self.height.load(AtomicOrdering::SeqCst), self.round.load(AtomicOrdering::SeqCst), &self.step.read()) > self.threshold()	
 	}
 }

@ -213,12 +139,12 @@ fn block_hash(header: &Header) -> H256 {
 	header.rlp(Seal::WithSome(1)).sha3()
 }

-fn proposer_signature(header: &Header) -> H520 {
-	try!(UntrustedRlp::new(header.seal()[1].as_slice()).as_val())
+fn proposer_signature(header: &Header) -> Result<H520, ::rlp::DecoderError> {
+	UntrustedRlp::new(header.seal()[1].as_slice()).as_val()
 }

-fn consensus_round(header: &Header) -> Round {
-	try!(UntrustedRlp::new(header.seal()[0].as_slice()).as_val())
+fn consensus_round(header: &Header) -> Result<Round, ::rlp::DecoderError> {
+	UntrustedRlp::new(header.seal()[0].as_slice()).as_val()
 }

 impl Engine for Tendermint {
@ -233,10 +159,10 @@ impl Engine for Tendermint {
 	/// Additional engine-specific information for the user/developer concerning `header`.
 	fn extra_info(&self, header: &Header) -> BTreeMap<String, String> {
 		map![
-			"signature".into() => proposer_signature(header).to_string(),
+			"signature".into() => proposer_signature(header).as_ref().map(ToString::to_string).unwrap_or("".into()),
 			"height".into() => header.number().to_string(),
-			"round".into() => consensus_round(header).to_string(),
-			"block_hash".into() => block_hash(header).to_string().unwrap_or("".into())
+			"round".into() => consensus_round(header).as_ref().map(ToString::to_string).unwrap_or("".into()),
+			"block_hash".into() => block_hash(header).to_string()
 		]
 	}

@ -326,10 +252,10 @@ impl Engine for Tendermint {
 		}

 		// Check if the message affects the current step.
-		if self.is_current(message) {
-				match self.step.load(AtomicOrdering::SeqCst) {
+		if self.is_current(&message) {
+				match *self.step.read() {
 					Step::Prevote => {
-						let votes = aligned_signatures(message);
+						let votes = self.votes.aligned_signatures(&message);
 						if votes.len() > self.threshold() {
 						}
 					},
@ -352,14 +278,15 @@ impl Engine for Tendermint {

 	/// Also transitions to Prevote if verifying Proposal.
 	fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
-		let proposer = public_to_address(&try!(recover(&proposal_signature(header).into(), &block_hash(header))));
+		let signature = try!(proposer_signature(header));
+		let proposer = public_to_address(&try!(recover(&signature.into(), &block_hash(header))));
 		if !self.is_proposer(&proposer) {
 			try!(Err(BlockError::InvalidSeal))
 		}
 		let proposal = ConsensusMessage {
-			signature: proposal_signature,
+			signature: signature,
 			height: header.number() as Height,
-			round: consensus_round(header),
+			round: try!(consensus_round(header)),
 			step: Step::Propose,
 			block_hash: Some(block_hash(header))
 		};
@ -368,7 +295,7 @@ impl Engine for Tendermint {
 		for rlp in votes_rlp.iter() {
 			let sig: H520 = try!(rlp.as_val());
 			let address = public_to_address(&try!(recover(&sig.into(), &block_hash(header))));
-			if !self.our_params.authorities.contains(a) {
+			if !self.our_params.authorities.contains(&address) {
 				try!(Err(BlockError::InvalidSeal))
 			}
 		}
@ -408,6 +335,11 @@ impl Engine for Tendermint {
 		let best_signatures = best_header.seal().get(2).expect("Tendermint seal should have three elements.").len();
 		new_signatures > best_signatures
 	}
+
+	fn register_message_channel(&self, message_channel: IoChannel<ClientIoMessage>) {
+		let mut guard = self.message_channel.lock();
+		*guard = Some(message_channel);
+	}
 }

 #[cfg(test)]
--- a/ethcore/src/engines/tendermint/params.rs
+++ b/ethcore/src/engines/tendermint/params.rs
@ -19,6 +19,7 @@
 use ethjson;
 use super::timeout::TendermintTimeouts;
 use util::{Address, U256};
+use time::Duration;

 /// `Tendermint` params.
 #[derive(Debug, Clone)]
@ -41,25 +42,30 @@ impl Default for TendermintParams {
 			gas_limit_bound_divisor: 0x0400.into(),
 			authorities: authorities,
 			authority_n: val_n,
-			timeouts:  DefaultTimeouts::default()
+			timeouts: TendermintTimeouts::default()
 		}
 	}
 }

+fn to_duration(ms: ethjson::uint::Uint) -> Duration {
+	let ms: usize = ms.into();
+	Duration::milliseconds(ms as i64)
+}
+
 impl From<ethjson::spec::TendermintParams> for TendermintParams {
 	fn from(p: ethjson::spec::TendermintParams) -> Self {
 		let val: Vec<_> = p.authorities.into_iter().map(Into::into).collect();
 		let val_n = val.len();
+		let dt = TendermintTimeouts::default();
 		TendermintParams {
 			gas_limit_bound_divisor: p.gas_limit_bound_divisor.into(),
 			authorities: val,
 			authority_n: val_n,
-			let dt = TendermintTimeouts::default();
 			timeouts: TendermintTimeouts {
-				propose: p.timeout_propose.unwrap_or(dt.propose),
-				prevote: p.timeout_prevote.unwrap_or(dt.prevote),
-				precommit: p.timeout_precommit.unwrap_or(dt.precommit),
-				commit: p.timeout_commit.unwrap_or(dt.commit)
+				propose: p.timeout_propose.map_or(dt.propose, to_duration),
+				prevote: p.timeout_prevote.map_or(dt.prevote, to_duration),
+				precommit: p.timeout_precommit.map_or(dt.precommit, to_duration),
+				commit: p.timeout_commit.map_or(dt.commit, to_duration)
 			}
 		}
 	}
--- a/ethcore/src/engines/tendermint/timeout.rs
+++ b/ethcore/src/engines/tendermint/timeout.rs
@ -30,14 +30,14 @@ pub struct TimerHandler {
 /// Base timeout of each step in ms.
 #[derive(Debug, Clone)]
 pub struct TendermintTimeouts {
-	propose: Duration,
-	prevote: Duartion,
-	precommit: Duration,
-	commit: Duration
+	pub propose: Duration,
+	pub prevote: Duration,
+	pub precommit: Duration,
+	pub commit: Duration
 }

 impl TendermintTimeouts {
-	pub fn for_step(step: Step) -> Duration {
+	pub fn for_step(&self, step: Step) -> Duration {
 		match step {
 			Step::Propose => self.propose,
 			Step::Prevote => self.prevote,
@ -49,7 +49,7 @@ impl TendermintTimeouts {

 impl Default for TendermintTimeouts {
 	fn default() -> Self {
-		DefaultTimeouts {
+		TendermintTimeouts {
 			propose: Duration::milliseconds(1000),
 			prevote: Duration::milliseconds(1000),
 			precommit: Duration::milliseconds(1000),
@ -64,38 +64,55 @@ pub struct NextStep;
 /// Timer token representing the consensus step timeouts.
 pub const ENGINE_TIMEOUT_TOKEN: TimerToken = 23;

+fn set_timeout(io: &IoContext<NextStep>, timeout: Duration) {
+	io.register_timer_once(ENGINE_TIMEOUT_TOKEN, timeout.num_milliseconds() as u64)
+		.unwrap_or_else(|e| warn!(target: "poa", "Failed to set consensus step timeout: {}.", e))
+}
+
+fn update_sealing(io_channel: Mutex<Option<IoChannel<ClientIoMessage>>>) {
+	if let Some(ref channel) = *io_channel.lock() {
+		match channel.send(ClientIoMessage::UpdateSealing) {
+			Ok(_) => trace!(target: "poa", "timeout: UpdateSealing message sent for round {}.", engine.round.load(AtomicOrdering::SeqCst)),
+			Err(err) => trace!(target: "poa", "timeout: Could not send a sealing message {} for round {}.", err, engine.round.load(AtomicOrdering::SeqCst)),
+		}
+	}
+}
+
 impl IoHandler<NextStep> for TimerHandler {
 	fn initialize(&self, io: &IoContext<NextStep>) {
 		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))
+			set_timeout(io, engine.our_params.timeouts.propose)
 		}
 	}

 	fn timeout(&self, io: &IoContext<NextStep>, 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);
-				let next_step = match *engine.step.try_read().unwrap() {
-					Step::Propose => Step::Prevote,
-					Step::Prevote => Step::Precommit,
-					Step::Precommit => Step::Propose,
-					Step::Commit => {
-						engine.round.fetch_add(1, AtomicOrdering::Relaxed);
-						Step::Propose
+				let next_step = match *engine.step.read() {
+					Step::Propose => {
+						set_timeout(io, engine.our_params.timeouts.prevote);
+						Some(Step::Prevote)
 					},
+					Step::Prevote if engine.has_enough_any_votes() => {
+						set_timeout(io, engine.our_params.timeouts.precommit);
+						Some(Step::Precommit)
+					},
+					Step::Precommit if engine.has_enough_any_votes() => {
+						set_timeout(io, engine.our_params.timeouts.propose);
+						engine.round.fetch_add(1, AtomicOrdering::SeqCst);
+						Some(Step::Propose)
+					},
+					Step::Commit => {
+						set_timeout(io, engine.our_params.timeouts.propose);
+						engine.round.store(0, AtomicOrdering::SeqCst);
+						engine.height.fetch_add(1, AtomicOrdering::SeqCst);
+						Some(Step::Propose)
+					},
+					_ => None,
 				};

-
-				io.register_timer_once(ENGINE_TIMEOUT_TOKEN, engine.next_timeout().as_millis())
-					.unwrap_or_else(|e| warn!(target: "poa", "Failed to restart consensus step timer: {}.", e))
-
-				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.),
-						Err(err) => trace!(target: "poa", "timeout: Could not send a sealing message {} for step {}.", err, engine.step.load(AtomicOrdering::Relaxed)),
-					}
+				if let Some(step) = next_step {
+					*engine.step.write() = step
 				}

 			}
--- a/ethcore/src/engines/tendermint/vote_collector.rs
+++ b/ethcore/src/engines/tendermint/vote_collector.rs
@ -33,9 +33,7 @@ impl VoteCollector {
 	}

 	pub fn vote(&self, message: ConsensusMessage, voter: Address) {
-		if let Some(mut guard) = self.votes.write() {
-			*guard.insert(message, voter);
-		}
+		self.votes.write().insert(message, voter);
 	}

 	pub fn seal_signatures(&self, height: Height, round: Round, block_hash: Option<H256>) -> Vec<H520> {
@ -52,13 +50,11 @@ impl VoteCollector {
 		self.seal_signatures(message.height, message.round, message.block_hash)
 	}

-	pub fn count_signatures(&self, height: Height, round: Round) -> usize {
+	pub fn count_step_votes(&self, height: Height, round: Round, step: &Step) -> usize {
 		self.votes
 			.read()
 			.keys()
-			// Get only Propose and Precommits.
-			.filter(|m| m.is_round(height, round) && m.step != Step::Prevote)
-			.map(|m| m.signature)
-			.collect()	
+			.filter(|m| m.is_step(height, round, step))
+			.count()	
 	}
 }
--- a/ethcore/src/error.rs
+++ b/ethcore/src/error.rs
@ -168,6 +168,8 @@ pub enum BlockError {
 	UnknownParent(H256),
 	/// Uncle parent given is unknown.
 	UnknownUncleParent(H256),
+	/// The same author issued different votes at the same step.
+	DoubleVote(H160),
 }

 impl fmt::Display for BlockError {
@ -201,6 +203,7 @@ impl fmt::Display for BlockError {
 			RidiculousNumber(ref oob) => format!("Implausible block number. {}", oob),
 			UnknownParent(ref hash) => format!("Unknown 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))
--- a/ethcore/src/ethereum/ethash.rs
+++ b/ethcore/src/ethereum/ethash.rs
@ -75,7 +75,9 @@ pub struct EthashParams {
 	/// Number of first block where ECIP-1010 begins.
 	pub ecip1010_pause_transition: u64,
 	/// 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 {
@ -89,19 +91,20 @@ impl From<ethjson::spec::EthashParams> for EthashParams {
 			block_reward: p.block_reward.into(),
 			registrar: p.registrar.map_or_else(Address::new, 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_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),
-			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),
 			eip155_transition: p.eip155_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),
-			eip161d_transition: p.eip161d_transition.map_or(0x7fffffffffffffff, Into::into),
-			ecip1010_pause_transition: p.ecip1010_pause_transition.map_or(0x7fffffffffffffff, Into::into),
-			ecip1010_continue_transition: p.ecip1010_continue_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(u64::max_value(), 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),
 		}
 	}
 }
@ -154,6 +157,7 @@ impl Engine for Ethash {
 			Schedule::new_homestead()
 		} else {
 			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.eip161abc_transition,
 				env_info.number >= self.ethash_params.eip161d_transition
--- a/ethcore/src/evm/schedule.rs
+++ b/ethcore/src/evm/schedule.rs
@ -70,6 +70,8 @@ pub struct Schedule {
 	pub quad_coeff_div: usize,
 	/// Cost for contract length when executing `CREATE`
 	pub create_data_gas: usize,
+	/// Maximum code size when creating a contract.
+	pub create_data_limit: usize,
 	/// Transaction cost
 	pub tx_gas: usize,
 	/// `CREATE` transaction cost
@ -111,7 +113,7 @@ impl Schedule {
 	}

 	/// 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 {
 			exceptional_failed_code_deposit: true,
 			have_delegate_call: true,
@ -139,6 +141,7 @@ impl Schedule {
 			memory_gas: 3,
 			quad_coeff_div: 512,
 			create_data_gas: 200,
+			create_data_limit: max_code_size,
 			tx_gas: 21000,
 			tx_create_gas: 53000,
 			tx_data_zero_gas: 4,
@ -183,6 +186,7 @@ impl Schedule {
 			memory_gas: 3,
 			quad_coeff_div: 512,
 			create_data_gas: 200,
+			create_data_limit: usize::max_value(),
 			tx_gas: 21000,
 			tx_create_gas: tcg,
 			tx_data_zero_gas: 4,
--- a/ethcore/src/externalities.rs
+++ b/ethcore/src/externalities.rs
@ -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) => {
 				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 {
 						true => Err(evm::Error::OutOfGas),
 						false => Ok(*gas)
--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@ -212,7 +212,8 @@ pub struct Miner {
 	sealing_block_last_request: Mutex<u64>,
 	// for sealing...
 	options: MinerOptions,
-	seals_internally: bool,
+	/// Does the node perform internal (without work) sealing.
+	pub seals_internally: bool,

 	gas_range_target: RwLock<(U256, U256)>,
 	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.
 	pub fn with_spec(spec: &Spec) -> Miner {
 		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 should_disable_sealing = !self.forced_sealing()
 				&& !has_local_transactions
+				&& !self.seals_internally
 				&& best_block > last_request
 				&& 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.
 	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 chain.import_block(sealed.rlp_bytes()).is_ok() {
+					trace!(target: "miner", "import_block_internally: imported internally sealed block");
 					return true
 				}
 			}
@ -773,7 +781,7 @@ impl MinerService for Miner {
 		chain: &MiningBlockChainClient,
 		transactions: Vec<SignedTransaction>
 	) -> Vec<Result<TransactionImportResult, Error>> {
-
+		trace!(target: "external_tx", "Importing external transactions");
 		let results = {
 			let mut transaction_queue = self.transaction_queue.lock();
 			self.add_transactions_to_queue(
--- a/ethcore/src/service.rs
+++ b/ethcore/src/service.rs
@ -48,6 +48,8 @@ pub enum ClientIoMessage {
 	FeedBlockChunk(H256, Bytes),
 	/// Take a snapshot for the block with given number.
 	TakeSnapshot(u64),
+	/// Trigger sealing update (useful for internal sealing).
+	UpdateSealing,
 }

 /// 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));

+		spec.engine.register_message_channel(io_service.channel());
+
 		let stop_guard = ::devtools::StopGuard::new();
 		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 {
 					debug!(target: "snapshot", "Failed to initialize periodic snapshot thread: {:?}", e);
 				}
-
-			}
+			},
+			ClientIoMessage::UpdateSealing => {
+				trace!(target: "authorityround", "message: UpdateSealing");
+				self.client.update_sealing()
+			},
 			_ => {} // ignore other messages
 		}
 	}
--- a/ethcore/src/spec/spec.rs
+++ b/ethcore/src/spec/spec.rs
@ -18,7 +18,7 @@

 use util::*;
 use builtin::Builtin;
-use engines::{Engine, NullEngine, InstantSeal, BasicAuthority, Tendermint};
+use engines::{Engine, NullEngine, InstantSeal, BasicAuthority, AuthorityRound, Tendermint};
 use pod_state::*;
 use account_db::*;
 use header::{BlockNumber, Header};
@ -150,6 +150,7 @@ impl Spec {
 			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::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("Failed to start AuthorityRound consensus engine."),
 			ethjson::spec::Engine::Tendermint(tendermint) => Tendermint::new(params, From::from(tendermint.params), builtins).expect("Failed to start the Tendermint consensus engine."),
 		}
 	}
@ -282,6 +283,10 @@ impl Spec {
 	/// Create a new Spec with InstantSeal consensus which does internal sealing (not requiring work).
 	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") }
+
 	/// Create a new Spec with Tendermint consensus which does internal sealing (not requiring work).
 	/// Account "0".sha3() and "1".sha3() are a authorities.
 	pub fn new_test_tendermint() -> Self { load_bundled!("tendermint") }
--- a/ethcore/src/tests/helpers.rs
+++ b/ethcore/src/tests/helpers.rs
@ -433,18 +433,19 @@ pub fn get_default_ethash_params() -> EthashParams{
 		block_reward: U256::from(0),
 		registrar: "0000000000000000000000000000000000000001".into(),
 		homestead_transition: 1150000,
-		dao_hardfork_transition: 0x7fffffffffffffff,
+		dao_hardfork_transition: u64::max_value(),
 		dao_hardfork_beneficiary: "0000000000000000000000000000000000000001".into(),
 		dao_hardfork_accounts: vec![],
-		difficulty_hardfork_transition: 0x7fffffffffffffff,
+		difficulty_hardfork_transition: u64::max_value(),
 		difficulty_hardfork_bound_divisor: U256::from(0),
-		bomb_defuse_transition: 0x7fffffffffffffff,
-		eip150_transition: 0x7fffffffffffffff,
-		eip155_transition: 0x7fffffffffffffff,
-		eip160_transition: 0x7fffffffffffffff,
-		eip161abc_transition: 0x7fffffffffffffff,
-		eip161d_transition: 0x7fffffffffffffff,
-		ecip1010_pause_transition: 0x7fffffffffffffff,
-		ecip1010_continue_transition: 0x7fffffffffffffff
+		bomb_defuse_transition: u64::max_value(),
+		eip150_transition: u64::max_value(),
+		eip155_transition: u64::max_value(),
+		eip160_transition: u64::max_value(),
+		eip161abc_transition: u64::max_value(),
+		eip161d_transition: u64::max_value(),
+		ecip1010_pause_transition: u64::max_value(),
+		ecip1010_continue_transition: u64::max_value(),
+		max_code_size: u64::max_value(),
 	}
 }
--- a/ethstore/res/wordlist.txt
+++ b/ethstore/res/wordlist.txt
--- a/js/package.json
+++ b/js/package.json
@ -1,6 +1,6 @@
 {
  "name": "parity.js",
-  "version": "0.2.43",
+  "version": "0.2.48",
  "main": "release/index.js",
  "jsnext:main": "src/index.js",
  "author": "Parity Team <admin@parity.io>",
--- a/js/src/abi/util/pad.js
+++ b/js/src/abi/util/pad.js
@ -46,7 +46,8 @@ function stringToBytes (input) {
  if (isArray(input)) {
    return input;
  } else if (input.substr(0, 2) === '0x') {
-    return input.substr(2).toLowerCase().match(/.{1,2}/g).map((value) => parseInt(value, 16));
+    const matches = input.substr(2).toLowerCase().match(/.{1,2}/g) || [];
+    return matches.map((value) => parseInt(value, 16));
  } else {
    return input.split('').map((char) => char.charCodeAt(0));
  }
--- a/js/src/api/contract/contract.js
+++ b/js/src/api/contract/contract.js
@ -40,9 +40,12 @@ export default class Contract {

    this._events.forEach((evt) => {
      this._instance[evt.name] = evt;
+      this._instance[evt.signature] = evt;
    });
+
    this._functions.forEach((fn) => {
      this._instance[fn.name] = fn;
+      this._instance[fn.signature] = fn;
    });

    this._sendSubscriptionChanges();
--- a/js/src/api/contract/contract.spec.js
+++ b/js/src/api/contract/contract.spec.js
@ -20,6 +20,7 @@ import sinon from 'sinon';
 import { TEST_HTTP_URL, mockHttp } from '../../../test/mockRpc';

 import Abi from '../../abi';
+import { sha3 } from '../util/sha3';

 import Api from '../api';
 import Contract from './contract';
@ -113,7 +114,13 @@ describe('api/contract/Contract', () => {
      ]);
      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');
    });
  });
--- a/js/src/dapps/basiccoin/Deploy/Event/event.css
+++ b/js/src/dapps/basiccoin/Deploy/Event/event.css
@ -46,11 +46,22 @@ a.link, a.link:hover, a.link:visited {
 }

 .address {
+  max-width: 250px;
  text-align: left;
+
+  div {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
 }

 .description {
  text-align: left;
+
+  div {
+    white-space: nowrap;
+  }
 }

 .center {
--- a/js/src/dapps/basiccoin/Deploy/Event/event.js
+++ b/js/src/dapps/basiccoin/Deploy/Event/event.js
@ -58,6 +58,7 @@ export default class Event extends Component {
        <td className={ styles.description }>
          <div>{ isPending ? '' : coin.tla }</div>
          <div>{ isPending ? '' : coin.name }</div>
+          <div>{ this.renderAddress(event.params.coin) }</div>
        </td>
        <td className={ styles.address }>
          { this.renderAddress(event.params.owner) }
--- a/js/src/dapps/basiccoin/Overview/Owner/owner.css
+++ b/js/src/dapps/basiccoin/Overview/Owner/owner.css
@ -46,3 +46,9 @@
 .icon {
  margin: 0 0 -4px 1em;
 }
+
+.byline {
+  opacity: 0.75;
+  font-size: 0.75em;
+  padding-top: 0.25em;
+}
--- a/js/src/dapps/basiccoin/Overview/Owner/owner.js
+++ b/js/src/dapps/basiccoin/Overview/Owner/owner.js
@ -68,6 +68,9 @@ export default class Owner extends Component {
        <Token
          address={ token.address }
          tokenreg={ token.tokenreg } />
+        <div className={ styles.byline }>
+          { token.address }
+        </div>
      </div>
    ));
  }
--- a/js/src/dapps/tokenreg/Status/reducer.js
+++ b/js/src/dapps/tokenreg/Status/reducer.js
@ -25,7 +25,7 @@ const initialState = {
  isLoading: true,
  subscriptionId: null,
  contract: {
-    addres: null,
+    address: null,
    instance: null,
    raw: null,
    owner: null,
--- a/js/src/dapps/tokenreg/Tokens/actions.js
+++ b/js/src/dapps/tokenreg/Tokens/actions.js
@ -239,22 +239,22 @@ export const addGithubhintURL = (from, key, url) => (dispatch, getState) => {
 export const unregisterToken = (index) => (dispatch, getState) => {
  console.log('unregistering token', index);

-  const state = getState();
-  const contractInstance = state.status.contract.instance;
+  const { contract } = getState().status;
+  const { instance, owner } = contract;

  const values = [ index ];
  const options = {
-    from: state.accounts.selected.address
+    from: owner
  };

-  contractInstance
+  instance
    .unregister
    .estimateGas(options, values)
    .then((gasEstimate) => {
      options.gas = gasEstimate.mul(1.2).toFixed(0);
      console.log(`transfer: gas estimated as ${gasEstimate.toFixed(0)} setting to ${options.gas}`);

-      return contractInstance.unregister.postTransaction(options, values);
+      return instance.unregister.postTransaction(options, values);
    })
    .catch((e) => {
      console.error(`unregisterToken #${index} error`, e);
--- a/js/src/modals/AddContract/addContract.js
+++ b/js/src/modals/AddContract/addContract.js
@ -227,6 +227,7 @@ export default class AddContract extends Component {
  onEditAbi = (abiIn) => {
    const { api } = this.context;
    const { abi, abiError, abiParsed } = validateAbi(abiIn, api);
+
    this.setState({ abi, abiError, abiParsed });
  }

--- a/js/src/modals/DeployContract/DetailsStep/detailsStep.js
+++ b/js/src/modals/DeployContract/DetailsStep/detailsStep.js
@ -15,10 +15,10 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 import React, { Component, PropTypes } from 'react';
-import { MenuItem } from 'material-ui';

-import { AddressSelect, Form, Input, InputAddressSelect, Select } from '../../../ui';
+import { AddressSelect, Form, Input, TypedInput } from '../../../ui';
 import { validateAbi } from '../../../util/validation';
+import { parseAbiType } from '../../../util/abi';

 import styles from '../deployContract.css';

@ -103,6 +103,7 @@ export default class DetailsStep extends Component {
          value={ code }
          onSubmit={ this.onCodeChange }
          readOnly={ readOnly } />
+
        { this.renderConstructorInputs() }
      </Form>
    );
@ -117,59 +118,23 @@ export default class DetailsStep extends Component {
    }

    return inputs.map((input, index) => {
-      const onChange = (event, value) => this.onParamChange(index, value);
-      const onChangeBool = (event, _index, value) => this.onParamChange(index, value === 'true');
-      const onSubmit = (value) => this.onParamChange(index, value);
-      const label = `${input.name}: ${input.type}`;
-      let inputBox = null;
+      const onChange = (value) => this.onParamChange(index, value);

-      switch (input.type) {
-        case 'address':
-          inputBox = (
-            <InputAddressSelect
-              accounts={ accounts }
-              editing
-              label={ label }
-              value={ params[index] }
-              error={ paramsError[index] }
-              onChange={ onChange } />
-          );
-          break;
-
-        case 'bool':
-          const boolitems = ['false', 'true'].map((bool) => {
-            return (
-              <MenuItem
-                key={ bool }
-                value={ bool }
-                label={ bool }>{ bool }</MenuItem>
-            );
-          });
-          inputBox = (
-            <Select
-              label={ label }
-              value={ params[index] ? 'true' : 'false' }
-              error={ paramsError[index] }
-              onChange={ onChangeBool }>
-              { boolitems }
-            </Select>
-          );
-          break;
-
-        default:
-          inputBox = (
-            <Input
-              label={ label }
-              value={ params[index] }
-              error={ paramsError[index] }
-              onSubmit={ onSubmit } />
-            );
-          break;
-      }
+      const label = `${input.name ? `${input.name}: ` : ''}${input.type}`;
+      const value = params[index];
+      const error = paramsError[index];
+      const param = parseAbiType(input.type);

      return (
        <div key={ index } className={ styles.funcparams }>
-          { inputBox }
+          <TypedInput
+            label={ label }
+            value={ value }
+            error={ error }
+            accounts={ accounts }
+            onChange={ onChange }
+            param={ param }
+          />
        </div>
      );
    });
@ -200,35 +165,14 @@ export default class DetailsStep extends Component {
    const { abiError, abiParsed } = validateAbi(abi, api);

    if (!abiError) {
-      const { inputs } = abiParsed.find((method) => method.type === 'constructor') || { inputs: [] };
+      const { inputs } = abiParsed
+        .find((method) => method.type === 'constructor') || { inputs: [] };
+
      const params = [];

      inputs.forEach((input) => {
-        switch (input.type) {
-          case 'address':
-            params.push('0x');
-            break;
-
-          case 'bool':
-            params.push(false);
-            break;
-
-          case 'bytes':
-            params.push('0x');
-            break;
-
-          case 'uint':
-            params.push('0');
-            break;
-
-          case 'string':
-            params.push('');
-            break;
-
-          default:
-            params.push('0');
-            break;
-        }
+        const param = parseAbiType(input.type);
+        params.push(param.default);
      });

      onParamsChange(params);
--- a/js/src/modals/DeployContract/deployContract.js
+++ b/js/src/modals/DeployContract/deployContract.js
@ -101,7 +101,8 @@ export default class DeployContract extends Component {
        steps={ deployError ? null : steps }
        title={ deployError ? 'deployment failed' : null }
        waiting={ [1] }
-        visible>
+        visible
+        scroll>
        { this.renderStep() }
      </Modal>
    );
@ -118,8 +119,22 @@ export default class DeployContract extends Component {
        onClick={ this.onClose } />
    );

+    const closeBtn = (
+      <Button
+        icon={ <ContentClear /> }
+        label='Close'
+        onClick={ this.onClose } />
+    );
+
+    const closeBtnOk = (
+      <Button
+        icon={ <ActionDoneAll /> }
+        label='Close'
+        onClick={ this.onClose } />
+    );
+
    if (deployError) {
-      return cancelBtn;
+      return closeBtn;
    }

    switch (step) {
@ -134,17 +149,10 @@ export default class DeployContract extends Component {
        ];

      case 1:
-        return [
-          cancelBtn
-        ];
+        return [ closeBtn ];

      case 2:
-        return [
-          <Button
-            icon={ <ActionDoneAll /> }
-            label='Close'
-            onClick={ this.onClose } />
-        ];
+        return [ closeBtnOk ];
    }
  }

@ -277,8 +285,6 @@ export default class DeployContract extends Component {
      return;
    }

-    console.log('onDeploymentState', data);
-
    switch (data.state) {
      case 'estimateGas':
      case 'postTransaction':
--- a/js/src/modals/Transfer/transfer.js
+++ b/js/src/modals/Transfer/transfer.js
@ -314,7 +314,7 @@ export default class Transfer extends Component {
    }

    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) {
      return ERRORS.invalidDecimals;
@ -516,6 +516,13 @@ export default class Transfer extends Component {
  }

  recalculateGas = () => {
+    if (!this.isValid()) {
+      this.setState({
+        gas: '0'
+      }, this.recalculate);
+      return;
+    }
+
    (this.state.isEth
      ? this._estimateGasEth()
      : this._estimateGasToken()
--- a/js/src/ui/Actionbar/Export/export.js
+++ b/js/src/ui/Actionbar/Export/export.js
@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 import React, { Component, PropTypes } from 'react';
+
 import FileSaver from 'file-saver';
 import FileDownloadIcon from 'material-ui/svg-icons/file/file-download';

@ -38,19 +39,18 @@ class ActionbarExport extends Component {
        className={ className }
        icon={ <FileDownloadIcon /> }
        label='export'
-        onClick={ this.onDownloadBackup } />
+        onClick={ this.handleExport }
+      />
    );
  }

-  onDownloadBackup = () => {
+  handleExport = () => {
    const { filename, content } = this.props;

-    const text = (typeof content === 'string')
-      ? content
-      : JSON.stringify(content, null, 4);
+    const text = JSON.stringify(content, null, 4);

-    const blob = new Blob([ text ], { type: 'text/plain;charset=utf-8' });
-    FileSaver.saveAs(blob, filename);
+    const blob = new Blob([ text ], { type: 'application/json' });
+    FileSaver.saveAs(blob, `${filename}.json`);
  }
 }

--- a/js/src/ui/Actionbar/Sort/sort.js
+++ b/js/src/ui/Actionbar/Sort/sort.js
@ -15,6 +15,8 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 import React, { Component, PropTypes } from 'react';
+import { observer } from 'mobx-react';
+
 import IconMenu from 'material-ui/IconMenu';
 import MenuItem from 'material-ui/MenuItem';

@ -22,11 +24,15 @@ import SortIcon from 'material-ui/svg-icons/content/sort';

 import { Button } from '../../';

+import SortStore from './sortStore';
 import styles from './sort.css';

+@observer
 export default class ActionbarSort extends Component {
  static propTypes = {
+    id: PropTypes.string.isRequired,
    onChange: PropTypes.func.isRequired,
+
    order: PropTypes.string,
    showDefault: PropTypes.bool,
    metas: PropTypes.array
@ -37,8 +43,10 @@ export default class ActionbarSort extends Component {
    showDefault: true
  }

-  state = {
-    menuOpen: false
+  store = new SortStore(this.props);
+
+  componentDidMount () {
+    this.store.restoreSavedOrder();
  }

  render () {
@ -51,12 +59,12 @@ export default class ActionbarSort extends Component {
            className={ styles.sortButton }
            label=''
            icon={ <SortIcon /> }
-            onClick={ this.handleMenuOpen }
+            onClick={ this.store.handleMenuOpen }
            />
        }
-        open={ this.state.menuOpen }
-        onRequestChange={ this.handleMenuChange }
-        onItemTouchTap={ this.handleSortChange }
+        open={ this.store.menuOpen }
+        onRequestChange={ this.store.handleMenuChange }
+        onItemTouchTap={ this.store.handleSortChange }
        targetOrigin={ { horizontal: 'right', vertical: 'top' } }
        anchorOrigin={ { horizontal: 'right', vertical: 'top' } }
        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 });
-  }
 }
--- a/js/src/ui/Actionbar/Sort/sortStore.js
+++ b/js/src/ui/Actionbar/Sort/sortStore.js
@ -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);
+  }
+}
--- a/js/src/ui/Form/AddressSelect/addressSelect.css
+++ b/js/src/ui/Form/AddressSelect/addressSelect.css
@ -39,6 +39,10 @@
  position: absolute;
  left: 0;
  top: 35px;
+
+  &.noLabel {
+    top: 11px;
+  }
 }

 .paddedInput input {
--- a/js/src/ui/Form/AddressSelect/addressSelect.js
+++ b/js/src/ui/Form/AddressSelect/addressSelect.js
@ -106,15 +106,21 @@ export default class AddressSelect extends Component {
  }

  renderIdentityIcon (inputValue) {
-    const { error, value } = this.props;
+    const { error, value, label } = this.props;

    if (error || !inputValue || value.length !== 42) {
      return null;
    }

+    const classes = [ styles.icon ];
+
+    if (!label) {
+      classes.push(styles.noLabel);
+    }
+
    return (
      <IdentityIcon
-        className={ styles.icon }
+        className={ classes.join(' ') }
        inline center
        address={ value } />
    );
--- a/js/src/ui/Form/Input/input.js
+++ b/js/src/ui/Form/Input/input.js
@ -16,6 +16,7 @@

 import React, { Component, PropTypes } from 'react';
 import { TextField } from 'material-ui';
+import { noop } from 'lodash';

 import CopyToClipboard from '../../CopyToClipboard';

@ -63,7 +64,9 @@ export default class Input extends Component {
    hideUnderline: PropTypes.bool,
    value: PropTypes.oneOfType([
      PropTypes.number, PropTypes.string
-    ])
+    ]),
+    min: PropTypes.any,
+    max: PropTypes.any
  };

  static defaultProps = {
@ -79,14 +82,14 @@ export default class Input extends Component {
  }

  componentWillReceiveProps (newProps) {
-    if (newProps.value !== this.props.value) {
+    if ((newProps.value !== this.props.value) && (newProps.value !== this.state.value)) {
      this.setValue(newProps.value);
    }
  }

  render () {
    const { value } = this.state;
-    const { children, className, hideUnderline, disabled, error, label, hint, multiLine, rows, type } = this.props;
+    const { children, className, hideUnderline, disabled, error, label, hint, multiLine, rows, type, min, max } = this.props;

    const readOnly = this.props.readOnly || disabled;

@ -129,7 +132,10 @@ export default class Input extends Component {
          onBlur={ this.onBlur }
          onChange={ this.onChange }
          onKeyDown={ this.onKeyDown }
+          onPaste={ this.onPaste }
          inputStyle={ inputStyle }
+          min={ min }
+          max={ max }
        >
          { children }
        </TextField>
@ -176,9 +182,9 @@ export default class Input extends Component {
  }

  onChange = (event, value) => {
-    this.setValue(value);
-
-    this.props.onChange && this.props.onChange(event, value);
+    this.setValue(value, () => {
+      this.props.onChange && this.props.onChange(event, value);
+    });
  }

  onBlur = (event) => {
@ -192,6 +198,14 @@ export default class Input extends Component {
    this.props.onBlur && this.props.onBlur(event);
  }

+  onPaste = (event) => {
+    const value = event.clipboardData.getData('Text');
+
+    window.setTimeout(() => {
+      this.onSubmit(value);
+    }, 0);
+  }
+
  onKeyDown = (event) => {
    const { value } = event.target;

@ -205,12 +219,12 @@ export default class Input extends Component {
  }

  onSubmit = (value) => {
-    this.setValue(value);
-
-    this.props.onSubmit && this.props.onSubmit(value);
+    this.setValue(value, () => {
+      this.props.onSubmit && this.props.onSubmit(value);
+    });
  }

-  setValue (value) {
-    this.setState({ value });
+  setValue (value, cb = noop) {
+    this.setState({ value }, cb);
  }
 }
--- a/js/src/ui/Form/InputAddress/inputAddress.css
+++ b/js/src/ui/Form/InputAddress/inputAddress.css
@ -30,6 +30,10 @@
 .iconDisabled {
  position: absolute;
  top: 35px;
+
+  &.noLabel {
+    top: 10px;
+  }
 }

 .icon {
--- a/js/src/ui/Form/InputAddress/inputAddress.js
+++ b/js/src/ui/Form/InputAddress/inputAddress.js
@ -69,14 +69,19 @@ class InputAddress extends Component {
  }

  renderIcon () {
-    const { value, disabled } = this.props;
+    const { value, disabled, label } = this.props;

    if (!value || !value.length || !util.isAddressValid(value)) {
      return null;
    }

+    const classes = [disabled ? styles.iconDisabled : styles.icon];
+    if (!label) {
+      classes.push(styles.noLabel);
+    }
+
    return (
-      <div className={ disabled ? styles.iconDisabled : styles.icon }>
+      <div className={ classes.join(' ') }>
        <IdentityIcon
          inline center
          address={ value } />
--- a/js/src/ui/Form/TypedInput/index.js
+++ b/js/src/ui/Form/TypedInput/index.js
@ -0,0 +1,17 @@
+// 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/>.
+
+export default from './typedInput';
--- a/js/src/ui/Form/TypedInput/typedInput.css
+++ b/js/src/ui/Form/TypedInput/typedInput.css
@ -0,0 +1,31 @@
+/* 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/>.
+*/
+
+.inputs {
+  padding-top: 2px;
+  overflow-x: hidden;
+
+  label {
+    line-height: 22px;
+    pointer-events: none;
+    color: rgba(255, 255, 255, 0.498039);
+    -webkit-user-select: none;
+    font-size: 12px;
+    top: 11px;
+    position: relative;
+  }
+}
--- a/js/src/ui/Form/TypedInput/typedInput.js
+++ b/js/src/ui/Form/TypedInput/typedInput.js
@ -0,0 +1,239 @@
+// 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 React, { Component, PropTypes } from 'react';
+import { MenuItem } from 'material-ui';
+import { range } from 'lodash';
+
+import IconButton from 'material-ui/IconButton';
+import AddIcon from 'material-ui/svg-icons/content/add';
+import RemoveIcon from 'material-ui/svg-icons/content/remove';
+
+import { Input, InputAddressSelect, Select } from '../../../ui';
+import { ABI_TYPES } from '../../../util/abi';
+
+import styles from './typedInput.css';
+
+export default class TypedInput extends Component {
+
+  static propTypes = {
+    onChange: PropTypes.func.isRequired,
+    accounts: PropTypes.object.isRequired,
+    param: PropTypes.object.isRequired,
+
+    error: PropTypes.any,
+    value: PropTypes.any,
+    label: PropTypes.string
+  };
+
+  render () {
+    const { param } = this.props;
+    const { type } = param;
+
+    if (type === ABI_TYPES.ARRAY) {
+      const { accounts, label, value = param.default } = this.props;
+      const { subtype, length } = param;
+
+      const fixedLength = !!length;
+
+      const inputs = range(length || value.length).map((_, index) => {
+        const onChange = (inputValue) => {
+          const newValues = [].concat(this.props.value);
+          newValues[index] = inputValue;
+          this.props.onChange(newValues);
+        };
+
+        return (
+          <TypedInput
+            key={ `${subtype.type}_${index}` }
+            onChange={ onChange }
+            accounts={ accounts }
+            param={ subtype }
+            value={ value[index] }
+          />
+        );
+      });
+
+      return (
+        <div className={ styles.inputs }>
+          <label>{ label }</label>
+          { fixedLength ? null : this.renderLength() }
+          { inputs }
+        </div>
+      );
+    }
+
+    return this.renderType(type);
+  }
+
+  renderLength () {
+    const iconStyle = {
+      width: 16,
+      height: 16
+    };
+
+    const style = {
+      width: 32,
+      height: 32,
+      padding: 0
+    };
+
+    return (
+      <div>
+        <IconButton
+          iconStyle={ iconStyle }
+          style={ style }
+          onClick={ this.onAddField }
+        >
+          <AddIcon />
+        </IconButton>
+
+        <IconButton
+          iconStyle={ iconStyle }
+          style={ style }
+          onClick={ this.onRemoveField }
+        >
+          <RemoveIcon />
+        </IconButton>
+      </div>
+    );
+  }
+
+  renderType (type) {
+    if (type === ABI_TYPES.ADDRESS) {
+      return this.renderAddress();
+    }
+
+    if (type === ABI_TYPES.BOOL) {
+      return this.renderBoolean();
+    }
+
+    if (type === ABI_TYPES.STRING) {
+      return this.renderDefault();
+    }
+
+    if (type === ABI_TYPES.BYTES) {
+      return this.renderDefault();
+    }
+
+    if (type === ABI_TYPES.INT) {
+      return this.renderNumber();
+    }
+
+    if (type === ABI_TYPES.FIXED) {
+      return this.renderNumber();
+    }
+
+    return this.renderDefault();
+  }
+
+  renderNumber () {
+    const { label, value, error, param } = this.props;
+
+    return (
+      <Input
+        label={ label }
+        value={ value }
+        error={ error }
+        onSubmit={ this.onSubmit }
+        type='number'
+        min={ param.signed ? null : 0 }
+      />
+    );
+  }
+
+  renderDefault () {
+    const { label, value, error } = this.props;
+
+    return (
+      <Input
+        label={ label }
+        value={ value }
+        error={ error }
+        onSubmit={ this.onSubmit }
+      />
+    );
+  }
+
+  renderAddress () {
+    const { accounts, label, value, error } = this.props;
+
+    return (
+      <InputAddressSelect
+        accounts={ accounts }
+        label={ label }
+        value={ value }
+        error={ error }
+        onChange={ this.onChange }
+        editing
+      />
+    );
+  }
+
+  renderBoolean () {
+    const { label, value, error } = this.props;
+
+    const boolitems = ['false', 'true'].map((bool) => {
+      return (
+        <MenuItem
+          key={ bool }
+          value={ bool }
+          label={ bool }
+        >
+          { bool }
+        </MenuItem>
+      );
+    });
+
+    return (
+      <Select
+        label={ label }
+        value={ value ? 'true' : 'false' }
+        error={ error }
+        onChange={ this.onChangeBool }
+      >
+        { boolitems }
+      </Select>
+    );
+  }
+
+  onChangeBool = (event, _index, value) => {
+    this.props.onChange(value === 'true');
+  }
+
+  onChange = (event, value) => {
+    this.props.onChange(value);
+  }
+
+  onSubmit = (value) => {
+    this.props.onChange(value);
+  }
+
+  onAddField = () => {
+    const { value, onChange, param } = this.props;
+    const newValues = [].concat(value, param.subtype.default);
+
+    onChange(newValues);
+  }
+
+  onRemoveField = () => {
+    const { value, onChange } = this.props;
+    const newValues = value.slice(0, -1);
+
+    onChange(newValues);
+  }
+
+}
--- a/js/src/ui/Form/index.js
+++ b/js/src/ui/Form/index.js
@ -16,6 +16,7 @@

 import AddressSelect from './AddressSelect';
 import FormWrap from './FormWrap';
+import TypedInput from './TypedInput';
 import Input from './Input';
 import InputAddress from './InputAddress';
 import InputAddressSelect from './InputAddressSelect';
@ -27,6 +28,7 @@ export default from './form';
 export {
  AddressSelect,
  FormWrap,
+  TypedInput,
  Input,
  InputAddress,
  InputAddressSelect,
--- a/js/src/ui/index.js
+++ b/js/src/ui/index.js
@ -29,7 +29,7 @@ import ContextProvider from './ContextProvider';
 import CopyToClipboard from './CopyToClipboard';
 import Editor from './Editor';
 import Errors from './Errors';
-import Form, { AddressSelect, FormWrap, Input, InputAddress, InputAddressSelect, InputChip, InputInline, Select } from './Form';
+import Form, { AddressSelect, FormWrap, TypedInput, Input, InputAddress, InputAddressSelect, InputChip, InputInline, Select } from './Form';
 import IdentityIcon from './IdentityIcon';
 import IdentityName from './IdentityName';
 import MethodDecoding from './MethodDecoding';
@ -62,6 +62,7 @@ export {
  Errors,
  Form,
  FormWrap,
+  TypedInput,
  Input,
  InputAddress,
  InputAddressSelect,
--- a/js/src/util/abi.js
+++ b/js/src/util/abi.js
@ -0,0 +1,146 @@
+// 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 { range } from 'lodash';
+
+const ARRAY_TYPE = 'ARRAY_TYPE';
+const ADDRESS_TYPE = 'ADDRESS_TYPE';
+const STRING_TYPE = 'STRING_TYPE';
+const BOOL_TYPE = 'BOOL_TYPE';
+const BYTES_TYPE = 'BYTES_TYPE';
+const INT_TYPE = 'INT_TYPE';
+const FIXED_TYPE = 'FIXED_TYPE';
+
+export const ABI_TYPES = {
+  ARRAY: ARRAY_TYPE, ADDRESS: ADDRESS_TYPE,
+  STRING: STRING_TYPE, BOOL: BOOL_TYPE,
+  BYTES: BYTES_TYPE, INT: INT_TYPE,
+  FIXED: FIXED_TYPE
+};
+
+export function parseAbiType (type) {
+  const arrayRegex = /^(.+)\[(\d*)]$/;
+
+  if (arrayRegex.test(type)) {
+    const matches = arrayRegex.exec(type);
+
+    const subtype = parseAbiType(matches[1]);
+    const M = parseInt(matches[2]) || null;
+    const defaultValue = !M
+      ? []
+      : range(M).map(() => subtype.default);
+
+    return {
+      type: ARRAY_TYPE,
+      subtype: subtype,
+      length: M,
+      default: defaultValue
+    };
+  }
+
+  const lengthRegex = /^(u?int|bytes)(\d{1,3})$/;
+
+  if (lengthRegex.test(type)) {
+    const matches = lengthRegex.exec(type);
+
+    const subtype = parseAbiType(matches[1]);
+    const length = parseInt(matches[2]);
+
+    return {
+      ...subtype,
+      length
+    };
+  }
+
+  const fixedLengthRegex = /^(u?fixed)(\d{1,3})x(\d{1,3})$/;
+
+  if (fixedLengthRegex.test(type)) {
+    const matches = fixedLengthRegex.exec(type);
+
+    const subtype = parseAbiType(matches[1]);
+    const M = parseInt(matches[2]);
+    const N = parseInt(matches[3]);
+
+    return {
+      ...subtype,
+      M, N
+    };
+  }
+
+  if (type === 'string') {
+    return {
+      type: STRING_TYPE,
+      default: ''
+    };
+  }
+
+  if (type === 'bool') {
+    return {
+      type: BOOL_TYPE,
+      default: false
+    };
+  }
+
+  if (type === 'address') {
+    return {
+      type: ADDRESS_TYPE,
+      default: ''
+    };
+  }
+
+  if (type === 'bytes') {
+    return {
+      type: BYTES_TYPE,
+      default: '0x'
+    };
+  }
+
+  if (type === 'uint') {
+    return {
+      type: INT_TYPE,
+      default: 0,
+      length: 256,
+      signed: false
+    };
+  }
+
+  if (type === 'int') {
+    return {
+      type: INT_TYPE,
+      default: 0,
+      length: 256,
+      signed: true
+    };
+  }
+
+  if (type === 'ufixed') {
+    return {
+      type: FIXED_TYPE,
+      default: 0,
+      length: 256,
+      signed: false
+    };
+  }
+
+  if (type === 'fixed') {
+    return {
+      type: FIXED_TYPE,
+      default: 0,
+      length: 256,
+      signed: true
+    };
+  }
+}
--- a/js/src/util/validation.js
+++ b/js/src/util/validation.js
@ -44,7 +44,7 @@ export function validateAbi (abi, api) {

    // Validate each elements of the Array
    const invalidIndex = abiParsed
-      .map((o) => isValidAbiEvent(o, api) || isValidAbiFunction(o, api))
+      .map((o) => isValidAbiEvent(o, api) || isValidAbiFunction(o, api) || isAbiFallback(o))
      .findIndex((valid) => !valid);

    if (invalidIndex !== -1) {
@ -74,6 +74,14 @@ function isValidAbiFunction (object, api) {
    (object.inputs && api.util.isArray(object.inputs));
 }

+function isAbiFallback (object) {
+  if (!object) {
+    return false;
+  }
+
+  return object.type === 'fallback';
+}
+
 function isValidAbiEvent (object, api) {
  if (!object) {
    return false;
--- a/js/src/views/Accounts/accounts.js
+++ b/js/src/views/Accounts/accounts.js
@ -22,7 +22,7 @@ import { uniq } from 'lodash';

 import List from './List';
 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';

@ -90,12 +90,15 @@ class Accounts extends Component {
    return (
      <ActionbarSort
        key='sortAccounts'
+        id='sortAccounts'
        order={ this.state.sortOrder }
        onChange={ onChange } />
    );
  }

  renderActionbar () {
+    const { accounts } = this.props;
+
    const buttons = [
      <Button
        key='newAccount'
@ -103,6 +106,11 @@ class Accounts extends Component {
        label='new account'
        onClick={ this.onNewAccountClick } />,

+      <ActionbarExport
+        key='exportAccounts'
+        content={ accounts }
+        filename='accounts' />,
+
      this.renderSearchButton(),
      this.renderSortButton()
    ];
--- a/js/src/views/Addresses/addresses.js
+++ b/js/src/views/Addresses/addresses.js
@ -75,6 +75,7 @@ class Addresses extends Component {
    return (
      <ActionbarSort
        key='sortAccounts'
+        id='sortAddresses'
        order={ this.state.sortOrder }
        onChange={ onChange } />
    );
@ -106,7 +107,7 @@ class Addresses extends Component {
      <ActionbarExport
        key='exportAddressbook'
        content={ contacts }
-        filename='addressbook.json' />,
+        filename='addressbook' />,

      <ActionbarImport
        key='importAddressbook'
--- a/js/src/views/Contract/Queries/inputQuery.js
+++ b/js/src/views/Contract/Queries/inputQuery.js
@ -19,7 +19,7 @@ import React, { Component, PropTypes } from 'react';
 import LinearProgress from 'material-ui/LinearProgress';
 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';

@ -33,6 +33,7 @@ export default class InputQuery extends Component {
    inputs: PropTypes.array.isRequired,
    outputs: PropTypes.array.isRequired,
    name: PropTypes.string.isRequired,
+    signature: PropTypes.string.isRequired,
    className: PropTypes.string
  }

@ -95,32 +96,48 @@ export default class InputQuery extends Component {
    }

    if (!results || results.length < 1) return null;
-
    return outputs
      .map((out, index) => ({
        name: out.name,
+        type: out.type,
        value: results[index],
        display: this.renderValue(results[index])
      }))
      .sort((outA, outB) => outA.display.length - outB.display.length)
-      .map((out, index) => (
-        <div key={ index }>
-          <div className={ styles.queryResultName }>
-            { out.name }
-          </div>
+      .map((out, index) => {
+        let input = null;
+        if (out.type === 'address') {
+          input = (
+            <InputAddress
+              className={ styles.queryValue }
+              disabled
+              value={ out.display }
+            />
+          );
+        } else {
+          input = (
+            <Input
+              className={ styles.queryValue }
+              readOnly
+              allowCopy
+              value={ out.display }
+            />
+          );
+        }

-          <Input
-            className={ styles.queryValue }
-            readOnly
-            allowCopy
-            value={ out.display }
-          />
-          <br />
-        </div>
-      ));
+        return (
+          <div key={ index }>
+            <div className={ styles.queryResultName }>
+              { out.name }
+            </div>
+            { input }
+          </div>
+        );
+      });
  }

  renderInput (input) {
+    const { values } = this.state;
    const { name, type } = input;
    const label = `${name ? `${name}: ` : ''}${type}`;

@ -142,6 +159,7 @@ export default class InputQuery extends Component {
          <InputAddressSelect
            hint={ type }
            label={ label }
+            value={ values[name] }
            required
            onChange={ onChange }
          />
@ -154,6 +172,7 @@ export default class InputQuery extends Component {
        <Input
          hint={ type }
          label={ label }
+          value={ values[name] }
          required
          onChange={ onChange }
        />
@ -177,7 +196,7 @@ export default class InputQuery extends Component {

  onClick = () => {
    const { values } = this.state;
-    const { inputs, contract, name, outputs } = this.props;
+    const { inputs, contract, name, outputs, signature } = this.props;

    this.setState({
      isLoading: true,
@ -187,7 +206,7 @@ export default class InputQuery extends Component {
    const inputValues = inputs.map(input => values[input.name]);

    contract
-      .instance[name]
+      .instance[signature]
      .call({}, inputValues)
      .then(results => {
        if (outputs.length === 1) {
--- a/js/src/views/Contract/Queries/queries.css
+++ b/js/src/views/Contract/Queries/queries.css
@ -56,18 +56,10 @@
 }

 .methodResults {
-  display: flex;
-  flex-wrap: wrap;
-  max-width: 24rem;
-  justify-content: space-around;
 }

 .methodResults > div {
  padding: 0.25rem 0.5rem;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  flex: 1 1 50%;
  box-sizing: border-box;

  & > div {
--- a/js/src/views/Contract/Queries/queries.js
+++ b/js/src/views/Contract/Queries/queries.js
@ -19,7 +19,7 @@ import React, { Component, PropTypes } from 'react';
 import { Card, CardTitle, CardText } from 'material-ui/Card';

 import InputQuery from './inputQuery';
-import { Container, ContainerTitle, Input } from '../../../ui';
+import { Container, ContainerTitle, Input, InputAddress } from '../../../ui';

 import styles from './queries.css';

@ -70,7 +70,7 @@ export default class Queries extends Component {
  }

  renderInputQuery (fn) {
-    const { abi, name } = fn;
+    const { abi, name, signature } = fn;
    const { contract } = this.props;

    return (
@ -80,6 +80,7 @@ export default class Queries extends Component {
          inputs={ abi.inputs }
          outputs={ abi.outputs }
          name={ name }
+          signature={ signature }
          contract={ contract }
        />
      </div>
@ -99,14 +100,14 @@ export default class Queries extends Component {
          <CardText
            className={ styles.methodContent }
          >
-            { this.renderValue(values[fn.name]) }
+            { this.renderValue(values[fn.name], fn.outputs[0].kind.type) }
          </CardText>
        </Card>
      </div>
    );
  }

-  renderValue (value) {
+  renderValue (value, type) {
    if (typeof value === 'undefined') {
      return null;
    }
@ -124,6 +125,16 @@ export default class Queries extends Component {
      valueToDisplay = value.toString();
    }

+    if (type === 'address') {
+      return (
+        <InputAddress
+          className={ styles.queryValue }
+          value={ valueToDisplay }
+          disabled
+        />
+      );
+    }
+
    return (
      <Input
        className={ styles.queryValue }
--- a/js/src/views/Contracts/contracts.js
+++ b/js/src/views/Contracts/contracts.js
@ -82,6 +82,7 @@ class Contracts extends Component {
    return (
      <ActionbarSort
        key='sortAccounts'
+        id='sortContracts'
        order={ this.state.sortOrder }
        metas={ [
          { key: 'timestamp', label: 'date' }
--- a/js/src/views/Signer/components/Account/Account.css
+++ b/js/src/views/Signer/components/Account/Account.css
@ -17,6 +17,9 @@
 .acc {
  text-align: center;
  display: inline-block;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  width: 100%;
 }

 .acc > * {
@ -35,10 +38,13 @@
 }

 .name {
-  text-overflow: ellipsis;
-  overflow: hidden;
  white-space: nowrap;
-  display: lock;
+  display: block;
  vertical-align: middle;
  text-transform: uppercase;
+
+  span {
+    text-overflow: ellipsis;
+    overflow: hidden;
+  }
 }
--- a/js/src/views/Signer/components/TransactionFinished/TransactionFinished.css
+++ b/js/src/views/Signer/components/TransactionFinished/TransactionFinished.css
@ -38,7 +38,9 @@
 }

 .transactionDetails {
-  margin-right: 321px;
+  padding-right: 321px;
+  width: 100%;
+  box-sizing: border-box;
 }

 .isConfirmed {
--- a/js/src/views/Signer/components/TransactionPending/TransactionPending.css
+++ b/js/src/views/Signer/components/TransactionPending/TransactionPending.css
@ -19,7 +19,9 @@
 }

 .transactionDetails {
-  margin-right: 321px;
+  padding-right: 321px;
+  width: 100%;
+  box-sizing: border-box;
 }

 .mainContainer {
--- a/js/src/views/Signer/containers/Embedded/embedded.css
+++ b/js/src/views/Signer/containers/Embedded/embedded.css
@ -15,6 +15,7 @@
 /* along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 */
 .signer {
+  width: 916px;
 }

 .pending {
--- a/js/webpack.vendor.js
+++ b/js/webpack.vendor.js
@ -14,6 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

+const HappyPack = require('happypack');
 const webpack = require('webpack');

 const ENV = process.env.NODE_ENV || 'development';
@ -22,10 +23,26 @@ const DEST = process.env.BUILD_DEST || '.build';

 let modules = [
  'babel-polyfill',
-  'browserify-aes', 'ethereumjs-tx', 'scryptsy',
-  'react', 'react-dom', 'react-redux', 'react-router',
-  'redux', 'redux-thunk', 'react-router-redux',
-  'lodash', 'material-ui', 'moment', 'blockies'
+  'bignumber.js',
+  'blockies',
+  'brace',
+  '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) {
@ -44,6 +61,11 @@ module.exports = {
      {
        test: /\.json$/,
        loaders: ['json']
+      },
+      {
+        test: /\.js$/,
+        include: /(ethereumjs-tx)/,
+        loaders: [ 'happypack/loader?id=js' ]
      }
    ]
  },
@ -63,6 +85,12 @@ module.exports = {
        'process.env': {
          NODE_ENV: JSON.stringify(ENV)
        }
+      }),
+
+      new HappyPack({
+        id: 'js',
+        threads: 4,
+        loaders: ['babel']
      })
    ];

--- a/json/src/spec/authority_round.rs
+++ b/json/src/spec/authority_round.rs
@ -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();
+	}
+}
--- a/json/src/spec/engine.rs
+++ b/json/src/spec/engine.rs
@ -18,6 +18,7 @@

 use spec::Ethash;
 use spec::BasicAuthority;
+use spec::AuthorityRound;
 use spec::Tendermint;

 /// Engine deserialization.
@ -31,7 +32,9 @@ pub enum Engine {
 	Ethash(Ethash),
 	/// BasicAuthority engine.
 	BasicAuthority(BasicAuthority),
-	/// Byzantine Fault Tolerant engine.
+	/// AuthorityRound engine.
+	AuthorityRound(AuthorityRound),
+	/// Tendermint engine.
 	Tendermint(Tendermint)
 }

--- a/json/src/spec/ethash.rs
+++ b/json/src/spec/ethash.rs
@ -92,6 +92,11 @@ pub struct EthashParams {
 	/// See main EthashParams docs.
 	#[serde(rename="ecip1010ContinueTransition")]
 	pub ecip1010_continue_transition: Option<Uint>,
+
+	/// See main EthashParams docs.
+	#[serde(rename="maxCodeSize")]
+	pub max_code_size: Option<Uint>,
+
 }

 /// Ethash engine deserialization.
--- a/json/src/spec/mod.rs
+++ b/json/src/spec/mod.rs
@ -26,6 +26,7 @@ pub mod engine;
 pub mod state;
 pub mod ethash;
 pub mod basic_authority;
+pub mod authority_round;
 pub mod tendermint;

 pub use self::account::Account;
@ -38,4 +39,8 @@ pub use self::engine::Engine;
 pub use self::state::State;
 pub use self::ethash::{Ethash, EthashParams};
 pub use self::basic_authority::{BasicAuthority, BasicAuthorityParams};
+<<<<<<< HEAD
 pub use self::tendermint::{Tendermint, TendermintParams};
+=======
+pub use self::authority_round::{AuthorityRound, AuthorityRoundParams};
+>>>>>>> parity/master
--- a/parity/blockchain.rs
+++ b/parity/blockchain.rs
@ -117,7 +117,7 @@ fn execute_import(cmd: ImportBlockchain) -> Result<String, String> {
 	let panic_handler = PanicHandler::new_in_arc();

 	// create dirs used by parity
-	try!(cmd.dirs.create_dirs());
+	try!(cmd.dirs.create_dirs(false, false));

 	// load spec file
 	let spec = try!(cmd.spec.spec());
@ -165,6 +165,9 @@ fn execute_import(cmd: ImportBlockchain) -> Result<String, String> {
 		Arc::new(Miner::with_spec(&spec)),
 	).map_err(|e| format!("Client service error: {:?}", e)));

+	// free up the spec in memory.
+	drop(spec);
+
 	panic_handler.forward_from(&service);
 	let client = service.client();

@ -263,7 +266,7 @@ fn execute_export(cmd: ExportBlockchain) -> Result<String, String> {
 	let panic_handler = PanicHandler::new_in_arc();

 	// create dirs used by parity
-	try!(cmd.dirs.create_dirs());
+	try!(cmd.dirs.create_dirs(false, false));

 	let format = cmd.format.unwrap_or_default();

@ -312,6 +315,8 @@ fn execute_export(cmd: ExportBlockchain) -> Result<String, String> {
 		Arc::new(Miner::with_spec(&spec)),
 	).map_err(|e| format!("Client service error: {:?}", e)));

+	drop(spec);
+
 	panic_handler.forward_from(&service);
 	let client = service.client();

--- a/parity/dir.rs
+++ b/parity/dir.rs
@ -44,11 +44,15 @@ impl Default for Directories {
 }

 impl Directories {
-	pub fn create_dirs(&self) -> Result<(), String> {
+	pub fn create_dirs(&self, dapps_enabled: bool, signer_enabled: bool) -> Result<(), String> {
 		try!(fs::create_dir_all(&self.db).map_err(|e| e.to_string()));
 		try!(fs::create_dir_all(&self.keys).map_err(|e| e.to_string()));
-		try!(fs::create_dir_all(&self.signer).map_err(|e| e.to_string()));
-		try!(fs::create_dir_all(&self.dapps).map_err(|e| e.to_string()));
+		if signer_enabled {
+			try!(fs::create_dir_all(&self.signer).map_err(|e| e.to_string()));
+		}
+		if dapps_enabled {
+			try!(fs::create_dir_all(&self.dapps).map_err(|e| e.to_string()));
+		}
 		Ok(())
 	}

--- a/parity/run.rs
+++ b/parity/run.rs
@ -110,7 +110,7 @@ pub fn execute(cmd: RunCmd, logger: Arc<RotatingLogger>) -> Result<(), String> {
 	raise_fd_limit();

 	// create dirs used by parity
-	try!(cmd.dirs.create_dirs());
+	try!(cmd.dirs.create_dirs(cmd.dapps_conf.enabled, cmd.signer_conf.enabled));

 	// load spec
 	let spec = try!(cmd.spec.spec());
@ -235,6 +235,9 @@ pub fn execute(cmd: RunCmd, logger: Arc<RotatingLogger>) -> Result<(), String> {
 		miner.clone(),
 	).map_err(|e| format!("Client service error: {:?}", e)));

+	// drop the spec to free up genesis state.
+	drop(spec);
+
 	// forward panics from service
 	panic_handler.forward_from(&service);

--- a/parity/snapshot.rs
+++ b/parity/snapshot.rs
@ -183,7 +183,6 @@ impl SnapshotCommand {

 		Ok((service, panic_handler))
 	}
-
 	/// restore from a snapshot
 	pub fn restore(self) -> Result<(), String> {
 		let file = self.file_path.clone();
--- a/util/io/src/service.rs
+++ b/util/io/src/service.rs
@ -249,7 +249,7 @@ impl<Message> Handler for IoManager<Message> where Message: Send + Clone + Sync
 		let handler_index  = token.0  / TOKENS_PER_HANDLER;
 		let token_id  = token.0  % TOKENS_PER_HANDLER;
 		if let Some(handler) = self.handlers.read().get(handler_index) {
-			let maybe_timer = self.timers.read().get(&token_id).cloned(); 
+			let maybe_timer = self.timers.read().get(&token.0).cloned();
 			if let Some(timer) = maybe_timer {
 				if timer.once {
 					self.timers.write().remove(&token_id);