revert some unnecessary changes

Author: xlc

core/client/src/block_builder/block_builder.rs

@@ -17,7 +17,6 @@
 use super::api::BlockBuilder as BlockBuilderApi;
 use std::vec::Vec;
 use parity_codec::Encode;
-use runtime_primitives::ApplyResult;
 use runtime_primitives::generic::BlockId;
 use runtime_primitives::traits::{
 	Header as HeaderT, Hash, Block as BlockT, One, HashFor, ProvideRuntimeApi, ApiRef, DigestFor,
@@ -104,11 +103,11 @@ where
 				ExecutionContext::BlockConstruction,
 				xt.clone()
 			)? {
-				ApplyResult::Success | ApplyResult::DispatchError(_) => {
+				Ok(_) => {
 					extrinsics.push(xt);
 					Ok(())
 				}
-				ApplyResult::ApplyError(e) => {
+				Err(e) => {
 					Err(error::Error::ApplyExtrinsicFailed(e))
 				}
 			}

core/sr-primitives/src/lib.rs

@@ -544,18 +544,18 @@ pub struct DispatchError {
 	pub message: Option<&'static str>,
 }
 
-// TODO: custom implement Encode & Decode to make it a two byte value
 #[derive(Eq, PartialEq, Clone, Copy, Encode, Decode)]
-#[cfg_attr(feature = "std", derive(Debug, Serialize))]
+ #[cfg_attr(feature = "std", derive(Debug, Serialize))]
+ /// Outcome of a valid extrinsic application. Capable of being sliced.
+ pub enum ApplyOutcome {
+ 	/// Successful application (extrinsic reported no issue).
+ 	Success,
+ 	/// Failed application (extrinsic was probably a no-op other than fees).
+ 	Fail(DispatchError),
+ }
+
 /// Result from attempt to apply an extrinsic.
-pub enum ApplyResult {
-	/// Successful application (extrinsic reported no issue).
-	Success,
-	/// Failed application (extrinsic was probably a no-op other than fees).
-	DispatchError(DispatchError),
-	/// Invalid extrinsic application.
-	ApplyError(ApplyError),
-}
+pub type ApplyResult = Result<ApplyOutcome, ApplyError>;
 
 /// Verify a signature on an encoded value in a lazy manner. This can be
 /// an optimization if the signature scheme has an "unsigned" escape hash.

core/test-runtime/src/system.rs

@@ -23,7 +23,7 @@ use runtime_support::storage::{self, StorageValue, StorageMap};
 use runtime_support::storage_items;
 use runtime_primitives::traits::{Hash as HashT, BlakeTwo256, Header as _};
 use runtime_primitives::generic;
-use runtime_primitives::{ApplyError, ApplyResult, transaction_validity::TransactionValidity};
+use runtime_primitives::{ApplyError, ApplyOutcome, ApplyResult, transaction_validity::TransactionValidity};
 use parity_codec::{KeyedVec, Encode};
 use super::{
 	AccountId, BlockNumber, Extrinsic, Transfer, H256 as Hash, Block, Header, Digest, AuthorityId
@@ -106,10 +106,7 @@ fn execute_block_with_state_root_handler(
 	// execute transactions
 	block.extrinsics.iter().enumerate().for_each(|(i, e)| {
 		storage::unhashed::put(well_known_keys::EXTRINSIC_INDEX, &(i as u32));
-		match execute_transaction_backend(e) {
-			ApplyResult::Success => (),
-			_ => panic!("Invalid transaction"),
-		};
+		execute_transaction_backend(e).unwrap_or_else(|_| panic!("Invalid transaction"));
 		storage::unhashed::kill(well_known_keys::EXTRINSIC_INDEX);
 	});
 
@@ -236,13 +233,11 @@ fn check_signature(utx: &Extrinsic) -> Result<(), ApplyError> {
 }
 
 fn execute_transaction_backend(utx: &Extrinsic) -> ApplyResult {
-	match check_signature(utx) {
-		Ok(_) => match utx {
-			Extrinsic::Transfer(ref transfer, _) => execute_transfer_backend(transfer),
-			Extrinsic::AuthoritiesChange(ref new_auth) => execute_new_authorities_backend(new_auth),
-			Extrinsic::IncludeData(_) => ApplyResult::Success,
-		},
-		Err(err) => ApplyResult::ApplyError(err)
+	check_signature(utx)?;
+	match utx {
+		Extrinsic::Transfer(ref transfer, _) => execute_transfer_backend(transfer),
+		Extrinsic::AuthoritiesChange(ref new_auth) => execute_new_authorities_backend(new_auth),
+		Extrinsic::IncludeData(_) => Ok(ApplyOutcome::Success),
 	}
 }
 
@@ -251,7 +246,7 @@ fn execute_transfer_backend(tx: &Transfer) -> ApplyResult {
 	let nonce_key = tx.from.to_keyed_vec(NONCE_OF);
 	let expected_nonce: u64 = storage::hashed::get_or(&blake2_256, &nonce_key, 0);
 	if !(tx.nonce == expected_nonce) {
-		return ApplyResult::ApplyError(ApplyError::Stale)
+		return Err(ApplyError::Stale)
 	}
 
 	// increment nonce in storage
@@ -263,19 +258,19 @@ fn execute_transfer_backend(tx: &Transfer) -> ApplyResult {
 
 	// enact transfer
 	if !(tx.amount <= from_balance) {
-		return ApplyResult::ApplyError(ApplyError::CantPay)
+		return Err(ApplyError::CantPay)
 	}
 	let to_balance_key = tx.to.to_keyed_vec(BALANCE_OF);
 	let to_balance: u64 = storage::hashed::get_or(&blake2_256, &to_balance_key, 0);
 	storage::hashed::put(&blake2_256, &from_balance_key, &(from_balance - tx.amount));
 	storage::hashed::put(&blake2_256, &to_balance_key, &(to_balance + tx.amount));
-	ApplyResult::Success
+	Ok(ApplyOutcome::Success)
 }
 
 fn execute_new_authorities_backend(new_authorities: &[AuthorityId]) -> ApplyResult {
 	let new_authorities: Vec<AuthorityId> = new_authorities.iter().cloned().collect();
 	<NewAuthorities>::put(new_authorities);
-	ApplyResult::Success
+	Ok(ApplyOutcome::Success)
 }
 
 #[cfg(feature = "std")]

node/executor/src/lib.rs

@@ -38,7 +38,7 @@ mod tests {
 		NativeOrEncoded};
 	use node_primitives::{Hash, BlockNumber, AccountId};
 	use runtime_primitives::traits::{Header as HeaderT, Hash as HashT};
-	use runtime_primitives::{generic::Era, ApplyError, ApplyResult, Perbill};
+	use runtime_primitives::{generic::Era, ApplyOutcome, ApplyError, ApplyResult, Perbill};
 	use {balances, indices, system, staking, timestamp, treasury, contract};
 	use contract::ContractAddressFor;
 	use system::{EventRecord, Phase};
@@ -912,7 +912,7 @@ mod tests {
 		let r = WasmExecutor::new()
 			.call(&mut t, 8, COMPACT_CODE, "BlockBuilder_apply_extrinsic", &vec![].and(&xt())).unwrap();
 		let r = ApplyResult::decode(&mut &r[..]).unwrap();
-		assert_eq!(r, ApplyResult::Success);
+		assert_eq!(r, Ok(ApplyOutcome::Success));
 
 		runtime_io::with_externalities(&mut t, || {
 			assert_eq!(Balances::total_balance(&alice()), 42);

srml/executive/src/lib.rs

@@ -78,7 +78,7 @@ use rstd::prelude::*;
 use rstd::marker::PhantomData;
 use rstd::convert::TryInto;
 use primitives::{
-	generic::Digest, ApplyResult, ApplyError, DispatchError, Error as PrimitiveError,
+	generic::Digest, ApplyResult, ApplyOutcome, ApplyError, DispatchError, Error as PrimitiveError,
 	traits::{
 		self, Header, Zero, One, Checkable, Applyable, CheckEqual, OnFinalize,
 		OnInitialize, NumberFor, Block as BlockT, OffchainWorker,
@@ -231,8 +231,8 @@ where
 	fn apply_extrinsic_no_note(uxt: Block::Extrinsic) {
 		let l = uxt.encode().len();
 		match Self::apply_extrinsic_with_len(uxt, l, None) {
-			ApplyResult::Success => (),
-			ApplyResult::DispatchError(e) => {
+			Ok(ApplyOutcome::Success) => (),
+			Ok(ApplyOutcome::Fail(e)) => {
 				runtime_io::print("Error:");
 				// as u8 first to ensure not using sign-extend
 				runtime_io::print(e.module as u8 as u64);
@@ -241,10 +241,10 @@ where
 					runtime_io::print(msg);
 				}
 			},
-			ApplyResult::ApplyError(ApplyError::CantPay) => panic!("All extrinsics should have sender able to pay their fees"),
-			ApplyResult::ApplyError(ApplyError::BadSignature) => panic!("All extrinsics should be properly signed"),
-			ApplyResult::ApplyError(ApplyError::Stale) | ApplyResult::ApplyError(ApplyError::Future) => panic!("All extrinsics should have the correct nonce"),
-			ApplyResult::ApplyError(ApplyError::FullBlock) => panic!("Extrinsics should not exceed block limit"),
+			Err(ApplyError::CantPay) => panic!("All extrinsics should have sender able to pay their fees"),
+			Err(ApplyError::BadSignature) => panic!("All extrinsics should be properly signed"),
+			Err(ApplyError::Stale) | Err(ApplyError::Future) => panic!("All extrinsics should have the correct nonce"),
+			Err(ApplyError::FullBlock) => panic!("Extrinsics should not exceed block limit"),
 		}
 	}
 
@@ -255,56 +255,49 @@ where
 		to_note: Option<Vec<u8>>,
 	) -> ApplyResult {
 		// Verify that the signature is good.
-		match uxt.check(&Default::default()) {
-			Err(_) => ApplyResult::ApplyError(ApplyError::BadSignature),
-			Ok(xt) => {
-				// Check the weight of the block if that extrinsic is applied.
-				let weight = xt.weight(encoded_len);
-				if <system::Module<System>>::all_extrinsics_weight() + weight > internal::MAX_TRANSACTIONS_WEIGHT {
-					return ApplyResult::ApplyError(ApplyError::FullBlock);
-				}
+		let xt = uxt.check(&Default::default()).map_err(|_| ApplyError::BadSignature)?;
+		// Check the weight of the block if that extrinsic is applied.
+		let weight = xt.weight(encoded_len);
+		if <system::Module<System>>::all_extrinsics_weight() + weight > internal::MAX_TRANSACTIONS_WEIGHT {
+			return Err(ApplyError::FullBlock);
+		}
 
-				if let (Some(sender), Some(index)) = (xt.sender(), xt.index()) {
-					// check index
-					let expected_index = <system::Module<System>>::account_nonce(sender);
-					if index != &expected_index {
-						return if index < &expected_index {
-							ApplyResult::ApplyError(ApplyError::Stale)
-						} else {
-							ApplyResult::ApplyError(ApplyError::Future)
-						}
-					}
-					// pay any fees
-					// TODO: propagate why can't pay
-					match Payment::make_payment(sender, encoded_len) {
-						Err(_) => return ApplyResult::ApplyError(ApplyError::CantPay),
-						Ok(_) => ()
-					};
-
-					// AUDIT: Under no circumstances may this function panic from here onwards.
-					// FIXME: ensure this at compile-time (such as by not defining a panic function, forcing
-					// a linker error unless the compiler can prove it cannot be called).
-					// increment nonce in storage
-					<system::Module<System>>::inc_account_nonce(sender);
+		if let (Some(sender), Some(index)) = (xt.sender(), xt.index()) {
+			// check index
+			let expected_index = <system::Module<System>>::account_nonce(sender);
+			if index != &expected_index {
+				return if index < &expected_index {
+					Err(ApplyError::Stale)
+				} else {
+					Err(ApplyError::Future)
 				}
+			}
+			// pay any fees
+			// TODO: propagate why can't pay
+			Payment::make_payment(sender, encoded_len).map_err(|_| ApplyError::CantPay)?;
+
+			// AUDIT: Under no circumstances may this function panic from here onwards.
+			// FIXME: ensure this at compile-time (such as by not defining a panic function, forcing
+			// a linker error unless the compiler can prove it cannot be called).
+			// increment nonce in storage
+			<system::Module<System>>::inc_account_nonce(sender);
+		}
 
-				// Make sure to `note_extrinsic` only after we know it's going to be executed
-				// to prevent it from leaking in storage.
-				if let Some(encoded) = to_note {
-					<system::Module<System>>::note_extrinsic(encoded);
-				}
+		// Make sure to `note_extrinsic` only after we know it's going to be executed
+		// to prevent it from leaking in storage.
+		if let Some(encoded) = to_note {
+			<system::Module<System>>::note_extrinsic(encoded);
+		}
 
-				// Decode parameters and dispatch
-				let (f, s) = xt.deconstruct();
-				let r = f.dispatch(s.into()).map_err(Into::<DispatchError>::into);
-				<system::Module<System>>::note_applied_extrinsic(&r, encoded_len as u32);
+		// Decode parameters and dispatch
+		let (f, s) = xt.deconstruct();
+		let r = f.dispatch(s.into()).map_err(Into::<DispatchError>::into);
+		<system::Module<System>>::note_applied_extrinsic(&r, encoded_len as u32);
 
-				match r {
-					Ok(_) => ApplyResult::Success,
-					Err(e) => ApplyResult::DispatchError(e),
-				}
-			}
-		}
+		Ok(match r {
+			Ok(_) => ApplyOutcome::Success,
+			Err(e) => ApplyOutcome::Fail(e),
+		})
 	}
 
 	fn final_checks(header: &System::Header) {