use one runtime call per channel when filtering out messages using best hash instead of one call per message

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, ChannelState,
-    CrossDomainMessage, MessageId, MessageKey,
+    CrossDomainMessage, MessageId, MessageKey, Nonce as XdmNonce,
 };
 use sp_messenger::{ChannelNonce, XdmId};
 use sp_runtime::traits::NumberFor;
@@ -418,7 +418,15 @@ sp_api::impl_runtime_apis! {
             unreachable!()
         }
 
-        fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelState)>{
+        fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelState)> {
+            unreachable!()
+        }
+
+        fn should_relay_outbox_messages(_: ChainId, _: ChannelId, _: XdmNonce) -> Option<XdmNonce> {
+            unreachable!()
+        }
+
+        fn should_relay_inbox_message_responses(_: 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, ChannelState, CrossDomainMessage,
-    MessageId, MessageKey,
+    MessageId, MessageKey, Nonce as XdmNonce,
 };
 use sp_messenger::{ChannelNonce, XdmId};
 use sp_messenger_host_functions::{get_storage_key, StorageKeyRequest};
@@ -1684,12 +1684,12 @@ impl_runtime_apis! {
             Messenger::inbox_response_message_unsigned(msg)
         }
 
-        fn should_relay_outbox_message(dst_chain_id: ChainId, msg_id: MessageId) -> bool {
-            Messenger::should_relay_outbox_message(dst_chain_id, msg_id)
+        fn should_relay_outbox_message(_: ChainId, _: MessageId) -> bool {
+            false
         }
 
-        fn should_relay_inbox_message_response(dst_chain_id: ChainId, msg_id: MessageId) -> bool {
-            Messenger::should_relay_inbox_message_response(dst_chain_id, msg_id)
+        fn should_relay_inbox_message_response(_: ChainId, _: MessageId) -> bool {
+            false
         }
 
         fn updated_channels() -> BTreeSet<(ChainId, ChannelId)> {
@@ -1708,9 +1708,17 @@ impl_runtime_apis! {
             Messenger::get_block_messages(query)
         }
 
-        fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelState)>{
+        fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelState)> {
             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 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)
+        }
     }
 
     impl sp_domains_fraud_proof::FraudProofApi<Block, DomainHeader> for Runtime {

domains/client/relayer/src/lib.rs

@@ -240,58 +240,6 @@ where
     .map_err(Error::UnableToSubmitCrossDomainMessage)
 }
 
-fn should_relay_outbox_message<Client, Block, CBlock>(
-    api: &ApiRef<'_, Client::Api>,
-    best_hash: Block::Hash,
-    msg: &BlockMessageWithStorageKey,
-) -> bool
-where
-    Block: BlockT,
-    CBlock: BlockT,
-    Client: ProvideRuntimeApi<Block> + HeaderBackend<Block>,
-    Client::Api: RelayerApi<Block, NumberFor<Block>, NumberFor<CBlock>, CBlock::Hash>,
-{
-    let id = msg.id();
-    match api.should_relay_outbox_message(best_hash, msg.dst_chain_id, id) {
-        Ok(val) => val,
-        Err(err) => {
-            tracing::error!(
-                target: LOG_TARGET,
-                ?err,
-                "Failed to fetch validity of outbox message {id:?} for domain {0:?}",
-                msg.dst_chain_id
-            );
-            false
-        }
-    }
-}
-
-fn should_relay_inbox_responses_message<Client, Block, CBlock>(
-    api: &ApiRef<'_, Client::Api>,
-    best_hash: Block::Hash,
-    msg: &BlockMessageWithStorageKey,
-) -> bool
-where
-    Block: BlockT,
-    CBlock: BlockT,
-    Client: ProvideRuntimeApi<Block> + HeaderBackend<Block>,
-    Client::Api: RelayerApi<Block, NumberFor<Block>, NumberFor<CBlock>, CBlock::Hash>,
-{
-    let id = msg.id();
-    match api.should_relay_inbox_message_response(best_hash, msg.dst_chain_id, id) {
-        Ok(val) => val,
-        Err(err) => {
-            tracing::error!(
-                target: LOG_TARGET,
-                ?err,
-                "Failed to fetch validity of inbox message response {id:?} for domain {0:?}",
-                msg.dst_chain_id
-            );
-            false
-        }
-    }
-}
-
 // Fetch the XDM at the given block and filter any already relayed XDM according to the best block
 fn fetch_and_filter_messages<Client, Block, CClient, CBlock>(
     client: &Arc<Client>,
@@ -306,32 +254,17 @@ where
     Client: ProvideRuntimeApi<Block> + HeaderBackend<Block>,
     Client::Api: RelayerApi<Block, NumberFor<Block>, NumberFor<CBlock>, CBlock::Hash>,
 {
-    let mut msgs =
-        if is_relayer_api_version_available::<_, Block, CBlock>(client, 3, fetch_message_at) {
-            fetch_messages::<_, _, Block, CBlock>(
-                &**consensus_client,
-                client,
-                fetch_message_at,
-                self_chain_id,
-            )
-            .map_err(|_| Error::FetchAssignedMessages)?
-        } else {
-            client
-                .runtime_api()
-                .block_messages(fetch_message_at)
-                .map_err(|_| Error::FetchAssignedMessages)?
-        };
-
-    let api = client.runtime_api();
-    let best_hash = client.info().best_hash;
-    msgs.outbox
-        .retain(|msg| should_relay_outbox_message::<Client, Block, CBlock>(&api, best_hash, msg));
-
-    msgs.inbox_responses.retain(|msg| {
-        should_relay_inbox_responses_message::<Client, Block, CBlock>(&api, best_hash, msg)
-    });
+    // return no messages for previous relayer version
+    if !is_relayer_api_version_available::<_, Block, CBlock>(client, 3, fetch_message_at) {
+        return Ok(BlockMessagesWithStorageKey::default());
+    }
 
-    Ok(msgs)
+    fetch_messages::<_, _, Block, CBlock>(
+        &**consensus_client,
+        client,
+        fetch_message_at,
+        self_chain_id,
+    )
 }
 
 // A helper struct used when constructing XDM proof
@@ -534,6 +467,48 @@ where
     }
 }
 
