Improve APIs for Tries in Runtime

substrate/frame/support/src/traits/proving.rs

@@ -24,9 +24,9 @@ use sp_core::Hasher;
 /// Something that can verify the existence of some data in a given proof.
 pub trait VerifyExistenceProof {
 	/// The proof type.
-	type Proof;
+	type Proof: Encode + Decode;
 	/// The hash type.
-	type Hash;
+	type Hash: Encode + Decode;
 
 	/// Verify the given `proof`.
 	///
@@ -77,7 +77,10 @@ pub struct SixteenPatriciaMerkleTreeExistenceProof {
 /// Implements [`VerifyExistenceProof`] using a 16-patricia merkle tree.
 pub struct SixteenPatriciaMerkleTreeProver<H>(core::marker::PhantomData<H>);
 
-impl<H: Hasher> VerifyExistenceProof for SixteenPatriciaMerkleTreeProver<H> {
+impl<H: Hasher> VerifyExistenceProof for SixteenPatriciaMerkleTreeProver<H>
+where
+	H::Out: Decode + Encode,
+{
 	type Proof = SixteenPatriciaMerkleTreeExistenceProof;
 	type Hash = H::Out;
 
@@ -92,6 +95,15 @@ impl<H: Hasher> VerifyExistenceProof for SixteenPatriciaMerkleTreeProver<H> {
 	}
 }
 
+/// An implementation which always returns an error when this feature is unavailable.
+impl VerifyExistenceProof for () {
+	type Proof = ();
+	type Hash = ();
+	fn verify_proof(_proof: Self::Proof, _root: &Self::Hash) -> Result<Vec<u8>, ()> {
+		Err(())
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;

substrate/primitives/runtime/Cargo.toml

@@ -36,6 +36,7 @@ sp-trie = { workspace = true }
 sp-weights = { workspace = true }
 docify = { workspace = true }
 tracing = { workspace = true, features = ["log"], default-features = false }
+binary-merkle-tree = { workspace = true }
 
 simple-mermaid = { version = "0.1.1", optional = true }
 
@@ -73,6 +74,7 @@ std = [
 	"sp-trie/std",
 	"sp-weights/std",
 	"tracing/std",
+	"binary-merkle-tree/std",
 ]
 
 # Serde support without relying on std features.

substrate/primitives/runtime/src/proving_trie.rs → substrate/primitives/runtime/src/proving_trie/base16.rs

@@ -24,105 +24,14 @@
 //! Proofs are created with latest substrate trie format (`LayoutV1`), and are not compatible with
 //! proofs using `LayoutV0`.
 
-use crate::{Decode, DispatchError, Encode, MaxEncodedLen, TypeInfo};
-#[cfg(feature = "serde")]
-use crate::{Deserialize, Serialize};
-
+use super::TrieError;
+use crate::{Decode, DispatchError, Encode};
 use sp_std::vec::Vec;
 use sp_trie::{
-	trie_types::{TrieDBBuilder, TrieDBMutBuilderV1, TrieError as SpTrieError},
-	LayoutV1, MemoryDB, Trie, TrieMut, VerifyError,
+	trie_types::{TrieDBBuilder, TrieDBMutBuilderV1},
+	LayoutV1, MemoryDB, Trie, TrieMut,
 };
 
-type HashOf<Hashing> = <Hashing as sp_core::Hasher>::Out;
-
-/// A runtime friendly error type for tries.
-#[derive(Eq, PartialEq, Clone, Copy, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum TrieError {
-	/* From TrieError */
-	/// Attempted to create a trie with a state root not in the DB.
-	InvalidStateRoot,
-	/// Trie item not found in the database,
-	IncompleteDatabase,
-	/// A value was found in the trie with a nibble key that was not byte-aligned.
-	ValueAtIncompleteKey,
-	/// Corrupt Trie item.
-	DecoderError,
-	/// Hash is not value.
-	InvalidHash,
-	/* From VerifyError */
-	/// The statement being verified contains multiple key-value pairs with the same key.
-	DuplicateKey,
-	/// The proof contains at least one extraneous node.
-	ExtraneousNode,
-	/// The proof contains at least one extraneous value which should have been omitted from the
-	/// proof.
-	ExtraneousValue,
-	/// The proof contains at least one extraneous hash reference the should have been omitted.
-	ExtraneousHashReference,
-	/// The proof contains an invalid child reference that exceeds the hash length.
-	InvalidChildReference,
-	/// The proof indicates that an expected value was not found in the trie.
-	ValueMismatch,
-	/// The proof is missing trie nodes required to verify.
-	IncompleteProof,
-	/// The root hash computed from the proof is incorrect.
-	RootMismatch,
-	/// One of the proof nodes could not be decoded.
-	DecodeError,
-}
-
-impl<T> From<SpTrieError<T>> for TrieError {
-	fn from(error: SpTrieError<T>) -> Self {
-		match error {
-			SpTrieError::InvalidStateRoot(..) => Self::InvalidStateRoot,
-			SpTrieError::IncompleteDatabase(..) => Self::IncompleteDatabase,
-			SpTrieError::ValueAtIncompleteKey(..) => Self::ValueAtIncompleteKey,
-			SpTrieError::DecoderError(..) => Self::DecoderError,
-			SpTrieError::InvalidHash(..) => Self::InvalidHash,
-		}
-	}
-}
-
-impl<T, U> From<VerifyError<T, U>> for TrieError {
-	fn from(error: VerifyError<T, U>) -> Self {
-		match error {
-			VerifyError::DuplicateKey(..) => Self::DuplicateKey,
-			VerifyError::ExtraneousNode => Self::ExtraneousNode,
-			VerifyError::ExtraneousValue(..) => Self::ExtraneousValue,
-			VerifyError::ExtraneousHashReference(..) => Self::ExtraneousHashReference,
-			VerifyError::InvalidChildReference(..) => Self::InvalidChildReference,
-			VerifyError::ValueMismatch(..) => Self::ValueMismatch,
-			VerifyError::IncompleteProof => Self::IncompleteProof,
-			VerifyError::RootMismatch(..) => Self::RootMismatch,
-			VerifyError::DecodeError(..) => Self::DecodeError,
-		}
-	}
-}
-
-impl From<TrieError> for &'static str {
-	fn from(e: TrieError) -> &'static str {
-		match e {
-			TrieError::InvalidStateRoot => "The state root is not in the database.",
-			TrieError::IncompleteDatabase => "A trie item was not found in the database.",
-			TrieError::ValueAtIncompleteKey =>
-				"A value was found with a key that is not byte-aligned.",
-			TrieError::DecoderError => "A corrupt trie item was encountered.",
-			TrieError::InvalidHash => "The hash does not match the expected value.",
-			TrieError::DuplicateKey => "The proof contains duplicate keys.",
-			TrieError::ExtraneousNode => "The proof contains extraneous nodes.",
-			TrieError::ExtraneousValue => "The proof contains extraneous values.",
-			TrieError::ExtraneousHashReference => "The proof contains extraneous hash references.",
-			TrieError::InvalidChildReference => "The proof contains an invalid child reference.",
-			TrieError::ValueMismatch => "The proof indicates a value mismatch.",
-			TrieError::IncompleteProof => "The proof is incomplete.",
-			TrieError::RootMismatch => "The root hash computed from the proof is incorrect.",
-			TrieError::DecodeError => "One of the proof nodes could not be decoded.",
-		}
-	}
-}
-
 /// A helper structure for building a basic base-16 merkle trie and creating compact proofs for that
 /// trie. Proofs are created with latest substrate trie format (`LayoutV1`), and are not compatible
 /// with proofs using `LayoutV0`.
@@ -131,7 +40,7 @@ where
 	Hashing: sp_core::Hasher,
 {
 	db: MemoryDB<Hashing>,
-	root: HashOf<Hashing>,
+	root: Hashing::Out,
 	_phantom: core::marker::PhantomData<(Key, Value)>,
 }
 
@@ -161,7 +70,7 @@ where
 	}
 
 	/// Access the underlying trie root.
-	pub fn root(&self) -> &HashOf<Hashing> {
+	pub fn root(&self) -> &Hashing::Out {
 		&self.root
 	}
 
@@ -178,31 +87,28 @@ where
 	}
 
 	/// Create a compact merkle proof needed to prove all `keys` and their values are in the trie.
-	/// Returns `None` if the nodes within the current `MemoryDB` are insufficient to create a
-	/// proof.
 	///
 	/// This function makes a proof with latest substrate trie format (`LayoutV1`), and is not
 	/// compatible with `LayoutV0`.
 	///
 	/// When verifying the proof created by this function, you must include all of the keys and
 	/// values of the proof, else the verifier will complain that extra nodes are provided in the
 	/// proof that are not needed.
-	pub fn create_proof(&self, keys: &[Key]) -> Result<Vec<Vec<u8>>, DispatchError> {
+	pub fn create_proof(&self, keys: &[Key]) -> Result<Vec<u8>, DispatchError> {
 		sp_trie::generate_trie_proof::<LayoutV1<Hashing>, _, _, _>(
 			&self.db,
 			self.root,
 			&keys.into_iter().map(|k| k.encode()).collect::<Vec<Vec<u8>>>(),
 		)
 		.map_err(|err| TrieError::from(*err).into())
+		.map(|structured_proof| structured_proof.encode())
 	}
 
 	/// Create a compact merkle proof needed to prove a single key and its value are in the trie.
-	/// Returns `None` if the nodes within the current `MemoryDB` are insufficient to create a
-	/// proof.
 	///
 	/// This function makes a proof with latest substrate trie format (`LayoutV1`), and is not
 	/// compatible with `LayoutV0`.
-	pub fn create_single_value_proof(&self, key: Key) -> Result<Vec<Vec<u8>>, DispatchError> {
+	pub fn create_single_value_proof(&self, key: Key) -> Result<Vec<u8>, DispatchError> {
 		self.create_proof(&[key])
 	}
 }
@@ -211,8 +117,8 @@ where
 ///
 /// Proofs must be created with latest substrate trie format (`LayoutV1`).
 pub fn verify_single_value_proof<Hashing, Key, Value>(
-	root: HashOf<Hashing>,
-	proof: &[Vec<u8>],
+	root: Hashing::Out,
+	proof: &[u8],
 	key: Key,
 	maybe_value: Option<Value>,
 ) -> Result<(), DispatchError>
@@ -221,9 +127,11 @@ where
 	Key: Encode,
 	Value: Encode,
 {
+	let structured_proof: Vec<Vec<u8>> =
+		Decode::decode(&mut &proof[..]).map_err(|_| TrieError::DecodeError)?;
 	sp_trie::verify_trie_proof::<LayoutV1<Hashing>, _, _, _>(
 		&root,
-		proof,
+		&structured_proof,
 		&[(key.encode(), maybe_value.map(|value| value.encode()))],
 	)
 	.map_err(|err| TrieError::from(err).into())
@@ -233,22 +141,28 @@ where
 ///
 /// Proofs must be created with latest substrate trie format (`LayoutV1`).
 pub fn verify_proof<Hashing, Key, Value>(
-	root: HashOf<Hashing>,
-	proof: &[Vec<u8>],
+	root: Hashing::Out,
+	proof: &[u8],
 	items: &[(Key, Option<Value>)],
 ) -> Result<(), DispatchError>
 where
 	Hashing: sp_core::Hasher,
 	Key: Encode,
 	Value: Encode,
 {
+	let structured_proof: Vec<Vec<u8>> =
+		Decode::decode(&mut &proof[..]).map_err(|_| TrieError::DecodeError)?;
 	let items_encoded = items
 		.into_iter()
 		.map(|(key, maybe_value)| (key.encode(), maybe_value.as_ref().map(|value| value.encode())))
 		.collect::<Vec<(Vec<u8>, Option<Vec<u8>>)>>();
 
-	sp_trie::verify_trie_proof::<LayoutV1<Hashing>, _, _, _>(&root, proof, &items_encoded)
-		.map_err(|err| TrieError::from(err).into())
+	sp_trie::verify_trie_proof::<LayoutV1<Hashing>, _, _, _>(
+		&root,
+		&structured_proof,
+		&items_encoded,
+	)
+	.map_err(|err| TrieError::from(err).into())
 }
 
 #[cfg(test)]
@@ -382,10 +296,13 @@ mod tests {
 			Err(TrieError::RootMismatch.into())
 		);
 
-		// Fail to verify proof with wrong data
+		// Crete a bad proof.
+		let bad_proof = balance_trie.create_single_value_proof(99u32).unwrap();
+
+		// Fail to verify data with the wrong proof
 		assert_eq!(
-			verify_single_value_proof::<BlakeTwo256, _, _>(root, &[], 6u32, Some(6u128)),
-			Err(TrieError::IncompleteProof.into())
+			verify_single_value_proof::<BlakeTwo256, _, _>(root, &bad_proof, 6u32, Some(6u128)),
+			Err(TrieError::ExtraneousHashReference.into())
 		);
 	}
 }