Remove requirement on Hash = H256, make Proposer return StorageChanges and Proof (#3860)

* Extend `Proposer` to optionally generate a proof of the proposal * Something * Refactor sr-api to not depend on client anymore * Fix benches * Apply suggestions from code review Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com> * Apply suggestions from code review * Introduce new `into_storage_changes` function * Switch to runtime api for `execute_block` and don't require `H256` anywhere in the code * Put the `StorageChanges` into the `Proposal` * Move the runtime api error to its own trait * Adds `StorageTransactionCache` to the runtime api This requires that we add `type NodeBlock = ` to the `impl_runtime_apis!` macro to work around some bugs in rustc :( * Remove `type NodeBlock` and switch to a "better" hack * Start using the transaction cache from the runtime api * Make it compile * Move `InMemory` to its own file * Make all tests work again * Return block, storage_changes and proof from Blockbuilder::bake() * Make sure that we use/set `storage_changes` when possible * Add test * Fix deadlock * Remove accidentally added folders * Introduce `RecordProof` as argument type to be more explicit * Update client/src/client.rs Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com> * Update primitives/state-machine/src/ext.rs Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com> * Integrates review feedback * Remove `unsafe` usage * Update client/block-builder/src/lib.rs Co-Authored-By: Benjamin Kampmann <ben@gnunicorn.org> * Update client/src/call_executor.rs * Bump versions Co-authored-by: Tomasz Drwięga <tomusdrw@users.noreply.github.com> Co-authored-by: Benjamin Kampmann <ben.kampmann@googlemail.com>
2026-04-27 16:17:59 +00:00 · 2020-01-10 10:48:32 +01:00
parent 74d6e660c6
commit fd6b29dd2c
140 changed files with 4860 additions and 3339 deletions
@@ -17,20 +17,16 @@
 use std::{sync::Arc, panic::UnwindSafe, result, cell::RefCell};
 use codec::{Encode, Decode};
 use sp_runtime::{
-	generic::BlockId, traits::Block as BlockT, traits::NumberFor,
+	generic::BlockId, traits::{Block as BlockT, HasherFor},
 };
 use sp_state_machine::{
 	self, OverlayedChanges, Ext, ExecutionManager, StateMachine, ExecutionStrategy,
-	backend::Backend as _, ChangesTrieTransaction, StorageProof,
+	backend::Backend as _, StorageProof,
 };
 use sc_executor::{RuntimeVersion, RuntimeInfo, NativeVersion};
 use sp_externalities::Extensions;
-use hash_db::Hasher;
-use sp_core::{
-	H256, Blake2Hasher, NativeOrEncoded, NeverNativeValue,
-	traits::CodeExecutor,
-};
-use sp_api::{ProofRecorder, InitializeBlock};
+use sp_core::{NativeOrEncoded, NeverNativeValue, traits::CodeExecutor};
+use sp_api::{ProofRecorder, InitializeBlock, StorageTransactionCache};
 use sc_client_api::{backend, call_executor::CallExecutor};

 /// Call executor that executes methods locally, querying all required
@@ -62,14 +58,16 @@ impl<B, E> Clone for LocalCallExecutor<B, E> where E: Clone {
 	}
 }

