Embed runtime version as a custom section

Cargo.toml

@@ -182,6 +182,7 @@ members = [
 	"primitives/trie",
 	"primitives/utils",
 	"primitives/version",
+	"primitives/version/proc-macro",
 	"primitives/wasm-interface",
 	"test-utils/client",
 	"test-utils/derive",

bin/node-template/runtime/Cargo.toml

@@ -34,6 +34,7 @@ sp-session = { version = "3.0.0", default-features = false, path = "../../../pri
 sp-std = { version = "3.0.0", default-features = false, path = "../../../primitives/std" }
 sp-transaction-pool = { version = "3.0.0", default-features = false, path = "../../../primitives/transaction-pool" }
 sp-version = { version = "3.0.0", default-features = false, path = "../../../primitives/version" }
+sp-version-proc-macro = { version = "3.0.0", path = "../../../primitives/version/proc-macro" }
 
 # Used for the node template's RPCs
 frame-system-rpc-runtime-api = { version = "3.0.0", default-features = false, path = "../../../frame/system/rpc/runtime-api/" }

bin/node-template/runtime/src/lib.rs

@@ -94,6 +94,7 @@ pub mod opaque {
 
 // To learn more about runtime versioning and what each of the following value means:
 //   https://substrate.dev/docs/en/knowledgebase/runtime/upgrades#runtime-versioning
+#[sp_version_proc_macro::runtime_version]
 pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("node-template"),
 	impl_name: create_runtime_str!("node-template"),

bin/node/runtime/Cargo.toml

@@ -35,6 +35,7 @@ sp-keyring = { version = "3.0.0", optional = true, path = "../../../primitives/k
 sp-session = { version = "3.0.0", default-features = false, path = "../../../primitives/session" }
 sp-transaction-pool = { version = "3.0.0", default-features = false, path = "../../../primitives/transaction-pool" }
 sp-version = { version = "3.0.0", default-features = false, path = "../../../primitives/version" }
+sp-version-proc-macro = { version = "3.0.0", path = "../../../primitives/version/proc-macro" }
 sp-npos-elections = { version = "3.0.0", default-features = false, path = "../../../primitives/npos-elections" }
 
 # frame dependencies

bin/node/runtime/src/lib.rs

@@ -105,6 +105,7 @@ pub fn wasm_binary_unwrap() -> &'static [u8] {
 }
 
 /// Runtime version.
+#[sp_version_proc_macro::runtime_version]
 pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("node"),
 	impl_name: create_runtime_str!("substrate-node"),

client/executor/common/src/runtime_blob/runtime_blob.rs

@@ -85,9 +85,24 @@ impl RuntimeBlob {
 		})
 	}
 
+	/// Scans the wasm blob for the first section with the name that matches the given. Returns the
+	/// contents of the custom section if found or `None` otherwise.
+	pub fn custom_section_contents(&self, section_name: &str) -> Option<&[u8]> {
+		self.raw_module
+			.custom_sections()
+			.filter(|cs| cs.name() == section_name)
+			.next()
+			.map(|cs| cs.payload())
+	}
+
 	/// Consumes this runtime blob and serializes it.
 	pub fn serialize(self) -> Vec<u8> {
 		serialize(self.raw_module)
 			.expect("serializing into a vec should succeed; qed")
 	}
+
+	/// Destructure this structure into the underlying parity-wasm Module.
+	pub fn into_inner(self) -> RawModule {
+		self.raw_module
+	}
 }

client/executor/src/integration_tests/mod.rs

@@ -17,6 +17,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 mod sandbox;
 
