remove redundant data from runtime calls and rename confusing runtime apis

Author: vedhavyas

crates/subspace-fake-runtime-api/src/lib.rs

@@ -17,7 +17,7 @@ use sp_domains_fraud_proof::fraud_proof::FraudProof;
 use sp_domains_fraud_proof::storage_proof::FraudProofStorageKeyRequest;
 use sp_messenger::messages::{
     BlockMessagesQuery, BlockMessagesWithStorageKey, ChainId, ChannelId, ChannelStateWithNonce,
-    CrossDomainMessage, MessageId, MessageKey, Nonce as XdmNonce,
+    CrossDomainMessage, MessageId, MessageKey, MessagesWithStorageKey, Nonce as XdmNonce,
 };
 use sp_messenger::{ChannelNonce, XdmId};
 use sp_runtime::traits::NumberFor;
@@ -414,19 +414,19 @@ sp_api::impl_runtime_apis! {
             unreachable!()
         }
 
-        fn block_messages_with_query(_: BlockMessagesQuery) -> BlockMessagesWithStorageKey {
+        fn block_messages_with_query(_: BlockMessagesQuery) -> MessagesWithStorageKey {
             unreachable!()
         }
 
         fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelStateWithNonce)> {
             unreachable!()
         }
 
-        fn should_relay_outbox_messages(_: ChainId, _: ChannelId, _: XdmNonce) -> Option<XdmNonce> {
+        fn first_outbox_message_nonce_to_relay(_: ChainId, _: ChannelId, _: XdmNonce) -> Option<XdmNonce> {
             unreachable!()
         }
 
-        fn should_relay_inbox_message_responses(_: ChainId, _: ChannelId, _: XdmNonce) -> Option<XdmNonce> {
+        fn first_inbox_message_response_nonce_to_relay(_: ChainId, _: ChannelId, _: XdmNonce) -> Option<XdmNonce> {
             unreachable!()
         }
     }

crates/subspace-runtime/src/lib.rs

@@ -72,7 +72,7 @@ use sp_domains_fraud_proof::storage_proof::{
 use sp_messenger::endpoint::{Endpoint, EndpointHandler as EndpointHandlerT, EndpointId};
 use sp_messenger::messages::{
     BlockMessagesQuery, BlockMessagesWithStorageKey, ChainId, ChannelStateWithNonce,
-    CrossDomainMessage, MessageId, MessageKey, Nonce as XdmNonce,
+    CrossDomainMessage, MessageId, MessageKey, MessagesWithStorageKey, Nonce as XdmNonce,
 };
 use sp_messenger::{ChannelNonce, XdmId};
 use sp_messenger_host_functions::{get_storage_key, StorageKeyRequest};
@@ -1704,20 +1704,20 @@ impl_runtime_apis! {
             Messenger::open_channels()
         }
 
-        fn block_messages_with_query(query: BlockMessagesQuery) -> BlockMessagesWithStorageKey {
+        fn block_messages_with_query(query: BlockMessagesQuery) -> MessagesWithStorageKey {
             Messenger::get_block_messages(query)
         }
 
         fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelStateWithNonce)> {
             Messenger::channels_and_states()
         }
 
-        fn should_relay_outbox_messages(dst_chain_id: ChainId, channel_id: ChannelId, from_nonce: XdmNonce) -> Option<XdmNonce> {
-            Messenger::should_relay_outbox_messages(dst_chain_id, channel_id, from_nonce)
+        fn first_outbox_message_nonce_to_relay(dst_chain_id: ChainId, channel_id: ChannelId, from_nonce: XdmNonce) -> Option<XdmNonce> {
+            Messenger::first_outbox_message_nonce_to_relay(dst_chain_id, channel_id, from_nonce)
         }
 
-        fn should_relay_inbox_message_responses(dst_chain_id: ChainId, channel_id: ChannelId, from_nonce: XdmNonce) -> Option<XdmNonce> {
-            Messenger::should_relay_inbox_message_responses(dst_chain_id, channel_id, from_nonce)
+        fn first_inbox_message_response_nonce_to_relay(dst_chain_id: ChainId, channel_id: ChannelId, from_nonce: XdmNonce) -> Option<XdmNonce> {
+            Messenger::first_inbox_message_response_nonce_to_relay(dst_chain_id, channel_id, from_nonce)
         }
     }
 

domains/client/relayer/src/lib.rs

@@ -22,8 +22,8 @@ use sp_api::{ApiExt, ApiRef, ProvideRuntimeApi};
 use sp_core::H256;
 use sp_domains::{ChannelId, DomainsApi};
 use sp_messenger::messages::{
-    BlockMessageWithStorageKey, BlockMessagesQuery, BlockMessagesWithStorageKey, ChainId,
-    ChannelState, ChannelStateWithNonce, CrossDomainMessage, Nonce, Proof,
+    BlockMessagesQuery, ChainId, ChannelState, ChannelStateWithNonce, CrossDomainMessage,
+    MessageNonceWithStorageKey, MessagesWithStorageKey, Nonce, Proof,
 };
 use sp_messenger::{MessengerApi, RelayerApi};
 use sp_mmr_primitives::MmrApi;
@@ -148,29 +148,36 @@ where
 }
 
 fn construct_cross_chain_message_and_submit<CNumber, CHash, Submitter, ProofConstructor>(
-    msgs: Vec<BlockMessageWithStorageKey>,
+    msgs: (ChainId, ChainId, ChannelId, Vec<MessageNonceWithStorageKey>),
     proof_constructor: ProofConstructor,
     submitter: Submitter,
 ) -> Result<(), Error>
 where
     Submitter: Fn(CrossDomainMessage<CNumber, CHash, H256>) -> Result<(), Error>,
     ProofConstructor: Fn(&[u8], ChainId) -> Result<Proof<CNumber, CHash, H256>, Error>,
 {
+    let (src_chain_id, dst_chain_id, channel_id, msgs) = msgs;
     for msg in msgs {
-        let proof = match proof_constructor(&msg.storage_key, msg.dst_chain_id) {
+        let proof = match proof_constructor(&msg.storage_key, dst_chain_id) {
             Ok(proof) => proof,
             Err(err) => {
                 tracing::error!(
                     target: LOG_TARGET,
                     "Failed to construct storage proof for message: {:?} bound to chain: {:?} with error: {:?}",
-                    (msg.channel_id, msg.nonce),
-                    msg.dst_chain_id,
+                    (channel_id, msg.nonce),
+                    dst_chain_id,
                     err
                 );
                 continue;
             }
         };
-        let msg = CrossDomainMessage::from_relayer_msg_with_proof(msg, proof);
+        let msg = CrossDomainMessage::from_relayer_msg_with_proof(
+            src_chain_id,
+            dst_chain_id,
+            channel_id,
+            msg,
+            proof,
+        );
         let (dst_domain, msg_id) = (msg.dst_chain_id, (msg.channel_id, msg.nonce));
         if let Err(err) = submitter(msg) {
             tracing::error!(
@@ -246,7 +253,7 @@ fn fetch_and_filter_messages<Client, Block, CClient, CBlock>(
     fetch_message_at: Block::Hash,
     consensus_client: &Arc<CClient>,
     self_chain_id: ChainId,
-) -> Result<BlockMessagesWithStorageKey, Error>
+) -> Result<Vec<(ChainId, ChannelId, MessagesWithStorageKey)>, Error>
 where
     CBlock: BlockT,
     CClient: AuxStore + HeaderBackend<CBlock>,
@@ -256,7 +263,7 @@ where
 {
     // return no messages for previous relayer version
     if !is_relayer_api_version_available::<_, Block, CBlock>(client, 3, fetch_message_at) {
-        return Ok(BlockMessagesWithStorageKey::default());
+        return Ok(vec![]);
     }
 
     fetch_messages::<_, _, Block, CBlock>(
@@ -379,35 +386,37 @@ where
             }
         };
 
-        construct_cross_chain_message_and_submit::<NumberFor<CBlock>, CBlock::Hash, _, _>(
-            block_messages.outbox,
-            |key, dst_chain_id| {
-                Self::construct_xdm_proof(
-                    consensus_chain_client,
-                    domain_client,
-                    dst_chain_id,
-                    mmr_consensus_block,
-                    key,
-                    xdm_proof_data.clone(),
-                )
-            },
-            |msg| gossip_outbox_message(domain_client, msg, gossip_message_sink),
-        )?;
-
-        construct_cross_chain_message_and_submit::<NumberFor<CBlock>, CBlock::Hash, _, _>(
-            block_messages.inbox_responses,
-            |key, dst_chain_id| {
-                Self::construct_xdm_proof(
-                    consensus_chain_client,
-                    domain_client,
-                    dst_chain_id,
-                    mmr_consensus_block,
-                    key,
-                    xdm_proof_data.clone(),
-                )
-            },
-            |msg| gossip_inbox_message_response(domain_client, msg, gossip_message_sink),
-        )?;
+        for (dst_chain_id, channel_id, messages) in block_messages {
+            construct_cross_chain_message_and_submit::<NumberFor<CBlock>, CBlock::Hash, _, _>(
+                (chain_id, dst_chain_id, channel_id, messages.outbox),
+                |key, dst_chain_id| {
+                    Self::construct_xdm_proof(
+                        consensus_chain_client,
+                        domain_client,
+                        dst_chain_id,
+                        mmr_consensus_block,
+                        key,
+                        xdm_proof_data.clone(),
+                    )
+                },
+                |msg| gossip_outbox_message(domain_client, msg, gossip_message_sink),
+            )?;
+
+            construct_cross_chain_message_and_submit::<NumberFor<CBlock>, CBlock::Hash, _, _>(
+                (chain_id, dst_chain_id, channel_id, messages.inbox_responses),
+                |key, dst_chain_id| {
+                    Self::construct_xdm_proof(
+                        consensus_chain_client,
+                        domain_client,
+                        dst_chain_id,
+                        mmr_consensus_block,
+                        key,
+                        xdm_proof_data.clone(),
+                    )
+                },
+                |msg| gossip_inbox_message_response(domain_client, msg, gossip_message_sink),
+            )?;
+        }
 
         Ok(())
     }
@@ -471,7 +480,7 @@ fn filter_block_messages<Client, Block, CBlock>(
     api: &ApiRef<'_, Client::Api>,
     best_hash: Block::Hash,
     query: BlockMessagesQuery,
-    messages: &mut BlockMessagesWithStorageKey,
+    messages: &mut MessagesWithStorageKey,
 ) -> Result<(), Error>
 where
     Block: BlockT,
@@ -486,8 +495,8 @@ where
         inbox_responses_from,
     } = query;
     let maybe_outbox_nonce =
-        api.should_relay_outbox_messages(best_hash, chain_id, channel_id, outbox_from)?;
-    let maybe_inbox_response_nonce = api.should_relay_inbox_message_responses(
+        api.first_outbox_message_nonce_to_relay(best_hash, chain_id, channel_id, outbox_from)?;
+    let maybe_inbox_response_nonce = api.first_inbox_message_response_nonce_to_relay(
         best_hash,
         chain_id,
         channel_id,
@@ -515,7 +524,7 @@ fn fetch_messages<Backend, Client, Block, CBlock>(
     client: &Arc<Client>,
     fetch_message_at: Block::Hash,
     self_chain_id: ChainId,
-) -> Result<BlockMessagesWithStorageKey, Error>
+) -> Result<Vec<(ChainId, ChannelId, MessagesWithStorageKey)>, Error>
 where
     Block: BlockT,
     CBlock: BlockT,
@@ -612,16 +621,9 @@ where
                 .ok()?;
             }
 
-            Some(messages)
+            Some((dst_chain_id, channel_id, messages))
         })
-        .fold(
-            BlockMessagesWithStorageKey::default(),
-            |mut acc, mut messages| {
-                acc.outbox.append(&mut messages.outbox);
-                acc.inbox_responses.append(&mut messages.inbox_responses);
-                acc
-            },
-        );
+        .collect();
 
     Ok(total_messages)
 }

domains/pallets/messenger/src/lib.rs

@@ -1513,12 +1513,12 @@ where
     }
 
     /// Returns the first outbox message nonce that should be relayed to the dst_chain.
