substrate-node: NativeElseWasmExecutor is no longer used (#2521)

This PR removes `NativeElseWasmExecutor` usage from substrate node.
Instead [`WasmExecutor<(sp_io::SubstrateHostFunctions,
sp_statement_store::runtime_api::HostFunctions)>`](https://github.com/paritytech/polkadot-sdk/blob/49a41ab3bb3f630c20e5b24cec8d92382404631c/substrate/bin/node/executor/src/lib.rs#L26)
is used.

Related to #2358.

---------

Co-authored-by: Davide Galassi <davxy@datawok.net>

substrate/bin/node/cli/Cargo.toml

@@ -90,6 +90,7 @@ sc-storage-monitor = { path = "../../../client/storage-monitor" }
 sc-offchain = { path = "../../../client/offchain" }
 
 # frame dependencies
+frame-benchmarking = { path = "../../../frame/benchmarking" }
 frame-system = { path = "../../../frame/system" }
 frame-system-rpc-runtime-api = { path = "../../../frame/system/rpc/runtime-api" }
 pallet-assets = { path = "../../../frame/assets" }
@@ -102,7 +103,6 @@ pallet-skip-feeless-payment = { path = "../../../frame/transaction-payment/skip-
 kitchensink-runtime = { path = "../runtime" }
 node-rpc = { path = "../rpc" }
 node-primitives = { path = "../primitives" }
-node-executor = { package = "staging-node-executor", path = "../executor" }
 
 # CLI-specific dependencies
 sc-cli = { path = "../../../client/cli", optional = true}
@@ -136,6 +136,26 @@ substrate-rpc-client = { path = "../../../utils/frame/rpc/client" }
 pallet-timestamp = { path = "../../../frame/timestamp" }
 substrate-cli-test-utils = { path = "../../../test-utils/cli" }
 
+wat = "1.0"
+frame-support = { path = "../../../frame/support" }
+node-testing = { path = "../testing" }
+pallet-balances = { path = "../../../frame/balances" }
+pallet-contracts = { path = "../../../frame/contracts" }
+pallet-glutton = { path = "../../../frame/glutton" }
+pallet-sudo = { path = "../../../frame/sudo" }
+pallet-treasury = { path = "../../../frame/treasury" }
+pallet-transaction-payment = { path = "../../../frame/transaction-payment" }
+sp-application-crypto = { path = "../../../primitives/application-crypto" }
+pallet-root-testing = { path = "../../../frame/root-testing" }
+sp-consensus-babe = { path = "../../../primitives/consensus/babe" }
+sp-externalities = { path = "../../../primitives/externalities" }
+sp-keyring = { path = "../../../primitives/keyring" }
+sp-runtime = { path = "../../../primitives/runtime" }
+serde_json = "1.0.108"
+scale-info = { version = "2.10.0", features = ["derive", "serde"] }
+sp-trie = { path = "../../../primitives/trie" }
+sp-state-machine = { path = "../../../primitives/state-machine" }
+
 [build-dependencies]
 clap = { version = "4.4.6", optional = true }
 clap_complete = { version = "4.0.2", optional = true }
@@ -163,14 +183,21 @@ cli = [
 ]
 runtime-benchmarks = [
 	"frame-benchmarking-cli/runtime-benchmarks",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
 	"frame-system/runtime-benchmarks",
 	"kitchensink-runtime/runtime-benchmarks",
+	"node-inspect?/runtime-benchmarks",
 	"pallet-asset-tx-payment/runtime-benchmarks",
 	"pallet-assets/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
+	"pallet-contracts/runtime-benchmarks",
+	"pallet-glutton/runtime-benchmarks",
 	"pallet-im-online/runtime-benchmarks",
 	"pallet-skip-feeless-payment/runtime-benchmarks",
+	"pallet-sudo/runtime-benchmarks",
 	"pallet-timestamp/runtime-benchmarks",
+	"pallet-treasury/runtime-benchmarks",
 	"sc-client-db/runtime-benchmarks",
 	"sc-service/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
@@ -178,15 +205,22 @@ runtime-benchmarks = [
 # Enable features that allow the runtime to be tried and debugged. Name might be subject to change
 # in the near future.
 try-runtime = [
+	"frame-support/try-runtime",
 	"frame-system/try-runtime",
 	"kitchensink-runtime/try-runtime",
 	"pallet-asset-conversion-tx-payment/try-runtime",
 	"pallet-asset-tx-payment/try-runtime",
 	"pallet-assets/try-runtime",
 	"pallet-balances/try-runtime",
+	"pallet-contracts/try-runtime",
+	"pallet-glutton/try-runtime",
 	"pallet-im-online/try-runtime",
+	"pallet-root-testing/try-runtime",
 	"pallet-skip-feeless-payment/try-runtime",
+	"pallet-sudo/try-runtime",
 	"pallet-timestamp/try-runtime",
+	"pallet-transaction-payment/try-runtime",
+	"pallet-treasury/try-runtime",
 	"sp-runtime/try-runtime",
 	"substrate-cli-test-utils/try-runtime",
 	"try-runtime-cli/try-runtime",
@@ -199,3 +233,7 @@ harness = false
 [[bench]]
 name = "block_production"
 harness = false
+
+[[bench]]
+name = "executor"
+harness = false

substrate/bin/node/cli/benches/executor.rs

@@ -0,0 +1,213 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use codec::{Decode, Encode};
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use frame_support::Hashable;
+use kitchensink_runtime::{
+	constants::currency::*, Block, BuildStorage, CheckedExtrinsic, Header, RuntimeCall,
+	RuntimeGenesisConfig, UncheckedExtrinsic,
+};
+use node_primitives::{BlockNumber, Hash};
+use node_testing::keyring::*;
+use sc_executor::{Externalities, RuntimeVersionOf};
+use sp_core::{
+	storage::well_known_keys,
+	traits::{CallContext, CodeExecutor, RuntimeCode},
+};
+use sp_runtime::traits::BlakeTwo256;
+use sp_state_machine::TestExternalities as CoreTestExternalities;
+use staging_node_cli::service::RuntimeExecutor;
+
+criterion_group!(benches, bench_execute_block);
+criterion_main!(benches);
+
+/// The wasm runtime code.
+pub fn compact_code_unwrap() -> &'static [u8] {
+	kitchensink_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];
+
+const TRANSACTION_VERSION: u32 = kitchensink_runtime::VERSION.transaction_version;
+
+const SPEC_VERSION: u32 = kitchensink_runtime::VERSION.spec_version;
+
+const HEAP_PAGES: u64 = 20;
+
+type TestExternalities<H> = CoreTestExternalities<H>;
+
+fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
+	node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH)
+}
+
+fn new_test_ext(genesis_config: &RuntimeGenesisConfig) -> TestExternalities<BlakeTwo256> {
+	let mut test_ext = TestExternalities::new_with_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()));
+	test_ext
+}
+
+fn construct_block<E: Externalities>(
+	executor: &RuntimeExecutor,
+	ext: &mut E,
+	number: BlockNumber,
+	parent_hash: Hash,
+	extrinsics: Vec<CheckedExtrinsic>,
+) -> (Vec<u8>, Hash) {
+	use sp_trie::{LayoutV0, TrieConfiguration};
+
+	// sign extrinsics.
+	let extrinsics = extrinsics.into_iter().map(sign).collect::<Vec<_>>();
+
+	// calculate the header fields that we can.
+	let extrinsics_root =
+		LayoutV0::<BlakeTwo256>::ordered_trie_root(extrinsics.iter().map(Encode::encode))
+			.to_fixed_bytes()
+			.into();
+
+	let header = Header {
+		parent_hash,
+		number,
+		extrinsics_root,
+		state_root: Default::default(),
+		digest: Default::default(),
+	};
+
+	let runtime_code = RuntimeCode {
+		code_fetcher: &sp_core::traits::WrappedRuntimeCode(compact_code_unwrap().into()),
+		hash: vec![1, 2, 3],
+		heap_pages: None,
+	};
+
+	// execute the block to get the real header.
+	executor
+		.call(
+			ext,
+			&runtime_code,
+			"Core_initialize_block",
+			&header.encode(),
+			true,
+			CallContext::Offchain,
+		)
+		.0
+		.unwrap();
+
+	for i in extrinsics.iter() {
+		executor
+			.call(
+				ext,
+				&runtime_code,
+				"BlockBuilder_apply_extrinsic",
+				&i.encode(),
+				true,
+				CallContext::Offchain,
+			)
+			.0
+			.unwrap();
+	}
+
+	let header = Header::decode(
+		&mut &executor
+			.call(
+				ext,
+				&runtime_code,
+				"BlockBuilder_finalize_block",
+				&[0u8; 0],
+				true,
+				CallContext::Offchain,
+			)
+			.0
+			.unwrap()[..],
+	)
+	.unwrap();
+
+	let hash = header.blake2_256();
+	(Block { header, extrinsics }.encode(), hash.into())
+}
+
+fn test_blocks(
+	genesis_config: &RuntimeGenesisConfig,
+	executor: &RuntimeExecutor,
+) -> Vec<(Vec<u8>, Hash)> {
+	let mut test_ext = new_test_ext(genesis_config);
+	let mut block1_extrinsics = vec![CheckedExtrinsic {
+		signed: None,
+		function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: 0 }),
+	}];
+	block1_extrinsics.extend((0..20).map(|i| CheckedExtrinsic {
+		signed: Some((alice(), signed_extra(i, 0))),
+		function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+			dest: bob().into(),
+			value: 1 * DOLLARS,
+		}),
+	}));
+	let block1 =
+		construct_block(executor, &mut test_ext.ext(), 1, GENESIS_HASH.into(), block1_extrinsics);
+
+	vec![block1]
+}
+
+fn bench_execute_block(c: &mut Criterion) {
+	let mut group = c.benchmark_group("execute blocks");
+
+	group.bench_function("wasm", |b| {
+		let genesis_config = node_testing::genesis::config();
+
+		let executor = RuntimeExecutor::builder().build();
+		let runtime_code = RuntimeCode {
+			code_fetcher: &sp_core::traits::WrappedRuntimeCode(compact_code_unwrap().into()),
+			hash: vec![1, 2, 3],
+			heap_pages: None,
+		};
+
+		// Get the runtime version to initialize the runtimes cache.
+		{
+			let mut test_ext = new_test_ext(&genesis_config);
+			executor.runtime_version(&mut test_ext.ext(), &runtime_code).unwrap();
+		}
+
+		let blocks = test_blocks(&genesis_config, &executor);
+
+		b.iter_batched_ref(
+			|| new_test_ext(&genesis_config),
+			|test_ext| {
+				for block in blocks.iter() {
+					executor
+						.call(
+							&mut test_ext.ext(),
+							&runtime_code,
+							"Core_execute_block",
+							&block.0,
+							false,
+							CallContext::Offchain,
+						)
+						.0
+						.unwrap();
+				}
+			},
+			BatchSize::LargeInput,
+		);
+	});
+}

