Support TimeoutUnordered packet payload

informalsystems · Jul 17, 2023 · 54180d0 · 54180d0
1 parent ae3edd8
commit 54180d0
Show file tree

Hide file tree

Showing 7 changed files with 126 additions and 35 deletions.
diff --git a/crates/relayer-all-in-one/src/one_for_all/impls/chain/message/timeout_unordered_packet.rs b/crates/relayer-all-in-one/src/one_for_all/impls/chain/message/timeout_unordered_packet.rs
@@ -1,24 +1,53 @@
 use async_trait::async_trait;
-use ibc_relayer_components::chain::traits::message_builders::timeout_unordered_packet::CanBuildTimeoutUnorderedPacketMessage;
+use ibc_relayer_components::chain::traits::message_builders::timeout_unordered_packet::{
+    CanBuildTimeoutUnorderedPacketMessage, CanBuildTimeoutUnorderedPacketPayload,
+};
+use ibc_relayer_components::chain::traits::types::packets::timeout::HasTimeoutUnorderedPacketPayload;
 
 use crate::one_for_all::traits::chain::OfaIbcChain;
 use crate::one_for_all::types::chain::OfaChainWrapper;
 use crate::std_prelude::*;
 
+impl<Chain, Counterparty> HasTimeoutUnorderedPacketPayload<OfaChainWrapper<Counterparty>>
+    for OfaChainWrapper<Chain>
+where
+    Chain: OfaIbcChain<Counterparty>,
+    Counterparty: OfaIbcChain<Chain>,
+{
+    type TimeoutUnorderedPacketPayload = Chain::TimeoutUnorderedPacketPayload;
+}
+
 #[async_trait]
-impl<Chain, Counterparty> CanBuildTimeoutUnorderedPacketMessage<OfaChainWrapper<Counterparty>>
+impl<Chain, Counterparty> CanBuildTimeoutUnorderedPacketPayload<OfaChainWrapper<Counterparty>>
     for OfaChainWrapper<Chain>
 where
     Chain: OfaIbcChain<Counterparty>,
     Counterparty: OfaIbcChain<Chain>,
 {
-    async fn build_timeout_unordered_packet_message(
+    async fn build_timeout_unordered_packet_payload(
         &self,
         height: &Self::Height,
         packet: &Self::IncomingPacket,
-    ) -> Result<Counterparty::Message, Self::Error> {
+    ) -> Result<Self::TimeoutUnorderedPacketPayload, Self::Error> {
+        self.chain
+            .build_timeout_unordered_packet_payload(height, packet)
+            .await
+    }
+}
+
+#[async_trait]
+impl<Chain, Counterparty> CanBuildTimeoutUnorderedPacketMessage<OfaChainWrapper<Counterparty>>
+    for OfaChainWrapper<Chain>
+where
+    Chain: OfaIbcChain<Counterparty>,
+    Counterparty: OfaIbcChain<Chain>,
+{
+    async fn build_timeout_unordered_packet_message(
+        &self,
+        payload: Counterparty::TimeoutUnorderedPacketPayload,
+    ) -> Result<Self::Message, Self::Error> {
         self.chain
-            .build_timeout_unordered_packet_message(height, packet)
+            .build_timeout_unordered_packet_message(payload)
             .await
     }
 }
diff --git a/crates/relayer-all-in-one/src/one_for_all/traits/chain.rs b/crates/relayer-all-in-one/src/one_for_all/traits/chain.rs
@@ -170,6 +170,8 @@ pub trait OfaChainTypes: Async {
     type ReceivePacketPayload: Async;
 
     type AckPacketPayload: Async;
+
+    type TimeoutUnorderedPacketPayload: Async;
 }
 
 #[async_trait]
@@ -351,11 +353,16 @@ where
         payload: Counterparty::AckPacketPayload,
     ) -> Result<Self::Message, Self::Error>;
 
