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/client/src/block_builder/block_builder.rs

@@ -24,10 +24,9 @@ use runtime_primitives::traits::{
 };
 use primitives::{H256, ExecutionContext};
 use crate::blockchain::HeaderBackend;
-use crate::runtime_api::Core;
+use crate::runtime_api::{Core, ApiExt};
 use crate::error;
 
-
 /// Utility for building new (valid) blocks from a stream of extrinsics.
 pub struct BlockBuilder<'a, Block, A: ProvideRuntimeApi> where Block: BlockT {
 	header: <Block as BlockT>::Header,
@@ -44,12 +43,22 @@ where
 {
 	/// Create a new instance of builder from the given client, building on the latest block.
 	pub fn new(api: &'a A) -> error::Result<Self> {
-		api.info().and_then(|i| Self::at_block(&BlockId::Hash(i.best_hash), api))
+		api.info().and_then(|i|
+			Self::at_block(&BlockId::Hash(i.best_hash), api, false)
+		)
 	}
 
-	/// Create a new instance of builder from the given client using a particular block's ID to
-	/// build upon.
-	pub fn at_block(block_id: &BlockId<Block>, api: &'a A) -> error::Result<Self> {
+	/// Create a new instance of builder from the given client using a
+	/// particular block's ID to build upon with optional proof recording enabled.
+	///
+	/// While proof recording is enabled, all accessed trie nodes are saved.
+	/// These recorded trie nodes can be used by a third party to proof the
+	/// output of this block builder without having access to the full storage.
+	pub fn at_block(
+		block_id: &BlockId<Block>,
+		api: &'a A,
+		proof_recording: bool
+	) -> error::Result<Self> {
 		let number = api.block_number_from_id(block_id)?
 			.ok_or_else(|| error::Error::UnknownBlock(format!("{}", block_id)))?
 			+ One::one();
@@ -63,8 +72,17 @@ where
 			parent_hash,
 			Default::default()
 		);
-		let api = api.runtime_api();
-		api.initialize_block_with_context(block_id, ExecutionContext::BlockConstruction, &header)?;
+
+		let mut api = api.runtime_api();
+
+		if proof_recording {
+			api.record_proof();
+		}
+
+		api.initialize_block_with_context(
+			block_id, ExecutionContext::BlockConstruction, &header
+		)?;
+
 		Ok(BlockBuilder {
 			header,
 			extrinsics: Vec::new(),
@@ -77,13 +95,15 @@ where
 	///
 	/// This will ensure the extrinsic can be validly executed (by executing it);
 	pub fn push(&mut self, xt: <Block as BlockT>::Extrinsic) -> error::Result<()> {
-		use crate::runtime_api::ApiExt;
-
 		let block_id = &self.block_id;
 		let extrinsics = &mut self.extrinsics;
 
 		self.api.map_api_result(|api| {
-			match api.apply_extrinsic_with_context(block_id, ExecutionContext::BlockConstruction, xt.clone())? {
+			match api.apply_extrinsic_with_context(
+				block_id,
+				ExecutionContext::BlockConstruction,
+				xt.clone()
+			)? {
 				Ok(ApplyOutcome::Success) | Ok(ApplyOutcome::Fail) => {
 					extrinsics.push(xt);
 					Ok(())
@@ -97,13 +117,34 @@ where
 
 	/// Consume the builder to return a valid `Block` containing all pushed extrinsics.
 	pub fn bake(mut self) -> error::Result<Block> {
-		self.header = self.api.finalize_block_with_context(&self.block_id, ExecutionContext::BlockConstruction)?;
+		self.bake_impl()?;
+		Ok(<Block as BlockT>::new(self.header, self.extrinsics))
+	}
+
+	fn bake_impl(&mut self) -> error::Result<()> {
+		self.header = self.api.finalize_block_with_context(
+			&self.block_id, ExecutionContext::BlockConstruction
+		)?;
 
 		debug_assert_eq!(
 			self.header.extrinsics_root().clone(),
-			HashFor::<Block>::ordered_trie_root(self.extrinsics.iter().map(Encode::encode)),
+			HashFor::<Block>::ordered_trie_root(
+				self.extrinsics.iter().map(Encode::encode)
+			),
 		);
 
-		Ok(<Block as BlockT>::new(self.header, self.extrinsics))
+		Ok(())
+	}
+
+	/// Consume the builder to return a valid `Block` containing all pushed extrinsics
+	/// and the generated proof.
+	///
+	/// The proof will be `Some(_)`, if proof recording was enabled while creating
+	/// the block builder.
+	pub fn bake_and_extract_proof(mut self) -> error::Result<(Block, Option<Vec<Vec<u8>>>)> {
+		self.bake_impl()?;
+
+		let proof = self.api.extract_proof();
+		Ok((<Block as BlockT>::new(self.header, self.extrinsics), proof))
 	}
 }