Allow usage of different proof formats

bin/node/cli/src/service.rs

@@ -396,7 +396,7 @@ mod tests {
 	use sc_consensus_epochs::descendent_query;
 	use sp_consensus::{
 		Environment, Proposer, BlockImportParams, BlockOrigin, ForkChoiceStrategy, BlockImport,
-		RecordProof,
+		RecordProof, StorageProofKind,
 	};
 	use node_primitives::{Block, DigestItem, Signature};
 	use node_runtime::{BalancesCall, Call, UncheckedExtrinsic, Address};
@@ -591,7 +591,7 @@ mod tests {
 						inherent_data,
 						digest,
 						std::time::Duration::from_secs(1),
-						RecordProof::Yes,
+						RecordProof::Yes(StorageProofKind::Flatten),
 					).await
 				}).expect("Error making test block").block;
 

client/api/src/call_executor.rs

@@ -24,6 +24,7 @@ use sp_runtime::{
 };
 use sp_state_machine::{
 	OverlayedChanges, ExecutionManager, ExecutionStrategy, StorageProof,
+	StorageProofKind,
 };
 use sc_executor::{RuntimeVersion, NativeVersion};
 use sp_externalities::Extensions;
@@ -92,7 +93,7 @@ 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<B>>>,
 		extensions: Option<Extensions>,
 	) -> sp_blockchain::Result<NativeOrEncoded<R>> where ExecutionManager<EM>: Clone;
 
@@ -109,14 +110,15 @@ pub trait CallExecutor<B: BlockT> {
 		mut state: S,
 		overlay: &mut OverlayedChanges,
 		method: &str,
-		call_data: &[u8]
+		call_data: &[u8],
+		kind: StorageProofKind,
 	) -> Result<(Vec<u8>, StorageProof), sp_blockchain::Error> {
 		let trie_state = state.as_trie_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_trie_state(trie_state, overlay, method, call_data, kind)
 	}
 
 	/// Execute a call to a contract on top of given trie state, gathering execution proof.
@@ -127,7 +129,8 @@ pub trait CallExecutor<B: BlockT> {
 		trie_state: &sp_state_machine::TrieBackend<S, HashFor<B>>,
 		overlay: &mut OverlayedChanges,
 		method: &str,
-		call_data: &[u8]
+		call_data: &[u8],
+		kind: StorageProofKind,
 	) -> Result<(Vec<u8>, StorageProof), sp_blockchain::Error>;
 
 	/// Get runtime version if supported.

client/api/src/cht.rs

@@ -32,7 +32,8 @@ 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
+	prove_read_on_trie_backend, read_proof_check, read_proof_check_on_flat_proving_backend,
+	StorageProofKind,
 };
 
 use sp_blockchain::{Error as ClientError, Result as ClientResult};
@@ -121,6 +122,7 @@ pub fn build_proof<Header, Hasher, BlocksI, HashesI>(
 	prove_read_on_trie_backend(
 		trie_storage,
 		blocks.into_iter().map(|number| encode_cht_key(number)),
+		StorageProofKind::Flatten,
 	).map_err(ClientError::Execution)
 }
 
@@ -170,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_flat_proving_backend::<Hasher>(
 				proving_backend,
 				local_cht_key,
 			).map_err(|e| ClientError::from(e)),

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, CloneableSpawn};
+pub use sp_state_machine::{StorageProof, LegacyDecodeAdapter, LegacyEncodeAdapter,
+	FlattenEncodeAdapter, StorageProofKind, ExecutionStrategy, CloneableSpawn};
 
 /// Usage Information Provider interface
 ///

client/api/src/proof_provider.rs

@@ -21,7 +21,7 @@ use sp_runtime::{
 	generic::BlockId,
 	traits::{Block as BlockT},
 };
-use crate::{StorageProof, ChangesProof};
+use crate::{StorageProof, ChangesProof, StorageProofKind};
 use sp_storage::{ChildInfo, StorageKey, PrefixedStorageKey};
 
 /// Interface for providing block proving utilities.
@@ -31,6 +31,7 @@ pub trait ProofProvider<Block: BlockT> {
 		&self,
 		id: &BlockId<Block>,
 		keys: &mut dyn Iterator<Item=&[u8]>,
+		kind: StorageProofKind,
 	) -> sp_blockchain::Result<StorageProof>;
 
 	/// Reads child storage value at a given block + storage_key + key, returning
@@ -40,6 +41,7 @@ pub trait ProofProvider<Block: BlockT> {
 		id: &BlockId<Block>,
 		child_info: &ChildInfo,
 		keys: &mut dyn Iterator<Item=&[u8]>,
+		kind: StorageProofKind,
 	) -> sp_blockchain::Result<StorageProof>;
 
 	/// Execute a call to a contract on top of state in a block of given hash