-    async fn build_timeout_unordered_packet_message(
+    async fn build_timeout_unordered_packet_payload(
         &self,
         height: &Self::Height,
         packet: &Self::IncomingPacket,
-    ) -> Result<Counterparty::Message, Self::Error>;
+    ) -> Result<Self::TimeoutUnorderedPacketPayload, Self::Error>;
+
+    async fn build_timeout_unordered_packet_message(
+        &self,
+        payload: Counterparty::TimeoutUnorderedPacketPayload,
+    ) -> Result<Self::Message, Self::Error>;
 
     async fn build_create_client_payload(
         &self,

diff --git a/crates/relayer-components/src/chain/traits/message_builders/timeout_unordered_packet.rs b/crates/relayer-components/src/chain/traits/message_builders/timeout_unordered_packet.rs
@@ -2,6 +2,7 @@ use async_trait::async_trait;
 
 use crate::chain::traits::types::height::HasHeightType;
 use crate::chain::traits::types::ibc::HasIbcChainTypes;
+use crate::chain::traits::types::message::HasMessageType;
 use crate::chain::traits::types::packet::HasIbcPacketTypes;
 use crate::chain::traits::types::packets::timeout::HasTimeoutUnorderedPacketPayload;
 use crate::core::traits::error::HasErrorType;
@@ -25,13 +26,12 @@ where
 
 #[async_trait]
 pub trait CanBuildTimeoutUnorderedPacketMessage<Counterparty>:
-    HasIbcPacketTypes<Counterparty> + HasHeightType + HasErrorType
+    HasMessageType + HasErrorType
 where
-    Counterparty: HasIbcChainTypes<Self>,
+    Counterparty: HasTimeoutUnorderedPacketPayload<Self>,
 {
     async fn build_timeout_unordered_packet_message(
         &self,
-        height: &Self::Height,
-        packet: &Self::IncomingPacket,
-    ) -> Result<Counterparty::Message, Self::Error>;
+        payload: Counterparty::TimeoutUnorderedPacketPayload,
+    ) -> Result<Self::Message, Self::Error>;
 }
diff --git a/...-components/src/relay/impls/packet_relayers/timeout_unordered/timeout_unordered_packet.rs b/...-components/src/relay/impls/packet_relayers/timeout_unordered/timeout_unordered_packet.rs
@@ -1,6 +1,8 @@
 use async_trait::async_trait;
 
-use crate::chain::traits::message_builders::timeout_unordered_packet::CanBuildTimeoutUnorderedPacketMessage;
+use crate::chain::traits::message_builders::timeout_unordered_packet::{
+    CanBuildTimeoutUnorderedPacketMessage, CanBuildTimeoutUnorderedPacketPayload,
+};
 use crate::chain::types::aliases::Height;
 use crate::relay::traits::chains::HasRelayChains;
 use crate::relay::traits::ibc_message_sender::CanSendSingleIbcMessage;
@@ -19,19 +21,26 @@ impl<Relay> TimeoutUnorderedPacketRelayer<Relay> for BaseTimeoutUnorderedPacketR
 where
     Relay: HasRelayChains,
     Relay: CanSendSingleIbcMessage<SourceTarget>,
