From 3de482a43115611510af41f79f10baa922bab247 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= <tomasz@ethcore.io>
Date: Tue, 21 Jun 2016 12:31:50 +0200
Subject: [PATCH 01/22] Additional assertions for internal state of queue

---
 ethcore/src/miner/transaction_queue.rs | 27 +++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/ethcore/src/miner/transaction_queue.rs b/ethcore/src/miner/transaction_queue.rs
index cc8430b42..146fa77e3 100644
--- a/ethcore/src/miner/transaction_queue.rs
+++ b/ethcore/src/miner/transaction_queue.rs
@@ -239,6 +239,7 @@ impl TransactionSet {
 		if let Some(ref old_order) = r {
 			self.by_priority.remove(old_order);
 		}
+		assert_eq!(self.by_priority.len(), self.by_address.len());
 		r
 	}
 
@@ -279,8 +280,10 @@ impl TransactionSet {
 	fn drop(&mut self, sender: &Address, nonce: &U256) -> Option<TransactionOrder> {
 		if let Some(tx_order) = self.by_address.remove(sender, nonce) {
 			self.by_priority.remove(&tx_order);
+			assert_eq!(self.by_priority.len(), self.by_address.len());
 			return Some(tx_order);
 		}
+		assert_eq!(self.by_priority.len(), self.by_address.len());
 		None
 	}
 
@@ -468,7 +471,9 @@ impl TransactionQueue {
 			}));
 		}
 
-		self.import_tx(vtx, client_account.nonce).map_err(Error::Transaction)
+		let r = self.import_tx(vtx, client_account.nonce).map_err(Error::Transaction);
+		assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
+		r
 	}
 
 	/// Removes all transactions from particular sender up to (excluding) given client (state) nonce.
@@ -484,6 +489,7 @@ impl TransactionQueue {
 		// And now lets check if there is some batch of transactions in future
 		// that should be placed in current. It should also update last_nonces.
 		self.move_matching_future_to_current(sender, client_nonce, client_nonce);
+		assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
 	}
 
 	/// Removes invalid transaction identified by hash from queue.
