Make decode_execution_result fallible

Also added a TODO about fetching runtime code while verifying.

Author: liuchengxu

crates/sp-executor/src/lib.rs

@@ -177,19 +177,18 @@ impl ExecutionPhase {
     pub fn decode_execution_result<Header: HeaderT>(
         &self,
         execution_result: Vec<u8>,
-    ) -> Header::Hash {
+    ) -> Result<Header::Hash, VerificationError> {
         match self {
             ExecutionPhase::InitializeBlock { .. } | ExecutionPhase::ApplyExtrinsic { .. } => {
                 let encoded_storage_root = Vec::<u8>::decode(&mut execution_result.as_slice())
-                    .expect("The return value of verifying `initialize_block` and `apply_extrinsic` must be an encoded storage root; qed");
+                    .map_err(VerificationError::InitializeBlockOrApplyExtrinsicDecode)?;
                 Header::Hash::decode(&mut encoded_storage_root.as_slice())
-                    .expect("storage root must use the same Header Hash type; qed")
+                    .map_err(VerificationError::StorageRootDecode)
             }
             ExecutionPhase::FinalizeBlock => {
-                let new_header = Header::decode(&mut execution_result.as_slice()).expect(
-                    "The return value of `BlockBuilder_finalize_block` must be a Header; qed",
-                );
-                *new_header.state_root()
+                let new_header = Header::decode(&mut execution_result.as_slice())
+                    .map_err(VerificationError::HeaderDecode)?;
+                Ok(*new_header.state_root())
             }
         }
     }
@@ -206,6 +205,12 @@ pub enum VerificationError {
     BadProof(sp_std::boxed::Box<dyn sp_state_machine::Error>),
     /// The `post_state_root` calculated by farmer does not match the one declared in [`FraudProof`].
     BadPostStateRoot { expected: H256, got: H256 },
+    /// Failed to decode the return value of `initialize_block` and `apply_extrinsic`.
+    InitializeBlockOrApplyExtrinsicDecode(parity_scale_codec::Error),
+    /// Failed to decode the storage root produced by verifying `initialize_block` or `apply_extrinsic`.
+    StorageRootDecode(parity_scale_codec::Error),
+    /// Failed to decode the header produced by `finalize_block`.
+    HeaderDecode(parity_scale_codec::Error),
 }
 
 /// Fraud proof for the state computation.

crates/subspace-fraud-proof/src/lib.rs

@@ -217,6 +217,7 @@ impl<
                 .expect("Block Hash must be H256; qed"),
         );
 
+        // TODO: ensure the fetched runtime code works as expected.
         let state = self
             .backend
             .state_at(at)
@@ -244,7 +245,7 @@ impl<
         .map_err(VerificationError::BadProof)?;
 
         let new_post_state_root =
-            execution_phase.decode_execution_result::<Block::Header>(execution_result);
+            execution_phase.decode_execution_result::<Block::Header>(execution_result)?;
         let new_post_state_root = H256::decode(&mut new_post_state_root.encode().as_slice())
             .expect("Block Hash must be H256; qed");
 

cumulus/client/cirrus-executor/src/tests.rs

@@ -196,7 +196,8 @@ async fn execution_proof_creation_and_verification_should_work() {
 	)
 	.expect("Check `initialize_block` proof");
 
-	let post_execution_root = execution_phase.decode_execution_result::<Header>(execution_result);
+	let post_execution_root =
+		execution_phase.decode_execution_result::<Header>(execution_result).unwrap();
 	assert_eq!(post_execution_root, intermediate_roots[0].into());
 
 	// Test extrinsic execution.
@@ -237,7 +238,7 @@ async fn execution_proof_creation_and_verification_should_work() {
 		.expect("Check extrinsic execution proof");
 
 		let post_execution_root =
-			execution_phase.decode_execution_result::<Header>(execution_result);
+			execution_phase.decode_execution_result::<Header>(execution_result).unwrap();
 		assert_eq!(post_execution_root, intermediate_roots[target_extrinsic_index + 1].into());
 	}
 
@@ -274,7 +275,8 @@ async fn execution_proof_creation_and_verification_should_work() {
 	)
 	.expect("Check `finalize_block` proof");
 
-	let post_execution_root = execution_phase.decode_execution_result::<Header>(execution_result);
+	let post_execution_root =
+		execution_phase.decode_execution_result::<Header>(execution_result).unwrap();
 	assert_eq!(post_execution_root, *header.state_root());
 }