-    Relay::DstChain: CanBuildTimeoutUnorderedPacketMessage<Relay::SrcChain>,
+    Relay::DstChain: CanBuildTimeoutUnorderedPacketPayload<Relay::SrcChain>,
+    Relay::SrcChain: CanBuildTimeoutUnorderedPacketMessage<Relay::DstChain>,
 {
     async fn relay_timeout_unordered_packet(
         relay: &Relay,
         destination_height: &Height<Relay::DstChain>,
         packet: &Packet<Relay>,
     ) -> Result<(), Relay::Error> {
-        let message = relay
+        let payload = relay
             .dst_chain()
-            .build_timeout_unordered_packet_message(destination_height, packet)
+            .build_timeout_unordered_packet_payload(destination_height, packet)
             .await
             .map_err(Relay::dst_chain_error)?;
 
+        let message = relay
+            .src_chain()
+            .build_timeout_unordered_packet_message(payload)
+            .await
+            .map_err(Relay::src_chain_error)?;
+
         relay.send_message(SourceTarget, message).await?;
 
         Ok(())

diff --git a/crates/relayer-cosmos/src/impls/chain.rs b/crates/relayer-cosmos/src/impls/chain.rs
@@ -55,8 +55,10 @@ use crate::methods::consensus_state::{find_consensus_state_height_before, query_
 use crate::methods::create_client::{build_create_client_message, build_create_client_payload};
 use crate::methods::packet::{
     build_ack_packet_message, build_ack_packet_payload, build_receive_packet_message,
-    build_receive_packet_payload, build_timeout_unordered_packet_message, query_is_packet_received,
+    build_receive_packet_payload, build_timeout_unordered_packet_message,
+    build_timeout_unordered_packet_payload, query_is_packet_received,
     query_write_acknowledgement_event, CosmosAckPacketPayload, CosmosReceivePacketPayload,
+    CosmosTimeoutUnorderedPacketPayload,
 };
 use crate::methods::update_client::{build_update_client_message, build_update_client_payload};
 use crate::traits::message::CosmosMessage;
@@ -163,6 +165,8 @@ where
     type ReceivePacketPayload = CosmosReceivePacketPayload;
 
     type AckPacketPayload = CosmosAckPacketPayload;
+
+    type TimeoutUnorderedPacketPayload = CosmosTimeoutUnorderedPacketPayload;
 }
 
 #[async_trait]
@@ -419,6 +423,7 @@ where
         ChannelOpenConfirmPayload = CosmosChannelOpenConfirmPayload,
         ReceivePacketPayload = CosmosReceivePacketPayload,
         AckPacketPayload = CosmosAckPacketPayload,
+        TimeoutUnorderedPacketPayload = CosmosTimeoutUnorderedPacketPayload,
     >,
 {
     fn incoming_packet_src_channel_id(packet: &Packet) -> &ChannelId {
@@ -567,12 +572,19 @@ where
     /// Construct a timeout packet message to be sent between Cosmos chains
     /// over an unordered channel in the event that a packet that originated
     /// from a source chain was not received.
-    async fn build_timeout_unordered_packet_message(
+    async fn build_timeout_unordered_packet_payload(
         &self,
         height: &Height,
         packet: &Packet,
+    ) -> Result<CosmosTimeoutUnorderedPacketPayload, Error> {
+        build_timeout_unordered_packet_payload(self, height, packet).await
+    }
+
+    async fn build_timeout_unordered_packet_message(
+        &self,
+        payload: CosmosTimeoutUnorderedPacketPayload,
     ) -> Result<Arc<dyn CosmosMessage>, Error> {
-        build_timeout_unordered_packet_message(self, height, packet).await
+        build_timeout_unordered_packet_message(payload)
     }
 
     async fn build_create_client_payload(

diff --git a/crates/relayer-cosmos/src/methods/packet.rs b/crates/relayer-cosmos/src/methods/packet.rs
@@ -32,6 +32,12 @@ pub struct CosmosAckPacketPayload {
     pub proofs: Proofs,
 }
 
+pub struct CosmosTimeoutUnorderedPacketPayload {
+    pub height: Height,
+    pub packet: Packet,
+    pub proofs: Proofs,
+}
+
 pub async fn build_receive_packet_payload<Chain: ChainHandle>(
     chain: &CosmosChain<Chain>,
     height: &Height,
@@ -141,11 +147,11 @@ pub fn build_ack_packet_message(
     Ok(wrap_cosmos_message(message))
 }
 
-pub async fn build_timeout_unordered_packet_message<Chain: ChainHandle>(
+pub async fn build_timeout_unordered_packet_payload<Chain: ChainHandle>(
     chain: &CosmosChain<Chain>,
     height: &Height,
     packet: &Packet,
-) -> Result<Arc<dyn CosmosMessage>, Error> {
+) -> Result<CosmosTimeoutUnorderedPacketPayload, Error> {
     let height = *height;
     let packet = packet.clone();
 
@@ -168,22 +174,32 @@ pub async fn build_timeout_unordered_packet_message<Chain: ChainHandle>(
 
             let packet = packet.clone();
 
-            let message = CosmosIbcMessage::new(Some(height), move |signer| {
-                Ok(MsgTimeout::new(
-                    packet.clone(),
-                    packet.sequence,
-                    proofs.clone(),
-                    signer.clone(),
-                )
-                .to_any())
-            });
-
-            Ok(wrap_cosmos_message(message))
+            Ok(CosmosTimeoutUnorderedPacketPayload {
+                height,
+                packet,
+                proofs,
+            })
         })
         .await
         .map_err(BaseError::join)?
 }
 
+pub fn build_timeout_unordered_packet_message(
+    payload: CosmosTimeoutUnorderedPacketPayload,
+) -> Result<Arc<dyn CosmosMessage>, Error> {
+    let message = CosmosIbcMessage::new(Some(payload.height), move |signer| {
+        Ok(MsgTimeout::new(
+            payload.packet.clone(),
+            payload.packet.sequence,
+            payload.proofs.clone(),
+            signer.clone(),
+        )
+        .to_any())
+    });
+
+    Ok(wrap_cosmos_message(message))
+}
+
 pub async fn query_is_packet_received<Chain: ChainHandle>(
     chain: &CosmosChain<Chain>,
     port_id: &PortId,

diff --git a/crates/relayer-mock/src/relayer_mock/base/impls/chain.rs b/crates/relayer-mock/src/relayer_mock/base/impls/chain.rs
@@ -18,7 +18,9 @@ use ibc_relayer_components::chain::traits::message_builders::ack_packet::{
 use ibc_relayer_components::chain::traits::message_builders::receive_packet::{
     CanBuildReceivePacketMessage, CanBuildReceivePacketPayload,
 };
-use ibc_relayer_components::chain::traits::message_builders::timeout_unordered_packet::CanBuildTimeoutUnorderedPacketMessage;
+use ibc_relayer_components::chain::traits::message_builders::timeout_unordered_packet::{
+    CanBuildTimeoutUnorderedPacketMessage, CanBuildTimeoutUnorderedPacketPayload,
+};
 use ibc_relayer_components::chain::traits::message_sender::CanSendMessages;
 use ibc_relayer_components::chain::traits::queries::consensus_state::CanQueryConsensusState;
 use ibc_relayer_components::chain::traits::queries::received_packet::CanQueryReceivedPacket;
@@ -39,6 +41,7 @@ use ibc_relayer_components::chain::traits::types::message::{
 use ibc_relayer_components::chain::traits::types::packet::{HasIbcPacketFields, HasIbcPacketTypes};
 use ibc_relayer_components::chain::traits::types::packets::ack::HasAckPacketPayload;
 use ibc_relayer_components::chain::traits::types::packets::receive::HasReceivePacketPayload;
+use ibc_relayer_components::chain::traits::types::packets::timeout::HasTimeoutUnorderedPacketPayload;
 use ibc_relayer_components::chain::traits::types::status::HasChainStatusType;
 use ibc_relayer_components::chain::traits::types::timestamp::HasTimestampType;
 use ibc_relayer_components::core::traits::error::HasErrorType;
@@ -427,9 +430,14 @@ impl CanBuildAckPacketMessage<MockChainContext> for MockChainContext {
         Ok(payload)
     }
 }
+
+impl HasTimeoutUnorderedPacketPayload<MockChainContext> for MockChainContext {
+    type TimeoutUnorderedPacketPayload = MockMessage;
+}
+
 #[async_trait]
-impl CanBuildTimeoutUnorderedPacketMessage<MockChainContext> for MockChainContext {
-    async fn build_timeout_unordered_packet_message(
+impl CanBuildTimeoutUnorderedPacketPayload<MockChainContext> for MockChainContext {
+    async fn build_timeout_unordered_packet_payload(
         &self,
         height: &MockHeight,
         packet: &PacketKey,
@@ -448,3 +456,13 @@ impl CanBuildTimeoutUnorderedPacketMessage<MockChainContext> for MockChainContex
         Ok(MockMessage::TimeoutPacket(*height, packet.clone()))
     }
 }
+
+#[async_trait]
+impl CanBuildTimeoutUnorderedPacketMessage<MockChainContext> for MockChainContext {
+    async fn build_timeout_unordered_packet_message(
+        &self,
+        payload: MockMessage,
+    ) -> Result<MockMessage, Error> {
+        Ok(payload)
+    }
+}