substrate/bin/node/cli/src/command.rs

@@ -24,7 +24,6 @@ use crate::{
 };
 use frame_benchmarking_cli::*;
 use kitchensink_runtime::{ExistentialDeposit, RuntimeApi};
-use node_executor::ExecutorDispatch;
 use node_primitives::Block;
 use sc_cli::{Result, SubstrateCli};
 use sc_service::PartialComponents;
@@ -89,7 +88,7 @@ pub fn run() -> Result<()> {
 		Some(Subcommand::Inspect(cmd)) => {
 			let runner = cli.create_runner(cmd)?;
 
-			runner.sync_run(|config| cmd.run::<Block, RuntimeApi, ExecutorDispatch>(config))
+			runner.sync_run(|config| cmd.run::<Block, RuntimeApi>(config))
 		},
 		Some(Subcommand::Benchmark(cmd)) => {
 			let runner = cli.create_runner(cmd)?;

substrate/bin/node/cli/src/service.rs

@@ -26,11 +26,9 @@ use frame_benchmarking_cli::SUBSTRATE_REFERENCE_HARDWARE;
 use frame_system_rpc_runtime_api::AccountNonceApi;
 use futures::prelude::*;
 use kitchensink_runtime::RuntimeApi;
-use node_executor::ExecutorDispatch;
 use node_primitives::Block;
 use sc_client_api::{Backend, BlockBackend};
 use sc_consensus_babe::{self, SlotProportion};
-use sc_executor::NativeElseWasmExecutor;
 use sc_network::{event::Event, NetworkEventStream, NetworkService};
 use sc_network_sync::{warp::WarpSyncParams, SyncingService};
 use sc_service::{config::Configuration, error::Error as ServiceError, RpcHandlers, TaskManager};
@@ -42,9 +40,25 @@ use sp_core::crypto::Pair;
 use sp_runtime::{generic, traits::Block as BlockT, SaturatedConversion};
 use std::sync::Arc;
 
+/// Host functions required for kitchensink runtime and Substrate node.
+#[cfg(not(feature = "runtime-benchmarks"))]
+pub type HostFunctions =
+	(sp_io::SubstrateHostFunctions, sp_statement_store::runtime_api::HostFunctions);
+
+/// Host functions required for kitchensink runtime and Substrate node.
+#[cfg(feature = "runtime-benchmarks")]
+pub type HostFunctions = (
+	sp_io::SubstrateHostFunctions,
+	sp_statement_store::runtime_api::HostFunctions,
+	frame_benchmarking::benchmarking::HostFunctions,
+);
+
+/// A specialized `WasmExecutor` intended to use accross substrate node. It provides all required
+/// HostFunctions.
+pub type RuntimeExecutor = sc_executor::WasmExecutor<HostFunctions>;
+
 /// The full client type definition.
-pub type FullClient =
-	sc_service::TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<ExecutorDispatch>>;
+pub type FullClient = sc_service::TFullClient<Block, RuntimeApi, RuntimeExecutor>;
 type FullBackend = sc_service::TFullBackend<Block>;
 type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
 type FullGrandpaBlockImport =
@@ -174,7 +188,7 @@ pub fn new_partial(
 		})
 		.transpose()?;
 
-	let executor = sc_service::new_native_or_wasm_executor(&config);
+	let executor = sc_service::new_wasm_executor(&config);
 
 	let (client, backend, keystore_container, task_manager) =
 		sc_service::new_full_parts::<Block, RuntimeApi, _>(

substrate/bin/node/cli/tests/basic.rs

@@ -0,0 +1,875 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use codec::{Decode, Encode, Joiner};
+use frame_support::{
+	dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo},
+	traits::Currency,
+	weights::Weight,
+};
+use frame_system::{self, AccountInfo, EventRecord, Phase};
+use sp_core::{storage::well_known_keys, traits::Externalities};
+use sp_runtime::{
+	traits::Hash as HashT, transaction_validity::InvalidTransaction, ApplyExtrinsicResult,
+};
+
+use kitchensink_runtime::{
+	constants::{currency::*, time::SLOT_DURATION},
+	Balances, CheckedExtrinsic, Header, Runtime, RuntimeCall, RuntimeEvent, System,
+	TransactionPayment, Treasury, UncheckedExtrinsic,
+};
+use node_primitives::{Balance, Hash};
+use node_testing::keyring::*;
+use wat;
+
+pub mod common;
+use self::common::{sign, *};
+
+/// The wasm runtime binary which hasn't undergone the compacting process.
+///
+/// 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 fn bloaty_code_unwrap() -> &'static [u8] {
+	kitchensink_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.
+///
+/// Note that reads the multiplier from storage directly, hence to get the fee of `extrinsic`
+/// at block `n`, it must be called prior to executing block `n` to do the calculation with the
+/// correct multiplier.
+fn transfer_fee<E: Encode>(extrinsic: &E) -> Balance {
+	TransactionPayment::compute_fee(
+		extrinsic.encode().len() as u32,
+		&default_transfer_call().get_dispatch_info(),
+		0,
+	)
+}
+
+fn xt() -> UncheckedExtrinsic {
+	sign(CheckedExtrinsic {
+		signed: Some((alice(), signed_extra(0, 0))),
+		function: RuntimeCall::Balances(default_transfer_call()),
+	})
+}
+
+fn set_heap_pages<E: Externalities>(ext: &mut E, heap_pages: u64) {
+	ext.place_storage(well_known_keys::HEAP_PAGES.to_vec(), Some(heap_pages.encode()));
+}
+
+fn changes_trie_block() -> (Vec<u8>, Hash) {
+	let time = 42 * 1000;
+	construct_block(
+		&mut new_test_ext(compact_code_unwrap()),
+		1,
+		GENESIS_HASH.into(),
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time }),
+			},
+			CheckedExtrinsic {
+				signed: Some((alice(), signed_extra(0, 0))),
+				function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+					dest: bob().into(),
+					value: 69 * DOLLARS,
+				}),
+			},
+		],
+		(time / SLOT_DURATION).into(),
+	)
+}
+
+/// block 1 and 2 must be created together to ensure transactions are only signed once (since they
+/// 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_unwrap());
+	let time1 = 42 * 1000;
+	let block1 = construct_block(
+		&mut t,
+		1,
+		GENESIS_HASH.into(),
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time1 }),
+			},
+			CheckedExtrinsic {
+				signed: Some((alice(), signed_extra(0, 0))),
+				function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+					dest: bob().into(),
+					value: 69 * DOLLARS,
+				}),
+			},
+		],
+		(time1 / SLOT_DURATION).into(),
+	);
+	let time2 = 52 * 1000;
+	let block2 = construct_block(
+		&mut t,
+		2,
+		block1.1,
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time2 }),
+			},
+			CheckedExtrinsic {
+				signed: Some((bob(), signed_extra(0, 0))),
+				function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+					dest: alice().into(),
+					value: 5 * DOLLARS,
+				}),
+			},
+			CheckedExtrinsic {
+				signed: Some((alice(), signed_extra(1, 0))),
+				function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+					dest: bob().into(),
+					value: 15 * DOLLARS,
+				}),
+			},
+		],
+		(time2 / SLOT_DURATION).into(),
+	);
+
+	// session change => consensus authorities change => authorities change digest item appears
+	let digest = Header::decode(&mut &block2.0[..]).unwrap().digest;
+	assert_eq!(digest.logs().len(), 1 /* Just babe slot */);
+
+	(block1, block2)
+}
+
+fn block_with_size(time: u64, nonce: u32, size: usize) -> (Vec<u8>, Hash) {
+	construct_block(
+		&mut new_test_ext(compact_code_unwrap()),
+		1,
+		GENESIS_HASH.into(),
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time * 1000 }),
+			},
+			CheckedExtrinsic {
+				signed: Some((alice(), signed_extra(nonce, 0))),
+				function: RuntimeCall::System(frame_system::Call::remark { remark: vec![0; size] }),
+			},
+		],
+		(time * 1000 / SLOT_DURATION).into(),
+	)
+}
+
+#[test]
+fn panic_execution_with_foreign_code_gives_error() {
+	let mut t = new_test_ext(bloaty_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			providers: 1,
+			data: (69u128, 0u128, 0u128, 1u128 << 127),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(), 69_u128.encode());
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r =
+		executor_call(&mut t, "Core_initialize_block", &vec![].and(&from_block_number(1u32)), true)
+			.0;
+	assert!(r.is_ok());
+	let v = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), true)
+		.0
+		.unwrap();
+	let r = ApplyExtrinsicResult::decode(&mut &v[..]).unwrap();
+	assert_eq!(r, Err(InvalidTransaction::Payment.into()));
+}
+
+#[test]
+fn bad_extrinsic_with_native_equivalent_code_gives_error() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			providers: 1,
+			data: (69u128, 0u128, 0u128, 1u128 << 127),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(), 69u128.encode());
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r =
+		executor_call(&mut t, "Core_initialize_block", &vec![].and(&from_block_number(1u32)), true)
+			.0;
+	assert!(r.is_ok());
+	let v = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), true)
+		.0
+		.unwrap();
+	let r = ApplyExtrinsicResult::decode(&mut &v[..]).unwrap();
+	assert_eq!(r, Err(InvalidTransaction::Payment.into()));
+}
+
+#[test]
+fn successful_execution_with_native_equivalent_code_gives_ok() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			providers: 1,
+			data: (111 * DOLLARS, 0u128, 0u128, 1u128 << 127),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(bob()),
+		AccountInfo::<
+			<Runtime as frame_system::Config>::Nonce,
+			<Runtime as frame_system::Config>::AccountData,
+		>::default()
+		.encode(),
+	);
+	t.insert(
+		<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(),
+		(111 * DOLLARS).encode(),
+	);
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r =
+		executor_call(&mut t, "Core_initialize_block", &vec![].and(&from_block_number(1u32)), true)
+			.0;
+	assert!(r.is_ok());
+
+	let fees = t.execute_with(|| transfer_fee(&xt()));
+
+	let r = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), true).0;
+	assert!(r.is_ok());
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - fees);
+		assert_eq!(Balances::total_balance(&bob()), 69 * DOLLARS);
+	});
+}
+
+#[test]
+fn successful_execution_with_foreign_code_gives_ok() {
+	let mut t = new_test_ext(bloaty_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			providers: 1,
+			data: (111 * DOLLARS, 0u128, 0u128, 1u128 << 127),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(bob()),
+		AccountInfo::<
+			<Runtime as frame_system::Config>::Nonce,
+			<Runtime as frame_system::Config>::AccountData,
+		>::default()
+		.encode(),
+	);
+	t.insert(
+		<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(),
+		(111 * DOLLARS).encode(),
+	);
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r =
+		executor_call(&mut t, "Core_initialize_block", &vec![].and(&from_block_number(1u32)), true)
+			.0;
+	assert!(r.is_ok());
+
+	let fees = t.execute_with(|| transfer_fee(&xt()));
+
+	let r = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), true).0;
+	assert!(r.is_ok());
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - fees);
+		assert_eq!(Balances::total_balance(&bob()), 69 * DOLLARS);
+	});
+}
+
+#[test]
+fn full_native_block_import_works() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	let (block1, block2) = blocks();
+
+	let mut alice_last_known_balance: Balance = Default::default();
+	let mut fees = t.execute_with(|| transfer_fee(&xt()));
+
+	let transfer_weight = default_transfer_call().get_dispatch_info().weight.saturating_add(
+		<Runtime as frame_system::Config>::BlockWeights::get()
+			.get(DispatchClass::Normal)
+			.base_extrinsic,
+	);
+	let timestamp_weight = pallet_timestamp::Call::set::<Runtime> { now: Default::default() }
+		.get_dispatch_info()
+		.weight
+		.saturating_add(
+			<Runtime as frame_system::Config>::BlockWeights::get()
+				.get(DispatchClass::Mandatory)
+				.base_extrinsic,
+		);
+
+	executor_call(&mut t, "Core_execute_block", &block1.0, true).0.unwrap();
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - fees);
+		assert_eq!(Balances::total_balance(&bob()), 169 * DOLLARS);
+		alice_last_known_balance = Balances::total_balance(&alice());
+		let events = vec![
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(0),
+				event: RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: timestamp_weight,
+						class: DispatchClass::Mandatory,
+						..Default::default()
+					},
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Withdraw {
+					who: alice().into(),
+					amount: fees,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+					from: alice().into(),
+					to: bob().into(),
+					amount: 69 * DOLLARS,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Deposit {
+					who: pallet_treasury::Pallet::<Runtime>::account_id(),
+					amount: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Treasury(pallet_treasury::Event::Deposit {
+					value: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::TransactionPayment(
+					pallet_transaction_payment::Event::TransactionFeePaid {
+						who: alice().into(),
+						actual_fee: fees,
+						tip: 0,
+					},
+				),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo { weight: transfer_weight, ..Default::default() },
+				}),
+				topics: vec![],
+			},
+		];
+		assert_eq!(System::events(), events);
+	});
+
+	fees = t.execute_with(|| transfer_fee(&xt()));
+	let pot = t.execute_with(|| Treasury::pot());
+
+	executor_call(&mut t, "Core_execute_block", &block2.0, true).0.unwrap();
+
+	t.execute_with(|| {
+		assert_eq!(
+			Balances::total_balance(&alice()),
+			alice_last_known_balance - 10 * DOLLARS - fees,
+		);
+		assert_eq!(Balances::total_balance(&bob()), 179 * DOLLARS - fees);
+		let events = vec![
+			EventRecord {
+				phase: Phase::Initialization,
+				event: RuntimeEvent::Treasury(pallet_treasury::Event::UpdatedInactive {
+					reactivated: 0,
+					deactivated: pot,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(0),
+				event: RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: timestamp_weight,
+						class: DispatchClass::Mandatory,
+						..Default::default()
+					},
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Withdraw {
+					who: bob().into(),
+					amount: fees,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+					from: bob().into(),
+					to: alice().into(),
+					amount: 5 * DOLLARS,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Deposit {
+					who: pallet_treasury::Pallet::<Runtime>::account_id(),
+					amount: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Treasury(pallet_treasury::Event::Deposit {
+					value: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::TransactionPayment(
+					pallet_transaction_payment::Event::TransactionFeePaid {
+						who: bob().into(),
+						actual_fee: fees,
+						tip: 0,
+					},
+				),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo { weight: transfer_weight, ..Default::default() },
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Withdraw {
+					who: alice().into(),
+					amount: fees,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+					from: alice().into(),
+					to: bob().into(),
+					amount: 15 * DOLLARS,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Deposit {
+					who: pallet_treasury::Pallet::<Runtime>::account_id(),
+					amount: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::Treasury(pallet_treasury::Event::Deposit {
+					value: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::TransactionPayment(
+					pallet_transaction_payment::Event::TransactionFeePaid {
+						who: alice().into(),
+						actual_fee: fees,
+						tip: 0,
+					},
+				),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo { weight: transfer_weight, ..Default::default() },
+				}),
+				topics: vec![],
+			},
+		];
+		assert_eq!(System::events(), events);
+	});
+}
+
+#[test]
+fn full_wasm_block_import_works() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	let (block1, block2) = blocks();
+
+	let mut alice_last_known_balance: Balance = Default::default();
+	let mut fees = t.execute_with(|| transfer_fee(&xt()));
+
+	executor_call(&mut t, "Core_execute_block", &block1.0, false).0.unwrap();
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - fees);
+		assert_eq!(Balances::total_balance(&bob()), 169 * DOLLARS);
+		alice_last_known_balance = Balances::total_balance(&alice());
+	});
+
+	fees = t.execute_with(|| transfer_fee(&xt()));
+
+	executor_call(&mut t, "Core_execute_block", &block2.0, false).0.unwrap();
+
+	t.execute_with(|| {
+		assert_eq!(
+			Balances::total_balance(&alice()),
+			alice_last_known_balance - 10 * DOLLARS - fees,
+		);
+		assert_eq!(Balances::total_balance(&bob()), 179 * DOLLARS - 1 * fees);
+	});
+}
+
+const CODE_TRANSFER: &str = r#"
+(module
+;; seal_call(
+;;    callee_ptr: u32,
+;;    callee_len: u32,
+;;    gas: u64,
+;;    value_ptr: u32,
+;;    value_len: u32,
+;;    input_data_ptr: u32,
+;;    input_data_len: u32,
+;;    output_ptr: u32,
+;;    output_len_ptr: u32
+;; ) -> u32
+(import "seal0" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32 i32) (result i32)))
+(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+(import "env" "memory" (memory 1 1))
+(func (export "deploy")
+)
+(func (export "call")
+	(block $fail
+		;; Load input data to contract memory
+		(call $seal_input
+			(i32.const 0)
+			(i32.const 52)
+		)
+
+		;; fail if the input size is not != 4
+		(br_if $fail
+			(i32.ne
+				(i32.const 4)
+				(i32.load (i32.const 52))
+			)
+		)
+
+		(br_if $fail
+			(i32.ne
+				(i32.load8_u (i32.const 0))
+				(i32.const 0)
+			)
+		)
+		(br_if $fail
+			(i32.ne
+				(i32.load8_u (i32.const 1))
+				(i32.const 1)
+			)
+		)
+		(br_if $fail
+			(i32.ne
+				(i32.load8_u (i32.const 2))
+				(i32.const 2)
+			)
+		)
+		(br_if $fail
+			(i32.ne
+				(i32.load8_u (i32.const 3))
+				(i32.const 3)
+			)
+		)
+
+		(drop
+			(call $seal_call
+				(i32.const 4)  ;; Pointer to "callee" address.
+				(i32.const 32)  ;; Length of "callee" address.
+				(i64.const 0)  ;; How much gas to devote for the execution. 0 = all.
+				(i32.const 36)  ;; Pointer to the buffer with value to transfer
+				(i32.const 16)   ;; Length of the buffer with value to transfer.
+				(i32.const 0)   ;; Pointer to input data buffer address
+				(i32.const 0)   ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+			)
+		)
+
+		(return)
+	)
+	unreachable
+)
+;; Destination AccountId to transfer the funds.
+;; Represented by H256 (32 bytes long) in little endian.
+(data (i32.const 4)
+	"\09\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+	"\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+	"\00\00\00\00"
+)
+;; Amount of value to transfer.
+;; Represented by u128 (16 bytes long) in little endian.
+(data (i32.const 36)
+	"\06\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+	"\00\00"
+)
+;; Length of the input buffer
+(data (i32.const 52) "\04")
+)
+"#;
+
+#[test]
+fn deploying_wasm_contract_should_work() {
+	let transfer_code = wat::parse_str(CODE_TRANSFER).unwrap();
+	let transfer_ch = <Runtime as frame_system::Config>::Hashing::hash(&transfer_code);
+
+	let addr =
+		pallet_contracts::Pallet::<Runtime>::contract_address(&charlie(), &transfer_ch, &[], &[]);
+
+	let time = 42 * 1000;
+	let b = construct_block(
+		&mut new_test_ext(compact_code_unwrap()),
+		1,
+		GENESIS_HASH.into(),
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time }),
+			},
+			CheckedExtrinsic {
+				signed: Some((charlie(), signed_extra(0, 0))),
+				function: RuntimeCall::Contracts(pallet_contracts::Call::instantiate_with_code::<
+					Runtime,
+				> {
+					value: 0,
+					gas_limit: Weight::from_parts(500_000_000, 0),
+					storage_deposit_limit: None,
+					code: transfer_code,
+					data: Vec::new(),
+					salt: Vec::new(),
+				}),
+			},
+			CheckedExtrinsic {
+				signed: Some((charlie(), signed_extra(1, 0))),
+				function: RuntimeCall::Contracts(pallet_contracts::Call::call::<Runtime> {
+					dest: sp_runtime::MultiAddress::Id(addr.clone()),
+					value: 10,
+					gas_limit: Weight::from_parts(500_000_000, 0),
+					storage_deposit_limit: None,
+					data: vec![0x00, 0x01, 0x02, 0x03],
+				}),
+			},
+		],
+		(time / SLOT_DURATION).into(),
+	);
+
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	executor_call(&mut t, "Core_execute_block", &b.0, false).0.unwrap();
+
+	t.execute_with(|| {
+		// Verify that the contract does exist by querying some of its storage items
+		// It does not matter that the storage item itself does not exist.
+		assert!(&pallet_contracts::Pallet::<Runtime>::get_storage(addr, vec![]).is_ok());
+	});
+}
+
+#[test]
+fn wasm_big_block_import_fails() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	set_heap_pages(&mut t.ext(), 4);
+
+	let result =
+		executor_call(&mut t, "Core_execute_block", &block_with_size(42, 0, 120_000).0, false).0;
+	assert!(result.is_err()); // Err(Wasmi(Trap(Trap { kind: Host(AllocatorOutOfSpace) })))
+}
+
+#[test]
+fn native_big_block_import_succeeds() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	executor_call(&mut t, "Core_execute_block", &block_with_size(42, 0, 120_000).0, true)
+		.0
+		.unwrap();
+}
+
+#[test]
+fn native_big_block_import_fails_on_fallback() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	// We set the heap pages to 8 because we know that should give an OOM in WASM with the given
+	// block.
+	set_heap_pages(&mut t.ext(), 8);
+
+	assert!(
+		executor_call(&mut t, "Core_execute_block", &block_with_size(42, 0, 120_000).0, false,)
+			.0
+			.is_err()
+	);
+}
+
+#[test]
+fn panic_execution_gives_error() {
+	let mut t = new_test_ext(bloaty_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			data: (0 * DOLLARS, 0u128, 0u128, 0u128),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(), 0_u128.encode());
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r = executor_call(
+		&mut t,
+		"Core_initialize_block",
+		&vec![].and(&from_block_number(1u32)),
+		false,
+	)
+	.0;
+	assert!(r.is_ok());
+	let r = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), false)
+		.0
+		.unwrap();
+	let r = ApplyExtrinsicResult::decode(&mut &r[..]).unwrap();
+	assert_eq!(r, Err(InvalidTransaction::Payment.into()));
+}
+
+#[test]
+fn successful_execution_gives_ok() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			providers: 1,
+			data: (111 * DOLLARS, 0u128, 0u128, 1u128 << 127),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(bob()),
+		AccountInfo::<
+			<Runtime as frame_system::Config>::Nonce,
+			<Runtime as frame_system::Config>::AccountData,
+		>::default()
+		.encode(),
+	);
+	t.insert(
+		<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(),
+		(111 * DOLLARS).encode(),
+	);
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r = executor_call(
+		&mut t,
+		"Core_initialize_block",
+		&vec![].and(&from_block_number(1u32)),
+		false,
+	)
+	.0;
+	assert!(r.is_ok());
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 111 * DOLLARS);
+	});
+
+	let fees = t.execute_with(|| transfer_fee(&xt()));
+
+	let r = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), false)
+		.0
+		.unwrap();
+	ApplyExtrinsicResult::decode(&mut &r[..])
+		.unwrap()
+		.expect("Extrinsic could not be applied")
+		.expect("Extrinsic failed");
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - fees);
+		assert_eq!(Balances::total_balance(&bob()), 69 * DOLLARS);
+	});
+}
+
+#[test]
+fn should_import_block_with_test_client() {
+	use node_testing::client::{
+		sp_consensus::BlockOrigin, ClientBlockImportExt, TestClientBuilder, TestClientBuilderExt,
+	};
+
+	let mut client = TestClientBuilder::new().build();
+	let block1 = changes_trie_block();
+	let block_data = block1.0;
+	let block = node_primitives::Block::decode(&mut &block_data[..]).unwrap();
+
+	futures::executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+}
+
+#[test]
+fn default_config_as_json_works() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	let r = executor_call(&mut t, "GenesisBuilder_create_default_config", &vec![], false)
+		.0
+		.unwrap();
+	let r = Vec::<u8>::decode(&mut &r[..]).unwrap();
+	let json = String::from_utf8(r.into()).expect("returned value is json. qed.");
+	let expected = include_str!("res/default_genesis_config.json").to_string();
+
+	assert_eq!(
+		serde_json::from_str::<serde_json::Value>(&expected).unwrap(),
+		serde_json::from_str::<serde_json::Value>(&json).unwrap()
+	);
+}