-    pub fn should_relay_outbox_messages(
+    pub fn first_outbox_message_nonce_to_relay(
         dst_chain_id: ChainId,
         channel_id: ChannelId,
         from_nonce: Nonce,
     ) -> Option<Nonce> {
-        Self::should_relay_message(
+        Self::first_relay_message(
             dst_chain_id,
             channel_id,
             from_nonce,
@@ -1527,20 +1527,20 @@ where
     }
 
     /// Returns the first inbox response message nonce that should be relayed to the dst_chain.
-    pub fn should_relay_inbox_message_responses(
+    pub fn first_inbox_message_response_nonce_to_relay(
         dst_chain_id: ChainId,
         channel_id: ChannelId,
         from_nonce: Nonce,
     ) -> Option<Nonce> {
-        Self::should_relay_message(
+        Self::first_relay_message(
             dst_chain_id,
             channel_id,
             from_nonce,
             InboxResponses::<T>::contains_key,
         )
     }
 
-    fn should_relay_message<Check>(
+    fn first_relay_message<Check>(
         dst_chain_id: ChainId,
         channel_id: ChannelId,
         from_nonce: Nonce,

domains/pallets/messenger/src/messages.rs

@@ -16,8 +16,8 @@ use alloc::collections::BTreeMap;
 use frame_support::ensure;
 use sp_messenger::endpoint::{EndpointHandler, EndpointRequest, EndpointResponse};
 use sp_messenger::messages::{
-    BlockMessageWithStorageKey, BlockMessagesQuery, BlockMessagesWithStorageKey, ChainId,
-    ChannelOpenParamsV1, Message, MessageId, MessageKey, MessageWeightTag, PayloadV1,
+    BlockMessagesQuery, ChainId, ChannelOpenParamsV1, Message, MessageId, MessageKey,
+    MessageNonceWithStorageKey, MessageWeightTag, MessagesWithStorageKey, PayloadV1,
     ProtocolMessageRequest, ProtocolMessageResponse, RequestResponse, VersionedPayload,
 };
 
@@ -389,7 +389,7 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    pub fn get_block_messages(query: BlockMessagesQuery) -> BlockMessagesWithStorageKey {
+    pub fn get_block_messages(query: BlockMessagesQuery) -> MessagesWithStorageKey {
         let BlockMessagesQuery {
             chain_id,
             channel_id,
@@ -411,37 +411,31 @@ impl<T: Config> Pallet<T> {
             return Default::default();
         }
 
-        let mut messages_with_storage_key = BlockMessagesWithStorageKey::default();
+        let mut messages_with_storage_key = MessagesWithStorageKey::default();
 
         // create storage keys for inbox responses
-        inbox_responses_weight_tags.into_iter().for_each(
-            |((chain_id, (channel_id, nonce)), weight_tag)| {
+        inbox_responses_weight_tags
+            .into_iter()
+            .for_each(|(nonce, weight_tag)| {
                 let storage_key =
                     InboxResponses::<T>::hashed_key_for((chain_id, channel_id, nonce));
                 messages_with_storage_key
                     .inbox_responses
-                    .push(BlockMessageWithStorageKey {
-                        src_chain_id: T::SelfChainId::get(),
-                        dst_chain_id: chain_id,
-                        channel_id,
+                    .push(MessageNonceWithStorageKey {
                         nonce,
                         storage_key,
                         weight_tag,
                     });
-            },
-        );
+            });
 
         // create storage keys for outbox
         outbox_weight_tags
             .into_iter()
-            .for_each(|((chain_id, (channel_id, nonce)), weight_tag)| {
+            .for_each(|(nonce, weight_tag)| {
                 let storage_key = Outbox::<T>::hashed_key_for((chain_id, channel_id, nonce));
                 messages_with_storage_key
                     .outbox
-                    .push(BlockMessageWithStorageKey {
-                        src_chain_id: T::SelfChainId::get(),
-                        dst_chain_id: chain_id,
-                        channel_id,
+                    .push(MessageNonceWithStorageKey {
                         nonce,
                         storage_key,
                         weight_tag,
@@ -454,7 +448,7 @@ impl<T: Config> Pallet<T> {
     fn get_weight_tags<WTG>(
         from: MessageKey,
         weight_tag_getter: WTG,
-    ) -> BTreeMap<(ChainId, MessageId), MessageWeightTag>
+    ) -> BTreeMap<Nonce, MessageWeightTag>
     where
         WTG: Fn((ChainId, MessageId)) -> Option<MessageWeightTag>,
     {
@@ -465,7 +459,7 @@ impl<T: Config> Pallet<T> {
                 // if the nonce is already processed, short circuit and return
                 None => return weight_tags,
                 Some(weight_tag) => {
-                    weight_tags.insert((chain_id, (channel_id, nonce)), weight_tag);
+                    weight_tags.insert(nonce, weight_tag);
                 }
             };