Client refactoring (#7038)

* Improves `BestBlock` comment

* Improves `TraceDB` comment

* Improves `journaldb::Algorithm` comment.

Probably the whole enum should be renamed to `Strategy` or something alike.

* Comments some of the `Client`'s fields

* Deglobs client imports

* Fixes comments

* Extracts `import_lock` to `Importer` struct

* Extracts `verifier` to `Importer` struct

* Extracts `block_queue` to `Importer` struct

* Extracts `miner` to `Importer` struct

* Extracts `ancient_verifier` to `Importer` struct

* Extracts `rng` to `Importer` struct

* Extracts `import_old_block` to `Importer` struct

* Adds `Nonce` trait

* Adds `Balance` trait

* Adds `ChainInfo` trait

* Fixes imports for tests using `chain_info` method

* Adds `BlockInfo` trait

* Adds more `ChainInfo` imports

* Adds `BlockInfo` imports

* Adds `ReopenBlock` trait

* Adds `PrepareOpenBlock` trait

* Fixes import in tests

* Adds `CallContract` trait

* Fixes imports in tests using `call_contract` method

* Adds `TransactionInfo` trait

* Adds `RegistryInfo` trait

* Fixes imports in tests using `registry_address` method

* Adds `ScheduleInfo` trait

* Adds `ImportSealedBlock` trait

* Fixes imports in test using `import_sealed_block` method

* Adds `BroadcastProposalBlock` trait

* Migrates `Miner` to static dispatch

* Fixes tests

* Moves `calculate_enacted_retracted` to `Importer`

* Moves import-related methods to `Importer`

* Removes redundant `import_old_block` wrapper

* Extracts `import_block*` into separate trait

* Fixes tests

* Handles `Pending` in `LightFetch`

* Handles `Pending` in filters

* Handles `Pending` in `ParityClient`

* Handles `Pending` in `EthClient`

* Removes `BlockId::Pending`, partly refactors dependent code

* Adds `StateInfo` trait

* Exports `StateOrBlock` and `BlockChain` types from `client` module

* Refactors `balance` RPC using generic API

* Refactors `storage_at` RPC using generic API

* Makes `MinerService::pending_state`'s return type dynamic

* Adds `StateOrBlock` and `BlockChain` types

* Adds impl of `client::BlockChain` for `Client`

* Exports `StateInfo` trait from `client` module

* Missing `self` use

To be fixed up to "Adds impl of `client::BlockChain` for `Client`"

* Adds `number_to_id` and refactors dependent RPC methods

* Refactors `code_at` using generic API

* Adds `StateClient` trait

* Refactors RPC to use `StateClient` trait

* Reverts `client::BlockChain` trait stuff, refactors methods to accept `StateOrBlock`

* Refactors TestClient

* Adds helper function `block_number_to_id`

* Uses `block_number_to_id` instead of local function

* Handles `Pending` in `list_accounts` and `list_storage_keys`

* Attempt to use associated types for state instead of trait objects

* Simplifies `state_at_beginning`

* Extracts `call` and `call_many` into separate trait

* Refactors `build_last_hashes` to accept reference

* Exports `Call` type from the module

* Refactors `call` and `call_many` to accept state and header

* Exports `state_at` in `StateClient`

* Exports `pending_block_header` from `MinerService`

* Refactors RPC `call` method using new API

* Adds missing parentheses

* Refactors `parity::call` to use new call API

* Update .gitlab-ci.yml

fix gitlab lint

* Fixes error handling

* Refactors `traces::call` and `call_many` to use new call API

* Refactors `call_contract`

* Refactors `block_header`

* Refactors internal RPC method `block`

* Moves `estimate_gas` to `Call` trait, refactors parameters

* Refactors `estimate_gas` in RPC

* Refactors `uncle`

* Refactors RPC `transaction`

* Covers missing branches

* Makes it all compile, fixes compiler grumbles

* Adds casts in `blockchain` module

* Fixes `PendingBlock` tests, work on `MinerService`

* Adds test stubs for StateClient and EngineInfo

* Makes `state_db` public

* Adds missing impls for `TestBlockChainClient`

* Adds trait documentation

* Adds missing docs to the `state_db` module

* Fixes trivial compilation errors

* Moves `code_hash` method to a `BlockInfo` trait

* Refactors `Verifier` to be generic over client

* Refactors `TransactionFilter` to be generic over client

* Refactors `Miner` and `Client` to reflect changes in verifier and txfilter API

* Moves `ServiceTransactionChecker` back to `ethcore`

* Fixes trait bounds in `Miner` API

* Fixes `Client`

* Fixes lifetime bound in `FullFamilyParams`

* Adds comments to `FullFamilyParams`

* Fixes imports in `ethcore`

* Fixes BlockNumber handling in `code_at` and `replay_block_transactions`

* fix compile issues

* First step to redundant trait merge

* Fixes compilation error in RPC tests

* Adds mock `State` as a stub for `TestClient`

* Handles `StateOrBlock::State` in `TestBlockChainClient::balance`

* Fixes `transaction_count` RPC

* Fixes `transaction_count`

* Moves `service_transaction.json` to the `contracts` subfolder

* Fixes compilation errors in tests

* Refactors client to use `AccountData`

* Refactors client to use `BlockChain`

* Refactors miner to use aggregate traits

* Adds `SealedBlockImporter` trait

* Refactors miner to use `SealedBlockImporter` trait

* Removes unused imports

* Simplifies `RegistryInfo::registry_address`

* Fixes indentation

* Removes commented out trait bound

ethcore/src/verification/canon_verifier.rs

@@ -16,6 +16,7 @@
 
 //! Canonical verifier.
 
+use client::{BlockInfo, CallContract};
 use engines::EthEngine;
 use error::Error;
 use header::Header;
@@ -25,13 +26,13 @@ use super::verification;
 /// A canonial verifier -- this does full verification.
 pub struct CanonVerifier;
 
-impl Verifier for CanonVerifier {
+impl<C: BlockInfo + CallContract> Verifier<C> for CanonVerifier {
 	fn verify_block_family(
 		&self,
 		header: &Header,
 		parent: &Header,
 		engine: &EthEngine,
-		do_full: Option<verification::FullFamilyParams>,
+		do_full: Option<verification::FullFamilyParams<C>>,
 	) -> Result<(), Error> {
 		verification::verify_block_family(header, parent, engine, do_full)
 	}

ethcore/src/verification/mod.rs

@@ -28,6 +28,8 @@ pub use self::canon_verifier::CanonVerifier;
 pub use self::noop_verifier::NoopVerifier;
 pub use self::queue::{BlockQueue, Config as QueueConfig, VerificationQueue, QueueInfo};
 
+use client::{BlockInfo, CallContract};
+
 /// Verifier type.
 #[derive(Debug, PartialEq, Clone)]
 pub enum VerifierType {
@@ -47,7 +49,7 @@ impl Default for VerifierType {
 }
 
 /// Create a new verifier based on type.
-pub fn new(v: VerifierType) -> Box<Verifier> {
+pub fn new<C: BlockInfo + CallContract>(v: VerifierType) -> Box<Verifier<C>> {
 	match v {
 		VerifierType::Canon | VerifierType::CanonNoSeal => Box::new(CanonVerifier),
 		VerifierType::Noop => Box::new(NoopVerifier),

ethcore/src/verification/noop_verifier.rs

@@ -16,6 +16,7 @@
 
 //! No-op verifier.
 
+use client::{BlockInfo, CallContract};
 use engines::EthEngine;
 use error::Error;
 use header::Header;
@@ -25,13 +26,13 @@ use super::{verification, Verifier};
 #[allow(dead_code)]
 pub struct NoopVerifier;
 
-impl Verifier for NoopVerifier {
+impl<C: BlockInfo + CallContract> Verifier<C> for NoopVerifier {
 	fn verify_block_family(
 		&self,
 		_: &Header,
 		_t: &Header,
 		_: &EthEngine,
-		_: Option<verification::FullFamilyParams>
+		_: Option<verification::FullFamilyParams<C>>
 	) -> Result<(), Error> {
 		Ok(())
 	}

ethcore/src/verification/verification.rs

@@ -33,7 +33,7 @@ use triehash::ordered_trie_root;
 use unexpected::{Mismatch, OutOfBounds};
 
 use blockchain::*;
-use client::BlockChainClient;
+use client::{BlockInfo, CallContract};
 use engines::EthEngine;
 use error::{BlockError, Error};
 use header::{BlockNumber, Header};
@@ -109,24 +109,36 @@ pub fn verify_block_unordered(header: Header, bytes: Bytes, engine: &EthEngine,
 	})
 }
 
-/// Parameters for full verification of block family: block bytes, transactions, blockchain, and state access.
-pub type FullFamilyParams<'a> = (&'a [u8], &'a [SignedTransaction], &'a BlockProvider, &'a BlockChainClient);
+/// Parameters for full verification of block family
+pub struct FullFamilyParams<'a, C: BlockInfo + CallContract + 'a> {
+	/// Serialized block bytes
+	pub block_bytes: &'a [u8],
+
+	/// Signed transactions
+	pub transactions: &'a [SignedTransaction],
+
+	/// Block provider to use during verification
+	pub block_provider: &'a BlockProvider,
+
+	/// Engine client to use during verification
+	pub client: &'a C,
+}
 
 /// Phase 3 verification. Check block information against parent and uncles.
-pub fn verify_block_family(header: &Header, parent: &Header, engine: &EthEngine, do_full: Option<FullFamilyParams>) -> Result<(), Error> {
+pub fn verify_block_family<C: BlockInfo + CallContract>(header: &Header, parent: &Header, engine: &EthEngine, do_full: Option<FullFamilyParams<C>>) -> Result<(), Error> {
 	// TODO: verify timestamp
 	verify_parent(&header, &parent, engine.params().gas_limit_bound_divisor)?;
 	engine.verify_block_family(&header, &parent)?;
 
-	let (bytes, txs, bc, client) = match do_full {
+	let params = match do_full {
 		Some(x) => x,
 		None => return Ok(()),
 	};
 
-	verify_uncles(header, bytes, bc, engine)?;
+	verify_uncles(header, params.block_bytes, params.block_provider, engine)?;
 
-	for transaction in txs {
-		engine.machine().verify_transaction(transaction, header, client)?;
+	for transaction in params.transactions {
+		engine.machine().verify_transaction(transaction, header, params.client)?;
 	}
 
 	Ok(())
@@ -486,12 +498,12 @@ mod tests {
 		let parent = bc.block_header(header.parent_hash())
 			.ok_or(BlockError::UnknownParent(header.parent_hash().clone()))?;
 
-		let full_params: FullFamilyParams = (
-			bytes,
-			&transactions[..],
-			bc as &BlockProvider,
-			&client as &::client::BlockChainClient
-		);
+		let full_params = FullFamilyParams {
+			block_bytes: bytes,
+			transactions: &transactions[..],
+			block_provider: bc as &BlockProvider,
+			client: &client,
+		};
 		verify_block_family(&header, &parent, engine, Some(full_params))
 	}
 

ethcore/src/verification/verifier.rs

@@ -16,20 +16,23 @@
 
 //! A generic verifier trait.
 
+use client::{BlockInfo, CallContract};
 use engines::EthEngine;
 use error::Error;
 use header::Header;
 use super::verification;
 
 /// Should be used to verify blocks.
-pub trait Verifier: Send + Sync {
+pub trait Verifier<C>: Send + Sync
+	where C: BlockInfo + CallContract
+{
 	/// Verify a block relative to its parent and uncles.
-    fn verify_block_family(
+	fn verify_block_family(
 		&self,
 		header: &Header,
 		parent: &Header,
 		engine: &EthEngine,
-		do_full: Option<verification::FullFamilyParams>
+		do_full: Option<verification::FullFamilyParams<C>>
 	) -> Result<(), Error>;
 
 	/// Do a final verification check for an enacted header vs its expected counterpart.