Don't include :code by default in storage proofs (#5060)

* Adds test to verify that the runtime currently is always contained in
the proof

* Start passing the runtime wasm code from the outside

* Fix compilation

* More build fixes

* Make the test work as expected now :)

* Last fixes

* Fixes benchmarks

* Review feedback

* Apply suggestions from code review

Co-Authored-By: Sergei Pepyakin <sergei@parity.io>

* Review feedback

* Fix compilation

Co-authored-by: Sergei Pepyakin <s.pepyakin@gmail.com>

substrate/client/executor/src/lib.rs

@@ -110,8 +110,12 @@ pub trait RuntimeInfo {
 	/// Native runtime information.
 	fn native_version(&self) -> &NativeVersion;
 
-	/// Extract RuntimeVersion of given :code block
-	fn runtime_version<E: Externalities> (&self, ext: &mut E) -> error::Result<RuntimeVersion>;
+	/// Extract [`RuntimeVersion`](sp_version::RuntimeVersion) of the given `runtime_code`.
+	fn runtime_version<E: Externalities>(
+		&self,
+		ext: &mut E,
+		runtime_code: &sp_core::traits::RuntimeCode,
+	) -> error::Result<RuntimeVersion>;
 }
 
 #[cfg(test)]

substrate/client/executor/src/native_executor.rs

@@ -20,7 +20,7 @@ use crate::{
 };
 use sp_version::{NativeVersion, RuntimeVersion};
 use codec::{Decode, Encode};
-use sp_core::{NativeOrEncoded, traits::{CodeExecutor, Externalities}};
+use sp_core::{NativeOrEncoded, traits::{CodeExecutor, Externalities, RuntimeCode}};
 use log::trace;
 use std::{result, cell::RefCell, panic::{UnwindSafe, AssertUnwindSafe}, sync::Arc};
 use sp_wasm_interface::{HostFunctions, Function};