substrate/bin/node/cli/tests/common.rs

@@ -0,0 +1,195 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use codec::{Decode, Encode};
+use frame_support::Hashable;
+use frame_system::offchain::AppCrypto;
+use sc_executor::error::Result;
+use sp_consensus_babe::{
+	digests::{PreDigest, SecondaryPlainPreDigest},
+	Slot, BABE_ENGINE_ID,
+};
+use sp_core::{
+	crypto::KeyTypeId,
+	sr25519::Signature,
+	traits::{CallContext, CodeExecutor, RuntimeCode},
+};
+use sp_runtime::{
+	traits::{BlakeTwo256, Header as HeaderT},
+	ApplyExtrinsicResult, Digest, DigestItem, MultiSignature, MultiSigner,
+};
+use sp_state_machine::TestExternalities as CoreTestExternalities;
+
+use kitchensink_runtime::{
+	constants::currency::*, Block, BuildStorage, CheckedExtrinsic, Header, Runtime,
+	UncheckedExtrinsic,
+};
+use node_primitives::{BlockNumber, Hash};
+use node_testing::keyring::*;
+use sp_externalities::Externalities;
+use staging_node_cli::service::RuntimeExecutor;
+
+pub const TEST_KEY_TYPE_ID: KeyTypeId = KeyTypeId(*b"test");
+
+pub mod sr25519 {
+	mod app_sr25519 {
+		use super::super::TEST_KEY_TYPE_ID;
+		use sp_application_crypto::{app_crypto, sr25519};
+		app_crypto!(sr25519, TEST_KEY_TYPE_ID);
+	}
+
+	pub type AuthorityId = app_sr25519::Public;
+}
+
+pub struct TestAuthorityId;
+impl AppCrypto<MultiSigner, MultiSignature> for TestAuthorityId {
+	type RuntimeAppPublic = sr25519::AuthorityId;
+	type GenericSignature = Signature;
+	type GenericPublic = sp_core::sr25519::Public;
+}
+
+/// The wasm runtime code.
+///
+/// `compact` since it is after post-processing with wasm-gc which performs tree-shaking thus
+/// making the binary slimmer. There is a convention to use compact version of the runtime
+/// as canonical.
+pub fn compact_code_unwrap() -> &'static [u8] {
+	kitchensink_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];
+
+pub const SPEC_VERSION: u32 = kitchensink_runtime::VERSION.spec_version;
+
+pub const TRANSACTION_VERSION: u32 = kitchensink_runtime::VERSION.transaction_version;
+
+pub type TestExternalities<H> = CoreTestExternalities<H>;
+
+pub fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
+	node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH)
+}
+
+pub fn default_transfer_call() -> pallet_balances::Call<Runtime> {
+	pallet_balances::Call::<Runtime>::transfer_allow_death {
+		dest: bob().into(),
+		value: 69 * DOLLARS,
+	}
+}
+
+pub fn from_block_number(n: u32) -> Header {
+	Header::new(n, Default::default(), Default::default(), [69; 32].into(), Default::default())
+}
+
+pub fn executor() -> RuntimeExecutor {
+	RuntimeExecutor::builder().build()
+}
+
+pub fn executor_call(
+	t: &mut TestExternalities<BlakeTwo256>,
+	method: &str,
+	data: &[u8],
+	use_native: bool,
+) -> (Result<Vec<u8>>, bool) {
+	let mut t = t.ext();
+
+	let code = t.storage(sp_core::storage::well_known_keys::CODE).unwrap();
+	let heap_pages = t.storage(sp_core::storage::well_known_keys::HEAP_PAGES);
+	let runtime_code = RuntimeCode {
+		code_fetcher: &sp_core::traits::WrappedRuntimeCode(code.as_slice().into()),
+		hash: sp_core::blake2_256(&code).to_vec(),
+		heap_pages: heap_pages.and_then(|hp| Decode::decode(&mut &hp[..]).ok()),
+	};
+	sp_tracing::try_init_simple();
+	executor().call(&mut t, &runtime_code, method, data, use_native, CallContext::Onchain)
+}
+
+pub fn new_test_ext(code: &[u8]) -> TestExternalities<BlakeTwo256> {
+	let ext = TestExternalities::new_with_code(
+		code,
+		node_testing::genesis::config().build_storage().unwrap(),
+	);
+	ext
+}
+
+/// Construct a fake block.
+///
+/// `extrinsics` must be a list of valid extrinsics, i.e. none of the extrinsics for example
+/// can report `ExhaustResources`. Otherwise, this function panics.
+pub fn construct_block(
+	env: &mut TestExternalities<BlakeTwo256>,
+	number: BlockNumber,
+	parent_hash: Hash,
+	extrinsics: Vec<CheckedExtrinsic>,
+	babe_slot: Slot,
+) -> (Vec<u8>, Hash) {
+	use sp_trie::{LayoutV1 as Layout, TrieConfiguration};
+
+	// sign extrinsics.
+	let extrinsics = extrinsics.into_iter().map(sign).collect::<Vec<_>>();
+
+	// calculate the header fields that we can.
+	let extrinsics_root =
+		Layout::<BlakeTwo256>::ordered_trie_root(extrinsics.iter().map(Encode::encode))
+			.to_fixed_bytes()
+			.into();
+
+	let header = Header {
+		parent_hash,
+		number,
+		extrinsics_root,
+		state_root: Default::default(),
+		digest: Digest {
+			logs: vec![DigestItem::PreRuntime(
+				BABE_ENGINE_ID,
+				PreDigest::SecondaryPlain(SecondaryPlainPreDigest {
+					slot: babe_slot,
+					authority_index: 42,
+				})
+				.encode(),
+			)],
+		},
+	};
+
+	// execute the block to get the real header.
+	executor_call(env, "Core_initialize_block", &header.encode(), true).0.unwrap();
+
+	for extrinsic in extrinsics.iter() {
+		// Try to apply the `extrinsic`. It should be valid, in the sense that it passes
+		// all pre-inclusion checks.
+		let r = executor_call(env, "BlockBuilder_apply_extrinsic", &extrinsic.encode(), true)
+			.0
+			.expect("application of an extrinsic failed");
+
+		match ApplyExtrinsicResult::decode(&mut &r[..])
+			.expect("apply result deserialization failed")
+		{
+			Ok(_) => {},
+			Err(e) => panic!("Applying extrinsic failed: {:?}", e),
+		}
+	}
+
+	let header = Header::decode(
+		&mut &executor_call(env, "BlockBuilder_finalize_block", &[0u8; 0], true).0.unwrap()[..],
+	)
+	.unwrap();
+
+	let hash = header.blake2_256();
+	(Block { header, extrinsics }.encode(), hash.into())
+}

