Integrate message-lane module RPCs into Rialto/Millau nodes (parityte…

…ch#458)

* integrate message-lane RPCs into Millau and Rialto runtime

* fmt

* use instance in InboundLanes

* moved RialtoMessageLaneKeys/MillauMessageLaneKeys inside rpc_extensions_builder to ease Substrate refs update

bridges/bin/millau/node/Cargo.toml

@@ -14,8 +14,12 @@ jsonrpc-core = "15.1.0"
 structopt = "0.3.20"
 
 # Bridge dependencies
+
+bp-message-lane = { path = "../../../primitives/message-lane" }
 bp-rialto = { path = "../../../primitives/rialto" }
+bp-runtime = { path = "../../../primitives/runtime" }
 millau-runtime = { path = "../runtime" }
+pallet-message-lane-rpc = { path = "../../../modules/message-lane/rpc" }
 
 # Substrate Dependencies
 

bridges/bin/millau/node/src/service.rs

@@ -28,6 +28,8 @@
 // =====================================================================================
 // =====================================================================================
 
+use bp_message_lane::{LaneId, MessageNonce};
+use bp_runtime::{InstanceId, RIALTO_BRIDGE_INSTANCE};
 use millau_runtime::{self, opaque::Block, RuntimeApi};
 use sc_client_api::{ExecutorProvider, RemoteBackend};
 use sc_executor::native_executor_instance;
@@ -36,6 +38,7 @@ use sc_finality_grandpa::{FinalityProofProvider as GrandpaFinalityProofProvider,
 use sc_finality_grandpa_rpc::GrandpaRpcHandler;
 use sc_service::{error::Error as ServiceError, Configuration, TaskManager};
 use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
+use sp_core::storage::StorageKey;
 use sp_inherents::InherentDataProviders;
 use std::sync::Arc;
 use std::time::Duration;
@@ -161,10 +164,40 @@ pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
 	let telemetry_connection_sinks = sc_service::TelemetryConnectionSinks::default();
 
 	let rpc_extensions_builder = {
+		// This struct is here to ease update process.
+
+		/// Millau runtime from message-lane RPC point of view.
+		struct MillauMessageLaneKeys;
+
+		impl pallet_message_lane_rpc::Runtime for MillauMessageLaneKeys {
+			fn message_key(&self, instance: &InstanceId, lane: &LaneId, nonce: MessageNonce) -> Option<StorageKey> {
+				match *instance {
+					RIALTO_BRIDGE_INSTANCE => Some(millau_runtime::rialto_messages::message_key(lane, nonce)),
+					_ => None,
+				}
+			}
+
+			fn outbound_lane_data_key(&self, instance: &InstanceId, lane: &LaneId) -> Option<StorageKey> {
+				match *instance {
+					RIALTO_BRIDGE_INSTANCE => Some(millau_runtime::rialto_messages::outbound_lane_data_key(lane)),
+					_ => None,
+				}
+			}
+
+			fn inbound_lane_data_key(&self, instance: &InstanceId, lane: &LaneId) -> Option<StorageKey> {
+				match *instance {
+					RIALTO_BRIDGE_INSTANCE => Some(millau_runtime::rialto_messages::inbound_lane_data_key(lane)),
+					_ => None,
+				}
+			}
+		}
+
+		use pallet_message_lane_rpc::{MessageLaneApi, MessageLaneRpcHandler};
 		use sc_finality_grandpa_rpc::GrandpaApi;
 		use sc_rpc::DenyUnsafe;
 		use substrate_frame_rpc_system::{FullSystem, SystemApi};
 
+		let backend = backend.clone();
 		let client = client.clone();
 		let pool = transaction_pool.clone();
 
@@ -188,6 +221,10 @@ pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
 				subscription_executor,
 				finality_proof_provider.clone(),
 			)));
+			io.extend_with(MessageLaneApi::to_delegate(MessageLaneRpcHandler::new(
+				backend.clone(),
+				Arc::new(MillauMessageLaneKeys),
+			)));
 
 			io
 		})

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

@@ -16,21 +16,41 @@
 
 //! Everything required to serve Millau <-> Rialto message lanes.
 
-use bridge_runtime_common::messages;
+use crate::Runtime;
 
 use bp_message_lane::{
 	source_chain::TargetHeaderChain,
 	target_chain::{ProvedMessages, SourceHeaderChain},
-	InboundLaneData, LaneId, Message, MessageNonce,
+	InboundLaneData, LaneId, Message, MessageKey, MessageNonce,
 };
 use bp_runtime::InstanceId;
