return Result<Self::Checked, &'static str> from Checkable::check

polkadot/transaction-pool/src/lib.rs

@@ -284,8 +284,8 @@ impl<'a, A> txpool::Verifier<UncheckedExtrinsic> for Verifier<'a, A> where
 		let inner = match uxt.clone().check_with(|a| self.lookup(a)) {
 			Ok(xt) => Some(xt),
 			// keep the transaction around in the future pool and attempt to promote it later.
-			Err((_, Self::NO_ACCOUNT)) => None,
-			Err((_, e)) => bail!(e),
+			Err(Self::NO_ACCOUNT) => None,
+			Err(e) => bail!(e),
 		};
 		let sender = inner.as_ref().map(|x| x.signed.clone());
 

substrate/runtime/executive/src/lib.rs

@@ -173,7 +173,7 @@ impl<
 	/// Actually apply an extrinsic given its `encoded_len`; this doesn't note its hash.
 	fn apply_extrinsic_no_note_with_len(uxt: Block::Extrinsic, encoded_len: usize) -> result::Result<internal::ApplyOutcome, internal::ApplyError> {
 		// Verify the signature is good.
-		let xt = uxt.check_with(Lookup::lookup).map_err(|_| internal::ApplyError::BadSignature(""))?;
+		let xt = uxt.check_with(Lookup::lookup).map_err(internal::ApplyError::BadSignature)?;
 
 		if xt.sender() != &Default::default() {
 			// check index

substrate/runtime/primitives/src/generic.rs

@@ -109,9 +109,8 @@ where
 	ThisLookup: FnOnce(Address) -> Result<AccountId, &'static str>,
 {
 	type Checked = CheckedExtrinsic<AccountId, Index, Call>;
-	type Error = &'static str;
 
-	fn check_with(self, lookup: ThisLookup) -> Result<Self::Checked, (Self, Self::Error)> {
+	fn check_with(self, lookup: ThisLookup) -> Result<Self::Checked, &'static str> {
 		if !self.is_signed() {
 			Ok(CheckedExtrinsic(Extrinsic {
 				signed: Default::default(),
@@ -121,17 +120,14 @@ where
 		} else {
 			let extrinsic: Extrinsic<AccountId, Index, Call>
 				= Extrinsic {
-					signed: match lookup(self.extrinsic.signed.clone()) {
-						Ok(success) => success,
-						Err(error) => return Err((self, error)),
-					},
-					index: self.extrinsic.index.clone(),
-					function: self.extrinsic.function.clone(),
+					signed: lookup(self.extrinsic.signed)?,
+					index: self.extrinsic.index,
+					function: self.extrinsic.function,
 				};
 			if ::verify_encoded_lazy(&self.signature, &extrinsic, &extrinsic.signed) {
 				Ok(CheckedExtrinsic(extrinsic))
 			} else {
-				Err((self, "bad signature in extrinsic"))
+				Err("bad signature in extrinsic")
 			}
 		}
 	}

substrate/runtime/primitives/src/testing.rs

@@ -158,9 +158,8 @@ impl<Call: AuxDispatchable + Slicable + Sized + Send + Sync + Serialize + Deseri
 	}
 }
 impl<Call: Slicable + Sync + Send + Serialize + AuxDispatchable, Context> Checkable<Context> for TestXt<Call> {
-	type Error = ();
 	type Checked = Self;
-	fn check_with(self, _: Context) -> Result<Self::Checked, (Self, ())> { Ok(self) }
+	fn check_with(self, _: Context) -> Result<Self::Checked, &'static str> { Ok(self) }
 }
 impl<Call: AuxDispatchable<Aux = u64> + Slicable + Sized + Send + Sync + Serialize + DeserializeOwned + Clone + Eq + Debug> Applyable for TestXt<Call> {
 	type AccountId = u64;

substrate/runtime/primitives/src/traits.rs

@@ -376,11 +376,8 @@ pub type HashingFor<B> = <<B as Block>::Header as Header>::Hashing;
 pub trait Checkable<Context>: Sized {
 	/// Returned if `check_with` succeeds.
 	type Checked;
-	/// Returned if `check_with` fails.
-	type Error;
 
-	/// Gives back ownership of unchanged `self` in case of an error.
-	fn check_with(self, context: Context) -> Result<Self::Checked, (Self, Self::Error)>;
+	fn check_with(self, context: Context) -> Result<Self::Checked, &'static str>;
 }
 
 /// A "checkable" piece of information, used by the standard Substrate Executive in order to
@@ -390,18 +387,14 @@ pub trait Checkable<Context>: Sized {
 pub trait BlindCheckable: Sized {
 	/// Returned if `check` succeeds.
 	type Checked;
-	/// Returned if `check` fails.
-	type Error;
 
-	/// Gives back ownership of unchanged `self` in case of an error.
-	fn check(self) -> Result<Self::Checked, (Self, Self::Error)>;
+	fn check(self) -> Result<Self::Checked, &'static str>;
 }
 
 // Every `BlindCheckable` is also a `Checkable` for arbitrary `Context`.
 impl<T: BlindCheckable, Context> Checkable<Context> for T {
 	type Checked = <Self as BlindCheckable>::Checked;
-	type Error = T::Error;
-	fn check_with(self, _: Context) -> Result<Self::Checked, (Self, Self::Error)> {
+	fn check_with(self, _: Context) -> Result<Self::Checked, &'static str> {
 		BlindCheckable::check(self)
 	}
 }

substrate/test-runtime/src/lib.rs

@@ -119,13 +119,12 @@ impl Slicable for Extrinsic {
 
 impl BlindCheckable for Extrinsic {
 	type Checked = Self;
-	type Error = &'static str;
 
-	fn check(self) -> Result<Self, (Self, Self::Error)> {
+	fn check(self) -> Result<Self, &'static str> {
 		if ::runtime_primitives::verify_encoded_lazy(&self.signature, &self.transfer, &self.transfer.from) {
 			Ok(self)
 		} else {
-			Err((self, "bad signature"))
+			Err("bad signature")
 		}
 	}
 }