chore/error: remove from str conversion and add deprecation notificat…

client/api/src/light.rs

@@ -314,11 +314,9 @@ pub mod tests {
 
 	pub type OkCallFetcher = Mutex<Vec<u8>>;
 
-	fn not_implemented_in_tests<T, E>() -> Ready<Result<T, E>>
-	where
-		E: std::convert::From<&'static str>,
+	fn not_implemented_in_tests<T>() -> Ready<Result<T, ClientError>>
 	{
-		futures::future::ready(Err("Not implemented on test node".into()))
+		futures::future::ready(Err(ClientError::Mock("Not implemented on test node")))
 	}
 
 	impl Fetcher<Block> for OkCallFetcher {

client/basic-authorship/src/basic_authorship.rs

@@ -208,10 +208,7 @@ impl<A, B, Block, C> sp_consensus::Proposer<Block> for
 		}));
 
 		async move {
-			match rx.await {
-				Ok(x) => x,
-				Err(err) => Err(sp_blockchain::Error::Msg(err.to_string()))
-			}
+			rx.await?
 		}.boxed()
 	}
 }

client/block-builder/src/lib.rs

@@ -212,7 +212,7 @@ where
 			&state,
 			changes_trie_state.as_ref(),
 			parent_hash,
-		)?;
+		).map_err(|e| sp_blockchain::Error::StorageChanges(e))?;
 
 		Ok(BuiltBlock {
 			block: <Block as BlockT>::new(header, self.extrinsics),

client/cli/src/error.rs

@@ -25,64 +25,61 @@ pub type Result<T> = std::result::Result<T, Error>;
 
 /// Error type for the CLI.
 #[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
 pub enum Error {
-	/// Io error
 	#[error(transparent)]
 	Io(#[from] std::io::Error),
-	/// Cli error
+
 	#[error(transparent)]
 	Cli(#[from] structopt::clap::Error),
-	/// Service error
+
 	#[error(transparent)]
 	Service(#[from] sc_service::Error),
-	/// Client error
+
 	#[error(transparent)]
 	Client(#[from] sp_blockchain::Error),
-	/// scale codec error
+
 	#[error(transparent)]
 	Codec(#[from] parity_scale_codec::Error),
-	/// Input error
+
 	#[error("Invalid input: {0}")]
 	Input(String),
-	/// Invalid listen multiaddress
+
 	#[error("Invalid listen multiaddress")]
 	InvalidListenMultiaddress,
-	/// Application specific error chain sequence forwarder.
-	#[error(transparent)]
-	Application(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
-	/// URI error.
+
 	#[error("Invalid URI; expecting either a secret URI or a public URI.")]
 	InvalidUri(crypto::PublicError),
-	/// Signature length mismatch.
+
 	#[error("Signature has an invalid length. Read {read} bytes, expected {expected} bytes")]
 	SignatureInvalidLength {
 		/// Amount of signature bytes read.
 		read: usize,
 		/// Expected number of signature bytes.
 		expected: usize,
 	},
-	/// Missing base path argument.
+
 	#[error("The base path is missing, please provide one")]
 	MissingBasePath,
-	/// Unknown key type specifier or missing key type specifier.
+
 	#[error("Unknown key type, must be a known 4-character sequence")]
 	KeyTypeInvalid,
-	/// Signature verification failed.
+
 	#[error("Signature verification failed")]
 	SignatureInvalid,
-	/// Storing a given key failed.
+
 	#[error("Key store operation failed")]
 	KeyStoreOperation,
-	/// An issue with the underlying key storage was encountered.
+
 	#[error("Key storage issue encountered")]
 	KeyStorage(#[from] sc_keystore::Error),
-	/// Bytes are not decodable when interpreted as hexadecimal string.
-	#[error("Invalid hex base data")]
+
+	#[error("Invalid hexadecimal string data")]
 	HexDataConversion(#[from] hex::FromHexError),
-	/// Shortcut type to specify types on the fly, discouraged.
-	#[deprecated = "Use `Forwarded` with an error type instead."]
-	#[error("Other: {0}")]
-	Other(String),
+
+	/// Application specific error chain sequence forwarder.
+	#[error(transparent)]
+	Application(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
 }
 
 impl std::convert::From<&str> for Error {
@@ -93,7 +90,7 @@ impl std::convert::From<&str> for Error {
 
 impl std::convert::From<String> for Error {
 	fn from(s: String) -> Error {
-		Error::Input(s.to_string())
+		Error::Input(s)
 	}
 }
 

client/consensus/slots/src/lib.rs

@@ -532,10 +532,11 @@ impl<T: Clone> SlotDuration<T> {
 			}
 		}?;
 
-		if slot_duration.slot_duration() == 0 {
-			return Err(sp_blockchain::Error::Msg(
-				"Invalid value for slot_duration: the value must be greater than 0.".into(),
-			))
+		{
+			let slot_duration = slot_duration.slot_duration();
+			if slot_duration == 0u64 {
+				return Err(sp_blockchain::Error::SlotDurationInvalid(slot_duration))
+			}
 		}
 
 		Ok(slot_duration)

client/db/src/lib.rs

@@ -868,9 +868,7 @@ impl<Block: BlockT> Backend<Block> {
 		let is_archive_pruning = config.pruning.is_archive();
 		let blockchain = BlockchainDb::new(db.clone())?;
 		let meta = blockchain.meta.clone();
-		let map_e = |e: sc_state_db::Error<io::Error>| sp_blockchain::Error::from(
-			format!("State database error: {:?}", e)
-		);
+		let map_e = |e: sc_state_db::Error<io::Error>| sp_blockchain::Error::from_state_db(e);
 		let state_db: StateDb<_, _> = StateDb::new(
 			config.pruning.clone(),
 			!config.source.supports_ref_counting(),
@@ -1059,7 +1057,7 @@ impl<Block: BlockT> Backend<Block> {
 
 			trace!(target: "db", "Canonicalize block #{} ({:?})", new_canonical, hash);
 			let commit = self.storage.state_db.canonicalize_block(&hash)
-				.map_err(|e: sc_state_db::Error<io::Error>| sp_blockchain::Error::from(format!("State database error: {:?}", e)))?;
+				.map_err(|e: sc_state_db::Error<io::Error>| sp_blockchain::Error::from_state_db(e))?;
 			apply_state_commit(transaction, commit);
 		};
 
@@ -1195,9 +1193,7 @@ impl<Block: BlockT> Backend<Block> {
 					number_u64,
 					&pending_block.header.parent_hash(),
 					changeset,
-				).map_err(|e: sc_state_db::Error<io::Error>|
-					sp_blockchain::Error::from(format!("State database error: {:?}", e))
-				)?;
+				).map_err(|e: sc_state_db::Error<io::Error>| sp_blockchain::Error::from_state_db(e))?;
 				apply_state_commit(&mut transaction, commit);
 
 				// Check if need to finalize. Genesis is always finalized instantly.
@@ -1352,7 +1348,7 @@ impl<Block: BlockT> Backend<Block> {
 			transaction.set_from_vec(columns::META, meta_keys::FINALIZED_BLOCK, lookup_key);
 
 			let commit = self.storage.state_db.canonicalize_block(&f_hash)
-				.map_err(|e: sc_state_db::Error<io::Error>| sp_blockchain::Error::from(format!("State database error: {:?}", e)))?;
+				.map_err(|e: sc_state_db::Error<io::Error>| sp_blockchain::Error::from_state_db(e))?;
 			apply_state_commit(transaction, commit);
 
 			if !f_num.is_zero() {

client/light/src/call_executor.rs

@@ -276,7 +276,8 @@ pub fn check_execution_proof_with_make_header<Header, E, H, MakeNextHeader>(
 
 	// TODO: Remove when solved: https://github.com/paritytech/substrate/issues/5047
 	let backend_runtime_code = sp_state_machine::backend::BackendRuntimeCode::new(&trie_backend);
-	let runtime_code = backend_runtime_code.runtime_code()?;
+	let runtime_code = backend_runtime_code.runtime_code()
+		.map_err(|_e| ClientError::RuntimeCodeMissing)?;
 
 	execution_proof_check_on_trie_backend::<H, Header::Number, _, _>(
 		&trie_backend,

client/light/src/fetcher.rs

@@ -239,7 +239,7 @@ impl<E, Block, H, S> FetchChecker<Block> for LightDataChecker<E, H, Block, S>
 			convert_hash(request.header.state_root()),
 			remote_proof,
 			request.keys.iter(),
-		).map_err(Into::into)
+		).map_err(|e| ClientError::from(e))
 	}
 
 	fn check_read_child_proof(
@@ -249,14 +249,14 @@ impl<E, Block, H, S> FetchChecker<Block> for LightDataChecker<E, H, Block, S>
 	) -> ClientResult<HashMap<Vec<u8>, Option<Vec<u8>>>> {
 		let child_info = match ChildType::from_prefixed_key(&request.storage_key) {
 			Some((ChildType::ParentKeyId, storage_key)) => ChildInfo::new_default(storage_key),
-			None => return Err("Invalid child type".into()),
+			None => return Err(ClientError::InvalidChildType),
 		};
 		read_child_proof_check::<H, _>(
 			convert_hash(request.header.state_root()),
 			remote_proof,
 			&child_info,
 			request.keys.iter(),
-		).map_err(Into::into)
+		).map_err(|e| ClientError::from(e))
 	}
 
 	fn check_execution_proof(
@@ -292,10 +292,10 @@ impl<E, Block, H, S> FetchChecker<Block> for LightDataChecker<E, H, Block, S>
 		if *request.header.extrinsics_root() == extrinsics_root {
 			Ok(body)
 		} else {
-			Err(format!("RemoteBodyRequest: invalid extrinsics root expected: {} but got {}",
-				*request.header.extrinsics_root(),
-				extrinsics_root,
-			).into())
+			Err(ClientError::ExtrinsicRootInvalid {
+				received: request.header.extrinsics_root().to_string(),
+				expected: extrinsics_root.to_string(),
+			})
 		}
 
 	}

client/network/src/light_client_handler.rs

@@ -627,7 +627,7 @@ where
 		let prefixed_key = PrefixedStorageKey::new_ref(&request.storage_key);
 		let child_info = match ChildType::from_prefixed_key(prefixed_key) {
 			Some((ChildType::ParentKeyId, storage_key)) => Ok(ChildInfo::new_default(storage_key)),
-			None => Err("Invalid child storage key".into()),
+			None => Err(sp_blockchain::Error::InvalidChildStorageKey),
 		};
 		let proof = match child_info.and_then(|child_info| self.chain.read_child_proof(
 			&BlockId::Hash(block),

client/network/src/on_demand_layer.rs

@@ -65,47 +65,47 @@ impl<Block: BlockT> FetchChecker<Block> for AlwaysBadChecker {
 		_remote_header: Option<Block::Header>,
 		_remote_proof: StorageProof,
 	) -> Result<Block::Header, ClientError> {
-		Err(ClientError::Msg("AlwaysBadChecker".into()))
+		Err(ClientError::AlwaysBadChecker)
 	}
 
 	fn check_read_proof(
 		&self,
 		_request: &RemoteReadRequest<Block::Header>,
 		_remote_proof: StorageProof,
 	) -> Result<HashMap<Vec<u8>,Option<Vec<u8>>>, ClientError> {
-		Err(ClientError::Msg("AlwaysBadChecker".into()))
+		Err(ClientError::AlwaysBadChecker)
 	}
 
 	fn check_read_child_proof(
 		&self,
 		_request: &RemoteReadChildRequest<Block::Header>,
 		_remote_proof: StorageProof,
 	) -> Result<HashMap<Vec<u8>, Option<Vec<u8>>>, ClientError> {
-		Err(ClientError::Msg("AlwaysBadChecker".into()))
+		Err(ClientError::AlwaysBadChecker)
 	}
 
 	fn check_execution_proof(
 		&self,
 		_request: &RemoteCallRequest<Block::Header>,
 		_remote_proof: StorageProof,
 	) -> Result<Vec<u8>, ClientError> {
-		Err(ClientError::Msg("AlwaysBadChecker".into()))
+		Err(ClientError::AlwaysBadChecker)
 	}
 
 	fn check_changes_proof(
 		&self,
 		_request: &RemoteChangesRequest<Block::Header>,
 		_remote_proof: ChangesProof<Block::Header>
 	) -> Result<Vec<(NumberFor<Block>, u32)>, ClientError> {
-		Err(ClientError::Msg("AlwaysBadChecker".into()))
+		Err(ClientError::AlwaysBadChecker)
 	}
 
 	fn check_body_proof(
 		&self,
 		_request: &RemoteBodyRequest<Block::Header>,
 		_body: Vec<Block::Extrinsic>
 	) -> Result<Vec<Block::Extrinsic>, ClientError> {
-		Err(ClientError::Msg("AlwaysBadChecker".into()))
+		Err(ClientError::AlwaysBadChecker)
 	}
 }
 

client/rpc-servers/src/middleware.rs

@@ -48,7 +48,7 @@ impl RpcMetrics {
 					&["protocol"]
 				).ok()?, r).ok()?,
 			})
-		}).ok_or(PrometheusError::Msg("Cannot register metric".to_string()))
+		}).ok_or(PrometheusError::AlreadyReg)
 	}
 }