+use std::sync::Arc;
 use codec::{Encode, Decode};
 use hex_literal::hex;
 use sp_core::{
@@ -29,6 +30,10 @@ use sp_state_machine::TestExternalities as CoreTestExternalities;
 use sp_trie::{TrieConfiguration, trie_types::Layout};
 use sp_wasm_interface::HostFunctions as _;
 use sp_runtime::traits::BlakeTwo256;
+use sc_executor_common::{
+	wasm_runtime::WasmModule,
+	runtime_blob::RuntimeBlob,
+};
 use tracing_subscriber::layer::SubscriberExt;
 
 use crate::WasmExecutionMethod;
@@ -553,16 +558,30 @@ fn should_trap_when_heap_exhausted(wasm_method: WasmExecutionMethod) {
 	assert!(err.contains("Allocator ran out of space"));
 }
 
-test_wasm_execution!(returns_mutable_static);
-fn returns_mutable_static(wasm_method: WasmExecutionMethod) {
-	let runtime = crate::wasm_runtime::create_wasm_runtime_with_code(
+fn mk_test_runtime(wasm_method: WasmExecutionMethod, pages: u64) -> Arc<dyn WasmModule> {
+	let raw =
+		sp_maybe_compressed_blob::decompress(
+			&wasm_binary_unwrap()[..],
+			sp_maybe_compressed_blob::CODE_BLOB_BOMB_LIMIT,
+		)
+		.expect("failed to uncompress the test runtime");
+	let blob = RuntimeBlob::new(&raw)
+		.expect("failed to create a runtime blob out of test runtime");
+
+	crate::wasm_runtime::create_wasm_runtime_with_code(
 		wasm_method,
-		1024,
-		&wasm_binary_unwrap()[..],
+		pages,
+		blob,
 		HostFunctions::host_functions(),
 		true,
 		None,
-	).expect("Creates runtime");
+	)
+	.expect("failed to instantiate wasm runtime")
+}
+
+test_wasm_execution!(returns_mutable_static);
+fn returns_mutable_static(wasm_method: WasmExecutionMethod) {
+	let runtime = mk_test_runtime(wasm_method, 1024);
 
 	let instance = runtime.new_instance().unwrap();
 	let res = instance.call_export("returns_mutable_static", &[0]).unwrap();
@@ -589,14 +608,7 @@ fn restoration_of_globals(wasm_method: WasmExecutionMethod) {
 	// to our allocator algorithm there are inefficiencies.
 	const REQUIRED_MEMORY_PAGES: u64 = 32;
 
-	let runtime = crate::wasm_runtime::create_wasm_runtime_with_code(
-		wasm_method,
-		REQUIRED_MEMORY_PAGES,
-		&wasm_binary_unwrap()[..],
-		HostFunctions::host_functions(),
-		true,
-		None,
-	).expect("Creates runtime");
+	let runtime = mk_test_runtime(wasm_method, REQUIRED_MEMORY_PAGES);
 	let instance = runtime.new_instance().unwrap();
 
 	// On the first invocation we allocate approx. 768KB (75%) of stack and then trap.
@@ -610,14 +622,7 @@ fn restoration_of_globals(wasm_method: WasmExecutionMethod) {
 
 test_wasm_execution!(interpreted_only heap_is_reset_between_calls);
 fn heap_is_reset_between_calls(wasm_method: WasmExecutionMethod) {
-	let runtime = crate::wasm_runtime::create_wasm_runtime_with_code(
-		wasm_method,
-		1024,
-		&wasm_binary_unwrap()[..],
-		HostFunctions::host_functions(),
-		true,
-		None,
-	).expect("Creates runtime");
+	let runtime = mk_test_runtime(wasm_method, 1024);
 	let instance = runtime.new_instance().unwrap();
 
 	let heap_base = instance.get_global_const("__heap_base")
@@ -671,9 +676,7 @@ fn parallel_execution(wasm_method: WasmExecutionMethod) {
 
 test_wasm_execution!(wasm_tracing_should_work);
 fn wasm_tracing_should_work(wasm_method: WasmExecutionMethod) {
-
-	use std::sync::{Arc, Mutex};
-
+	use std::sync::Mutex;
 	use sc_tracing::{SpanDatum, TraceEvent};
 
 	struct TestTraceHandler(Arc<Mutex<Vec<SpanDatum>>>);

client/executor/src/native_executor.rs

@@ -35,12 +35,15 @@ use sp_core::{
 	NativeOrEncoded,
 	traits::{
 		CodeExecutor, Externalities, RuntimeCode, MissingHostFunctions,
-		RuntimeSpawnExt, RuntimeSpawn,
+		RuntimeSpawnExt, RuntimeSpawn, ReadRuntimeVersionExt,
 	},
 };
 use log::trace;
 use sp_wasm_interface::{HostFunctions, Function};
-use sc_executor_common::wasm_runtime::{WasmInstance, WasmModule, InvokeMethod};
+use sc_executor_common::{
+	wasm_runtime::{WasmInstance, WasmModule, InvokeMethod},
+	runtime_blob::RuntimeBlob,
+};
 use sp_externalities::ExternalitiesExt as _;
 use sp_tasks::new_async_externalities;
 
@@ -213,16 +216,22 @@ impl sp_core::traits::CallInWasm for WasmExecutor {
 				with_externalities_safe(
 					&mut **ext,
 					move || {
-						RuntimeInstanceSpawn::register_on_externalities(module.clone());
+						preregister_builtin_ext(module.clone());
 						instance.call_export(method, call_data)
 					}
 				)
 			}).map_err(|e| e.to_string())
 		} else {
+			use sp_maybe_compressed_blob::CODE_BLOB_BOMB_LIMIT;
+			let wasm_code = sp_maybe_compressed_blob::decompress(wasm_code, CODE_BLOB_BOMB_LIMIT)
+				.map_err(|e| format!("Decompression error: {:?}", e))?;
+			let runtime_blob = RuntimeBlob::new(&wasm_code)
+				.map_err(|e| format!("Failed to create runtime blob: {:?}", e))?;
+
 			let module = crate::wasm_runtime::create_wasm_runtime_with_code(
 				self.method,
 				self.default_heap_pages,
-				&wasm_code,
+				runtime_blob,
 				self.host_functions.to_vec(),
 				allow_missing_host_functions,
 				self.cache_path.as_deref(),
@@ -239,7 +248,7 @@ impl sp_core::traits::CallInWasm for WasmExecutor {
 			with_externalities_safe(
 				&mut **ext,
 				move || {
-					RuntimeInstanceSpawn::register_on_externalities(module.clone());
+					preregister_builtin_ext(module.clone());
 					instance.call_export(method, call_data)
 				}
 			)
@@ -436,31 +445,51 @@ impl RuntimeInstanceSpawn {
 		ext.extension::<sp_core::traits::TaskExecutorExt>()
 			.map(move |task_ext| Self::new(module, task_ext.clone()))
 	}
+}
 
-	/// Register new `RuntimeSpawnExt` on current externalities.
-	///
-	/// This extensions will spawn instances from provided `module`.
-	pub fn register_on_externalities(module: Arc<dyn WasmModule>) {
-		sp_externalities::with_externalities(
-			move |mut ext| {
-				if let Some(runtime_spawn) =
-					Self::with_externalities_and_module(module.clone(), ext)
-				{
-					if let Err(e) = ext.register_extension(
-						RuntimeSpawnExt(Box::new(runtime_spawn))
-					) {
-						trace!(
-							target: "executor",
-							"Failed to register `RuntimeSpawnExt` instance on externalities: {:?}",
-							e,
-						)
-					}
-				}
-			}
-		);
+struct ReadRuntimeVersion;
+
+impl sp_core::traits::ReadRuntimeVersion for ReadRuntimeVersion {
+	fn read_runtime_version(
+		&self,
+		wasm_code: &[u8],
+	) -> std::result::Result<Option<Vec<u8>>, String> {
+		let runtime_blob = RuntimeBlob::new(wasm_code)
+			.map_err(|e| format!("Failed to create runtime blob: {:?}", e))?;
+
+		crate::wasm_runtime::read_embedded_version(&runtime_blob)
+			.map_err(|e| format!("Failed to read the static section: {:?}", e))
+			.map(|v| v.map(|v| v.encode()))
 	}
 }
 
+/// Pre-registers the built-in extensions to the currently effective externalities.
+///
+/// Meant to be called each time before calling into the runtime.
+fn preregister_builtin_ext(module: Arc<dyn WasmModule>) {
+	sp_externalities::with_externalities(move |mut ext| {
+		if let Some(runtime_spawn) =
+			RuntimeInstanceSpawn::with_externalities_and_module(module, ext)
+		{
+			if let Err(e) = ext.register_extension(RuntimeSpawnExt(Box::new(runtime_spawn))) {
+				trace!(
+					target: "executor",
+					"Failed to register `RuntimeSpawnExt` instance on externalities: {:?}",
+					e,
+				)
+			}
+		}
+
+		if let Err(e) = ext.register_extension(ReadRuntimeVersionExt::new(ReadRuntimeVersion)) {
+			trace!(
+				target: "executor",
+				"Failed to register `ReadRuntimeVersionExt` instance on externalities: {:?}",
+				e,
+			)
+		}
+	});
+}
+
 impl<D: NativeExecutionDispatch + 'static> CodeExecutor for NativeExecutor<D> {
 	type Error = Error;
 
@@ -506,7 +535,7 @@ impl<D: NativeExecutionDispatch + 'static> CodeExecutor for NativeExecutor<D> {
 						with_externalities_safe(
 							&mut **ext,
 							move || {
-								RuntimeInstanceSpawn::register_on_externalities(module.clone());
+								preregister_builtin_ext(module.clone());
 								instance.call_export(method, data).map(NativeOrEncoded::Encoded)
 							}
 						)