Tweak DB and mining defaults (#2598 )

* Increase WAL size * Decreased default work queue size
Configurable history size in beta (#2587 )
2016-10-12 20:44:25 +02:00 · 2016-10-12 20:44:17 +02:00 · 2016-10-13 00:20:33 +07:00 · 2016-10-12 17:33:59 +02:00 · 2016-10-12 22:33:17 +07:00 · 2016-10-12 21:29:58 +07:00
30 changed files with 517 additions and 283 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -19,11 +19,11 @@ linux-stable:
  script:
    - cargo build --release --verbose
    - strip target/release/parity
-    - md5sum target/release/parity >> checksum
+    - md5sum target/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu/parity --body target/release/parity
-    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu/checksum --body checksum
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-stable
@@ -42,11 +42,11 @@ linux-stable-14.04:
  script:
    - cargo build --release --verbose
    - strip target/release/parity
-    - md5sum target/release/parity >> checksum
+    - md5sum target/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-ubuntu_14_04-gnu/parity --body target/release/parity
-    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-ubuntu_14_04-gnu/checksum --body checksum
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-ubuntu_14_04-gnu/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-14.04
@@ -105,11 +105,11 @@ linux-centos:
    - export CC="gcc"
    - cargo build --release --verbose
    - strip target/release/parity
-    - md5sum target/release/parity >> checksum
+    - md5sum target/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-centos-gnu/parity --body target/release/parity
-    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-centos-gnu/checksum --body checksum
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-centos-gnu/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-centos
@@ -121,7 +121,6 @@ linux-armv7:
  stage: build
  image: ethcore/rust-armv7:latest
  only:
-    - master
    - beta
    - tags
    - stable
@@ -133,11 +132,11 @@ linux-armv7:
    - cat .cargo/config
    - cargo build --target armv7-unknown-linux-gnueabihf --release --verbose
    - arm-linux-gnueabihf-strip target/armv7-unknown-linux-gnueabihf/release/parity
-    - md5sum target/armv7-unknown-linux-gnueabihf/release/parity >> checksum
+    - md5sum target/armv7-unknown-linux-gnueabihf/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/armv7-unknown-linux-gnueabihf/parity --body target/armv7-unknown-linux-gnueabihf/release/parity
-    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/armv7-unknown-linux-gnueabihf/checksum --body checksum
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/armv7-unknown-linux-gnueabihf/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-arm
@@ -150,7 +149,6 @@ linux-arm:
  stage: build
  image: ethcore/rust-arm:latest
  only:
-    - master
    - beta
    - tags
    - stable
@@ -162,11 +160,11 @@ linux-arm:
    - cat .cargo/config
    - cargo build --target arm-unknown-linux-gnueabihf --release --verbose
    - arm-linux-gnueabihf-strip target/arm-unknown-linux-gnueabihf/release/parity
-    - md5sum target/arm-unknown-linux-gnueabihf/release/parity >> checksum
+    - md5sum target/arm-unknown-linux-gnueabihf/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/arm-unknown-linux-gnueabihf/parity --body target/arm-unknown-linux-gnueabihf/release/parity
-    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/arm-unknown-linux-gnueabihf/checksum --body checksum
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/arm-unknown-linux-gnueabihf/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-arm
@@ -179,7 +177,6 @@ linux-armv6:
  stage: build
  image: ethcore/rust-armv6:latest
  only:
-    - master
    - beta
    - tags
    - stable
@@ -191,11 +188,11 @@ linux-armv6:
    - cat .cargo/config
    - cargo build --target arm-unknown-linux-gnueabi --release --verbose
    - arm-linux-gnueabi-strip target/arm-unknown-linux-gnueabi/release/parity
-    - md5sum target/arm-unknown-linux-gnueabi/release/parity >> checksum 
+    - md5sum target/arm-unknown-linux-gnueabi/release/parity >> parity.md5 
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/arm-unknown-linux-gnueabi/parity --body target/arm-unknown-linux-gnueabi/release/parity
-    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/arm-unknown-linux-gnueabi/checksum --body checksum
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/arm-unknown-linux-gnueabi/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-arm
@@ -208,7 +205,6 @@ linux-aarch64:
  stage: build
  image: ethcore/rust-aarch64:latest
  only:
-    - master
    - beta
    - tags
    - stable
@@ -220,11 +216,11 @@ linux-aarch64:
    - cat .cargo/config
    - cargo build --target aarch64-unknown-linux-gnu --release --verbose
    - aarch64-linux-gnu-strip target/aarch64-unknown-linux-gnu/release/parity
-    - md5sum target/aarch64-unknown-linux-gnu/release/parity >> checksum
+    - md5sum target/aarch64-unknown-linux-gnu/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/aarch64-unknown-linux-gnu/parity --body target/aarch64-unknown-linux-gnu/release/parity
-    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/aarch64-unknown-linux-gnu/checksum --body checksum
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/aarch64-unknown-linux-gnu/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-arm
@@ -242,11 +238,11 @@ darwin:
    - stable
  script:
    - cargo build --release --verbose
-    - md5sum target/release/parity >> checksum
+    - md5sum target/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-apple-darwin/parity --body target/release/parity
-    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-apple-darwin/checksum --body checksum
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-apple-darwin/parity.md5 --body parity.md5
  tags:
    - osx
  artifacts:
@@ -264,21 +260,42 @@ windows:
    - set INCLUDE=C:\Program Files (x86)\Microsoft SDKs\Windows\v7.1A\Include;C:\vs2015\VC\include;C:\Program Files (x86)\Windows Kits\10\Include\10.0.10240.0\ucrt
    - set LIB=C:\vs2015\VC\lib;C:\Program Files (x86)\Windows Kits\10\Lib\10.0.10240.0\ucrt\x64
    - set RUST_BACKTRACE=1
-    - set RUSTFLAGS=-Zorbit=off
+    - set RUSTFLAGS=%RUSTFLAGS% -Zorbit=off -D warnings
    - rustup default stable-x86_64-pc-windows-msvc
    - cargo build --release --verbose
-    - cmd md5sum target\release\parity >> checksum
+    - curl -sL --url "https://github.com/ethcore/win-build/raw/master/SimpleFC.dll" -o nsis\SimpleFC.dll
+    - curl -sL --url "https://github.com/ethcore/win-build/raw/master/vc_redist.x64.exe" -o nsis\vc_redist.x64.exe
+    - signtool sign /f %keyfile% /p %certpass% target\release\parity.exe
+    - cd nsis
+    - makensis.exe installer.nsi
+    - copy installer.exe InstallParity.exe
+    - signtool sign /f %keyfile% /p %certpass% InstallParity.exe
+    - md5sums InstallParity.exe > InstallParity.exe.md5
+    - zip win-installer.zip InstallParity.exe InstallParity.exe.md5
+    - md5sums win-installer.zip > win-installer.zip.md5
+    - cd ..\target\release\
+    - md5sums parity.exe parity.pdb > parity.md5
+    - md5sums parity.exe > parity.exe.md5
+    - zip parity.zip parity.exe parity.pdb parity.md5
+    - md5sums parity.zip > parity.zip.md5
+    - cd ..\..
    - aws configure set aws_access_key_id %s3_key%
    - aws configure set aws_secret_access_key %s3_secret%
-    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity --body target\release\parity.exe
-    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity --body target\release\parity.pdb
-    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/checksum --body checksum
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity.exe --body target\release\parity.exe
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity.exe.md5 --body target\release\parity.exe.md5
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity.zip --body target\release\parity.zip
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity.zip.md5 --body target\release\parity.zip.md5
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/InstallParity.exe --body nsis\InstallParity.exe
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/InstallParity.exe.md5 --body nsis\InstallParity.exe.md5
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/win-installer.zip --body nsis\win-installer.zip
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/win-installer.zip.md5 --body nsis\win-installer.zip.md5
  tags:
   - rust-windows
  artifacts:
    paths:
    - target/release/parity.exe
    - target/release/parity.pdb
+    - nsis/InstallParity.exe
    name: "x86_64-pc-windows-msvc_parity"
 test-linux:
  stage: test
@@ -289,6 +306,5 @@ test-linux:
    - ./test.sh --verbose
  tags:
    - rust-test
-    - javascript
  dependencies:
    - linux-stable
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 [root]
 name = "parity"
-version = "1.3.5"
+version = "1.3.7"
 dependencies = [
 "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "clippy 0.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -20,7 +20,7 @@ dependencies = [
 "ethcore-logger 1.3.0",
 "ethcore-rpc 1.3.0",
 "ethcore-signer 1.3.0",
- "ethcore-util 1.3.5",
+ "ethcore-util 1.3.7",
 "ethsync 1.3.0",
 "fdlimit 0.1.0",
 "hyper 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -270,7 +270,7 @@ dependencies = [
 "ethcore-ipc 1.3.0",
 "ethcore-ipc-codegen 1.3.0",
 "ethcore-ipc-nano 1.3.0",
- "ethcore-util 1.3.5",
+ "ethcore-util 1.3.7",
 "ethjson 0.1.0",
 "ethstore 0.1.0",
 "evmjit 1.3.0",
@@ -294,7 +294,7 @@ version = "1.3.0"
 dependencies = [
 "clippy 0.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-rpc 1.3.0",
- "ethcore-util 1.3.5",
+ "ethcore-util 1.3.7",
 "hyper 0.9.4 (git+https://github.com/ethcore/hyper)",
 "jsonrpc-core 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "jsonrpc-http-server 6.1.0 (git+https://github.com/ethcore/jsonrpc-http-server.git)",
@@ -336,7 +336,7 @@ name = "ethcore-ipc"
 version = "1.3.0"
 dependencies = [
 "ethcore-devtools 1.3.0",
- "ethcore-util 1.3.5",
+ "ethcore-util 1.3.7",
 "nanomsg 0.5.1 (git+https://github.com/ethcore/nanomsg.rs.git)",
 "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -381,7 +381,7 @@ dependencies = [
 "ethcore-ipc 1.3.0",
 "ethcore-ipc-codegen 1.3.0",
 "ethcore-ipc-nano 1.3.0",
- "ethcore-util 1.3.5",
+ "ethcore-util 1.3.7",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "nanomsg 0.5.1 (git+https://github.com/ethcore/nanomsg.rs.git)",
 "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -393,7 +393,7 @@ name = "ethcore-logger"
 version = "1.3.0"
 dependencies = [
 "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethcore-util 1.3.5",
+ "ethcore-util 1.3.7",
 "isatty 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -408,7 +408,7 @@ dependencies = [
 "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-devtools 1.3.0",
 "ethcore-io 1.3.0",
- "ethcore-util 1.3.5",
+ "ethcore-util 1.3.7",
 "igd 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -432,7 +432,7 @@ dependencies = [
 "ethcore-devtools 1.3.0",
 "ethcore-io 1.3.0",
 "ethcore-ipc 1.3.0",
- "ethcore-util 1.3.5",
+ "ethcore-util 1.3.7",
 "ethjson 0.1.0",
 "ethsync 1.3.0",
 "json-ipc-server 0.2.4 (git+https://github.com/ethcore/json-ipc-server.git?branch=beta)",
@@ -455,7 +455,7 @@ dependencies = [
 "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-io 1.3.0",
 "ethcore-rpc 1.3.0",
- "ethcore-util 1.3.5",
+ "ethcore-util 1.3.7",
 "jsonrpc-core 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "parity-dapps-signer 1.4.0 (git+https://github.com/ethcore/parity-ui.git)",
@@ -466,7 +466,7 @@ dependencies = [

 [[package]]
 name = "ethcore-util"
-version = "1.3.5"
+version = "1.3.7"
 dependencies = [
 "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -499,7 +499,7 @@ dependencies = [
 name = "ethjson"
 version = "0.1.0"
 dependencies = [
- "ethcore-util 1.3.5",
+ "ethcore-util 1.3.7",
 "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_codegen 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -547,7 +547,7 @@ dependencies = [
 "ethcore-ipc-codegen 1.3.0",
 "ethcore-ipc-nano 1.3.0",
 "ethcore-network 1.3.0",
- "ethcore-util 1.3.5",
+ "ethcore-util 1.3.7",
 "heapsize 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 description = "Ethcore client."
 name = "parity"
-version = "1.3.5"
+version = "1.3.7"
 license = "GPL-3.0"
 authors = ["Ethcore <admin@ethcore.io>"]
 build = "build.rs"
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -395,6 +395,10 @@ impl<'x> OpenBlock<'x> {
 			uncle_bytes: uncle_bytes,
 		}
 	}
+
+	#[cfg(test)]
+	/// Return mutable block reference. To be used in tests only.
+	pub fn block_mut (&mut self) -> &mut ExecutedBlock { &mut self.block }
 }

 impl<'x> IsBlock for OpenBlock<'x> {
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@@ -17,6 +17,7 @@ use std::collections::{HashSet, HashMap, BTreeMap, VecDeque};
 use std::sync::{Arc, Weak};
 use std::path::{Path};
 use std::fmt;
+use std::cmp;
 use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering as AtomicOrdering};
 use std::time::{Instant};
 use time::precise_time_ns;
@@ -73,6 +74,7 @@ pub use blockchain::CacheSize as BlockChainCacheSize;

 const MAX_TX_QUEUE_SIZE: usize = 4096;
 const MAX_QUEUE_SIZE_TO_SLEEP_ON: usize = 2;
+const MIN_HISTORY_SIZE: u64 = 8;

 impl fmt::Display for BlockChainInfo {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -139,10 +141,9 @@ pub struct Client {
 	notify: RwLock<Vec<Weak<ChainNotify>>>,
 	queue_transactions: AtomicUsize,
 	last_hashes: RwLock<VecDeque<H256>>,
+	history: u64,
 }

-const HISTORY: u64 = 1200;
-
 // database columns
 /// Column for State
 pub const DB_COL_STATE: Option<u32> = Some(0);
@@ -159,13 +160,6 @@ pub const DB_COL_ACCOUNT_BLOOM: Option<u32> = Some(5);
 /// Number of columns in DB
 pub const DB_NO_OF_COLUMNS: Option<u32> = Some(6);

-/// Append a path element to the given path and return the string.
-pub fn append_path<P>(path: P, item: &str) -> String where P: AsRef<Path> {
-	let mut p = path.as_ref().to_path_buf();
-	p.push(item);
-	p.to_str().unwrap().to_owned()
-}
-
 impl Client {
 	/// Create a new client with given spec and DB path and custom verifier.
 	pub fn new(
@@ -182,7 +176,7 @@ impl Client {
 		db_config.compaction = config.db_compaction.compaction_profile();
 		db_config.wal = config.db_wal;

-		let db = Arc::new(try!(Database::open(&db_config, &path.to_str().unwrap()).map_err(ClientError::Database)));
+		let db = Arc::new(try!(Database::open(&db_config, &path.to_str().expect("DB path could not be converted to string.")).map_err(ClientError::Database)));
 		let chain = Arc::new(BlockChain::new(config.blockchain, &gb, db.clone()));
 		let tracedb = Arc::new(try!(TraceDB::new(config.tracing, db.clone(), chain.clone())));

@@ -194,6 +188,19 @@ impl Client {
 			try!(db.write(batch).map_err(ClientError::Database));
 		}

+		trace!("Cleanup journal: DB Earliest = {:?}, Latest = {:?}", state_db.journal_db().earliest_era(), state_db.journal_db().latest_era());
+		let history = cmp::max(MIN_HISTORY_SIZE, config.history);
+		if let (Some(earliest), Some(latest)) = (state_db.journal_db().earliest_era(), state_db.journal_db().latest_era()) {
+			if latest > earliest && latest - earliest > history {
+				for era in earliest..(latest - history + 1) {
+					trace!("Removing era {}", era);
+					let batch = DBTransaction::new(&db);
+					try!(state_db.journal_db_mut().commit_old(&batch, era, &chain.block_hash(era).expect("Old block not found in the database")));
+					try!(db.write(batch).map_err(ClientError::Database));
+				}
+			}
+		}
+
 		if !chain.block_header(&chain.best_block_hash()).map_or(true, |h| state_db.journal_db().contains(h.state_root())) {
 			warn!("State root not found for block #{} ({})", chain.best_block_number(), chain.best_block_hash().hex());
 		}
@@ -226,6 +233,7 @@ impl Client {
 			notify: RwLock::new(Vec::new()),
 			queue_transactions: AtomicUsize::new(0),
 			last_hashes: RwLock::new(VecDeque::new()),
+			history: history,
 		};
 		Ok(Arc::new(client))
 	}
@@ -282,7 +290,7 @@ impl Client {

 		// Check the block isn't so old we won't be able to enact it.
 		let best_block_number = self.chain.best_block_number();
-		if best_block_number >= HISTORY && header.number() <= best_block_number - HISTORY {
+		if best_block_number >= self.history && header.number() <= best_block_number - self.history {
 			warn!(target: "client", "Block import failed for #{} ({})\nBlock is ancient (current best block: #{}).", header.number(), header.hash(), best_block_number);
 			return Err(());
 		}
@@ -295,31 +303,28 @@ impl Client {
 		};

 		// Check if Parent is in chain
-		let chain_has_parent = self.chain.block_header(&header.parent_hash);
-		if let None = chain_has_parent {
-			warn!(target: "client", "Block import failed for #{} ({}): Parent not found ({}) ", header.number(), header.hash(), header.parent_hash);
-			return Err(());
-		};
+		let chain_has_parent = self.chain.block_header(header.parent_hash());
+		if let Some(parent) = chain_has_parent {
+			// Enact Verified Block
+			let last_hashes = self.build_last_hashes(header.parent_hash().clone());
+			let db = self.state_db.lock().boxed_clone_canon(&header.parent_hash());

-		// Enact Verified Block
-		let parent = chain_has_parent.unwrap();
-		let last_hashes = self.build_last_hashes(header.parent_hash().clone());
-		let db = self.state_db.lock().boxed_clone_canon(&header.parent_hash);
+			let enact_result = enact_verified(block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, &self.vm_factory, self.trie_factory.clone());
+			let locked_block = try!(enact_result.map_err(|e| {
+				warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
+			}));

-		let enact_result = enact_verified(block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, &self.vm_factory, self.trie_factory.clone());
-		if let Err(e) = enact_result {
-			warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
-			return Err(());
-		};
+			// Final Verification
+			if let Err(e) = self.verifier.verify_block_final(header, locked_block.block().header()) {
+				warn!(target: "client", "Stage 4 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
+				return Err(());
+			}

-		// Final Verification
-		let locked_block = enact_result.unwrap();
-		if let Err(e) = self.verifier.verify_block_final(header, locked_block.block().header()) {
-			warn!(target: "client", "Stage 4 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
-			return Err(());
+			Ok(locked_block)
+		} else {
+			warn!(target: "client", "Block import failed for #{} ({}): Parent not found ({}) ", header.number(), header.hash(), header.parent_hash());
+			Err(())
 		}
-
-		Ok(locked_block)
 	}

 	fn calculate_enacted_retracted(&self, import_results: &[ImportRoute]) -> (Vec<H256>, Vec<H256>) {
@@ -372,14 +377,17 @@ impl Client {
 					invalid_blocks.insert(header.hash());
 					continue;
 				}
+				let is_invalid = invalid_blocks.contains(header.parent_hash());
+				if let (false, Ok(closed_block)) = (is_invalid, self.check_and_close_block(&block)) {
+					imported_blocks.push(header.hash());

-				let closed_block = closed_block.unwrap();
-				imported_blocks.push(header.hash());
+					let route = self.commit_block(closed_block, &header.hash(), &block.bytes);
+					import_results.push(route);

-				let route = self.commit_block(closed_block, &header.hash(), &block.bytes);
-				import_results.push(route);
-
-				self.report.write().accrue_block(&block);
+					self.report.write().accrue_block(&block);
+				} else {
+					invalid_blocks.insert(header.hash());
+				}
 			}

 			let imported = imported_blocks.len();
@@ -426,9 +434,9 @@ impl Client {
 		let number = block.header().number();
 		let parent = block.header().parent_hash().clone();
 		// Are we committing an era?
-		let ancient = if number >= HISTORY {
-			let n = number - HISTORY;
-			Some((n, self.chain.block_hash(n).unwrap()))
+		let ancient = if number >= self.history {
+			let n = number - self.history;
+			Some((n, self.chain.block_hash(n).expect("only verified blocks can be commited; verified block has hash; qed")))
 		} else {
 			None
 		};
@@ -505,7 +513,7 @@ impl Client {
 			let db = self.state_db.lock().boxed_clone();

 			// early exit for pruned blocks
-			if db.is_pruned() && self.chain.best_block_number() >= block_number + HISTORY {
+			if db.is_pruned() && self.chain.best_block_number() >= block_number + self.history {
 				return None;
 			}

@@ -610,7 +618,7 @@ impl Client {
 		let best_block_number = self.chain_info().best_block_number;
 		let block_number = try!(self.block_number(at).ok_or(snapshot::Error::InvalidStartingBlock(at)));

-		if best_block_number > HISTORY + block_number && db.is_pruned() {
+		if best_block_number > self.history + block_number && db.is_pruned() {
 			return Err(snapshot::Error::OldBlockPrunedDB.into());
 		}

@@ -622,8 +630,10 @@ impl Client {
 					0
 				};

-				self.block_hash(BlockID::Number(start_num))
-					.expect("blocks within HISTORY are always stored.")
+				match self.block_hash(BlockID::Number(start_num)) {
+					Some(h) => h,
+					None => return Err(snapshot::Error::InvalidStartingBlock(at).into()),
+				}
 			}
 			_ => match self.block_hash(at) {
 				Some(hash) => hash,
@@ -835,8 +845,9 @@ impl BlockChainClient for Client {
 			let t = self.chain.block_body(&address.block_hash)
 				.and_then(|block| BodyView::new(&block).localized_transaction_at(&address.block_hash, block_number, address.index));

-			match (t, self.chain.transaction_receipt(&address)) {
-				(Some(tx), Some(receipt)) => {
+			let tx_and_sender = t.and_then(|tx| tx.sender().ok().map(|sender| (tx, sender)));
+			match (tx_and_sender, self.chain.transaction_receipt(&address)) {
+				(Some((tx, sender)), Some(receipt)) => {
 					let block_hash = tx.block_hash.clone();
 					let block_number = tx.block_number.clone();
 					let transaction_hash = tx.hash();
@@ -858,7 +869,7 @@ impl BlockChainClient for Client {
 						gas_used: receipt.gas_used - prior_gas_used,
 						contract_address: match tx.action {
 							Action::Call(_) => None,
-							Action::Create => Some(contract_address(&tx.sender().unwrap(), &tx.nonce))
+							Action::Create => Some(contract_address(&sender, &tx.nonce))
 						},
 						logs: receipt.logs.into_iter().enumerate().map(|(i, log)| LocalizedLogEntry {
 							entry: log,
@@ -981,17 +992,18 @@ impl BlockChainClient for Client {
 		let start = self.block_number(filter.range.start);
 		let end = self.block_number(filter.range.end);

-		if start.is_some() && end.is_some() {
-			let filter = trace::Filter {
-				range: start.unwrap() as usize..end.unwrap() as usize,
-				from_address: From::from(filter.from_address),
-				to_address: From::from(filter.to_address),
-			};
+		match (start, end) {
+			(Some(s), Some(e)) => {
+				let filter = trace::Filter {
+					range: s as usize..e as usize,
+					from_address: From::from(filter.from_address),
+					to_address: From::from(filter.to_address),
+				};

-			let traces = self.tracedb.filter(&filter);
-			Some(traces)
-		} else {
-			None
+				let traces = self.tracedb.filter(&filter);
+				Some(traces)
+			},
+			_ => None,
 		}
 	}

@@ -1063,11 +1075,15 @@ impl MiningBlockChainClient for Client {
 		// Add uncles
 		self.chain
 			.find_uncle_headers(&h, engine.maximum_uncle_age())
-			.unwrap()
+			.unwrap_or_else(Vec::new)
 			.into_iter()
 			.take(engine.maximum_uncle_count())
 			.foreach(|h| {
-				open_block.push_uncle(h).unwrap();
+				open_block.push_uncle(h).expect("pushing maximum_uncle_count;
+												open_block was just created;
+												push_uncle is not ok only if more than maximum_uncle_count is pushed;
+												so all push_uncle are Ok;
+												qed");
 			});

 		open_block
--- a/ethcore/src/client/config.rs
+++ b/ethcore/src/client/config.rs
@@ -107,6 +107,8 @@ pub struct ClientConfig {
 	pub mode: Mode,
 	/// Type of block verifier used by client.
 	pub verifier_type: VerifierType,
+	/// State pruning history size.
+	pub history: u64,
 }

 #[cfg(test)]
--- a/ethcore/src/client/test_client.rs
+++ b/ethcore/src/client/test_client.rs
@@ -53,6 +53,8 @@ pub struct TestBlockChainClient {
 	pub genesis_hash: H256,
 	/// Last block hash.
 	pub last_hash: RwLock<H256>,
+	/// Extra data do set for each block
+	pub extra_data: Bytes,
 	/// Difficulty.
 	pub difficulty: RwLock<U256>,
 	/// Balances.
@@ -99,11 +101,17 @@ impl Default for TestBlockChainClient {
 impl TestBlockChainClient {
 	/// Creates new test client.
 	pub fn new() -> Self {
+		Self::new_with_extra_data(Bytes::new())
+	}
+
+	/// Creates new test client with specified extra data for each block
+	pub fn new_with_extra_data(extra_data: Bytes) -> Self {
 		let spec = Spec::new_test();
 		let mut client = TestBlockChainClient {
 			blocks: RwLock::new(HashMap::new()),
 			numbers: RwLock::new(HashMap::new()),
 			genesis_hash: H256::new(),
+			extra_data: extra_data,
 			last_hash: RwLock::new(H256::new()),
 			difficulty: RwLock::new(From::from(0)),
 			balances: RwLock::new(HashMap::new()),
@@ -121,7 +129,7 @@ impl TestBlockChainClient {
 		client.genesis_hash = client.last_hash.read().clone();
 		client
 	}
-
+	
 	/// Set the transaction receipt result
 	pub fn set_transaction_receipt(&self, id: TransactionID, receipt: LocalizedReceipt) {
 		self.receipts.write().insert(id, receipt);
@@ -166,6 +174,7 @@ impl TestBlockChainClient {
 			header.parent_hash = self.last_hash.read().clone();
 			header.number = n as BlockNumber;
 			header.gas_limit = U256::from(1_000_000);
+			header.extra_data = self.extra_data.clone();
 			let uncles = match with {
 				EachBlockWith::Uncle | EachBlockWith::UncleAndTransaction => {
 					let mut uncles = RlpStream::new_list(1);
--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@@ -48,6 +48,17 @@ pub enum PendingSet {
 	SealingOrElseQueue,
 }

+/// Type of the gas limit to apply to the transaction queue.
+#[derive(Debug, PartialEq)]
+pub enum GasLimit {
+	/// Depends on the block gas limit and is updated with every block.
+	Auto,
+	/// No limit.
+	None,
+	/// Set to a fixed gas value.
+	Fixed(U256),
+}
+
 /// Configures the behaviour of the miner.
 #[derive(Debug, PartialEq)]
 pub struct MinerOptions {
@@ -73,6 +84,8 @@ pub struct MinerOptions {
 	pub work_queue_size: usize,
 	/// Can we submit two different solutions for the same block and expect both to result in an import?
 	pub enable_resubmission: bool,
+	/// Global gas limit for all transaction in the queue except for local and retracted.
+	pub tx_queue_gas_limit: GasLimit,
 }

 impl Default for MinerOptions {
@@ -87,8 +100,9 @@ impl Default for MinerOptions {
 			tx_queue_strategy: PrioritizationStrategy::GasFactorAndGasPrice,
 			pending_set: PendingSet::AlwaysQueue,
 			reseal_min_period: Duration::from_secs(2),
-			work_queue_size: 20,
+			work_queue_size: 5,
 			enable_resubmission: true,
+			tx_queue_gas_limit: GasLimit::Auto,
 		}
 	}
 }
@@ -210,8 +224,12 @@ impl Miner {
 	/// Creates new instance of miner
 	pub fn new(options: MinerOptions, gas_pricer: GasPricer, spec: &Spec, accounts: Option<Arc<AccountProvider>>) -> Arc<Miner> {
 		let work_poster = if !options.new_work_notify.is_empty() { Some(WorkPoster::new(&options.new_work_notify)) } else { None };
+		let gas_limit = match options.tx_queue_gas_limit {
+			GasLimit::Fixed(ref limit) => *limit,
+			_ => !U256::zero(),
+		};
 		let txq = Arc::new(Mutex::new(TransactionQueue::with_limits(
-			options.tx_queue_strategy, options.tx_queue_size, !U256::zero(), options.tx_gas_limit
+			options.tx_queue_strategy, options.tx_queue_size, gas_limit, options.tx_gas_limit
 		)));
 		Arc::new(Miner {
 			transaction_queue: txq,
@@ -249,6 +267,7 @@ impl Miner {
 	fn prepare_sealing(&self, chain: &MiningBlockChainClient) {
 		trace!(target: "miner", "prepare_sealing: entering");

+		let _timer = PerfTimer::new("prepare_sealing");
 		{
 			trace!(target: "miner", "recalibrating...");
 			let txq = self.transaction_queue.clone();
@@ -401,8 +420,10 @@ impl Miner {
 		let gas_limit = HeaderView::new(&chain.best_block_header()).gas_limit();
 		let mut queue = self.transaction_queue.lock();
 		queue.set_gas_limit(gas_limit);
-		// Set total qx queue gas limit to be 2x the block gas limit.
-		queue.set_total_gas_limit(gas_limit << 1);
+		if let GasLimit::Auto = self.options.tx_queue_gas_limit {
+			// Set total tx queue gas limit to be 2x the block gas limit.
+			queue.set_total_gas_limit(gas_limit << 1);
+		}
 	}

 	/// Returns true if we had to prepare new pending block
@@ -1022,6 +1043,7 @@ mod tests {
 				tx_gas_limit: !U256::zero(),
 				tx_queue_size: 1024,
 				tx_queue_strategy: PrioritizationStrategy::GasFactorAndGasPrice,
+				tx_queue_gas_limit: GasLimit::None,
 				pending_set: PendingSet::AlwaysSealing,
 				work_queue_size: 5,
 				enable_resubmission: true,
--- a/ethcore/src/miner/mod.rs
+++ b/ethcore/src/miner/mod.rs
@@ -48,7 +48,7 @@ mod work_notify;
 mod price_info;

 pub use self::transaction_queue::{TransactionQueue, PrioritizationStrategy, AccountDetails, TransactionOrigin};
-pub use self::miner::{Miner, MinerOptions, PendingSet, GasPricer, GasPriceCalibratorOptions};
+pub use self::miner::{Miner, MinerOptions, PendingSet, GasPricer, GasPriceCalibratorOptions, GasLimit};
 pub use self::external::{ExternalMiner, ExternalMinerService};
 pub use client::TransactionImportResult;

--- a/ethcore/src/miner/transaction_queue.rs
+++ b/ethcore/src/miner/transaction_queue.rs
@@ -310,7 +310,9 @@ impl TransactionSet {
 					let r = gas.overflowing_add(order.gas);
 					if r.1 { return false }
 					gas = r.0;
-					count <= self.limit && gas <= self.gas_limit
+					// Own and retracted transactions are allowed to go above the gas limit, bot not above the count limit.
+					(gas <= self.gas_limit || order.origin == TransactionOrigin::Local || order.origin == TransactionOrigin::RetractedBlock) &&
+						count <= self.limit
 				})
 				.map(|order| by_hash.get(&order.hash)
 					.expect("All transactions in `self.by_priority` and `self.by_address` are kept in sync with `by_hash`."))
@@ -1757,13 +1759,27 @@ mod test {
 	#[test]
 	fn should_limit_by_gas() {
 		let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 100, default_gas_val() * U256::from(2), !U256::zero());
-		let (tx1, _) = new_txs_with_gas_price_diff(U256::from(4), U256::from(1));
-		let (tx3, _) = new_txs_with_gas_price_diff(U256::from(4), U256::from(2));
-		txq.add(tx1.clone(), &default_nonce, TransactionOrigin::External).unwrap();
-		txq.add(tx3.clone(), &default_nonce, TransactionOrigin::External).unwrap();
+		let (tx1, tx2) = new_txs_with_gas_price_diff(U256::from(1), U256::from(1));
+		let (tx3, tx4) = new_txs_with_gas_price_diff(U256::from(1), U256::from(2));
+		txq.add(tx1.clone(), &default_nonce, TransactionOrigin::External).ok();
+		txq.add(tx2.clone(), &default_nonce, TransactionOrigin::External).ok();
+		txq.add(tx3.clone(), &default_nonce, TransactionOrigin::External).ok();
+		txq.add(tx4.clone(), &default_nonce, TransactionOrigin::External).ok();
 		assert_eq!(txq.status().pending, 2);
 	}

+	#[test]
+	fn should_keep_own_transactions_above_gas_limit() {
+		let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 100, default_gas_val() * U256::from(2), !U256::zero());
+		let (tx1, tx2) = new_txs_with_gas_price_diff(U256::from(1), U256::from(1));
+		let (tx3, tx4) = new_txs_with_gas_price_diff(U256::from(1), U256::from(2));
+		txq.add(tx1.clone(), &default_nonce, TransactionOrigin::Local).unwrap();
+		txq.add(tx2.clone(), &default_nonce, TransactionOrigin::Local).unwrap();
+		txq.add(tx3.clone(), &default_nonce, TransactionOrigin::Local).unwrap();
+		txq.add(tx4.clone(), &default_nonce, TransactionOrigin::Local).unwrap();
+		assert_eq!(txq.status().pending, 4);
+	}
+
 	#[test]
 	fn should_drop_transactions_with_old_nonces() {
 		let mut txq = TransactionQueue::default();
--- a/ethcore/src/state_db.rs
+++ b/ethcore/src/state_db.rs
@@ -323,6 +323,11 @@ impl StateDB {
 		&*self.db
 	}

+	/// Returns underlying `JournalDB`.
+	pub fn journal_db_mut(&mut self) -> &mut JournalDB {
+		&mut *self.db
+	}
+
 	/// Add pending cache change.
 	/// The change is queued to be applied in `commit`.
 	pub fn add_to_account_cache(&mut self, addr: Address, data: Option<Account>, modified: bool) {
--- a/ethcore/src/tests/client.rs
+++ b/ethcore/src/tests/client.rs
@@ -22,6 +22,7 @@ use tests::helpers::*;
 use common::*;
 use devtools::*;
 use miner::Miner;
+use spec::Spec;

 #[test]
 fn imports_from_empty() {
@@ -167,3 +168,26 @@ fn can_mine() {

 	assert_eq!(*b.block().header().parent_hash(), BlockView::new(&dummy_blocks[0]).header_view().sha3());
 }
+
+#[test]
+fn change_history_size() {
+	let dir = RandomTempPath::new();
+	let test_spec = Spec::new_null();
+	let mut config = ClientConfig::default();
+	config.history = 2;
+	let address = Address::random();
+	{
+		let client = Client::new(ClientConfig::default(), &test_spec, dir.as_path(), Arc::new(Miner::with_spec(&test_spec)), IoChannel::disconnected()).unwrap();
+		for _ in 0..20 {
+			let mut b = client.prepare_open_block(Address::default(), (3141562.into(), 31415620.into()), vec![]);
+			b.block_mut().fields_mut().state.add_balance(&address, &5.into());
+			b.block_mut().fields_mut().state.commit().unwrap();
+			let b = b.close_and_lock().seal(&*test_spec.engine, vec![]).unwrap();
+			client.import_sealed_block(b).unwrap(); // account change is in the journal overlay
+		}
+	}
+	let mut config = ClientConfig::default();
+	config.history = 10;
+	let client = Client::new(config, &test_spec, dir.as_path(), Arc::new(Miner::with_spec(&test_spec)), IoChannel::disconnected()).unwrap();
+	assert_eq!(client.state().balance(&address), 100.into());
+}
--- a/ethcore/src/trace/db.rs
+++ b/ethcore/src/trace/db.rs
@@ -268,16 +268,6 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 			return;
 		}

-		// at first, let's insert new block traces
-		{
-			let mut traces = self.traces.write();
-			// it's important to use overwrite here,
-			// cause this value might be queried by hash later
-			batch.write_with_cache(DB_COL_TRACE, &mut *traces, request.block_hash, request.traces, CacheUpdatePolicy::Overwrite);
-			// note_used must be called after locking traces to avoid cache/traces deadlock on garbage collection
-			self.note_used(CacheID::Trace(request.block_hash.clone()));
-		}
-
 		// now let's rebuild the blooms
 		{
 			let range_start = request.block_number as Number + 1 - request.enacted.len();
@@ -288,12 +278,25 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 				// all traces are expected to be found here. That's why `expect` has been used
 				// instead of `filter_map`. If some traces haven't been found, it meens that
 				// traces database is corrupted or incomplete.
-				.map(|block_hash| self.traces(block_hash).expect("Traces database is incomplete."))
-				.map(|block_traces| block_traces.bloom())
+				.map(|block_hash| if block_hash == &request.block_hash {
+					request.traces.bloom()
+				} else {
+					self.traces(block_hash).expect("Traces database is incomplete.").bloom()
+				})
 				.map(blooms::Bloom::from)
 				.map(Into::into)
 				.collect();

+			// insert new block traces into the cache and the database
+			{
+				let mut traces = self.traces.write();
+				// it's important to use overwrite here,
+				// cause this value might be queried by hash later
+				batch.write_with_cache(DB_COL_TRACE, &mut *traces, request.block_hash, request.traces, CacheUpdatePolicy::Overwrite);
+				// note_used must be called after locking traces to avoid cache/traces deadlock on garbage collection
+				self.note_used(CacheID::Trace(request.block_hash.clone()));
+			}
+
 			let chain = BloomGroupChain::new(self.bloom_config, self);
 			let trace_blooms = chain.replace(&replaced_range, enacted_blooms);
 			let blooms_to_insert = trace_blooms.into_iter()
--- a/nsis/installer.nsi
+++ b/nsis/installer.nsi
@@ -4,7 +4,7 @@
 !define DESCRIPTION "Fast, light, robust Ethereum implementation"
 !define VERSIONMAJOR 1
 !define VERSIONMINOR 3
-!define VERSIONBUILD 5
+!define VERSIONBUILD 7

 !addplugindir .\

--- a/parity/blockchain.rs
+++ b/parity/blockchain.rs
@@ -75,6 +75,7 @@ pub struct ImportBlockchain {
 	pub file_path: Option<String>,
 	pub format: Option<DataFormat>,
 	pub pruning: Pruning,
+	pub pruning_history: u64,
 	pub compaction: DatabaseCompactionProfile,
 	pub wal: bool,
 	pub mode: Mode,
@@ -91,6 +92,7 @@ pub struct ExportBlockchain {
 	pub file_path: Option<String>,
 	pub format: Option<DataFormat>,
 	pub pruning: Pruning,
+	pub pruning_history: u64,
 	pub compaction: DatabaseCompactionProfile,
 	pub wal: bool,
 	pub mode: Mode,
@@ -131,7 +133,7 @@ fn execute_import(cmd: ImportBlockchain) -> Result<String, String> {
 	try!(execute_upgrades(&cmd.dirs, genesis_hash, spec.fork_name.as_ref(), algorithm, cmd.compaction.compaction_profile()));

 	// prepare client config
-	let client_config = to_client_config(&cmd.cache_config, &cmd.dirs, genesis_hash, cmd.mode, cmd.tracing, cmd.pruning, cmd.compaction, cmd.wal, cmd.vm_type, "".into(), spec.fork_name.as_ref());
+	let client_config = to_client_config(&cmd.cache_config, &cmd.dirs, genesis_hash, cmd.mode, cmd.tracing, cmd.pruning, cmd.pruning_history, cmd.compaction, cmd.wal, cmd.vm_type, "".into(), spec.fork_name.as_ref());

 	// build client
 	let service = try!(ClientService::start(
@@ -242,7 +244,7 @@ fn execute_export(cmd: ExportBlockchain) -> Result<String, String> {
 	try!(execute_upgrades(&cmd.dirs, genesis_hash, spec.fork_name.as_ref(), algorithm, cmd.compaction.compaction_profile()));

 	// prepare client config
-	let client_config = to_client_config(&cmd.cache_config, &cmd.dirs, genesis_hash, cmd.mode, cmd.tracing, cmd.pruning, cmd.compaction, cmd.wal, VMType::default(), "".into(), spec.fork_name.as_ref());
+	let client_config = to_client_config(&cmd.cache_config, &cmd.dirs, genesis_hash, cmd.mode, cmd.tracing, cmd.pruning, cmd.pruning_history, cmd.compaction, cmd.wal, VMType::default(), "".into(), spec.fork_name.as_ref());

 	let service = try!(ClientService::start(
 		client_config,
--- a/parity/cli.rs
+++ b/parity/cli.rs
@@ -164,7 +164,7 @@ Sealing/Mining Options:
  --work-queue-size ITEMS  Specify the number of historical work packages
                           which are kept cached lest a solution is found for
                           them later. High values take more memory but result
-                           in fewer unusable solutions [default: 20].
+                           in fewer unusable solutions [default: 5].
  --tx-gas-limit GAS       Apply a limit of GAS as the maximum amount of gas
                           a single transaction may have for it to be mined.
  --relay-set SET          Set of transactions to relay. SET may be:
@@ -200,6 +200,10 @@ Sealing/Mining Options:
                           gas_price - Prioritize txs with high gas price;
                           gas_factor - Prioritize txs using gas price
                           and gas limit ratio [default: gas_factor].
+  --tx-queue-gas LIMIT     Maximum amount of total gas for external transactions in
+                           the queue. LIMIT can be either an amount of gas or
+                           'auto' or 'off'. 'auto' sets the limit to be 2x
+                           the current block gas limit. [default: auto].
  --remove-solved          Move solved blocks from the work package queue
                           instead of cloning them. This gives a slightly
                           faster import speed, but means that extra solutions
@@ -219,6 +223,8 @@ Footprint Options:
                           fast - maintain journal overlay. Fast but 50MB used.
                           auto - use the method most recently synced or
                           default to fast if none synced [default: auto].
+  --pruning-history NUM    Set a number of recent states to keep when pruning
+                           is active. [default: 64].
  --cache-size-db MB       Override database cache size [default: 64].
  --cache-size-blocks MB   Specify the prefered size of the blockchain cache in
                           megabytes [default: 8].
@@ -325,6 +331,7 @@ pub struct Args {
 	pub flag_bootnodes: Option<String>,
 	pub flag_network_id: Option<String>,
 	pub flag_pruning: String,
+	pub flag_pruning_history: u64,
 	pub flag_tracing: String,
 	pub flag_port: u16,
 	pub flag_min_peers: u16,
@@ -379,6 +386,7 @@ pub struct Args {
 	pub flag_extra_data: Option<String>,
 	pub flag_tx_queue_size: usize,
 	pub flag_tx_queue_strategy: String,
+	pub flag_tx_queue_gas: String,
 	pub flag_notify_work: Option<String>,
 	pub flag_logging: Option<String>,
 	pub flag_version: bool,
--- a/parity/configuration.rs
+++ b/parity/configuration.rs
@@ -31,7 +31,7 @@ use rpc::{IpcConfiguration, HttpConfiguration};
 use ethcore_rpc::NetworkSettings;
 use cache::CacheConfig;
 use helpers::{to_duration, to_mode, to_block_id, to_u256, to_pending_set, to_price, replace_home,
-geth_ipc_path, parity_ipc_path, to_bootnodes, to_addresses, to_address};
+geth_ipc_path, parity_ipc_path, to_bootnodes, to_addresses, to_address, to_gas_limit};
 use params::{ResealPolicy, AccountsConfig, GasPricerConfig, MinerExtras};
 use ethcore_logger::Config as LogConfig;
 use dir::Directories;
@@ -73,6 +73,7 @@ impl Configuration {
 	pub fn into_command(self) -> Result<Cmd, String> {
 		let dirs = self.directories();
 		let pruning = try!(self.args.flag_pruning.parse());
+		let pruning_history = self.args.flag_pruning_history;
 		let vm_type = try!(self.vm_type());
 		let mode = try!(to_mode(&self.args.flag_mode, self.args.flag_mode_timeout, self.args.flag_mode_alarm));
 		let miner_options = try!(self.miner_options());
@@ -134,6 +135,7 @@ impl Configuration {
 				file_path: self.args.arg_file.clone(),
 				format: format,
 				pruning: pruning,
+				pruning_history: pruning_history,
 				compaction: compaction,
 				wal: wal,
 				mode: mode,
@@ -150,6 +152,7 @@ impl Configuration {
 				file_path: self.args.arg_file.clone(),
 				format: format,
 				pruning: pruning,
+				pruning_history: pruning_history,
 				compaction: compaction,
 				wal: wal,
 				mode: mode,
@@ -164,6 +167,7 @@ impl Configuration {
 				dirs: dirs,
 				spec: spec,
 				pruning: pruning,
+				pruning_history: pruning_history,
 				logger_config: logger_config,
 				mode: mode,
 				tracing: tracing,
@@ -180,6 +184,7 @@ impl Configuration {
 				dirs: dirs,
 				spec: spec,
 				pruning: pruning,
+				pruning_history: pruning_history,
 				logger_config: logger_config,
 				mode: mode,
 				tracing: tracing,
@@ -202,6 +207,7 @@ impl Configuration {
 				dirs: dirs,
 				spec: spec,
 				pruning: pruning,
+				pruning_history: pruning_history,
 				daemon: daemon,
 				logger_config: logger_config,
 				miner_options: miner_options,
@@ -342,6 +348,7 @@ impl Configuration {
 			},
 			tx_queue_size: self.args.flag_tx_queue_size,
 			tx_queue_strategy: try!(self.transaction_queue_strategy()),
+			tx_queue_gas_limit: try!(to_gas_limit(&self.args.flag_tx_queue_gas)),
 			pending_set: try!(to_pending_set(&self.args.flag_relay_set)),
 			reseal_min_period: Duration::from_millis(self.args.flag_reseal_min_period),
 			work_queue_size: self.args.flag_work_queue_size,
@@ -694,6 +701,7 @@ mod tests {
 			file_path: Some("blockchain.json".into()),
 			format: Default::default(),
 			pruning: Default::default(),
+			pruning_history: 64,
 			compaction: Default::default(),
 			wal: true,
 			mode: Default::default(),
@@ -713,6 +721,7 @@ mod tests {
 			dirs: Default::default(),
 			file_path: Some("blockchain.json".into()),
 			pruning: Default::default(),
+			pruning_history: 64,
 			format: Default::default(),
 			compaction: Default::default(),
 			wal: true,
@@ -734,6 +743,7 @@ mod tests {
 			dirs: Default::default(),
 			file_path: Some("blockchain.json".into()),
 			pruning: Default::default(),
+			pruning_history: 64,
 			format: Some(DataFormat::Hex),
 			compaction: Default::default(),
 			wal: true,
@@ -761,6 +771,7 @@ mod tests {
 			dirs: Default::default(),
 			spec: Default::default(),
 			pruning: Default::default(),
+			pruning_history: 64,
 			daemon: None,
 			logger_config: Default::default(),
 			miner_options: Default::default(),
--- a/parity/helpers.rs
+++ b/parity/helpers.rs
@@ -22,7 +22,7 @@ use std::fs::File;
 use util::{clean_0x, U256, Uint, Address, path, H256, CompactionProfile};
 use util::journaldb::Algorithm;
 use ethcore::client::{Mode, BlockID, Switch, VMType, DatabaseCompactionProfile, ClientConfig};
-use ethcore::miner::PendingSet;
+use ethcore::miner::{PendingSet, GasLimit};
 use cache::CacheConfig;
 use dir::Directories;
 use params::Pruning;
@@ -94,6 +94,14 @@ pub fn to_pending_set(s: &str) -> Result<PendingSet, String> {
 	}
 }

+pub fn to_gas_limit(s: &str) -> Result<GasLimit, String> {
+	match s {
+		"auto" => Ok(GasLimit::Auto),
+		"off" => Ok(GasLimit::None),
+		other => Ok(GasLimit::Fixed(try!(to_u256(other)))),
+	}
+}
+
 pub fn to_address(s: Option<String>) -> Result<Address, String> {
 	match s {
 		Some(ref a) => clean_0x(a).parse().map_err(|_| format!("Invalid address: {:?}", a)),
@@ -194,6 +202,7 @@ pub fn to_client_config(
 		mode: Mode,
 		tracing: Switch,
 		pruning: Pruning,
+		pruning_history: u64,
 		compaction: DatabaseCompactionProfile,
 		wal: bool,
 		vm_type: VMType,
@@ -221,6 +230,7 @@ pub fn to_client_config(
 	client_config.mode = mode;
 	client_config.tracing.enabled = tracing;
 	client_config.pruning = pruning.to_algorithm(dirs, genesis_hash, fork_name);
+	client_config.history = pruning_history;
 	client_config.db_compaction = compaction;
 	client_config.db_wal = wal;
 	client_config.vm_type = vm_type;
--- a/parity/main.rs
+++ b/parity/main.rs
@@ -117,6 +117,8 @@ fn start() -> Result<String, String> {
 }

 fn main() {
+	// Always print backtrace on panic.
+	::std::env::set_var("RUST_BACKTRACE", "1");
 	// just redirect to the sync::main()
 	if std::env::args().nth(1).map_or(false, |arg| arg == "sync") {
 		sync::main();
--- a/parity/run.rs
+++ b/parity/run.rs
@@ -52,6 +52,7 @@ pub struct RunCmd {
 	pub dirs: Directories,
 	pub spec: SpecType,
 	pub pruning: Pruning,
+	pub pruning_history: u64,
 	/// Some if execution should be daemonized. Contains pid_file path.
 	pub daemon: Option<String>,
 	pub logger_config: LogConfig,
@@ -149,6 +150,7 @@ pub fn execute(cmd: RunCmd) -> Result<(), String> {
 		cmd.mode,
 		cmd.tracing,
 		cmd.pruning,
+		cmd.pruning_history,
 		cmd.compaction,
 		cmd.wal,
 		cmd.vm_type,
--- a/parity/snapshot.rs
+++ b/parity/snapshot.rs
@@ -52,6 +52,7 @@ pub struct SnapshotCommand {
 	pub dirs: Directories,
 	pub spec: SpecType,
 	pub pruning: Pruning,
+	pub pruning_history: u64,
 	pub logger_config: LogConfig,
 	pub mode: Mode,
 	pub tracing: Switch,
@@ -89,7 +90,7 @@ impl SnapshotCommand {
 		try!(execute_upgrades(&self.dirs, genesis_hash, spec.fork_name.as_ref(), algorithm, self.compaction.compaction_profile()));

 		// prepare client config
-		let client_config = to_client_config(&self.cache_config, &self.dirs, genesis_hash, self.mode, self.tracing, self.pruning, self.compaction, self.wal, VMType::default(), "".into(), spec.fork_name.as_ref());
+		let client_config = to_client_config(&self.cache_config, &self.dirs, genesis_hash, self.mode, self.tracing, self.pruning, self.pruning_history, self.compaction, self.wal, VMType::default(), "".into(), spec.fork_name.as_ref());

 		let service = try!(ClientService::start(
 			client_config,
--- a/rpc/src/v1/tests/eth.rs
+++ b/rpc/src/v1/tests/eth.rs
@@ -25,7 +25,7 @@ use ethcore::spec::{Genesis, Spec};
 use ethcore::block::Block;
 use ethcore::views::BlockView;
 use ethcore::ethereum;
-use ethcore::miner::{MinerOptions, GasPricer, MinerService, ExternalMiner, Miner, PendingSet, PrioritizationStrategy};
+use ethcore::miner::{MinerOptions, GasPricer, MinerService, ExternalMiner, Miner, PendingSet, PrioritizationStrategy, GasLimit};
 use ethcore::account_provider::AccountProvider;
 use devtools::RandomTempPath;
 use util::Hashable;
@@ -60,6 +60,7 @@ fn miner_service(spec: &Spec, accounts: Arc<AccountProvider>) -> Arc<Miner> {
 			tx_queue_size: 1024,
 			tx_gas_limit: !U256::zero(),
 			tx_queue_strategy: PrioritizationStrategy::GasPriceOnly,
+			tx_queue_gas_limit: GasLimit::None,
 			pending_set: PendingSet::SealingOrElseQueue,
 			reseal_min_period: Duration::from_secs(0),
 			work_queue_size: 50,
--- a/sync/src/blocks.rs
+++ b/sync/src/blocks.rs
@@ -183,8 +183,8 @@ impl BlockCollection {
 		{
 			let mut blocks = Vec::new();
 			let mut head = self.head;
-			while head.is_some() {
-				head = self.parents.get(&head.unwrap()).cloned();
+			while let Some(h) = head {
+				head = self.parents.get(&h).cloned();
 				if let Some(head) = head {
 					match self.blocks.get(&head) {
 						Some(block) if block.body.is_some() => {
@@ -200,7 +200,7 @@ impl BlockCollection {
 			for block in blocks.drain(..) {
 				let mut block_rlp = RlpStream::new_list(3);
 				block_rlp.append_raw(&block.header, 1);
-				let body = Rlp::new(block.body.as_ref().unwrap()); // incomplete blocks are filtered out in the loop above
+				let body = Rlp::new(block.body.as_ref().expect("blocks contains only full blocks; qed"));
 				block_rlp.append_raw(body.at(0).as_raw(), 1);
 				block_rlp.append_raw(body.at(1).as_raw(), 1);
 				drained.push(block_rlp.out());
--- a/sync/src/chain.rs
+++ b/sync/src/chain.rs
@@ -89,7 +89,6 @@

 use util::*;
 use network::*;
-use std::mem::{replace};
 use ethcore::views::{HeaderView, BlockView};
 use ethcore::header::{BlockNumber, Header as BlockHeader};
 use ethcore::client::{BlockChainClient, BlockStatus, BlockID, BlockChainInfo, BlockImportError};
@@ -138,7 +137,7 @@ const GET_RECEIPTS_PACKET: u8 = 0x0f;
 const RECEIPTS_PACKET: u8 = 0x10;

 const HEADERS_TIMEOUT_SEC: f64 = 15f64;
-const BODIES_TIMEOUT_SEC: f64 = 5f64;
+const BODIES_TIMEOUT_SEC: f64 = 10f64;
 const FORK_HEADER_TIMEOUT_SEC: f64 = 3f64;

 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
@@ -230,8 +229,6 @@ struct PeerInfo {
 	network_id: U256,
 	/// Peer best block hash
 	latest_hash: H256,
-	/// Peer best block number if known
-	latest_number: Option<BlockNumber>,
 	/// Peer total difficulty if known
 	difficulty: Option<U256>,
 	/// Type of data currenty being requested from peer.
@@ -360,6 +357,8 @@ impl ChainSync {
 		}
 		self.syncing_difficulty = From::from(0u64);
 		self.state = SyncState::Idle;
+		// Reactivate peers only if some progress has been made
+		// since the last sync round of if starting fresh.
 		self.active_peers = self.peers.keys().cloned().collect();
 	}

@@ -371,7 +370,8 @@ impl ChainSync {
 		self.continue_sync(io);
 	}

-	/// Remove peer from active peer set
+	/// Remove peer from active peer set. Peer will be reactivated on the next sync
+	/// round.
 	fn deactivate_peer(&mut self, io: &mut SyncIo, peer_id: PeerId) {
 		trace!(target: "sync", "Deactivating peer {}", peer_id);
 		self.active_peers.remove(&peer_id);
@@ -401,7 +401,6 @@ impl ChainSync {
 			network_id: try!(r.val_at(1)),
 			difficulty: Some(try!(r.val_at(2))),
 			latest_hash: try!(r.val_at(3)),
-			latest_number: None,
 			genesis: try!(r.val_at(4)),
 			asking: PeerAsking::Nothing,
 			asking_blocks: Vec::new(),
@@ -434,7 +433,11 @@ impl ChainSync {
 		}

 		self.peers.insert(peer_id.clone(), peer);
-		self.active_peers.insert(peer_id.clone());
+		// Don't activate peer immediatelly when searching for common block.
+		// Let the current sync round complete first.
+		if self.state != SyncState::ChainHead {
+			self.active_peers.insert(peer_id.clone());
+		}
 		debug!(target: "sync", "Connected {}:{}", peer_id, io.peer_info(peer_id));
 		if let Some((fork_block, _)) = self.fork_block {
 			self.request_headers_by_number(io, peer_id, fork_block, 1, 0, false, PeerAsking::ForkHeader);
@@ -521,7 +524,7 @@ impl ChainSync {
 				continue;
 			}

-			if self.highest_block == None || number > self.highest_block.unwrap() {
+			if self.highest_block.as_ref().map_or(true,  |n| number > *n) {
 				self.highest_block = Some(number);
 			}
 			let hash = info.hash();
@@ -553,9 +556,9 @@ impl ChainSync {
 		}

 		if headers.is_empty() {
-			// Peer does not have any new subchain heads, deactivate it nd try with another
+			// Peer does not have any new subchain heads, deactivate it and try with another.
 			trace!(target: "sync", "{} Disabled for no data", peer_id);
-			io.disable_peer(peer_id);
+			self.deactivate_peer(io, peer_id);
 		}
 		match self.state {
 			SyncState::ChainHead => {
@@ -634,9 +637,9 @@ impl ChainSync {
 		}
 		let mut unknown = false;
 		{
-			let peer = self.peers.get_mut(&peer_id).unwrap();
-			peer.latest_hash = header.hash();
-			peer.latest_number = Some(header.number());
+			if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+				peer.latest_hash = header.hash();
+			}
 		}
 		if self.last_imported_block > header.number() && self.last_imported_block - header.number() > MAX_NEW_BLOCK_AGE {
 			trace!(target: "sync", "Ignored ancient new block {:?}", h);
@@ -729,9 +732,9 @@ impl ChainSync {
 					new_hashes.push(hash.clone());
 					if number > max_height {
 						trace!(target: "sync", "New unknown block hash {:?}", hash);
-						let peer = self.peers.get_mut(&peer_id).unwrap();
-						peer.latest_hash = hash.clone();
-						peer.latest_number = Some(number);
+						if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+							peer.latest_hash = hash.clone();
+						}
 						max_height = number;
 					}
 				},
@@ -808,15 +811,18 @@ impl ChainSync {
 			return;
 		}
 		let (peer_latest, peer_difficulty) = {
-			let peer = self.peers.get_mut(&peer_id).unwrap();
-			if peer.asking != PeerAsking::Nothing || !peer.can_sync() {
+			if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+				if peer.asking != PeerAsking::Nothing || !peer.can_sync() {
+					return;
+				}
+				if self.state == SyncState::Waiting {
+					trace!(target: "sync", "Waiting for the block queue");
+					return;
+				}
+				(peer.latest_hash.clone(), peer.difficulty.clone())
+			} else {
 				return;
 			}
-			if self.state == SyncState::Waiting {
-				trace!(target: "sync", "Waiting for the block queue");
-				return;
-			}
-			(peer.latest_hash.clone(), peer.difficulty.clone())
 		};
 		let chain_info = io.chain().chain_info();
 		let td = chain_info.pending_total_difficulty;
@@ -893,35 +899,40 @@ impl ChainSync {
 		// check to see if we need to download any block bodies first
 		let needed_bodies = self.blocks.needed_bodies(MAX_BODIES_TO_REQUEST, ignore_others);
 		if !needed_bodies.is_empty() {
-			replace(&mut self.peers.get_mut(&peer_id).unwrap().asking_blocks, needed_bodies.clone());
+			if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+				peer.asking_blocks = needed_bodies.clone();
+			}
 			self.request_bodies(io, peer_id, needed_bodies);
 			return;
 		}

 		// find subchain to download
 		if let Some((h, count)) = self.blocks.needed_headers(MAX_HEADERS_TO_REQUEST, ignore_others) {
-			replace(&mut self.peers.get_mut(&peer_id).unwrap().asking_blocks, vec![h.clone()]);
+			if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+				peer.asking_blocks = vec![h.clone()];
+			}
 			self.request_headers_by_hash(io, peer_id, &h, count, 0, false, PeerAsking::BlockHeaders);
 		}
 	}

 	/// Clear all blocks/headers marked as being downloaded by a peer.
 	fn clear_peer_download(&mut self, peer_id: PeerId) {
-		let peer = self.peers.get_mut(&peer_id).unwrap();
-		match peer.asking {
-			PeerAsking::BlockHeaders | PeerAsking::Heads => {
-				for b in &peer.asking_blocks {
-					self.blocks.clear_header_download(b);
-				}
-			},
-			PeerAsking::BlockBodies => {
-				for b in &peer.asking_blocks {
-					self.blocks.clear_body_download(b);
-				}
-			},
-			_ => (),
+		if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+			match peer.asking {
+				PeerAsking::BlockHeaders | PeerAsking::Heads => {
+					for b in &peer.asking_blocks {
+						self.blocks.clear_header_download(b);
+					}
+				},
+				PeerAsking::BlockBodies => {
+					for b in &peer.asking_blocks {
+						self.blocks.clear_body_download(b);
+					}
+				},
+				_ => (),
+			}
+			peer.asking_blocks.clear();
 		}
-		peer.asking_blocks.clear();
 	}

 	fn block_imported(&mut self, hash: &H256, number: BlockNumber, parent: &H256) {
@@ -1030,30 +1041,34 @@ impl ChainSync {

 	/// Reset peer status after request is complete.
 	fn reset_peer_asking(&mut self, peer_id: PeerId, asking: PeerAsking) -> bool {
-		let peer = self.peers.get_mut(&peer_id).unwrap();
-		peer.expired = false;
-		if peer.asking != asking {
-			trace!(target:"sync", "Asking {:?} while expected {:?}", peer.asking, asking);
-			peer.asking = PeerAsking::Nothing;
+		if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+			peer.expired = false;
+			if peer.asking != asking {
+				trace!(target:"sync", "Asking {:?} while expected {:?}", peer.asking, asking);
+				peer.asking = PeerAsking::Nothing;
+				false
+			}
+			else {
+				peer.asking = PeerAsking::Nothing;
+				true
+			}
+		} else {
 			false
 		}
-		else {
-			peer.asking = PeerAsking::Nothing;
-			true
-		}
 	}

 	/// Generic request sender
 	fn send_request(&mut self, sync: &mut SyncIo, peer_id: PeerId, asking: PeerAsking,  packet_id: PacketId, packet: Bytes) {
-		let peer = self.peers.get_mut(&peer_id).unwrap();
-		if peer.asking != PeerAsking::Nothing {
-			warn!(target:"sync", "Asking {:?} while requesting {:?}", peer.asking, asking);
-		}
-		peer.asking = asking;
-		peer.ask_time = time::precise_time_s();
-		if let Err(e) = sync.send(peer_id, packet_id, packet) {
-			debug!(target:"sync", "Error sending request: {:?}", e);
-			sync.disable_peer(peer_id);
+		if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+			if peer.asking != PeerAsking::Nothing {
+				warn!(target:"sync", "Asking {:?} while requesting {:?}", peer.asking, asking);
+			}
+			peer.asking = asking;
+			peer.ask_time = time::precise_time_s();
+			if let Err(e) = sync.send(peer_id, packet_id, packet) {
+				debug!(target:"sync", "Error sending request: {:?}", e);
+				sync.disable_peer(peer_id);
+			}
 		}
 	}

@@ -1371,7 +1386,7 @@ impl ChainSync {
 	/// creates latest block rlp for the given client
 	fn create_latest_block_rlp(chain: &BlockChainClient) -> Bytes {
 		let mut rlp_stream = RlpStream::new_list(2);
-		rlp_stream.append_raw(&chain.block(BlockID::Hash(chain.chain_info().best_block_hash)).unwrap(), 1);
+		rlp_stream.append_raw(&chain.block(BlockID::Hash(chain.chain_info().best_block_hash)).expect("Best block always exists"), 1);
 		rlp_stream.append(&chain.chain_info().total_difficulty);
 		rlp_stream.out()
 	}
@@ -1385,25 +1400,23 @@ impl ChainSync {
 	}

 	/// returns peer ids that have less blocks than our chain
-	fn get_lagging_peers(&mut self, chain_info: &BlockChainInfo, io: &SyncIo) -> Vec<(PeerId, BlockNumber)> {
+	fn get_lagging_peers(&mut self, chain_info: &BlockChainInfo, io: &SyncIo) -> Vec<PeerId> {
 		let latest_hash = chain_info.best_block_hash;
-		let latest_number = chain_info.best_block_number;
 		self.peers.iter_mut().filter_map(|(&id, ref mut peer_info)|
 			match io.chain().block_status(BlockID::Hash(peer_info.latest_hash.clone())) {
 				BlockStatus::InChain => {
-					if peer_info.latest_number.is_none() {
-						peer_info.latest_number = Some(HeaderView::new(&io.chain().block_header(BlockID::Hash(peer_info.latest_hash.clone())).unwrap()).number());
+					if peer_info.latest_hash != latest_hash {
+						Some(id)
+					} else {
+						None
 					}
-					if peer_info.latest_hash != latest_hash && latest_number > peer_info.latest_number.unwrap() {
-						Some((id, peer_info.latest_number.unwrap()))
-					} else { None }
 				},
 				_ => None
 			})
 			.collect::<Vec<_>>()
 	}

-	fn select_random_lagging_peers(&mut self, peers: &[(PeerId, BlockNumber)]) -> Vec<(PeerId, BlockNumber)> {
+	fn select_random_lagging_peers(&mut self, peers: &[PeerId]) -> Vec<PeerId> {
 		use rand::Rng;
 		// take sqrt(x) peers
 		let mut peers = peers.to_vec();
@@ -1416,46 +1429,42 @@ impl ChainSync {
 	}

 	/// propagates latest block to lagging peers
-	fn propagate_blocks(&mut self, chain_info: &BlockChainInfo, io: &mut SyncIo, sealed: &[H256], peers: &[(PeerId, BlockNumber)]) -> usize {
+	fn propagate_blocks(&mut self, chain_info: &BlockChainInfo, io: &mut SyncIo, sealed: &[H256], peers: &[PeerId]) -> usize {
 		trace!(target: "sync", "Sending NewBlocks to {:?}", peers);
 		let mut sent = 0;
-		for &(peer_id, _) in peers {
+		for peer_id in peers {
 			if sealed.is_empty() {
 				let rlp =  ChainSync::create_latest_block_rlp(io.chain());
-				self.send_packet(io, peer_id, NEW_BLOCK_PACKET, rlp);
+				self.send_packet(io, *peer_id, NEW_BLOCK_PACKET, rlp);
 			} else {
 				for h in sealed {
 					let rlp =  ChainSync::create_new_block_rlp(io.chain(), h);
-					self.send_packet(io, peer_id, NEW_BLOCK_PACKET, rlp);
+					self.send_packet(io, *peer_id, NEW_BLOCK_PACKET, rlp);
 				}
 			}
-			self.peers.get_mut(&peer_id).unwrap().latest_hash = chain_info.best_block_hash.clone();
-			self.peers.get_mut(&peer_id).unwrap().latest_number = Some(chain_info.best_block_number);
+			if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+				peer.latest_hash = chain_info.best_block_hash.clone();
+			}
 			sent += 1;
 		}
 		sent
 	}

 	/// propagates new known hashes to all peers
-	fn propagate_new_hashes(&mut self, chain_info: &BlockChainInfo, io: &mut SyncIo, peers: &[(PeerId, BlockNumber)]) -> usize {
+	fn propagate_new_hashes(&mut self, chain_info: &BlockChainInfo, io: &mut SyncIo, peers: &[PeerId]) -> usize {
 		trace!(target: "sync", "Sending NewHashes to {:?}", peers);
 		let mut sent = 0;
-		let last_parent = HeaderView::new(&io.chain().block_header(BlockID::Hash(chain_info.best_block_hash.clone())).unwrap()).parent_hash();
-		for &(peer_id, peer_number) in peers {
-			let peer_best = if chain_info.best_block_number - peer_number > MAX_PEER_LAG_PROPAGATION as BlockNumber {
-				// If we think peer is too far behind just send one latest hash
-				last_parent.clone()
-			} else {
-				self.peers.get(&peer_id).unwrap().latest_hash.clone()
-			};
-			sent += match ChainSync::create_new_hashes_rlp(io.chain(), &peer_best, &chain_info.best_block_hash) {
+		let last_parent = HeaderView::new(&io.chain().block_header(BlockID::Hash(chain_info.best_block_hash.clone()))
+			.expect("Best block always exists")).parent_hash();
+		for peer_id in peers {
+			sent += match ChainSync::create_new_hashes_rlp(io.chain(), &last_parent, &chain_info.best_block_hash) {
 				Some(rlp) => {
 					{
-						let peer = self.peers.get_mut(&peer_id).unwrap();
-						peer.latest_hash = chain_info.best_block_hash.clone();
-						peer.latest_number = Some(chain_info.best_block_number);
+						if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+							peer.latest_hash = chain_info.best_block_hash.clone();
+						}
 					}
-					self.send_packet(io, peer_id, NEW_BLOCK_HASHES_PACKET, rlp);
+					self.send_packet(io, *peer_id, NEW_BLOCK_HASHES_PACKET, rlp);
 					1
 				},
 				None => 0
@@ -1735,7 +1744,6 @@ mod tests {
 				genesis: H256::zero(),
 				network_id: U256::zero(),
 				latest_hash: peer_latest_hash,
-				latest_number: None,
 				difficulty: None,
 				asking: PeerAsking::Nothing,
 				asking_blocks: Vec::new(),
--- a/sync/src/tests/chain.rs
+++ b/sync/src/tests/chain.rs
@@ -95,6 +95,27 @@ fn forked() {
 	assert_eq!(&*net.peer(2).chain.numbers.read(), &peer1_chain);
 }

+#[test]
+fn forked_with_misbehaving_peer() {
+	::env_logger::init().ok();
+	let mut net = TestNet::new(3);
+	// peer 0 is on a totally different chain with higher total difficulty
+	net.peer_mut(0).chain = TestBlockChainClient::new_with_extra_data(b"fork".to_vec());
+	net.peer_mut(0).chain.add_blocks(500, EachBlockWith::Nothing);
+	net.peer_mut(1).chain.add_blocks(100, EachBlockWith::Nothing);
+	net.peer_mut(2).chain.add_blocks(100, EachBlockWith::Nothing);
+
+	net.peer_mut(1).chain.add_blocks(100, EachBlockWith::Nothing);
+	net.peer_mut(2).chain.add_blocks(200, EachBlockWith::Uncle);
+	// peer 1 should sync to peer 2, others should not change
+	let peer0_chain = net.peer(0).chain.numbers.read().clone();
+	let peer2_chain = net.peer(2).chain.numbers.read().clone();
+	net.sync();
+	assert_eq!(&*net.peer(0).chain.numbers.read(), &peer0_chain);
+	assert_eq!(&*net.peer(1).chain.numbers.read(), &peer2_chain);
+	assert_eq!(&*net.peer(2).chain.numbers.read(), &peer2_chain);
+}
+
 #[test]
 fn net_hard_fork() {
 	::env_logger::init().ok();
@@ -116,11 +137,12 @@ fn net_hard_fork() {

 #[test]
 fn restart() {
+	::env_logger::init().ok();
 	let mut net = TestNet::new(3);
 	net.peer_mut(1).chain.add_blocks(1000, EachBlockWith::Uncle);
 	net.peer_mut(2).chain.add_blocks(1000, EachBlockWith::Uncle);

-	net.sync_steps(8);
+	net.sync();

 	// make sure that sync has actually happened
 	assert!(net.peer(0).chain.chain_info().best_block_number > 100);
--- a/sync/src/tests/helpers.rs
+++ b/sync/src/tests/helpers.rs
@@ -26,6 +26,7 @@ pub struct TestIo<'p> {
 	pub chain: &'p mut TestBlockChainClient,
 	pub queue: &'p mut VecDeque<TestPacket>,
 	pub sender: Option<PeerId>,
+	pub to_disconnect: HashSet<PeerId>,
 	overlay: RwLock<HashMap<BlockNumber, Bytes>>,
 }

@@ -35,16 +36,19 @@ impl<'p> TestIo<'p> {
 			chain: chain,
 			queue: queue,
 			sender: sender,
+			to_disconnect: HashSet::new(),
 			overlay: RwLock::new(HashMap::new()),
 		}
 	}
 }

 impl<'p> SyncIo for TestIo<'p> {
-	fn disable_peer(&mut self, _peer_id: PeerId) {
+	fn disable_peer(&mut self, peer_id: PeerId) {
+		self.disconnect_peer(peer_id);
 	}

-	fn disconnect_peer(&mut self, _peer_id: PeerId) {
+	fn disconnect_peer(&mut self, peer_id: PeerId) {
+		self.to_disconnect.insert(peer_id);
 	}

 	fn is_expired(&self) -> bool {
@@ -141,13 +145,30 @@ impl TestNet {
 	pub fn sync_step(&mut self) {
 		for peer in 0..self.peers.len() {
 			if let Some(packet) = self.peers[peer].queue.pop_front() {
-				let mut p = self.peers.get_mut(packet.recipient).unwrap();
-				trace!("--- {} -> {} ---", peer, packet.recipient);
-				ChainSync::dispatch_packet(&p.sync, &mut TestIo::new(&mut p.chain, &mut p.queue, Some(peer as PeerId)), peer as PeerId, packet.packet_id, &packet.data);
-				trace!("----------------");
+				let disconnecting = {
+					let mut p = self.peers.get_mut(packet.recipient).unwrap();
+					trace!("--- {} -> {} ---", peer, packet.recipient);
+					let to_disconnect = {
+						let mut io = TestIo::new(&mut p.chain, &mut p.queue, Some(peer as PeerId));
+						ChainSync::dispatch_packet(&p.sync, &mut io, peer as PeerId, packet.packet_id, &packet.data);
+						io.to_disconnect
+					};
+					for d in &to_disconnect {
+						// notify this that disconnecting peers are disconnecting
+						let mut io = TestIo::new(&mut p.chain, &mut p.queue, Some(*d));
+						p.sync.write().on_peer_aborting(&mut io, *d);
+					}
+					to_disconnect
+				};
+				for d in &disconnecting {
+					// notify other peers that this peer is disconnecting
+					let mut p = self.peers.get_mut(*d).unwrap();
+					let mut io = TestIo::new(&mut p.chain, &mut p.queue, Some(peer as PeerId));
+					p.sync.write().on_peer_aborting(&mut io, peer as PeerId);
+				}
 			}
-			let mut p = self.peers.get_mut(peer).unwrap();
-			p.sync.write().maintain_sync(&mut TestIo::new(&mut p.chain, &mut p.queue, None));
+
+			self.sync_step_peer(peer);
 		}
 	}

--- a/util/Cargo.toml
+++ b/util/Cargo.toml
@@ -3,7 +3,7 @@ description = "Ethcore utility library"
 homepage = "http://ethcore.io"
 license = "GPL-3.0"
 name = "ethcore-util"
-version = "1.3.5"
+version = "1.3.7"
 authors = ["Ethcore <admin@ethcore.io>"]
 build = "build.rs"

--- a/util/src/journaldb/overlayrecentdb.rs
+++ b/util/src/journaldb/overlayrecentdb.rs
@@ -70,6 +70,7 @@ struct JournalOverlay {
 	pending_overlay: H256FastMap<Bytes>, // Nodes being transfered from backing_overlay to backing db
 	journal: HashMap<u64, Vec<JournalEntry>>,
 	latest_era: Option<u64>,
+	earliest_era: Option<u64>,
 }

 #[derive(PartialEq)]
@@ -123,7 +124,10 @@ impl OverlayRecentDB {
 	fn can_reconstruct_refs(&self) -> bool {
 		let reconstructed = Self::read_overlay(&self.backing, self.column);
 		let journal_overlay = self.journal_overlay.read();
-		*journal_overlay == reconstructed
+		journal_overlay.backing_overlay == reconstructed.backing_overlay &&
+		journal_overlay.pending_overlay == reconstructed.pending_overlay &&
+		journal_overlay.journal == reconstructed.journal &&
+		journal_overlay.latest_era == reconstructed.latest_era
 	}

 	fn payload(&self, key: &H256) -> Option<Bytes> {
@@ -135,6 +139,7 @@ impl OverlayRecentDB {
 		let mut overlay = MemoryDB::new();
 		let mut count = 0;
 		let mut latest_era = None;
+		let mut earliest_era = None;
 		if let Some(val) = db.get(col, &LATEST_ERA_KEY).expect("Low-level database error.") {
 			let mut era = decode::<u64>(&val);
 			latest_era = Some(era);
@@ -166,6 +171,7 @@ impl OverlayRecentDB {
 						deletions: deletions,
 					});
 					index += 1;
+					earliest_era = Some(era);
 				};
 				if index == 0 || era == 0 {
 					break;
@@ -178,9 +184,62 @@ impl OverlayRecentDB {
 			backing_overlay: overlay,
 			pending_overlay: HashMap::default(),
 			journal: journal,
-			latest_era: latest_era }
+			latest_era: latest_era,
+			earliest_era: earliest_era,
+		}
 	}

+	fn apply_old_commit(batch: &DBTransaction, journal_overlay: &mut JournalOverlay, column: Option<u32>, end_era: u64, canon_id: &H256) -> Result<(), UtilError> {
+		// apply old commits' details
+		if let Some(ref mut records) = journal_overlay.journal.get_mut(&end_era) {
+			let mut canon_insertions: Vec<(H256, Bytes)> = Vec::new();
+			let mut canon_deletions: Vec<H256> = Vec::new();
+			let mut overlay_deletions: Vec<H256> = Vec::new();
+			let mut index = 0usize;
+			for mut journal in records.drain(..) {
+				//delete the record from the db
+				let mut r = RlpStream::new_list(3);
+				r.append(&end_era);
+				r.append(&index);
+				r.append(&&PADDING[..]);
+				try!(batch.delete(column, &r.drain()));
+				trace!("commit: Delete journal for time #{}.{}: {}, (canon was {}): +{} -{} entries", end_era, index, journal.id, canon_id, journal.insertions.len(), journal.deletions.len());
+				{
+					if canon_id == &journal.id {
+						for h in &journal.insertions {
+							if let Some((d, rc)) = journal_overlay.backing_overlay.raw(&to_short_key(h)) {
+								if rc > 0 {
+									canon_insertions.push((h.clone(), d.to_owned())); //TODO: optimize this to avoid data copy
+								}
+							}
+						}
+						canon_deletions = journal.deletions;
+					}
+					overlay_deletions.append(&mut journal.insertions);
+				}
+				index += 1;
+			}
+			// apply canon inserts first
+			for (k, v) in canon_insertions {
+				try!(batch.put(column, &k, &v));
+				journal_overlay.pending_overlay.insert(to_short_key(&k), v);
+			}
+			// update the overlay
+			for k in overlay_deletions {
+				journal_overlay.backing_overlay.remove_and_purge(&to_short_key(&k));
+			}
+			// apply canon deletions
+			for k in canon_deletions {
+				if !journal_overlay.backing_overlay.contains(&to_short_key(&k)) {
+					try!(batch.delete(column, &k));
+				}
+			}
+		}
+		journal_overlay.journal.remove(&end_era);
+		Ok(())
+	}
+
+
 }

 #[inline]
@@ -214,6 +273,8 @@ impl JournalDB for OverlayRecentDB {

 	fn latest_era(&self) -> Option<u64> { self.journal_overlay.read().latest_era }

+	fn earliest_era(&self) -> Option<u64> { self.journal_overlay.read().earliest_era }
+
 	fn state(&self, key: &H256) -> Option<Bytes> {
 		let journal_overlay = self.journal_overlay.read();
 		let key = to_short_key(key);
@@ -257,57 +318,16 @@ impl JournalDB for OverlayRecentDB {
 			}
 			journal_overlay.journal.entry(now).or_insert_with(Vec::new).push(JournalEntry { id: id.clone(), insertions: inserted_keys, deletions: removed_keys });
 		}
-
-		let journal_overlay = &mut *journal_overlay;
-		// apply old commits' details
 		if let Some((end_era, canon_id)) = end {
-			if let Some(ref mut records) = journal_overlay.journal.get_mut(&end_era) {
-				let mut canon_insertions: Vec<(H256, Bytes)> = Vec::new();
-				let mut canon_deletions: Vec<H256> = Vec::new();
-				let mut overlay_deletions: Vec<H256> = Vec::new();
-				let mut index = 0usize;
-				for mut journal in records.drain(..) {
-					//delete the record from the db
-					let mut r = RlpStream::new_list(3);
-					r.append(&end_era);
-					r.append(&index);
-					r.append(&&PADDING[..]);
-					try!(batch.delete(self.column, &r.drain()));
-					trace!("commit: Delete journal for time #{}.{}: {}, (canon was {}): +{} -{} entries", end_era, index, journal.id, canon_id, journal.insertions.len(), journal.deletions.len());
-					{
-						if canon_id == journal.id {
-							for h in &journal.insertions {
-								if let Some((d, rc)) = journal_overlay.backing_overlay.raw(&to_short_key(h)) {
-									if rc > 0 {
-										canon_insertions.push((h.clone(), d.to_owned())); //TODO: optimize this to avoid data copy
-									}
-								}
-							}
-							canon_deletions = journal.deletions;
-						}
-						overlay_deletions.append(&mut journal.insertions);
-					}
-					index += 1;
-				}
-				// apply canon inserts first
-				for (k, v) in canon_insertions {
-					try!(batch.put(self.column, &k, &v));
-					journal_overlay.pending_overlay.insert(to_short_key(&k), v);
-				}
-				// update the overlay
-				for k in overlay_deletions {
-					journal_overlay.backing_overlay.remove_and_purge(&to_short_key(&k));
-				}
-				// apply canon deletions
-				for k in canon_deletions {
-					if !journal_overlay.backing_overlay.contains(&to_short_key(&k)) {
-						try!(batch.delete(self.column, &k));
-					}
-				}
-			}
-			journal_overlay.journal.remove(&end_era);
+			try!(Self::apply_old_commit(batch, &mut journal_overlay, self.column, end_era, &canon_id));
 		}
-		Ok(0)
+		Ok((0))
+
+	}
+
+	fn commit_old(&mut self, batch: &DBTransaction, end_era: u64, end_id: &H256) -> Result<(), UtilError> {
+		let mut journal_overlay = self.journal_overlay.write();
+		Self::apply_old_commit(batch, &mut journal_overlay, self.column, end_era, end_id)
 	}

 	fn flush(&self) {
--- a/util/src/journaldb/traits.rs
+++ b/util/src/journaldb/traits.rs
@@ -35,10 +35,19 @@ pub trait JournalDB: HashDB {
 	/// Get the latest era in the DB. None if there isn't yet any data in there.
 	fn latest_era(&self) -> Option<u64>;

+	/// Get the earliest era in the DB. None if there isn't yet any data in there.
+	fn earliest_era(&self) -> Option<u64> { None }
+
 	/// Commit all recent insert operations and canonical historical commits' removals from the
 	/// old era to the backing database, reverting any non-canonical historical commit's inserts.
 	fn commit(&mut self, batch: &DBTransaction, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result<u32, UtilError>;

+	/// Commit canonical historical commits' removals from the
+	/// old era to the backing database, reverting any non-canonical historical commit's inserts.
+	fn commit_old(&mut self, _batch: &DBTransaction, _end_era: u64, _end_id: &H256) -> Result<(), UtilError> {
+		Ok(())
+	}
+
 	/// Commit all queued insert and delete operations without affecting any journalling -- this requires that all insertions
 	/// and deletions are indeed canonical and will likely lead to an invalid database if that assumption is violated.
 	///
--- a/util/src/kvdb.rs
+++ b/util/src/kvdb.rs
@@ -213,7 +213,7 @@ impl Database {
 		if let Some(rate_limit) = config.compaction.write_rate_limit {
 			try!(opts.set_parsed_options(&format!("rate_limiter_bytes_per_sec={}", rate_limit)));
 		}
-		try!(opts.set_parsed_options(&format!("max_total_wal_size={}", 64 * 1024 * 1024)));
+		try!(opts.set_parsed_options(&format!("max_total_wal_size={}", 256 * 1024 * 1024)));
 		opts.set_max_open_files(config.max_open_files);
 		opts.create_if_missing(true);
 		opts.set_use_fsync(false);
Author	SHA1	Message	Date
Arkadiy Paronyan	3c2c356f73	Tweak DB and mining defaults (#2598 ) * Increase WAL size * Decreased default work queue size	2016-10-12 20:44:25 +02:00
Arkadiy Paronyan	6b4d0cea6b	Configurable history size in beta (#2587 ) * Reduce DB history * Configurable history size * Set min history size * Test * Fixed a test and reduced the limit	2016-10-12 20:44:17 +02:00
Denis S. Soldatov aka General-Beck	13de1ebc8e	Update gitlab-ci remove arm builds from `master`	2016-10-13 00:20:33 +07:00
Arkadiy Paronyan	1fdb033db4	Backports to beta (#2592 ) * TX queue gas limit config and allow local transactions over the gas limit (#2553) * Gas limit config; Allow local transactions over the limit * Fix typo [ci:skip] * v1.3.7	2016-10-12 17:33:59 +02:00
Denis S. Soldatov aka General-Beck	c1f0ea2016	Update gitlab-ci installer.exe -> InstallParity.exe	2016-10-12 22:33:17 +07:00
Denis S. Soldatov aka General-Beck	964f556284	Update gitlab-ci checksum -> parity.md5	2016-10-12 21:29:58 +07:00
Denis S. Soldatov aka General-Beck	8fba01a208	Update gitlab-ci fix S3 path for win	2016-10-12 20:18:53 +07:00
Denis S. Soldatov aka General-Beck	77b49623ff	Update gitlab-ci fix win build	2016-10-12 19:55:21 +07:00
Denis S. Soldatov aka General-Beck	2a29d7a76f	Update gitlab-ci update windows biuld (add .exe .zip *.md5	2016-10-12 19:22:28 +07:00
Denis S. Soldatov aka General-Beck	66f684548d	Update gitlab-ci fix windows installer	2016-10-12 16:21:12 +07:00
Denis S. Soldatov aka General-Beck	ccebe473d0	Update gitlab-ci fix errors in windows build	2016-10-12 13:27:22 +07:00
Denis S. Soldatov aka General-Beck	9707e61525	Update gitlab-ci [ci:skip] Deny warnings in windows build	2016-10-12 01:54:43 +07:00
Denis S. Soldatov aka General-Beck	039594de92	Update gitlab-ci switch to curl in win build	2016-10-12 01:39:53 +07:00
Denis S. Soldatov aka General-Beck	69441b1322	Update gitlab-ci add windows installer	2016-10-12 00:08:24 +07:00
Arkadiy Paronyan	8492e3e61d	Backports to beta v1.3.6 (#2571 ) * v1.3.6 * Print backtrace on panic (#2535) * Don't activate peers on connect; Test (#2537) * Removing unwarps from sync module (#2551) * Remove unwrap from client module (#2554) * remove unwraps in client * imporve block hash expect message * mining perf trace * Fixed race condition in trace import (#2555)	2016-10-11 15:53:45 +02:00
Denis S. Soldatov aka General-Beck	4b7c97783b	Update gitlab-ci remove javascript tag	2016-10-08 10:51:42 +07:00