+fn filter_block_messages<Client, Block, CBlock>(
+    api: &ApiRef<'_, Client::Api>,
+    best_hash: Block::Hash,
+    query: BlockMessagesQuery,
+    messages: &mut BlockMessagesWithStorageKey,
+) -> Result<(), Error>
+where
+    Block: BlockT,
+    CBlock: BlockT,
+    Client: ProvideRuntimeApi<Block> + HeaderBackend<Block>,
+    Client::Api: RelayerApi<Block, NumberFor<Block>, NumberFor<CBlock>, CBlock::Hash>,
+{
+    let BlockMessagesQuery {
+        chain_id,
+        channel_id,
+        outbox_from,
+        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(
+        best_hash,
+        chain_id,
+        channel_id,
+        inbox_responses_from,
+    )?;
+
+    if let Some(nonce) = maybe_outbox_nonce {
+        messages.outbox.retain(|msg| msg.nonce >= nonce)
+    } else {
+        messages.outbox.clear()
+    }
+
+    if let Some(nonce) = maybe_inbox_response_nonce {
+        messages.inbox_responses.retain(|msg| msg.nonce >= nonce)
+    } else {
+        messages.inbox_responses.clear();
+    }
+
+    Ok(())
+}
+
 // Fetch the unprocessed XDMs at a given block
 fn fetch_messages<Backend, Client, Block, CBlock>(
     backend: &Backend,
@@ -580,6 +555,8 @@ where
         queries
     };
 
+    let best_hash = client.info().best_hash;
+    let runtime_api_best = client.runtime_api();
     let total_messages = queries
         .into_iter()
         .filter_map(|query| {
@@ -588,9 +565,19 @@ where
                 channel_id,
                 ..
             } = query;
-            let messages = runtime_api
-                .block_messages_with_query(fetch_message_at, query)
+            let mut messages = runtime_api
+                .block_messages_with_query(fetch_message_at, query.clone())
                 .ok()?;
+
+            // filter messages with best hash
+            filter_block_messages::<Client, _, CBlock>(
+                &runtime_api_best,
+                best_hash,
+                query,
+                &mut messages,
+            )
+            .ok()?;
+
             if !messages.outbox.is_empty()
                 && let Some(max_nonce) = messages.outbox.iter().map(|key| key.nonce).max()
             {

domains/pallets/messenger/src/lib.rs

@@ -45,8 +45,9 @@ use scale_info::TypeInfo;
 use sp_core::U256;
 use sp_domains::{DomainAllowlistUpdates, DomainId};
 use sp_messenger::messages::{
-    ChainId, Channel, ChannelId, ChannelState, CrossDomainMessage, Message, MessageId, Nonce,
+    ChainId, Channel, ChannelId, ChannelState, CrossDomainMessage, Message, Nonce,
 };
+use sp_messenger::MAX_FUTURE_ALLOWED_NONCES;
 use sp_runtime::traits::Hash;
 use sp_runtime::DispatchError;
 use subspace_runtime_primitives::CreateUnsigned;
@@ -1510,14 +1511,54 @@ where
         Some(T::create_unsigned(call.into()))
     }
 
-    /// Returns true if the outbox message has not received the response yet.
-    pub fn should_relay_outbox_message(dst_chain_id: ChainId, msg_id: MessageId) -> bool {
-        Outbox::<T>::contains_key((dst_chain_id, msg_id.0, msg_id.1))
+    /// Returns the first outbox message nonce that should be relayed to the dst_chain.
+    pub fn should_relay_outbox_messages(
+        dst_chain_id: ChainId,
+        channel_id: ChannelId,
+        from_nonce: Nonce,
+    ) -> Option<Nonce> {
+        Self::should_relay_message(
+            dst_chain_id,
+            channel_id,
+            from_nonce,
+            Outbox::<T>::contains_key,
+        )
     }
 
-    /// Returns true if the inbox message response has not received acknowledgement yet.
-    pub fn should_relay_inbox_message_response(dst_chain_id: ChainId, msg_id: MessageId) -> bool {
-        InboxResponses::<T>::contains_key((dst_chain_id, msg_id.0, msg_id.1))
+    /// Returns the first inbox response message nonce that should be relayed to the dst_chain.
+    pub fn should_relay_inbox_message_responses(
+        dst_chain_id: ChainId,
+        channel_id: ChannelId,
+        from_nonce: Nonce,
+    ) -> Option<Nonce> {
+        Self::should_relay_message(
+            dst_chain_id,
+            channel_id,
+            from_nonce,
+            InboxResponses::<T>::contains_key,
+        )
+    }
+
+    fn should_relay_message<Check>(
+        dst_chain_id: ChainId,
+        channel_id: ChannelId,
+        from_nonce: Nonce,
+        check: Check,
+    ) -> Option<Nonce>
+    where
+        Check: Fn((ChainId, ChannelId, Nonce)) -> bool,
+    {
+        let mut nonce = from_nonce;
+        let to_nonce = from_nonce.saturating_add(MAX_FUTURE_ALLOWED_NONCES.into());
+        while nonce <= to_nonce {
+            if check((dst_chain_id, channel_id, nonce)) {
+                return Some(nonce);
+            }
+
+            nonce = nonce.saturating_add(Nonce::one())
+        }
+
+        None
     }
 }
 

domains/primitives/messenger/src/lib.rs

@@ -310,6 +310,12 @@ sp_api::decl_runtime_apis! {
 
         /// Returns all the channels to other chains and their local Channel state.
         fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelState)>;
+
+        /// Returns the first outbox message nonce that should be relayed to the dst_chain.
+        fn should_relay_outbox_messages(dst_chain_id: ChainId, channel_id: ChannelId, from_nonce: Nonce) -> Option<Nonce>;
+
+        /// Returns the first inbox response message nonce that should be relayed to the dst_chain.
+        fn should_relay_inbox_message_responses(dst_chain_id: ChainId,channel_id: ChannelId, from_nonce: Nonce) -> Option<Nonce>;
     }
 
     /// Api to provide XDM extraction from Runtime Calls.

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

@@ -43,7 +43,7 @@ use sp_domains::{ChannelId, DomainAllowlistUpdates, DomainId, Transfers};
 use sp_messenger::endpoint::{Endpoint, EndpointHandler as EndpointHandlerT, EndpointId};
 use sp_messenger::messages::{
     BlockMessagesQuery, BlockMessagesWithStorageKey, ChainId, ChannelState, CrossDomainMessage,
-    MessageId, MessageKey,
+    MessageId, MessageKey, Nonce as XdmNonce,
 };
 use sp_messenger::{ChannelNonce, XdmId};
 use sp_messenger_host_functions::{get_storage_key, StorageKeyRequest};
@@ -1126,12 +1126,12 @@ impl_runtime_apis! {
             Messenger::inbox_response_message_unsigned(msg)
         }
 
-        fn should_relay_outbox_message(dst_chain_id: ChainId, msg_id: MessageId) -> bool {
-            Messenger::should_relay_outbox_message(dst_chain_id, msg_id)
+        fn should_relay_outbox_message(_: ChainId, _: MessageId) -> bool {
+            false
         }
 
-        fn should_relay_inbox_message_response(dst_chain_id: ChainId, msg_id: MessageId) -> bool {
-            Messenger::should_relay_inbox_message_response(dst_chain_id, msg_id)
+        fn should_relay_inbox_message_response(_: ChainId, _: MessageId) -> bool {
+            false
         }
 
         fn updated_channels() -> BTreeSet<(ChainId, ChannelId)> {
@@ -1150,9 +1150,17 @@ impl_runtime_apis! {
             Messenger::get_block_messages(query)
         }
 
-        fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelState)>{
+        fn channels_and_state() -> Vec<(ChainId, ChannelId, ChannelState)> {
             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 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)
+        }
     }
 
     impl sp_domain_sudo::DomainSudoApi<Block> for Runtime {