-use bridge_runtime_common::messages::MessageBridge;
+use bridge_runtime_common::messages::{self, MessageBridge};
 use frame_support::{
+	storage::generator::StorageMap,
 	weights::{Weight, WeightToFeePolynomial},
 	RuntimeDebug,
 };
+use pallet_message_lane::{DefaultInstance, InboundLanes, OutboundLanes, OutboundMessages};
+use sp_core::storage::StorageKey;
 use sp_trie::StorageProof;
 
+/// Storage key of the Millau -> Rialto message in the runtime storage.
+pub fn message_key(lane: &LaneId, nonce: MessageNonce) -> StorageKey {
+	let message_key = MessageKey { lane_id: *lane, nonce };
+	let raw_storage_key = OutboundMessages::<Runtime, DefaultInstance>::storage_map_final_key(message_key);
+	StorageKey(raw_storage_key)
+}
+
+/// Storage key of the Millau -> Rialto message lane state in the runtime storage.
+pub fn outbound_lane_data_key(lane: &LaneId) -> StorageKey {
+	StorageKey(OutboundLanes::<DefaultInstance>::storage_map_final_key(*lane))
+}
+
+/// Storage key of the Rialto -> Millau message lane state in the runtime storage.
+pub fn inbound_lane_data_key(lane: &LaneId) -> StorageKey {
+	StorageKey(InboundLanes::<Runtime, DefaultInstance>::storage_map_final_key(*lane))
+}
+
 /// Message payload for Millau -> Rialto messages.
 pub type ToRialtoMessagePayload = messages::source::FromThisChainMessagePayload<WithRialtoMessageBridge>;
 

bridges/bin/rialto/node/Cargo.toml

@@ -15,6 +15,8 @@ structopt = "0.3.20"
 
 # Bridge dependencies
 
+bp-message-lane = { path = "../../../primitives/message-lane" }
+bp-runtime = { path = "../../../primitives/runtime" }
 pallet-message-lane-rpc = { path = "../../../modules/message-lane/rpc" }
 rialto-runtime = { path = "../runtime" }
 

bridges/bin/rialto/node/src/service.rs

@@ -28,13 +28,16 @@
 // =====================================================================================
 // =====================================================================================
 
+use bp_message_lane::{LaneId, MessageNonce};
+use bp_runtime::{InstanceId, MILLAU_BRIDGE_INSTANCE};
 use rialto_runtime::{self, opaque::Block, RuntimeApi};
 use sc_client_api::{ExecutorProvider, RemoteBackend};
 use sc_executor::native_executor_instance;
 pub use sc_executor::NativeExecutor;
 use sc_finality_grandpa::{FinalityProofProvider as GrandpaFinalityProofProvider, SharedVoterState};
 use sc_service::{error::Error as ServiceError, Configuration, TaskManager};
 use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
+use sp_core::storage::StorageKey;
 use sp_inherents::InherentDataProviders;
 use std::sync::Arc;
 use std::time::Duration;
@@ -160,9 +163,38 @@ pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
 	let telemetry_connection_sinks = sc_service::TelemetryConnectionSinks::default();
 
 	let rpc_extensions_builder = {
+		// This struct is here to ease update process.
+
+		/// Rialto runtime from message-lane RPC point of view.
+		struct RialtoMessageLaneKeys;
+
+		impl pallet_message_lane_rpc::Runtime for RialtoMessageLaneKeys {
+			fn message_key(&self, instance: &InstanceId, lane: &LaneId, nonce: MessageNonce) -> Option<StorageKey> {
+				match *instance {
+					MILLAU_BRIDGE_INSTANCE => Some(rialto_runtime::millau_messages::message_key(lane, nonce)),
+					_ => None,
+				}
+			}
+
+			fn outbound_lane_data_key(&self, instance: &InstanceId, lane: &LaneId) -> Option<StorageKey> {
+				match *instance {
+					MILLAU_BRIDGE_INSTANCE => Some(rialto_runtime::millau_messages::outbound_lane_data_key(lane)),
+					_ => None,
+				}
+			}
+
+			fn inbound_lane_data_key(&self, instance: &InstanceId, lane: &LaneId) -> Option<StorageKey> {
+				match *instance {
+					MILLAU_BRIDGE_INSTANCE => Some(rialto_runtime::millau_messages::inbound_lane_data_key(lane)),
+					_ => None,
+				}
+			}
+		}
+
+		use pallet_message_lane_rpc::{MessageLaneApi, MessageLaneRpcHandler};
 		use sc_rpc::DenyUnsafe;
 		use substrate_frame_rpc_system::{FullSystem, SystemApi};
-
+		let backend = backend.clone();
 		let client = client.clone();
 		let pool = transaction_pool.clone();
 
@@ -173,6 +205,10 @@ pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
 				pool.clone(),
 				DenyUnsafe::No,
 			)));
