[stable2407] Backport #6526 (#6530)

Backport #6526 into `stable2407` from bkchr.

See the
[documentation](https://github.com/paritytech/polkadot-sdk/blob/master/docs/BACKPORT.md)
on how to use this bot.

<!--
  # To be used by other automation, do not modify:
  original-pr-number: #${pull_number}
-->

---------

Co-authored-by: Bastian Köcher <git@kchr.de>
Co-authored-by: command-bot <>
Co-authored-by: Bastian Köcher <info@kchr.de>

Author: paritytech-cmd-bot-polkadot-sdk[bot]

cumulus/pallets/parachain-system/src/validate_block/trie_cache.rs

@@ -85,7 +85,10 @@ impl<H: Hasher> CacheProvider<H> {
 }
 
 impl<H: Hasher> TrieCacheProvider<H> for CacheProvider<H> {
-	type Cache<'a> = TrieCache<'a, H> where H: 'a;
+	type Cache<'a>
+		= TrieCache<'a, H>
+	where
+		H: 'a;
 
 	fn as_trie_db_cache(&self, storage_root: <H as Hasher>::Out) -> Self::Cache<'_> {
 		TrieCache {

cumulus/pallets/parachain-system/src/validate_block/trie_recorder.rs

@@ -115,7 +115,10 @@ impl<H: Hasher> SizeOnlyRecorderProvider<H> {
 }
 
 impl<H: trie_db::Hasher> sp_trie::TrieRecorderProvider<H> for SizeOnlyRecorderProvider<H> {
-	type Recorder<'a> = SizeOnlyRecorder<'a, H> where H: 'a;
+	type Recorder<'a>
+		= SizeOnlyRecorder<'a, H>
+	where
+		H: 'a;
 
 	fn drain_storage_proof(self) -> Option<StorageProof> {
 		None

cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs

@@ -542,8 +542,7 @@ impl InstanceFilter<RuntimeCall> for ProxyType {
 						RuntimeCall::Utility { .. } |
 						RuntimeCall::Multisig { .. } |
 						RuntimeCall::NftFractionalization { .. } |
-						RuntimeCall::Nfts { .. } |
-						RuntimeCall::Uniques { .. }
+						RuntimeCall::Nfts { .. } | RuntimeCall::Uniques { .. }
 				)
 			},
 			ProxyType::AssetOwner => matches!(

cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs

@@ -536,8 +536,7 @@ impl InstanceFilter<RuntimeCall> for ProxyType {
 						RuntimeCall::Utility { .. } |
 						RuntimeCall::Multisig { .. } |
 						RuntimeCall::NftFractionalization { .. } |
-						RuntimeCall::Nfts { .. } |
-						RuntimeCall::Uniques { .. }
+						RuntimeCall::Nfts { .. } | RuntimeCall::Uniques { .. }
 				)
 			},
 			ProxyType::AssetOwner => matches!(

prdoc/pr_6526.prdoc

@@ -0,0 +1,8 @@
+title: 'sp-runtime: Be a little bit more functional :D'
+doc:
+- audience: Runtime Dev
+  description: 
+    Some internal refactorings in the `Digest` code.
+crates:
+- name: sp-runtime
+  bump: patch

substrate/primitives/runtime/src/generic/digest.rs

@@ -20,6 +20,7 @@
 #[cfg(all(not(feature = "std"), feature = "serde"))]
 use alloc::format;
 use alloc::vec::Vec;
+use codec::DecodeAll;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -256,8 +257,7 @@ impl DigestItem {
 		self.dref().try_as_raw(id)
 	}
 
-	/// Returns the data contained in the item if `Some` if this entry has the id given, decoded
-	/// to the type provided `T`.
+	/// Returns the data decoded as `T`, if the `id` is matching.
 	pub fn try_to<T: Decode>(&self, id: OpaqueDigestItemId) -> Option<T> {
 		self.dref().try_to::<T>(id)
 	}
@@ -367,69 +367,48 @@ impl<'a> DigestItemRef<'a> {
 	/// Try to match this digest item to the given opaque item identifier; if it matches, then
 	/// try to cast to the given data type; if that works, return it.
 	pub fn try_to<T: Decode>(&self, id: OpaqueDigestItemId) -> Option<T> {
-		self.try_as_raw(id).and_then(|mut x| Decode::decode(&mut x).ok())
+		self.try_as_raw(id).and_then(|mut x| DecodeAll::decode_all(&mut x).ok())
 	}
 
 	/// Try to match this to a `Self::Seal`, check `id` matches and decode it.
 	///
 	/// Returns `None` if this isn't a seal item, the `id` doesn't match or when the decoding fails.
 	pub fn seal_try_to<T: Decode>(&self, id: &ConsensusEngineId) -> Option<T> {
-		match self {
-			Self::Seal(v, s) if *v == id => Decode::decode(&mut &s[..]).ok(),
-			_ => None,
-		}
+		self.as_seal()
+			.filter(|s| s.0 == *id)
+			.and_then(|mut d| DecodeAll::decode_all(&mut d.1).ok())
 	}
 
 	/// Try to match this to a `Self::Consensus`, check `id` matches and decode it.
 	///
 	/// Returns `None` if this isn't a consensus item, the `id` doesn't match or
 	/// when the decoding fails.
 	pub fn consensus_try_to<T: Decode>(&self, id: &ConsensusEngineId) -> Option<T> {
-		match self {
-			Self::Consensus(v, s) if *v == id => Decode::decode(&mut &s[..]).ok(),
-			_ => None,
-		}
+		self.as_consensus()
+			.filter(|s| s.0 == *id)
+			.and_then(|mut d| DecodeAll::decode_all(&mut d.1).ok())
 	}
 
 	/// Try to match this to a `Self::PreRuntime`, check `id` matches and decode it.
 	///
 	/// Returns `None` if this isn't a pre-runtime item, the `id` doesn't match or
 	/// when the decoding fails.
 	pub fn pre_runtime_try_to<T: Decode>(&self, id: &ConsensusEngineId) -> Option<T> {
-		match self {
-			Self::PreRuntime(v, s) if *v == id => Decode::decode(&mut &s[..]).ok(),
-			_ => None,
-		}
+		self.as_pre_runtime()
+			.filter(|s| s.0 == *id)
+			.and_then(|mut d| DecodeAll::decode_all(&mut d.1).ok())
 	}
 }
 
 impl<'a> Encode for DigestItemRef<'a> {
 	fn encode(&self) -> Vec<u8> {
-		let mut v = Vec::new();
-
 		match *self {
-			Self::Consensus(val, data) => {
-				DigestItemType::Consensus.encode_to(&mut v);
-				(val, data).encode_to(&mut v);
-			},
-			Self::Seal(val, sig) => {
-				DigestItemType::Seal.encode_to(&mut v);
-				(val, sig).encode_to(&mut v);
-			},
-			Self::PreRuntime(val, data) => {
-				DigestItemType::PreRuntime.encode_to(&mut v);
-				(val, data).encode_to(&mut v);
-			},
-			Self::Other(val) => {
-				DigestItemType::Other.encode_to(&mut v);
-				val.encode_to(&mut v);
-			},
-			Self::RuntimeEnvironmentUpdated => {
-				DigestItemType::RuntimeEnvironmentUpdated.encode_to(&mut v);
-			},
+			Self::Consensus(val, data) => (DigestItemType::Consensus, val, data).encode(),
+			Self::Seal(val, sig) => (DigestItemType::Seal, val, sig).encode(),
+			Self::PreRuntime(val, data) => (DigestItemType::PreRuntime, val, data).encode(),
+			Self::Other(val) => (DigestItemType::Other, val).encode(),
+			Self::RuntimeEnvironmentUpdated => DigestItemType::RuntimeEnvironmentUpdated.encode(),
 		}
-
-		v
 	}
 }
 

substrate/primitives/state-machine/src/trie_backend.rs

@@ -73,7 +73,10 @@ pub trait TrieCacheProvider<H: Hasher> {
 
 #[cfg(feature = "std")]
 impl<H: Hasher> TrieCacheProvider<H> for LocalTrieCache<H> {
-	type Cache<'a> = TrieCache<'a, H> where H: 'a;
+	type Cache<'a>
+		= TrieCache<'a, H>
+	where
+		H: 'a;
 
 	fn as_trie_db_cache(&self, storage_root: H::Out) -> Self::Cache<'_> {
 		self.as_trie_db_cache(storage_root)
@@ -90,7 +93,10 @@ impl<H: Hasher> TrieCacheProvider<H> for LocalTrieCache<H> {
 
 #[cfg(feature = "std")]
 impl<H: Hasher> TrieCacheProvider<H> for &LocalTrieCache<H> {
-	type Cache<'a> = TrieCache<'a, H> where Self: 'a;
+	type Cache<'a>
+		= TrieCache<'a, H>
+	where
+		Self: 'a;
 
 	fn as_trie_db_cache(&self, storage_root: H::Out) -> Self::Cache<'_> {
 		(*self).as_trie_db_cache(storage_root)
@@ -139,7 +145,10 @@ impl<H: Hasher> trie_db::TrieCache<NodeCodec<H>> for UnimplementedCacheProvider<
 
 #[cfg(not(feature = "std"))]
 impl<H: Hasher> TrieCacheProvider<H> for UnimplementedCacheProvider<H> {
-	type Cache<'a> = UnimplementedCacheProvider<H> where H: 'a;
+	type Cache<'a>
+		= UnimplementedCacheProvider<H>
+	where
+		H: 'a;
 
 	fn as_trie_db_cache(&self, _storage_root: <H as Hasher>::Out) -> Self::Cache<'_> {
 		unimplemented!()
@@ -176,7 +185,10 @@ impl<H: Hasher> trie_db::TrieRecorder<H::Out> for UnimplementedRecorderProvider<
 
 #[cfg(not(feature = "std"))]
 impl<H: Hasher> TrieRecorderProvider<H> for UnimplementedRecorderProvider<H> {
-	type Recorder<'a> = UnimplementedRecorderProvider<H> where H: 'a;
+	type Recorder<'a>
+		= UnimplementedRecorderProvider<H>
+	where
+		H: 'a;
 
 	fn drain_storage_proof(self) -> Option<StorageProof> {
 		unimplemented!()

substrate/primitives/trie/src/recorder.rs

@@ -252,7 +252,10 @@ pub struct TrieRecorder<'a, H: Hasher> {
 }
 
 impl<H: Hasher> crate::TrieRecorderProvider<H> for Recorder<H> {
-	type Recorder<'a> = TrieRecorder<'a, H> where H: 'a;
+	type Recorder<'a>
+		= TrieRecorder<'a, H>
+	where
+		H: 'a;
 
 	fn drain_storage_proof(self) -> Option<StorageProof> {
 		Some(Recorder::drain_storage_proof(self))