substrate/bin/node/cli/tests/fees.rs

@@ -0,0 +1,323 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use codec::{Encode, Joiner};
+use frame_support::{
+	dispatch::GetDispatchInfo,
+	traits::Currency,
+	weights::{constants::ExtrinsicBaseWeight, IdentityFee, WeightToFee},
+};
+use kitchensink_runtime::{
+	constants::{currency::*, time::SLOT_DURATION},
+	Balances, CheckedExtrinsic, Multiplier, Runtime, RuntimeCall, TransactionByteFee,
+	TransactionPayment,
+};
+use node_primitives::Balance;
+use node_testing::keyring::*;
+use sp_runtime::{traits::One, Perbill};
+
+pub mod common;
+use self::common::{sign, *};
+
+#[test]
+fn fee_multiplier_increases_and_decreases_on_big_weight() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	// initial fee multiplier must be one.
+	let mut prev_multiplier = Multiplier::one();
+
+	t.execute_with(|| {
+		assert_eq!(TransactionPayment::next_fee_multiplier(), prev_multiplier);
+	});
+
+	let mut tt = new_test_ext(compact_code_unwrap());
+
+	let time1 = 42 * 1000;
+	// big one in terms of weight.
+	let block1 = construct_block(
+		&mut tt,
+		1,
+		GENESIS_HASH.into(),
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time1 }),
+			},
+			CheckedExtrinsic {
+				signed: Some((charlie(), signed_extra(0, 0))),
+				function: RuntimeCall::Sudo(pallet_sudo::Call::sudo {
+					call: Box::new(RuntimeCall::RootTesting(
+						pallet_root_testing::Call::fill_block { ratio: Perbill::from_percent(60) },
+					)),
+				}),
+			},
+		],
+		(time1 / SLOT_DURATION).into(),
+	);
+
+	let time2 = 52 * 1000;
+	// small one in terms of weight.
+	let block2 = construct_block(
+		&mut tt,
+		2,
+		block1.1,
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time2 }),
+			},
+			CheckedExtrinsic {
+				signed: Some((charlie(), signed_extra(1, 0))),
+				function: RuntimeCall::System(frame_system::Call::remark { remark: vec![0; 1] }),
+			},
+		],
+		(time2 / SLOT_DURATION).into(),
+	);
+
+	println!(
+		"++ Block 1 size: {} / Block 2 size {}",
+		block1.0.encode().len(),
+		block2.0.encode().len(),
+	);
+
+	// execute a big block.
+	executor_call(&mut t, "Core_execute_block", &block1.0, true).0.unwrap();
+
+	// weight multiplier is increased for next block.
+	t.execute_with(|| {
+		let fm = TransactionPayment::next_fee_multiplier();
+		println!("After a big block: {:?} -> {:?}", prev_multiplier, fm);
+		assert!(fm > prev_multiplier);
+		prev_multiplier = fm;
+	});
+
+	// execute a big block.
+	executor_call(&mut t, "Core_execute_block", &block2.0, true).0.unwrap();
+
+	// weight multiplier is increased for next block.
+	t.execute_with(|| {
+		let fm = TransactionPayment::next_fee_multiplier();
+		println!("After a small block: {:?} -> {:?}", prev_multiplier, fm);
+		assert!(fm < prev_multiplier);
+	});
+}
+
+fn new_account_info(free_dollars: u128) -> Vec<u8> {
+	frame_system::AccountInfo {
+		nonce: 0u32,
+		consumers: 0,
+		providers: 1,
+		sufficients: 0,
+		data: (free_dollars * DOLLARS, 0 * DOLLARS, 0 * DOLLARS, 1u128 << 127),
+	}
+	.encode()
+}
+
+#[test]
+fn transaction_fee_is_correct() {
+	// This uses the exact values of substrate-node.
+	//
+	// weight of transfer call as of now: 1_000_000
+	// if weight of the cheapest weight would be 10^7, this would be 10^9, which is:
+	//   - 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_unwrap());
+	t.insert(<frame_system::Account<Runtime>>::hashed_key_for(alice()), new_account_info(100));
+	t.insert(<frame_system::Account<Runtime>>::hashed_key_for(bob()), new_account_info(10));
+	t.insert(
+		<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(),
+		(110 * DOLLARS).encode(),
+	);
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let tip = 1_000_000;
+	let xt = sign(CheckedExtrinsic {
+		signed: Some((alice(), signed_extra(0, tip))),
+		function: RuntimeCall::Balances(default_transfer_call()),
+	});
+
+	let r =
+		executor_call(&mut t, "Core_initialize_block", &vec![].and(&from_block_number(1u32)), true)
+			.0;
+
+	assert!(r.is_ok());
+	let r = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt.clone()), true).0;
+	assert!(r.is_ok());
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&bob()), (10 + 69) * DOLLARS);
+		// Components deducted from alice's balances:
+		// - Base fee
+		// - Weight fee
+		// - Length fee
+		// - Tip
+		// - Creation-fee of bob's account.
+		let mut balance_alice = (100 - 69) * DOLLARS;
+
+		let base_weight = ExtrinsicBaseWeight::get();
+		let base_fee = IdentityFee::<Balance>::weight_to_fee(&base_weight);
+
+		let length_fee = TransactionByteFee::get() * (xt.clone().encode().len() as Balance);
+		balance_alice -= length_fee;
+
+		let weight = default_transfer_call().get_dispatch_info().weight;
+		let weight_fee = IdentityFee::<Balance>::weight_to_fee(&weight);
+
+		// we know that weight to fee multiplier is effect-less in block 1.
+		// current weight of transfer = 200_000_000
+		// Linear weight to fee is 1:1 right now (1 weight = 1 unit of balance)
+		assert_eq!(weight_fee, weight.ref_time() as Balance);
+		balance_alice -= base_fee;
+		balance_alice -= weight_fee;
+		balance_alice -= tip;
+
+		assert_eq!(Balances::total_balance(&alice()), balance_alice);
+	});
+}
+
+#[test]
+#[should_panic]
+#[cfg(feature = "stress-test")]
+fn block_weight_capacity_report() {
+	// Just report how many transfer calls you could fit into a block. The number should at least
+	// be a few hundred (250 at the time of writing but can change over time). Runs until panic.
+	use node_primitives::Nonce;
+
+	// execution ext.
+	let mut t = new_test_ext(compact_code_unwrap());
+	// setup ext.
+	let mut tt = new_test_ext(compact_code_unwrap());
+
+	let factor = 50;
+	let mut time = 10;
+	let mut nonce: Nonce = 0;
+	let mut block_number = 1;
+	let mut previous_hash: node_primitives::Hash = GENESIS_HASH.into();
+
+	loop {
+		let num_transfers = block_number * factor;
+		let mut xts = (0..num_transfers)
+			.map(|i| CheckedExtrinsic {
+				signed: Some((charlie(), signed_extra(nonce + i as Nonce, 0))),
+				function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+					dest: bob().into(),
+					value: 0,
+				}),
+			})
+			.collect::<Vec<CheckedExtrinsic>>();
+
+		xts.insert(
+			0,
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time * 1000 }),
+			},
+		);
+
+		// NOTE: this is super slow. Can probably be improved.
+		let block = construct_block(
+			&mut tt,
+			block_number,
+			previous_hash,
+			xts,
+			(time * 1000 / SLOT_DURATION).into(),
+		);
+
+		let len = block.0.len();
+		print!(
+			"++ Executing block with {} transfers. Block size = {} bytes / {} kb / {} mb",
+			num_transfers,
+			len,
+			len / 1024,
+			len / 1024 / 1024,
+		);
+
+		let r = executor_call(&mut t, "Core_execute_block", &block.0, true).0;
+
+		println!(" || Result = {:?}", r);
+		assert!(r.is_ok());
+
+		previous_hash = block.1;
+		nonce += num_transfers;
+		time += 10;
+		block_number += 1;
+	}
+}
+
+#[test]
+#[should_panic]
+#[cfg(feature = "stress-test")]
+fn block_length_capacity_report() {
+	// Just report how big a block can get. Executes until panic. Should be ignored unless if
+	// manually inspected. The number should at least be a few megabytes (5 at the time of
+	// writing but can change over time).
+	use node_primitives::Nonce;
+
+	// execution ext.
+	let mut t = new_test_ext(compact_code_unwrap());
+	// setup ext.
+	let mut tt = new_test_ext(compact_code_unwrap());
+
+	let factor = 256 * 1024;
+	let mut time = 10;
+	let mut nonce: Nonce = 0;
+	let mut block_number = 1;
+	let mut previous_hash: node_primitives::Hash = GENESIS_HASH.into();
+
+	loop {
+		// NOTE: this is super slow. Can probably be improved.
+		let block = construct_block(
+			&mut tt,
+			block_number,
+			previous_hash,
+			vec![
+				CheckedExtrinsic {
+					signed: None,
+					function: RuntimeCall::Timestamp(pallet_timestamp::Call::set {
+						now: time * 1000,
+					}),
+				},
+				CheckedExtrinsic {
+					signed: Some((charlie(), signed_extra(nonce, 0))),
+					function: RuntimeCall::System(frame_system::Call::remark {
+						remark: vec![0u8; (block_number * factor) as usize],
+					}),
+				},
+			],
+			(time * 1000 / SLOT_DURATION).into(),
+		);
+
+		let len = block.0.len();
+		print!(
+			"++ Executing block with big remark. Block size = {} bytes / {} kb / {} mb",
+			len,
+			len / 1024,
+			len / 1024 / 1024,
+		);
+
+		let r = executor_call(&mut t, "Core_execute_block", &block.0, true).0;
+
+		println!(" || Result = {:?}", r);
+		assert!(r.is_ok());
+
+		previous_hash = block.1;
+		nonce += 1;
+		time += 10;
+		block_number += 1;
+	}
+}

