Remove all (non-dev) client references from frame, activate dependency enforcer (#4184)

* Move transaction pool to primitives

* move backend, errors into primitives

* remove unused client depencies

* Move rpc-api into primitives

* Move peerset back to client

* Move rpc/api back to client, move palette/support/rpc into utils

* move support-rpc into subfolder

* move system-rpc into utils

* move transaction-pool  and -graph back into client

* fix broken imports

* Clean up test primitives

* Make support test utils independent of frame

* remove unnecessary node dependencies from service

* Reactivate dependency script:
 - only enforce the now achieved status quo will remain
 - allow for primitives to depend on /client for now without failing
 - more discriptive error message so people understand, what it wants
 - minor fix to differentiative between ../client and /client (which may be a subfolder)
 - don't allow this to fail anylonger.

* fix doc comment

* 'Should not' rather than 'must not'.

* Revert unwanted dependency changes

* fix faulty import

* fixup derive_more version

* fix wrong import path

substrate/primitives/blockchain/src/error.rs

@@ -0,0 +1,175 @@
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Substrate client possible errors.
+
+use std::{self, error, result};
+use sp_state_machine;
+use sr_primitives::transaction_validity::TransactionValidityError;
+#[allow(deprecated)]
+use sp_block_builder_runtime_api::compatability_v3;
+use sp_consensus;
+use derive_more::{Display, From};
+use parity_scale_codec::Error as CodecError;
+
+/// Client Result type alias
+pub type Result<T> = result::Result<T, Error>;
+
+
+/// Error when the runtime failed to apply an extrinsic.
+#[derive(Debug, Display)]
+pub enum ApplyExtrinsicFailed {
+	/// The transaction cannot be included into the current block.
+	///
+	/// This doesn't necessary mean that the transaction itself is invalid, but it might be just
+	/// unappliable onto the current block.
+	#[display(fmt = "Extrinsic is not valid: {:?}", _0)]
+	Validity(TransactionValidityError),
+	/// This is used for miscelanious errors that can be represented by string and not handleable.
+	///
+	/// This will become obsolete with complete migration to v4 APIs.
+	#[display(fmt = "Extrinsic failed: {:?}", _0)]
+	Msg(String),
+}
+
+/// Substrate Client error
+#[derive(Debug, Display, From)]
+pub enum Error {
+	/// Consensus Error
+	#[display(fmt = "Consensus: {}", _0)]
+	Consensus(sp_consensus::Error),
+	/// Backend error.
+	#[display(fmt = "Backend error: {}", _0)]
+	#[from(ignore)]
+	Backend(String),
+	/// Unknown block.
+	#[display(fmt = "UnknownBlock: {}", _0)]
+	#[from(ignore)]
+	UnknownBlock(String),
+	/// The `apply_extrinsic` is not valid due to the given `TransactionValidityError`.
+	#[display(fmt = "{:?}", _0)]
+	ApplyExtrinsicFailed(ApplyExtrinsicFailed),
+	/// Execution error.
+	#[display(fmt = "Execution: {}", _0)]
+	Execution(Box<dyn sp_state_machine::Error>),
+	/// Blockchain error.
+	#[display(fmt = "Blockchain: {}", _0)]
+	Blockchain(Box<Error>),
+	/// Invalid authorities set received from the runtime.
+	#[display(fmt = "Current state of blockchain has invalid authorities set")]
+	InvalidAuthoritiesSet,
+	/// Could not get runtime version.
+	#[display(fmt = "On-chain runtime does not specify version")]
+	VersionInvalid,
+	/// Genesis config is invalid.
+	#[display(fmt = "Genesis config provided is invalid")]
+	GenesisInvalid,
+	/// Error decoding header justification.
+	#[display(fmt = "error decoding justification for header")]
+	JustificationDecode,
+	/// Justification for header is correctly encoded, but invalid.
+	#[display(fmt = "bad justification for header: {}", _0)]
+	#[from(ignore)]
+	BadJustification(String),
+	/// Not available on light client.
+	#[display(fmt = "This method is not currently available when running in light client mode")]
+	NotAvailableOnLightClient,
+	/// Invalid remote CHT-based proof.
+	#[display(fmt = "Remote node has responded with invalid header proof")]
+	InvalidCHTProof,
+	/// Remote fetch has been cancelled.
+	#[display(fmt = "Remote data fetch has been cancelled")]
+	RemoteFetchCancelled,
+	/// Remote fetch has been failed.
+	#[display(fmt = "Remote data fetch has been failed")]
+	RemoteFetchFailed,
+	/// Error decoding call result.
+	#[display(fmt = "Error decoding call result of {}: {}", _0, _1)]
+	CallResultDecode(&'static str, CodecError),
+	/// Error converting a parameter between runtime and node.
+	#[display(fmt = "Error converting `{}` between runtime and node", _0)]
+	#[from(ignore)]
+	RuntimeParamConversion(String),
+	/// Changes tries are not supported.
+	#[display(fmt = "Changes tries are not supported by the runtime")]
+	ChangesTriesNotSupported,
+	/// Key changes query has failed.
+	#[display(fmt = "Failed to check changes proof: {}", _0)]
+	#[from(ignore)]
+	ChangesTrieAccessFailed(String),
+	/// Last finalized block not parent of current.
+	#[display(fmt = "Did not finalize blocks in sequential order.")]
+	#[from(ignore)]
+	NonSequentialFinalization(String),
+	/// Safety violation: new best block not descendent of last finalized.
+	#[display(fmt = "Potential long-range attack: block not in finalized chain.")]
+	NotInFinalizedChain,
+	/// Hash that is required for building CHT is missing.
+	#[display(fmt = "Failed to get hash of block for building CHT")]
+	MissingHashRequiredForCHT,
+	/// Invalid calculated state root on block import.
+	#[display(fmt = "Calculated state root does not match.")]
+	InvalidStateRoot,
+	/// A convenience variant for String
+	#[display(fmt = "{}", _0)]
+	#[from(ignore)]
+	Msg(String),
+}
+
+impl error::Error for Error {
+	fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+		match self {
+			Error::Consensus(e) => Some(e),
+			Error::Blockchain(e) => Some(e),
+			_ => None,
+		}
+	}
+}
+
+impl From<String> for Error {
+	fn from(s: String) -> Self {
+		Error::Msg(s)
+	}
+}
+
+impl<'a> From<&'a str> for Error {
+	fn from(s: &'a str) -> Self {
+		Error::Msg(s.into())
+	}
+}
+
+#[allow(deprecated)]
+impl From<compatability_v3::ApplyError> for ApplyExtrinsicFailed {
+	fn from(e: compatability_v3::ApplyError) -> Self {
+		use self::compatability_v3::ApplyError::*;
+		match e {
+			Validity(tx_validity) => Self::Validity(tx_validity),
+			e => Self::Msg(format!("Apply extrinsic failed: {:?}", e)),
+		}
+	}
+}
+
+impl Error {
+	/// Chain a blockchain error.
+	pub fn from_blockchain(e: Box<Error>) -> Self {
+		Error::Blockchain(e)
+	}
+
+	/// Chain a state error.
+	pub fn from_state(e: Box<dyn sp_state_machine::Error>) -> Self {
+		Error::Execution(e)
+	}
+}