Cumulus changes version 2 (#2313)

* ensure imbalances are properly accounted for (#2183)

* ensure imbalances are properly accounted for

* bump runtime version

* Update node/runtime/src/lib.rs

* implement contract events (#2161)

* implement contract events

* update runtime

* renaming

* update test code hash

* improve complexity details

* add deposit event base cost

* add test

* Revert "add deposit event base cost"

This reverts commit 58ec010c0f4f4f0e16935ad41da32aedd17a8c57.

* update test

* Revert "update test"

This reverts commit 6fe61a593ccf0d41f09a0b97472b28ed8751a999.

* Revert "Revert "add deposit event base cost""

This reverts commit 145e8a9bac15313a4c380aa66b94fd4d36fa3f6d.

* Fix format a bit

*  Replace Vec<u8> with [u8; 32] for contract storage key (#2184)

* Replace Vec<u8> with [u8; 32] for contract storage key

* Read storage keys from sandbox memory into fixed size buffer

* Increment `impl_version`

* Remove redundant Ok(()) and explicitly specify StorageKey buffer type (#2188)

* Switch to `derive(Encode, Decode)` for `Call` (#2178)

* Add some tests

* More tests

* Switch to `derive(Encode, Decode)` for `Call`

* Update lock files

* Simplify the macro cases

* Cache changes trie config in db storage (#2170)

* cache changes trie config in db storage

* Update core/client/db/src/lib.rs

Co-Authored-By: svyatonik <svyatonik@gmail.com>

* Update core/client/db/src/lib.rs

Co-Authored-By: svyatonik <svyatonik@gmail.com>

* Fix version check for renamed runtime api methods (#2190)

* Add feature to disable including the test-runtime wasm blob

* Enable `std` feature for `consensus_authorities`

* Implement `skip_initialize_block` and `initialize_block` for runtime api

* Add test and fixes bug

* Begin to implement support for passing the `ProofRecorder`

* Make sure proof generation works as intended

* Fixes tests

* Make `BlockBuilder` generate proofs on request.

* Adds `TestClientBuilder` to simplify creating a test client

* Add `include-wasm-blob` to `test-client` as well

* Make `test-client` compile without including the wasm file

* Disable more stuff in test-client without wasm

* Reorganize the re-exports

* Use correct bounds

* Update docs

* Update core/client/src/block_builder/block_builder.rs

Co-Authored-By: bkchr <bkchr@users.noreply.github.com>

* Extend test to actually generated proof

* Switch to enum for `skip_initialize_block`

* Some wasm files updates

substrate/core/sr-api-macros/tests/runtime_calls.rs

@@ -14,9 +14,20 @@
 // You should have received a copy of the GNU General Public License
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
 
-use test_client::runtime::{TestAPI, DecodeFails};
-use runtime_primitives::{generic::BlockId, traits::ProvideRuntimeApi};
-use state_machine::ExecutionStrategy;
+use test_client::{
+	AccountKeyring, runtime::{TestAPI, DecodeFails, Transfer, Header},
+	NativeExecutor, LocalExecutor,
+};
+use runtime_primitives::{
+	generic::BlockId,
+	traits::{ProvideRuntimeApi, Header as HeaderT, Hash as HashT},
+};
+use state_machine::{
+	ExecutionStrategy, create_proof_check_backend,
+	execution_proof_check_on_trie_backend,
+};
+
+use codec::Encode;
 
 fn calling_function_with_strat(strat: ExecutionStrategy) {
 	let client = test_client::new_with_execution_strategy(strat);
@@ -114,3 +125,66 @@ fn use_trie_function() {
 	let block_id = BlockId::Number(client.info().unwrap().chain.best_number);
 	assert_eq!(runtime_api.use_trie(&block_id).unwrap(), 2);
 }
+
+#[test]
+fn initialize_block_works() {
+	let client = test_client::new_with_execution_strategy(ExecutionStrategy::Both);
+	let runtime_api = client.runtime_api();
+	let block_id = BlockId::Number(client.info().unwrap().chain.best_number);
+	assert_eq!(runtime_api.get_block_number(&block_id).unwrap(), 1);
+}
+
+#[test]
+fn initialize_block_is_called_only_once() {
+	let client = test_client::new_with_execution_strategy(ExecutionStrategy::Both);
+	let runtime_api = client.runtime_api();
+	let block_id = BlockId::Number(client.info().unwrap().chain.best_number);
+	assert_eq!(runtime_api.take_block_number(&block_id).unwrap(), Some(1));
+	assert_eq!(runtime_api.take_block_number(&block_id).unwrap(), None);
+}
+
+#[test]
+fn initialize_block_is_skipped() {
+	let client = test_client::new_with_execution_strategy(ExecutionStrategy::Both);
+	let runtime_api = client.runtime_api();
+	let block_id = BlockId::Number(client.info().unwrap().chain.best_number);
+	assert!(runtime_api.without_initialize_block(&block_id).unwrap());
+}
+
+#[test]
+fn record_proof_works() {
+	let client = test_client::new_with_execution_strategy(ExecutionStrategy::Both);
+
+	let block_id = BlockId::Number(client.info().unwrap().chain.best_number);
+	let storage_root = client.best_block_header().unwrap().state_root().clone();
+
+	let transaction = Transfer {
+		amount: 1000,
+		nonce: 0,
+		from: AccountKeyring::Alice.into(),
+		to: Default::default(),
+	}.into_signed_tx();
+
+	// Build the block and record proof
+	let mut builder = client
+		.new_block_at_with_proof_recording(&block_id)
+		.expect("Creates block builder");
+	builder.push(transaction.clone()).unwrap();
+	let (block, proof) = builder.bake_and_extract_proof().expect("Bake block");
+
+	let backend = create_proof_check_backend::<<<Header as HeaderT>::Hashing as HashT>::Hasher>(
+		storage_root,
+		proof.expect("Proof was generated"),
+	).expect("Creates proof backend.");
+
+	// Use the proof backend to execute `execute_block`.
+	let mut overlay = Default::default();
+	let executor = NativeExecutor::<LocalExecutor>::new(None);
+	execution_proof_check_on_trie_backend(
+		&backend,
+		&mut overlay,
+		&executor,
+		"Core_execute_block",
+		&block.encode(),
+	).expect("Executes block while using the proof backend");
+}