fix(deferredack): add custom ack type (#2069)

- Partially implements #2043 

Add custom ack type to write whatever bytes passed in.

cosmwasm/ucs01-relay-api/src/protocol.rs

@@ -260,7 +260,11 @@ pub trait TransferProtocol {
         let packet = Self::Packet::try_from(ibc_packet.clone().data)?;
         // same branch as failure ack
         let memo = Into::<String>::into(packet.extension().clone());
-        let ack = GenericAck::Err("giving up on forwarded packet after timeout".to_owned());
+        let ack = GenericAck::Err(
+            b"giving up on forwarded packet after timeout"
+                .to_vec()
+                .into(),
+        );
         let refund_msgs = if let Some((ack_msgs, _)) = self.pfm_ack(
             ack,
             ibc_packet.clone(),
@@ -302,17 +306,6 @@ pub trait TransferProtocol {
         let handle = || -> Result<IbcReceiveResponse<Self::CustomMsg>, Self::Error> {
             let packet = Self::Packet::try_from(original_packet.data.clone())?;
 
-            // NOTE: The default message ack is always successful and only
-            // overwritten if the submessage execution revert via the reply
-            // handler. The caller must ensure that the protocol is called in
-            // the reply handler via the `receive_error` for the acknowledgement
-            // to be overwritten.
-            let transfer_msgs = self
-                .receive_transfer(packet.receiver(), packet.tokens())?
-                .1
-                .into_iter()
-                .map(|msg| SubMsg::reply_on_error(msg, Self::RECEIVE_REPLY_ID));
-
             let memo = Into::<String>::into(packet.extension().clone());
 
             if let Ok(memo) = serde_json_wasm::from_str::<Memo>(&memo) {
@@ -324,6 +317,17 @@ pub trait TransferProtocol {
                 };
             }
 
+            // NOTE: The default message ack is always successful and only
+            // overwritten if the submessage execution revert via the reply
+            // handler. The caller must ensure that the protocol is called in
+            // the reply handler via the `receive_error` for the acknowledgement
+            // to be overwritten.
+            let transfer_msgs = self
+                .receive_transfer(packet.receiver(), packet.tokens())?
+                .1
+                .into_iter()
+                .map(|msg| SubMsg::reply_on_error(msg, Self::RECEIVE_REPLY_ID));
+
             let packet_event = if memo.is_empty() {
                 Event::new(PACKET_EVENT)
             } else {

cosmwasm/ucs01-relay-api/src/types.rs

@@ -2,7 +2,7 @@ use cosmwasm_schema::cw_serde;
 use cosmwasm_std::{Binary, Coin, HexBinary, IbcEndpoint, StdError, Uint128, Uint256};
 use ethabi::{ParamType, Token};
 
-pub type GenericAck = Result<Binary, String>;
+pub type GenericAck = Result<Binary, Binary>;
 
 #[derive(thiserror::Error, Debug)]
 pub enum EncodingError {
@@ -294,8 +294,8 @@ impl TryFrom<Binary> for Ucs01Ack {
 impl From<Ucs01Ack> for GenericAck {
     fn from(value: Ucs01Ack) -> Self {
         match value {
-            Ucs01Ack::Failure => Err(Default::default()),
-            Ucs01Ack::Success => Ok(Default::default()),
+            Ucs01Ack::Failure => Err([0].into()),
+            Ucs01Ack::Success => Ok([1].into()),
         }
     }
 }
@@ -332,8 +332,8 @@ impl TryFrom<Binary> for Ics20Ack {
 impl From<Ics20Ack> for GenericAck {
     fn from(value: Ics20Ack) -> Self {
         match value {
-            Ics20Ack::Result(err) => Ok(err),
-            Ics20Ack::Error(err) => Err(err),
+            Ics20Ack::Result(_) => Ok(value.try_into().unwrap()),
+            Ics20Ack::Error(_) => Err(value.try_into().unwrap()),
         }
     }
 }

cosmwasm/ucs01-relay/src/protocol.rs

@@ -3,10 +3,7 @@ use cosmwasm_std::{
     IbcEndpoint, IbcOrder, IbcPacket, IbcReceiveResponse, MessageInfo, Uint128, Uint512,
 };
 use prost::Message;
-use protos::{
-    deferredack::v1beta1::MsgWriteDeferredAck,
-    ibc::core::channel::v1::{acknowledgement::Response, Acknowledgement},
-};
+use protos::deferredack::v1beta1::MsgWriteDeferredAck;
 use sha2::{Digest, Sha256};
 use token_factory_api::TokenFactoryMsg;
 use ucs01_relay_api::{
@@ -671,17 +668,15 @@ impl<'a> TransferProtocol for Ics20Protocol<'a> {
                     Vec::from_iter(
                         (!value_string.is_empty()).then_some((ATTR_SUCCESS, value_string)),
                     ),
-                    Acknowledgement {
-                        response: Some(Response::Result(value.to_vec())),
-                    },
+                    value.to_vec(),
                 )
             }
             Err(error) => (
                 self.send_tokens_failure(sender, &String::new(), tokens)?,
-                Vec::from_iter((!error.is_empty()).then_some((ATTR_ERROR, error.clone()))),
-                Acknowledgement {
-                    response: Some(Response::Error(error)),
-                },
+                Vec::from_iter(
+                    (!error.is_empty()).then_some((ATTR_ERROR, error.clone().to_string())),
+                ),
+                error.to_vec(),
             ),
         };
 
@@ -709,7 +704,7 @@ impl<'a> TransferProtocol for Ics20Protocol<'a> {
         let value = MsgWriteDeferredAck {
             sender: self.self_addr().to_string(),
             deferred_packet_info: Some(deferred_packet_into),
-            ack: Some(ack_def),
+            ack: ack_def,
         }
         .encode_to_vec();
 
@@ -734,7 +729,7 @@ impl<'a> TransferProtocol for Ics20Protocol<'a> {
         match foreign_protocol {
             Ucs01Protocol::VERSION => Ok(match ack {
                 Ok(_) => Ucs01Protocol::ack_success(),
-                Err(e) => Ucs01Protocol::ack_failure(e),
+                Err(_) => Ucs01Protocol::ack_failure("".into()),
             }
             .into()),
             Ics20Protocol::VERSION => Ok(ack),
@@ -1057,17 +1052,15 @@ impl<'a> TransferProtocol for Ucs01Protocol<'a> {
                     Vec::from_iter(
                         (!value_string.is_empty()).then_some((ATTR_SUCCESS, value_string)),
                     ),
-                    Acknowledgement {
-                        response: Some(Response::Result(value.to_vec())),
-                    },
+                    value.to_vec(),
                 )
             }
             Err(error) => (
                 self.send_tokens_failure(sender, &String::new().as_bytes().into(), tokens)?,
-                Vec::from_iter((!error.is_empty()).then_some((ATTR_ERROR, error.clone()))),
-                Acknowledgement {
-                    response: Some(Response::Error(error)),
-                },
+                Vec::from_iter(
+                    (!error.is_empty()).then_some((ATTR_ERROR, error.clone().to_string())),
+                ),
+                error.to_vec(),
             ),
         };
 
@@ -1095,7 +1088,7 @@ impl<'a> TransferProtocol for Ucs01Protocol<'a> {
         let value = MsgWriteDeferredAck {
             sender: self.self_addr().to_string(),
             deferred_packet_info: Some(deferred_packet_into),
-            ack: Some(ack_def),
+            ack: ack_def,
         }
         .encode_to_vec();