Make most tests compile again

runtime/src/validate_block/implementation.rs

@@ -141,16 +141,17 @@ impl<B: BlockT<Hash = H256>> Storage for WitnessStorage<B> {
 		let root = match delta_trie_root::<Layout<Blake2Hasher>, _, _, _, _>(
 			&mut self.witness_data,
 			self.storage_root.clone(),
-			self.overlay.drain()
+			self.overlay.drain(),
 		) {
 			Ok(root) => root,
-			Err(_) => return [0; STORAGE_ROOT_LEN],
+			Err(e) => match *e {
+				trie_db::TrieError::InvalidStateRoot(_) => panic!("Invalid state root"),
+				trie_db::TrieError::IncompleteDatabase(_) => panic!("IncompleteDatabase"),
+				trie_db::TrieError::DecoderError(_, _) => panic!("DecodeError"),
+			}
 		};
 
-		assert!(root.as_ref().len() <= STORAGE_ROOT_LEN);
-		let mut res = [0; STORAGE_ROOT_LEN];
-		res.copy_from_slice(root.as_ref());
-		res
+		root.into()
 	}
 }
 

runtime/src/validate_block/mod.rs

@@ -63,7 +63,7 @@ macro_rules! register_validate_block_impl {
 			unsafe fn validate_block(
 				arguments: *const u8,
 				arguments_len: usize,
-			) {
+			) -> u64 {
 				let params = $crate::validate_block::parachain::wasm_api::load_params(
 					arguments,
 					arguments_len,
@@ -72,6 +72,9 @@ macro_rules! register_validate_block_impl {
 				$crate::validate_block::implementation::validate_block::<
 					$block, $block_executor
 				>(params);
+
+				// We don't return anything for now.
+				0
 			}
 		}
 	};
@@ -83,4 +86,4 @@ macro_rules! register_validate_block_impl {
 #[macro_export]
 macro_rules! register_validate_block_impl {
 	($block:ty, $block_executor:ty) => {};
-}
+}

runtime/src/validate_block/tests.rs

@@ -19,7 +19,7 @@ use crate::{ParachainBlockData, WitnessData};
 use rio::TestExternalities;
 use keyring::AccountKeyring;
 use runtime_primitives::{generic::BlockId, traits::{Block as BlockT, Header as HeaderT}};
-use executor::{WasmExecutor, error::Result, wasmi::RuntimeValue::I32};
+use executor::{call_in_wasm, error::Result, WasmExecutionMethod};
 use test_client::{
 	TestClientBuilder, TestClientBuilderExt, DefaultTestClientBuilderExt, Client, LongestChain,
 	runtime::{Block, Transfer, Hash, WASM_BINARY, Header}
@@ -31,34 +31,21 @@ use codec::Encode;
 
 fn call_validate_block(parent_head: Header, block_data: ParachainBlockData<Block>) -> Result<()> {
 	let mut ext = TestExternalities::default();
-	WasmExecutor::new().call_with_custom_signature(
-		&mut ext,
-		1024,
-		&WASM_BINARY,
-		"validate_block",
-		|alloc| {
-			let params = ValidationParams {
-				block_data: block_data.encode(),
-				parent_head: parent_head.encode(),
-				ingress: Vec::new(),
-			}.encode();
-			let params_offset = alloc(&params)?;
+	let mut ext_ext = ext.ext();
+	let params = ValidationParams {
+		block_data: block_data.encode(),
+		parent_head: parent_head.encode(),
+		ingress: Vec::new(),
+	}.encode();
 
-			Ok(
-				vec![
-					I32(params_offset as i32),
-					I32(params.len() as i32),
-				]
-			)
-		},
-		|res, _| {
-			if res.is_none() {
-				Ok(Some(()))
-			} else {
-				Ok(None)
-			}
-		}
-	)
+	call_in_wasm(
+		"validate_block",
+		&params,
+		WasmExecutionMethod::Interpreted,
+		&mut ext_ext,
+		&WASM_BINARY,
+		1024,
+	).map(|v| assert!(v.is_empty(), "`validate_block` does not return anything"))
 }
 
 fn create_extrinsics() -> Vec<<Block as BlockT>::Extrinsic> {
@@ -99,9 +86,10 @@ fn build_block_with_proof(
 	extrinsics: Vec<<Block as BlockT>::Extrinsic>,
 ) -> (Block, WitnessData) {
 	let block_id = BlockId::Hash(client.info().chain.best_hash);
-	let mut builder = client.new_block_at_with_proof_recording(
+	let mut builder = client.new_block_at(
 		&block_id,
-		Default::default()
+		Default::default(),
+		true,
 	).expect("Initializes new block");
 
 	extrinsics.into_iter().for_each(|e| builder.push(e).expect("Pushes an extrinsic"));