@@ -51,7 +53,9 @@ pub trait ProofProvider<Block: BlockT> {
 		id: &BlockId<Block>,
 		method: &str,
 		call_data: &[u8],
+		kind: StorageProofKind,
 	) -> sp_blockchain::Result<(Vec<u8>, StorageProof)>;
+
 	/// Reads given header and generates CHT-based header proof.
 	fn header_proof(&self, id: &BlockId<Block>) -> sp_blockchain::Result<(Block::Header, StorageProof)>;
 

client/basic-authorship/src/lib.rs

@@ -21,7 +21,7 @@
 //!
 //! ```
 //! # use sc_basic_authorship::ProposerFactory;
-//! # use sp_consensus::{Environment, Proposer, RecordProof};
+//! # use sp_consensus::{Environment, Proposer, RecordProof, StorageProofKind};
 //! # use sp_runtime::generic::BlockId;
 //! # use std::{sync::Arc, time::Duration};
 //! # use substrate_test_runtime_client::{self, runtime::{Extrinsic, Transfer}, AccountKeyring};
@@ -45,7 +45,7 @@
 //! 	Default::default(),
 //! 	Default::default(),
 //! 	Duration::from_secs(2),
-//! 	RecordProof::Yes,
+//! 	RecordProof::Yes(StorageProofKind::Flatten),
 //! );
 //!
 //! // We wait until the proposition is performed.

client/block-builder/src/lib.rs

@@ -129,8 +129,8 @@ where
 
 		let mut api = api.runtime_api();
 
-		if record_proof.yes() {
-			api.record_proof();
+		if let Some(kind) = record_proof.kind() {
+			api.record_proof(kind);
 		}
 
 		let block_id = BlockId::Hash(parent_hash);
@@ -231,7 +231,7 @@ mod tests {
 			&client,
 			client.info().best_hash,
 			client.info().best_number,
-			RecordProof::Yes,
+			RecordProof::Yes(sp_api::StorageProofKind::Flatten),
 			Default::default(),
 			&*backend,
 		).unwrap().build().unwrap();

client/finality-grandpa/src/finality_proof.rs

@@ -40,7 +40,7 @@ use log::{trace, warn};
 
 use sp_blockchain::{Backend as BlockchainBackend, Error as ClientError, Result as ClientResult};
 use sc_client_api::{
-	backend::Backend, StorageProof,
+	backend::Backend, StorageProof, StorageProofKind,
 	light::{FetchChecker, RemoteReadRequest},
 	StorageProvider, ProofProvider,
 };
@@ -97,7 +97,7 @@ impl<BE, Block: BlockT> AuthoritySetForFinalityProver<Block> for Arc<dyn Storage
 	}
 
 	fn prove_authorities(&self, block: &BlockId<Block>) -> ClientResult<StorageProof> {
-		self.read_proof(block, &mut std::iter::once(GRANDPA_AUTHORITIES_KEY))
+		self.read_proof(block, &mut std::iter::once(GRANDPA_AUTHORITIES_KEY), StorageProofKind::Flatten)
 	}
 }
 
@@ -228,7 +228,7 @@ pub(crate) struct FinalityProofFragment<Header: HeaderT> {
 	/// The set of headers in the range (U; F] that we believe are unknown to the caller. Ordered.
 	pub unknown_headers: Vec<Header>,
 	/// Optional proof of execution of GRANDPA::authorities() at the `block`.
-	pub authorities_proof: Option<StorageProof>,
+	pub authorities_proof: Option<Vec<Vec<u8>>>,
 }
 
 /// Proof of finality is the ordered set of finality fragments, where:
@@ -344,7 +344,7 @@ pub(crate) fn prove_finality<Block: BlockT, B: BlockchainBackend<Block>, J>(
 				block: current,
 				justification,
 				unknown_headers: ::std::mem::take(&mut unknown_headers),
-				authorities_proof: new_authorities_proof,
+				authorities_proof: new_authorities_proof.map(StorageProof::expect_flatten_content),
 			};
 
 			// append justification to finality proof if required
@@ -511,7 +511,7 @@ fn check_finality_proof_fragment<Block: BlockT, B, J>(
 		current_authorities = authorities_provider.check_authorities_proof(
 			proof_fragment.block,
 			header,
-			new_authorities_proof,
+			StorageProof::Flatten(new_authorities_proof),
 		)?;
 
 		current_set_id += 1;
@@ -836,8 +836,8 @@ pub(crate) mod tests {
 					_ => unreachable!("no other authorities should be fetched: {:?}", block_id),
 				},
 				|block_id| match block_id {
-					BlockId::Number(5) => Ok(StorageProof::new(vec![vec![50]])),
-					BlockId::Number(7) => Ok(StorageProof::new(vec![vec![70]])),
+					BlockId::Number(5) => Ok(StorageProof::Flatten(vec![vec![50]])),
+					BlockId::Number(7) => Ok(StorageProof::Flatten(vec![vec![70]])),
 					_ => unreachable!("no other authorities should be proved: {:?}", block_id),
 				},
 			),
