Support AckPacket payload

crates/relayer-all-in-one/src/one_for_all/impls/chain/message/ack_packet.rs

@@ -1,25 +1,53 @@
 use async_trait::async_trait;
-use ibc_relayer_components::chain::traits::message_builders::ack_packet::CanBuildAckPacketMessage;
+use ibc_relayer_components::chain::traits::message_builders::ack_packet::{
+    CanBuildAckPacketMessage, CanBuildAckPacketPayload,
+};
+use ibc_relayer_components::chain::traits::types::packets::ack::HasAckPacketPayload;
 
 use crate::one_for_all::traits::chain::OfaIbcChain;
 use crate::one_for_all::types::chain::OfaChainWrapper;
 use crate::std_prelude::*;
 
 #[async_trait]
-impl<Chain, Counterparty> CanBuildAckPacketMessage<OfaChainWrapper<Counterparty>>
+impl<Chain, Counterparty> HasAckPacketPayload<OfaChainWrapper<Counterparty>>
     for OfaChainWrapper<Chain>
 where
     Chain: OfaIbcChain<Counterparty>,
     Counterparty: OfaIbcChain<Chain>,
 {
-    async fn build_ack_packet_message(
+    type AckPacketPayload = Chain::AckPacketPayload;
+}
+
+#[async_trait]
+impl<Chain, Counterparty> CanBuildAckPacketPayload<OfaChainWrapper<Counterparty>>
+    for OfaChainWrapper<Chain>
+where
+    Chain: OfaIbcChain<Counterparty>,
+    Counterparty: OfaIbcChain<Chain>,
+{
+    async fn build_ack_packet_payload(
         &self,
         height: &Self::Height,
         packet: &Self::IncomingPacket,
         ack: &Self::WriteAcknowledgementEvent,
-    ) -> Result<Counterparty::Message, Self::Error> {
+    ) -> Result<Self::AckPacketPayload, Self::Error> {
         self.chain
-            .build_ack_packet_message(height, packet, ack)
+            .build_ack_packet_payload(height, packet, ack)
             .await
     }
 }
+
+#[async_trait]
+impl<Chain, Counterparty> CanBuildAckPacketMessage<OfaChainWrapper<Counterparty>>
+    for OfaChainWrapper<Chain>
+where
+    Chain: OfaIbcChain<Counterparty>,
+    Counterparty: OfaIbcChain<Chain>,
+{
+    async fn build_ack_packet_message(
+        &self,
+        payload: Counterparty::AckPacketPayload,
+    ) -> Result<Self::Message, Self::Error> {
+        self.chain.build_ack_packet_message(payload).await
+    }
+}

crates/relayer-all-in-one/src/one_for_all/traits/chain.rs

@@ -168,6 +168,8 @@ pub trait OfaChainTypes: Async {
     type ChannelOpenTryEvent: Async;
 
     type ReceivePacketPayload: Async;
+
+    type AckPacketPayload: Async;
 }
 
 #[async_trait]
@@ -337,12 +339,17 @@ where
         payload: Counterparty::ReceivePacketPayload,
     ) -> Result<Self::Message, Self::Error>;
 
-    async fn build_ack_packet_message(
+    async fn build_ack_packet_payload(
         &self,
         height: &Self::Height,
         packet: &Self::IncomingPacket,
         ack: &Self::WriteAcknowledgementEvent,
-    ) -> Result<Counterparty::Message, Self::Error>;
+    ) -> Result<Self::AckPacketPayload, Self::Error>;
+
+    async fn build_ack_packet_message(
+        &self,
+        payload: Counterparty::AckPacketPayload,
+    ) -> Result<Self::Message, Self::Error>;
 
     async fn build_timeout_unordered_packet_message(
         &self,

crates/relayer-components/src/chain/traits/message_builders/ack_packet.rs

@@ -3,6 +3,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::ibc_events::write_ack::HasWriteAcknowledgementEvent;
+use crate::chain::traits::types::message::HasMessageType;
 use crate::chain::traits::types::packet::HasIbcPacketTypes;
 use crate::chain::traits::types::packets::ack::HasAckPacketPayload;
 use crate::core::traits::error::HasErrorType;
@@ -27,18 +28,12 @@ where
 }
 
 #[async_trait]
-pub trait CanBuildAckPacketMessage<Counterparty>:
-    HasWriteAcknowledgementEvent<Counterparty>
-    + HasIbcPacketTypes<Counterparty>
-    + HasHeightType
-    + HasErrorType
+pub trait CanBuildAckPacketMessage<Counterparty>: HasMessageType + HasErrorType
 where
-    Counterparty: HasIbcChainTypes<Self>,
+    Counterparty: HasAckPacketPayload<Self>,
 {
     async fn build_ack_packet_message(
         &self,
-        height: &Self::Height,
-        packet: &Self::IncomingPacket,
-        ack: &Self::WriteAcknowledgementEvent,
-    ) -> Result<Counterparty::Message, Self::Error>;
+        payload: Counterparty::AckPacketPayload,
+    ) -> Result<Self::Message, Self::Error>;
 }

