block messages with a query and fix the open_channels response to include closed channels as well

Author: vedhavyas

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

@@ -16,7 +16,8 @@ use sp_domains::{
 use sp_domains_fraud_proof::fraud_proof::FraudProof;
 use sp_domains_fraud_proof::storage_proof::FraudProofStorageKeyRequest;
 use sp_messenger::messages::{
-    BlockMessagesWithStorageKey, ChainId, ChannelId, CrossDomainMessage, MessageId, MessageKey,
+    BlockMessagesQuery, BlockMessagesWithStorageKey, ChainId, ChannelId, ChannelState,
+    CrossDomainMessage, MessageId, MessageKey,
 };
 use sp_messenger::{ChannelNonce, XdmId};
 use sp_runtime::traits::NumberFor;
@@ -412,6 +413,14 @@ sp_api::impl_runtime_apis! {
         fn open_channels() -> BTreeSet<(ChainId, ChannelId)> {
             unreachable!()
         }
+
+        fn block_messages_with_query(_: BlockMessagesQuery) -> BlockMessagesWithStorageKey {
+            unreachable!()
+        }
+
+        fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelState)>{
+            unreachable!()
+        }
     }
 
     impl sp_domains_fraud_proof::FraudProofApi<Block, DomainHeader> for Runtime {

crates/subspace-runtime/src/lib.rs

@@ -71,7 +71,8 @@ use sp_domains_fraud_proof::storage_proof::{
 };
 use sp_messenger::endpoint::{Endpoint, EndpointHandler as EndpointHandlerT, EndpointId};
 use sp_messenger::messages::{
-    BlockMessagesWithStorageKey, ChainId, CrossDomainMessage, MessageId, MessageKey,
+    BlockMessagesQuery, BlockMessagesWithStorageKey, ChainId, ChannelState, CrossDomainMessage,
+    MessageId, MessageKey,
 };
 use sp_messenger::{ChannelNonce, XdmId};
 use sp_messenger_host_functions::{get_storage_key, StorageKeyRequest};
@@ -1672,7 +1673,7 @@ impl_runtime_apis! {
 
     impl sp_messenger::RelayerApi<Block, BlockNumber, BlockNumber, BlockHashFor<Block>> for Runtime {
         fn block_messages() -> BlockMessagesWithStorageKey {
-            Messenger::get_block_messages()
+            BlockMessagesWithStorageKey::default()
         }
 
         fn outbox_message_unsigned(msg: CrossDomainMessage<NumberFor<Block>, BlockHashFor<Block>, BlockHashFor<Block>>) -> Option<ExtrinsicFor<Block>> {
@@ -1702,6 +1703,14 @@ impl_runtime_apis! {
         fn open_channels() -> BTreeSet<(ChainId, ChannelId)> {
             Messenger::open_channels()
         }
+
+        fn block_messages_with_query(query: BlockMessagesQuery) -> BlockMessagesWithStorageKey {
+            Messenger::get_block_messages(query)
+        }
+
+        fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelState)>{
+            Messenger::channels_and_states()
+        }
     }
 
     impl sp_domains_fraud_proof::FraudProofApi<Block, DomainHeader> for Runtime {

domains/pallets/messenger/src/lib.rs

@@ -1410,7 +1410,11 @@ mod pallet {
         }
 
         pub fn open_channels() -> BTreeSet<(ChainId, ChannelId)> {
-            crate::migrations::get_open_channels::<T>()
+            Channels::<T>::iter_keys().collect()
+        }
+
+        pub fn channels_and_states() -> Vec<(ChainId, ChannelId, ChannelState)> {
+            crate::migrations::get_channels_and_states::<T>()
         }
 
         pub fn channel_nonce(chain_id: ChainId, channel_id: ChannelId) -> Option<ChannelNonce> {

domains/pallets/messenger/src/messages.rs

@@ -16,11 +16,13 @@ use alloc::collections::BTreeMap;
 use frame_support::ensure;
 use sp_messenger::endpoint::{EndpointHandler, EndpointRequest, EndpointResponse};
 use sp_messenger::messages::{
-    BlockMessageWithStorageKey, BlockMessagesWithStorageKey, ChainId, ChannelOpenParamsV1, Message,
-    MessageId, MessageWeightTag, PayloadV1, ProtocolMessageRequest, ProtocolMessageResponse,
-    RequestResponse, VersionedPayload,
+    BlockMessageWithStorageKey, BlockMessagesQuery, BlockMessagesWithStorageKey, ChainId,
+    ChannelOpenParamsV1, Message, MessageId, MessageKey, MessageWeightTag, PayloadV1,
+    ProtocolMessageRequest, ProtocolMessageResponse, RequestResponse, VersionedPayload,
 };
-use sp_runtime::traits::Get;
+
+use sp_messenger::MAX_FUTURE_ALLOWED_NONCES;
+use sp_runtime::traits::{Get, One};
 use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};
 #[cfg(feature = "std")]
 use std::collections::BTreeMap;
@@ -387,11 +389,23 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    pub fn get_block_messages() -> BlockMessagesWithStorageKey {
-        let inbox_responses_weight_tags: BTreeMap<(ChainId, MessageId), MessageWeightTag> =
-            InboxResponseMessageWeightTags::<T>::iter().collect();
-        let outbox_weight_tags: BTreeMap<(ChainId, MessageId), MessageWeightTag> =
-            OutboxMessageWeightTags::<T>::iter().collect();
+    pub fn get_block_messages(query: BlockMessagesQuery) -> BlockMessagesWithStorageKey {
+        let BlockMessagesQuery {
+            chain_id,
+            channel_id,
+            outbox_from,
+            inbox_responses_from,
+        } = query;
+
+        let inbox_responses_weight_tags = Self::get_weight_tags(
+            (chain_id, channel_id, inbox_responses_from),
+            InboxResponseMessageWeightTags::<T>::get,
+        );
+
+        let outbox_weight_tags = Self::get_weight_tags(
+            (chain_id, channel_id, outbox_from),
+            OutboxMessageWeightTags::<T>::get,
+        );
 
         if outbox_weight_tags.is_empty() && inbox_responses_weight_tags.is_empty() {
             return Default::default();
@@ -436,4 +450,31 @@ impl<T: Config> Pallet<T> {
 
         messages_with_storage_key
     }
+
+    fn get_weight_tags<WTG>(
+        from: MessageKey,
+        weight_tag_getter: WTG,
+    ) -> BTreeMap<(ChainId, MessageId), MessageWeightTag>
+    where
+        WTG: Fn((ChainId, MessageId)) -> Option<MessageWeightTag>,
+    {
+        let (chain_id, channel_id, mut nonce) = from;
+        let mut weight_tags = BTreeMap::new();
+        while weight_tags.len() as u32 <= MAX_FUTURE_ALLOWED_NONCES {
+            match weight_tag_getter((chain_id, (channel_id, nonce))) {
+                // 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);
+                }
+            };
+
+            nonce = match nonce.checked_add(One::one()) {
+                None => return weight_tags,
+                Some(nonce) => nonce,
+            }
+        }
+
+        weight_tags
+    }
 }

domains/pallets/messenger/src/migrations.rs

@@ -2,5 +2,5 @@ mod v0_to_v1;
 mod v1_to_v2;
 
 pub use v0_to_v1::VersionCheckedMigrateDomainsV0ToV1;
-pub(crate) use v1_to_v2::migrate_channels::{get_channel, get_open_channels};
+pub(crate) use v1_to_v2::migrate_channels::{get_channel, get_channels_and_states};
 pub use v1_to_v2::VersionCheckedMigrateDomainsV1ToV2;

domains/pallets/messenger/src/migrations/v1_to_v2.rs

@@ -5,7 +5,7 @@ extern crate alloc;
 use crate::migrations::v1_to_v2::migrate_channels::migrate_channels;
 use crate::{BalanceOf, Channels as ChannelStorageV1, Config, Pallet};
 #[cfg(not(feature = "std"))]
-use alloc::collections::BTreeSet;
+use alloc::vec::Vec;
 use core::marker::PhantomData;
 use frame_support::migrations::VersionedMigration;
 use frame_support::pallet_prelude::{Decode, Encode, OptionQuery, TypeInfo};
@@ -14,8 +14,6 @@ use frame_support::weights::Weight;
 use frame_support::{storage_alias, Identity};
 use sp_domains::{ChainId, ChannelId};
 use sp_messenger::messages::{Channel as ChannelV1, ChannelState, Nonce};
-#[cfg(feature = "std")]
-use std::collections::BTreeSet;
 
 pub type VersionCheckedMigrateDomainsV1ToV2<T> = VersionedMigration<
     1,
@@ -91,6 +89,7 @@ pub(crate) mod migrate_channels {
         Channel<BalanceOf<T>, <T as frame_system::Config>::AccountId>,
         OptionQuery,
     >;
+
     pub(super) fn migrate_channels<T: Config>() -> Weight {
         let mut count = 0;
         Channels::<T>::drain().for_each(|(chain_id, channel_id, channel)| {
@@ -111,13 +110,12 @@ pub(crate) mod migrate_channels {
         })
     }
 
-    pub(crate) fn get_open_channels<T: Config>() -> BTreeSet<(ChainId, ChannelId)> {
-        let keys: BTreeSet<(ChainId, ChannelId)> = ChannelStorageV1::<T>::iter_keys().collect();
+    pub(crate) fn get_channels_and_states<T: Config>() -> Vec<(ChainId, ChannelId, ChannelState)> {
+        let keys: Vec<(ChainId, ChannelId)> = ChannelStorageV1::<T>::iter_keys().collect();
         keys.into_iter()
-            .filter(|(chain_id, channel_id)| {
-                get_channel::<T>(*chain_id, *channel_id)
-                    .map(|channel| channel.state != ChannelState::Closed)
-                    .unwrap_or_default()
+            .filter_map(|(chain_id, channel_id)| {
+                get_channel::<T>(chain_id, channel_id)
+                    .map(|channel| (chain_id, channel_id, channel.state))
             })
             .collect()
     }

domains/pallets/messenger/src/tests.rs

@@ -22,8 +22,8 @@ use sp_domains::proof_provider_and_verifier::{StorageProofVerifier, Verification
 use sp_domains::DomainAllowlistUpdates;
 use sp_messenger::endpoint::{Endpoint, EndpointPayload, EndpointRequest, Sender};
 use sp_messenger::messages::{
-    ChainId, ChannelOpenParamsV1, CrossDomainMessage, MessageWeightTag, PayloadV1, Proof,
-    ProtocolMessageRequest, RequestResponse, VersionedPayload,
+    BlockMessagesQuery, ChainId, ChannelOpenParamsV1, CrossDomainMessage, MessageWeightTag,
+    PayloadV1, Proof, ProtocolMessageRequest, RequestResponse, VersionedPayload,
 };
 use sp_mmr_primitives::{EncodableOpaqueLeaf, LeafProof as MmrProof};
 use sp_runtime::traits::{Convert, Zero};
@@ -80,7 +80,13 @@ fn create_channel(chain_id: ChainId, channel_id: ChannelId) {
     ));
 
     // check outbox relayer storage key generation
-    let messages_with_keys = chain_a::Messenger::get_block_messages();
+    let query = BlockMessagesQuery {
+        chain_id,
+        channel_id,
+        outbox_from: Nonce::zero(),
+        inbox_responses_from: Nonce::zero(),
+    };
+    let messages_with_keys = chain_a::Messenger::get_block_messages(query);
     assert_eq!(messages_with_keys.outbox.len(), 1);
     assert_eq!(messages_with_keys.inbox_responses.len(), 0);
     let expected_key =
@@ -294,7 +300,13 @@ fn open_channel_between_chains(
         }));
 
         // check inbox response storage key generation
-        let messages_with_keys = chain_b::Messenger::get_block_messages();
+        let query = BlockMessagesQuery {
+            chain_id: chain_a_id,
+            channel_id,
+            outbox_from: Nonce::zero(),
+            inbox_responses_from: Nonce::zero(),
+        };
+        let messages_with_keys = chain_b::Messenger::get_block_messages(query);
         assert_eq!(messages_with_keys.outbox.len(), 0);
         assert_eq!(messages_with_keys.inbox_responses.len(), 1);
         let expected_key = InboxResponses::<chain_b::Runtime>::hashed_key_for((

domains/primitives/messenger/src/lib.rs

@@ -23,7 +23,7 @@ pub mod messages;
 #[cfg(not(feature = "std"))]
 extern crate alloc;
 
-use crate::messages::{MessageKey, Nonce};
+use crate::messages::{ChannelState, MessageKey, Nonce};
 #[cfg(not(feature = "std"))]
 use alloc::collections::BTreeMap;
 #[cfg(not(feature = "std"))]
@@ -37,7 +37,9 @@ use frame_support::inherent::{InherentIdentifier, IsFatalError};
 use frame_support::storage::storage_prefix;
 #[cfg(feature = "runtime-benchmarks")]
 use frame_support::{Identity, StorageHasher};
-use messages::{BlockMessagesWithStorageKey, ChannelId, CrossDomainMessage, MessageId};
+use messages::{
+    BlockMessagesQuery, BlockMessagesWithStorageKey, ChannelId, CrossDomainMessage, MessageId,
+};
 use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use sp_domains::{ChainId, DomainAllowlistUpdates, DomainId};
@@ -266,7 +268,7 @@ pub struct ChannelNonce {
 
 sp_api::decl_runtime_apis! {
     /// Api useful for relayers to fetch messages and submit transactions.
-    #[api_version(2)]
+    #[api_version(3)]
     pub trait RelayerApi<BlockNumber, CNumber, CHash>
     where
         BlockNumber: Encode + Decode,
@@ -301,6 +303,13 @@ sp_api::decl_runtime_apis! {
 
         /// Returns all the open channels to other chains.
         fn open_channels() -> BTreeSet<(ChainId, ChannelId)>;
+
+        /// Returns outbox and inbox responses from given nonce to maximum allowed nonce per block
+        /// Storage key is used to generate the storage proof for the message.
+        fn block_messages_with_query(query: BlockMessagesQuery) -> BlockMessagesWithStorageKey;
+
+        /// Returns all the channels to other chains and their local Channel state.
+        fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelState)>;
     }
 
     /// Api to provide XDM extraction from Runtime Calls.

domains/primitives/messenger/src/messages.rs

@@ -269,6 +269,15 @@ impl BlockMessagesWithStorageKey {
     }
 }
 
+/// A query to fetch block messages for Outbox and Inbox Responses
+#[derive(Debug, Encode, Decode, TypeInfo, Clone, Eq, PartialEq)]
+pub struct BlockMessagesQuery {
+    pub chain_id: ChainId,
+    pub channel_id: ChannelId,
+    pub outbox_from: Nonce,
+    pub inbox_responses_from: Nonce,
+}
+
 impl<BlockNumber, BlockHash, MmrHash> CrossDomainMessage<BlockNumber, BlockHash, MmrHash> {
     pub fn from_relayer_msg_with_proof(
         r_msg: BlockMessageWithStorageKey,

domains/runtime/auto-id/src/lib.rs

@@ -42,7 +42,8 @@ use sp_core::{Get, OpaqueMetadata};
 use sp_domains::{ChannelId, DomainAllowlistUpdates, DomainId, Transfers};
 use sp_messenger::endpoint::{Endpoint, EndpointHandler as EndpointHandlerT, EndpointId};
 use sp_messenger::messages::{
-    BlockMessagesWithStorageKey, ChainId, CrossDomainMessage, MessageId, MessageKey,
+    BlockMessagesQuery, BlockMessagesWithStorageKey, ChainId, ChannelState, CrossDomainMessage,
+    MessageId, MessageKey,
 };
 use sp_messenger::{ChannelNonce, XdmId};
 use sp_messenger_host_functions::{get_storage_key, StorageKeyRequest};
@@ -1114,7 +1115,7 @@ impl_runtime_apis! {
 
     impl sp_messenger::RelayerApi<Block, BlockNumber, ConsensusBlockNumber, ConsensusBlockHash> for Runtime {
         fn block_messages() -> BlockMessagesWithStorageKey {
-            Messenger::get_block_messages()
+            BlockMessagesWithStorageKey::default()
         }
 
         fn outbox_message_unsigned(msg: CrossDomainMessage<NumberFor<Block>, BlockHashFor<Block>, BlockHashFor<Block>>) -> Option<ExtrinsicFor<Block>> {
@@ -1144,6 +1145,14 @@ impl_runtime_apis! {
         fn open_channels() -> BTreeSet<(ChainId, ChannelId)> {
             Messenger::open_channels()
         }
+
+        fn block_messages_with_query(query: BlockMessagesQuery) -> BlockMessagesWithStorageKey {
+            Messenger::get_block_messages(query)
+        }
+
+        fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelState)>{
+            Messenger::channels_and_states()
+        }
     }
 
     impl sp_domain_sudo::DomainSudoApi<Block> for Runtime {