@@ -853,14 +853,14 @@ pub(crate) mod tests {
 				block: header(5).hash(),
 				justification: just5,
 				unknown_headers: Vec::new(),
-				authorities_proof: Some(StorageProof::new(vec![vec![50]])),
+				authorities_proof: Some(vec![vec![50]]),
 			},
 			// last fragment provides justification for #7 && unknown#7
 			FinalityProofFragment {
 				block: header(7).hash(),
 				justification: just7.clone(),
 				unknown_headers: vec![header(7)],
-				authorities_proof: Some(StorageProof::new(vec![vec![70]])),
+				authorities_proof: Some(vec![vec![70]]),
 			},
 		]);
 
@@ -874,7 +874,7 @@ pub(crate) mod tests {
 			0,
 			auth3,
 			&ClosureAuthoritySetForFinalityChecker(
-				|hash, _header, proof: StorageProof| match proof.clone().iter_nodes().next().map(|x| x[0]) {
+				|hash, _header, proof: StorageProof| match proof.clone().iter_nodes_flatten().next().map(|x| x[0]) {
 					Some(50) => Ok(auth5.clone()),
 					Some(70) => Ok(auth7.clone()),
 					_ => unreachable!("no other proofs should be checked: {}", hash),
@@ -935,7 +935,7 @@ pub(crate) mod tests {
 				block: header(4).hash(),
 				justification: TestJustification((0, authorities.clone()), vec![7]).encode(),
 				unknown_headers: vec![header(4)],
-				authorities_proof: Some(StorageProof::new(vec![vec![42]])),
+				authorities_proof: Some(vec![vec![42]]),
 			}, FinalityProofFragment {
 				block: header(5).hash(),
 				justification: TestJustification((0, authorities), vec![8]).encode(),
@@ -985,7 +985,7 @@ pub(crate) mod tests {
 				block: header(2).hash(),
 				justification: TestJustification((1, initial_authorities.clone()), vec![7]).encode(),
 				unknown_headers: Vec::new(),
-				authorities_proof: Some(StorageProof::new(vec![vec![42]])),
+				authorities_proof: Some(vec![vec![42]]),
 			}, FinalityProofFragment {
 				block: header(4).hash(),
 				justification: TestJustification((2, next_authorities.clone()), vec![8]).encode(),

client/finality-grandpa/src/light_import.rs

@@ -573,7 +573,7 @@ pub mod tests {
 	use sp_consensus::{import_queue::CacheKeyId, ForkChoiceStrategy, BlockImport};
 	use sp_finality_grandpa::AuthorityId;
 	use sp_core::{H256, crypto::Public};
-	use sc_client_api::{in_mem::Blockchain as InMemoryAuxStore, StorageProof};
+	use sc_client_api::{in_mem::Blockchain as InMemoryAuxStore};
 	use substrate_test_runtime_client::runtime::{Block, Header};
 	use crate::tests::TestApi;
 	use crate::finality_proof::{
@@ -867,7 +867,7 @@ pub mod tests {
 						Vec::new(),
 					).encode(),
 					unknown_headers: Vec::new(),
-					authorities_proof: Some(StorageProof::new(vec![])),
+					authorities_proof: Some(vec![]),
 				},
 			].encode(),
 			&mut verifier,

client/finality-grandpa/src/tests.rs

@@ -30,7 +30,7 @@ use tokio::runtime::{Runtime, Handle};
 use sp_keyring::Ed25519Keyring;
 use sc_client_api::backend::TransactionFor;
 use sp_blockchain::Result;
-use sp_api::{ApiRef, StorageProof, ProvideRuntimeApi};
+use sp_api::{ApiRef, StorageProof, StorageProofKind, ProvideRuntimeApi};
 use substrate_test_runtime_client::runtime::BlockNumber;
 use sp_consensus::{
 	BlockOrigin, ForkChoiceStrategy, ImportedAux, BlockImportParams, ImportResult, BlockImport,
@@ -248,7 +248,7 @@ impl AuthoritySetForFinalityProver<Block> for TestApi {
 		let backend = <InMemoryBackend<HashFor<Block>>>::from(vec![
 			(None, vec![(b"authorities".to_vec(), Some(authorities.encode()))])
 		]);
-		let proof = prove_read(backend, vec![b"authorities"])
+		let proof = prove_read(backend, vec![b"authorities"], StorageProofKind::Flatten)
 			.expect("failure proving read from in-memory storage backend");
 		Ok(proof)
 	}