+			io.extend_with(MessageLaneApi::to_delegate(MessageLaneRpcHandler::new(
+				backend.clone(),
+				Arc::new(RialtoMessageLaneKeys),
+			)));
 
 			io
 		})

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

@@ -16,21 +16,41 @@
 
 //! Everything required to serve Millau <-> Rialto message lanes.
 
-use bridge_runtime_common::messages;
+use crate::Runtime;
 
 use bp_message_lane::{
 	source_chain::TargetHeaderChain,
 	target_chain::{ProvedMessages, SourceHeaderChain},
-	InboundLaneData, LaneId, Message, MessageNonce,
+	InboundLaneData, LaneId, Message, MessageKey, MessageNonce,
 };
 use bp_runtime::InstanceId;
-use bridge_runtime_common::messages::MessageBridge;
+use bridge_runtime_common::messages::{self, MessageBridge};
 use frame_support::{
+	storage::generator::StorageMap,
 	weights::{Weight, WeightToFeePolynomial},
 	RuntimeDebug,
 };
+use pallet_message_lane::{DefaultInstance, InboundLanes, OutboundLanes, OutboundMessages};
+use sp_core::storage::StorageKey;
 use sp_trie::StorageProof;
 
+/// Storage key of the Rialto -> Millau message in the runtime storage.
+pub fn message_key(lane: &LaneId, nonce: MessageNonce) -> StorageKey {
+	let message_key = MessageKey { lane_id: *lane, nonce };
+	let raw_storage_key = OutboundMessages::<Runtime, DefaultInstance>::storage_map_final_key(message_key);
+	StorageKey(raw_storage_key)
+}
+
+/// Storage key of the Rialto -> Millau message lane state in the runtime storage.
+pub fn outbound_lane_data_key(lane: &LaneId) -> StorageKey {
+	StorageKey(OutboundLanes::<DefaultInstance>::storage_map_final_key(*lane))
+}
+
+/// Storage key of the Millau -> Rialto message lane state in the runtime storage.
+pub fn inbound_lane_data_key(lane: &LaneId) -> StorageKey {
+	StorageKey(InboundLanes::<Runtime, DefaultInstance>::storage_map_final_key(*lane))
+}
+
 /// Message payload for Rialto -> Millau messages.
 pub type ToMillauMessagePayload = messages::source::FromThisChainMessagePayload<WithMillauMessageBridge>;
 

bridges/modules/message-lane/src/lib.rs

@@ -138,11 +138,11 @@ decl_error! {
 decl_storage! {
 	trait Store for Module<T: Trait<I>, I: Instance = DefaultInstance> as MessageLane {
 		/// Map of lane id => inbound lane data.
-		InboundLanes: map hasher(blake2_128_concat) LaneId => InboundLaneData<T::InboundRelayer>;
+		pub InboundLanes: map hasher(blake2_128_concat) LaneId => InboundLaneData<T::InboundRelayer>;
 		/// Map of lane id => outbound lane data.
-		OutboundLanes: map hasher(blake2_128_concat) LaneId => OutboundLaneData;
+		pub OutboundLanes: map hasher(blake2_128_concat) LaneId => OutboundLaneData;
 		/// All queued outbound messages.
-		OutboundMessages: map hasher(blake2_128_concat) MessageKey => Option<MessageData<T::OutboundMessageFee>>;
+		pub OutboundMessages: map hasher(blake2_128_concat) MessageKey => Option<MessageData<T::OutboundMessageFee>>;
 	}
 }
 

bridges/primitives/runtime/src/lib.rs

@@ -28,6 +28,12 @@ mod chain;
 /// Use this when something must be shared among all instances.
 pub const NO_INSTANCE_ID: InstanceId = [0, 0, 0, 0];
 
+/// Bridge-with-Rialto instance id.
+pub const RIALTO_BRIDGE_INSTANCE: InstanceId = *b"rlto";
+
+/// Bridge-with-Millau instance id.
+pub const MILLAU_BRIDGE_INSTANCE: InstanceId = *b"mlau";
+
 /// Call-dispatch module prefix.
 pub const CALL_DISPATCH_MODULE_PREFIX: &[u8] = b"pallet-bridge/call-dispatch";