-impl<B, E, Block> CallExecutor<Block, Blake2Hasher> for LocalCallExecutor<B, E>
-	where
-		B: backend::Backend<Block, Blake2Hasher>,
-		E: CodeExecutor + RuntimeInfo,
-		Block: BlockT<Hash=H256>,
+impl<B, E, Block> CallExecutor<Block> for LocalCallExecutor<B, E>
+where
+	B: backend::Backend<Block>,
+	E: CodeExecutor + RuntimeInfo,
+	Block: BlockT,
 {
 	type Error = E::Error;

+	type Backend = B;
+
 	fn call(
 		&self,
 		id: &BlockId<Block>,
@@ -90,10 +88,8 @@ impl<B, E, Block> CallExecutor<Block, Blake2Hasher> for LocalCallExecutor<B, E>
 			extensions.unwrap_or_default(),
 		).execute_using_consensus_failure_handler::<_, NeverNativeValue, fn() -> _>(
 			strategy.get_manager(),
-			false,
 			None,
-		)
-		.map(|(result, _, _)| result)?;
+		)?;
 		{
 			let _lock = self.backend.get_import_lock().read();
 			self.backend.destroy_state(state)?;
@@ -117,6 +113,9 @@ impl<B, E, Block> CallExecutor<Block, Blake2Hasher> for LocalCallExecutor<B, E>
 		method: &str,
 		call_data: &[u8],
 		changes: &RefCell<OverlayedChanges>,
+		storage_transaction_cache: Option<&RefCell<
+			StorageTransactionCache<Block, B::State>
+		>>,
 		initialize_block: InitializeBlock<'a, Block>,
 		execution_manager: ExecutionManager<EM>,
 		native_call: Option<NC>,
@@ -134,6 +133,8 @@ impl<B, E, Block> CallExecutor<Block, Blake2Hasher> for LocalCallExecutor<B, E>

 		let mut state = self.backend.state_at(*at)?;

+		let mut storage_transaction_cache = storage_transaction_cache.map(|c| c.borrow_mut());
+
 		let result = match recorder {
 			Some(recorder) => {
 				let trie_state = state.as_trie_backend()
@@ -144,7 +145,7 @@ impl<B, E, Block> CallExecutor<Block, Blake2Hasher> for LocalCallExecutor<B, E>

 				let backend = sp_state_machine::ProvingBackend::new_with_recorder(
 					trie_state,
-					recorder.clone()
+					recorder.clone(),
 				);

 				StateMachine::new(
@@ -156,13 +157,9 @@ impl<B, E, Block> CallExecutor<Block, Blake2Hasher> for LocalCallExecutor<B, E>
 					call_data,
 					extensions.unwrap_or_default(),
 				)
-				.execute_using_consensus_failure_handler(
-					execution_manager,
-					false,
-					native_call,
-				)
-				.map(|(result, _, _)| result)
-				.map_err(Into::into)
+				// TODO: https://github.com/paritytech/substrate/issues/4455
+				// .with_storage_transaction_cache(storage_transaction_cache.as_mut().map(|c| &mut **c))
+				.execute_using_consensus_failure_handler(execution_manager, native_call)
 			}
 			None => StateMachine::new(
 				&state,
@@ -173,12 +170,8 @@ impl<B, E, Block> CallExecutor<Block, Blake2Hasher> for LocalCallExecutor<B, E>
 				call_data,
 				extensions.unwrap_or_default(),
 			)
-			.execute_using_consensus_failure_handler(
-				execution_manager,
-				false,
-				native_call,
-			)
-			.map(|(result, _, _)| result)
+			.with_storage_transaction_cache(storage_transaction_cache.as_mut().map(|c| &mut **c))
+			.execute_using_consensus_failure_handler(execution_manager, native_call)
 		}?;
 		{
 			let _lock = self.backend.get_import_lock().read();
@@ -190,9 +183,11 @@ impl<B, E, Block> CallExecutor<Block, Blake2Hasher> for LocalCallExecutor<B, E>
 	fn runtime_version(&self, id: &BlockId<Block>) -> sp_blockchain::Result<RuntimeVersion> {
 		let mut overlay = OverlayedChanges::default();
 		let state = self.backend.state_at(*id)?;
+		let mut cache = StorageTransactionCache::<Block, B::State>::default();

 		let mut ext = Ext::new(
 			&mut overlay,
+			&mut cache,
 			&state,
 			self.backend.changes_trie_storage(),
 			None,
@@ -205,51 +200,9 @@ impl<B, E, Block> CallExecutor<Block, Blake2Hasher> for LocalCallExecutor<B, E>
 		version.map_err(|e| sp_blockchain::Error::VersionInvalid(format!("{:?}", e)).into())
 	}

-	fn call_at_state<
-		S: sp_state_machine::Backend<Blake2Hasher>,
-		F: FnOnce(
-			Result<NativeOrEncoded<R>, Self::Error>,
-			Result<NativeOrEncoded<R>, Self::Error>,
-		) -> Result<NativeOrEncoded<R>, Self::Error>,
-		R: Encode + Decode + PartialEq,
-		NC: FnOnce() -> result::Result<R, String> + UnwindSafe,
-	>(&self,
-		state: &S,
-		changes: &mut OverlayedChanges,
-		method: &str,
-		call_data: &[u8],
-		manager: ExecutionManager<F>,
-		native_call: Option<NC>,
-		extensions: Option<Extensions>,
-	) -> sp_blockchain::Result<(
-		NativeOrEncoded<R>,
-		(S::Transaction, <Blake2Hasher as Hasher>::Out),
-		Option<ChangesTrieTransaction<Blake2Hasher, NumberFor<Block>>>,
-	)> {
-		StateMachine::new(
-			state,
-			self.backend.changes_trie_storage(),
-			changes,
-			&self.executor,
-			method,
-			call_data,
-			extensions.unwrap_or_default(),
-		).execute_using_consensus_failure_handler(
-			manager,
-			true,
-			native_call,
-		)
-		.map(|(result, storage_tx, changes_tx)| (
-			result,
-			storage_tx.expect("storage_tx is always computed when compute_tx is true; qed"),
-			changes_tx,
-		))
-		.map_err(Into::into)
-	}
-
-	fn prove_at_trie_state<S: sp_state_machine::TrieBackendStorage<Blake2Hasher>>(
+	fn prove_at_trie_state<S: sp_state_machine::TrieBackendStorage<HasherFor<Block>>>(
 		&self,
-		trie_state: &sp_state_machine::TrieBackend<S, Blake2Hasher>,
+		trie_state: &sp_state_machine::TrieBackend<S, HasherFor<Block>>,
 		overlay: &mut OverlayedChanges,
 		method: &str,
 		call_data: &[u8]
@@ -271,9 +224,9 @@ impl<B, E, Block> CallExecutor<Block, Blake2Hasher> for LocalCallExecutor<B, E>

 impl<B, E, Block> sp_version::GetRuntimeVersion<Block> for LocalCallExecutor<B, E>
 	where
-		B: backend::Backend<Block, Blake2Hasher>,
+		B: backend::Backend<Block>,
 		E: CodeExecutor + RuntimeInfo,
-		Block: BlockT<Hash=H256>,
+		Block: BlockT,
 {
 	fn native_version(&self) -> &sp_version::NativeVersion {
 		self.executor.native_version()