Catch Polytone callback errors

packages/interchain/interchain-core/src/analysis.rs

@@ -8,11 +8,12 @@ use crate::tx::TxId;
 use crate::{IbcAckParser, InterchainError};
 use cosmwasm_std::{Binary, Empty};
 use cw_orch_core::environment::CwEnv;
+use cw_orch_core::environment::IndexResponse;
 
 /// Trait used for analysis of IBC packet flows
-pub trait PacketAnalysis {
+pub trait PacketAnalysis: IndexResponse {
     /// Result of the Analysis of the packet flows
-    type AnalysisResult<CustomResult>;
+    type AnalysisResult<CustomResult>: IndexResponse;
 
     /// Asserts that there is no timeout packet inside the result structure.
     fn assert_no_timeout(&self) -> Result<(), InterchainError>;
@@ -69,6 +70,45 @@ impl<T: PacketAnalysis> PacketAnalysis for IbcPacketOutcome<T> {
                 ack,
             } => {
                 let ibc_app_result = IbcAckParser::any_standard_app_result(&ack)?;
+
+                // In case we have a polytone result, we verify that the execution result is not a failure
+                if let crate::IbcAppResult::Polytone(_) = ibc_app_result {
+                    // An execution failure in the ack for polytone, has those events :
+                    // "method" --> "reply_callback_error"
+                    // "packet_sequence" --> <packet-sequence>
+                    // "callback_error" --> <callback-error>  to
+                    let callback_error = ack_tx
+                        .events()
+                        .into_iter()
+                        .filter(|e| e.ty == "wasm")
+                        .filter_map(|e| {
+                            let method_position = e.attributes.iter().position(|a| {
+                                a.key == "method" && a.value == "reply_callback_error"
+                            })?;
+                            if let Some(packet_sequence) = e.attributes.get(method_position + 1) {
+                                if packet_sequence.key != "packet_sequence" {
+                                    return None;
+                                }
+                            } else {
+                                return None;
+                            }
+                            if let Some(packet_sequence) = e.attributes.get(method_position + 2) {
+                                if packet_sequence.key != "callback_error" {
+                                    None
+                                } else {
+                                    Some(packet_sequence.value.clone())
+                                }
+                            } else {
+                                None
+                            }
+                        })
+                        .next();
+
+                    if let Some(callback_error) = callback_error {
+                        return Err(InterchainError::CallbackError(callback_error));
+                    }
+                };
+
                 Ok(IbcPacketResult {
                     receive_tx: receive_tx.assert()?,
                     ack_tx: ack_tx.assert()?,

packages/interchain/interchain-core/src/error.rs

@@ -58,4 +58,7 @@ pub enum InterchainError {
 
     #[error("Failure acknowledgment received: {0:?}")]
     FailedAckReceived(String),
+
+    #[error("Callback Failure during acknowledgment : {0:?}")]
+    CallbackError(String),
 }

packages/interchain/interchain-core/src/packet.rs

@@ -203,7 +203,7 @@ pub mod success {
     /// Success packet outcome. This is the result of a packet analysis.
     /// The T generic is used to allow for raw transactions or analyzed transactions to be used
     #[derive(Debug, PartialEq, Clone)]
-    pub struct IbcPacketResult<T, CustomResult = Empty> {
+    pub struct IbcPacketResult<T: IndexResponse, CustomResult = Empty> {
         /// The packets gets transmitted to the dst chain
         pub receive_tx: T,
         /// The ack is broadcasted back on the src chain
@@ -238,7 +238,7 @@ pub mod success {
             Vec<IbcPacketResult<SuccessNestedPacketsFlow<Chain, CustomResult>, CustomResult>>,
     }
 
-    impl<T: IndexResponse> IndexResponse for IbcPacketResult<T> {
+    impl<T: IndexResponse, CustomResult> IndexResponse for IbcPacketResult<T, CustomResult> {
         fn events(&self) -> Vec<cosmwasm_std::Event> {
             [self.receive_tx.events(), self.ack_tx.events()].concat()
         }
@@ -266,7 +266,7 @@ pub mod success {
         }
     }
 
-    impl<Chain: CwEnv> IndexResponse for SuccessSinglePacketFlow<Chain> {
+    impl<Chain: CwEnv, CustomResult> IndexResponse for SuccessSinglePacketFlow<Chain, CustomResult> {
         fn events(&self) -> Vec<cosmwasm_std::Event> {
             let mut events: Vec<_> = self
                 .send_tx
@@ -311,7 +311,7 @@ pub mod success {
         }
     }
 
-    impl<Chain: CwEnv> IndexResponse for SuccessNestedPacketsFlow<Chain> {
+    impl<Chain: CwEnv, CustomResult> IndexResponse for SuccessNestedPacketsFlow<Chain, CustomResult> {
         fn events(&self) -> Vec<cosmwasm_std::Event> {
             let mut self_events = self.tx_id.response.events();
             let other_events = self

packages/interchain/interchain-core/src/tx.rs

@@ -34,7 +34,7 @@ impl<C: CwEnv, CustomResult: std::fmt::Debug> std::fmt::Debug for TxId<C, Custom
     }
 }
 
-impl<Chain: CwEnv, CustomResult: std::fmt::Debug> IndexResponse for TxId<Chain, CustomResult> {
+impl<Chain: CwEnv, CustomResult> IndexResponse for TxId<Chain, CustomResult> {
     fn events(&self) -> Vec<cosmwasm_std::Event> {
         self.response.events()
     }