Allow usage of different proof formats

bin/node/bench/src/trie.rs

@@ -23,7 +23,8 @@ use kvdb::KeyValueDB;
 use lazy_static::lazy_static;
 use rand::Rng;
 use hash_db::Prefix;
-use sp_state_machine::Backend as _;
+use sp_state_machine::backend::Backend as _;
+use sp_state_machine::SimpleProof;
 use sp_trie::{trie_types::TrieDBMut, TrieMut as _};
 
 use node_primitives::Hash;
@@ -181,7 +182,7 @@ impl core::Benchmark for TrieReadBenchmark {
 		let storage: Arc<dyn sp_state_machine::Storage<sp_core::Blake2Hasher>> =
 			Arc::new(Storage(db.open(self.database_type)));
 
-		let trie_backend = sp_state_machine::TrieBackend::new(
+		let trie_backend = sp_state_machine::TrieBackend::<_, _, SimpleProof>::new(
 			storage,
 			self.root,
 		);

client/api/src/backend.rs

@@ -40,12 +40,22 @@ use sp_blockchain;
 use sp_consensus::BlockOrigin;
 use parking_lot::RwLock;
 
-pub use sp_state_machine::Backend as StateBackend;
+pub use sp_state_machine::backend::Backend as StateBackend;
+pub use sp_state_machine::backend::ProofRawFor;
 use std::marker::PhantomData;
 
 /// Extracts the state backend type for the given backend.
 pub type StateBackendFor<B, Block> = <B as Backend<Block>>::State;
 
+/// Extracts the proof for the given backend.
+pub type ProofFor<B, Block> = <
+	RecProofForB<B, Block> as StateBackend<HashFor<Block>>
+>::StorageProof;
+
+type RecProofForSB<B, Block> = <B as StateBackend<HashFor<Block>>>::RecProofBackend;
+
+type RecProofForB<B, Block> = RecProofForSB<StateBackendFor<B, Block>, Block>;
+
 /// Extracts the transaction for the given state backend.
 pub type TransactionForSB<B, Block> = <B as StateBackend<HashFor<Block>>>::Transaction;
 

client/api/src/call_executor.rs

@@ -24,14 +24,15 @@ use sp_runtime::{
 	generic::BlockId, traits::{Block as BlockT, HashFor},
 };
 use sp_state_machine::{
-	OverlayedChanges, ExecutionManager, ExecutionStrategy, StorageProof,
+	OverlayedChanges, ExecutionManager, ExecutionStrategy,
 };
 use sc_executor::{RuntimeVersion, NativeVersion};
 use sp_externalities::Extensions;
 use sp_core::{NativeOrEncoded,offchain::storage::OffchainOverlayedChanges};
 
 use sp_api::{ProofRecorder, InitializeBlock, StorageTransactionCache};
 use crate::execution_extensions::ExecutionExtensions;
+use sp_state_machine::backend::ProofRawFor;
 
 /// Executor Provider
 pub trait ExecutorProvider<Block: BlockT> {
@@ -93,7 +94,9 @@ pub trait CallExecutor<B: BlockT> {
 		initialize_block: InitializeBlock<'a, B>,
 		execution_manager: ExecutionManager<EM>,
 		native_call: Option<NC>,
-		proof_recorder: &Option<ProofRecorder<B>>,
+		proof_recorder: Option<&RefCell<
+			ProofRecorder<<Self::Backend as crate::backend::Backend<B>>::State, B>
+		>>,
 		extensions: Option<Extensions>,
 	) -> sp_blockchain::Result<NativeOrEncoded<R>> where ExecutionManager<EM>: Clone;
 
@@ -105,31 +108,31 @@ pub trait CallExecutor<B: BlockT> {
 	/// Execute a call to a contract on top of given state, gathering execution proof.
 	///
 	/// No changes are made.
-	fn prove_at_state<S: sp_state_machine::Backend<HashFor<B>>>(
+	fn prove_at_state<S: sp_state_machine::backend::Backend<HashFor<B>>>(
 		&self,
-		mut state: S,
+		state: S,
 		overlay: &mut OverlayedChanges,
 		method: &str,
 		call_data: &[u8]
-	) -> Result<(Vec<u8>, StorageProof), sp_blockchain::Error> {
-		let trie_state = state.as_trie_backend()
+	) -> Result<(Vec<u8>, ProofRawFor<S, HashFor<B>>), sp_blockchain::Error> {
+		let proof_state = state.as_proof_backend()
 			.ok_or_else(||
 				Box::new(sp_state_machine::ExecutionError::UnableToGenerateProof)
 					as Box<dyn sp_state_machine::Error>
 			)?;
-		self.prove_at_trie_state(trie_state, overlay, method, call_data)
+		self.prove_at_proof_backend_state(&proof_state, overlay, method, call_data)
 	}
 
 	/// Execute a call to a contract on top of given trie state, gathering execution proof.
 	///
 	/// No changes are made.
-	fn prove_at_trie_state<S: sp_state_machine::TrieBackendStorage<HashFor<B>>>(
+	fn prove_at_proof_backend_state<P: sp_state_machine::backend::RecProofBackend<HashFor<B>>>(
 		&self,
-		trie_state: &sp_state_machine::TrieBackend<S, HashFor<B>>,
+		proof_backend: &P,
 		overlay: &mut OverlayedChanges,
 		method: &str,
-		call_data: &[u8]
-	) -> Result<(Vec<u8>, StorageProof), sp_blockchain::Error>;
+		call_data: &[u8],
+	) -> Result<(Vec<u8>, ProofRawFor<P, HashFor<B>>), sp_blockchain::Error>;
 
 	/// Get runtime version if supported.
 	fn native_runtime_version(&self) -> Option<&NativeVersion>;

client/api/src/cht.rs

@@ -32,12 +32,13 @@ use sp_trie;
 use sp_core::{H256, convert_hash};
 use sp_runtime::traits::{Header as HeaderT, AtLeast32Bit, Zero, One};
 use sp_state_machine::{
-	MemoryDB, TrieBackend, Backend as StateBackend, StorageProof, InMemoryBackend,
-	prove_read_on_trie_backend, read_proof_check, read_proof_check_on_proving_backend
+	backend::Backend as StateBackend, SimpleProof, InMemoryBackend,
+	prove_read_on_proof_backend, read_proof_check, read_proof_check_on_proving_backend,
 };
-
 use sp_blockchain::{Error as ClientError, Result as ClientResult};
 
+type ProofCheckBackend<H> = sp_state_machine::InMemoryProofCheckBackend<H, SimpleProof>;
+
 /// The size of each CHT. This value is passed to every CHT-related function from
 /// production code. Other values are passed from tests.
 const SIZE: u32 = 2048;
@@ -104,7 +105,7 @@ pub fn build_proof<Header, Hasher, BlocksI, HashesI>(
 	cht_num: Header::Number,
 	blocks: BlocksI,
 	hashes: HashesI
-) -> ClientResult<StorageProof>
+) -> ClientResult<SimpleProof>
 	where
 		Header: HeaderT,
 		Hasher: hash_db::Hasher,
@@ -116,11 +117,11 @@ pub fn build_proof<Header, Hasher, BlocksI, HashesI>(
 		.into_iter()
 		.map(|(k, v)| (k, Some(v)))
 		.collect::<Vec<_>>();
-	let mut storage = InMemoryBackend::<Hasher>::default().update(vec![(None, transaction)]);
-	let trie_storage = storage.as_trie_backend()
-		.expect("InMemoryState::as_trie_backend always returns Some; qed");
-	prove_read_on_trie_backend(
-		trie_storage,
+	let storage = InMemoryBackend::<Hasher, SimpleProof>::default().update(vec![(None, transaction)]);
+	let proof_backend = storage.as_proof_backend()
+		.expect("InMemoryState::as_proof_backend always returns Some; qed");
+	prove_read_on_proof_backend(
+		&proof_backend,
 		blocks.into_iter().map(|number| encode_cht_key(number)),
 	).map_err(ClientError::Execution)
 }
@@ -130,7 +131,7 @@ pub fn check_proof<Header, Hasher>(
 	local_root: Header::Hash,
 	local_number: Header::Number,
 	remote_hash: Header::Hash,
-	remote_proof: StorageProof,
+	remote_proof: SimpleProof,
 ) -> ClientResult<()>
 	where
 		Header: HeaderT,
@@ -142,7 +143,7 @@ pub fn check_proof<Header, Hasher>(
 		local_number,
 		remote_hash,
 		move |local_root, local_cht_key|
-			read_proof_check::<Hasher, _>(
+			read_proof_check::<ProofCheckBackend<Hasher>, Hasher, _>(
 				local_root,
 				remote_proof,
 				::std::iter::once(local_cht_key),
@@ -159,7 +160,7 @@ pub fn check_proof_on_proving_backend<Header, Hasher>(
 	local_root: Header::Hash,
 	local_number: Header::Number,
 	remote_hash: Header::Hash,
-	proving_backend: &TrieBackend<MemoryDB<Hasher>, Hasher>,
+	proving_backend: &ProofCheckBackend<Hasher>,
 ) -> ClientResult<()>
 	where
 		Header: HeaderT,
@@ -171,7 +172,7 @@ pub fn check_proof_on_proving_backend<Header, Hasher>(
 		local_number,
 		remote_hash,
 		|_, local_cht_key|
-			read_proof_check_on_proving_backend::<Hasher>(
+			read_proof_check_on_proving_backend::<ProofCheckBackend<Hasher>, Hasher>(
 				proving_backend,
 				local_cht_key,
 			).map_err(|e| ClientError::from(e)),

client/api/src/in_mem.rs

@@ -29,7 +29,7 @@ use sp_runtime::generic::BlockId;
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT, Zero, NumberFor, HashFor};
 use sp_runtime::{Justification, Storage};
 use sp_state_machine::{
-	ChangesTrieTransaction, InMemoryBackend, Backend as StateBackend, StorageCollection,
+	ChangesTrieTransaction, backend::Backend as StateBackend, StorageCollection,
 	ChildStorageCollection,
 };
 use sp_blockchain::{CachedHeaderMetadata, HeaderMetadata};
@@ -44,6 +44,8 @@ use crate::{
 	leaves::LeafSet,
 };
 
+type InMemoryBackend<H> = sp_state_machine::InMemoryBackend<H, sp_state_machine::SimpleProof>;
+
 struct PendingBlock<B: BlockT> {
 	block: StoredBlock<B>,
 	state: NewBlockState,

client/api/src/lib.rs

@@ -37,7 +37,8 @@ pub use light::*;
 pub use notifications::*;
 pub use proof_provider::*;
 
-pub use sp_state_machine::{StorageProof, ExecutionStrategy};
+pub use sp_state_machine::{ProofCommon, SimpleProof, ExecutionStrategy,
+	ProofNodes, BackendProof};
 
 /// Usage Information Provider interface
 ///

client/api/src/light.rs

@@ -27,7 +27,7 @@ use sp_runtime::{
 	generic::BlockId
 };
 use sp_core::{ChangesTrieConfigurationRange, storage::PrefixedStorageKey};
-use sp_state_machine::StorageProof;
+use sp_state_machine::SimpleProof;
 use sp_blockchain::{
 	HeaderMetadata, well_known_cache_keys, HeaderBackend, Cache as BlockchainCache,
 	Error as ClientError, Result as ClientResult,
@@ -124,7 +124,7 @@ pub struct ChangesProof<Header: HeaderT> {
 	pub roots: BTreeMap<Header::Number, Header::Hash>,
 	/// The proofs for all changes tries roots that have been touched AND are
 	/// missing from the requester' node. It is a map of CHT number => proof.
-	pub roots_proof: StorageProof,
+	pub roots_proof: SimpleProof,
 }
 
 /// Remote block body request
@@ -190,31 +190,31 @@ pub trait Fetcher<Block: BlockT>: Send + Sync {
 ///
 /// Implementations of this trait should not use any prunable blockchain data
 /// except that is passed to its methods.
-pub trait FetchChecker<Block: BlockT>: Send + Sync {
+pub trait FetchChecker<Block: BlockT, P>: Send + Sync {
 	/// Check remote header proof.
 	fn check_header_proof(
 		&self,
 		request: &RemoteHeaderRequest<Block::Header>,
 		header: Option<Block::Header>,
-		remote_proof: StorageProof,
+		remote_proof: SimpleProof,
 	) -> ClientResult<Block::Header>;
 	/// Check remote storage read proof.
 	fn check_read_proof(
 		&self,
 		request: &RemoteReadRequest<Block::Header>,
-		remote_proof: StorageProof,
+		remote_proof: P,
 	) -> ClientResult<HashMap<Vec<u8>, Option<Vec<u8>>>>;
 	/// Check remote storage read proof.
 	fn check_read_child_proof(
 		&self,
 		request: &RemoteReadChildRequest<Block::Header>,
-		remote_proof: StorageProof,
+		remote_proof: P,
 	) -> ClientResult<HashMap<Vec<u8>, Option<Vec<u8>>>>;
 	/// Check remote method execution proof.
 	fn check_execution_proof(
 		&self,
 		request: &RemoteCallRequest<Block::Header>,
-		remote_proof: StorageProof,
+		remote_proof: P,
 	) -> ClientResult<Vec<u8>>;
 	/// Check remote changes query proof.
 	fn check_changes_proof(

client/api/src/proof_provider.rs

@@ -19,19 +19,20 @@
 //! Proof utilities
 use sp_runtime::{
 	generic::BlockId,
-	traits::{Block as BlockT},
+	traits::{Block as BlockT, HashFor},
 };
-use crate::{StorageProof, ChangesProof};
+use crate::{SimpleProof, ChangesProof};
 use sp_storage::{ChildInfo, StorageKey, PrefixedStorageKey};
+use sp_trie::BackendProof;
 
 /// Interface for providing block proving utilities.
-pub trait ProofProvider<Block: BlockT> {
+pub trait ProofProvider<Block: BlockT, Proof: BackendProof<HashFor<Block>>> {
 	/// Reads storage value at a given block + key, returning read proof.
 	fn read_proof(
 		&self,
 		id: &BlockId<Block>,
 		keys: &mut dyn Iterator<Item=&[u8]>,
-	) -> sp_blockchain::Result<StorageProof>;
+	) -> sp_blockchain::Result<Proof::ProofRaw>;
 
 	/// Reads child storage value at a given block + storage_key + key, returning
 	/// read proof.
@@ -40,7 +41,7 @@ pub trait ProofProvider<Block: BlockT> {
 		id: &BlockId<Block>,
 		child_info: &ChildInfo,
 		keys: &mut dyn Iterator<Item=&[u8]>,
-	) -> sp_blockchain::Result<StorageProof>;
+	) -> sp_blockchain::Result<Proof::ProofRaw>;
 
 	/// Execute a call to a contract on top of state in a block of given hash
 	/// AND returning execution proof.
@@ -51,9 +52,10 @@ pub trait ProofProvider<Block: BlockT> {
 		id: &BlockId<Block>,
 		method: &str,
 		call_data: &[u8],
-	) -> sp_blockchain::Result<(Vec<u8>, StorageProof)>;
+	) -> sp_blockchain::Result<(Vec<u8>, Proof::ProofRaw)>;
+
 	/// Reads given header and generates CHT-based header proof.
-	fn header_proof(&self, id: &BlockId<Block>) -> sp_blockchain::Result<(Block::Header, StorageProof)>;
+	fn header_proof(&self, id: &BlockId<Block>) -> sp_blockchain::Result<(Block::Header, SimpleProof)>;
 
 	/// Get proof for computation of (block, extrinsic) pairs where key has been changed at given blocks range.
 	/// `min` is the hash of the first block, which changes trie root is known to the requester - when we're using

client/basic-authorship/src/basic_authorship.rs

@@ -22,7 +22,7 @@
 
 use std::{time, sync::Arc};
 use sc_client_api::backend;
-use codec::Decode;
+use codec::{Encode, Decode};
 use sp_consensus::{evaluation, Proposal, RecordProof};
 use sp_inherents::InherentData;
 use log::{error, info, debug, trace, warn};
@@ -312,7 +312,8 @@ impl<A, B, Block, C> Proposer<B, Block, C, A>
 			error!("Failed to evaluate authored block: {:?}", err);
 		}
 
-		Ok(Proposal { block, proof, storage_changes })
+		let proof: Option<backend::ProofFor<B, Block>> = proof.map(Into::into);
+		Ok(Proposal { block, encoded_proof: proof.map(|p| p.encode()), storage_changes })
 	}
 }
 

client/basic-authorship/src/lib.rs

@@ -25,10 +25,7 @@
 //! # use sp_consensus::{Environment, Proposer, RecordProof};
 //! # use sp_runtime::generic::BlockId;
 //! # use std::{sync::Arc, time::Duration};
-//! # use substrate_test_runtime_client::{
-//! #     runtime::{Extrinsic, Transfer}, AccountKeyring,
-//! #     DefaultTestClientBuilderExt, TestClientBuilderExt,
-//! # };
+//! # use substrate_test_runtime_client::{self, runtime::{Extrinsic, Transfer}, AccountKeyring};
 //! # use sc_transaction_pool::{BasicPool, FullChainApi};
 //! # let client = Arc::new(substrate_test_runtime_client::new());
 //! # let spawner = sp_core::testing::TaskExecutor::new();