Reintroduce header chain trait (#1622)

* reintroduce header chain trait

* renive BridgedChainWithMessages::maximal_extrinsic_size

bridges/bin/millau/runtime/src/rialto_messages.rs

@@ -16,14 +16,14 @@
 
 //! Everything required to serve Millau <-> Rialto messages.
 
-use crate::{OriginCaller, Runtime, RuntimeCall, RuntimeOrigin};
+use crate::{OriginCaller, RialtoGrandpaInstance, Runtime, RuntimeCall, RuntimeOrigin};
 
 use bp_messages::{
 	source_chain::TargetHeaderChain,
 	target_chain::{ProvedMessages, SourceHeaderChain},
 	InboundLaneData, LaneId, Message, MessageNonce, Parameter as MessagesParameter,
 };
-use bp_runtime::{Chain, ChainId, MILLAU_CHAIN_ID, RIALTO_CHAIN_ID};
+use bp_runtime::{ChainId, MILLAU_CHAIN_ID, RIALTO_CHAIN_ID};
 use bridge_runtime_common::messages::{
 	self, BasicConfirmationTransactionEstimation, MessageBridge, MessageTransaction,
 };
@@ -98,6 +98,8 @@ impl MessageBridge for WithRialtoMessageBridge {
 
 	type ThisChain = Millau;
 	type BridgedChain = Rialto;
+	type BridgedHeaderChain =
+		pallet_bridge_grandpa::GrandpaChainHeaders<Runtime, RialtoGrandpaInstance>;
 
 	fn bridged_balance_to_this_balance(
 		bridged_balance: bp_rialto::Balance,
@@ -115,18 +117,14 @@ impl MessageBridge for WithRialtoMessageBridge {
 pub struct Millau;
 
 impl messages::ChainWithMessages for Millau {
-	type Hash = bp_millau::Hash;
-	type AccountId = bp_millau::AccountId;
-	type Signer = bp_millau::AccountSigner;
-	type Signature = bp_millau::Signature;
-	type Balance = bp_millau::Balance;
+	type Chain = bp_millau::Millau;
 }
 
 impl messages::ThisChainWithMessages for Millau {
 	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type ConfirmationTransactionEstimation = BasicConfirmationTransactionEstimation<
-		Self::AccountId,
+		bp_millau::AccountId,
 		{ bp_millau::MAX_SINGLE_MESSAGE_DELIVERY_CONFIRMATION_TX_WEIGHT.ref_time() },
 		{ bp_rialto::EXTRA_STORAGE_PROOF_SIZE },
 		{ bp_millau::TX_EXTRA_BYTES },
@@ -177,18 +175,10 @@ impl messages::ThisChainWithMessages for Millau {
 pub struct Rialto;
 
 impl messages::ChainWithMessages for Rialto {
-	type Hash = bp_rialto::Hash;
-	type AccountId = bp_rialto::AccountId;
-	type Signer = bp_rialto::AccountSigner;
-	type Signature = bp_rialto::Signature;
-	type Balance = bp_rialto::Balance;
+	type Chain = bp_rialto::Rialto;
 }
 
 impl messages::BridgedChainWithMessages for Rialto {
-	fn maximal_extrinsic_size() -> u32 {
-		bp_rialto::Rialto::max_extrinsic_size()
-	}
-
 	fn verify_dispatch_weight(_message_payload: &[u8]) -> bool {
 		true
 	}
@@ -248,11 +238,7 @@ impl TargetHeaderChain<ToRialtoMessagePayload, bp_millau::AccountId> for Rialto
 	fn verify_messages_delivery_proof(
 		proof: Self::MessagesDeliveryProof,
 	) -> Result<(LaneId, InboundLaneData<bp_millau::AccountId>), Self::Error> {
-		messages::source::verify_messages_delivery_proof::<
-			WithRialtoMessageBridge,
-			Runtime,
-			crate::RialtoGrandpaInstance,
-		>(proof)
+		messages::source::verify_messages_delivery_proof::<WithRialtoMessageBridge>(proof)
 	}
 }
 
@@ -269,11 +255,8 @@ impl SourceHeaderChain<bp_rialto::Balance> for Rialto {
 		proof: Self::MessagesProof,
 		messages_count: u32,
 	) -> Result<ProvedMessages<Message<bp_rialto::Balance>>, Self::Error> {
-		messages::target::verify_messages_proof::<
-			WithRialtoMessageBridge,
-			Runtime,
-			crate::RialtoGrandpaInstance,
-		>(proof, messages_count)
+		messages::target::verify_messages_proof::<WithRialtoMessageBridge>(proof, messages_count)
+			.map_err(Into::into)
 	}
 }
 
@@ -296,7 +279,7 @@ impl MessagesParameter for MillauToRialtoMessagesParameter {
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use crate::{DbWeight, RialtoGrandpaInstance, Runtime, WithRialtoMessagesInstance};
+	use crate::{DbWeight, Runtime, WithRialtoMessagesInstance};
 
 	use bp_runtime::Chain;
 	use bridge_runtime_common::{

bridges/bin/millau/runtime/src/rialto_parachain_messages.rs

@@ -16,15 +16,14 @@
 
 //! Everything required to serve Millau <-> RialtoParachain messages.
 
-use crate::{Runtime, RuntimeCall, RuntimeOrigin};
+use crate::{Runtime, RuntimeCall, RuntimeOrigin, WithRialtoParachainsInstance};
 
 use bp_messages::{
 	source_chain::TargetHeaderChain,
 	target_chain::{ProvedMessages, SourceHeaderChain},
 	InboundLaneData, LaneId, Message, MessageNonce, Parameter as MessagesParameter,
 };
-use bp_polkadot_core::parachains::ParaId;
-use bp_runtime::{Chain, ChainId, MILLAU_CHAIN_ID, RIALTO_PARACHAIN_CHAIN_ID};
+use bp_runtime::{ChainId, MILLAU_CHAIN_ID, RIALTO_PARACHAIN_CHAIN_ID};
 use bridge_runtime_common::messages::{
 	self, BasicConfirmationTransactionEstimation, MessageBridge, MessageTransaction,
 };
@@ -103,6 +102,11 @@ impl MessageBridge for WithRialtoParachainMessageBridge {
 
 	type ThisChain = Millau;
 	type BridgedChain = RialtoParachain;
+	type BridgedHeaderChain = pallet_bridge_parachains::ParachainHeaders<
+		Runtime,
+		WithRialtoParachainsInstance,
+		bp_rialto_parachain::RialtoParachain,
+	>;
 
 	fn bridged_balance_to_this_balance(
 		bridged_balance: bp_rialto_parachain::Balance,
@@ -120,18 +124,14 @@ impl MessageBridge for WithRialtoParachainMessageBridge {
 pub struct Millau;
 
 impl messages::ChainWithMessages for Millau {
-	type Hash = bp_millau::Hash;
-	type AccountId = bp_millau::AccountId;
-	type Signer = bp_millau::AccountSigner;
-	type Signature = bp_millau::Signature;
-	type Balance = bp_millau::Balance;
+	type Chain = bp_millau::Millau;
 }
 
 impl messages::ThisChainWithMessages for Millau {
 	type RuntimeCall = RuntimeCall;
 	type RuntimeOrigin = RuntimeOrigin;
 	type ConfirmationTransactionEstimation = BasicConfirmationTransactionEstimation<
-		Self::AccountId,
+		bp_rialto_parachain::AccountId,
 		{ bp_millau::MAX_SINGLE_MESSAGE_DELIVERY_CONFIRMATION_TX_WEIGHT.ref_time() },
 		{ bp_rialto_parachain::EXTRA_STORAGE_PROOF_SIZE },
 		{ bp_millau::TX_EXTRA_BYTES },
@@ -166,18 +166,10 @@ impl messages::ThisChainWithMessages for Millau {
 pub struct RialtoParachain;
 
 impl messages::ChainWithMessages for RialtoParachain {
-	type Hash = bp_rialto_parachain::Hash;
-	type AccountId = bp_rialto_parachain::AccountId;
-	type Signer = bp_rialto_parachain::AccountSigner;
-	type Signature = bp_rialto_parachain::Signature;
-	type Balance = bp_rialto_parachain::Balance;
+	type Chain = bp_rialto_parachain::RialtoParachain;
 }
 
 impl messages::BridgedChainWithMessages for RialtoParachain {
-	fn maximal_extrinsic_size() -> u32 {
-		bp_rialto_parachain::RialtoParachain::max_extrinsic_size()
-	}
-
 	fn verify_dispatch_weight(_message_payload: &[u8]) -> bool {
 		true
 	}
@@ -241,12 +233,7 @@ impl TargetHeaderChain<ToRialtoParachainMessagePayload, bp_millau::AccountId> fo
 	fn verify_messages_delivery_proof(
 		proof: Self::MessagesDeliveryProof,
 	) -> Result<(LaneId, InboundLaneData<bp_millau::AccountId>), Self::Error> {
-		messages::source::verify_messages_delivery_proof_from_parachain::<
-			WithRialtoParachainMessageBridge,
-			bp_rialto_parachain::Header,
-			Runtime,
-			crate::WithRialtoParachainsInstance,
-		>(ParaId(bp_rialto_parachain::RIALTO_PARACHAIN_ID), proof)
+		messages::source::verify_messages_delivery_proof::<WithRialtoParachainMessageBridge>(proof)
 	}
 }
 
@@ -263,12 +250,11 @@ impl SourceHeaderChain<bp_rialto_parachain::Balance> for RialtoParachain {
 		proof: Self::MessagesProof,
 		messages_count: u32,
 	) -> Result<ProvedMessages<Message<bp_rialto_parachain::Balance>>, Self::Error> {
-		messages::target::verify_messages_proof_from_parachain::<
-			WithRialtoParachainMessageBridge,
-			bp_rialto_parachain::Header,
-			Runtime,
-			crate::WithRialtoParachainsInstance,
-		>(ParaId(bp_rialto_parachain::RIALTO_PARACHAIN_ID), proof, messages_count)
+		messages::target::verify_messages_proof::<WithRialtoParachainMessageBridge>(
+			proof,
+			messages_count,
+		)
+		.map_err(Into::into)
 	}
 }
 

bridges/bin/rialto-parachain/runtime/src/millau_messages.rs

@@ -19,14 +19,14 @@
 // TODO: this is almost exact copy of `millau_messages.rs` from Rialto runtime.
 // Should be extracted to a separate crate and reused here.
 
-use crate::{OriginCaller, Runtime, RuntimeCall, RuntimeOrigin};
+use crate::{MillauGrandpaInstance, OriginCaller, Runtime, RuntimeCall, RuntimeOrigin};
 
 use bp_messages::{
 	source_chain::TargetHeaderChain,
 	target_chain::{ProvedMessages, SourceHeaderChain},
 	InboundLaneData, LaneId, Message, MessageNonce, Parameter as MessagesParameter,
 };
-use bp_runtime::{Chain, ChainId, MILLAU_CHAIN_ID, RIALTO_PARACHAIN_CHAIN_ID};
+use bp_runtime::{ChainId, MILLAU_CHAIN_ID, RIALTO_PARACHAIN_CHAIN_ID};
 use bridge_runtime_common::messages::{
 	self, BasicConfirmationTransactionEstimation, MessageBridge, MessageTransaction,
 };
@@ -102,6 +102,8 @@ impl MessageBridge for WithMillauMessageBridge {
 
 	type ThisChain = RialtoParachain;
 	type BridgedChain = Millau;
+	type BridgedHeaderChain =
+		pallet_bridge_grandpa::GrandpaChainHeaders<Runtime, MillauGrandpaInstance>;
 
 	fn bridged_balance_to_this_balance(
 		bridged_balance: bp_millau::Balance,
@@ -119,18 +121,14 @@ impl MessageBridge for WithMillauMessageBridge {
 pub struct RialtoParachain;
 
 impl messages::ChainWithMessages for RialtoParachain {
-	type Hash = bp_rialto_parachain::Hash;
-	type AccountId = bp_rialto_parachain::AccountId;
-	type Signer = bp_rialto_parachain::AccountSigner;
-	type Signature = bp_rialto_parachain::Signature;
-	type Balance = bp_rialto_parachain::Balance;
+	type Chain = bp_rialto_parachain::RialtoParachain;
 }
 
 impl messages::ThisChainWithMessages for RialtoParachain {
 	type RuntimeCall = RuntimeCall;
 	type RuntimeOrigin = RuntimeOrigin;
 	type ConfirmationTransactionEstimation = BasicConfirmationTransactionEstimation<
-		Self::AccountId,
+		bp_rialto_parachain::AccountId,
 		{ bp_rialto_parachain::MAX_SINGLE_MESSAGE_DELIVERY_CONFIRMATION_TX_WEIGHT.ref_time() },
 		{ bp_millau::EXTRA_STORAGE_PROOF_SIZE },
 		{ bp_rialto_parachain::TX_EXTRA_BYTES },
@@ -184,18 +182,10 @@ impl messages::ThisChainWithMessages for RialtoParachain {
 pub struct Millau;
 
 impl messages::ChainWithMessages for Millau {
-	type Hash = bp_millau::Hash;
-	type AccountId = bp_millau::AccountId;
-	type Signer = bp_millau::AccountSigner;
-	type Signature = bp_millau::Signature;
-	type Balance = bp_millau::Balance;
+	type Chain = bp_millau::Millau;
 }
 
 impl messages::BridgedChainWithMessages for Millau {
-	fn maximal_extrinsic_size() -> u32 {
-		bp_millau::Millau::max_extrinsic_size()
-	}
-
 	fn verify_dispatch_weight(_message_payload: &[u8]) -> bool {
 		true
 	}
@@ -255,11 +245,7 @@ impl TargetHeaderChain<ToMillauMessagePayload, bp_rialto_parachain::AccountId> f
 	fn verify_messages_delivery_proof(
 		proof: Self::MessagesDeliveryProof,
 	) -> Result<(LaneId, InboundLaneData<bp_rialto_parachain::AccountId>), Self::Error> {
-		messages::source::verify_messages_delivery_proof::<
-			WithMillauMessageBridge,
-			Runtime,
-			crate::MillauGrandpaInstance,
-		>(proof)
+		messages::source::verify_messages_delivery_proof::<WithMillauMessageBridge>(proof)
 	}
 }
 
@@ -276,11 +262,8 @@ impl SourceHeaderChain<bp_millau::Balance> for Millau {
 		proof: Self::MessagesProof,
 		messages_count: u32,
 	) -> Result<ProvedMessages<Message<bp_millau::Balance>>, Self::Error> {
-		messages::target::verify_messages_proof::<
-			WithMillauMessageBridge,
-			Runtime,
-			crate::MillauGrandpaInstance,
-		>(proof, messages_count)
+		messages::target::verify_messages_proof::<WithMillauMessageBridge>(proof, messages_count)
+			.map_err(Into::into)
 	}
 }
 

bridges/bin/rialto/runtime/src/millau_messages.rs

@@ -16,14 +16,14 @@
 
 //! Everything required to serve Millau <-> Rialto messages.
 
-use crate::{OriginCaller, Runtime, RuntimeCall, RuntimeOrigin};
+use crate::{MillauGrandpaInstance, OriginCaller, Runtime, RuntimeCall, RuntimeOrigin};
 
 use bp_messages::{
 	source_chain::TargetHeaderChain,
 	target_chain::{ProvedMessages, SourceHeaderChain},
 	InboundLaneData, LaneId, Message, MessageNonce, Parameter as MessagesParameter,
 };
-use bp_runtime::{Chain, ChainId, MILLAU_CHAIN_ID, RIALTO_CHAIN_ID};
+use bp_runtime::{ChainId, MILLAU_CHAIN_ID, RIALTO_CHAIN_ID};
 use bridge_runtime_common::messages::{
 	self, BasicConfirmationTransactionEstimation, MessageBridge, MessageTransaction,
 };
@@ -96,6 +96,8 @@ impl MessageBridge for WithMillauMessageBridge {
 
 	type ThisChain = Rialto;
 	type BridgedChain = Millau;
+	type BridgedHeaderChain =
+		pallet_bridge_grandpa::GrandpaChainHeaders<Runtime, MillauGrandpaInstance>;
 
 	fn bridged_balance_to_this_balance(
 		bridged_balance: bp_millau::Balance,
@@ -113,18 +115,14 @@ impl MessageBridge for WithMillauMessageBridge {
 pub struct Rialto;
 
 impl messages::ChainWithMessages for Rialto {
-	type Hash = bp_rialto::Hash;
-	type AccountId = bp_rialto::AccountId;
-	type Signer = bp_rialto::AccountSigner;
-	type Signature = bp_rialto::Signature;
-	type Balance = bp_rialto::Balance;
+	type Chain = bp_rialto::Rialto;
 }
 
 impl messages::ThisChainWithMessages for Rialto {
 	type RuntimeOrigin = RuntimeOrigin;
 	type RuntimeCall = RuntimeCall;
 	type ConfirmationTransactionEstimation = BasicConfirmationTransactionEstimation<
-		Self::AccountId,
+		bp_rialto::AccountId,
 		{ bp_rialto::MAX_SINGLE_MESSAGE_DELIVERY_CONFIRMATION_TX_WEIGHT.ref_time() },
 		{ bp_millau::EXTRA_STORAGE_PROOF_SIZE },
 		{ bp_rialto::TX_EXTRA_BYTES },
@@ -175,18 +173,10 @@ impl messages::ThisChainWithMessages for Rialto {
 pub struct Millau;
 
 impl messages::ChainWithMessages for Millau {
-	type Hash = bp_millau::Hash;
-	type AccountId = bp_millau::AccountId;
-	type Signer = bp_millau::AccountSigner;
-	type Signature = bp_millau::Signature;
-	type Balance = bp_millau::Balance;
+	type Chain = bp_millau::Millau;
 }
 
 impl messages::BridgedChainWithMessages for Millau {
-	fn maximal_extrinsic_size() -> u32 {
-		bp_millau::Millau::max_extrinsic_size()
-	}
-
 	fn verify_dispatch_weight(_message_payload: &[u8]) -> bool {
 		true
 	}
@@ -246,11 +236,7 @@ impl TargetHeaderChain<ToMillauMessagePayload, bp_rialto::AccountId> for Millau
 	fn verify_messages_delivery_proof(
 		proof: Self::MessagesDeliveryProof,
 	) -> Result<(LaneId, InboundLaneData<bp_rialto::AccountId>), Self::Error> {
-		messages::source::verify_messages_delivery_proof::<
-			WithMillauMessageBridge,
-			Runtime,
-			crate::MillauGrandpaInstance,
-		>(proof)
+		messages::source::verify_messages_delivery_proof::<WithMillauMessageBridge>(proof)
 	}
 }
 
@@ -267,11 +253,8 @@ impl SourceHeaderChain<bp_millau::Balance> for Millau {
 		proof: Self::MessagesProof,
 		messages_count: u32,
 	) -> Result<ProvedMessages<Message<bp_millau::Balance>>, Self::Error> {
-		messages::target::verify_messages_proof::<
-			WithMillauMessageBridge,
-			Runtime,
-			crate::MillauGrandpaInstance,
-		>(proof, messages_count)
+		messages::target::verify_messages_proof::<WithMillauMessageBridge>(proof, messages_count)
+			.map_err(Into::into)
 	}
 }
 

bridges/bin/runtime-common/Cargo.toml

@@ -15,6 +15,7 @@ static_assertions = { version = "1.1", optional = true }
 
 # Bridge dependencies
 
+bp-header-chain = { path = "../../primitives/header-chain", default-features = false }
 bp-messages = { path = "../../primitives/messages", default-features = false }
 bp-parachains = { path = "../../primitives/parachains", default-features = false }
 bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false }
@@ -47,6 +48,7 @@ millau-runtime = { path = "../millau/runtime" }
 [features]
 default = ["std"]
 std = [
+	"bp-header-chain/std",
 	"bp-messages/std",
 	"bp-parachains/std",
 	"bp-polkadot-core/std",

bridges/bin/runtime-common/src/integrity.rs

@@ -49,36 +49,6 @@ macro_rules! assert_chain_types(
 	}
 );
 
-/// Macro that ensures that the bridge configuration and chain primitives crates are sharing
-/// the same types (hash, account id, ...).
-#[macro_export]
-macro_rules! assert_bridge_types(
-	( bridge: $bridge:path, this_chain: $this:path, bridged_chain: $bridged:path ) => {
-		{
-			// if one of this asserts fail, then all chains, bridged with this chain and bridge relays are now broken
-			//
-			// `frame_support::weights::Weight` is used here directly, because all chains we know are using this
-			// primitive (may be changed in the future)
-			use $crate::messages::{
-				AccountIdOf, BalanceOf, BridgedChain, HashOf, SignatureOf, SignerOf, ThisChain,
-			};
-			use static_assertions::assert_type_eq_all;
-
-			assert_type_eq_all!(HashOf<ThisChain<$bridge>>, bp_runtime::HashOf<$this>);
-			assert_type_eq_all!(AccountIdOf<ThisChain<$bridge>>, bp_runtime::AccountIdOf<$this>);
-			assert_type_eq_all!(SignerOf<ThisChain<$bridge>>, bp_runtime::AccountPublicOf<$this>);
-			assert_type_eq_all!(SignatureOf<ThisChain<$bridge>>, bp_runtime::SignatureOf<$this>);
-			assert_type_eq_all!(BalanceOf<ThisChain<$bridge>>, bp_runtime::BalanceOf<$this>);
-
-			assert_type_eq_all!(HashOf<BridgedChain<$bridge>>, bp_runtime::HashOf<$bridged>);
-			assert_type_eq_all!(AccountIdOf<BridgedChain<$bridge>>, bp_runtime::AccountIdOf<$bridged>);
-			assert_type_eq_all!(SignerOf<BridgedChain<$bridge>>, bp_runtime::AccountPublicOf<$bridged>);
-			assert_type_eq_all!(SignatureOf<BridgedChain<$bridge>>, bp_runtime::SignatureOf<$bridged>);
-			assert_type_eq_all!(BalanceOf<BridgedChain<$bridge>>, bp_runtime::BalanceOf<$bridged>);
-		}
-	}
-);
-
 /// Macro that ensures that the bridge GRANDPA pallet is configured properly to bridge with given
 /// chain.
 #[macro_export]
@@ -145,7 +115,6 @@ macro_rules! assert_complete_bridge_types(
 		bridged_chain: $bridged:path,
 	) => {
 		$crate::assert_chain_types!(runtime: $r, this_chain: $this);
-		$crate::assert_bridge_types!(bridge: $bridge, this_chain: $this, bridged_chain: $bridged);
 		$crate::assert_bridge_grandpa_pallet_types!(
 			runtime: $r,
 			with_bridged_chain_grandpa_instance: $gi,

bridges/bin/runtime-common/src/lib.rs

@@ -28,6 +28,8 @@ pub mod messages_benchmarking;
 pub mod messages_extension;
 pub mod parachains_benchmarking;
 
+mod messages_generation;
+
 #[cfg(feature = "integrity-test")]
 pub mod integrity;
 

bridges/bin/runtime-common/src/messages_benchmarking.rs

@@ -19,14 +19,18 @@
 
 #![cfg(feature = "runtime-benchmarks")]
 
-use crate::messages::{
+use crate::{
+	messages::{
 		source::{FromBridgedChainMessagesDeliveryProof, FromThisChainMessagePayload},
 		target::FromBridgedChainMessagesProof,
-	AccountIdOf, BalanceOf, BridgedChain, CallOf, HashOf, MessageBridge, RawStorageProof,
-	SignatureOf, SignerOf, ThisChain,
+		AccountIdOf, BalanceOf, BridgedChain, CallOf, HashOf, MessageBridge, ThisChain,
+	},
+	messages_generation::{
+		encode_all_messages, encode_lane_data, grow_trie, prepare_messages_storage_proof,
+	},
 };
 
-use bp_messages::{storage_keys, MessageData, MessageKey, MessagePayload};
+use bp_messages::storage_keys;
 use bp_runtime::{record_all_trie_keys, StorageProofSize};
 use codec::Encode;
 use frame_support::{dispatch::GetDispatchInfo, weights::Weight};
@@ -34,7 +38,7 @@ use pallet_bridge_messages::benchmarking::{
 	MessageDeliveryProofParams, MessageParams, MessageProofParams,
 };
 use sp_core::Hasher;
-use sp_runtime::traits::{Header, IdentifyAccount, MaybeSerializeDeserialize, Zero};
+use sp_runtime::traits::{Header, MaybeSerializeDeserialize, Zero};
 use sp_std::{fmt::Debug, prelude::*};
 use sp_trie::{trie_types::TrieDBMutBuilderV1, LayoutV1, MemoryDB, Recorder, TrieMut};
 
@@ -71,10 +75,6 @@ where
 	BalanceOf<ThisChain<B>>: Debug + MaybeSerializeDeserialize,
 	CallOf<ThisChain<B>>: From<frame_system::Call<R>> + GetDispatchInfo,
 	HashOf<BridgedChain<B>>: Copy + Default,
-	SignatureOf<ThisChain<B>>: From<sp_core::ed25519::Signature>,
-	SignerOf<ThisChain<B>>: Clone
-		+ From<sp_core::ed25519::Public>
-		+ IdentifyAccount<AccountId = AccountIdOf<ThisChain<B>>>,
 {
 	let message_payload = match params.size {
 		StorageProofSize::Minimal(ref size) => vec![0u8; *size as _],
@@ -82,8 +82,15 @@ where
 	};
 
 	// finally - prepare storage proof and update environment
-	let (state_root, storage_proof) =
-		prepare_messages_storage_proof::<B, BHH>(&params, message_payload);
+	let (state_root, storage_proof) = prepare_messages_storage_proof::<B>(
+		params.lane,
+		params.message_nonces.clone(),
+		params.outbound_lane_data,
+		params.size,
+		message_payload,
+		encode_all_messages,
+		encode_lane_data,
+	);
 	let (_, bridged_header_hash) = insert_header_to_grandpa_pallet::<R, FI>(state_root);
 
 	(
@@ -141,69 +148,6 @@ where
 	}
 }
 
-/// Prepare storage proof of given messages.
-///
-/// Returns state trie root and nodes with prepared messages.
-fn prepare_messages_storage_proof<B, BHH>(
-	params: &MessageProofParams,
-	message_payload: MessagePayload,
-) -> (HashOf<BridgedChain<B>>, RawStorageProof)
-where
-	B: MessageBridge,
-	BHH: Hasher<Out = HashOf<BridgedChain<B>>>,
-	HashOf<BridgedChain<B>>: Copy + Default,
-{
-	// prepare Bridged chain storage with messages and (optionally) outbound lane state
-	let message_count =
-		params.message_nonces.end().saturating_sub(*params.message_nonces.start()) + 1;
-	let mut storage_keys = Vec::with_capacity(message_count as usize + 1);
-	let mut root = Default::default();
-	let mut mdb = MemoryDB::default();
-	{
-		let mut trie = TrieDBMutBuilderV1::<BHH>::new(&mut mdb, &mut root).build();
-
-		// insert messages
-		for nonce in params.message_nonces.clone() {
-			let message_key = MessageKey { lane_id: params.lane, nonce };
-			let message_data = MessageData {
-				fee: BalanceOf::<BridgedChain<B>>::from(0),
-				payload: message_payload.clone(),
-			};
-			let storage_key = storage_keys::message_key(
-				B::BRIDGED_MESSAGES_PALLET_NAME,
-				&message_key.lane_id,
-				message_key.nonce,
-			)
-			.0;
-			trie.insert(&storage_key, &message_data.encode())
-				.map_err(|_| "TrieMut::insert has failed")
-				.expect("TrieMut::insert should not fail in benchmarks");
-			storage_keys.push(storage_key);
-		}
-
-		// insert outbound lane state
-		if let Some(ref outbound_lane_data) = params.outbound_lane_data {
-			let storage_key =
-				storage_keys::outbound_lane_data_key(B::BRIDGED_MESSAGES_PALLET_NAME, &params.lane)
-					.0;
-			trie.insert(&storage_key, &outbound_lane_data.encode())
-				.map_err(|_| "TrieMut::insert has failed")
-				.expect("TrieMut::insert should not fail in benchmarks");
-			storage_keys.push(storage_key);
-		}
-	}
-	root = grow_trie(root, &mut mdb, params.size);
-
-	// generate storage proof to be delivered to This chain
-	let mut proof_recorder = Recorder::<LayoutV1<BHH>>::new();
-	record_all_trie_keys::<LayoutV1<BHH>, _>(&mdb, &root, &mut proof_recorder)
-		.map_err(|_| "record_all_trie_keys has failed")
-		.expect("record_all_trie_keys should not fail in benchmarks");
-	let storage_proof = proof_recorder.drain().into_iter().map(|n| n.data.to_vec()).collect();
-
-	(root, storage_proof)
-}
-
 /// Insert header to the bridge GRANDPA pallet.
 pub(crate) fn insert_header_to_grandpa_pallet<R, GI>(
 	state_root: bp_runtime::HashOf<R::BridgedChain>,
@@ -225,38 +169,3 @@ where
 	pallet_bridge_grandpa::initialize_for_benchmarks::<R, GI>(bridged_header);
 	(bridged_block_number, bridged_header_hash)
 }
-
-/// Populate trie with dummy keys+values until trie has at least given size.
-pub fn grow_trie<H: Hasher>(
-	mut root: H::Out,
-	mdb: &mut MemoryDB<H>,
-	trie_size: StorageProofSize,
-) -> H::Out {
-	let (iterations, leaf_size, minimal_trie_size) = match trie_size {
-		StorageProofSize::Minimal(_) => return root,
-		StorageProofSize::HasLargeLeaf(size) => (1, size, size),
-		StorageProofSize::HasExtraNodes(size) => (8, 1, size),
-	};
-
-	let mut key_index = 0;
-	loop {
-		// generate storage proof to be delivered to This chain
-		let mut proof_recorder = Recorder::<LayoutV1<H>>::new();
-		record_all_trie_keys::<LayoutV1<H>, _>(mdb, &root, &mut proof_recorder)
-			.map_err(|_| "record_all_trie_keys has failed")
-			.expect("record_all_trie_keys should not fail in benchmarks");
-		let size: usize = proof_recorder.drain().into_iter().map(|n| n.data.len()).sum();
-		if size > minimal_trie_size as _ {
-			return root
-		}
-
-		let mut trie = TrieDBMutBuilderV1::<H>::from_existing(mdb, &mut root).build();
-		for _ in 0..iterations {
-			trie.insert(&key_index.encode(), &vec![42u8; leaf_size as _])
-				.map_err(|_| "TrieMut::insert has failed")
-				.expect("TrieMut::insert should not fail in benchmarks");
-			key_index += 1;
-		}
-		trie.commit();
-	}
-}

bridges/bin/runtime-common/src/messages_generation.rs

@@ -0,0 +1,154 @@
+// Copyright 2019-2022 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Helpers for generating message storage proofs, that are used by tests and by benchmarks.
+
+#![cfg(any(feature = "runtime-benchmarks", test))]
+
+use crate::messages::{BalanceOf, BridgedChain, HashOf, HasherOf, MessageBridge, RawStorageProof};
+
+use bp_messages::{
+	storage_keys, LaneId, MessageData, MessageKey, MessageNonce, MessagePayload, OutboundLaneData,
+};
+use bp_runtime::{record_all_trie_keys, StorageProofSize};
+use codec::Encode;
+use sp_core::Hasher;
+use sp_runtime::traits::Zero;
+use sp_std::{ops::RangeInclusive, prelude::*};
+use sp_trie::{trie_types::TrieDBMutBuilderV1, LayoutV1, MemoryDB, Recorder, TrieMut};
+
+/// Simple and correct message data encode function.
+pub(crate) fn encode_all_messages<B: Encode>(
+	_: MessageNonce,
+	m: &MessageData<B>,
+) -> Option<Vec<u8>> {
+	Some(m.encode())
+}
+
+/// Simple and correct outbound lane data encode function.
+pub(crate) fn encode_lane_data(d: &OutboundLaneData) -> Vec<u8> {
+	d.encode()
+}
+
+/// Prepare storage proof of given messages.
+///
+/// Returns state trie root and nodes with prepared messages.
+pub(crate) fn prepare_messages_storage_proof<B>(
+	lane: LaneId,
+	message_nonces: RangeInclusive<MessageNonce>,
+	outbound_lane_data: Option<OutboundLaneData>,
+	size: StorageProofSize,
+	message_payload: MessagePayload,
+	encode_message: impl Fn(MessageNonce, &MessageData<BalanceOf<BridgedChain<B>>>) -> Option<Vec<u8>>,
+	encode_outbound_lane_data: impl Fn(&OutboundLaneData) -> Vec<u8>,
+) -> (HashOf<BridgedChain<B>>, RawStorageProof)
+where
+	B: MessageBridge,
+	HashOf<BridgedChain<B>>: Copy + Default,
+{
+	// prepare Bridged chain storage with messages and (optionally) outbound lane state
+	let message_count = message_nonces.end().saturating_sub(*message_nonces.start()) + 1;
+	let mut storage_keys = Vec::with_capacity(message_count as usize + 1);
+	let mut root = Default::default();
+	let mut mdb = MemoryDB::default();
+	{
+		let mut trie =
+			TrieDBMutBuilderV1::<HasherOf<BridgedChain<B>>>::new(&mut mdb, &mut root).build();
+
+		// insert messages
+		for nonce in message_nonces {
+			let message_key = MessageKey { lane_id: lane, nonce };
+			let message_data = MessageData {
+				fee: BalanceOf::<BridgedChain<B>>::zero(),
+				payload: message_payload.clone(),
+			};
+			let message_data = match encode_message(nonce, &message_data) {
+				Some(message_data) => message_data,
+				None => continue,
+			};
+			let storage_key = storage_keys::message_key(
+				B::BRIDGED_MESSAGES_PALLET_NAME,
+				&message_key.lane_id,
+				message_key.nonce,
+			)
+			.0;
+			trie.insert(&storage_key, &message_data)
+				.map_err(|_| "TrieMut::insert has failed")
+				.expect("TrieMut::insert should not fail in benchmarks");
+			storage_keys.push(storage_key);
+		}
+
+		// insert outbound lane state
+		if let Some(outbound_lane_data) = outbound_lane_data.as_ref().map(encode_outbound_lane_data)
+		{
+			let storage_key =
+				storage_keys::outbound_lane_data_key(B::BRIDGED_MESSAGES_PALLET_NAME, &lane).0;
+			trie.insert(&storage_key, &outbound_lane_data)
+				.map_err(|_| "TrieMut::insert has failed")
+				.expect("TrieMut::insert should not fail in benchmarks");
+			storage_keys.push(storage_key);
+		}
+	}
+	root = grow_trie(root, &mut mdb, size);
+
+	// generate storage proof to be delivered to This chain
+	let mut proof_recorder = Recorder::<LayoutV1<HasherOf<BridgedChain<B>>>>::new();
+	record_all_trie_keys::<LayoutV1<HasherOf<BridgedChain<B>>>, _>(
+		&mdb,
+		&root,
+		&mut proof_recorder,
+	)
+	.map_err(|_| "record_all_trie_keys has failed")
+	.expect("record_all_trie_keys should not fail in benchmarks");
+	let storage_proof = proof_recorder.drain().into_iter().map(|n| n.data.to_vec()).collect();
+
+	(root, storage_proof)
+}
+
+/// Populate trie with dummy keys+values until trie has at least given size.
+pub fn grow_trie<H: Hasher>(
+	mut root: H::Out,
+	mdb: &mut MemoryDB<H>,
+	trie_size: StorageProofSize,
+) -> H::Out {
+	let (iterations, leaf_size, minimal_trie_size) = match trie_size {
+		StorageProofSize::Minimal(_) => return root,
+		StorageProofSize::HasLargeLeaf(size) => (1, size, size),
+		StorageProofSize::HasExtraNodes(size) => (8, 1, size),
+	};
+
+	let mut key_index = 0;
+	loop {
+		// generate storage proof to be delivered to This chain
+		let mut proof_recorder = Recorder::<LayoutV1<H>>::new();
+		record_all_trie_keys::<LayoutV1<H>, _>(mdb, &root, &mut proof_recorder)
+			.map_err(|_| "record_all_trie_keys has failed")
+			.expect("record_all_trie_keys should not fail in benchmarks");
+		let size: usize = proof_recorder.drain().into_iter().map(|n| n.data.len()).sum();
+		if size > minimal_trie_size as _ {
+			return root
+		}
+
+		let mut trie = TrieDBMutBuilderV1::<H>::from_existing(mdb, &mut root).build();
+		for _ in 0..iterations {
+			trie.insert(&key_index.encode(), &vec![42u8; leaf_size as _])
+				.map_err(|_| "TrieMut::insert has failed")
+				.expect("TrieMut::insert should not fail in benchmarks");
+			key_index += 1;
+		}
+		trie.commit();
+	}
+}

bridges/bin/runtime-common/src/parachains_benchmarking.rs

@@ -18,7 +18,9 @@
 
 #![cfg(feature = "runtime-benchmarks")]
 
-use crate::messages_benchmarking::{grow_trie, insert_header_to_grandpa_pallet};
+use crate::{
+	messages_benchmarking::insert_header_to_grandpa_pallet, messages_generation::grow_trie,
+};
 
 use bp_parachains::parachain_head_storage_key_at_source;
 use bp_polkadot_core::parachains::{ParaHash, ParaHead, ParaHeadsProof, ParaId};

bridges/modules/grandpa/src/lib.rs

@@ -38,7 +38,7 @@
 
 use storage_types::StoredAuthoritySet;
 
-use bp_header_chain::{justification::GrandpaJustification, InitializationData};
+use bp_header_chain::{justification::GrandpaJustification, HeaderChain, InitializationData};
 use bp_runtime::{
 	BlockNumberOf, BoundedStorageValue, Chain, HashOf, HasherOf, HeaderOf, OwnedBridgeModule,
 };
@@ -67,6 +67,8 @@ pub use weights::WeightInfo;
 /// The target that will be used when publishing logs related to this pallet.
 pub const LOG_TARGET: &str = "runtime::bridge-grandpa";
 
+/// Bridged chain from the pallet configuration.
+pub type BridgedChain<T, I> = <T as Config<I>>::BridgedChain;
 /// Block number of the bridged chain.
 pub type BridgedBlockNumber<T, I> = BlockNumberOf<<T as Config<I>>::BridgedChain>;
 /// Block hash of the bridged chain.
@@ -382,8 +384,6 @@ pub mod pallet {
 		TooManyRequests,
 		/// The header being imported is older than the best finalized header known to the pallet.
 		OldHeader,
-		/// The header is unknown to the pallet.
-		UnknownHeader,
 		/// The scheduled authority set change found in the header is unsupported by the pallet.
 		///
 		/// This is the case for non-standard (e.g forced) authority set changes.
@@ -392,8 +392,6 @@ pub mod pallet {
 		NotInitialized,
 		/// The pallet has already been initialized.
 		AlreadyInitialized,
-		/// The storage proof doesn't contains storage root. So it is invalid for given header.
-		StorageRootMismatch,
 		/// Too many authorities in the set.
 		TooManyAuthoritiesInSet,
 		/// Too large header.
@@ -581,9 +579,6 @@ pub mod pallet {
 
 impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	/// Get the best finalized header the pallet knows of.
-	///
-	/// Returns a dummy header if there is no best header. This can only happen
-	/// if the pallet has not been initialized yet.
 	pub fn best_finalized() -> Option<BridgedHeader<T, I>> {
 		let (_, hash) = <BestFinalized<T, I>>::get()?;
 		<ImportedHeaders<T, I>>::get(hash).map(|h| h.into_inner())
@@ -593,21 +588,14 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 	pub fn is_known_header(hash: BridgedBlockHash<T, I>) -> bool {
 		<ImportedHeaders<T, I>>::contains_key(hash)
 	}
+}
 
-	/// Verify that the passed storage proof is valid, given it is crafted using
-	/// known finalized header. If the proof is valid, then the `parse` callback
-	/// is called and the function returns its result.
-	pub fn parse_finalized_storage_proof<R>(
-		hash: BridgedBlockHash<T, I>,
-		storage_proof: sp_trie::StorageProof,
-		parse: impl FnOnce(bp_runtime::StorageProofChecker<BridgedBlockHasher<T, I>>) -> R,
-	) -> Result<R, sp_runtime::DispatchError> {
-		let header = <ImportedHeaders<T, I>>::get(hash).ok_or(Error::<T, I>::UnknownHeader)?;
-		let storage_proof_checker =
-			bp_runtime::StorageProofChecker::new(*header.state_root(), storage_proof)
-				.map_err(|_| Error::<T, I>::StorageRootMismatch)?;
+/// Bridge GRANDPA pallet as header chain.
+pub type GrandpaChainHeaders<T, I> = Pallet<T, I>;
 
-		Ok(parse(storage_proof_checker))
+impl<T: Config<I>, I: 'static> HeaderChain<BridgedChain<T, I>> for GrandpaChainHeaders<T, I> {
+	fn finalized_header(hash: HashOf<BridgedChain<T, I>>) -> Option<HeaderOf<BridgedChain<T, I>>> {
+		ImportedHeaders::<T, I>::get(hash).map(|h| h.into_inner())
 	}
 }
 
@@ -1119,7 +1107,7 @@ mod tests {
 					sp_trie::StorageProof::new(vec![]),
 					|_| (),
 				),
-				Error::<TestRuntime>::UnknownHeader,
+				bp_header_chain::HeaderChainError::UnknownHeader,
 			);
 		});
 	}

bridges/modules/parachains/Cargo.toml

@@ -12,6 +12,7 @@ scale-info = { version = "2.1.1", default-features = false, features = ["derive"
 
 # Bridge Dependencies
 
+bp-header-chain = { path = "../../primitives/header-chain", default-features = false }
 bp-parachains = { path = "../../primitives/parachains", default-features = false }
 bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false }
 bp-runtime = { path = "../../primitives/runtime", default-features = false }
@@ -34,6 +35,7 @@ sp-io = { git = "https://github.com/paritytech/substrate", branch = "master" }
 [features]
 default = ["std"]
 std = [
+	"bp-header-chain/std",
 	"bp-parachains/std",
 	"bp-polkadot-core/std",
 	"bp-runtime/std",

bridges/modules/parachains/src/lib.rs

@@ -26,12 +26,14 @@
 pub use weights::WeightInfo;
 pub use weights_ext::WeightInfoExt;
 
+use bp_header_chain::HeaderChain;
 use bp_parachains::{parachain_head_storage_key_at_source, ParaInfo};
-use bp_polkadot_core::parachains::{ParaHash, ParaHasher, ParaHead, ParaHeadsProof, ParaId};
-use bp_runtime::StorageProofError;
+use bp_polkadot_core::parachains::{ParaHash, ParaHead, ParaHeadsProof, ParaId};
+use bp_runtime::{HashOf, HeaderOf, Parachain, StorageProofError};
+use codec::Decode;
 use frame_support::{dispatch::PostDispatchInfo, traits::Contains};
 use sp_runtime::traits::Header as HeaderT;
-use sp_std::vec::Vec;
+use sp_std::{marker::PhantomData, vec::Vec};
 
 // Re-export in crate namespace for `construct_runtime!`.
 pub use pallet::*;
@@ -410,27 +412,6 @@ pub mod pallet {
 			ImportedParaHeads::<T, I>::get(parachain, hash).map(|h| h.into_inner())
 		}
 
-		/// Verify that the passed storage proof is valid, given it is crafted using
-		/// known finalized header. If the proof is valid, then the `parse` callback
-		/// is called and the function returns its result.
-		pub fn parse_finalized_storage_proof<R>(
-			parachain: ParaId,
-			hash: ParaHash,
-			storage_proof: sp_trie::StorageProof,
-			decode_state_root: impl FnOnce(ParaHead) -> Option<ParaHash>,
-			parse: impl FnOnce(bp_runtime::StorageProofChecker<ParaHasher>) -> R,
-		) -> Result<R, sp_runtime::DispatchError> {
-			let para_head =
-				Self::parachain_head(parachain, hash).ok_or(Error::<T, I>::UnknownParaHead)?;
-			let state_root =
-				decode_state_root(para_head).ok_or(Error::<T, I>::FailedToExtractStateRoot)?;
-			let storage_proof_checker =
-				bp_runtime::StorageProofChecker::new(state_root, storage_proof)
-					.map_err(|_| Error::<T, I>::StorageRootMismatch)?;
-
-			Ok(parse(storage_proof_checker))
-		}
-
 		/// Read parachain head from storage proof.
 		fn read_parachain_head(
 			storage: &bp_runtime::StorageProofChecker<RelayBlockHasher>,
@@ -617,6 +598,18 @@ pub mod pallet {
 	}
 }
 
+/// Single parachain header chain adapter.
+pub struct ParachainHeaders<T, I, C>(PhantomData<(T, I, C)>);
+
+impl<T: Config<I>, I: 'static, C: Parachain<Hash = ParaHash>> HeaderChain<C>
+	for ParachainHeaders<T, I, C>
+{
+	fn finalized_header(hash: HashOf<C>) -> Option<HeaderOf<C>> {
+		Pallet::<T, I>::parachain_head(ParaId(C::PARACHAIN_ID), hash)
+			.and_then(|head| Decode::decode(&mut &head.0[..]).ok())
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;

bridges/primitives/chain-rialto-parachain/src/lib.rs

@@ -21,7 +21,7 @@
 use bp_messages::{
 	InboundMessageDetails, LaneId, MessageNonce, MessagePayload, OutboundMessageDetails,
 };
-use bp_runtime::{decl_bridge_runtime_apis, Chain};
+use bp_runtime::{decl_bridge_runtime_apis, Chain, Parachain};
 use frame_support::{
 	dispatch::DispatchClass,
 	weights::{constants::WEIGHT_PER_SECOND, IdentityFee, Weight},
@@ -160,6 +160,10 @@ impl Chain for RialtoParachain {
 	}
 }
 
+impl Parachain for RialtoParachain {
+	const PARACHAIN_ID: u32 = RIALTO_PARACHAIN_ID;
+}
+
 frame_support::parameter_types! {
 	pub BlockLength: limits::BlockLength =
 		limits::BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);

bridges/primitives/header-chain/Cargo.toml

@@ -23,6 +23,7 @@ sp-core = { git = "https://github.com/paritytech/substrate", branch = "master",
 sp-finality-grandpa = { git = "https://github.com/paritytech/substrate", branch = "master", default-features = false }
 sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "master", default-features = false }
 sp-std = { git = "https://github.com/paritytech/substrate", branch = "master", default-features = false }
+sp-trie = { git = "https://github.com/paritytech/substrate", branch = "master", default-features = false }
 
 [dev-dependencies]
 bp-test-utils = { path = "../test-utils" }
@@ -42,4 +43,5 @@ std = [
 	"sp-finality-grandpa/std",
 	"sp-runtime/std",
 	"sp-std/std",
+	"sp-trie/std",
 ]

bridges/primitives/header-chain/src/lib.rs

@@ -19,19 +19,58 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use bp_runtime::BasicOperatingMode;
+use bp_runtime::{BasicOperatingMode, Chain, HashOf, HasherOf, HeaderOf, StorageProofChecker};
 use codec::{Codec, Decode, Encode, EncodeLike};
 use core::{clone::Clone, cmp::Eq, default::Default, fmt::Debug};
+use frame_support::PalletError;
 use scale_info::TypeInfo;
 #[cfg(feature = "std")]
 use serde::{Deserialize, Serialize};
 use sp_finality_grandpa::{AuthorityList, ConsensusLog, SetId, GRANDPA_ENGINE_ID};
 use sp_runtime::{traits::Header as HeaderT, Digest, RuntimeDebug};
 use sp_std::boxed::Box;
+use sp_trie::StorageProof;
 
 pub mod justification;
 pub mod storage_keys;
 
+/// Header chain error.
+#[derive(Clone, Copy, Decode, Encode, Eq, PalletError, PartialEq, RuntimeDebug, TypeInfo)]
+pub enum HeaderChainError {
+	/// Header with given hash is missing from the chain.
+	UnknownHeader,
+	/// The storage proof doesn't contains storage root.
+	StorageRootMismatch,
+}
+
+impl From<HeaderChainError> for &'static str {
+	fn from(err: HeaderChainError) -> &'static str {
+		match err {
+			HeaderChainError::UnknownHeader => "UnknownHeader",
+			HeaderChainError::StorageRootMismatch => "StorageRootMismatch",
+		}
+	}
+}
+
+/// Substrate header chain, abstracted from the way it is stored.
+pub trait HeaderChain<C: Chain> {
+	/// Returns finalized header by its hash.
+	fn finalized_header(hash: HashOf<C>) -> Option<HeaderOf<C>>;
+	/// Parse storage proof using finalized header.
+	fn parse_finalized_storage_proof<R>(
+		hash: HashOf<C>,
+		storage_proof: StorageProof,
+		parse: impl FnOnce(StorageProofChecker<HasherOf<C>>) -> R,
+	) -> Result<R, HeaderChainError> {
+		let header = Self::finalized_header(hash).ok_or(HeaderChainError::UnknownHeader)?;
+		let storage_proof_checker =
+			bp_runtime::StorageProofChecker::new(*header.state_root(), storage_proof)
+				.map_err(|_| HeaderChainError::StorageRootMismatch)?;
+
+		Ok(parse(storage_proof_checker))
+	}
+}
+
 /// A type that can be used as a parameter in a dispatchable function.
 ///
 /// When using `decl_module` all arguments for call functions must implement this trait.
@@ -79,6 +118,7 @@ pub trait FinalityProof<Number>: Clone + Send + Sync + Debug {
 
 /// A trait that provides helper methods for querying the consensus log.
 pub trait ConsensusLogReader {
+	/// Returns true if digest contains item that schedules authorities set change.
 	fn schedules_authorities_change(digest: &Digest) -> bool;
 }
 

bridges/primitives/runtime/src/chain.rs

@@ -195,6 +195,12 @@ pub trait Chain: Send + Sync + 'static {
 	fn max_extrinsic_weight() -> Weight;
 }
 
+/// Minimal parachain representation that may be used from no_std environment.
+pub trait Parachain: Chain {
+	/// Parachain identifier.
+	const PARACHAIN_ID: u32;
+}
+
 /// Block number used by the chain.
 pub type BlockNumberOf<C> = <C as Chain>::BlockNumber;
 

bridges/primitives/runtime/src/lib.rs

@@ -32,7 +32,7 @@ use sp_std::{convert::TryFrom, fmt::Debug, vec, vec::Vec};
 
 pub use chain::{
 	AccountIdOf, AccountPublicOf, BalanceOf, BlockNumberOf, Chain, EncodedOrDecodedCall, HashOf,
-	HasherOf, HeaderOf, IndexOf, SignatureOf, TransactionEraOf,
+	HasherOf, HeaderOf, IndexOf, Parachain, SignatureOf, TransactionEraOf,
 };
 pub use frame_support::storage::storage_prefix as storage_value_final_key;
 use num_traits::{CheckedSub, One};