Better handling of stable-only build

bin/node-template/node/src/chain_spec.rs

@@ -38,12 +38,15 @@ pub fn authority_keys_from_seed(s: &str) -> (AuraId, GrandpaId) {
 	)
 }
 
-pub fn development_config() -> ChainSpec {
-	ChainSpec::from_genesis(
+pub fn development_config() -> Result<ChainSpec, String> {
+	let wasm_binary = WASM_BINARY.ok_or("Development wasm binary not available".to_string())?;
+
+	Ok(ChainSpec::from_genesis(
 		"Development",
 		"dev",
 		ChainType::Development,
-		|| testnet_genesis(
+		move || testnet_genesis(
+			wasm_binary,
 			vec![
 				authority_keys_from_seed("Alice"),
 			],
@@ -61,15 +64,18 @@ pub fn development_config() -> ChainSpec {
 		None,
 		None,
 		None,
-	)
+	))
 }
 
-pub fn local_testnet_config() -> ChainSpec {
-	ChainSpec::from_genesis(
+pub fn local_testnet_config() -> Result<ChainSpec, String> {
+	let wasm_binary = WASM_BINARY.ok_or("Development wasm binary not available".to_string())?;
+
+	Ok(ChainSpec::from_genesis(
 		"Local Testnet",
 		"local_testnet",
 		ChainType::Local,
-		|| testnet_genesis(
+		move || testnet_genesis(
+			wasm_binary,
 			vec![
 				authority_keys_from_seed("Alice"),
 				authority_keys_from_seed("Bob"),
@@ -96,16 +102,19 @@ pub fn local_testnet_config() -> ChainSpec {
 		None,
 		None,
 		None,
-	)
+	))
 }
 
-fn testnet_genesis(initial_authorities: Vec<(AuraId, GrandpaId)>,
+fn testnet_genesis(
+	wasm_binary: &[u8],
+	initial_authorities: Vec<(AuraId, GrandpaId)>,
 	root_key: AccountId,
 	endowed_accounts: Vec<AccountId>,
-	_enable_println: bool) -> GenesisConfig {
+	_enable_println: bool,
+) -> GenesisConfig {
 	GenesisConfig {
 		system: Some(SystemConfig {
-			code: WASM_BINARY.to_vec(),
+			code: wasm_binary.to_vec(),
 			changes_trie_config: Default::default(),
 		}),
 		balances: Some(BalancesConfig {

bin/node-template/node/src/command.rs

@@ -47,8 +47,8 @@ impl SubstrateCli for Cli {
 
 	fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
 		Ok(match id {
-			"dev" => Box::new(chain_spec::development_config()),
-			"" | "local" => Box::new(chain_spec::local_testnet_config()),
+			"dev" => Box::new(chain_spec::development_config()?),
+			"" | "local" => Box::new(chain_spec::local_testnet_config()?),
 			path => Box::new(chain_spec::ChainSpec::from_json_file(
 				std::path::PathBuf::from(path),
 			)?),

bin/node-template/runtime/build.rs

@@ -3,7 +3,7 @@ use wasm_builder_runner::WasmBuilder;
 fn main() {
 	WasmBuilder::new()
 		.with_current_project()
-		.with_wasm_builder_from_crates("1.0.11")
+		.with_wasm_builder_from_crates("2.0.0")
 		.export_heap_base()
 		.import_memory()
 		.build()

bin/node/cli/src/chain_spec.rs

@@ -25,7 +25,7 @@ use node_runtime::{
 	AuthorityDiscoveryConfig, BabeConfig, BalancesConfig, ContractsConfig, CouncilConfig,
 	DemocracyConfig,GrandpaConfig, ImOnlineConfig, SessionConfig, SessionKeys, StakerStatus,
 	StakingConfig, ElectionsConfig, IndicesConfig, SocietyConfig, SudoConfig, SystemConfig,
-	TechnicalCommitteeConfig, WASM_BINARY,
+	TechnicalCommitteeConfig, wasm_binary_unwrap,
 };
 use node_runtime::Block;
 use node_runtime::constants::currency::*;
@@ -241,7 +241,7 @@ pub fn testnet_genesis(
 
 	GenesisConfig {
 		frame_system: Some(SystemConfig {
-			code: WASM_BINARY.to_vec(),
+			code: wasm_binary_unwrap().to_vec(),
 			changes_trie_config: Default::default(),
 		}),
 		pallet_balances: Some(BalancesConfig {

bin/node/executor/benches/bench.rs

@@ -36,7 +36,10 @@ criterion_group!(benches, bench_execute_block);
 criterion_main!(benches);
 
 /// The wasm runtime code.
-const COMPACT_CODE: &[u8] = node_runtime::WASM_BINARY;
+pub fn compact_code_unwrap() -> &'static [u8] {
+	node_runtime::WASM_BINARY.expect("Development wasm binary is not available. \
+									  Testing is only supported with the flag disabled.")
+}
 
 const GENESIS_HASH: [u8; 32] = [69u8; 32];
 
@@ -60,7 +63,7 @@ fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
 
 fn new_test_ext(genesis_config: &GenesisConfig) -> TestExternalities<BlakeTwo256> {
 	let mut test_ext = TestExternalities::new_with_code(
-		COMPACT_CODE,
+		compact_code_unwrap(),
 		genesis_config.build_storage().unwrap(),
 	);
 	test_ext.ext().place_storage(well_known_keys::HEAP_PAGES.to_vec(), Some(HEAP_PAGES.encode()));
@@ -94,7 +97,7 @@ fn construct_block<E: Externalities>(
 	};
 
 	let runtime_code = RuntimeCode {
-		code_fetcher: &sp_core::traits::WrappedRuntimeCode(COMPACT_CODE.into()),
+		code_fetcher: &sp_core::traits::WrappedRuntimeCode(compact_code_unwrap().into()),
 		hash: vec![1, 2, 3],
 		heap_pages: None,
 	};
@@ -168,15 +171,15 @@ fn bench_execute_block(c: &mut Criterion) {
 	c.bench_function_over_inputs(
 		"execute blocks",
 		|b, strategy| {
-			let genesis_config = node_testing::genesis::config(false, Some(COMPACT_CODE));
+			let genesis_config = node_testing::genesis::config(false, Some(compact_code_unwrap()));
 			let (use_native, wasm_method) = match strategy {
 				ExecutionMethod::Native => (true, WasmExecutionMethod::Interpreted),
 				ExecutionMethod::Wasm(wasm_method) => (false, *wasm_method),
 			};
 
 			let executor = NativeExecutor::new(wasm_method, None, 8);
 			let runtime_code = RuntimeCode {
-				code_fetcher: &sp_core::traits::WrappedRuntimeCode(COMPACT_CODE.into()),
+				code_fetcher: &sp_core::traits::WrappedRuntimeCode(compact_code_unwrap().into()),
 				hash: vec![1, 2, 3],
 				heap_pages: None,
 			};

bin/node/executor/tests/basic.rs

@@ -47,7 +47,10 @@ use self::common::{*, sign};
 /// The idea here is to pass it as the current runtime code to the executor so the executor will
 /// have to execute provided wasm code instead of the native equivalent. This trick is used to
 /// test code paths that differ between native and wasm versions.
-pub const BLOATY_CODE: &[u8] = node_runtime::WASM_BINARY_BLOATY;
+pub fn bloaty_code_unwrap() -> &'static [u8] {
+	node_runtime::WASM_BINARY_BLOATY.expect("Development wasm binary is not available. \
+											 Testing is only supported with the flag disabled.")
+}
 
 /// Default transfer fee. This will use the same logic that is implemented in transaction-payment module.
 ///
@@ -75,7 +78,7 @@ fn set_heap_pages<E: Externalities>(ext: &mut E, heap_pages: u64) {
 
 fn changes_trie_block() -> (Vec<u8>, Hash) {
 	construct_block(
-		&mut new_test_ext(COMPACT_CODE, true),
+		&mut new_test_ext(compact_code_unwrap(), true),
 		1,
 		GENESIS_HASH.into(),
 		vec![
@@ -95,7 +98,7 @@ fn changes_trie_block() -> (Vec<u8>, Hash) {
 /// are not guaranteed to be deterministic) and to ensure that the correct state is propagated
 /// from block1's execution to block2 to derive the correct storage_root.
 fn blocks() -> ((Vec<u8>, Hash), (Vec<u8>, Hash)) {
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 	let block1 = construct_block(
 		&mut t,
 		1,
@@ -140,7 +143,7 @@ fn blocks() -> ((Vec<u8>, Hash), (Vec<u8>, Hash)) {
 
 fn block_with_size(time: u64, nonce: u32, size: usize) -> (Vec<u8>, Hash) {
 	construct_block(
-		&mut new_test_ext(COMPACT_CODE, false),
+		&mut new_test_ext(compact_code_unwrap(), false),
 		1,
 		GENESIS_HASH.into(),
 		vec![
@@ -158,7 +161,7 @@ fn block_with_size(time: u64, nonce: u32, size: usize) -> (Vec<u8>, Hash) {
 
 #[test]
 fn panic_execution_with_foreign_code_gives_error() {
-	let mut t = new_test_ext(BLOATY_CODE, false);
+	let mut t = new_test_ext(bloaty_code_unwrap(), false);
 	t.insert(
 		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
 		(69u128, 0u8, 0u128, 0u128, 0u128).encode()
@@ -187,7 +190,7 @@ fn panic_execution_with_foreign_code_gives_error() {
 
 #[test]
 fn bad_extrinsic_with_native_equivalent_code_gives_error() {
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 	t.insert(
 		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
 		(0u32, 0u8, 69u128, 0u128, 0u128, 0u128).encode()
@@ -216,7 +219,7 @@ fn bad_extrinsic_with_native_equivalent_code_gives_error() {
 
 #[test]
 fn successful_execution_with_native_equivalent_code_gives_ok() {
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 	t.insert(
 		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
 		(0u32, 0u8, 111 * DOLLARS, 0u128, 0u128, 0u128).encode()
@@ -259,7 +262,7 @@ fn successful_execution_with_native_equivalent_code_gives_ok() {
 
 #[test]
 fn successful_execution_with_foreign_code_gives_ok() {
-	let mut t = new_test_ext(BLOATY_CODE, false);
+	let mut t = new_test_ext(bloaty_code_unwrap(), false);
 	t.insert(
 		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
 		(0u32, 0u8, 111 * DOLLARS, 0u128, 0u128, 0u128).encode()
@@ -302,7 +305,7 @@ fn successful_execution_with_foreign_code_gives_ok() {
 
 #[test]
 fn full_native_block_import_works() {
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 
 	let (block1, block2) = blocks();
 
@@ -439,7 +442,7 @@ fn full_native_block_import_works() {
 
 #[test]
 fn full_wasm_block_import_works() {
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 
 	let (block1, block2) = blocks();
 
@@ -589,7 +592,7 @@ fn deploying_wasm_contract_should_work() {
 	);
 
 	let b = construct_block(
-		&mut new_test_ext(COMPACT_CODE, false),
+		&mut new_test_ext(compact_code_unwrap(), false),
 		1,
 		GENESIS_HASH.into(),
 		vec![
@@ -628,7 +631,7 @@ fn deploying_wasm_contract_should_work() {
 		]
 	);
 
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 
 	executor_call::<NeverNativeValue, fn() -> _>(
 		&mut t,
@@ -652,7 +655,7 @@ fn deploying_wasm_contract_should_work() {
 
 #[test]
 fn wasm_big_block_import_fails() {
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 
 	set_heap_pages(&mut t.ext(), 4);
 
@@ -668,7 +671,7 @@ fn wasm_big_block_import_fails() {
 
 #[test]
 fn native_big_block_import_succeeds() {
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 
 	executor_call::<NeverNativeValue, fn() -> _>(
 		&mut t,
@@ -681,7 +684,7 @@ fn native_big_block_import_succeeds() {
 
 #[test]
 fn native_big_block_import_fails_on_fallback() {
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 
 	assert!(
 		executor_call::<NeverNativeValue, fn() -> _>(
@@ -696,7 +699,7 @@ fn native_big_block_import_fails_on_fallback() {
 
 #[test]
 fn panic_execution_gives_error() {
-	let mut t = new_test_ext(BLOATY_CODE, false);
+	let mut t = new_test_ext(bloaty_code_unwrap(), false);
 	t.insert(
 		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
 		(0u32, 0u8, 0 * DOLLARS, 0u128, 0u128, 0u128).encode()
@@ -725,7 +728,7 @@ fn panic_execution_gives_error() {
 
 #[test]
 fn successful_execution_gives_ok() {
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 	t.insert(
 		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
 		(0u32, 0u8, 111 * DOLLARS, 0u128, 0u128, 0u128).encode()
@@ -778,7 +781,7 @@ fn full_native_block_import_works_with_changes_trie() {
 	let block_data = block1.0;
 	let block = Block::decode(&mut &block_data[..]).unwrap();
 
-	let mut t = new_test_ext(COMPACT_CODE, true);
+	let mut t = new_test_ext(compact_code_unwrap(), true);
 	executor_call::<NeverNativeValue, fn() -> _>(
 		&mut t,
 		"Core_execute_block",
@@ -794,7 +797,7 @@ fn full_native_block_import_works_with_changes_trie() {
 fn full_wasm_block_import_works_with_changes_trie() {
 	let block1 = changes_trie_block();
 
-	let mut t = new_test_ext(COMPACT_CODE, true);
+	let mut t = new_test_ext(compact_code_unwrap(), true);
 	executor_call::<NeverNativeValue, fn() -> _>(
 		&mut t,
 		"Core_execute_block",

bin/node/executor/tests/common.rs

@@ -68,7 +68,10 @@ impl AppCrypto<MultiSigner, MultiSignature> for TestAuthorityId {
 /// making the binary slimmer. There is a convention to use compact version of the runtime
 /// as canonical. This is why `native_executor_instance` also uses the compact version of the
 /// runtime.
-pub const COMPACT_CODE: &[u8] = node_runtime::WASM_BINARY;
+pub fn compact_code_unwrap() -> &'static [u8] {
+	node_runtime::WASM_BINARY.expect("Development wasm binary is not available. \
+									  Testing is only supported with the flag disabled.")
+}
 
 pub const GENESIS_HASH: [u8; 32] = [69u8; 32];
 

bin/node/executor/tests/fees.rs

@@ -36,7 +36,7 @@ use self::common::{*, sign};
 
 #[test]
 fn fee_multiplier_increases_and_decreases_on_big_weight() {
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 
 	// initial fee multiplier must be one.
 	let mut prev_multiplier = Multiplier::one();
@@ -45,7 +45,7 @@ fn fee_multiplier_increases_and_decreases_on_big_weight() {
 		assert_eq!(TransactionPayment::next_fee_multiplier(), prev_multiplier);
 	});
 
-	let mut tt = new_test_ext(COMPACT_CODE, false);
+	let mut tt = new_test_ext(compact_code_unwrap(), false);
 
 	// big one in terms of weight.
 	let block1 = construct_block(
@@ -130,7 +130,7 @@ fn transaction_fee_is_correct() {
 	//   - 1 MILLICENTS in substrate node.
 	//   - 1 milli-dot based on current polkadot runtime.
 	// (this baed on assigning 0.1 CENT to the cheapest tx with `weight = 100`)
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 	t.insert(
 		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
 		(0u32, 0u8, 100 * DOLLARS, 0 * DOLLARS, 0 * DOLLARS, 0 * DOLLARS).encode()
@@ -209,9 +209,9 @@ fn block_weight_capacity_report() {
 	use node_primitives::Index;
 
 	// execution ext.
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 	// setup ext.
-	let mut tt = new_test_ext(COMPACT_CODE, false);
+	let mut tt = new_test_ext(compact_code_unwrap(), false);
 
 	let factor = 50;
 	let mut time = 10;
@@ -276,9 +276,9 @@ fn block_length_capacity_report() {
 	use node_primitives::Index;
 
 	// execution ext.
-	let mut t = new_test_ext(COMPACT_CODE, false);
+	let mut t = new_test_ext(compact_code_unwrap(), false);
 	// setup ext.
-	let mut tt = new_test_ext(COMPACT_CODE, false);
+	let mut tt = new_test_ext(compact_code_unwrap(), false);
 
 	let factor = 256 * 1024;
 	let mut time = 10;