crates/relayer-components/src/relay/impls/packet_relayers/ack/base_ack_packet.rs

@@ -1,6 +1,8 @@
 use async_trait::async_trait;
 
-use crate::chain::traits::message_builders::ack_packet::CanBuildAckPacketMessage;
+use crate::chain::traits::message_builders::ack_packet::{
+    CanBuildAckPacketMessage, CanBuildAckPacketPayload,
+};
 use crate::chain::types::aliases::{Height, WriteAcknowledgementEvent};
 use crate::relay::traits::chains::HasRelayChains;
 use crate::relay::traits::ibc_message_sender::CanSendSingleIbcMessage;
@@ -19,20 +21,27 @@ impl<Relay> AckPacketRelayer<Relay> for BaseAckPacketRelayer
 where
     Relay: HasRelayChains,
     Relay: CanSendSingleIbcMessage<SourceTarget>,
-    Relay::DstChain: CanBuildAckPacketMessage<Relay::SrcChain>,
+    Relay::DstChain: CanBuildAckPacketPayload<Relay::SrcChain>,
+    Relay::SrcChain: CanBuildAckPacketMessage<Relay::DstChain>,
 {
     async fn relay_ack_packet(
         relay: &Relay,
         destination_height: &Height<Relay::DstChain>,
         packet: &Packet<Relay>,
         ack: &WriteAcknowledgementEvent<Relay::DstChain, Relay::SrcChain>,
     ) -> Result<(), Relay::Error> {
-        let message = relay
+        let payload = relay
             .dst_chain()
-            .build_ack_packet_message(destination_height, packet, ack)
+            .build_ack_packet_payload(destination_height, packet, ack)
             .await
             .map_err(Relay::dst_chain_error)?;
 
+        let message = relay
+            .src_chain()
+            .build_ack_packet_message(payload)
+            .await
+            .map_err(Relay::src_chain_error)?;
+
         relay.send_message(SourceTarget, message).await?;
 
         Ok(())

crates/relayer-cosmos/src/impls/chain.rs

@@ -54,9 +54,9 @@ use crate::methods::connection::{
 use crate::methods::consensus_state::{find_consensus_state_height_before, query_consensus_state};
 use crate::methods::create_client::{build_create_client_message, build_create_client_payload};
 use crate::methods::packet::{
-    build_ack_packet_message, build_receive_packet_message, build_receive_packet_payload,
-    build_timeout_unordered_packet_message, query_is_packet_received,
-    query_write_acknowledgement_event, CosmosReceivePacketPayload,
+    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,
+    query_write_acknowledgement_event, CosmosAckPacketPayload, CosmosReceivePacketPayload,
 };
 use crate::methods::update_client::{build_update_client_message, build_update_client_payload};
 use crate::traits::message::CosmosMessage;
@@ -161,6 +161,8 @@ where
     type ChannelOpenTryEvent = CosmosChannelOpenTryEvent;
 
     type ReceivePacketPayload = CosmosReceivePacketPayload;
+
+    type AckPacketPayload = CosmosAckPacketPayload;
 }
 
 #[async_trait]
@@ -416,6 +418,7 @@ where
         ChannelOpenAckPayload = CosmosChannelOpenAckPayload,
         ChannelOpenConfirmPayload = CosmosChannelOpenConfirmPayload,
         ReceivePacketPayload = CosmosReceivePacketPayload,
+        AckPacketPayload = CosmosAckPacketPayload,
     >,
 {
     fn incoming_packet_src_channel_id(packet: &Packet) -> &ChannelId {
@@ -539,19 +542,26 @@ where
         &self,
         payload: CosmosReceivePacketPayload,
     ) -> Result<Arc<dyn CosmosMessage>, Error> {
-        build_receive_packet_message(payload).await
+        build_receive_packet_message(payload)
     }
 
     /// Construct an acknowledgement packet to be sent from a Cosmos
     /// chain that successfully received a packet from another Cosmos
     /// chain.
-    async fn build_ack_packet_message(
+    async fn build_ack_packet_payload(
         &self,
         height: &Height,
         packet: &Packet,
         ack: &WriteAcknowledgement,
+    ) -> Result<CosmosAckPacketPayload, Error> {
+        build_ack_packet_payload(self, height, packet, ack).await
+    }
+
+    async fn build_ack_packet_message(
+        &self,
+        payload: CosmosAckPacketPayload,
     ) -> Result<Arc<dyn CosmosMessage>, Error> {
-        build_ack_packet_message(self, height, packet, ack).await
+        build_ack_packet_message(payload)
     }
 
     /// Construct a timeout packet message to be sent between Cosmos chains

crates/relayer-cosmos/src/methods/packet.rs

@@ -25,6 +25,13 @@ pub struct CosmosReceivePacketPayload {
     pub proofs: Proofs,
 }
 
+pub struct CosmosAckPacketPayload {
+    pub height: Height,
+    pub packet: Packet,
+    pub ack: Vec<u8>,
+    pub proofs: Proofs,
+}
+
 pub async fn build_receive_packet_payload<Chain: ChainHandle>(
     chain: &CosmosChain<Chain>,
     height: &Height,
@@ -62,7 +69,7 @@ pub async fn build_receive_packet_payload<Chain: ChainHandle>(
         .map_err(BaseError::join)?
 }
 
-pub async fn build_receive_packet_message(
+pub fn build_receive_packet_message(
     payload: CosmosReceivePacketPayload,
 ) -> Result<Arc<dyn CosmosMessage>, Error> {
     let message = CosmosIbcMessage::new(Some(payload.height), move |signer| {
@@ -77,12 +84,12 @@ pub async fn build_receive_packet_message(
     Ok(wrap_cosmos_message(message))
 }
 
-pub async fn build_ack_packet_message<Chain: ChainHandle>(
+pub async fn build_ack_packet_payload<Chain: ChainHandle>(
     chain: &CosmosChain<Chain>,
     height: &Height,
     packet: &Packet,
     ack: &WriteAcknowledgement,
-) -> Result<Arc<dyn CosmosMessage>, Error> {
+) -> Result<CosmosAckPacketPayload, Error> {
     let height = *height;
     let packet = packet.clone();
     let ack = ack.clone();
@@ -107,22 +114,33 @@ pub async fn build_ack_packet_message<Chain: ChainHandle>(
             let packet = packet.clone();
             let ack = ack.ack.clone();
 
-            let message = CosmosIbcMessage::new(Some(height), move |signer| {
-                Ok(MsgAcknowledgement::new(
-                    packet.clone(),
-                    ack.clone().into(),
-                    proofs.clone(),
-                    signer.clone(),
-                )
-                .to_any())
-            });
-
-            Ok(wrap_cosmos_message(message))
+            Ok(CosmosAckPacketPayload {
+                height,
+                packet,
+                ack,
+                proofs,
+            })
         })
         .await
         .map_err(BaseError::join)?
 }
 
+pub fn build_ack_packet_message(
+    payload: CosmosAckPacketPayload,
+) -> Result<Arc<dyn CosmosMessage>, Error> {
+    let message = CosmosIbcMessage::new(Some(payload.height), move |signer| {
+        Ok(MsgAcknowledgement::new(
+            payload.packet.clone(),
+            payload.ack.clone().into(),
+            payload.proofs.clone(),
+            signer.clone(),
+        )
+        .to_any())
+    });
+
+    Ok(wrap_cosmos_message(message))
+}
+
 pub async fn build_timeout_unordered_packet_message<Chain: ChainHandle>(
     chain: &CosmosChain<Chain>,
     height: &Height,

crates/relayer-mock/src/relayer_mock/base/impls/chain.rs

@@ -12,7 +12,9 @@ use async_trait::async_trait;
 use eyre::eyre;
 use ibc_relayer_components::chain::traits::logs::event::CanLogChainEvent;
 use ibc_relayer_components::chain::traits::logs::packet::CanLogChainPacket;
-use ibc_relayer_components::chain::traits::message_builders::ack_packet::CanBuildAckPacketMessage;
+use ibc_relayer_components::chain::traits::message_builders::ack_packet::{
+    CanBuildAckPacketMessage, CanBuildAckPacketPayload,
+};
 use ibc_relayer_components::chain::traits::message_builders::receive_packet::{
     CanBuildReceivePacketMessage, CanBuildReceivePacketPayload,
 };
@@ -35,6 +37,7 @@ use ibc_relayer_components::chain::traits::types::message::{
     CanEstimateMessageSize, HasMessageType,
 };
 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::status::HasChainStatusType;
 use ibc_relayer_components::chain::traits::types::timestamp::HasTimestampType;
@@ -387,9 +390,13 @@ impl CanBuildReceivePacketMessage<MockChainContext> for MockChainContext {
     }
 }
 
+impl HasAckPacketPayload<MockChainContext> for MockChainContext {
+    type AckPacketPayload = MockMessage;
+}
+
 #[async_trait]
-impl CanBuildAckPacketMessage<MockChainContext> for MockChainContext {
-    async fn build_ack_packet_message(
+impl CanBuildAckPacketPayload<MockChainContext> for MockChainContext {
+    async fn build_ack_packet_payload(
         &self,
         height: &MockHeight,
         packet: &PacketKey,
@@ -414,6 +421,12 @@ impl CanBuildAckPacketMessage<MockChainContext> for MockChainContext {
     }
 }
 
+#[async_trait]
+impl CanBuildAckPacketMessage<MockChainContext> for MockChainContext {
+    async fn build_ack_packet_message(&self, payload: MockMessage) -> Result<MockMessage, Error> {
+        Ok(payload)
+    }
+}
 #[async_trait]
 impl CanBuildTimeoutUnorderedPacketMessage<MockChainContext> for MockChainContext {
     async fn build_timeout_unordered_packet_message(