substrate/bin/node/cli/tests/res/default_genesis_config.json

@@ -0,0 +1,108 @@
+{
+  "system": {},
+  "babe": {
+    "authorities": [],
+    "epochConfig": null
+  },
+  "indices": {
+    "indices": []
+  },
+  "balances": {
+    "balances": []
+  },
+  "transactionPayment": {
+    "multiplier": "1000000000000000000"
+  },
+  "staking": {
+    "validatorCount": 0,
+    "minimumValidatorCount": 0,
+    "invulnerables": [],
+    "forceEra": "NotForcing",
+    "slashRewardFraction": 0,
+    "canceledPayout": 0,
+    "stakers": [],
+    "minNominatorBond": 0,
+    "minValidatorBond": 0,
+    "maxValidatorCount": null,
+    "maxNominatorCount": null
+  },
+  "session": {
+    "keys": []
+  },
+  "democracy": {},
+  "council": {
+    "members": []
+  },
+  "technicalCommittee": {
+    "members": []
+  },
+  "elections": {
+    "members": []
+  },
+  "technicalMembership": {
+    "members": []
+  },
+  "grandpa": {
+    "authorities": []
+  },
+  "treasury": {},
+  "sudo": {
+    "key": null
+  },
+  "imOnline": {
+    "keys": []
+  },
+  "authorityDiscovery": {
+    "keys": []
+  },
+  "society": {
+    "pot": 0
+  },
+  "vesting": {
+    "vesting": []
+  },
+  "glutton": {
+    "compute": "0",
+    "storage": "0",
+    "trashDataCount": 0
+  },
+  "assets": {
+    "assets": [],
+    "metadata": [],
+    "accounts": []
+  },
+  "poolAssets": {
+    "assets": [],
+    "metadata": [],
+    "accounts": []
+  },
+  "transactionStorage": {
+    "byteFee": 10,
+    "entryFee": 1000,
+    "storagePeriod": 100800
+  },
+  "allianceMotion": {
+    "members": []
+  },
+  "alliance": {
+    "fellows": [],
+    "allies": []
+  },
+  "mixnet": {
+    "mixnodes": []
+  },
+  "nominationPools": {
+    "minJoinBond": 0,
+    "minCreateBond": 0,
+    "maxPools": 16,
+    "maxMembersPerPool": 32,
+    "maxMembers": 512,
+    "globalMaxCommission": null
+  },
+  "txPause": {
+    "paused": []
+  },
+  "safeMode": {
+    "enteredUntil": null
+  }
+}