@@ -493,6 +499,8 @@ impl TransactionQueue {
 	/// If gap is introduced marks subsequent transactions as future
 	pub fn remove_invalid<T>(&mut self, transaction_hash: &H256, fetch_account: &T)
 		where T: Fn(&Address) -> AccountDetails {
+
+		assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
 		let transaction = self.by_hash.remove(transaction_hash);
 		if transaction.is_none() {
 			// We don't know this transaction
@@ -511,6 +519,7 @@ impl TransactionQueue {
 			// And now lets check if there is some chain of transactions in future
 			// that should be placed in current
 			self.move_matching_future_to_current(sender, current_nonce, current_nonce);
+			assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
 			return;
 		}
 
@@ -520,6 +529,7 @@ impl TransactionQueue {
 			// This will keep consistency in queue
 			// Moves all to future and then promotes a batch from current:
 			self.remove_all(sender, current_nonce);
+			assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
 			return;
 		}
 	}
@@ -538,7 +548,7 @@ impl TransactionQueue {
 			} else {
 				trace!(target: "miner", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
 				// Remove the transaction completely
-				self.by_hash.remove(&order.hash);
+				self.by_hash.remove(&order.hash).expect("All transactions in `future` are also in `by_hash`");
 			}
 		}
 	}
@@ -558,7 +568,7 @@ impl TransactionQueue {
 				self.future.insert(*sender, k, order.update_height(k, current_nonce));
 			} else {
 				trace!(target: "miner", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
-				self.by_hash.remove(&order.hash);
+				self.by_hash.remove(&order.hash).expect("All transactions in `future` are also in `by_hash`");
 			}
 		}
 		self.future.enforce_limit(&mut self.by_hash);
@@ -685,7 +695,8 @@ impl TransactionQueue {
 		// same (sender, nonce), but above function would not move it.
 		if let Some(order) = self.future.drop(&address, &nonce) {
 			// Let's insert that transaction to current (if it has higher gas_price)
-			let future_tx = self.by_hash.remove(&order.hash).unwrap();
+			let future_tx = self.by_hash.remove(&order.hash).expect("All transactions in `future` are always in `by_hash`.");
+			// if transaction in `current` (then one we are importing) is replaced it means that it has to low gas_price
 			try!(check_too_cheap(Self::replace_transaction(future_tx, state_nonce, &mut self.current, &mut self.by_hash)));
 		}
 
@@ -726,7 +737,9 @@ impl TransactionQueue {
 		let address = tx.sender();
 		let nonce = tx.nonce();
 
-		by_hash.insert(hash, tx);
+		let old_hash = by_hash.insert(hash, tx);
+		assert!(old_hash.is_none(), "Each hash has to be inserted exactly once.");
+
 
 		if let Some(old) = set.insert(address, nonce, order.clone()) {
 			// There was already transaction in queue. Let's check which one should stay
@@ -736,11 +749,11 @@ impl TransactionQueue {
 				// Put back old transaction since it has greater priority (higher gas_price)
 				set.insert(address, nonce, old);
 				// and remove new one
-				by_hash.remove(&hash);
+				by_hash.remove(&hash).expect("The hash has been just inserted and no other line is altering `by_hash`.");
 				false
 			} else {
 				// Make sure we remove old transaction entirely
-				by_hash.remove(&old.hash);
+				by_hash.remove(&old.hash).expect("The hash is coming from `future` so it has to be in `by_hash`.");
 				true
 			}
 		} else {

From c2ffa904789f27d1a4982494489c481c87b3e829 Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Tue, 21 Jun 2016 13:09:27 +0200
Subject: [PATCH 02/22] importing presale wallet in progress

---
 ethstore/src/crypto.rs       | 11 ++++++--
 ethstore/src/ethkey.rs       |  8 ++++++
 ethstore/src/json/hash.rs    | 27 +++++++++++++++++-
 ethstore/src/json/mod.rs.in  |  4 ++-
 ethstore/src/json/presale.rs | 42 ++++++++++++++++++++++++++++
 ethstore/src/lib.rs          |  1 +
 ethstore/src/presale.rs      | 53 ++++++++++++++++++++++++++++++++++++
 7 files changed, 142 insertions(+), 4 deletions(-)
 create mode 100644 ethstore/src/json/presale.rs
 create mode 100644 ethstore/src/presale.rs

diff --git a/ethstore/src/crypto.rs b/ethstore/src/crypto.rs
index 2858808d7..2733fa720 100644
--- a/ethstore/src/crypto.rs
+++ b/ethstore/src/crypto.rs
@@ -65,8 +65,8 @@ impl Keccak256<[u8; 32]> for [u8] {
 
 /// AES encryption
 pub mod aes {
-	use rcrypto::blockmodes::CtrMode;
-	use rcrypto::aessafe::AesSafe128Encryptor;
+	use rcrypto::blockmodes::{CtrMode, CbcDecryptor, PkcsPadding};
+	use rcrypto::aessafe::{AesSafe128Encryptor, AesSafe128Decryptor};
 	use rcrypto::symmetriccipher::{Encryptor, Decryptor};
 	use rcrypto::buffer::{RefReadBuffer, RefWriteBuffer};
 
@@ -81,5 +81,12 @@ pub mod aes {
 		let mut encryptor = CtrMode::new(AesSafe128Encryptor::new(k), iv.to_vec());
 		encryptor.decrypt(&mut RefReadBuffer::new(encrypted), &mut RefWriteBuffer::new(dest), true).expect("Invalid length or padding");
 	}
+
+	/// Decrypt a message using cbc mode
+	pub fn decrypt_cbc(k: &[u8], iv: &[u8], encrypted: &[u8], dest: &mut [u8]) {
+		let mut encryptor = CbcDecryptor::new(AesSafe128Decryptor::new(k), PkcsPadding, iv.to_vec());
+		encryptor.decrypt(&mut RefReadBuffer::new(encrypted), &mut RefWriteBuffer::new(dest), true).expect("Invalid length or padding");
+	}
+
 }
 
diff --git a/ethstore/src/ethkey.rs b/ethstore/src/ethkey.rs
index eba877397..9d8858b79 100644
--- a/ethstore/src/ethkey.rs
+++ b/ethstore/src/ethkey.rs
@@ -31,3 +31,11 @@ impl From<json::H160> for Address {
 		From::from(a)
 	}
 }
+
+impl<'a> From<&'a json::H160> for Address {
+	fn from(json: &'a json::H160) -> Self {
+		let mut a = [0u8; 20];
+		a.copy_from_slice(json);
+		From::from(a)
+	}
+}
diff --git a/ethstore/src/json/hash.rs b/ethstore/src/json/hash.rs
index f0fb91e7a..2edc7b80b 100644
--- a/ethstore/src/json/hash.rs
+++ b/ethstore/src/json/hash.rs
@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
+use std::fmt;
+use std::ops;
 use std::str::FromStr;
 use rustc_serialize::hex::{FromHex, ToHex};
 use serde::{Serialize, Serializer, Deserialize, Deserializer, Error as SerdeError};
@@ -22,9 +24,31 @@ use super::Error;
 
 macro_rules! impl_hash {
 	($name: ident, $size: expr) => {
-		#[derive(Debug, PartialEq)]
 		pub struct $name([u8; $size]);
 
+		impl fmt::Debug for $name {
+			fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+				let self_ref: &[u8] = &self.0;
+				write!(f, "{:?}", self_ref)
+			}
+		}
+
+		impl PartialEq for $name {
+			fn eq(&self, other: &Self) -> bool {
+				let self_ref: &[u8] = &self.0;
+				let other_ref: &[u8] = &other.0;
+				self_ref == other_ref
+			}
+		}
+
+		impl ops::Deref for $name {
+			type Target = [u8];
+
+			fn deref(&self) -> &Self::Target {
+				&self.0
+			}
+		}
+
 		impl Serialize for $name {
 			fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
 			where S: Serializer {
@@ -85,3 +109,4 @@ macro_rules! impl_hash {
 impl_hash!(H128, 16);
 impl_hash!(H160, 20);
 impl_hash!(H256, 32);
+impl_hash!(H768, 96);
diff --git a/ethstore/src/json/mod.rs.in b/ethstore/src/json/mod.rs.in
index c4a67a287..7272d7e2e 100644
--- a/ethstore/src/json/mod.rs.in
+++ b/ethstore/src/json/mod.rs.in
@@ -5,14 +5,16 @@ mod hash;
 mod id;
 mod kdf;
 mod key_file;
+mod presale;
 mod version;
 
 pub use self::cipher::{Cipher, CipherSer, CipherSerParams, Aes128Ctr};
 pub use self::crypto::Crypto;
 pub use self::error::Error;
-pub use self::hash::{H128, H160, H256};
+pub use self::hash::{H128, H160, H256, H768};
 pub use self::id::UUID;
 pub use self::kdf::{Kdf, KdfSer, Prf, Pbkdf2, Scrypt, KdfSerParams};
 pub use self::key_file::KeyFile;
+pub use self::presale::PresaleWallet;
 pub use self::version::Version;
 
diff --git a/ethstore/src/json/presale.rs b/ethstore/src/json/presale.rs
new file mode 100644
index 000000000..cba50695f
--- /dev/null
+++ b/ethstore/src/json/presale.rs
@@ -0,0 +1,42 @@
+use std::io::Read;
+use serde_json;
+use super::{H160, H768};
+
+#[derive(Debug, PartialEq, Deserialize)]
+pub struct PresaleWallet {
+	pub encseed: H768,
+	#[serde(rename = "ethaddr")]
+	pub address: H160,
+}
+
+impl PresaleWallet {
+	pub fn load<R>(reader: R) -> Result<Self, serde_json::Error> where R: Read {
+		serde_json::from_reader(reader)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::str::FromStr;
+	use serde_json;
+	use json::{PresaleWallet, H160, H768};
+
+	#[test]
+	fn presale_wallet() {
+		let json = r#"
+		{
+			"encseed": "137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066",
+			"ethaddr": "ede84640d1a1d3e06902048e67aa7db8d52c2ce1",
+			"email": "123@gmail.com",
+			"btcaddr": "1JvqEc6WLhg6GnyrLBe2ztPAU28KRfuseH"
+		} "#;
+
+		let expected = PresaleWallet {
+			encseed: H768::from_str("137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066").unwrap(),
+			address: H160::from_str("ede84640d1a1d3e06902048e67aa7db8d52c2ce1").unwrap(),
+		};
+
+		let wallet: PresaleWallet = serde_json::from_str(json).unwrap();
+		assert_eq!(expected, wallet);
+	}
+}
diff --git a/ethstore/src/lib.rs b/ethstore/src/lib.rs
index 19f1c4806..90bb367fa 100644
--- a/ethstore/src/lib.rs
+++ b/ethstore/src/lib.rs
@@ -37,6 +37,7 @@ mod crypto;
 mod error;
 mod ethstore;
 mod import;
+mod presale;
 mod random;
 mod secret_store;
 
diff --git a/ethstore/src/presale.rs b/ethstore/src/presale.rs
new file mode 100644
index 000000000..aad19b15c
--- /dev/null
+++ b/ethstore/src/presale.rs
@@ -0,0 +1,53 @@
+use rcrypto::pbkdf2::pbkdf2;
+use rcrypto::sha2::Sha256;
+use rcrypto::hmac::Hmac;
+use json::PresaleWallet;
+use ethkey::{Address, Secret, KeyPair};
+use crypto::Keccak256;
+use {crypto, Error};
+
+fn decrypt_presale_wallet(wallet: &PresaleWallet, password: &str) -> Result<KeyPair, Error> {
+	let mut iv = [0u8; 16];
+	iv.copy_from_slice(&wallet.encseed[..16]);
+
+	let mut ciphertext = [0u8; 80];
+	ciphertext.copy_from_slice(&wallet.encseed[16..]);
+
+	let mut h_mac = Hmac::new(Sha256::new(), password.as_bytes());
+	let mut derived_key = vec![0u8; 16];
+	pbkdf2(&mut h_mac, password.as_bytes(), 2000, &mut derived_key);
+
+	let mut key = [0u8; 64];
+	crypto::aes::decrypt_cbc(&derived_key, &iv, &ciphertext, &mut key);
+
+	let secret = Secret::from(key.keccak256());
+	if let Ok(kp) = KeyPair::from_secret(secret) {
+		if kp.address() == Address::from(&wallet.address) {
+			return Ok(kp)
+		}
+	}
+
+	Err(Error::InvalidPassword)
+}
+
+#[cfg(test)]
+mod tests {
+	use ethkey::{KeyPair, Address};
+	use super::decrypt_presale_wallet;
+	use json::PresaleWallet;
+
+	#[test]
+	fn test() {
+		let json = r#"
+		{
+			"encseed": "137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066",
+			"ethaddr": "ede84640d1a1d3e06902048e67aa7db8d52c2ce1",
+			"email": "123@gmail.com",
+			"btcaddr": "1JvqEc6WLhg6GnyrLBe2ztPAU28KRfuseH"
+		} "#;
+
+		let wallet = PresaleWallet::load(json.as_bytes()).unwrap();
+		let kp = decrypt_presale_wallet(&wallet, "123").unwrap();
+		assert_eq!(kp.address(), Address::from(wallet.address));
+	}
+}

From a8a731ba11fee703516bc3aaaac1cfa9776873f5 Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Tue, 21 Jun 2016 13:30:32 +0200
Subject: [PATCH 03/22] PresaleWallet data structure

---
 ethstore/src/lib.rs     |  1 +
 ethstore/src/presale.rs | 71 ++++++++++++++++++++++++++++-------------
 2 files changed, 50 insertions(+), 22 deletions(-)

diff --git a/ethstore/src/lib.rs b/ethstore/src/lib.rs
index 90bb367fa..96d860db4 100644
--- a/ethstore/src/lib.rs
+++ b/ethstore/src/lib.rs
@@ -45,5 +45,6 @@ pub use self::account::SafeAccount;
 pub use self::error::Error;
 pub use self::ethstore::EthStore;
 pub use self::import::import_accounts;
+pub use self::presale::PresaleWallet;
 pub use self::secret_store::SecretStore;
 
diff --git a/ethstore/src/presale.rs b/ethstore/src/presale.rs
index aad19b15c..5ba57b8d4 100644
--- a/ethstore/src/presale.rs
+++ b/ethstore/src/presale.rs
@@ -1,40 +1,66 @@
+use std::fs;
+use std::path::Path;
 use rcrypto::pbkdf2::pbkdf2;
 use rcrypto::sha2::Sha256;
 use rcrypto::hmac::Hmac;
-use json::PresaleWallet;
+use json;
 use ethkey::{Address, Secret, KeyPair};
 use crypto::Keccak256;
 use {crypto, Error};
 
-fn decrypt_presale_wallet(wallet: &PresaleWallet, password: &str) -> Result<KeyPair, Error> {
-	let mut iv = [0u8; 16];
-	iv.copy_from_slice(&wallet.encseed[..16]);
+pub struct PresaleWallet {
+	iv: [u8; 16],
+	ciphertext: [u8; 80],
+	address: Address,
+}
 
-	let mut ciphertext = [0u8; 80];
-	ciphertext.copy_from_slice(&wallet.encseed[16..]);
+impl From<json::PresaleWallet> for PresaleWallet {
+	fn from(wallet: json::PresaleWallet) -> Self {
+		let mut iv = [0u8; 16];
+		iv.copy_from_slice(&wallet.encseed[..16]);
 
-	let mut h_mac = Hmac::new(Sha256::new(), password.as_bytes());
-	let mut derived_key = vec![0u8; 16];
-	pbkdf2(&mut h_mac, password.as_bytes(), 2000, &mut derived_key);
+		let mut ciphertext = [0u8; 80];
+		ciphertext.copy_from_slice(&wallet.encseed[16..]);
 
-	let mut key = [0u8; 64];
-	crypto::aes::decrypt_cbc(&derived_key, &iv, &ciphertext, &mut key);
-
-	let secret = Secret::from(key.keccak256());
-	if let Ok(kp) = KeyPair::from_secret(secret) {
-		if kp.address() == Address::from(&wallet.address) {
-			return Ok(kp)
+		PresaleWallet {
+			iv: iv,
+			ciphertext: ciphertext,
+			address: Address::from(wallet.address),
 		}
 	}
+}
 
-	Err(Error::InvalidPassword)
+impl PresaleWallet {
+	pub fn open<P>(path: P) -> Result<Self, Error> where P: AsRef<Path> {
+		let file = try!(fs::File::open(path));
+		let presale = json::PresaleWallet::load(file).unwrap();
+		Ok(PresaleWallet::from(presale))
+	}
+
+	pub fn decrypt(&self, password: &str) -> Result<KeyPair, Error> {
+		let mut h_mac = Hmac::new(Sha256::new(), password.as_bytes());
+		let mut derived_key = vec![0u8; 16];
+		pbkdf2(&mut h_mac, password.as_bytes(), 2000, &mut derived_key);
+
+		let mut key = [0u8; 64];
+		crypto::aes::decrypt_cbc(&derived_key, &self.iv, &self.ciphertext, &mut key);
+
+		let secret = Secret::from(key.keccak256());
+		if let Ok(kp) = KeyPair::from_secret(secret) {
+			if kp.address() == self.address {
+				return Ok(kp)
+			}
+		}
+
+		Err(Error::InvalidPassword)
+	}
 }
 
 #[cfg(test)]
 mod tests {
-	use ethkey::{KeyPair, Address};
-	use super::decrypt_presale_wallet;
-	use json::PresaleWallet;
+	use ethkey::Address;
+	use super::PresaleWallet;
+	use json;
 
 	#[test]
 	fn test() {
@@ -46,8 +72,9 @@ mod tests {
 			"btcaddr": "1JvqEc6WLhg6GnyrLBe2ztPAU28KRfuseH"
 		} "#;
 
-		let wallet = PresaleWallet::load(json.as_bytes()).unwrap();
-		let kp = decrypt_presale_wallet(&wallet, "123").unwrap();
+		let wallet = json::PresaleWallet::load(json.as_bytes()).unwrap();
+		let wallet = PresaleWallet::from(wallet);
+		let kp = wallet.decrypt("123").unwrap();
 		assert_eq!(kp.address(), Address::from(wallet.address));
 	}
 }

From be03a6acbdaa58d884c6fb454e38178af68a8ed8 Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Tue, 21 Jun 2016 15:04:36 +0200
Subject: [PATCH 04/22] import-wallet option for ethstore executable

---
 ethstore/README.md           | 15 +++++++++++++++
 ethstore/src/bin/ethstore.rs | 11 ++++++++++-
 ethstore/src/crypto.rs       |  7 ++++---
 ethstore/src/ethkey.rs       |  8 --------
 ethstore/src/presale.rs      |  2 +-
 5 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/ethstore/README.md b/ethstore/README.md
index aba4911bf..0cf50f454 100644
--- a/ethstore/README.md
+++ b/ethstore/README.md
@@ -20,6 +20,7 @@ Usage:
     ethstore change-pwd <address> <old-pwd> <new-pwd> [--dir DIR]
     ethstore list [--dir DIR]
     ethstore import [--src DIR] [--dir DIR]
+    ethstore import-wallet <path> <password> [--dir DIR]
     ethstore remove <address> <password> [--dir DIR]
     ethstore sign <address> <password> <message> [--dir DIR]
     ethstore [-h | --help]
@@ -38,6 +39,7 @@ Commands:
     change-pwd         Change account password.
     list               List accounts.
     import             Import accounts from src.
+    import-wallet      Import presale wallet.
     remove             Remove account.
     sign               Sign message.
 ```
@@ -119,6 +121,19 @@ ethstore list
 
 --
 
+#### `import-wallet <path> <password> [--dir DIR]`
+*Import account from presale wallet.*
+
+- `<path>` - presale wallet path
+- `<password>` - account password, any string
+- `[--dir DIR]` - secret store directory, It may be either parity, parity-test, geth, geth-test or a path. default: parity
+
+```
+e6a3d25a7cb7cd21cb720df5b5e8afd154af1bbb
+```
+
+--
+
 #### `remove <address> <password> [--dir DIR]`
 *Remove account from secret store.*
 
diff --git a/ethstore/src/bin/ethstore.rs b/ethstore/src/bin/ethstore.rs
index 6020679d4..948d7a76e 100644
--- a/ethstore/src/bin/ethstore.rs
+++ b/ethstore/src/bin/ethstore.rs
@@ -24,7 +24,7 @@ use std::str::FromStr;
 use docopt::Docopt;
 use ethstore::ethkey::{Secret, Address, Message};
 use ethstore::dir::{KeyDirectory, ParityDirectory, DiskDirectory, GethDirectory, DirectoryType};
-use ethstore::{EthStore, SecretStore, import_accounts, Error};
+use ethstore::{EthStore, SecretStore, import_accounts, Error, PresaleWallet};
 
 pub const USAGE: &'static str = r#"
 Ethereum key management.
@@ -35,6 +35,7 @@ Usage:
     ethstore change-pwd <address> <old-pwd> <new-pwd> [--dir DIR]
     ethstore list [--dir DIR]
     ethstore import [--src DIR] [--dir DIR]
+    ethstore import-wallet <path> <password> [--dir DIR]
     ethstore remove <address> <password> [--dir DIR]
     ethstore sign <address> <password> <message> [--dir DIR]
     ethstore [-h | --help]
@@ -53,6 +54,7 @@ Commands:
     change-pwd         Change password.
     list               List accounts.
     import             Import accounts from src.
+    import-wallet      Import presale wallet.
     remove             Remove account.
     sign               Sign message.
 "#;
@@ -63,6 +65,7 @@ struct Args {
 	cmd_change_pwd: bool,
 	cmd_list: bool,
 	cmd_import: bool,
+	cmd_import_wallet: bool,
 	cmd_remove: bool,
 	cmd_sign: bool,
 	arg_secret: String,
@@ -71,6 +74,7 @@ struct Args {
 	arg_new_pwd: String,
 	arg_address: String,
 	arg_message: String,
+	arg_path: String,
 	flag_src: String,
 	flag_dir: String,
 }
@@ -128,6 +132,11 @@ fn execute<S, I>(command: I) -> Result<String, Error> where I: IntoIterator<Item
 		let dst = try!(key_dir(&args.flag_dir));
 		let accounts = try!(import_accounts(src.deref(), dst.deref()));
 		Ok(format_accounts(&accounts))
+	} else if args.cmd_import_wallet {
+		let wallet = try!(PresaleWallet::open(&args.arg_path));
+		let kp = try!(wallet.decrypt(&args.arg_password));
+		let address = try!(store.insert_account(kp.secret().clone(), &args.arg_password));
+		Ok(format!("{}", address))
 	} else if args.cmd_remove {
 		let address = try!(Address::from_str(&args.arg_address));
 		let ok = store.remove_account(&address, &args.arg_password).is_ok();
diff --git a/ethstore/src/crypto.rs b/ethstore/src/crypto.rs
index 2733fa720..d8169c9c3 100644
--- a/ethstore/src/crypto.rs
+++ b/ethstore/src/crypto.rs
@@ -67,7 +67,7 @@ impl Keccak256<[u8; 32]> for [u8] {
 pub mod aes {
 	use rcrypto::blockmodes::{CtrMode, CbcDecryptor, PkcsPadding};
 	use rcrypto::aessafe::{AesSafe128Encryptor, AesSafe128Decryptor};
-	use rcrypto::symmetriccipher::{Encryptor, Decryptor};
+	use rcrypto::symmetriccipher::{Encryptor, Decryptor, SymmetricCipherError};
 	use rcrypto::buffer::{RefReadBuffer, RefWriteBuffer};
 
 	/// Encrypt a message
@@ -83,9 +83,10 @@ pub mod aes {
 	}
 
 	/// Decrypt a message using cbc mode
-	pub fn decrypt_cbc(k: &[u8], iv: &[u8], encrypted: &[u8], dest: &mut [u8]) {
+	pub fn decrypt_cbc(k: &[u8], iv: &[u8], encrypted: &[u8], dest: &mut [u8]) -> Result<(), SymmetricCipherError> {
 		let mut encryptor = CbcDecryptor::new(AesSafe128Decryptor::new(k), PkcsPadding, iv.to_vec());
-		encryptor.decrypt(&mut RefReadBuffer::new(encrypted), &mut RefWriteBuffer::new(dest), true).expect("Invalid length or padding");
+		try!(encryptor.decrypt(&mut RefReadBuffer::new(encrypted), &mut RefWriteBuffer::new(dest), true));
+		Ok(())
 	}
 
 }
diff --git a/ethstore/src/ethkey.rs b/ethstore/src/ethkey.rs
index 9d8858b79..eba877397 100644
--- a/ethstore/src/ethkey.rs
+++ b/ethstore/src/ethkey.rs
@@ -31,11 +31,3 @@ impl From<json::H160> for Address {
 		From::from(a)
 	}
 }
-
-impl<'a> From<&'a json::H160> for Address {
-	fn from(json: &'a json::H160) -> Self {
-		let mut a = [0u8; 20];
-		a.copy_from_slice(json);
-		From::from(a)
-	}
-}
diff --git a/ethstore/src/presale.rs b/ethstore/src/presale.rs
index 5ba57b8d4..8c8172473 100644
--- a/ethstore/src/presale.rs
+++ b/ethstore/src/presale.rs
@@ -43,7 +43,7 @@ impl PresaleWallet {
 		pbkdf2(&mut h_mac, password.as_bytes(), 2000, &mut derived_key);
 
 		let mut key = [0u8; 64];
-		crypto::aes::decrypt_cbc(&derived_key, &self.iv, &self.ciphertext, &mut key);
+		try!(crypto::aes::decrypt_cbc(&derived_key, &self.iv, &self.ciphertext, &mut key).map_err(|_| Error::InvalidPassword));
 
 		let secret = Secret::from(key.keccak256());
 		if let Ok(kp) = KeyPair::from_secret(secret) {

From 7136cd7057b2ea42910fd24fc718c1e2c91073f4 Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Tue, 21 Jun 2016 15:07:15 +0200
Subject: [PATCH 05/22] improved import wallet test

---
 ethstore/src/presale.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/ethstore/src/presale.rs b/ethstore/src/presale.rs
index 8c8172473..09c86abea 100644
--- a/ethstore/src/presale.rs
+++ b/ethstore/src/presale.rs
@@ -58,7 +58,6 @@ impl PresaleWallet {
 
 #[cfg(test)]
 mod tests {
-	use ethkey::Address;
 	use super::PresaleWallet;
 	use json;
 
@@ -74,7 +73,7 @@ mod tests {
 
 		let wallet = json::PresaleWallet::load(json.as_bytes()).unwrap();
 		let wallet = PresaleWallet::from(wallet);
-		let kp = wallet.decrypt("123").unwrap();
-		assert_eq!(kp.address(), Address::from(wallet.address));
+		assert!(wallet.decrypt("123").is_ok());
+		assert!(wallet.decrypt("124").is_err());
 	}
 }

From bbe5cd001a1663e544237b83c7528eb7be5e9b3b Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Tue, 21 Jun 2016 17:50:22 +0200
Subject: [PATCH 06/22] presale wallet cli for parity

---
 parity/cli.rs  |  2 ++
 parity/main.rs | 29 +++++++++++++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/parity/cli.rs b/parity/cli.rs
index 507137f8b..d8effec88 100644
--- a/parity/cli.rs
+++ b/parity/cli.rs
@@ -25,6 +25,7 @@ Usage:
   parity daemon <pid-file> [options]
   parity account (new | list ) [options]
   parity account import <path>... [options]
+  parity wallet import <path> --password FILE [options]
   parity import [ <file> ] [options]
   parity export [ <file> ] [options]
   parity signer new-token [options]
@@ -215,6 +216,7 @@ Miscellaneous Options:
 pub struct Args {
 	pub cmd_daemon: bool,
 	pub cmd_account: bool,
+	pub cmd_wallet: bool,
 	pub cmd_new: bool,
 	pub cmd_list: bool,
 	pub cmd_export: bool,
diff --git a/parity/main.rs b/parity/main.rs
index a44cdf6d3..b610e3025 100644
--- a/parity/main.rs
+++ b/parity/main.rs
@@ -129,6 +129,11 @@ fn execute(conf: Configuration) {
 		return;
 	}
 
+	if conf.args.cmd_wallet {
+		execute_wallet_cli(conf);
+		return;
+	}
+
 	if conf.args.cmd_export {
 		execute_export(conf);
 		return;
@@ -534,6 +539,30 @@ fn execute_account_cli(conf: Configuration) {
 	}
 }
 
+fn execute_wallet_cli(conf: Configuration) {
+	use ethcore::ethstore::{PresaleWallet, SecretStore, EthStore};
+	use ethcore::ethstore::dir::DiskDirectory;
+	use ethcore::account_provider::AccountProvider;
+
+	let wallet_path = conf.args.arg_path.first().unwrap();
+	let filename = conf.args.flag_password.first().unwrap();
+	let mut file = File::open(filename).unwrap_or_else(|_| die!("{} Unable to read password file.", filename));
+	let mut file_content = String::new();
+	file.read_to_string(&mut file_content).unwrap_or_else(|_| die!("{} Unable to read password file.", filename));
+
+	let dir = Box::new(DiskDirectory::create(conf.keys_path()).unwrap());
+	let iterations = conf.keys_iterations();
+	let store = AccountProvider::new(Box::new(EthStore::open_with_iterations(dir, iterations).unwrap()));
+
+	// remove eof
+	let pass = &file_content[..file_content.len() - 1];
+	let wallet = PresaleWallet::open(wallet_path).unwrap_or_else(|_| die!("Unable to open presale wallet."));
+	let kp = wallet.decrypt(pass).unwrap_or_else(|_| die!("Invalid password"));
+	let address = store.insert_account(kp.secret().clone(), pass).unwrap();
+
+	println!("Imported account: {}", address);
+}
+
 fn wait_for_exit(
 	panic_handler: Arc<PanicHandler>,
 	_rpc_server: Option<RpcServer>,

From 9547324b464e5680afa7e88c4fc488bea2fa5fef Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Wed, 22 Jun 2016 17:02:40 +0200
Subject: [PATCH 07/22] ethstore cli loads passwords from files

---
 ethstore/README.md           | 28 ++++++++++++++++++----------
 ethstore/src/bin/ethstore.rs | 30 +++++++++++++++++++++++-------
 2 files changed, 41 insertions(+), 17 deletions(-)

diff --git a/ethstore/README.md b/ethstore/README.md
index 0cf50f454..0b85d99b4 100644
--- a/ethstore/README.md
+++ b/ethstore/README.md
@@ -50,11 +50,11 @@ Commands:
 *Encrypt secret with a password and save it in secret store.*
 
 - `<secret>` - ethereum secret, 32 bytes long
-- `<password>` - account password, any string
+- `<password>` - account password, file path
 - `[--dir DIR]` - secret store directory, It may be either parity, parity-test, geth, geth-test or a path. default: parity
 
 ```
-ethstore insert 7d29fab185a33e2cd955812397354c472d2b84615b645aa135ff539f6b0d70d5 "this is sparta"
+ethstore insert 7d29fab185a33e2cd955812397354c472d2b84615b645aa135ff539f6b0d70d5 password.txt
 ```
 
 ```
@@ -77,12 +77,12 @@ ethstore insert `ethkey generate random -s` "this is sparta"
 *Change account password.*
 
 - `<address>` - ethereum address, 20 bytes long
-- `<old-pwd>` - old account password, any string
-- `<new-pwd>` - new account password, any string
+- `<old-pwd>` - old account password, file path
+- `<new-pwd>` - new account password, file path
 - `[--dir DIR]` - secret store directory, It may be either parity, parity-test, geth, geth-test or a path. default: parity
 
 ```
-ethstore change-pwd a8fa5dd30a87bb9e3288d604eb74949c515ab66e "this is sparta" "hello world"
+ethstore change-pwd a8fa5dd30a87bb9e3288d604eb74949c515ab66e old_pwd.txt new_pwd.txt
 ```
 
 ```
@@ -114,6 +114,10 @@ ethstore list
 - `[--src DIR]` - secret store directory, It may be either parity, parity-test, geth, geth-test or a path. default: geth
 - `[--dir DIR]` - secret store directory, It may be either parity, parity-test, geth, geth-test or a path. default: parity
 
+```
+ethstore import
+```
+
 ```
  0: e6a3d25a7cb7cd21cb720df5b5e8afd154af1bbb
  1: 6edddfc6349aff20bc6467ccf276c5b52487f7a8
@@ -125,9 +129,13 @@ ethstore list
 *Import account from presale wallet.*
 
 - `<path>` - presale wallet path
-- `<password>` - account password, any string
+- `<password>` - account password, file path
 - `[--dir DIR]` - secret store directory, It may be either parity, parity-test, geth, geth-test or a path. default: parity
 
+```
+ethstore import-wallet ethwallet.json password.txt
+```
+
 ```
 e6a3d25a7cb7cd21cb720df5b5e8afd154af1bbb
 ```
@@ -138,11 +146,11 @@ e6a3d25a7cb7cd21cb720df5b5e8afd154af1bbb
 *Remove account from secret store.*
 
 - `<address>` - ethereum address, 20 bytes long
-- `<password>` - account password, any string
+- `<password>` - account password, file path
 - `[--dir DIR]` - secret store directory, It may be either parity, parity-test, geth, geth-test or a path. default: parity
 
 ```
-ethstore remove a8fa5dd30a87bb9e3288d604eb74949c515ab66e "hello world"
+ethstore remove a8fa5dd30a87bb9e3288d604eb74949c515ab66e password.txt
 ```
 
 ```
@@ -155,12 +163,12 @@ true
 *Sign message with account's secret.*
 
 - `<address>` - ethereum address, 20 bytes long
-- `<password>` - account password, any string
+- `<password>` - account password, file path
 - `<message>` - message to sign, 32 bytes long
 - `[--dir DIR]` - secret store directory, It may be either parity, parity-test, geth, geth-test or a path. default: parity
 
 ```
-ethstore sign 24edfff680d536a5f6fe862d36df6f8f6f40f115 "this is sparta" 7d29fab185a33e2cd955812397354c472d2b84615b645aa135ff539f6b0d70d5
+ethstore sign 24edfff680d536a5f6fe862d36df6f8f6f40f115 password.txt 7d29fab185a33e2cd955812397354c472d2b84615b645aa135ff539f6b0d70d5
 ```
 
 ```
diff --git a/ethstore/src/bin/ethstore.rs b/ethstore/src/bin/ethstore.rs
index 948d7a76e..5683a8116 100644
--- a/ethstore/src/bin/ethstore.rs
+++ b/ethstore/src/bin/ethstore.rs
@@ -18,7 +18,8 @@ extern crate rustc_serialize;
 extern crate docopt;
 extern crate ethstore;
 
-use std::{env, process};
+use std::{env, process, fs};
+use std::io::Read;
 use std::ops::Deref;
 use std::str::FromStr;
 use docopt::Docopt;
@@ -109,6 +110,15 @@ fn format_accounts(accounts: &[Address]) -> String {
 		.join("\n")
 }
 
+fn load_password(path: &str) -> Result<String, Error> {
+	let mut file = try!(fs::File::open(path));
+	let mut password = String::new();
+	try!(file.read_to_string(&mut password));
+	// drop EOF
+	let _ = password.pop();
+	Ok(password)
+}
+
 fn execute<S, I>(command: I) -> Result<String, Error> where I: IntoIterator<Item=S>, S: AsRef<str> {
 	let args: Args = Docopt::new(USAGE)
 		.and_then(|d| d.argv(command).decode())
@@ -118,11 +128,14 @@ fn execute<S, I>(command: I) -> Result<String, Error> where I: IntoIterator<Item
 
 	return if args.cmd_insert {
 		let secret = try!(Secret::from_str(&args.arg_secret));
-		let address = try!(store.insert_account(secret, &args.arg_password));
+		let password = try!(load_password(&args.arg_password));
+		let address = try!(store.insert_account(secret, &password));
 		Ok(format!("{}", address))
 	} else if args.cmd_change_pwd {
 		let address = try!(Address::from_str(&args.arg_address));
-		let ok = store.change_password(&address, &args.arg_old_pwd, &args.arg_new_pwd).is_ok();
+		let old_pwd = try!(load_password(&args.arg_old_pwd));
+		let new_pwd = try!(load_password(&args.arg_new_pwd));
+		let ok = store.change_password(&address, &old_pwd, &new_pwd).is_ok();
 		Ok(format!("{}", ok))
 	} else if args.cmd_list {
 		let accounts = store.accounts();
@@ -134,17 +147,20 @@ fn execute<S, I>(command: I) -> Result<String, Error> where I: IntoIterator<Item
 		Ok(format_accounts(&accounts))
 	} else if args.cmd_import_wallet {
 		let wallet = try!(PresaleWallet::open(&args.arg_path));
-		let kp = try!(wallet.decrypt(&args.arg_password));
-		let address = try!(store.insert_account(kp.secret().clone(), &args.arg_password));
+		let password = try!(load_password(&args.arg_password));
+		let kp = try!(wallet.decrypt(&password));
+		let address = try!(store.insert_account(kp.secret().clone(), &password));
 		Ok(format!("{}", address))
 	} else if args.cmd_remove {
 		let address = try!(Address::from_str(&args.arg_address));
-		let ok = store.remove_account(&address, &args.arg_password).is_ok();
+		let password = try!(load_password(&args.arg_password));
+		let ok = store.remove_account(&address, &password).is_ok();
 		Ok(format!("{}", ok))
 	} else if args.cmd_sign {
 		let address = try!(Address::from_str(&args.arg_address));
 		let message = try!(Message::from_str(&args.arg_message));
-		let signature = try!(store.sign(&address, &args.arg_password, &message));
+		let password = try!(load_password(&args.arg_password));
+		let signature = try!(store.sign(&address, &password, &message));
 		Ok(format!("{}", signature))
 	} else {
 		unreachable!();

From 5302a7dd58265728f230d14bb1358a90ec1d2497 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@ethcore.io>
Date: Wed, 22 Jun 2016 19:49:07 +0200
Subject: [PATCH 08/22] Ensure judging the SF trigger by relative branch

Rather than just the canon chain.
---
 ethcore/src/client/client.rs |  6 +++---
 ethcore/src/client/mod.rs    | 16 +++++++++++++---
 ethcore/src/miner/miner.rs   |  2 +-
 3 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs
index fa063cd61..693296469 100644
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@@ -230,7 +230,7 @@ impl<V> Client<V> where V: Verifier {
 		let last_hashes = self.build_last_hashes(header.parent_hash.clone());
 		let db = self.state_db.lock().unwrap().boxed_clone();
 
-		let enact_result = enact_verified(&block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, self.dao_rescue_block_gas_limit(), &self.vm_factory);
+		let enact_result = enact_verified(&block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, self.dao_rescue_block_gas_limit(header.parent_hash.clone()), &self.vm_factory);
 		if let Err(e) = enact_result {
 			warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
 			return Err(());
@@ -486,7 +486,7 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 			last_hashes: last_hashes,
 			gas_used: U256::zero(),
 			gas_limit: U256::max_value(),
-			dao_rescue_block_gas_limit: self.dao_rescue_block_gas_limit(),
+			dao_rescue_block_gas_limit: self.dao_rescue_block_gas_limit(view.parent_hash()),
 		};
 		// that's just a copy of the state.
 		let mut state = self.state();
@@ -808,7 +808,7 @@ impl<V> MiningBlockChainClient for Client<V> where V: Verifier {
 			self.state_db.lock().unwrap().boxed_clone(),
 			&self.chain.block_header(&h).expect("h is best block hash: so it's header must exist: qed"),
 			self.build_last_hashes(h.clone()),
-			self.dao_rescue_block_gas_limit(),
+			self.dao_rescue_block_gas_limit(h.clone()),
 			author,
 			gas_floor_target,
 			extra_data,
diff --git a/ethcore/src/client/mod.rs b/ethcore/src/client/mod.rs
index c1bc3203c..589b65e16 100644
--- a/ethcore/src/client/mod.rs
+++ b/ethcore/src/client/mod.rs
@@ -227,9 +227,19 @@ pub trait BlockChainClient : Sync + Send {
 
 
 	/// Get `Some` gas limit of block 1_760_000, or `None` if chain is not yet that long.
-	fn dao_rescue_block_gas_limit(&self) -> Option<U256> {
-		self.block_header(BlockID::Number(1_760_000))
-			.map(|header| HeaderView::new(&header).gas_limit())
+	fn dao_rescue_block_gas_limit(&self, chain_hash: H256) -> Option<U256> {
+		if let Some(mut header) = self.block_header(BlockID::Hash(chain_hash)) {
+			if HeaderView::new(&header).number() < 1_760_000 {
+				None
+			} else {
+				while HeaderView::new(&header).number() != 1_760_000 {
+					header = self.block_header(BlockID::Hash(HeaderView::new(&header).parent_hash())).expect("chain is complete; parent of chain entry must be in chain; qed");
+				}
+				Some(HeaderView::new(&header).gas_limit())
+			}
+		} else {
+			None
+		}
 	}	
 }
 
diff --git a/ethcore/src/miner/miner.rs b/ethcore/src/miner/miner.rs
index 41e4b4810..290e94059 100644
--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@@ -274,7 +274,7 @@ impl MinerService for Miner {
 					last_hashes: last_hashes,
 					gas_used: U256::zero(),
 					gas_limit: U256::max_value(),
-					dao_rescue_block_gas_limit: chain.dao_rescue_block_gas_limit(),
+					dao_rescue_block_gas_limit: chain.dao_rescue_block_gas_limit(header.parent_hash().clone()),
 				};
 				// that's just a copy of the state.
 				let mut state = block.state().clone();

From cc7038383a4f895e6d197e092cd89b9209a84ef0 Mon Sep 17 00:00:00 2001
From: NikVolf <nikvolf@gmail.com>
Date: Wed, 22 Jun 2016 20:51:36 +0300
Subject: [PATCH 09/22] rpc api by default for ipc

---
 parity/cli.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/parity/cli.rs b/parity/cli.rs
index 1e77031e2..12d5d6db3 100644
--- a/parity/cli.rs
+++ b/parity/cli.rs
@@ -55,7 +55,7 @@ Account Options:
                            ACCOUNTS is a comma-delimited list of addresses.
   --password FILE          Provide a file containing a password for unlocking
                            an account.
-  --keys-iterations NUM    Specify the number of iterations to use when 
+  --keys-iterations NUM    Specify the number of iterations to use when
                            deriving key from the password (bigger is more
                            secure) [default: 10240].
   --no-import-keys         Do not import keys from legacy clients.
@@ -98,7 +98,7 @@ API and Console Options:
   --ipc-path PATH          Specify custom path for JSON-RPC over IPC service
                            [default: $HOME/.parity/jsonrpc.ipc].
   --ipc-apis APIS          Specify custom API set available via JSON-RPC over
-                           IPC [default: web3,eth,net,ethcore,personal,traces].
+                           IPC [default: web3,eth,net,ethcore,personal,traces,rpc].
 
   --dapps-off              Disable the Dapps server (e.g. status page).
   --dapps-port PORT        Specify the port portion of the Dapps server

From d53306382d4fbdd1542a245f771afe02a80eb9a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= <tomusdrw@users.noreply.github.com>
Date: Wed, 22 Jun 2016 19:52:18 +0200
Subject: [PATCH 10/22] Removing signer connection limit (#1396)

---
 signer/src/ws_server/mod.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/signer/src/ws_server/mod.rs b/signer/src/ws_server/mod.rs
index beffbd2f7..b6b7c15f7 100644
--- a/signer/src/ws_server/mod.rs
+++ b/signer/src/ws_server/mod.rs
@@ -93,7 +93,6 @@ impl Server {
 		let config = {
 			let mut config = ws::Settings::default();
 			// It's also used for handling min-sysui requests (browser can make many of them in paralel)
-			config.max_connections = 15;
 			config.method_strict = true;
 			// Was shutting down server when suspending on linux:
 			config.shutdown_on_interrupt = false;

From e346cbc7f92db44917995f8cc6eca2c0ad5e1702 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@ethcore.io>
Date: Wed, 22 Jun 2016 21:32:17 +0200
Subject: [PATCH 11/22] Make --signer default. (#1392)

---
 parity/cli.rs           | 4 ++--
 parity/configuration.rs | 6 +++---
 parity/main.rs          | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/parity/cli.rs b/parity/cli.rs
index 144e2e51c..7192cc9ce 100644
--- a/parity/cli.rs
+++ b/parity/cli.rs
@@ -116,7 +116,7 @@ API and Console Options:
   --dapps-path PATH        Specify directory where dapps should be installed.
                            [default: $HOME/.parity/dapps]
 
-  --signer                 Enable Trusted Signer WebSocket endpoint used by
+  --signer-off             Disable Trusted Signer WebSocket endpoint used by
                            Signer UIs.
   --signer-port PORT       Specify the port of Trusted Signer server
                            [default: 8180].
@@ -274,7 +274,7 @@ pub struct Args {
 	pub flag_dapps_user: Option<String>,
 	pub flag_dapps_pass: Option<String>,
 	pub flag_dapps_path: String,
-	pub flag_signer: bool,
+	pub flag_signer_off: bool,
 	pub flag_signer_port: u16,
 	pub flag_signer_path: String,
 	pub flag_no_token: bool,
diff --git a/parity/configuration.rs b/parity/configuration.rs
index 94835a8a9..4196564b5 100644
--- a/parity/configuration.rs
+++ b/parity/configuration.rs
@@ -432,10 +432,10 @@ impl Configuration {
 	}
 
 	pub fn signer_port(&self) -> Option<u16> {
-		if self.args.flag_signer {
-			Some(self.args.flag_signer_port)
-		} else {
+		if self.args.flag_signer_off {
 			None
+		} else {
+			Some(self.args.flag_signer_port)
 		}
 	}
 }
diff --git a/parity/main.rs b/parity/main.rs
index b610e3025..c6960993a 100644
--- a/parity/main.rs
+++ b/parity/main.rs
@@ -192,7 +192,7 @@ fn execute_client(conf: Configuration, spec: Spec, client_config: ClientConfig)
 	let sync_config = conf.sync_config(&spec);
 
 	// Create and display a new token for UIs.
-	if conf.args.flag_signer && !conf.args.flag_no_token {
+	if !conf.args.flag_signer_off && !conf.args.flag_no_token {
 		new_token(conf.directories().signer).unwrap_or_else(|e| {
 			die!("Error generating token: {:?}", e)
 		});

From 9a1e1b7c890903d54a6e82664cc3cd215997dc18 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= <tomusdrw@users.noreply.github.com>
Date: Wed, 22 Jun 2016 21:32:26 +0200
Subject: [PATCH 12/22] Signer with Unlocked Account (#1398)

---
 ethcore/src/account_provider.rs        |  7 ++++
 parity/main.rs                         |  6 ++++
 parity/rpc_apis.rs                     |  2 +-
 rpc/src/v1/impls/eth_signing.rs        | 15 ++++++--
 rpc/src/v1/tests/mocked/eth_signing.rs | 47 ++++++++++++++++++++++++--
 5 files changed, 72 insertions(+), 5 deletions(-)

diff --git a/ethcore/src/account_provider.rs b/ethcore/src/account_provider.rs
index 6744c6bd2..a71251727 100644
--- a/ethcore/src/account_provider.rs
+++ b/ethcore/src/account_provider.rs
@@ -205,6 +205,13 @@ impl AccountProvider {
 		self.unlock_account(account, password, Unlock::Temp)
 	}
 
+	/// 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();
+		unlocked.get(&account).is_some()
+	}
+
 	/// Signs the message. Account must be unlocked.
 	pub fn sign<A, M>(&self, account: A, message: M) -> Result<H520, Error> where Address: From<A>, Message: From<M> {
 		let account = Address::from(account).into();
diff --git a/parity/main.rs b/parity/main.rs
index c6960993a..17d941a5d 100644
--- a/parity/main.rs
+++ b/parity/main.rs
@@ -198,6 +198,12 @@ fn execute_client(conf: Configuration, spec: Spec, client_config: ClientConfig)
 		});
 	}
 
+	// Display warning about using unlock with signer
+	if conf.args.flag_signer && conf.args.flag_unlock.is_some() {
+		warn!("Using Trusted Signer and --unlock is not recommended!");
+		warn!("NOTE that Signer will not ask you to confirm transactions from unlocked account.");
+	}
+
 	// Secret Store
 	let account_service = Arc::new(conf.account_service());
 
diff --git a/parity/rpc_apis.rs b/parity/rpc_apis.rs
index 22520f266..c0daaa926 100644
--- a/parity/rpc_apis.rs
+++ b/parity/rpc_apis.rs
@@ -150,7 +150,7 @@ pub fn setup_rpc<T: Extendable>(server: T, deps: Arc<Dependencies>, apis: ApiSet
 				server.add_delegate(EthFilterClient::new(&deps.client, &deps.miner).to_delegate());
 
 				if deps.signer_port.is_some() {
-					server.add_delegate(EthSigningQueueClient::new(&deps.signer_queue, &deps.client, &deps.miner).to_delegate());
+					server.add_delegate(EthSigningQueueClient::new(&deps.signer_queue, &deps.client, &deps.miner, &deps.secret_store).to_delegate());
 				} else {
 					server.add_delegate(EthSigningUnsafeClient::new(&deps.client, &deps.secret_store, &deps.miner).to_delegate());
 				}
diff --git a/rpc/src/v1/impls/eth_signing.rs b/rpc/src/v1/impls/eth_signing.rs
index c5103fd2d..700c679d6 100644
--- a/rpc/src/v1/impls/eth_signing.rs
+++ b/rpc/src/v1/impls/eth_signing.rs
@@ -43,15 +43,17 @@ fn fill_optional_fields<C, M>(request: &mut TransactionRequest, client: &C, mine
 /// Implementation of functions that require signing when no trusted signer is used.
 pub struct EthSigningQueueClient<C, M> where C: MiningBlockChainClient, M: MinerService {
 	queue: Weak<ConfirmationsQueue>,
+	accounts: Weak<AccountProvider>,
 	client: Weak<C>,
 	miner: Weak<M>,
 }
 
 impl<C, M> EthSigningQueueClient<C, M> where C: MiningBlockChainClient, M: MinerService {
 	/// Creates a new signing queue client given shared signing queue.
-	pub fn new(queue: &Arc<ConfirmationsQueue>, client: &Arc<C>, miner: &Arc<M>) -> Self {
+	pub fn new(queue: &Arc<ConfirmationsQueue>, client: &Arc<C>, miner: &Arc<M>, accounts: &Arc<AccountProvider>) -> Self {
 		EthSigningQueueClient {
 			queue: Arc::downgrade(queue),
+			accounts: Arc::downgrade(accounts),
 			client: Arc::downgrade(client),
 			miner: Arc::downgrade(miner),
 		}
@@ -71,9 +73,18 @@ impl<C, M> EthSigning for EthSigningQueueClient<C, M>
 	fn send_transaction(&self, params: Params) -> Result<Value, Error> {
 		from_params::<(TransactionRequest, )>(params)
 			.and_then(|(mut request, )| {
-				let queue = take_weak!(self.queue);
+				let accounts = take_weak!(self.accounts);
 				let (client, miner) = (take_weak!(self.client), take_weak!(self.miner));
 
+				if accounts.is_unlocked(request.from) {
+					let sender = request.from;
+					return match sign_and_dispatch(&*client, &*miner, request, &*accounts, sender) {
+						Ok(hash) => to_value(&hash),
+						_ => to_value(&H256::zero()),
+					}
+				}
+
+				let queue = take_weak!(self.queue);
 				fill_optional_fields(&mut request, &*client, &*miner);
 				let id = queue.add_request(request);
 				let result = id.wait_with_timeout();
diff --git a/rpc/src/v1/tests/mocked/eth_signing.rs b/rpc/src/v1/tests/mocked/eth_signing.rs
index a2755ce18..5f3e75d35 100644
--- a/rpc/src/v1/tests/mocked/eth_signing.rs
+++ b/rpc/src/v1/tests/mocked/eth_signing.rs
@@ -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/>.
 
+use std::str::FromStr;
 use std::sync::Arc;
 use jsonrpc_core::IoHandler;
 use v1::impls::EthSigningQueueClient;
@@ -21,12 +22,16 @@ use v1::traits::EthSigning;
 use v1::helpers::{ConfirmationsQueue, SigningQueue};
 use v1::tests::helpers::TestMinerService;
 use util::{Address, FixedHash};
+use util::numbers::{Uint, U256};
+use ethcore::account_provider::AccountProvider;
 use ethcore::client::TestBlockChainClient;
+use ethcore::transaction::{Transaction, Action};
 
 struct EthSigningTester {
 	pub queue: Arc<ConfirmationsQueue>,
 	pub client: Arc<TestBlockChainClient>,
 	pub miner: Arc<TestMinerService>,
+	pub accounts: Arc<AccountProvider>,
 	pub io: IoHandler,
 }
 
@@ -35,13 +40,15 @@ impl Default for EthSigningTester {
 		let queue = Arc::new(ConfirmationsQueue::default());
 		let client = Arc::new(TestBlockChainClient::default());
 		let miner = Arc::new(TestMinerService::default());
+		let accounts = Arc::new(AccountProvider::transient_provider());
 		let io = IoHandler::new();
-		io.add_delegate(EthSigningQueueClient::new(&queue, &client, &miner).to_delegate());
+		io.add_delegate(EthSigningQueueClient::new(&queue, &client, &miner, &accounts).to_delegate());
 
 		EthSigningTester {
 			queue: queue,
 			client: client,
 			miner: miner,
+			accounts: accounts,
 			io: io,
 		}
 	}
@@ -78,5 +85,41 @@ fn should_add_transaction_to_queue() {
 	// then
 	assert_eq!(tester.io.handle_request(&request), Some(response.to_owned()));
 	assert_eq!(tester.queue.requests().len(), 1);
-
+}
+
+#[test]
+fn should_dispatch_transaction_if_account_is_unlocked() {
+	// given
+	let tester = eth_signing();
+	let acc = tester.accounts.new_account("test").unwrap();
+	tester.accounts.unlock_account_permanently(acc, "test".into()).unwrap();
+
+	let t = Transaction {
+		nonce: U256::zero(),
+		gas_price: U256::from(0x9184e72a000u64),
+		gas: U256::from(0x76c0),
+		action: Action::Call(Address::from_str("d46e8dd67c5d32be8058bb8eb970870f07244567").unwrap()),
+		value: U256::from(0x9184e72au64),
+		data: vec![]
+	};
+	let signature = tester.accounts.sign(acc, t.hash()).unwrap();
+	let t = t.with_signature(signature);
+
+	// when
+	let request = r#"{
+		"jsonrpc": "2.0",
+		"method": "eth_sendTransaction",
+		"params": [{
+			"from": ""#.to_owned() + format!("0x{:?}", acc).as_ref() + r#"",
+			"to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
+			"gas": "0x76c0",
+			"gasPrice": "0x9184e72a000",
+			"value": "0x9184e72a"
+		}],
+		"id": 1
+	}"#;
+	let response = r#"{"jsonrpc":"2.0","result":""#.to_owned() + format!("0x{:?}", t.hash()).as_ref() + r#"","id":1}"#;
+
+	// then
+	assert_eq!(tester.io.handle_request(&request), Some(response.to_owned()));
 }

From 230c6c889ab34b7f874be852eb64e5055d65bda7 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@ethcore.io>
Date: Wed, 22 Jun 2016 21:33:10 +0200
Subject: [PATCH 13/22] Ensure judging the SF trigger by relative branch
 (#1399)

Rather than just the canon chain.
---
 ethcore/src/client/client.rs |  6 +++---
 ethcore/src/client/mod.rs    | 16 +++++++++++++---
 ethcore/src/miner/miner.rs   |  2 +-
 3 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs
index fa063cd61..693296469 100644
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@@ -230,7 +230,7 @@ impl<V> Client<V> where V: Verifier {
 		let last_hashes = self.build_last_hashes(header.parent_hash.clone());
 		let db = self.state_db.lock().unwrap().boxed_clone();
 
-		let enact_result = enact_verified(&block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, self.dao_rescue_block_gas_limit(), &self.vm_factory);
+		let enact_result = enact_verified(&block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, self.dao_rescue_block_gas_limit(header.parent_hash.clone()), &self.vm_factory);
 		if let Err(e) = enact_result {
 			warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
 			return Err(());
@@ -486,7 +486,7 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 			last_hashes: last_hashes,
 			gas_used: U256::zero(),
 			gas_limit: U256::max_value(),
-			dao_rescue_block_gas_limit: self.dao_rescue_block_gas_limit(),
+			dao_rescue_block_gas_limit: self.dao_rescue_block_gas_limit(view.parent_hash()),
 		};
 		// that's just a copy of the state.
 		let mut state = self.state();
@@ -808,7 +808,7 @@ impl<V> MiningBlockChainClient for Client<V> where V: Verifier {
 			self.state_db.lock().unwrap().boxed_clone(),
 			&self.chain.block_header(&h).expect("h is best block hash: so it's header must exist: qed"),
 			self.build_last_hashes(h.clone()),
-			self.dao_rescue_block_gas_limit(),
+			self.dao_rescue_block_gas_limit(h.clone()),
 			author,
 			gas_floor_target,
 			extra_data,
diff --git a/ethcore/src/client/mod.rs b/ethcore/src/client/mod.rs
index c1bc3203c..589b65e16 100644
--- a/ethcore/src/client/mod.rs
+++ b/ethcore/src/client/mod.rs
@@ -227,9 +227,19 @@ pub trait BlockChainClient : Sync + Send {
 
 
 	/// Get `Some` gas limit of block 1_760_000, or `None` if chain is not yet that long.
-	fn dao_rescue_block_gas_limit(&self) -> Option<U256> {
-		self.block_header(BlockID::Number(1_760_000))
-			.map(|header| HeaderView::new(&header).gas_limit())
+	fn dao_rescue_block_gas_limit(&self, chain_hash: H256) -> Option<U256> {
+		if let Some(mut header) = self.block_header(BlockID::Hash(chain_hash)) {
+			if HeaderView::new(&header).number() < 1_760_000 {
+				None
+			} else {
+				while HeaderView::new(&header).number() != 1_760_000 {
+					header = self.block_header(BlockID::Hash(HeaderView::new(&header).parent_hash())).expect("chain is complete; parent of chain entry must be in chain; qed");
+				}
+				Some(HeaderView::new(&header).gas_limit())
+			}
+		} else {
+			None
+		}
 	}	
 }
 
diff --git a/ethcore/src/miner/miner.rs b/ethcore/src/miner/miner.rs
index 41e4b4810..290e94059 100644
--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@@ -274,7 +274,7 @@ impl MinerService for Miner {
 					last_hashes: last_hashes,
 					gas_used: U256::zero(),
 					gas_limit: U256::max_value(),
-					dao_rescue_block_gas_limit: chain.dao_rescue_block_gas_limit(),
+					dao_rescue_block_gas_limit: chain.dao_rescue_block_gas_limit(header.parent_hash().clone()),
 				};
 				// that's just a copy of the state.
 				let mut state = block.state().clone();

From 1602906b565aecbebbb3b221255663ad68ffb7d9 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@ethcore.io>
Date: Wed, 22 Jun 2016 21:37:29 +0200
Subject: [PATCH 14/22] Shortcut SF condition when canon known

---
 ethcore/src/client/mod.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/ethcore/src/client/mod.rs b/ethcore/src/client/mod.rs
index 589b65e16..3ed56573a 100644
--- a/ethcore/src/client/mod.rs
+++ b/ethcore/src/client/mod.rs
@@ -228,6 +228,11 @@ pub trait BlockChainClient : Sync + Send {
 
 	/// Get `Some` gas limit of block 1_760_000, or `None` if chain is not yet that long.
 	fn dao_rescue_block_gas_limit(&self, chain_hash: H256) -> Option<U256> {
+		// shortcut if the canon chain is already known.
+		if self.chain_info().best_block_number > 1_761_000 {
+			return self.block_header(BlockID::Number(1_760_000)).map(|header| HeaderView::new(&header).gas_limit());
+		}
+		// otherwise check according to `chain_hash`.
 		if let Some(mut header) = self.block_header(BlockID::Hash(chain_hash)) {
 			if HeaderView::new(&header).number() < 1_760_000 {
 				None

From 8a867262ad41d3381e7ffadb26a17673ac390a87 Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@ethcore.io>
Date: Thu, 23 Jun 2016 02:42:56 +0200
Subject: [PATCH 15/22] Build fix.

---
 parity/main.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/parity/main.rs b/parity/main.rs
index 17d941a5d..0b64d0644 100644
--- a/parity/main.rs
+++ b/parity/main.rs
@@ -199,7 +199,7 @@ fn execute_client(conf: Configuration, spec: Spec, client_config: ClientConfig)
 	}
 
 	// Display warning about using unlock with signer
-	if conf.args.flag_signer && conf.args.flag_unlock.is_some() {
+	if !conf.args.flag_signer_off && conf.args.flag_unlock.is_some() {
 		warn!("Using Trusted Signer and --unlock is not recommended!");
 		warn!("NOTE that Signer will not ask you to confirm transactions from unlocked account.");
 	}

From a76e3a134f880e6fd0b43321bdaf579a0fad1ed7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= <tomasz@ethcore.io>
Date: Thu, 23 Jun 2016 10:54:25 +0200
Subject: [PATCH 16/22] Bumping clippy

---
 Cargo.toml         | 2 +-
 dapps/Cargo.toml   | 2 +-
 db/Cargo.toml      | 2 +-
 ethcore/Cargo.toml | 2 +-
 hook.sh            | 2 +-
 json/Cargo.toml    | 2 +-
 rpc/Cargo.toml     | 2 +-
 signer/Cargo.toml  | 2 +-
 sync/Cargo.toml    | 2 +-
 util/Cargo.toml    | 2 +-
 10 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 9f4c34c0b..6c4b54d46 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,7 +22,7 @@ fdlimit = { path = "util/fdlimit" }
 num_cpus = "0.2"
 number_prefix = "0.2"
 rpassword = "0.2.1"
-clippy = { version = "0.0.76", optional = true}
+clippy = { version = "0.0.77", optional = true}
 ethcore = { path = "ethcore" }
 ethcore-util = { path = "util" }
 ethsync = { path = "sync" }
diff --git a/dapps/Cargo.toml b/dapps/Cargo.toml
index dc45085d5..4cc4bc472 100644
--- a/dapps/Cargo.toml
+++ b/dapps/Cargo.toml
@@ -28,7 +28,7 @@ parity-dapps-wallet = { git = "https://github.com/ethcore/parity-dapps-wallet-rs
 parity-dapps-dao = { git = "https://github.com/ethcore/parity-dapps-dao-rs.git", version = "0.4.0", optional = true }
 parity-dapps-makerotc = { git = "https://github.com/ethcore/parity-dapps-makerotc-rs.git", version = "0.3.0", optional = true }
 mime_guess = { version = "1.6.1" }
-clippy = { version = "0.0.76", optional = true}
+clippy = { version = "0.0.77", optional = true}
 
 [build-dependencies]
 serde_codegen = { version = "0.7.0", optional = true }
diff --git a/db/Cargo.toml b/db/Cargo.toml
index b77840d02..a51bf9ab9 100644
--- a/db/Cargo.toml
+++ b/db/Cargo.toml
@@ -12,7 +12,7 @@ syntex = "*"
 ethcore-ipc-codegen = { path = "../ipc/codegen" }
 
 [dependencies]
-clippy = { version = "0.0.67", optional = true}
+clippy = { version = "0.0.77", optional = true}
 ethcore-devtools = { path = "../devtools" }
 ethcore-ipc = { path = "../ipc/rpc" }
 rocksdb = { git = "https://github.com/ethcore/rust-rocksdb" }
diff --git a/ethcore/Cargo.toml b/ethcore/Cargo.toml
index 294ad82c4..515091a16 100644
--- a/ethcore/Cargo.toml
+++ b/ethcore/Cargo.toml
@@ -22,7 +22,7 @@ ethcore-util = { path = "../util" }
 evmjit = { path = "../evmjit", optional = true }
 ethash = { path = "../ethash" }
 num_cpus = "0.2"
-clippy = { version = "0.0.76", optional = true}
+clippy = { version = "0.0.77", optional = true}
 crossbeam = "0.2.9"
 lazy_static = "0.2"
 ethcore-devtools = { path = "../devtools" }
diff --git a/hook.sh b/hook.sh
index 9ce825f80..1b15aafa8 100755
--- a/hook.sh
+++ b/hook.sh
@@ -7,6 +7,6 @@ echo "set -e" >> $FILE
 echo "cargo build --features dev" >> $FILE
 # Build tests
 echo "cargo test --no-run --features dev \\" >> $FILE
-echo " -p ethkey -p ethstore -p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity -p ethcore-dapps -p ethcore-signer" >> $FILE
+echo " -p ethkey -p ethstore -p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity -p ethcore-dapps -p ethcore-signer -p ethcore-db" >> $FILE
 echo "" >> $FILE
 chmod +x $FILE
diff --git a/json/Cargo.toml b/json/Cargo.toml
index a2a560c43..e93f493e1 100644
--- a/json/Cargo.toml
+++ b/json/Cargo.toml
@@ -10,7 +10,7 @@ rustc-serialize = "0.3"
 serde = "0.7.0"
 serde_json = "0.7.0"
 serde_macros = { version = "0.7.0", optional = true }
-clippy = { version = "0.0.76", optional = true}
+clippy = { version = "0.0.77", optional = true}
 
 [build-dependencies]
 serde_codegen = { version = "0.7.0", optional = true }
diff --git a/rpc/Cargo.toml b/rpc/Cargo.toml
index b1369c88d..60b8236e1 100644
--- a/rpc/Cargo.toml
+++ b/rpc/Cargo.toml
@@ -23,7 +23,7 @@ ethcore-devtools = { path = "../devtools" }
 rustc-serialize = "0.3"
 transient-hashmap = "0.1"
 serde_macros = { version = "0.7.0", optional = true }
-clippy = { version = "0.0.76", optional = true}
+clippy = { version = "0.0.77", optional = true}
 json-ipc-server = { git = "https://github.com/ethcore/json-ipc-server.git" }
 
 [build-dependencies]
diff --git a/signer/Cargo.toml b/signer/Cargo.toml
index 82160d55a..0cae9b0a5 100644
--- a/signer/Cargo.toml
+++ b/signer/Cargo.toml
@@ -20,7 +20,7 @@ ethcore-util = { path = "../util" }
 ethcore-rpc = { path = "../rpc" }
 parity-minimal-sysui = { git = "https://github.com/ethcore/parity-dapps-minimal-sysui-rs.git" }
 
-clippy = { version = "0.0.76", optional = true}
+clippy = { version = "0.0.77", optional = true}
 
 [features]
 dev = ["clippy"]
diff --git a/sync/Cargo.toml b/sync/Cargo.toml
index c77749c39..8bb0d37c9 100644
--- a/sync/Cargo.toml
+++ b/sync/Cargo.toml
@@ -10,7 +10,7 @@ authors = ["Ethcore <admin@ethcore.io"]
 [dependencies]
 ethcore-util = { path = "../util" }
 ethcore = { path = "../ethcore" }
-clippy = { version = "0.0.76", optional = true}
+clippy = { version = "0.0.77", optional = true}
 log = "0.3"
 env_logger = "0.3"
 time = "0.1.34"
diff --git a/util/Cargo.toml b/util/Cargo.toml
index 8b213ad47..fd61d6009 100644
--- a/util/Cargo.toml
+++ b/util/Cargo.toml
@@ -28,7 +28,7 @@ crossbeam = "0.2"
 slab = "0.2"
 sha3 = { path = "sha3" }
 serde = "0.7.0"
-clippy = { version = "0.0.76", optional = true}
+clippy = { version = "0.0.77", optional = true}
 json-tests = { path = "json-tests" }
 igd = "0.4.2"
 ethcore-devtools = { path = "../devtools" }

From be8f922b3f19096e85a8e8647bec3a3f07b1e03d Mon Sep 17 00:00:00 2001
From: keorn <pczaban@gmail.com>
Date: Thu, 23 Jun 2016 10:16:11 +0100
Subject: [PATCH 17/22] Replace deprecated hashdb trait names (#1394)

* replace deprecated hashdb method names

* spaces -> tabs
---
 ethcore/src/account.rs                |   6 +-
 ethcore/src/account_db.rs             |  22 ++---
 util/src/hashdb.rs                    |  24 +++--
 util/src/journaldb/archivedb.rs       |  68 +++++++-------
 util/src/journaldb/earlymergedb.rs    | 130 +++++++++++++-------------
 util/src/journaldb/overlayrecentdb.rs | 118 +++++++++++------------
 util/src/journaldb/refcounteddb.rs    |  60 ++++++------
 util/src/memorydb.rs                  |   6 +-
 util/src/overlaydb.rs                 |  22 ++---
 util/src/trie/triedb.rs               |   8 +-
 util/src/trie/triedbmut.rs            |  18 ++--
 11 files changed, 240 insertions(+), 242 deletions(-)

diff --git a/ethcore/src/account.rs b/ethcore/src/account.rs
index 29922dda5..d0628436d 100644
--- a/ethcore/src/account.rs
+++ b/ethcore/src/account.rs
@@ -166,16 +166,16 @@ impl Account {
 		!self.code_cache.is_empty() || (self.code_cache.is_empty() && self.code_hash == Some(SHA3_EMPTY))
 	}
 
-	/// Provide a database to lookup `code_hash`. Should not be called if it is a contract without code.
+	/// Provide a database to get `code_hash`. Should not be called if it is a contract without code.
 	pub fn cache_code(&mut self, db: &AccountDB) -> bool {
 		// TODO: fill out self.code_cache;
 		trace!("Account::cache_code: ic={}; self.code_hash={:?}, self.code_cache={}", self.is_cached(), self.code_hash, self.code_cache.pretty());
 		self.is_cached() ||
 			match self.code_hash {
-				Some(ref h) => match db.lookup(h) {
+				Some(ref h) => match db.get(h) {
 					Some(x) => { self.code_cache = x.to_vec(); true },
 					_ => {
-						warn!("Failed reverse lookup of {}", h);
+						warn!("Failed reverse get of {}", h);
 						false
 					},
 				},
diff --git a/ethcore/src/account_db.rs b/ethcore/src/account_db.rs
index c21ea2993..7337940da 100644
--- a/ethcore/src/account_db.rs
+++ b/ethcore/src/account_db.rs
@@ -30,18 +30,18 @@ impl<'db> HashDB for AccountDB<'db>{
 		unimplemented!()
 	}
 
-	fn lookup(&self, key: &H256) -> Option<&[u8]> {
+	fn get(&self, key: &H256) -> Option<&[u8]> {
 		if key == &SHA3_NULL_RLP {
 			return Some(&NULL_RLP_STATIC);
 		}
-		self.db.lookup(&combine_key(&self.address, key))
+		self.db.get(&combine_key(&self.address, key))
 	}
 
-	fn exists(&self, key: &H256) -> bool {
+	fn contains(&self, key: &H256) -> bool {
 		if key == &SHA3_NULL_RLP {
 			return true;
 		}
-		self.db.exists(&combine_key(&self.address, key))
+		self.db.contains(&combine_key(&self.address, key))
 	}
 
 	fn insert(&mut self, _value: &[u8]) -> H256 {
@@ -52,7 +52,7 @@ impl<'db> HashDB for AccountDB<'db>{
 		unimplemented!()
 	}
 
-	fn kill(&mut self, _key: &H256) {
+	fn remove(&mut self, _key: &H256) {
 		unimplemented!()
 	}
 }
@@ -82,18 +82,18 @@ impl<'db> HashDB for AccountDBMut<'db>{
 		unimplemented!()
 	}
 
-	fn lookup(&self, key: &H256) -> Option<&[u8]> {
+	fn get(&self, key: &H256) -> Option<&[u8]> {
 		if key == &SHA3_NULL_RLP {
 			return Some(&NULL_RLP_STATIC);
 		}
-		self.db.lookup(&combine_key(&self.address, key))
+		self.db.get(&combine_key(&self.address, key))
 	}
 
-	fn exists(&self, key: &H256) -> bool {
+	fn contains(&self, key: &H256) -> bool {
 		if key == &SHA3_NULL_RLP {
 			return true;
 		}
-		self.db.exists(&combine_key(&self.address, key))
+		self.db.contains(&combine_key(&self.address, key))
 	}
 
 	fn insert(&mut self, value: &[u8]) -> H256 {
@@ -114,12 +114,12 @@ impl<'db> HashDB for AccountDBMut<'db>{
 		self.db.emplace(key, value.to_vec())
 	}
 
-	fn kill(&mut self, key: &H256) {
+	fn remove(&mut self, key: &H256) {
 		if key == &SHA3_NULL_RLP {
 			return;
 		}
 		let key = combine_key(&self.address, key);
-		self.db.kill(&key)
+		self.db.remove(&key)
 	}
 }
 
diff --git a/util/src/hashdb.rs b/util/src/hashdb.rs
index 0a5f13d52..1ec3069d8 100644
--- a/util/src/hashdb.rs
+++ b/util/src/hashdb.rs
@@ -20,12 +20,10 @@ use bytes::*;
 use std::collections::HashMap;
 
 /// Trait modelling datastore keyed by a 32-byte Keccak hash.
-pub trait HashDB : AsHashDB {
+pub trait HashDB: AsHashDB {
 	/// Get the keys in the database together with number of underlying references.
 	fn keys(&self) -> HashMap<H256, i32>;
 
-	/// Deprecated. use `get`.
-	fn lookup(&self, key: &H256) -> Option<&[u8]>; // TODO: rename to get.
 	/// Look up a given hash into the bytes that hash to it, returning None if the
 	/// hash is not known.
 	///
@@ -41,10 +39,8 @@ pub trait HashDB : AsHashDB {
 	///   assert_eq!(m.get(&hash).unwrap(), hello_bytes);
 	/// }
 	/// ```
-	fn get(&self, key: &H256) -> Option<&[u8]> { self.lookup(key) }
+	fn get(&self, key: &H256) -> Option<&[u8]>;
 
-	/// Deprecated. Use `contains`.
-	fn exists(&self, key: &H256) -> bool; // TODO: rename to contains.
 	/// Check for the existance of a hash-key.
 	///
 	/// # Examples
@@ -63,10 +59,10 @@ pub trait HashDB : AsHashDB {
 	///   assert!(!m.contains(&key));
 	/// }
 	/// ```
-	fn contains(&self, key: &H256) -> bool { self.exists(key) }
+	fn contains(&self, key: &H256) -> bool;
 
 	/// Insert a datum item into the DB and return the datum's hash for a later lookup. Insertions
-	/// are counted and the equivalent number of `kill()`s must be performed before the data
+	/// are counted and the equivalent number of `remove()`s must be performed before the data
 	/// is considered dead.
 	///
 	/// # Examples
@@ -86,8 +82,6 @@ pub trait HashDB : AsHashDB {
 	/// Like `insert()` , except you provide the key and the data is all moved.
 	fn emplace(&mut self, key: H256, value: Bytes);
 
-	/// Deprecated - use `remove`.
-	fn kill(&mut self, key: &H256); // TODO: rename to remove.
 	/// Remove a datum previously inserted. Insertions can be "owed" such that the same number of `insert()`s may
 	/// happen without the data being eventually being inserted into the DB.
 	///
@@ -109,7 +103,7 @@ pub trait HashDB : AsHashDB {
 	///   assert_eq!(m.get(key).unwrap(), d);
 	/// }
 	/// ```
-	fn remove(&mut self, key: &H256) { self.kill(key) }
+	fn remove(&mut self, key: &H256);
 }
 
 /// Upcast trait.
@@ -121,6 +115,10 @@ pub trait AsHashDB {
 }
 
 impl<T: HashDB> AsHashDB for T {
-	fn as_hashdb(&self) -> &HashDB { self }
-	fn as_hashdb_mut(&mut self) -> &mut HashDB { self }
+	fn as_hashdb(&self) -> &HashDB {
+		self
+	}
+	fn as_hashdb_mut(&mut self) -> &mut HashDB {
+		self
+	}
 }
diff --git a/util/src/journaldb/archivedb.rs b/util/src/journaldb/archivedb.rs
index 0381c08ea..c7f6b92fa 100644
--- a/util/src/journaldb/archivedb.rs
+++ b/util/src/journaldb/archivedb.rs
@@ -98,7 +98,7 @@ impl HashDB for ArchiveDB {
 		ret
 	}
 
-	fn lookup(&self, key: &H256) -> Option<&[u8]> {
+	fn get(&self, key: &H256) -> Option<&[u8]> {
 		let k = self.overlay.raw(key);
 		match k {
 			Some(&(ref d, rc)) if rc > 0 => Some(d),
@@ -113,8 +113,8 @@ impl HashDB for ArchiveDB {
 		}
 	}
 
-	fn exists(&self, key: &H256) -> bool {
-		self.lookup(key).is_some()
+	fn contains(&self, key: &H256) -> bool {
+		self.get(key).is_some()
 	}
 
 	fn insert(&mut self, value: &[u8]) -> H256 {
@@ -123,8 +123,8 @@ impl HashDB for ArchiveDB {
 	fn emplace(&mut self, key: H256, value: Bytes) {
 		self.overlay.emplace(key, value);
 	}
-	fn kill(&mut self, key: &H256) {
-		self.overlay.kill(key);
+	fn remove(&mut self, key: &H256) {
+		self.overlay.remove(key);
 	}
 }
 
@@ -207,7 +207,7 @@ mod tests {
 		jdb.commit(5, &b"1004a".sha3(), Some((3, b"1002a".sha3()))).unwrap();
 		jdb.commit(6, &b"1005a".sha3(), Some((4, b"1003a".sha3()))).unwrap();
 
-		assert!(jdb.exists(&x));
+		assert!(jdb.contains(&x));
 	}
 
 	#[test]
@@ -216,14 +216,14 @@ mod tests {
 		let mut jdb = ArchiveDB::new_temp();
 		let h = jdb.insert(b"foo");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.remove(&h);
 		jdb.commit(1, &b"1".sha3(), None).unwrap();
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(2, &b"2".sha3(), None).unwrap();
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(3, &b"3".sha3(), Some((0, b"0".sha3()))).unwrap();
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(4, &b"4".sha3(), Some((1, b"1".sha3()))).unwrap();
 	}
 
@@ -235,26 +235,26 @@ mod tests {
 		let foo = jdb.insert(b"foo");
 		let bar = jdb.insert(b"bar");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
 
 		jdb.remove(&foo);
 		jdb.remove(&bar);
 		let baz = jdb.insert(b"baz");
 		jdb.commit(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
+		assert!(jdb.contains(&baz));
 
 		let foo = jdb.insert(b"foo");
 		jdb.remove(&baz);
 		jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&baz));
 
 		jdb.remove(&foo);
 		jdb.commit(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 
 		jdb.commit(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap();
 	}
@@ -267,8 +267,8 @@ mod tests {
 		let foo = jdb.insert(b"foo");
 		let bar = jdb.insert(b"bar");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
 
 		jdb.remove(&foo);
 		let baz = jdb.insert(b"baz");
@@ -277,12 +277,12 @@ mod tests {
 		jdb.remove(&bar);
 		jdb.commit(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap();
 
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
+		assert!(jdb.contains(&baz));
 
 		jdb.commit(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 	}
 
 	#[test]
@@ -292,16 +292,16 @@ mod tests {
 
 		let foo = jdb.insert(b"foo");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 
 		jdb.remove(&foo);
 		jdb.commit(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap();
 		jdb.insert(b"foo");
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 		jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 		jdb.commit(3, &b"2".sha3(), Some((0, b"2".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 	}
 
 	#[test]
@@ -315,10 +315,10 @@ mod tests {
 
 		jdb.insert(b"foo");
 		jdb.commit(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 
 		jdb.commit(2, &b"2a".sha3(), Some((1, b"1a".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 	}
 
 	#[test]
@@ -344,8 +344,8 @@ mod tests {
 
 		{
 			let mut jdb = ArchiveDB::new(dir.to_str().unwrap(), None);
-			assert!(jdb.exists(&foo));
-			assert!(jdb.exists(&bar));
+			assert!(jdb.contains(&foo));
+			assert!(jdb.contains(&bar));
 			jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
 		}
 	}
@@ -373,7 +373,7 @@ mod tests {
 			let mut jdb = ArchiveDB::new(dir.to_str().unwrap(), None);
 			jdb.remove(&foo);
 			jdb.commit(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap();
-			assert!(jdb.exists(&foo));
+			assert!(jdb.contains(&foo));
 			jdb.remove(&foo);
 			jdb.commit(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap();
 			jdb.commit(5, &b"5".sha3(), Some((4, b"4".sha3()))).unwrap();
@@ -402,7 +402,7 @@ mod tests {
 		{
 			let mut jdb = ArchiveDB::new(dir.to_str().unwrap(), None);
 			jdb.commit(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap();
-			assert!(jdb.exists(&foo));
+			assert!(jdb.contains(&foo));
 		}
 	}
 
diff --git a/util/src/journaldb/earlymergedb.rs b/util/src/journaldb/earlymergedb.rs
index e495b9d03..71959fa35 100644
--- a/util/src/journaldb/earlymergedb.rs
+++ b/util/src/journaldb/earlymergedb.rs
@@ -172,8 +172,8 @@ impl EarlyMergeDB {
 		trace!(target: "jdb.fine", "replay_keys: (end) refs={:?}", refs);
 	}
 
-	fn kill_keys(deletes: &[H256], refs: &mut HashMap<H256, RefInfo>, batch: &DBTransaction, from: RemoveFrom, trace: bool) {
-		// with a kill on {queue_refs: 1, in_archive: true}, we have two options:
+	fn remove_keys(deletes: &[H256], refs: &mut HashMap<H256, RefInfo>, batch: &DBTransaction, from: RemoveFrom, trace: bool) {
+		// with a remove on {queue_refs: 1, in_archive: true}, we have two options:
 		// - convert to {queue_refs: 1, in_archive: false} (i.e. remove it from the conceptual archive)
 		// - convert to {queue_refs: 0, in_archive: true} (i.e. remove it from the conceptual queue)
 		// (the latter option would then mean removing the RefInfo, since it would no longer be counted in the queue.)
@@ -186,13 +186,13 @@ impl EarlyMergeDB {
 					c.in_archive = false;
 					Self::reset_already_in(batch, h);
 					if trace {
-						trace!(target: "jdb.fine", "    kill({}): In archive, 1 in queue: Reducing to queue only and recording", h);
+						trace!(target: "jdb.fine", "    remove({}): In archive, 1 in queue: Reducing to queue only and recording", h);
 					}
 					continue;
 				} else if c.queue_refs > 1 {
 					c.queue_refs -= 1;
 					if trace {
-						trace!(target: "jdb.fine", "    kill({}): In queue > 1 refs: Decrementing ref count to {}", h, c.queue_refs);
+						trace!(target: "jdb.fine", "    remove({}): In queue > 1 refs: Decrementing ref count to {}", h, c.queue_refs);
 					}
 					continue;
 				} else {
@@ -204,14 +204,14 @@ impl EarlyMergeDB {
 					refs.remove(h);
 					Self::reset_already_in(batch, h);
 					if trace {
-						trace!(target: "jdb.fine", "    kill({}): In archive, 1 in queue: Removing from queue and leaving in archive", h);
+						trace!(target: "jdb.fine", "    remove({}): In archive, 1 in queue: Removing from queue and leaving in archive", h);
 					}
 				}
 				Some(RefInfo{queue_refs: 1, in_archive: false}) => {
 					refs.remove(h);
 					batch.delete(&h.bytes()).expect("Low-level database error. Some issue with your hard disk?");
 					if trace {
-						trace!(target: "jdb.fine", "    kill({}): Not in archive, only 1 ref in queue: Removing from queue and DB", h);
+						trace!(target: "jdb.fine", "    remove({}): Not in archive, only 1 ref in queue: Removing from queue and DB", h);
 					}
 				}
 				None => {
@@ -219,7 +219,7 @@ impl EarlyMergeDB {
 					//assert!(!Self::is_already_in(db, &h));
 					batch.delete(&h.bytes()).expect("Low-level database error. Some issue with your hard disk?");
 					if trace {
-						trace!(target: "jdb.fine", "    kill({}): Not in queue - MUST BE IN ARCHIVE: Removing from DB", h);
+						trace!(target: "jdb.fine", "    remove({}): Not in queue - MUST BE IN ARCHIVE: Removing from DB", h);
 					}
 				}
 				_ => panic!("Invalid value in refs: {:?}", n),
@@ -290,7 +290,7 @@ impl HashDB for EarlyMergeDB {
 		ret
 	}
 
-	fn lookup(&self, key: &H256) -> Option<&[u8]> {
+	fn get(&self, key: &H256) -> Option<&[u8]> {
 		let k = self.overlay.raw(key);
 		match k {
 			Some(&(ref d, rc)) if rc > 0 => Some(d),
@@ -305,8 +305,8 @@ impl HashDB for EarlyMergeDB {
 		}
 	}
 
-	fn exists(&self, key: &H256) -> bool {
-		self.lookup(key).is_some()
+	fn contains(&self, key: &H256) -> bool {
+		self.get(key).is_some()
 	}
 
 	fn insert(&mut self, value: &[u8]) -> H256 {
@@ -315,8 +315,8 @@ impl HashDB for EarlyMergeDB {
 	fn emplace(&mut self, key: H256, value: Bytes) {
 		self.overlay.emplace(key, value);
 	}
-	fn kill(&mut self, key: &H256) {
-		self.overlay.kill(key);
+	fn remove(&mut self, key: &H256) {
+		self.overlay.remove(key);
 	}
 }
 
@@ -472,7 +472,7 @@ impl JournalDB for EarlyMergeDB {
 					if trace {
 						trace!(target: "jdb.ops", "  Expunging: {:?}", deletes);
 					}
-					Self::kill_keys(&deletes, &mut refs, &batch, RemoveFrom::Archive, trace);
+					Self::remove_keys(&deletes, &mut refs, &batch, RemoveFrom::Archive, trace);
 
 					if trace {
 						trace!(target: "jdb.ops", "  Finalising: {:?}", inserts);
@@ -504,7 +504,7 @@ impl JournalDB for EarlyMergeDB {
 					if trace {
 						trace!(target: "jdb.ops", "  Reverting: {:?}", inserts);
 					}
-					Self::kill_keys(&inserts, &mut refs, &batch, RemoveFrom::Queue, trace);
+					Self::remove_keys(&inserts, &mut refs, &batch, RemoveFrom::Queue, trace);
 				}
 
 				try!(batch.delete(&last));
@@ -565,7 +565,7 @@ mod tests {
 		jdb.commit(6, &b"1005a".sha3(), Some((4, b"1003a".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
 
-		assert!(jdb.exists(&x));
+		assert!(jdb.contains(&x));
 	}
 
 	#[test]
@@ -584,8 +584,8 @@ mod tests {
 		assert!(jdb.can_reconstruct_refs());
 		jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
 
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
 	}
 
 	#[test]
@@ -595,20 +595,20 @@ mod tests {
 		let h = jdb.insert(b"foo");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.remove(&h);
 		jdb.commit(1, &b"1".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(2, &b"2".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(3, &b"3".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(4, &b"4".sha3(), Some((1, b"1".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(!jdb.exists(&h));
+		assert!(!jdb.contains(&h));
 	}
 
 	#[test]
@@ -620,38 +620,38 @@ mod tests {
 		let bar = jdb.insert(b"bar");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
 
 		jdb.remove(&foo);
 		jdb.remove(&bar);
 		let baz = jdb.insert(b"baz");
 		jdb.commit(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
+		assert!(jdb.contains(&baz));
 
 		let foo = jdb.insert(b"foo");
 		jdb.remove(&baz);
 		jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(!jdb.exists(&bar));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(!jdb.contains(&bar));
+		assert!(jdb.contains(&baz));
 
 		jdb.remove(&foo);
 		jdb.commit(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(!jdb.exists(&bar));
-		assert!(!jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(!jdb.contains(&bar));
+		assert!(!jdb.contains(&baz));
 
 		jdb.commit(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(!jdb.exists(&foo));
-		assert!(!jdb.exists(&bar));
-		assert!(!jdb.exists(&baz));
+		assert!(!jdb.contains(&foo));
+		assert!(!jdb.contains(&bar));
+		assert!(!jdb.contains(&baz));
 	}
 
 	#[test]
@@ -663,8 +663,8 @@ mod tests {
 		let bar = jdb.insert(b"bar");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
 
 		jdb.remove(&foo);
 		let baz = jdb.insert(b"baz");
@@ -675,15 +675,15 @@ mod tests {
 		jdb.commit(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
 
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
+		assert!(jdb.contains(&baz));
 
 		jdb.commit(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(!jdb.exists(&baz));
-		assert!(!jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(!jdb.contains(&baz));
+		assert!(!jdb.contains(&bar));
 	}
 
 	#[test]
@@ -694,19 +694,19 @@ mod tests {
 		let foo = jdb.insert(b"foo");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 
 		jdb.remove(&foo);
 		jdb.commit(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
 		jdb.insert(b"foo");
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 		jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 		jdb.commit(3, &b"2".sha3(), Some((0, b"2".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 	}
 
 	#[test]
@@ -730,11 +730,11 @@ mod tests {
 		jdb.commit(1, &b"1c".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
 
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 
 		jdb.commit(2, &b"2a".sha3(), Some((1, b"1a".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 	}
 
 	#[test]
@@ -758,11 +758,11 @@ mod tests {
 		jdb.commit(1, &b"1c".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
 
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 
 		jdb.commit(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 	}
 
 	#[test]
@@ -826,11 +826,11 @@ mod tests {
 
 		{
 			let mut jdb = EarlyMergeDB::new(dir.to_str().unwrap(), None);
-			assert!(jdb.exists(&foo));
-			assert!(jdb.exists(&bar));
+			assert!(jdb.contains(&foo));
+			assert!(jdb.contains(&bar));
 			jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(!jdb.exists(&foo));
+			assert!(!jdb.contains(&foo));
 		}
 	}
 
@@ -933,7 +933,7 @@ mod tests {
 		jdb.insert(b"foo");
 		jdb.commit(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap();	// BROKEN
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 
 		jdb.remove(&foo);
 		jdb.commit(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap();
@@ -941,7 +941,7 @@ mod tests {
 
 		jdb.commit(5, &b"5".sha3(), Some((4, b"4".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(!jdb.exists(&foo));
+		assert!(!jdb.contains(&foo));
 	}
 
 	#[test]
@@ -1002,12 +1002,12 @@ mod tests {
 			jdb.remove(&foo);
 			jdb.commit(2, &b"2".sha3(), Some((0, b"0".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(jdb.exists(&foo));
+			assert!(jdb.contains(&foo));
 
 			jdb.insert(b"foo");
 			jdb.commit(3, &b"3".sha3(), Some((1, b"1".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(jdb.exists(&foo));
+			assert!(jdb.contains(&foo));
 
 		// incantation to reopen the db
 		}; { let mut jdb = EarlyMergeDB::new(dir.to_str().unwrap(), None);
@@ -1015,21 +1015,21 @@ mod tests {
 			jdb.remove(&foo);
 			jdb.commit(4, &b"4".sha3(), Some((2, b"2".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(jdb.exists(&foo));
+			assert!(jdb.contains(&foo));
 
 		// incantation to reopen the db
 		}; { let mut jdb = EarlyMergeDB::new(dir.to_str().unwrap(), None);
 
 			jdb.commit(5, &b"5".sha3(), Some((3, b"3".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(jdb.exists(&foo));
+			assert!(jdb.contains(&foo));
 
 		// incantation to reopen the db
 		}; { let mut jdb = EarlyMergeDB::new(dir.to_str().unwrap(), None);
 
 			jdb.commit(6, &b"6".sha3(), Some((4, b"4".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(!jdb.exists(&foo));
+			assert!(!jdb.contains(&foo));
 		}
 	}
 
@@ -1059,9 +1059,9 @@ mod tests {
 			let mut jdb = EarlyMergeDB::new(dir.to_str().unwrap(), None);
 			jdb.commit(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(jdb.exists(&foo));
-			assert!(!jdb.exists(&baz));
-			assert!(!jdb.exists(&bar));
+			assert!(jdb.contains(&foo));
+			assert!(!jdb.contains(&baz));
+			assert!(!jdb.contains(&bar));
 		}
 	}
 }
diff --git a/util/src/journaldb/overlayrecentdb.rs b/util/src/journaldb/overlayrecentdb.rs
index 709a8fe5f..158b771fb 100644
--- a/util/src/journaldb/overlayrecentdb.rs
+++ b/util/src/journaldb/overlayrecentdb.rs
@@ -288,11 +288,11 @@ impl JournalDB for OverlayRecentDB {
 				}
 				// update the overlay
 				for k in overlay_deletions {
-					journal_overlay.backing_overlay.kill(&k);
+					journal_overlay.backing_overlay.remove(&k);
 				}
 				// apply canon deletions
 				for k in canon_deletions {
-					if !journal_overlay.backing_overlay.exists(&k) {
+					if !journal_overlay.backing_overlay.contains(&k) {
 						try!(batch.delete(&k));
 					}
 				}
@@ -321,12 +321,12 @@ impl HashDB for OverlayRecentDB {
 		ret
 	}
 
-	fn lookup(&self, key: &H256) -> Option<&[u8]> {
+	fn get(&self, key: &H256) -> Option<&[u8]> {
 		let k = self.transaction_overlay.raw(key);
 		match k {
 			Some(&(ref d, rc)) if rc > 0 => Some(d),
 			_ => {
-				let v = self.journal_overlay.read().unwrap().backing_overlay.lookup(key).map(|v| v.to_vec());
+				let v = self.journal_overlay.read().unwrap().backing_overlay.get(key).map(|v| v.to_vec());
 				match v {
 					Some(x) => {
 						Some(&self.transaction_overlay.denote(key, x).0)
@@ -344,8 +344,8 @@ impl HashDB for OverlayRecentDB {
 		}
 	}
 
-	fn exists(&self, key: &H256) -> bool {
-		self.lookup(key).is_some()
+	fn contains(&self, key: &H256) -> bool {
+		self.get(key).is_some()
 	}
 
 	fn insert(&mut self, value: &[u8]) -> H256 {
@@ -354,8 +354,8 @@ impl HashDB for OverlayRecentDB {
 	fn emplace(&mut self, key: H256, value: Bytes) {
 		self.transaction_overlay.emplace(key, value);
 	}
-	fn kill(&mut self, key: &H256) {
-		self.transaction_overlay.kill(key);
+	fn remove(&mut self, key: &H256) {
+		self.transaction_overlay.remove(key);
 	}
 }
 
@@ -397,7 +397,7 @@ mod tests {
 		jdb.commit(6, &b"1005a".sha3(), Some((4, b"1003a".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
 
-		assert!(jdb.exists(&x));
+		assert!(jdb.contains(&x));
 	}
 
 	#[test]
@@ -407,20 +407,20 @@ mod tests {
 		let h = jdb.insert(b"foo");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.remove(&h);
 		jdb.commit(1, &b"1".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(2, &b"2".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(3, &b"3".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(4, &b"4".sha3(), Some((1, b"1".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(!jdb.exists(&h));
+		assert!(!jdb.contains(&h));
 	}
 
 	#[test]
@@ -432,38 +432,38 @@ mod tests {
 		let bar = jdb.insert(b"bar");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
 
 		jdb.remove(&foo);
 		jdb.remove(&bar);
 		let baz = jdb.insert(b"baz");
 		jdb.commit(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
+		assert!(jdb.contains(&baz));
 
 		let foo = jdb.insert(b"foo");
 		jdb.remove(&baz);
 		jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(!jdb.exists(&bar));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(!jdb.contains(&bar));
+		assert!(jdb.contains(&baz));
 
 		jdb.remove(&foo);
 		jdb.commit(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(!jdb.exists(&bar));
-		assert!(!jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(!jdb.contains(&bar));
+		assert!(!jdb.contains(&baz));
 
 		jdb.commit(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(!jdb.exists(&foo));
-		assert!(!jdb.exists(&bar));
-		assert!(!jdb.exists(&baz));
+		assert!(!jdb.contains(&foo));
+		assert!(!jdb.contains(&bar));
+		assert!(!jdb.contains(&baz));
 	}
 
 	#[test]
@@ -475,8 +475,8 @@ mod tests {
 		let bar = jdb.insert(b"bar");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
 
 		jdb.remove(&foo);
 		let baz = jdb.insert(b"baz");
@@ -487,15 +487,15 @@ mod tests {
 		jdb.commit(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
 
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
+		assert!(jdb.contains(&baz));
 
 		jdb.commit(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
-		assert!(!jdb.exists(&baz));
-		assert!(!jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(!jdb.contains(&baz));
+		assert!(!jdb.contains(&bar));
 	}
 
 	#[test]
@@ -506,19 +506,19 @@ mod tests {
 		let foo = jdb.insert(b"foo");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 
 		jdb.remove(&foo);
 		jdb.commit(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
 		jdb.insert(b"foo");
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 		jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 		jdb.commit(3, &b"2".sha3(), Some((0, b"2".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 	}
 
 	#[test]
@@ -542,11 +542,11 @@ mod tests {
 		jdb.commit(1, &b"1c".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
 
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 
 		jdb.commit(2, &b"2a".sha3(), Some((1, b"1a".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 	}
 
 	#[test]
@@ -570,11 +570,11 @@ mod tests {
 		jdb.commit(1, &b"1c".sha3(), Some((0, b"0".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
 
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 
 		jdb.commit(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 	}
 
 	#[test]
@@ -638,11 +638,11 @@ mod tests {
 
 		{
 			let mut jdb = OverlayRecentDB::new(dir.to_str().unwrap(), None);
-			assert!(jdb.exists(&foo));
-			assert!(jdb.exists(&bar));
+			assert!(jdb.contains(&foo));
+			assert!(jdb.contains(&bar));
 			jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(!jdb.exists(&foo));
+			assert!(!jdb.contains(&foo));
 		}
 	}
 
@@ -745,7 +745,7 @@ mod tests {
 		jdb.insert(b"foo");
 		jdb.commit(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap();	// BROKEN
 		assert!(jdb.can_reconstruct_refs());
-		assert!(jdb.exists(&foo));
+		assert!(jdb.contains(&foo));
 
 		jdb.remove(&foo);
 		jdb.commit(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap();
@@ -753,7 +753,7 @@ mod tests {
 
 		jdb.commit(5, &b"5".sha3(), Some((4, b"4".sha3()))).unwrap();
 		assert!(jdb.can_reconstruct_refs());
-		assert!(!jdb.exists(&foo));
+		assert!(!jdb.contains(&foo));
 	}
 
 	#[test]
@@ -814,12 +814,12 @@ mod tests {
 			jdb.remove(&foo);
 			jdb.commit(2, &b"2".sha3(), Some((0, b"0".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(jdb.exists(&foo));
+			assert!(jdb.contains(&foo));
 
 			jdb.insert(b"foo");
 			jdb.commit(3, &b"3".sha3(), Some((1, b"1".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(jdb.exists(&foo));
+			assert!(jdb.contains(&foo));
 
 		// incantation to reopen the db
 		}; { let mut jdb = OverlayRecentDB::new(dir.to_str().unwrap(), None);
@@ -827,21 +827,21 @@ mod tests {
 			jdb.remove(&foo);
 			jdb.commit(4, &b"4".sha3(), Some((2, b"2".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(jdb.exists(&foo));
+			assert!(jdb.contains(&foo));
 
 		// incantation to reopen the db
 		}; { let mut jdb = OverlayRecentDB::new(dir.to_str().unwrap(), None);
 
 			jdb.commit(5, &b"5".sha3(), Some((3, b"3".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(jdb.exists(&foo));
+			assert!(jdb.contains(&foo));
 
 		// incantation to reopen the db
 		}; { let mut jdb = OverlayRecentDB::new(dir.to_str().unwrap(), None);
 
 			jdb.commit(6, &b"6".sha3(), Some((4, b"4".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(!jdb.exists(&foo));
+			assert!(!jdb.contains(&foo));
 		}
 	}
 
@@ -871,9 +871,9 @@ mod tests {
 			let mut jdb = OverlayRecentDB::new(dir.to_str().unwrap(), None);
 			jdb.commit(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap();
 			assert!(jdb.can_reconstruct_refs());
-			assert!(jdb.exists(&foo));
-			assert!(!jdb.exists(&baz));
-			assert!(!jdb.exists(&bar));
+			assert!(jdb.contains(&foo));
+			assert!(!jdb.contains(&baz));
+			assert!(!jdb.contains(&bar));
 		}
 	}
 
@@ -893,7 +893,7 @@ mod tests {
 		assert!(jdb.can_reconstruct_refs());
 		jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
 
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
 	}
 }
diff --git a/util/src/journaldb/refcounteddb.rs b/util/src/journaldb/refcounteddb.rs
index 31f31f654..fc7da1541 100644
--- a/util/src/journaldb/refcounteddb.rs
+++ b/util/src/journaldb/refcounteddb.rs
@@ -88,11 +88,11 @@ impl RefCountedDB {
 
 impl HashDB for RefCountedDB {
 	fn keys(&self) -> HashMap<H256, i32> { self.forward.keys() }
-	fn lookup(&self, key: &H256) -> Option<&[u8]> { self.forward.lookup(key) }
-	fn exists(&self, key: &H256) -> bool { self.forward.exists(key) }
+	fn get(&self, key: &H256) -> Option<&[u8]> { self.forward.get(key) }
+	fn contains(&self, key: &H256) -> bool { self.forward.contains(key) }
 	fn insert(&mut self, value: &[u8]) -> H256 { let r = self.forward.insert(value); self.inserts.push(r.clone()); r }
 	fn emplace(&mut self, key: H256, value: Bytes) { self.inserts.push(key.clone()); self.forward.emplace(key, value); }
-	fn kill(&mut self, key: &H256) { self.removes.push(key.clone()); }
+	fn remove(&mut self, key: &H256) { self.removes.push(key.clone()); }
 }
 
 impl JournalDB for RefCountedDB {
@@ -212,16 +212,16 @@ mod tests {
 		let mut jdb = RefCountedDB::new_temp();
 		let h = jdb.insert(b"foo");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.remove(&h);
 		jdb.commit(1, &b"1".sha3(), None).unwrap();
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(2, &b"2".sha3(), None).unwrap();
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(3, &b"3".sha3(), Some((0, b"0".sha3()))).unwrap();
-		assert!(jdb.exists(&h));
+		assert!(jdb.contains(&h));
 		jdb.commit(4, &b"4".sha3(), Some((1, b"1".sha3()))).unwrap();
-		assert!(!jdb.exists(&h));
+		assert!(!jdb.contains(&h));
 	}
 
 	#[test]
@@ -251,34 +251,34 @@ mod tests {
 		let foo = jdb.insert(b"foo");
 		let bar = jdb.insert(b"bar");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
 
 		jdb.remove(&foo);
 		jdb.remove(&bar);
 		let baz = jdb.insert(b"baz");
 		jdb.commit(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
+		assert!(jdb.contains(&baz));
 
 		let foo = jdb.insert(b"foo");
 		jdb.remove(&baz);
 		jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
-		assert!(!jdb.exists(&bar));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(!jdb.contains(&bar));
+		assert!(jdb.contains(&baz));
 
 		jdb.remove(&foo);
 		jdb.commit(3, &b"3".sha3(), Some((2, b"2".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
-		assert!(!jdb.exists(&bar));
-		assert!(!jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(!jdb.contains(&bar));
+		assert!(!jdb.contains(&baz));
 
 		jdb.commit(4, &b"4".sha3(), Some((3, b"3".sha3()))).unwrap();
-		assert!(!jdb.exists(&foo));
-		assert!(!jdb.exists(&bar));
-		assert!(!jdb.exists(&baz));
+		assert!(!jdb.contains(&foo));
+		assert!(!jdb.contains(&bar));
+		assert!(!jdb.contains(&baz));
 	}
 
 	#[test]
@@ -289,8 +289,8 @@ mod tests {
 		let foo = jdb.insert(b"foo");
 		let bar = jdb.insert(b"bar");
 		jdb.commit(0, &b"0".sha3(), None).unwrap();
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
 
 		jdb.remove(&foo);
 		let baz = jdb.insert(b"baz");
@@ -299,13 +299,13 @@ mod tests {
 		jdb.remove(&bar);
 		jdb.commit(1, &b"1b".sha3(), Some((0, b"0".sha3()))).unwrap();
 
-		assert!(jdb.exists(&foo));
-		assert!(jdb.exists(&bar));
-		assert!(jdb.exists(&baz));
+		assert!(jdb.contains(&foo));
+		assert!(jdb.contains(&bar));
+		assert!(jdb.contains(&baz));
 
 		jdb.commit(2, &b"2b".sha3(), Some((1, b"1b".sha3()))).unwrap();
-		assert!(jdb.exists(&foo));
-		assert!(!jdb.exists(&baz));
-		assert!(!jdb.exists(&bar));
+		assert!(jdb.contains(&foo));
+		assert!(!jdb.contains(&baz));
+		assert!(!jdb.contains(&bar));
 	}
 }
diff --git a/util/src/memorydb.rs b/util/src/memorydb.rs
index cfd7237e6..ea77f4aa2 100644
--- a/util/src/memorydb.rs
+++ b/util/src/memorydb.rs
@@ -162,7 +162,7 @@ impl MemoryDB {
 static NULL_RLP_STATIC: [u8; 1] = [0x80; 1];
 
 impl HashDB for MemoryDB {
-	fn lookup(&self, key: &H256) -> Option<&[u8]> {
+	fn get(&self, key: &H256) -> Option<&[u8]> {
 		if key == &SHA3_NULL_RLP {
 			return Some(&NULL_RLP_STATIC);
 		}
@@ -176,7 +176,7 @@ impl HashDB for MemoryDB {
 		self.data.iter().filter_map(|(k, v)| if v.1 != 0 {Some((k.clone(), v.1))} else {None}).collect()
 	}
 
-	fn exists(&self, key: &H256) -> bool {
+	fn contains(&self, key: &H256) -> bool {
 		if key == &SHA3_NULL_RLP {
 			return true;
 		}
@@ -222,7 +222,7 @@ impl HashDB for MemoryDB {
 		self.data.insert(key, (value, 1));
 	}
 
-	fn kill(&mut self, key: &H256) {
+	fn remove(&mut self, key: &H256) {
 		if key == &SHA3_NULL_RLP {
 			return;
 		}
diff --git a/util/src/overlaydb.rs b/util/src/overlaydb.rs
index ce4e894c8..b1ea44dac 100644
--- a/util/src/overlaydb.rs
+++ b/util/src/overlaydb.rs
@@ -92,7 +92,7 @@ impl OverlayDB {
 	///
 	/// Returns either an error or the number of items changed in the backing database.
 	///
-	/// Will return an error if the number of `kill()`s ever exceeds the number of
+	/// Will return an error if the number of `remove()`s ever exceeds the number of
 	/// `insert()`s for any key. This will leave the database in an undeterminate
 	/// state. Don't ever let it happen.
 	///
@@ -104,15 +104,15 @@ impl OverlayDB {
 	/// fn main() {
 	///   let mut m = OverlayDB::new_temp();
 	///   let key = m.insert(b"foo");			// insert item.
-	///   assert!(m.exists(&key));				// key exists (in memory).
+	///   assert!(m.contains(&key));			// key exists (in memory).
 	///   assert_eq!(m.commit().unwrap(), 1);	// 1 item changed.
-	///   assert!(m.exists(&key));				// key still exists (in backing).
-	///   m.kill(&key);							// delete item.
-	///   assert!(!m.exists(&key));				// key "doesn't exist" (though still does in backing).
-	///   m.kill(&key);							// oh dear... more kills than inserts for the key...
+	///   assert!(m.contains(&key));			// key still exists (in backing).
+	///   m.remove(&key);							// delete item.
+	///   assert!(!m.contains(&key));			// key "doesn't exist" (though still does in backing).
+	///   m.remove(&key);							// oh dear... more removes than inserts for the key...
 	///   //m.commit().unwrap();				// this commit/unwrap would cause a panic.
-	///   m.revert();							// revert both kills.
-	///   assert!(m.exists(&key));				// key now still exists.
+	///   m.revert();							// revert both removes.
+	///   assert!(m.contains(&key));			// key now still exists.
 	/// }
 	/// ```
 	pub fn commit(&mut self) -> Result<u32, UtilError> {
@@ -224,7 +224,7 @@ impl HashDB for OverlayDB {
 		}
 		ret
 	}
-	fn lookup(&self, key: &H256) -> Option<&[u8]> {
+	fn get(&self, key: &H256) -> Option<&[u8]> {
 		// return ok if positive; if negative, check backing - might be enough references there to make
 		// it positive again.
 		let k = self.overlay.raw(key);
@@ -249,7 +249,7 @@ impl HashDB for OverlayDB {
 			}
 		}
 	}
-	fn exists(&self, key: &H256) -> bool {
+	fn contains(&self, key: &H256) -> bool {
 		// return ok if positive; if negative, check backing - might be enough references there to make
 		// it positive again.
 		let k = self.overlay.raw(key);
@@ -271,7 +271,7 @@ impl HashDB for OverlayDB {
 	}
 	fn insert(&mut self, value: &[u8]) -> H256 { self.overlay.insert(value) }
 	fn emplace(&mut self, key: H256, value: Bytes) { self.overlay.emplace(key, value); }
-	fn kill(&mut self, key: &H256) { self.overlay.kill(key); }
+	fn remove(&mut self, key: &H256) { self.overlay.remove(key); }
 }
 
 #[test]
diff --git a/util/src/trie/triedb.rs b/util/src/trie/triedb.rs
index fccd5da90..9cd3a8c41 100644
--- a/util/src/trie/triedb.rs
+++ b/util/src/trie/triedb.rs
@@ -133,7 +133,7 @@ impl<'db> TrieDB<'db> {
 
 	/// Get the data of the root node.
 	fn root_data(&self) -> &[u8] {
-		self.db.lookup(&self.root).expect("Trie root not found!")
+		self.db.get(&self.root).expect("Trie root not found!")
 	}
 
 	/// Get the root node as a `Node`.
@@ -184,7 +184,7 @@ impl<'db> TrieDB<'db> {
 
 	/// Return optional data for a key given as a `NibbleSlice`. Returns `None` if no data exists.
 	fn do_lookup<'a, 'key>(&'a self, key: &NibbleSlice<'key>) -> Option<&'a [u8]> where 'a: 'key {
-		let root_rlp = self.db.lookup(&self.root).expect("Trie root not found!");
+		let root_rlp = self.db.get(&self.root).expect("Trie root not found!");
 		self.get_from_node(&root_rlp, key)
 	}
 
@@ -213,7 +213,7 @@ impl<'db> TrieDB<'db> {
 		// check if its sha3 + len
 		let r = Rlp::new(node);
 		match r.is_data() && r.size() == 32 {
-			true => self.db.lookup(&r.as_val::<H256>()).unwrap_or_else(|| panic!("Not found! {:?}", r.as_val::<H256>())),
+			true => self.db.get(&r.as_val::<H256>()).unwrap_or_else(|| panic!("Not found! {:?}", r.as_val::<H256>())),
 			false => node
 		}
 	}
@@ -349,7 +349,7 @@ impl<'db> Trie for TrieDB<'db> {
 impl<'db> fmt::Debug for TrieDB<'db> {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		try!(writeln!(f, "c={:?} [", self.hash_count));
-		let root_rlp = self.db.lookup(&self.root).expect("Trie root not found!");
+		let root_rlp = self.db.get(&self.root).expect("Trie root not found!");
 		try!(self.fmt_all(Node::decoded(root_rlp), f, 0));
 		writeln!(f, "]")
 	}
diff --git a/util/src/trie/triedbmut.rs b/util/src/trie/triedbmut.rs
index afabd6437..65d5bbd2b 100644
--- a/util/src/trie/triedbmut.rs
+++ b/util/src/trie/triedbmut.rs
@@ -87,7 +87,7 @@ impl<'db> TrieDBMut<'db> {
 	/// Create a new trie with the backing database `db` and `root`.
 	/// Returns an error if `root` does not exist.
 	pub fn from_existing(db: &'db mut HashDB, root: &'db mut H256) -> Result<Self, TrieError> {
-		if !db.exists(root) {
+		if !db.contains(root) {
 			Err(TrieError::InvalidStateRoot)
 		} else {
 			Ok(TrieDBMut {
@@ -143,7 +143,7 @@ impl<'db> TrieDBMut<'db> {
 	/// Set the trie to a new root node's RLP, inserting the new RLP into the backing database
 	/// and removing the old.
 	fn set_root_rlp(&mut self, root_data: &[u8]) {
-		self.db.kill(&self.root);
+		self.db.remove(&self.root);
 		*self.root = self.db.insert(root_data);
 		self.hash_count += 1;
 		trace!("set_root_rlp {:?} {:?}", root_data.pretty(), self.root);
@@ -174,7 +174,7 @@ impl<'db> TrieDBMut<'db> {
 
 	/// Get the root node's RLP.
 	fn root_node(&self) -> Node {
-		Node::decoded(self.db.lookup(&self.root).expect("Trie root not found!"))
+		Node::decoded(self.db.get(&self.root).expect("Trie root not found!"))
 	}
 
 	/// Get the root node as a `Node`.
@@ -225,7 +225,7 @@ impl<'db> TrieDBMut<'db> {
 
 	/// Return optional data for a key given as a `NibbleSlice`. Returns `None` if no data exists.
 	fn do_lookup<'a, 'key>(&'a self, key: &NibbleSlice<'key>) -> Option<&'a [u8]> where 'a: 'key {
-		let root_rlp = self.db.lookup(&self.root).expect("Trie root not found!");
+		let root_rlp = self.db.get(&self.root).expect("Trie root not found!");
 		self.get_from_node(&root_rlp, key)
 	}
 
@@ -254,7 +254,7 @@ impl<'db> TrieDBMut<'db> {
 		// check if its sha3 + len
 		let r = Rlp::new(node);
 		match r.is_data() && r.size() == 32 {
-			true => self.db.lookup(&r.as_val::<H256>()).expect("Not found!"),
+			true => self.db.get(&r.as_val::<H256>()).expect("Not found!"),
 			false => node
 		}
 	}
@@ -266,7 +266,7 @@ impl<'db> TrieDBMut<'db> {
 		trace!("ADD: {:?} {:?}", key, value.pretty());
 		// determine what the new root is, insert new nodes and remove old as necessary.
 		let mut todo: Journal = Journal::new();
-		let root_rlp = self.augmented(self.db.lookup(&self.root).expect("Trie root not found!"), key, value, &mut todo);
+		let root_rlp = self.augmented(self.db.get(&self.root).expect("Trie root not found!"), key, value, &mut todo);
 		self.apply(todo);
 		self.set_root_rlp(&root_rlp);
 		trace!("/");
@@ -279,7 +279,7 @@ impl<'db> TrieDBMut<'db> {
 		trace!("DELETE: {:?}", key);
 		// determine what the new root is, insert new nodes and remove old as necessary.
 		let mut todo: Journal = Journal::new();
-		match self.cleared_from_slice(self.db.lookup(&self.root).expect("Trie root not found!"), key, &mut todo) {
+		match self.cleared_from_slice(self.db.get(&self.root).expect("Trie root not found!"), key, &mut todo) {
 			Some(root_rlp) => {
 				self.apply(todo);
 				self.set_root_rlp(&root_rlp);
@@ -335,7 +335,7 @@ impl<'db> TrieDBMut<'db> {
 		}
 		else if rlp.is_data() && rlp.size() == 32 {
 			let h = rlp.as_val();
-			let r = self.db.lookup(&h).unwrap_or_else(||{
+			let r = self.db.get(&h).unwrap_or_else(||{
 				println!("Node not found! rlp={:?}, node_hash={:?}", rlp.as_raw().pretty(), h);
 				println!("Journal: {:?}", journal);
 				panic!();
@@ -670,7 +670,7 @@ impl<'db> TrieMut for TrieDBMut<'db> {
 impl<'db> fmt::Debug for TrieDBMut<'db> {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		try!(writeln!(f, "c={:?} [", self.hash_count));
-		let root_rlp = self.db.lookup(&self.root).expect("Trie root not found!");
+		let root_rlp = self.db.get(&self.root).expect("Trie root not found!");
 		try!(self.fmt_all(Node::decoded(root_rlp), f, 0));
 		writeln!(f, "]")
 	}

From 129ce97ad57f21021873ea2e8651724d997cba1f Mon Sep 17 00:00:00 2001
From: Gav Wood <gavin@ethcore.io>
Date: Thu, 23 Jun 2016 11:30:48 +0200
Subject: [PATCH 18/22] Constants for SF# and update.

---
 ethcore/src/block.rs      |  3 ++-
 ethcore/src/client/mod.rs | 12 ++++++------
 ethcore/src/env_info.rs   |  2 +-
 3 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs
index ff05b5af1..f7288c85b 100644
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -288,6 +288,7 @@ impl<'x> OpenBlock<'x> {
 	/// Get the environment info concerning this block.
 	pub fn env_info(&self) -> EnvInfo {
 		// TODO: memoise.
+		const SOFT_FORK_BLOCK: u64 = 1775000;
 		EnvInfo {
 			number: self.block.base.header.number,
 			author: self.block.base.header.author.clone(),
@@ -296,7 +297,7 @@ impl<'x> OpenBlock<'x> {
 			last_hashes: self.last_hashes.clone(),		// TODO: should be a reference.
 			gas_used: self.block.receipts.last().map_or(U256::zero(), |r| r.gas_used),
 			gas_limit: self.block.base.header.gas_limit.clone(),
-			dao_rescue_block_gas_limit: if self.block.base.header.number == 1760000 { Some(self.block.base.header.gas_limit) } else { self.dao_rescue_block_gas_limit },
+			dao_rescue_block_gas_limit: if self.block.base.header.number == SOFT_FORK_BLOCK { Some(self.block.base.header.gas_limit) } else { self.dao_rescue_block_gas_limit },
 		}
 	}
 
diff --git a/ethcore/src/client/mod.rs b/ethcore/src/client/mod.rs
index 3ed56573a..86686cb4c 100644
--- a/ethcore/src/client/mod.rs
+++ b/ethcore/src/client/mod.rs
@@ -225,19 +225,19 @@ pub trait BlockChainClient : Sync + Send {
 		}
 	}
 
-
-	/// Get `Some` gas limit of block 1_760_000, or `None` if chain is not yet that long.
+	/// Get `Some` gas limit of SOFT_FORK_BLOCK, or `None` if chain is not yet that long.
 	fn dao_rescue_block_gas_limit(&self, chain_hash: H256) -> Option<U256> {
+		const SOFT_FORK_BLOCK: u64 = 1775000;
 		// shortcut if the canon chain is already known.
-		if self.chain_info().best_block_number > 1_761_000 {
-			return self.block_header(BlockID::Number(1_760_000)).map(|header| HeaderView::new(&header).gas_limit());
+		if self.chain_info().best_block_number > SOFT_FORK_BLOCK + 1000 {
+			return self.block_header(BlockID::Number(SOFT_FORK_BLOCK)).map(|header| HeaderView::new(&header).gas_limit());
 		}
 		// otherwise check according to `chain_hash`.
 		if let Some(mut header) = self.block_header(BlockID::Hash(chain_hash)) {
-			if HeaderView::new(&header).number() < 1_760_000 {
+			if HeaderView::new(&header).number() < SOFT_FORK_BLOCK {
 				None
 			} else {
-				while HeaderView::new(&header).number() != 1_760_000 {
+				while HeaderView::new(&header).number() != SOFT_FORK_BLOCK {
 					header = self.block_header(BlockID::Hash(HeaderView::new(&header).parent_hash())).expect("chain is complete; parent of chain entry must be in chain; qed");
 				}
 				Some(HeaderView::new(&header).gas_limit())
diff --git a/ethcore/src/env_info.rs b/ethcore/src/env_info.rs
index a38a31ff7..8304fcc03 100644
--- a/ethcore/src/env_info.rs
+++ b/ethcore/src/env_info.rs
@@ -40,7 +40,7 @@ pub struct EnvInfo {
 	/// The gas used.
 	pub gas_used: U256,
 
-	/// Block gas limit at DAO rescue block #1760000 or None if not yet there.
+	/// Block gas limit at DAO rescue block SOFT_FORK_BLOCK or None if not yet there.
 	pub dao_rescue_block_gas_limit: Option<U256>,
 }
 

From 5bf906625bb584d9c213097b6fd19bd5d8809d61 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= <tomasz@ethcore.io>
Date: Thu, 23 Jun 2016 12:04:54 +0200
Subject: [PATCH 19/22] Fixing warnings

---
 Cargo.lock                     | 20 ++++++++++----------
 ethcore/src/block.rs           |  3 +++
 ethcore/src/error.rs           |  6 +++---
 ethcore/src/ethereum/ethash.rs |  2 +-
 hook.sh                        |  2 +-
 parity/main.rs                 |  2 +-
 sync/src/chain.rs              |  2 +-
 util/src/network/host.rs       |  1 +
 8 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index dc37f0431..f735f0e54 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3,7 +3,7 @@ name = "parity"
 version = "1.2.0"
 dependencies = [
  "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "clippy 0.0.76 (registry+https://github.com/rust-lang/crates.io-index)",
+ "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
  "ctrlc 1.1.1 (git+https://github.com/ethcore/rust-ctrlc.git)",
  "daemonize 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "docopt 0.6.80 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -129,15 +129,15 @@ dependencies = [
 
 [[package]]
 name = "clippy"
-version = "0.0.76"
+version = "0.0.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "clippy_lints 0.0.76 (registry+https://github.com/rust-lang/crates.io-index)",
+ "clippy_lints 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "clippy_lints"
-version = "0.0.76"
+version = "0.0.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -250,7 +250,7 @@ name = "ethcore"
 version = "1.2.0"
 dependencies = [
  "bloomchain 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "clippy 0.0.76 (registry+https://github.com/rust-lang/crates.io-index)",
+ "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
  "crossbeam 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "ethash 1.2.0",
@@ -275,7 +275,7 @@ dependencies = [
 name = "ethcore-dapps"
 version = "1.2.0"
 dependencies = [
- "clippy 0.0.76 (registry+https://github.com/rust-lang/crates.io-index)",
+ "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
  "ethcore-rpc 1.2.0",
  "ethcore-util 1.2.0",
  "hyper 0.9.3 (git+https://github.com/ethcore/hyper)",
@@ -337,7 +337,7 @@ dependencies = [
 name = "ethcore-rpc"
 version = "1.2.0"
 dependencies = [
- "clippy 0.0.76 (registry+https://github.com/rust-lang/crates.io-index)",
+ "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
  "ethash 1.2.0",
  "ethcore 1.2.0",
  "ethcore-devtools 1.2.0",
@@ -360,7 +360,7 @@ dependencies = [
 name = "ethcore-signer"
 version = "1.2.0"
 dependencies = [
- "clippy 0.0.76 (registry+https://github.com/rust-lang/crates.io-index)",
+ "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.0",
@@ -379,7 +379,7 @@ dependencies = [
  "arrayvec 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
  "bigint 0.1.0",
  "chrono 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
- "clippy 0.0.76 (registry+https://github.com/rust-lang/crates.io-index)",
+ "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
  "crossbeam 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "elastic-array 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -451,7 +451,7 @@ dependencies = [
 name = "ethsync"
 version = "1.2.0"
 dependencies = [
- "clippy 0.0.76 (registry+https://github.com/rust-lang/crates.io-index)",
+ "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.0",
diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs
index ff05b5af1..a5f1d6df9 100644
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -489,6 +489,7 @@ pub fn enact(
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
+#[cfg_attr(feature="dev", allow(too_many_arguments))]
 pub fn enact_bytes(
 	block_bytes: &[u8],
 	engine: &Engine,
@@ -505,6 +506,7 @@ pub fn enact_bytes(
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
+#[cfg_attr(feature="dev", allow(too_many_arguments))]
 pub fn enact_verified(
 	block: &PreverifiedBlock,
 	engine: &Engine,
@@ -520,6 +522,7 @@ pub fn enact_verified(
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header. Seal the block aferwards
+#[cfg_attr(feature="dev", allow(too_many_arguments))]
 pub fn enact_and_seal(
 	block_bytes: &[u8],
 	engine: &Engine,
diff --git a/ethcore/src/error.rs b/ethcore/src/error.rs
index 9be800e13..92d3cbe6b 100644
--- a/ethcore/src/error.rs
+++ b/ethcore/src/error.rs
@@ -228,7 +228,7 @@ pub enum Error {
 	/// The value of the nonce or mishash is invalid.
 	PowInvalid,
 	/// Error concerning TrieDBs
-	TrieError(TrieError),
+	Trie(TrieError),
 }
 
 impl fmt::Display for Error {
@@ -244,7 +244,7 @@ impl fmt::Display for Error {
 				f.write_fmt(format_args!("Unknown engine name ({})", name)),
 			Error::PowHashInvalid => f.write_str("Invalid or out of date PoW hash."),
 			Error::PowInvalid => f.write_str("Invalid nonce or mishash"),
-			Error::TrieError(ref err) => f.write_fmt(format_args!("{}", err)),
+			Error::Trie(ref err) => f.write_fmt(format_args!("{}", err)),
 		}
 	}
 }
@@ -308,7 +308,7 @@ impl From<IoError> for Error {
 
 impl From<TrieError> for Error {
 	fn from(err: TrieError) -> Error {
-		Error::TrieError(err)
+		Error::Trie(err)
 	}
 }
 
diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs
index 0e90e3867..700458934 100644
--- a/ethcore/src/ethereum/ethash.rs
+++ b/ethcore/src/ethereum/ethash.rs
@@ -106,7 +106,7 @@ impl Engine for Ethash {
 		} else {
 			let mut s = Schedule::new_homestead();
 			if self.ethash_params.dao_rescue_soft_fork {
-				s.reject_dao_transactions = env_info.dao_rescue_block_gas_limit.map(|x| x <= 4_000_000.into()).unwrap_or(false);
+				s.reject_dao_transactions = env_info.dao_rescue_block_gas_limit.map_or(false, |x| x <= 4_000_000.into());
 			}
 			s
 		}
diff --git a/hook.sh b/hook.sh
index 1b15aafa8..9ce825f80 100755
--- a/hook.sh
+++ b/hook.sh
@@ -7,6 +7,6 @@ echo "set -e" >> $FILE
 echo "cargo build --features dev" >> $FILE
 # Build tests
 echo "cargo test --no-run --features dev \\" >> $FILE
-echo " -p ethkey -p ethstore -p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity -p ethcore-dapps -p ethcore-signer -p ethcore-db" >> $FILE
+echo " -p ethkey -p ethstore -p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity -p ethcore-dapps -p ethcore-signer" >> $FILE
 echo "" >> $FILE
 chmod +x $FILE
diff --git a/parity/main.rs b/parity/main.rs
index 0b64d0644..f73711e93 100644
--- a/parity/main.rs
+++ b/parity/main.rs
@@ -546,7 +546,7 @@ fn execute_account_cli(conf: Configuration) {
 }
 
 fn execute_wallet_cli(conf: Configuration) {
-	use ethcore::ethstore::{PresaleWallet, SecretStore, EthStore};
+	use ethcore::ethstore::{PresaleWallet, EthStore};
 	use ethcore::ethstore::dir::DiskDirectory;
 	use ethcore::account_provider::AccountProvider;
 
diff --git a/sync/src/chain.rs b/sync/src/chain.rs
index 55e4e93b2..33b04eca0 100644
--- a/sync/src/chain.rs
+++ b/sync/src/chain.rs
@@ -946,7 +946,7 @@ impl ChainSync {
 			let tx = try!(r.at(i)).as_raw().to_vec();
 			transactions.push(tx);
 		}
-		let _ = io.chain().queue_transactions(transactions);
+		io.chain().queue_transactions(transactions);
 		Ok(())
 	}
 
diff --git a/util/src/network/host.rs b/util/src/network/host.rs
index 7de581b4d..03f37fa61 100644
--- a/util/src/network/host.rs
+++ b/util/src/network/host.rs
@@ -735,6 +735,7 @@ impl<Message> Host<Message> where Message: Send + Sync + Clone {
 		self.kill_connection(token, io, true);
 	}
 
+	#[cfg_attr(feature="dev", allow(collapsible_if))]
 	fn session_readable(&self, token: StreamToken, io: &IoContext<NetworkIoMessage<Message>>) {
 		let mut ready_data: Vec<ProtocolId> = Vec::new();
 		let mut packet_data: Vec<(ProtocolId, PacketId, Vec<u8>)> = Vec::new();

From 19585947a5194ddbd38cd87f693fca5c013081b7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Drwi=C4=99ga?= <tomasz@ethcore.io>
Date: Thu, 23 Jun 2016 14:46:31 +0200
Subject: [PATCH 20/22] Fixing jit compilation

---
 ethcore/src/evm/jit.rs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/ethcore/src/evm/jit.rs b/ethcore/src/evm/jit.rs
index d46ad917f..4f43d327b 100644
--- a/ethcore/src/evm/jit.rs
+++ b/ethcore/src/evm/jit.rs
@@ -16,9 +16,8 @@
 
 //! Just in time compiler execution environment.
 use common::*;
-use trace::VMTracer;
 use evmjit;
-use evm::{self, Error, GasLeft};
+use evm::{self, GasLeft};
 
 /// Should be used to convert jit types to ethcore
 trait FromJit<T>: Sized {
@@ -303,7 +302,7 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
 
 #[derive(Default)]
 pub struct JitEvm {
-	ctxt: Option<evmjit::ContextHandle>,
+	context: Option<evmjit::ContextHandle>,
 }
 
 impl evm::Evm for JitEvm {
@@ -347,7 +346,7 @@ impl evm::Evm for JitEvm {
 		data.timestamp = ext.env_info().timestamp as i64;
 
 		self.context = Some(unsafe { evmjit::ContextHandle::new(data, schedule, &mut ext_handle) });
-		let context = self.context.as_ref_mut().unwrap();
+		let mut context = self.context.as_mut().unwrap();
 		let res = context.exec();
 
 		match res {

From 27b18df3dd12aa3850e4e1e05faac48675e498b4 Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Thu, 23 Jun 2016 19:56:43 +0300
Subject: [PATCH 21/22] further rocksdb tuning (#1409)

---
 util/src/kvdb.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/util/src/kvdb.rs b/util/src/kvdb.rs
index 66a4a02ee..c1be5c691 100644
--- a/util/src/kvdb.rs
+++ b/util/src/kvdb.rs
@@ -20,8 +20,10 @@ use std::default::Default;
 use rocksdb::{DB, Writable, WriteBatch, IteratorMode, DBVector, DBIterator,
 	IndexType, Options, DBCompactionStyle, BlockBasedOptions, Direction};
 
-const DB_FILE_SIZE_BASE: u64 = 10 * 1024 * 1024;
-const DB_FILE_SIZE_MULTIPLIER: i32 = 5;
+const DB_FILE_SIZE_BASE: u64 = 128 * 1024 * 1024;
+const DB_FILE_SIZE_MULTIPLIER: i32 = 1;
+const DB_BACKGROUND_FLUSHES: i32 = 4;
+const DB_BACKGROUND_COMPACTIONS: i32 = 4;
 
 /// Write transaction. Batches a sequence of put/delete operations for efficiency.
 pub struct DBTransaction {
@@ -116,6 +118,8 @@ impl Database {
 		opts.set_compaction_style(DBCompactionStyle::DBUniversalCompaction);
 		opts.set_target_file_size_base(DB_FILE_SIZE_BASE);
 		opts.set_target_file_size_multiplier(DB_FILE_SIZE_MULTIPLIER);
+		opts.set_max_background_flushes(DB_BACKGROUND_FLUSHES);
+		opts.set_max_background_compactions(DB_BACKGROUND_COMPACTIONS);
 		if let Some(cache_size) = config.cache_size {
 			// half goes to read cache
 			opts.set_block_cache_size_mb(cache_size as u64 / 2);

From 416781a8d4a9e4e88937949b23f91aa54613d6e5 Mon Sep 17 00:00:00 2001
From: Arkadiy Paronyan <arkady.paronyan@gmail.com>
Date: Thu, 23 Jun 2016 18:57:42 +0200
Subject: [PATCH 22/22] Tweaked cli options (#1407)

---
 parity/cli.rs           | 26 ++++++++++++++++----------
 parity/configuration.rs |  8 ++++----
 parity/main.rs          |  6 +++---
 3 files changed, 23 insertions(+), 17 deletions(-)

diff --git a/parity/cli.rs b/parity/cli.rs
index 7fd8d6482..cc68a8d4d 100644
--- a/parity/cli.rs
+++ b/parity/cli.rs
@@ -82,7 +82,7 @@ Networking Options:
   --reserved-only          Connect only to reserved nodes.
 
 API and Console Options:
-  --jsonrpc-off            Disable the JSON-RPC API server.
+  --no-jsonrpc             Disable the JSON-RPC API server.
   --jsonrpc-port PORT      Specify the port portion of the JSONRPC API server
                            [default: 8545].
   --jsonrpc-interface IP   Specify the hostname portion of the JSONRPC API
@@ -95,13 +95,13 @@ API and Console Options:
                            ethcore, ethcore_set, traces.
                            [default: web3,eth,net,ethcore,personal,traces].
 
-  --ipc-off                Disable JSON-RPC over IPC service.
+  --no-ipc                 Disable JSON-RPC over IPC service.
   --ipc-path PATH          Specify custom path for JSON-RPC over IPC service
                            [default: $HOME/.parity/jsonrpc.ipc].
   --ipc-apis APIS          Specify custom API set available via JSON-RPC over
                            IPC [default: web3,eth,net,ethcore,personal,traces,rpc].
 
-  --dapps-off              Disable the Dapps server (e.g. status page).
+  --no-dapps               Disable the Dapps server (e.g. status page).
   --dapps-port PORT        Specify the port portion of the Dapps server
                            [default: 8080].
   --dapps-interface IP     Specify the hostname portion of the Dapps
@@ -116,7 +116,7 @@ API and Console Options:
   --dapps-path PATH        Specify directory where dapps should be installed.
                            [default: $HOME/.parity/dapps]
 
-  --signer-off             Disable Trusted Signer WebSocket endpoint used by
+  --signer                 Enable Trusted Signer WebSocket endpoint used by
                            Signer UIs.
   --signer-port PORT       Specify the port of Trusted Signer server
                            [default: 8180].
@@ -160,7 +160,7 @@ Footprint Options:
                            light - early merges with partial tracking. Fast,
                            light, and experimental!
                            auto - use the method most recently synced or
-                           default to archive if none synced [default: auto].
+                           default to fast if none synced [default: auto].
   --cache-pref-size BYTES  Specify the prefered size of the blockchain cache in
                            bytes [default: 16384].
   --cache-max-size BYTES   Specify the maximum size of the blockchain cache in
@@ -197,13 +197,16 @@ Legacy Options:
   --nodekey KEY            Equivalent to --node-key KEY.
   --nodiscover             Equivalent to --no-discovery.
   -j --jsonrpc             Does nothing; JSON-RPC is on by default now.
+  --jsonrpc-off            Equivalent to --no-jsonrpc.
   -w --webapp              Does nothing; dapps server is on by default now.
+  --dapps-off              Equivalent to --no-dapps.
   --rpc                    Does nothing; JSON-RPC is on by default now.
   --rpcaddr IP             Equivalent to --jsonrpc-interface IP.
   --rpcport PORT           Equivalent to --jsonrpc-port PORT.
   --rpcapi APIS            Equivalent to --jsonrpc-apis APIS.
   --rpccorsdomain URL      Equivalent to --jsonrpc-cors URL.
-  --ipcdisable             Equivalent to --ipc-off.
+  --ipcdisable             Equivalent to --no-ipc.
+  --ipc-off                Equivalent to --no-ipc.
   --ipcapi APIS            Equivalent to --ipc-apis APIS.
   --ipcpath PATH           Equivalent to --ipc-path PATH.
   --gasprice WEI           Minimum amount of Wei per GAS to be paid for a
@@ -260,21 +263,21 @@ pub struct Args {
 	pub flag_cache_pref_size: usize,
 	pub flag_cache_max_size: usize,
 	pub flag_queue_max_size: usize,
-	pub flag_jsonrpc_off: bool,
+	pub flag_no_jsonrpc: bool,
 	pub flag_jsonrpc_interface: String,
 	pub flag_jsonrpc_port: u16,
 	pub flag_jsonrpc_cors: Option<String>,
 	pub flag_jsonrpc_apis: String,
-	pub flag_ipc_off: bool,
+	pub flag_no_ipc: bool,
 	pub flag_ipc_path: String,
 	pub flag_ipc_apis: String,
-	pub flag_dapps_off: bool,
+	pub flag_no_dapps: bool,
 	pub flag_dapps_port: u16,
 	pub flag_dapps_interface: String,
 	pub flag_dapps_user: Option<String>,
 	pub flag_dapps_pass: Option<String>,
 	pub flag_dapps_path: String,
-	pub flag_signer_off: bool,
+	pub flag_signer: bool,
 	pub flag_signer_port: u16,
 	pub flag_signer_path: String,
 	pub flag_no_token: bool,
@@ -312,6 +315,9 @@ pub struct Args {
 	pub flag_testnet: bool,
 	pub flag_networkid: Option<String>,
 	pub flag_ipcdisable: bool,
+	pub flag_ipc_off: bool,
+	pub flag_jsonrpc_off: bool,
+	pub flag_dapps_off: bool,
 	pub flag_ipcpath: Option<String>,
 	pub flag_ipcapi: Option<String>,
 	pub flag_db_cache_size: Option<usize>,
diff --git a/parity/configuration.rs b/parity/configuration.rs
index 4196564b5..4560324d3 100644
--- a/parity/configuration.rs
+++ b/parity/configuration.rs
@@ -265,7 +265,7 @@ impl Configuration {
 			"light" => journaldb::Algorithm::EarlyMerge,
 			"fast" => journaldb::Algorithm::OverlayRecent,
 			"basic" => journaldb::Algorithm::RefCounted,
-			"auto" => self.find_best_db(spec).unwrap_or(journaldb::Algorithm::Archive),
+			"auto" => self.find_best_db(spec).unwrap_or(journaldb::Algorithm::OverlayRecent),
 			_ => { die!("Invalid pruning method given."); }
 		};
 
@@ -359,7 +359,7 @@ impl Configuration {
 
 	pub fn ipc_settings(&self) -> IpcConfiguration {
 		IpcConfiguration {
-			enabled: !(self.args.flag_ipcdisable || self.args.flag_ipc_off),
+			enabled: !(self.args.flag_ipcdisable || self.args.flag_ipc_off || self.args.flag_no_ipc),
 			socket_addr: self.ipc_path(),
 			apis: self.args.flag_ipcapi.clone().unwrap_or(self.args.flag_ipc_apis.clone()),
 		}
@@ -372,7 +372,7 @@ impl Configuration {
 			chain: self.chain(),
 			max_peers: self.max_peers(),
 			network_port: self.net_port(),
-			rpc_enabled: !self.args.flag_jsonrpc_off,
+			rpc_enabled: !self.args.flag_jsonrpc_off && !self.args.flag_no_jsonrpc,
 			rpc_interface: self.args.flag_rpcaddr.clone().unwrap_or(self.args.flag_jsonrpc_interface.clone()),
 			rpc_port: self.args.flag_rpcport.unwrap_or(self.args.flag_jsonrpc_port),
 		}
@@ -432,7 +432,7 @@ impl Configuration {
 	}
 
 	pub fn signer_port(&self) -> Option<u16> {
-		if self.args.flag_signer_off {
+		if !self.args.flag_signer {
 			None
 		} else {
 			Some(self.args.flag_signer_port)
diff --git a/parity/main.rs b/parity/main.rs
index f73711e93..8beba61b5 100644
--- a/parity/main.rs
+++ b/parity/main.rs
@@ -192,14 +192,14 @@ fn execute_client(conf: Configuration, spec: Spec, client_config: ClientConfig)
 	let sync_config = conf.sync_config(&spec);
 
 	// Create and display a new token for UIs.
-	if !conf.args.flag_signer_off && !conf.args.flag_no_token {
+	if conf.args.flag_signer && !conf.args.flag_no_token {
 		new_token(conf.directories().signer).unwrap_or_else(|e| {
 			die!("Error generating token: {:?}", e)
 		});
 	}
 
 	// Display warning about using unlock with signer
-	if !conf.args.flag_signer_off && conf.args.flag_unlock.is_some() {
+	if conf.args.flag_signer && conf.args.flag_unlock.is_some() {
 		warn!("Using Trusted Signer and --unlock is not recommended!");
 		warn!("NOTE that Signer will not ask you to confirm transactions from unlocked account.");
 	}
@@ -264,7 +264,7 @@ fn execute_client(conf: Configuration, spec: Spec, client_config: ClientConfig)
 
 	if conf.args.flag_webapp { println!("WARNING: Flag -w/--webapp is deprecated. Dapps server is now on by default. Ignoring."); }
 	let dapps_server = dapps::new(dapps::Configuration {
-		enabled: !conf.args.flag_dapps_off,
+		enabled: !conf.args.flag_dapps_off && !conf.args.flag_no_dapps,
 		interface: conf.args.flag_dapps_interface.clone(),
 		port: conf.args.flag_dapps_port,
 		user: conf.args.flag_dapps_user.clone(),