@@ -130,6 +130,7 @@ impl<D: NativeExecutionDispatch> NativeExecutor<D> {
 	fn with_runtime<E, R>(
 		&self,
 		ext: &mut E,
+		runtime_code: &RuntimeCode,
 		f: impl for<'a> FnOnce(
 			AssertUnwindSafe<&'a mut (dyn WasmRuntime + 'static)>,
 			&'a RuntimeVersion,
@@ -138,8 +139,9 @@ impl<D: NativeExecutionDispatch> NativeExecutor<D> {
 	) -> Result<R> where E: Externalities {
 		RUNTIMES_CACHE.with(|cache| {
 			let mut cache = cache.borrow_mut();
-			let (runtime, version, code_hash) = cache.fetch_runtime(
+			let (runtime, version) = cache.fetch_runtime(
 				ext,
+				runtime_code,
 				self.fallback_method,
 				self.default_heap_pages,
 				&*self.host_functions,
@@ -151,7 +153,7 @@ impl<D: NativeExecutionDispatch> NativeExecutor<D> {
 			match f(runtime, version, ext) {
 				Ok(res) => res,
 				Err(e) => {
-					cache.invalidate_runtime(self.fallback_method, code_hash);
+					cache.invalidate_runtime(self.fallback_method, runtime_code.hash.clone());
 					Err(e)
 				}
 			}
@@ -179,8 +181,9 @@ impl<D: NativeExecutionDispatch> RuntimeInfo for NativeExecutor<D> {
 	fn runtime_version<E: Externalities>(
 		&self,
 		ext: &mut E,
+		runtime_code: &RuntimeCode,
 	) -> Result<RuntimeVersion> {
-		self.with_runtime(ext, |_runtime, version, _ext| Ok(Ok(version.clone())))
+		self.with_runtime(ext, runtime_code, |_runtime, version, _ext| Ok(Ok(version.clone())))
 	}
 }
 
@@ -195,13 +198,14 @@ impl<D: NativeExecutionDispatch + 'static> CodeExecutor for NativeExecutor<D> {
 	>(
 		&self,
 		ext: &mut E,
+		runtime_code: &RuntimeCode,
 		method: &str,
 		data: &[u8],
 		use_native: bool,
 		native_call: Option<NC>,
-	) -> (Result<NativeOrEncoded<R>>, bool){
+	) -> (Result<NativeOrEncoded<R>>, bool) {
 		let mut used_native = false;
-		let result = self.with_runtime(ext, |mut runtime, onchain_version, mut ext| {
+		let result = self.with_runtime(ext, runtime_code, |mut runtime, onchain_version, mut ext| {
 			match (
 				use_native,
 				onchain_version.can_call_with(&self.native_version.runtime_version),

substrate/client/executor/src/wasm_runtime.rs

@@ -22,7 +22,7 @@
 use crate::error::{Error, WasmError};
 use log::{trace, warn};
 use codec::Decode;
-use sp_core::{storage::well_known_keys, traits::Externalities};
+use sp_core::traits::{Externalities, RuntimeCode};
 use sp_version::RuntimeVersion;
 use std::{collections::hash_map::{Entry, HashMap}, panic::AssertUnwindSafe};
 use sc_executor_common::wasm_runtime::WasmRuntime;
@@ -86,8 +86,9 @@ impl RuntimesCache {
 	///
 	/// # Parameters
 	///
-	/// `ext` - Externalities to use for the runtime. This is used for setting
-	/// up an initial runtime instance.
+	/// `ext` - Externalities to use for the getting the runtime's version call.
+	///
+	/// `runtime_code` - The runtime wasm code used setup the runtime.
 	///
 	/// `default_heap_pages` - Number of 64KB pages to allocate for Wasm execution.
 	///
@@ -95,8 +96,8 @@ impl RuntimesCache {
 	///
 	/// # Return value
 	///
-	/// If no error occurred a tuple `(&mut WasmRuntime, H256)` is
-	/// returned. `H256` is the hash of the runtime code.
+	/// If no error occurred a tuple `(&mut WasmRuntime, RuntimeVerion)` is
+	/// returned.
 	///
 	/// In case of failure one of two errors can be returned:
 	///
@@ -107,20 +108,14 @@ impl RuntimesCache {
 	pub fn fetch_runtime<E: Externalities>(
 		&mut self,
 		ext: &mut E,
+		runtime_code: &RuntimeCode,
 		wasm_method: WasmExecutionMethod,
 		default_heap_pages: u64,
 		host_functions: &[&'static dyn Function],
-	) -> Result<(&mut (dyn WasmRuntime + 'static), &RuntimeVersion, Vec<u8>), Error> {
-		let code_hash = ext
-			.original_storage_hash(well_known_keys::CODE)
-			.ok_or(Error::InvalidCode("`CODE` not found in storage.".into()))?;
+	) -> Result<(&mut (dyn WasmRuntime + 'static), &RuntimeVersion), Error> {
+		let heap_pages = runtime_code.heap_pages.unwrap_or(default_heap_pages);
 
-		let heap_pages = ext
-			.storage(well_known_keys::HEAP_PAGES)
-			.and_then(|pages| u64::decode(&mut &pages[..]).ok())
-			.unwrap_or(default_heap_pages);
-
-		let result = match self.instances.entry((wasm_method, code_hash.clone())) {
+		let result = match self.instances.entry((wasm_method, runtime_code.hash.clone())) {
 			Entry::Occupied(o) => {
 				let result = o.into_mut();
 				if let Ok(ref mut cached_runtime) = result {
@@ -142,6 +137,7 @@ impl RuntimesCache {
 						*result = create_versioned_wasm_runtime(
 							ext,
 							wasm_method,
+							runtime_code,
 							heap_pages,
 							host_functions.into(),
 						);
@@ -157,6 +153,7 @@ impl RuntimesCache {
 				let result = create_versioned_wasm_runtime(
 					ext,
 					wasm_method,
+					runtime_code,
 					heap_pages,
 					host_functions.into(),
 				);
@@ -168,7 +165,7 @@ impl RuntimesCache {
 		};
 
 		result.as_mut()
-			.map(|entry| (entry.runtime.as_mut(), &entry.version, code_hash))
+			.map(|entry| (entry.runtime.as_mut(), &entry.version))
 			.map_err(|ref e| Error::InvalidCode(format!("{:?}", e)))
 	}
 
@@ -209,13 +206,17 @@ pub fn create_wasm_runtime_with_code(
 fn create_versioned_wasm_runtime<E: Externalities>(
 	ext: &mut E,
 	wasm_method: WasmExecutionMethod,
+	runtime_code: &RuntimeCode,
 	heap_pages: u64,
 	host_functions: Vec<&'static dyn Function>,
 ) -> Result<VersionedRuntime, WasmError> {
-	let code = ext
-		.original_storage(well_known_keys::CODE)
-		.ok_or(WasmError::CodeNotFound)?;
-	let mut runtime = create_wasm_runtime_with_code(wasm_method, heap_pages, &code, host_functions, false)?;
+	let mut runtime = create_wasm_runtime_with_code(
+		wasm_method,
+		heap_pages,
+		&runtime_code.code,
+		host_functions,
+		false,
+	)?;
 
 	// Call to determine runtime version.
 	let version_result = {