Extract engines to own crates (#10966)

* Add client-traits crate
Move the BlockInfo trait to new crate

* New crate `machine`
Contains code extracted from ethcore that defines `Machine`, `Externalities` and other execution related code.

* Use new machine and client-traits crates in ethcore

* Use new crates machine and client-traits instead of ethcore where appropriate

* Fix tests

* Don't re-export so many types from ethcore::client

* Fixing more fallout from removing re-export

* fix test

* More fallout from not re-exporting types

* Add some docs

* cleanup

* import the macro edition style

* Tweak docs

* Add missing import

* remove unused ethabi_derive imports

* Use latest ethabi-contract

* Move many traits from ethcore/client/traits to client-traits crate
Initial version of extracted Engine trait

* Move snapshot related traits to the engine crate (eew)

* Move a few snapshot related types to common_types
Cleanup Executed as exported from machine crate

* fix warning

* Gradually introduce new engine crate: snapshot

* ethcore typechecks with new engine crate

* Sort out types outside ethcore

* Add an EpochVerifier to ethash and use that in Engine.epoch_verifier()
Cleanup

* Document pub members

* Sort out tests
Sort out default impls for EpochVerifier

* Add test-helpers feature and move EngineSigner impl to the right place

* Sort out tests

* Sort out tests and refactor verification types

* Fix missing traits

* More missing traits
Fix Histogram

* Fix tests and cleanup

* cleanup

* Put back needed logger import

* Don't rexport common_types from ethcore/src/client
Don't export ethcore::client::*

* Remove files no longer used
Use types from the engine crate
Explicit exports from engine::engine

* Get rid of itertools

* Move a few more traits from ethcore to client-traits: BlockChainReset, ScheduleInfo, StateClient

* Move ProvingBlockChainClient to client-traits

* Don't re-export ForkChoice and Transition from ethcore

* Address grumbles: sort imports, remove commented out code

* Fix merge resolution error

* Extract the Clique engine to own crate

* Extract NullEngine and the block_reward module from ethcore

* Extract InstantSeal engine to own crate

* Extract remaining engines

* Extract executive_state to own crate so it can be used by engine crates

* Remove snapshot stuff from the engine crate

* Put snapshot traits back in ethcore

* cleanup

* Remove stuff from ethcore

* Don't use itertools

* itertools in aura is legit-ish

* More post-merge fixes

* Re-export less types in client

* cleanup

* Update ethcore/block-reward/Cargo.toml

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* Update ethcore/engines/basic-authority/Cargo.toml

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* Update ethcore/engines/ethash/Cargo.toml

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* Update ethcore/engines/clique/src/lib.rs

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* signers is already a ref

* Add an EngineType enum to tighten up Engine.name()

* Introduce Snapshotting enum to distinguish the type of snapshots a chain uses

* Rename supports_warp to snapshot_mode

* Missing import

* Update ethcore/src/snapshot/consensus/mod.rs

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* remove double-semicolons

ethcore/engines/null-engine/src/lib.rs

@@ -0,0 +1,111 @@
+// Copyright 2015-2019 Parity Technologies (UK) Ltd.
+// This file is part of Parity Ethereum.
+
+// Parity Ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Ethereum.  If not, see <http://www.gnu.org/licenses/>.
+
+use common_types::{
+	BlockNumber,
+	header::Header,
+	engines::params::CommonParams,
+	errors::EthcoreError as Error,
+};
+use engine::Engine;
+use block_reward::{self, RewardKind};
+use ethereum_types::U256;
+use machine::{
+	ExecutedBlock,
+	Machine,
+};
+use common_types::snapshot::Snapshotting;
+
+/// Params for a null engine.
+#[derive(Clone, Default)]
+pub struct NullEngineParams {
+	/// base reward for a block.
+	pub block_reward: U256,
+}
+
+impl From<ethjson::spec::NullEngineParams> for NullEngineParams {
+	fn from(p: ethjson::spec::NullEngineParams) -> Self {
+		NullEngineParams {
+			block_reward: p.block_reward.map_or_else(Default::default, Into::into),
+		}
+	}
+}
+
+/// An engine which does not provide any consensus mechanism and does not seal blocks.
+pub struct NullEngine {
+	params: NullEngineParams,
+	machine: Machine,
+}
+
+impl NullEngine {
+	/// Returns new instance of NullEngine with default VM Factory
+	pub fn new(params: NullEngineParams, machine: Machine) -> Self {
+		NullEngine {
+			params,
+			machine,
+		}
+	}
+}
+impl Engine for NullEngine {
+	fn name(&self) -> &str { "NullEngine" }
+
+	fn machine(&self) -> &Machine { &self.machine }
+
+	fn maximum_uncle_count(&self, _block: BlockNumber) -> usize { 2 }
+
+	fn on_close_block(
+		&self,
+		block: &mut ExecutedBlock,
+		_parent_header: &Header
+	) -> Result<(), Error> {
+		use std::ops::Shr;
+
+		let author = *block.header.author();
+		let number = block.header.number();
+
+		let reward = self.params.block_reward;
+		if reward == U256::zero() { return Ok(()) }
+
+		let n_uncles = block.uncles.len();
+
+		let mut rewards = Vec::new();
+
+		// Bestow block reward
+		let result_block_reward = reward + reward.shr(5) * U256::from(n_uncles);
+		rewards.push((author, RewardKind::Author, result_block_reward));
+
+		// bestow uncle rewards.
+		for u in &block.uncles {
+			let uncle_author = u.author();
+			let result_uncle_reward = (reward * U256::from(8 + u.number() - number)).shr(3);
+			rewards.push((*uncle_author, RewardKind::uncle(number, u.number()), result_uncle_reward));
+		}
+
+		block_reward::apply_block_rewards(&rewards, block, &self.machine)
+	}
+
+	fn verify_local_seal(&self, _header: &Header) -> Result<(), Error> {
+		Ok(())
+	}
+
+	fn snapshot_mode(&self) -> Snapshotting {
+		Snapshotting::PoW { blocks: 10_000, max_restore_blocks: 10_000 }
+	}
+
+	fn params(&self) -> &CommonParams {
+		self.machine.params()
+	}
+}