substrate/bin/node/cli/tests/submit_transaction.rs

@@ -0,0 +1,259 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use codec::Decode;
+use frame_system::offchain::{SendSignedTransaction, Signer, SubmitTransaction};
+use kitchensink_runtime::{Executive, Indices, Runtime, UncheckedExtrinsic};
+use sp_application_crypto::AppCrypto;
+use sp_core::offchain::{testing::TestTransactionPoolExt, TransactionPoolExt};
+use sp_keyring::sr25519::Keyring::Alice;
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
+
+pub mod common;
+use self::common::*;
+
+#[test]
+fn should_submit_unsigned_transaction() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	let (pool, state) = TestTransactionPoolExt::new();
+	t.register_extension(TransactionPoolExt::new(pool));
+
+	t.execute_with(|| {
+		let signature =
+			pallet_im_online::sr25519::AuthoritySignature::try_from(vec![0; 64]).unwrap();
+		let heartbeat_data = pallet_im_online::Heartbeat {
+			block_number: 1,
+			session_index: 1,
+			authority_index: 0,
+			validators_len: 0,
+		};
+
+		let call = pallet_im_online::Call::heartbeat { heartbeat: heartbeat_data, signature };
+		SubmitTransaction::<Runtime, pallet_im_online::Call<Runtime>>::submit_unsigned_transaction(
+			call.into(),
+		)
+		.unwrap();
+
+		assert_eq!(state.read().transactions.len(), 1)
+	});
+}
+
+const PHRASE: &str = "news slush supreme milk chapter athlete soap sausage put clutch what kitten";
+
+#[test]
+fn should_submit_signed_transaction() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	let (pool, state) = TestTransactionPoolExt::new();
+	t.register_extension(TransactionPoolExt::new(pool));
+
+	let keystore = MemoryKeystore::new();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter1", PHRASE)))
+		.unwrap();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter2", PHRASE)))
+		.unwrap();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter3", PHRASE)))
+		.unwrap();
+	t.register_extension(KeystoreExt::new(keystore));
+
+	t.execute_with(|| {
+		let results =
+			Signer::<Runtime, TestAuthorityId>::all_accounts().send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death {
+					dest: Alice.to_account_id().into(),
+					value: Default::default(),
+				}
+			});
+
+		let len = results.len();
+		assert_eq!(len, 3);
+		assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
+		assert_eq!(state.read().transactions.len(), len);
+	});
+}
+
+#[test]
+fn should_submit_signed_twice_from_the_same_account() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	let (pool, state) = TestTransactionPoolExt::new();
+	t.register_extension(TransactionPoolExt::new(pool));
+
+	let keystore = MemoryKeystore::new();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter1", PHRASE)))
+		.unwrap();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter2", PHRASE)))
+		.unwrap();
+	t.register_extension(KeystoreExt::new(keystore));
+
+	t.execute_with(|| {
+		let result =
+			Signer::<Runtime, TestAuthorityId>::any_account().send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death {
+					dest: Alice.to_account_id().into(),
+					value: Default::default(),
+				}
+			});
+
+		assert!(result.is_some());
+		assert_eq!(state.read().transactions.len(), 1);
+
+		// submit another one from the same account. The nonce should be incremented.
+		let result =
+			Signer::<Runtime, TestAuthorityId>::any_account().send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death {
+					dest: Alice.to_account_id().into(),
+					value: Default::default(),
+				}
+			});
+
+		assert!(result.is_some());
+		assert_eq!(state.read().transactions.len(), 2);
+
+		// now check that the transaction nonces are not equal
+		let s = state.read();
+		fn nonce(tx: UncheckedExtrinsic) -> frame_system::CheckNonce<Runtime> {
+			let extra = tx.signature.unwrap().2;
+			extra.5
+		}
+		let nonce1 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[0]).unwrap());
+		let nonce2 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[1]).unwrap());
+		assert!(nonce1 != nonce2, "Transactions should have different nonces. Got: {:?}", nonce1);
+	});
+}
+
+#[test]
+fn should_submit_signed_twice_from_all_accounts() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	let (pool, state) = TestTransactionPoolExt::new();
+	t.register_extension(TransactionPoolExt::new(pool));
+
+	let keystore = MemoryKeystore::new();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter1", PHRASE)))
+		.unwrap();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter2", PHRASE)))
+		.unwrap();
+	t.register_extension(KeystoreExt::new(keystore));
+
+	t.execute_with(|| {
+		let results = Signer::<Runtime, TestAuthorityId>::all_accounts()
+			.send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death { dest: Alice.to_account_id().into(), value: Default::default() }
+			});
+
+		let len = results.len();
+		assert_eq!(len, 2);
+		assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
+		assert_eq!(state.read().transactions.len(), 2);
+
+		// submit another one from the same account. The nonce should be incremented.
+		let results = Signer::<Runtime, TestAuthorityId>::all_accounts()
+			.send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death { dest: Alice.to_account_id().into(), value: Default::default() }
+			});
+
+		let len = results.len();
+		assert_eq!(len, 2);
+		assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
+		assert_eq!(state.read().transactions.len(), 4);
+
+		// now check that the transaction nonces are not equal
+		let s = state.read();
+		fn nonce(tx: UncheckedExtrinsic) -> frame_system::CheckNonce<Runtime> {
+			let extra = tx.signature.unwrap().2;
+			extra.5
+		}
+		let nonce1 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[0]).unwrap());
+		let nonce2 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[1]).unwrap());
+		let nonce3 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[2]).unwrap());
+		let nonce4 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[3]).unwrap());
+		assert!(
+			nonce1 != nonce3,
+			"Transactions should have different nonces. Got: 1st tx nonce: {:?}, 2nd nonce: {:?}", nonce1, nonce3
+		);
+		assert!(
+			nonce2 != nonce4,
+			"Transactions should have different nonces. Got: 1st tx nonce: {:?}, 2nd tx nonce: {:?}", nonce2, nonce4
+		);
+	});
+}
+
+#[test]
+fn submitted_transaction_should_be_valid() {
+	use codec::Encode;
+	use sp_runtime::{
+		traits::StaticLookup,
+		transaction_validity::{TransactionSource, TransactionTag},
+	};
+
+	let mut t = new_test_ext(compact_code_unwrap());
+	let (pool, state) = TestTransactionPoolExt::new();
+	t.register_extension(TransactionPoolExt::new(pool));
+
+	let keystore = MemoryKeystore::new();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter1", PHRASE)))
+		.unwrap();
+	t.register_extension(KeystoreExt::new(keystore));
+
+	t.execute_with(|| {
+		let results =
+			Signer::<Runtime, TestAuthorityId>::all_accounts().send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death {
+					dest: Alice.to_account_id().into(),
+					value: Default::default(),
+				}
+			});
+		let len = results.len();
+		assert_eq!(len, 1);
+		assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
+	});
+
+	// check that transaction is valid, but reset environment storage,
+	// since CreateTransaction increments the nonce
+	let tx0 = state.read().transactions[0].clone();
+	let mut t = new_test_ext(compact_code_unwrap());
+	t.execute_with(|| {
+		let source = TransactionSource::External;
+		let extrinsic = UncheckedExtrinsic::decode(&mut &*tx0).unwrap();
+		// add balance to the account
+		let author = extrinsic.signature.clone().unwrap().0;
+		let address = Indices::lookup(author).unwrap();
+		let data = pallet_balances::AccountData { free: 5_000_000_000_000, ..Default::default() };
+		let account = frame_system::AccountInfo { providers: 1, data, ..Default::default() };
+		<frame_system::Account<Runtime>>::insert(&address, account);
+
+		// check validity
+		let res = Executive::validate_transaction(
+			source,
+			extrinsic,
+			frame_system::BlockHash::<Runtime>::get(0),
+		)
+		.unwrap();
+
+		// We ignore res.priority since this number can change based on updates to weights and such.
+		assert_eq!(res.requires, Vec::<TransactionTag>::new());
+		assert_eq!(res.provides, vec![(address, 0).encode()]);
+		assert_eq!(res.longevity, 2047);
+		assert_eq!(res.propagate, true);
+	});
+}