Merge pull request #1887 from ethcore/stable-staging

Backports to stable
Fixing miner deadlock (#1885 )
2016-08-09 13:51:33 +02:00 · 2016-08-09 11:59:09 +02:00 · 2016-08-09 11:56:04 +02:00 · 2016-08-09 11:55:58 +02:00 · 2016-08-09 11:49:27 +02:00 · 2016-08-09 11:47:59 +02:00
31 changed files with 362 additions and 155 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 [root]
 name = "parity"
-version = "1.2.3"
+version = "1.2.4"
 dependencies = [
 "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -16,7 +16,7 @@ dependencies = [
 "ethcore-ipc-nano 1.2.0",
 "ethcore-rpc 1.2.0",
 "ethcore-signer 1.2.0",
- "ethcore-util 1.2.3",
+ "ethcore-util 1.2.4",
 "ethsync 1.2.0",
 "fdlimit 0.1.0",
 "hyper 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -104,14 +104,17 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 [[package]]
-name = "byteorder"
-version = "0.5.2"
+name = "bytes"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 [[package]]
 name = "bytes"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+version = "0.4.0-dev"
+source = "git+https://github.com/carllerche/bytes#6529f6392a9717585b8d67e1db96e6fa0fb6cb1f"
+dependencies = [
+ "stable-heap 0.1.0 (git+https://github.com/carllerche/stable-heap?rev=3c5cd1ca47)",
+]

 [[package]]
 name = "cfg-if"
@@ -164,7 +167,7 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
- "url 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@@ -257,7 +260,7 @@ dependencies = [
 "ethcore-devtools 1.2.0",
 "ethcore-ipc 1.2.0",
 "ethcore-ipc-codegen 1.2.0",
- "ethcore-util 1.2.3",
+ "ethcore-util 1.2.4",
 "ethjson 0.1.0",
 "ethstore 0.1.0",
 "heapsize 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -278,7 +281,7 @@ version = "1.2.0"
 dependencies = [
 "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-rpc 1.2.0",
- "ethcore-util 1.2.3",
+ "ethcore-util 1.2.4",
 "hyper 0.9.4 (git+https://github.com/ethcore/hyper)",
 "jsonrpc-core 2.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "jsonrpc-http-server 5.1.0 (git+https://github.com/ethcore/jsonrpc-http-server.git)",
@@ -293,7 +296,7 @@ dependencies = [
 "serde_codegen 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "syntex 0.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "url 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@@ -308,7 +311,7 @@ name = "ethcore-ipc"
 version = "1.2.0"
 dependencies = [
 "ethcore-devtools 1.2.0",
- "ethcore-util 1.2.3",
+ "ethcore-util 1.2.4",
 "nanomsg 0.5.1 (git+https://github.com/ethcore/nanomsg.rs.git)",
 "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -342,7 +345,7 @@ dependencies = [
 "ethash 1.2.0",
 "ethcore 1.2.0",
 "ethcore-devtools 1.2.0",
- "ethcore-util 1.2.3",
+ "ethcore-util 1.2.4",
 "ethjson 0.1.0",
 "ethsync 1.2.0",
 "json-ipc-server 0.2.4 (git+https://github.com/ethcore/json-ipc-server.git)",
@@ -364,18 +367,18 @@ dependencies = [
 "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-rpc 1.2.0",
- "ethcore-util 1.2.3",
+ "ethcore-util 1.2.4",
 "jsonrpc-core 2.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "parity-dapps-signer 0.6.0 (git+https://github.com/ethcore/parity-ui.git)",
 "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "ws 0.5.0 (git+https://github.com/ethcore/ws-rs.git?branch=stable)",
+ "ws 0.5.2 (git+https://github.com/ethcore/ws-rs.git?branch=mio-upstream-stable)",
 ]

 [[package]]
 name = "ethcore-util"
-version = "1.2.3"
+version = "1.2.4"
 dependencies = [
 "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -414,7 +417,7 @@ dependencies = [
 name = "ethjson"
 version = "0.1.0"
 dependencies = [
- "ethcore-util 1.2.3",
+ "ethcore-util 1.2.4",
 "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_codegen 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -456,7 +459,7 @@ dependencies = [
 "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore 1.2.0",
- "ethcore-util 1.2.3",
+ "ethcore-util 1.2.4",
 "heapsize 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -563,7 +566,7 @@ dependencies = [
 "traitobject 0.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "typeable 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicase 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "url 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "vecio 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@@ -597,7 +600,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "json-ipc-server"
 version = "0.2.4"
-source = "git+https://github.com/ethcore/json-ipc-server.git#7a02a0f8b249fda100b9bab5f90b2081d410d8cf"
+source = "git+https://github.com/ethcore/json-ipc-server.git#56b6307130710ebc73cb9be087b6ed0b6c400bcf"
 dependencies = [
 "bytes 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -605,7 +608,7 @@ dependencies = [
 "lazy_static 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "miow 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "miow 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@@ -721,7 +724,7 @@ dependencies = [
 "bytes 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "miow 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "miow 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "net2 0.2.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "nix 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -737,7 +740,7 @@ dependencies = [
 "bytes 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "miow 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "miow 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "net2 0.2.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "nix 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -745,9 +748,24 @@ dependencies = [
 "winapi 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "mio"
+version = "0.6.0-dev"
+source = "git+https://github.com/carllerche/mio?rev=62ec763c9cc34d8a452ed0392c575c50ddd5fc8d#62ec763c9cc34d8a452ed0392c575c50ddd5fc8d"
+dependencies = [
+ "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "miow 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "net2 0.2.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "nix 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "slab 0.2.0 (git+https://github.com/carllerche/slab?rev=5476efcafb)",
+ "winapi 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "miow"
-version = "0.1.2"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -795,6 +813,19 @@ dependencies = [
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "nix"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cfg-if 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "semver 0.1.20 (registry+https://github.com/rust-lang/crates.io-index)",
+ "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "nodrop"
 version = "0.1.6"
@@ -1193,11 +1224,8 @@ dependencies = [

 [[package]]
 name = "sha1"
-version = "0.1.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "byteorder 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]

 [[package]]
 name = "sha3"
@@ -1211,6 +1239,11 @@ name = "slab"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"

+[[package]]
+name = "slab"
+version = "0.2.0"
+source = "git+https://github.com/carllerche/slab?rev=5476efcafb#5476efcafbc5ef4d7315b1bea3f756d8a1fe975e"
+
 [[package]]
 name = "slab"
 version = "0.2.0"
@@ -1230,6 +1263,11 @@ name = "spmc"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"

+[[package]]
+name = "stable-heap"
+version = "0.1.0"
+source = "git+https://github.com/carllerche/stable-heap?rev=3c5cd1ca47#3c5cd1ca4706f167a1de85658b5af0d6d3e65165"
+
 [[package]]
 name = "strsim"
 version = "0.3.0"
@@ -1386,7 +1424,7 @@ dependencies = [

 [[package]]
 name = "url"
-version = "1.1.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "idna 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1450,15 +1488,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"

 [[package]]
 name = "ws"
-version = "0.5.0"
-source = "git+https://github.com/ethcore/ws-rs.git?branch=stable#a876fc115c3ef50a17c8822c9bd2f6e94473e005"
+version = "0.5.2"
+source = "git+https://github.com/ethcore/ws-rs.git?branch=mio-upstream-stable#afbff59776ce16ccec5ee9e218b8891830ee6fdf"
 dependencies = [
+ "bytes 0.4.0-dev (git+https://github.com/carllerche/bytes)",
 "httparse 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "mio 0.5.1 (git+https://github.com/ethcore/mio?branch=v0.5.x)",
+ "mio 0.6.0-dev (git+https://github.com/carllerche/mio?rev=62ec763c9cc34d8a452ed0392c575c50ddd5fc8d)",
 "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
- "sha1 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "url 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "sha1 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "slab 0.2.0 (git+https://github.com/carllerche/slab?rev=5476efcafb)",
+ "url 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 description = "Ethcore client."
 name = "parity"
-version = "1.2.3"
+version = "1.2.4"
 license = "GPL-3.0"
 authors = ["Ethcore <admin@ethcore.io>"]
 build = "build.rs"
--- a/db/src/database.rs
+++ b/db/src/database.rs
@@ -26,12 +26,6 @@ use std::mem;
 use ipc::binary::BinaryConvertError;
 use std::collections::{VecDeque, HashMap, BTreeMap};

-impl From<String> for Error {
-	fn from(s: String) -> Error {
-		Error::RocksDb(s)
-	}
-}
-
 enum WriteCacheEntry {
 	Remove,
 	Write(Vec<u8>),
--- a/db/src/traits.rs
+++ b/db/src/traits.rs
@@ -31,8 +31,8 @@ pub struct KeyValue {
 	pub value: Vec<u8>,
 }

-	#[derive(Debug, Binary)]
-	pub enum Error {
+#[derive(Debug, Binary)]
+pub enum Error {
 	AlreadyOpen,
 	IsClosed,
 	RocksDb(String),
@@ -41,6 +41,12 @@ pub struct KeyValue {
 	UncommitedTransactions,
 }

+impl From<String> for Error {
+	fn from(s: String) -> Error {
+		Error::RocksDb(s)
+	}
+}
+
 /// Database configuration
 #[derive(Binary)]
 pub struct DatabaseConfig {
@@ -68,7 +74,7 @@ impl DatabaseConfig {
 	}
 }

-	pub trait DatabaseService : Sized {
+pub trait DatabaseService : Sized {
 	/// Opens database in the specified path
 	fn open(&self, config: DatabaseConfig, path: String) -> Result<(), Error>;

--- a/ethcore/res/null_morden.json
+++ b/ethcore/res/null_morden.json
@@ -4,7 +4,7 @@
 		"Null": null
 	},
 	"params": {
-		"accountStartNonce": "0x0100000",
+		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x2"
--- a/ethcore/src/account_provider.rs
+++ b/ethcore/src/account_provider.rs
@@ -17,9 +17,9 @@
 //! Account management.

 use std::fmt;
-use std::sync::RwLock;
 use std::collections::HashMap;
-use util::{Address as H160, H256, H520};
+use std::time::{Instant, Duration};
+use util::{Address as H160, H256, H520, Mutex};
 use ethstore::{SecretStore, Error as SSError, SafeAccount, EthStore};
 use ethstore::dir::{KeyDirectory};
 use ethstore::ethkey::{Address as SSAddress, Message as SSMessage, Secret as SSSecret, Random, Generator};
@@ -32,6 +32,8 @@ enum Unlock {
 	/// Account unlocked permantently can always sign message.
 	/// Use with caution.
 	Perm,
+	/// Account unlocked with a timeout
+	Timed((Instant, u32)),
 }

 /// Data associated with account.
@@ -126,7 +128,7 @@ impl KeyDirectory for NullDir {
 /// Account management.
 /// Responsible for unlocking accounts.
 pub struct AccountProvider {
-	unlocked: RwLock<HashMap<SSAddress, AccountData>>,
+	unlocked: Mutex<HashMap<SSAddress, AccountData>>,
 	sstore: Box<SecretStore>,
 }

@@ -134,7 +136,7 @@ impl AccountProvider {
 	/// Creates new account provider.
 	pub fn new(sstore: Box<SecretStore>) -> Self {
 		AccountProvider {
-			unlocked: RwLock::new(HashMap::new()),
+			unlocked: Mutex::new(HashMap::new()),
 			sstore: sstore,
 		}
 	}
@@ -142,7 +144,7 @@ impl AccountProvider {
 	/// Creates not disk backed provider.
 	pub fn transient_provider() -> Self {
 		AccountProvider {
-			unlocked: RwLock::new(HashMap::new()),
+			unlocked: Mutex::new(HashMap::new()),
 			sstore: Box::new(EthStore::open(Box::new(NullDir)).unwrap())
 		}
 	}
@@ -176,12 +178,10 @@ impl AccountProvider {
 		let _ = try!(self.sstore.sign(&account, &password, &Default::default()));

 		// check if account is already unlocked pernamently, if it is, do nothing
-		{
-			let unlocked = self.unlocked.read().unwrap();
-			if let Some(data) = unlocked.get(&account) {
-				if let Unlock::Perm = data.unlock {
-					return Ok(())
-				}
+		let mut unlocked = self.unlocked.lock().unwrap();
+		if let Some(data) = unlocked.get(&account) {
+			if let Unlock::Perm = data.unlock {
+				return Ok(())
 			}
 		}

@@ -190,7 +190,6 @@ impl AccountProvider {
 			password: password,
 		};

-		let mut unlocked = self.unlocked.write().unwrap();
 		unlocked.insert(account, data);
 		Ok(())
 	}
@@ -205,10 +204,15 @@ impl AccountProvider {
 		self.unlock_account(account, password, Unlock::Temp)
 	}

+	/// Unlocks account temporarily with a timeout.
+	pub fn unlock_account_timed<A>(&self, account: A, password: String, duration_ms: u32) -> Result<(), Error> where Address: From<A> {
+		self.unlock_account(account, password, Unlock::Timed((Instant::now(), duration_ms)))
+	}
+
 	/// Checks if given account is unlocked
 	pub fn is_unlocked<A>(&self, account: A) -> bool where Address: From<A> {
 		let account = Address::from(account).into();
-		let unlocked = self.unlocked.read().unwrap();
+		let unlocked = self.unlocked.lock().unwrap();
 		unlocked.get(&account).is_some()
 	}

@@ -218,15 +222,20 @@ impl AccountProvider {
 		let message = Message::from(message).into();

 		let data = {
-			let unlocked = self.unlocked.read().unwrap();
-			try!(unlocked.get(&account).ok_or(Error::NotUnlocked)).clone()
+			let mut unlocked = self.unlocked.lock().unwrap();
+			let data = try!(unlocked.get(&account).ok_or(Error::NotUnlocked)).clone();
+			if let Unlock::Temp = data.unlock {
+				unlocked.remove(&account).expect("data exists: so key must exist: qed");
+			}
+			if let Unlock::Timed((ref start, ref duration)) = data.unlock {
+				if start.elapsed() > Duration::from_millis(*duration as u64) {
+					unlocked.remove(&account).expect("data exists: so key must exist: qed");
+					return Err(Error::NotUnlocked);
+				}
+			}
+			data
 		};

-		if let Unlock::Temp = data.unlock {
-			let mut unlocked = self.unlocked.write().unwrap();
-			unlocked.remove(&account).expect("data exists: so key must exist: qed");
-		}
-
 		let signature = try!(self.sstore.sign(&account, &data.password, &message));
 		Ok(H520(signature.into()))
 	}
@@ -244,6 +253,7 @@ impl AccountProvider {
 mod tests {
 	use super::AccountProvider;
 	use ethstore::ethkey::{Generator, Random};
+	use std::time::Duration;

 	#[test]
 	fn unlock_account_temp() {
@@ -269,4 +279,16 @@ mod tests {
 		assert!(ap.sign(kp.address(), [0u8; 32]).is_ok());
 		assert!(ap.sign(kp.address(), [0u8; 32]).is_ok());
 	}
+
+	#[test]
+	fn unlock_account_timer() {
+		let kp = Random.generate().unwrap();
+		let ap = AccountProvider::transient_provider();
+		assert!(ap.insert_account(kp.secret().clone(), "test").is_ok());
+		assert!(ap.unlock_account_timed(kp.address(), "test1".into(), 2000).is_err());
+		assert!(ap.unlock_account_timed(kp.address(), "test".into(), 2000).is_ok());
+		assert!(ap.sign(kp.address(), [0u8; 32]).is_ok());
+		::std::thread::sleep(Duration::from_millis(2000));
+		assert!(ap.sign(kp.address(), [0u8; 32]).is_err());
+	}
 }
--- a/ethcore/src/client/error.rs
+++ b/ethcore/src/client/error.rs
@@ -1,4 +1,5 @@
 use trace::Error as TraceError;
+use util::UtilError;
 use std::fmt::{Display, Formatter, Error as FmtError};

 /// Client configuration errors.
@@ -6,6 +7,10 @@ use std::fmt::{Display, Formatter, Error as FmtError};
 pub enum Error {
 	/// TraceDB configuration error.
 	Trace(TraceError),
+	/// Database error
+	Database(String),
+	/// Util error
+	Util(UtilError),
 }

 impl From<TraceError> for Error {
@@ -14,10 +19,18 @@ impl From<TraceError> for Error {
 	}
 }

+impl From<UtilError> for Error {
+	fn from(err: UtilError) -> Self {
+		Error::Util(err)
+	}
+}
+
 impl Display for Error {
 	fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
 		match *self {
-			Error::Trace(ref err) => write!(f, "{}", err)
+			Error::Trace(ref err) => write!(f, "{}", err),
+			Error::Util(ref err) => write!(f, "{}", err),
+			Error::Database(ref s) => write!(f, "Database error: {}", s),
 		}
 	}
 }
--- a/ethcore/src/client/test_client.rs
+++ b/ethcore/src/client/test_client.rs
@@ -66,6 +66,8 @@ pub struct TestBlockChainClient {
 	pub queue_size: AtomicUsize,
 	/// Miner
 	pub miner: Arc<Miner>,
+	/// Test spec
+	spec: Spec,
 }

 #[derive(Clone)]
@@ -105,6 +107,7 @@ impl TestBlockChainClient {
 			receipts: RwLock::new(HashMap::new()),
 			queue_size: AtomicUsize::new(0),
 			miner: Arc::new(Miner::with_spec(Spec::new_test())),
+			spec: Spec::new_test(),
 		};
 		client.add_blocks(1, EachBlockWith::Nothing); // add genesis block
 		client.genesis_hash = client.last_hash.read().unwrap().clone();
@@ -267,7 +270,7 @@ impl BlockChainClient for TestBlockChainClient {

 	fn nonce(&self, address: &Address, id: BlockID) -> Option<U256> {
 		match id {
-			BlockID::Latest => Some(self.nonces.read().unwrap().get(address).cloned().unwrap_or_else(U256::zero)),
+			BlockID::Latest => Some(self.nonces.read().unwrap().get(address).cloned().unwrap_or(self.spec.params.account_start_nonce)),
 			_ => None,
 		}
 	}
--- a/ethcore/src/executive.rs
+++ b/ethcore/src/executive.rs
@@ -98,11 +98,11 @@ impl<'a> Executive<'a> {
 		let check = options.check_nonce;
 		match options.tracing {
 			true => match options.vm_tracing {
-				true => self.transact_with_tracer(t, check, ExecutiveTracer::default(), ExecutiveVMTracer::default()),
+				true => self.transact_with_tracer(t, check, ExecutiveTracer::default(), ExecutiveVMTracer::toplevel()),
 				false => self.transact_with_tracer(t, check, ExecutiveTracer::default(), NoopVMTracer),
 			},
 			false => match options.vm_tracing {
-				true => self.transact_with_tracer(t, check, NoopTracer, ExecutiveVMTracer::default()),
+				true => self.transact_with_tracer(t, check, NoopTracer, ExecutiveVMTracer::toplevel()),
 				false => self.transact_with_tracer(t, check, NoopTracer, NoopVMTracer),
 			},
 		}
@@ -633,7 +633,7 @@ mod tests {
 		let engine = TestEngine::new(5);
 		let mut substate = Substate::new();
 		let mut tracer = ExecutiveTracer::default();
-		let mut vm_tracer = ExecutiveVMTracer::default();
+		let mut vm_tracer = ExecutiveVMTracer::toplevel();

 		let gas_left = {
 			let mut ex = Executive::new(&mut state, &info, &engine, &factory);
@@ -692,7 +692,7 @@ mod tests {
 			],
 			subs: vec![
 				VMTrace {
-					parent_step: 7,
+					parent_step: 6,
 					code: vec![96, 16, 128, 96, 12, 96, 0, 57, 96, 0, 243, 0, 96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53, 85],
 					operations: vec![
 						VMOperation { pc: 0, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 67976.into(), stack_push: vec_into![16], mem_diff: None, store_diff: None }) },
@@ -742,7 +742,7 @@ mod tests {
 		let engine = TestEngine::new(5);
 		let mut substate = Substate::new();
 		let mut tracer = ExecutiveTracer::default();
-		let mut vm_tracer = ExecutiveVMTracer::default();
+		let mut vm_tracer = ExecutiveVMTracer::toplevel();

 		let gas_left = {
 			let mut ex = Executive::new(&mut state, &info, &engine, &factory);
--- a/ethcore/src/miner/external.rs
+++ b/ethcore/src/miner/external.rs
@@ -15,9 +15,9 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
-use util::numbers::U256;
-use util::hash::H256;
+use std::sync::{Arc};
+use std::time::{Instant, Duration};
+use util::{Mutex, U256, H256};

 /// External miner interface.
 pub trait ExternalMinerService: Send + Sync {
@@ -26,50 +26,50 @@ pub trait ExternalMinerService: Send + Sync {

 	/// Total hashrate.
 	fn hashrate(&self) -> U256;
-
-	/// Returns true if external miner is mining.
-	fn is_mining(&self) -> bool;
 }

 /// External Miner.
 pub struct ExternalMiner {
-	hashrates: Arc<RwLock<HashMap<H256, U256>>>,
+	hashrates: Arc<Mutex<HashMap<H256, (Instant, U256)>>>,
 }

 impl Default for ExternalMiner {
 	fn default() -> Self {
 		ExternalMiner {
-			hashrates: Arc::new(RwLock::new(HashMap::new())),
+			hashrates: Arc::new(Mutex::new(HashMap::new())),
 		}
 	}
 }

 impl ExternalMiner {
 	/// Creates new external miner with prefilled hashrates.
-	pub fn new(hashrates: Arc<RwLock<HashMap<H256, U256>>>) -> Self {
+	pub fn new(hashrates: Arc<Mutex<HashMap<H256, (Instant, U256)>>>) -> Self {
 		ExternalMiner {
-			hashrates: hashrates
+			hashrates: hashrates,
 		}
 	}
 }

+const ENTRY_TIMEOUT: u64 = 2;
+
 impl ExternalMinerService for ExternalMiner {
 	fn submit_hashrate(&self, hashrate: U256, id: H256) {
-		self.hashrates.write().unwrap().insert(id, hashrate);
+		self.hashrates.lock().unwrap().insert(id, (Instant::now() + Duration::from_secs(ENTRY_TIMEOUT), hashrate));
 	}

 	fn hashrate(&self) -> U256 {
-		self.hashrates.read().unwrap().iter().fold(U256::from(0), |sum, (_, v)| sum + *v)
-	}
-
-	fn is_mining(&self) -> bool {
-		!self.hashrates.read().unwrap().is_empty()
+		let mut hashrates = self.hashrates.lock().unwrap();
+		let h = hashrates.drain().filter(|&(_, (t, _))| t > Instant::now()).collect();
+		*hashrates = h;
+		hashrates.iter().fold(U256::from(0), |sum, (_, &(_, v))| sum + v)
 	}
 }

 #[cfg(test)]
 mod tests {
 	use super::*;
+	use std::thread::sleep;
+	use std::time::Duration;
 	use util::{H256, U256};

 	fn miner() -> ExternalMiner {
@@ -77,16 +77,18 @@ mod tests {
 	}

 	#[test]
-	fn should_return_that_is_mining_if_there_is_at_least_one_entry() {
+	fn it_should_forget_old_hashrates() {
 		// given
 		let m = miner();
-		assert_eq!(m.is_mining(), false);
+		assert_eq!(m.hashrate(), U256::from(0));
+		m.submit_hashrate(U256::from(10), H256::from(1));
+		assert_eq!(m.hashrate(), U256::from(10));

 		// when
-		m.submit_hashrate(U256::from(10), H256::from(1));
+		sleep(Duration::from_secs(3));

 		// then
-		assert_eq!(m.is_mining(), true);
+		assert_eq!(m.hashrate(), U256::from(0));
 	}

 	#[test]
--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@@ -96,12 +96,10 @@ pub struct Miner {
 	// NOTE [ToDr]  When locking always lock in this order!
 	transaction_queue: Mutex<TransactionQueue>,
 	sealing_work: Mutex<SealingWork>,
-
-	// for sealing...
-	options: MinerOptions,
-	
 	next_allowed_reseal: Mutex<Instant>,
 	sealing_block_last_request: Mutex<u64>,
+	// for sealing...
+	options: MinerOptions,
 	gas_range_target: RwLock<(U256, U256)>,
 	author: RwLock<Address>,
 	extra_data: RwLock<Bytes>,
@@ -651,11 +649,11 @@ impl MinerService for Miner {
 	fn update_sealing(&self, chain: &MiningBlockChainClient) {
 		trace!(target: "miner", "update_sealing");
 		let requires_reseal = {
+			let has_local_transactions = self.transaction_queue.lock().unwrap().has_local_pending_transactions();
 			let mut sealing_work = self.sealing_work.lock().unwrap();
 			if sealing_work.enabled {
 				trace!(target: "miner", "update_sealing: sealing enabled");
 				let current_no = chain.chain_info().best_block_number;
-				let has_local_transactions = self.transaction_queue.lock().unwrap().has_local_pending_transactions();
 				let last_request = *self.sealing_block_last_request.lock().unwrap();
 				let should_disable_sealing = !self.forced_sealing()
 					&& !has_local_transactions
@@ -689,6 +687,10 @@ impl MinerService for Miner {
 		}
 	}

+	fn is_sealing(&self) -> bool {
+		self.sealing_work.lock().unwrap().queue.is_in_use()
+	}
+
 	fn map_sealing_work<F, T>(&self, chain: &MiningBlockChainClient, f: F) -> Option<T> where F: FnOnce(&ClosedBlock) -> T {
 		trace!(target: "miner", "map_sealing_work: entering");
 		self.enable_and_prepare_sealing(chain);
--- a/ethcore/src/miner/mod.rs
+++ b/ethcore/src/miner/mod.rs
@@ -148,6 +148,9 @@ pub trait MinerService : Send + Sync {
 	/// Returns highest transaction nonce for given address.
 	fn last_nonce(&self, address: &Address) -> Option<U256>;

+	/// Is it currently sealing?
+	fn is_sealing(&self) -> bool;
+
 	/// Suggested gas price.
 	fn sensible_gas_price(&self) -> U256 { 20000000000u64.into() }

--- a/ethcore/src/state.rs
+++ b/ethcore/src/state.rs
@@ -167,7 +167,7 @@ impl State {

 	/// Get the nonce of account `a`.
 	pub fn nonce(&self, a: &Address) -> U256 {
-		self.get(a, false).as_ref().map_or(U256::zero(), |account| *account.nonce())
+		self.get(a, false).as_ref().map_or(self.account_start_nonce, |account| *account.nonce())
 	}

 	/// Mutate storage of account `address` so that it is `value` for `key`.
--- a/ethcore/src/trace/executive_tracer.rs
+++ b/ethcore/src/trace/executive_tracer.rs
@@ -155,11 +155,24 @@ impl Tracer for ExecutiveTracer {
 }

 /// Simple VM tracer. Traces all operations.
-#[derive(Default)]
 pub struct ExecutiveVMTracer {
 	data: VMTrace,
 }

+impl ExecutiveVMTracer {
+	/// Create a new top-level instance.
+	pub fn toplevel() -> Self {
+		ExecutiveVMTracer {
+			data: VMTrace {
+				parent_step: 0,
+				code: vec![],
+				operations: vec![Default::default()],	// prefill with a single entry so that prepare_subtrace can get the parent_step
+				subs: vec![],
+			}
+		}
+	}
+}
+
 impl VMTracer for ExecutiveVMTracer {
 	fn trace_prepare_execute(&mut self, pc: usize, instruction: u8, gas_cost: &U256) -> bool {
 		self.data.operations.push(VMOperation {
@@ -183,7 +196,7 @@ impl VMTracer for ExecutiveVMTracer {

 	fn prepare_subtrace(&self, code: &[u8]) -> Self {
 		ExecutiveVMTracer { data: VMTrace {
-			parent_step: self.data.operations.len(),
+			parent_step: self.data.operations.len() - 1,	// won't overflow since we must already have pushed an operation in trace_prepare_execute.
 			code: code.to_vec(),
 			operations: vec![],
 			subs: vec![],
--- a/ethcore/src/types/trace_types/trace.rs
+++ b/ethcore/src/types/trace_types/trace.rs
@@ -473,7 +473,7 @@ impl Decodable for VMExecutedOperation {
 	}
 }

-#[derive(Debug, Clone, PartialEq, Binary)]
+#[derive(Debug, Clone, PartialEq, Binary, Default)]
 /// A record of the execution of a single VM operation.
 pub struct VMOperation {
 	/// The program counter.
--- a/ethcore/src/verification/verification.rs
+++ b/ethcore/src/verification/verification.rs
@@ -40,7 +40,8 @@ pub fn verify_block_basic(header: &Header, bytes: &[u8], engine: &Engine) -> Res
 	try!(verify_header(&header, engine));
 	try!(verify_block_integrity(bytes, &header.transactions_root, &header.uncles_hash));
 	try!(engine.verify_block_basic(&header, Some(bytes)));
-	for u in Rlp::new(bytes).at(2).iter().map(|rlp| rlp.as_val::<Header>()) {
+	for u in try!(UntrustedRlp::new(bytes).at(2)).iter().map(|rlp| rlp.as_val::<Header>()) {
+		let u = try!(u);
 		try!(verify_header(&u, engine));
 		try!(engine.verify_block_basic(&u, None));
 	}
@@ -58,8 +59,8 @@ pub fn verify_block_basic(header: &Header, bytes: &[u8], engine: &Engine) -> Res
 /// Returns a `PreverifiedBlock` structure populated with transactions
 pub fn verify_block_unordered(header: Header, bytes: Bytes, engine: &Engine) -> Result<PreverifiedBlock, Error> {
 	try!(engine.verify_block_unordered(&header, Some(&bytes)));
-	for u in Rlp::new(&bytes).at(2).iter().map(|rlp| rlp.as_val::<Header>()) {
-		try!(engine.verify_block_unordered(&u, None));
+	for u in try!(UntrustedRlp::new(&bytes).at(2)).iter().map(|rlp| rlp.as_val::<Header>()) {
+		try!(engine.verify_block_unordered(&try!(u), None));
 	}
 	// Verify transactions.
 	let mut transactions = Vec::new();
@@ -84,7 +85,7 @@ pub fn verify_block_family(header: &Header, bytes: &[u8], engine: &Engine, bc: &
 	try!(verify_parent(&header, &parent));
 	try!(engine.verify_block_family(&header, &parent, Some(bytes)));

-	let num_uncles = Rlp::new(bytes).at(2).item_count();
+	let num_uncles = try!(UntrustedRlp::new(bytes).at(2)).item_count();
 	if num_uncles != 0 {
 		if num_uncles > engine.maximum_uncle_count() {
 			return Err(From::from(BlockError::TooManyUncles(OutOfBounds { min: None, max: Some(engine.maximum_uncle_count()), found: num_uncles })));
@@ -106,7 +107,8 @@ pub fn verify_block_family(header: &Header, bytes: &[u8], engine: &Engine, bc: &
 			}
 		}

-		for uncle in Rlp::new(bytes).at(2).iter().map(|rlp| rlp.as_val::<Header>()) {
+		for uncle in try!(UntrustedRlp::new(bytes).at(2)).iter().map(|rlp| rlp.as_val::<Header>()) {
+			let uncle = try!(uncle);
 			if excluded.contains(&uncle.hash()) {
 				return Err(From::from(BlockError::UncleInChain(uncle.hash())))
 			}
@@ -210,13 +212,13 @@ fn verify_parent(header: &Header, parent: &Header) -> Result<(), Error> {

 /// Verify block data against header: transactions root and uncles hash.
 fn verify_block_integrity(block: &[u8], transactions_root: &H256, uncles_hash: &H256) -> Result<(), Error> {
-	let block = Rlp::new(block);
-	let tx = block.at(1);
+	let block = UntrustedRlp::new(block);
+	let tx = try!(block.at(1));
 	let expected_root = &ordered_trie_root(tx.iter().map(|r| r.as_raw().to_vec()).collect()); //TODO: get rid of vectors here
 	if expected_root != transactions_root {
 		return Err(From::from(BlockError::InvalidTransactionsRoot(Mismatch { expected: expected_root.clone(), found: transactions_root.clone() })))
 	}
-	let expected_uncles = &block.at(2).as_raw().sha3();
+	let expected_uncles = &try!(block.at(2)).as_raw().sha3();
 	if expected_uncles != uncles_hash {
 		return Err(From::from(BlockError::InvalidUnclesHash(Mismatch { expected: expected_uncles.clone(), found: uncles_hash.clone() })))
 	}
--- a/nsis/installer.nsi
+++ b/nsis/installer.nsi
@@ -4,7 +4,7 @@
 !define DESCRIPTION "Fast, light, robust Ethereum implementation"
 !define VERSIONMAJOR 1
 !define VERSIONMINOR 2
-!define VERSIONBUILD 3
+!define VERSIONBUILD 4

 !addplugindir .\

--- a/parity/rpc_apis.rs
+++ b/parity/rpc_apis.rs
@@ -156,7 +156,7 @@ pub fn setup_rpc<T: Extendable>(server: T, deps: Arc<Dependencies>, apis: ApiSet
 				}
 			},
 			Api::Personal => {
-				server.add_delegate(PersonalClient::new(&deps.secret_store, &deps.client, &deps.miner, deps.signer_port).to_delegate());
+				server.add_delegate(PersonalClient::new(&deps.secret_store, &deps.client, &deps.miner, deps.signer_port, !deps.allow_pending_receipt_query).to_delegate());
 			},
 			Api::Signer => {
 				server.add_delegate(SignerClient::new(&deps.secret_store, &deps.client, &deps.miner, &deps.signer_queue).to_delegate());
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -283,7 +283,7 @@ impl<C, S, M, EM> Eth for EthClient<C, S, M, EM> where

 	fn is_mining(&self, params: Params) -> Result<Value, Error> {
 		match params {
-			Params::None => to_value(&self.external_miner.is_mining()),
+			Params::None => to_value(&(take_weak!(self.miner).is_sealing())),
 			_ => Err(Error::invalid_params())
 		}
 	}
--- a/rpc/src/v1/impls/personal.rs
+++ b/rpc/src/v1/impls/personal.rs
@@ -31,16 +31,18 @@ pub struct PersonalClient<C, M> where C: MiningBlockChainClient, M: MinerService
 	client: Weak<C>,
 	miner: Weak<M>,
 	signer_port: Option<u16>,
+	allow_perm_unlock: bool,
 }

 impl<C, M> PersonalClient<C, M> where C: MiningBlockChainClient, M: MinerService {
 	/// Creates new PersonalClient
-	pub fn new(store: &Arc<AccountProvider>, client: &Arc<C>, miner: &Arc<M>, signer_port: Option<u16>) -> Self {
+	pub fn new(store: &Arc<AccountProvider>, client: &Arc<C>, miner: &Arc<M>, signer_port: Option<u16>, allow_perm_unlock: bool) -> Self {
 		PersonalClient {
 			accounts: Arc::downgrade(store),
 			client: Arc::downgrade(client),
 			miner: Arc::downgrade(miner),
 			signer_port: signer_port,
+			allow_perm_unlock: allow_perm_unlock,
 		}
 	}
 }
@@ -71,10 +73,17 @@ impl<C: 'static, M: 'static> Personal for PersonalClient<C, M> where C: MiningBl
 	}

 	fn unlock_account(&self, params: Params) -> Result<Value, Error> {
-		from_params::<(Address, String, u64)>(params).and_then(
-			|(account, account_pass, _)|{
+		from_params::<(Address, String, Option<u64>)>(params).and_then(
+			|(account, account_pass, duration)|{
+				let account: Address = account.into();
 				let store = take_weak!(self.accounts);
-				match store.unlock_account_temporarily(account, account_pass) {
+				let r = match (self.allow_perm_unlock, duration) {
+					(false, _) => store.unlock_account_temporarily(account, account_pass),
+					(true, Some(0)) => store.unlock_account_permanently(account, account_pass),
+					(true, Some(d)) => store.unlock_account_timed(account, account_pass, d as u32 * 1000),
+					(true, None) => store.unlock_account_timed(account, account_pass, 300_000),
+				};
+				match r {
 					Ok(_) => Ok(Value::Bool(true)),
 					Err(_) => Ok(Value::Bool(false)),
 				}
--- a/rpc/src/v1/tests/eth.rs
+++ b/rpc/src/v1/tests/eth.rs
@@ -236,6 +236,54 @@ const TRANSACTION_COUNT_SPEC: &'static [u8] = br#"{
 }
 "#;

+const POSITIVE_NONCE_SPEC: &'static [u8] = br#"{
+	"name": "Frontier (Test)",
+	"engine": {
+		"Ethash": {
+			"params": {
+				"gasLimitBoundDivisor": "0x0400",
+				"minimumDifficulty": "0x020000",
+				"difficultyBoundDivisor": "0x0800",
+				"durationLimit": "0x0d",
+				"blockReward": "0x4563918244F40000",
+				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
+				"frontierCompatibilityModeLimit": "0xffffffffffffffff",
+				"daoHardforkTransition": "0xffffffffffffffff",
+				"daoHardforkBeneficiary": "0x0000000000000000000000000000000000000000",
+				"daoHardforkAccounts": []
+			}
+		}
+	},
+	"params": {
+		"accountStartNonce": "0x0100",
+		"maximumExtraDataSize": "0x20",
+		"minGasLimit": "0x50000",
+		"networkID" : "0x1"
+	},
+	"genesis": {
+		"seal": {
+			"ethereum": {
+				"nonce": "0x0000000000000042",
+				"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
+			}
+		},
+		"difficulty": "0x400000000",
+		"author": "0x0000000000000000000000000000000000000000",
+		"timestamp": "0x00",
+		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+		"extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
+		"gasLimit": "0x50000"
+	},
+	"accounts": {
+		"0000000000000000000000000000000000000001": { "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
+		"0000000000000000000000000000000000000002": { "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
+		"0000000000000000000000000000000000000003": { "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
+		"0000000000000000000000000000000000000004": { "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } },
+		"faa34835af5c2ea724333018a515fbb7d5bc0b33": { "balance": "10000000000000", "nonce": "0" }
+	}
+}
+"#;
+
 #[test]
 fn eth_transaction_count() {
 	use util::crypto::Secret;
@@ -365,6 +413,24 @@ fn verify_transaction_counts(name: String, chain: BlockChain) {
 	}
 }

+#[test]
+fn starting_nonce_test() {
+	let tester = EthTester::from_spec_provider(|| Spec::load(POSITIVE_NONCE_SPEC));
+	let address = ::util::hash::Address::from(10);
+
+	let sample = tester.handler.handle_request(&(r#"
+		{
+			"jsonrpc": "2.0",
+			"method": "eth_getTransactionCount",
+			"params": [""#.to_owned() + format!("0x{:?}", address).as_ref() + r#"", "latest"],
+			"id": 15
+		}
+		"#)
+	).unwrap();
+
+	assert_eq!(r#"{"jsonrpc":"2.0","result":"0x0100","id":15}"#, &sample);
+}
+
 register_test!(eth_transaction_count_1, verify_transaction_counts, "BlockchainTests/bcWalletTest");
 register_test!(eth_transaction_count_2, verify_transaction_counts, "BlockchainTests/bcTotalDifficultyTest");
 register_test!(eth_transaction_count_3, verify_transaction_counts, "BlockchainTests/bcGasPricerTest");
--- a/rpc/src/v1/tests/helpers/miner_service.rs
+++ b/rpc/src/v1/tests/helpers/miner_service.rs
@@ -205,6 +205,10 @@ impl MinerService for TestMinerService {
 		self.last_nonces.read().unwrap().get(address).cloned()
 	}

+	fn is_sealing(&self) -> bool {
+		false
+	}
+
 	/// Submit `seal` as a valid solution for the header of `pow_hash`.
 	/// Will check the seal, but not actually insert the block into the chain.
 	fn submit_seal(&self, _chain: &MiningBlockChainClient, _pow_hash: H256, _seal: Vec<Bytes>) -> Result<(), Error> {
--- a/rpc/src/v1/tests/mocked/eth.rs
+++ b/rpc/src/v1/tests/mocked/eth.rs
@@ -16,7 +16,8 @@

 use std::str::FromStr;
 use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
+use std::sync::{Arc, RwLock, Mutex};
+use std::time::{Instant, Duration};
 use jsonrpc_core::IoHandler;
 use util::hash::{Address, H256, FixedHash};
 use util::numbers::{Uint, U256};
@@ -55,8 +56,8 @@ struct EthTester {
 	pub client: Arc<TestBlockChainClient>,
 	pub sync: Arc<TestSyncProvider>,
 	pub accounts_provider: Arc<AccountProvider>,
-	miner: Arc<TestMinerService>,
-	hashrates: Arc<RwLock<HashMap<H256, U256>>>,
+	pub miner: Arc<TestMinerService>,
+	hashrates: Arc<Mutex<HashMap<H256, (Instant, U256)>>>,
 	pub io: IoHandler,
 }

@@ -66,7 +67,7 @@ impl Default for EthTester {
 		let sync = sync_provider();
 		let ap = accounts_provider();
 		let miner = miner_service();
-		let hashrates = Arc::new(RwLock::new(HashMap::new()));
+		let hashrates = Arc::new(Mutex::new(HashMap::new()));
 		let external_miner = Arc::new(ExternalMiner::new(hashrates.clone()));
 		let eth = EthClient::new(&client, &sync, &ap, &miner, &external_miner, true).to_delegate();
 		let sign = EthSigningUnsafeClient::new(&client, &ap, &miner).to_delegate();
@@ -132,9 +133,9 @@ fn rpc_eth_syncing() {
 #[test]
 fn rpc_eth_hashrate() {
 	let tester = EthTester::default();
-	tester.hashrates.write().unwrap().insert(H256::from(0), U256::from(0xfffa));
-	tester.hashrates.write().unwrap().insert(H256::from(0), U256::from(0xfffb));
-	tester.hashrates.write().unwrap().insert(H256::from(1), U256::from(0x1));
+	tester.hashrates.lock().unwrap().insert(H256::from(0), (Instant::now() + Duration::from_secs(2), U256::from(0xfffa)));
+	tester.hashrates.lock().unwrap().insert(H256::from(0), (Instant::now() + Duration::from_secs(2), U256::from(0xfffb)));
+	tester.hashrates.lock().unwrap().insert(H256::from(1), (Instant::now() + Duration::from_secs(2), U256::from(0x1)));

 	let request = r#"{"jsonrpc": "2.0", "method": "eth_hashrate", "params": [], "id": 1}"#;
 	let response = r#"{"jsonrpc":"2.0","result":"0xfffc","id":1}"#;
@@ -157,8 +158,8 @@ fn rpc_eth_submit_hashrate() {
 	let response = r#"{"jsonrpc":"2.0","result":true,"id":1}"#;

 	assert_eq!(tester.io.handle_request(request), Some(response.to_owned()));
-	assert_eq!(tester.hashrates.read().unwrap().get(&H256::from("0x59daa26581d0acd1fce254fb7e85952f4c09d0915afd33d3886cd914bc7d283c")).cloned(),
-		Some(U256::from(0x500_000)));
+	assert_eq!(tester.hashrates.lock().unwrap().get(&H256::from("0x59daa26581d0acd1fce254fb7e85952f4c09d0915afd33d3886cd914bc7d283c")).cloned().unwrap().1,
+		U256::from(0x500_000));
 }

 #[test]
@@ -209,16 +210,11 @@ fn rpc_eth_author() {
 #[test]
 fn rpc_eth_mining() {
 	let tester = EthTester::default();
+	tester.miner.set_author(Address::from_str("d46e8dd67c5d32be8058bb8eb970870f07244567").unwrap());

 	let request = r#"{"jsonrpc": "2.0", "method": "eth_mining", "params": [], "id": 1}"#;
 	let response = r#"{"jsonrpc":"2.0","result":false,"id":1}"#;
 	assert_eq!(tester.io.handle_request(request), Some(response.to_owned()));
-
-	tester.hashrates.write().unwrap().insert(H256::from(1), U256::from(0x1));
-
-	let request = r#"{"jsonrpc": "2.0", "method": "eth_mining", "params": [], "id": 1}"#;
-	let response = r#"{"jsonrpc":"2.0","result":true,"id":1}"#;
-	assert_eq!(tester.io.handle_request(request), Some(response.to_owned()));
 }

 #[test]
--- a/rpc/src/v1/tests/mocked/personal.rs
+++ b/rpc/src/v1/tests/mocked/personal.rs
@@ -50,7 +50,7 @@ fn setup(signer: Option<u16>) -> PersonalTester {
 	let accounts = accounts_provider();
 	let client = blockchain_client();
 	let miner = miner_service();
-	let personal = PersonalClient::new(&accounts, &client, &miner, signer);
+	let personal = PersonalClient::new(&accounts, &client, &miner, signer, false);

 	let io = IoHandler::new();
 	io.add_delegate(personal.to_delegate());
--- a/signer/Cargo.toml
+++ b/signer/Cargo.toml
@@ -15,7 +15,7 @@ rand = "0.3.14"
 jsonrpc-core = "2.0"
 log = "0.3"
 env_logger = "0.3"
-ws = { git = "https://github.com/ethcore/ws-rs.git", branch = "stable" }
+ws = { git = "https://github.com/ethcore/ws-rs.git", branch = "mio-upstream-stable" }
 ethcore-util = { path = "../util" }
 ethcore-rpc = { path = "../rpc" }
 parity-dapps-signer = { git = "https://github.com/ethcore/parity-ui.git", version = "0.6", optional = true}
--- a/signer/src/authcode_store.rs
+++ b/signer/src/authcode_store.rs
@@ -46,7 +46,7 @@ impl TimeProvider for DefaultTimeProvider {
 }

 /// No of seconds the hash is valid
-const TIME_THRESHOLD: u64 = 2;
+const TIME_THRESHOLD: u64 = 7;
 const TOKEN_LENGTH: usize = 16;

 /// Manages authorization codes for `SignerUIs`
@@ -102,7 +102,7 @@ impl<T: TimeProvider> AuthCodes<T> {
 		let now = self.now.now();
 		// check time
 		if time >= now + TIME_THRESHOLD || time <= now - TIME_THRESHOLD {
-			warn!(target: "signer", "Received old authentication request.");
+			warn!(target: "signer", "Received old authentication request. ({} vs {})", now, time);
 			return false;
 		}

@@ -169,8 +169,8 @@ mod tests {
 	fn should_return_false_if_hash_is_valid_but_time_is_invalid() {
 		// given
 		let code = "23521352asdfasdfadf";
-		let time = 105;
-		let time2 = 95;
+		let time = 107;
+		let time2 = 93;
 		let codes = AuthCodes::new(vec![code.into()], || 100);

 		// when
--- a/signer/src/ws_server/session.rs
+++ b/signer/src/ws_server/session.rs
@@ -142,7 +142,9 @@ impl ws::Handler for Session {
 	fn on_message(&mut self, msg: ws::Message) -> ws::Result<()> {
 		let req = try!(msg.as_text());
 		match self.handler.handle_request(req) {
-			Some(res) => self.out.send(res),
+			Some(res) => {
+				self.out.send(res)
+			},
 			None => Ok(()),
 		}
 	}
--- a/sync/src/chain.rs
+++ b/sync/src/chain.rs
@@ -193,6 +193,16 @@ enum PeerAsking {
 	Heads,
 }

+#[derive(Clone, Eq, PartialEq)]
+enum ForkConfirmation {
+	/// Fork block confirmation pending.
+	Unconfirmed,
+	/// Peers chain is too short to confirm the fork.
+	TooShort,
+	/// Fork is confurmed.
+	Confirmed,
+}
+
 #[derive(Clone)]
 /// Syncing peer information
 struct PeerInfo {
@@ -218,13 +228,17 @@ struct PeerInfo {
 	ask_time: f64,
 	/// Pending request is expird and result should be ignored
 	expired: bool,
-	/// Peer fork confirmed
-	confirmed: bool,
+	/// Peer fork confirmation status
+	confirmation: ForkConfirmation,
 }

 impl PeerInfo {
-	fn is_available(&self) -> bool {
-		self.confirmed && !self.expired
+	fn can_sync(&self) -> bool {
+		self.confirmation == ForkConfirmation::Confirmed && !self.expired
+	}
+
+	fn is_allowed(&self) -> bool {
+		self.confirmation != ForkConfirmation::Unconfirmed && !self.expired
 	}
 }

@@ -301,8 +315,8 @@ impl ChainSync {
 			highest_block_number: self.highest_block.map(|n| max(n, self.last_imported_block)),
 			blocks_received: if self.last_imported_block > self.starting_block { self.last_imported_block - self.starting_block } else { 0 },
 			blocks_total: match self.highest_block { Some(x) if x > self.starting_block => x - self.starting_block, _ => 0 },
-			num_peers: self.peers.values().filter(|p| p.confirmed).count(),
-			num_active_peers: self.peers.values().filter(|p| p.confirmed && p.asking != PeerAsking::Nothing).count(),
+			num_peers: self.peers.values().filter(|p| p.is_allowed()).count(),
+			num_active_peers: self.peers.values().filter(|p| p.is_allowed() && p.asking != PeerAsking::Nothing).count(),
 			mem_used:
 				self.blocks.heap_size()
 				+ self.peers.heap_size_of_children()
@@ -324,7 +338,7 @@ impl ChainSync {
 			p.asking_blocks.clear();
 			p.asking_hash = None;
 			// mark any pending requests as expired
-			if p.asking != PeerAsking::Nothing && p.confirmed {
+			if p.asking != PeerAsking::Nothing && p.is_allowed() {
 				p.expired = true;
 			}
 		}
@@ -378,7 +392,7 @@ impl ChainSync {
 			asking_hash: None,
 			ask_time: 0f64,
 			expired: false,
-			confirmed: self.fork_block.is_none(),
+			confirmation: if self.fork_block.is_none() { ForkConfirmation::Confirmed } else { ForkConfirmation::Unconfirmed },
 		};

 		trace!(target: "sync", "New peer {} (protocol: {}, network: {:?}, difficulty: {:?}, latest:{}, genesis:{})", peer_id, peer.protocol_version, peer.network_id, peer.difficulty, peer.latest_hash, peer.genesis);
@@ -421,14 +435,19 @@ impl ChainSync {
 			Some(ref mut peer) if peer.asking == PeerAsking::ForkHeader => {
 				let item_count = r.item_count();
 				if item_count == 0 || (item_count == 1 && try!(r.at(0)).as_raw().sha3() == self.fork_block.unwrap().1) {
-					trace!(target: "sync", "{}: Confirmed peer", peer_id);
 					peer.asking = PeerAsking::Nothing;
-					peer.confirmed = true;
+					if item_count == 0 {
+						trace!(target: "sync", "{}: Chain is too short to confirm the block", peer_id);
+						peer.confirmation = ForkConfirmation::TooShort;
+					} else {
+						trace!(target: "sync", "{}: Confirmed peer", peer_id);
+						peer.confirmation = ForkConfirmation::Confirmed;
+					}
 					true
 				} else {
 					trace!(target: "sync", "{}: Fork mismatch", peer_id);
 					io.disconnect_peer(peer_id);
-					false
+					return Ok(());
 				}
 			},
 			_ => false,
@@ -580,6 +599,10 @@ impl ChainSync {
 	/// Called by peer once it has new block bodies
 	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	fn on_peer_new_block(&mut self, io: &mut SyncIo, peer_id: PeerId, r: &UntrustedRlp) -> Result<(), PacketDecodeError> {
+		if !self.peers.get(&peer_id).map_or(false, |p| p.can_sync()) {
+			trace!(target: "sync", "Ignoring new block from unconfirmed peer {}", peer_id);
+			return Ok(());
+		}
 		let block_rlp = try!(r.at(0));
 		let header_rlp = try!(block_rlp.at(0));
 		let h = header_rlp.as_raw().sha3();
@@ -644,6 +667,10 @@ impl ChainSync {

 	/// Handles `NewHashes` packet. Initiates headers download for any unknown hashes.
 	fn on_peer_new_hashes(&mut self, io: &mut SyncIo, peer_id: PeerId, r: &UntrustedRlp) -> Result<(), PacketDecodeError> {
+		if !self.peers.get(&peer_id).map_or(false, |p| p.can_sync()) {
+			trace!(target: "sync", "Ignoring new hashes from unconfirmed peer {}", peer_id);
+			return Ok(());
+		}
 		if self.state != SyncState::Idle {
 			trace!(target: "sync", "Ignoring new hashes since we're already downloading.");
 			let max = r.iter().take(MAX_NEW_HASHES).map(|item| item.val_at::<BlockNumber>(1).unwrap_or(0)).fold(0u64, max);
@@ -727,7 +754,7 @@ impl ChainSync {
 	/// Resume downloading
 	fn continue_sync(&mut self, io: &mut SyncIo) {
 		let mut peers: Vec<(PeerId, U256)> = self.peers.iter().filter_map(|(k, p)|
-			if p.is_available() { Some((*k, p.difficulty.unwrap_or_else(U256::zero))) } else { None }).collect();
+			if p.can_sync() { Some((*k, p.difficulty.unwrap_or_else(U256::zero))) } else { None }).collect();
 		thread_rng().shuffle(&mut peers); //TODO: sort by rating
 		trace!(target: "sync", "Syncing with {}/{} peers", self.active_peers.len(), peers.len());
 		for (p, _) in peers {
@@ -735,7 +762,7 @@ impl ChainSync {
 				self.sync_peer(io, p, false);
 			}
 		}
-		if self.state != SyncState::Waiting && !self.peers.values().any(|p| p.asking != PeerAsking::Nothing && p.is_available()) {
+		if self.state != SyncState::Waiting && !self.peers.values().any(|p| p.asking != PeerAsking::Nothing && p.can_sync()) {
 			self.complete_sync();
 		}
 	}
@@ -761,7 +788,7 @@ impl ChainSync {
 		}
 		let (peer_latest, peer_difficulty) = {
 			let peer = self.peers.get_mut(&peer_id).unwrap();
-			if peer.asking != PeerAsking::Nothing || !peer.is_available() {
+			if peer.asking != PeerAsking::Nothing || !peer.can_sync() {
 				return;
 			}
 			if self.state == SyncState::Waiting {
@@ -1023,7 +1050,7 @@ impl ChainSync {
 		if !io.is_chain_queue_empty() {
 			return Ok(());
 		}
-		if self.peers.get(&peer_id).map_or(false, |p| p.confirmed) {
+		if !self.peers.get(&peer_id).map_or(false, |p| p.can_sync()) {
 			trace!(target: "sync", "{} Ignoring transactions from unconfirmed/unknown peer", peer_id);
 		}

@@ -1679,7 +1706,7 @@ mod tests {
 				asking_hash: None,
 				ask_time: 0f64,
 				expired: false,
-				confirmed: false,
+				confirmation: super::ForkConfirmation::Confirmed,
 			});
 		sync
 	}
--- a/util/Cargo.toml
+++ b/util/Cargo.toml
@@ -3,7 +3,7 @@ description = "Ethcore utility library"
 homepage = "http://ethcore.io"
 license = "GPL-3.0"
 name = "ethcore-util"
-version = "1.2.3"
+version = "1.2.4"
 authors = ["Ethcore <admin@ethcore.io>"]
 build = "build.rs"

--- a/util/src/misc.rs
+++ b/util/src/misc.rs
@@ -49,7 +49,7 @@ pub fn version() -> String {
 	let date_dash = if commit_date.is_empty() { "" } else { "-" };
 	let env = Target::env();
 	let env_dash = if env.is_empty() { "" } else { "-" };
-	format!("Parity/v{}-beta{}{}{}{}/{}-{}{}{}/rustc{}", env!("CARGO_PKG_VERSION"), sha3_dash, sha3, date_dash, commit_date, Target::arch(), Target::os(), env_dash, env, rustc_version())
+	format!("Parity/v{}-stable{}{}{}{}/{}-{}{}{}/rustc{}", env!("CARGO_PKG_VERSION"), sha3_dash, sha3, date_dash, commit_date, Target::arch(), Target::os(), env_dash, env, rustc_version())
 }

 /// Get the standard version data for this software.
--- a/util/src/using_queue.rs
+++ b/util/src/using_queue.rs
@@ -70,6 +70,9 @@ impl<T> UsingQueue<T> where T: Clone {
 		self.pending = Some(b);
 	}

+	/// Is there anything in the queue currently?
+	pub fn is_in_use(&self) -> bool { self.in_use.len() > 0 }
+
 	/// Clears everything; the queue is entirely reset.
 	pub fn reset(&mut self) {
 		self.pending = None;
Author	SHA1	Message	Date
Marek Kotewicz	a66fd116e4	Merge pull request #1887 from ethcore/stable-staging Backports to stable	2016-08-09 13:51:33 +02:00
Tomasz Drwięga	6af33f4309	Fixing miner deadlock (#1885 )	2016-08-09 11:59:09 +02:00
Tomasz Drwięga	ff84f36f89	Fixing test	2016-08-09 11:56:04 +02:00
Tomusdrw	7dafbeea8f	ws-rs update	2016-08-09 11:55:58 +02:00
Arkadiy Paronyan	4a9c43cea1	Use UntrustedRlp for block verification (#1872 )	2016-08-09 11:49:27 +02:00
Arkadiy Paronyan	c396d0e9f1	Sync to peers with confirmed fork block only (#1863 )	2016-08-09 11:47:59 +02:00
Arkadiy Paronyan	78825dcd59	Miner tweaks (#1797 ) (#1862 ) * Miner tweaks (#1797) * Mining fixes. - Use queue to determine whether we're mining - Kick stale hash rates Fixes #1794 Fixes #1641 * Fix tests. * Address grumbles. * Fixed tests	2016-08-08 11:50:58 +02:00
Arkadiy Paronyan	801cf6fcba	Unlock account with timeout for geth compatibility (#1854 ) (#1858 ) * Unlock account with timeout for geth compatibility * Fixed test	2016-08-06 09:26:06 +02:00
Arkadiy Paronyan	aa9b152f76	Backport fixes to stable (#1855 ) * Fix up the VM trace. * Fix test. * Fix state not using "account_starting_nonce" (#1830) * failng test * use account_starting_nonce instead of zero * simplier test * jsons are getting closer * incorrect test client and incorrect tests fix * null_morden is using 0x0 starting nonce * replaced json with the correct one * superwhatever line * Bump json-ipc-server again (#1839) * bump ipc version * bumping once more * v1.2.4 * Fixed reported max height and transaction propagation (#1852) * Fixed max height and transaction propagation * Fixed tests	2016-08-05 23:34:06 +02:00