feat: Add IBCv2 timeout entrypoint

Author: kulikthebird

contracts/ibc2/src/contract.rs

@@ -1,7 +1,7 @@
 use cosmwasm_std::{
     entry_point, from_json, to_json_vec, Binary, Deps, DepsMut, Empty, Env, Ibc2Msg,
-    Ibc2PacketReceiveMsg, Ibc2Payload, IbcAcknowledgement, IbcReceiveResponse, MessageInfo,
-    QueryResponse, Response, StdAck, StdError, StdResult,
+    Ibc2PacketReceiveMsg, Ibc2PacketTimeoutMsg, Ibc2Payload, IbcAcknowledgement, IbcBasicResponse,
+    IbcReceiveResponse, MessageInfo, QueryResponse, Response, StdAck, StdError, StdResult,
 };
 
 use crate::msg::{IbcPayload, QueryMsg};
@@ -95,3 +95,12 @@ pub fn ibc2_packet_receive(
         Ok(resp)
     }
 }
+
+#[entry_point]
+pub fn ibc2_packet_timeout(
+    _deps: DepsMut,
+    _env: Env,
+    _msg: Ibc2PacketTimeoutMsg,
+) -> StdResult<IbcBasicResponse> {
+    Ok(IbcBasicResponse::default())
+}

packages/std/src/exports.rs

@@ -23,7 +23,7 @@ use crate::ibc::{
 };
 use crate::ibc::{IbcChannelOpenMsg, IbcChannelOpenResponse};
 #[cfg(feature = "ibc2")]
-use crate::ibc2::Ibc2PacketReceiveMsg;
+use crate::ibc2::{Ibc2PacketReceiveMsg, Ibc2PacketTimeoutMsg};
 use crate::imports::{ExternalApi, ExternalQuerier, ExternalStorage};
 use crate::memory::{Owned, Region};
 use crate::panic::install_panic_handler;
@@ -555,6 +555,36 @@ where
     Region::from_vec(v).to_heap_ptr() as u32
 }
 
+/// do_ibc_packet_timeout is designed for use with #[entry_point] to make a "C" extern
+///
+/// contract_fn is called when a packet that this contract previously sent has provably
+/// timedout and will never be relayed to the calling chain. This generally behaves
+/// like ick_ack_fn upon an acknowledgement containing an error.
+///
+/// - `Q`: custom query type (see QueryRequest)
+/// - `C`: custom response message type (see CosmosMsg)
+/// - `E`: error type for responses
+#[cfg(feature = "ibc2")]
+pub fn do_ibc2_packet_timeout<Q, C, E>(
+    contract_fn: &dyn Fn(DepsMut<Q>, Env, Ibc2PacketTimeoutMsg) -> Result<IbcBasicResponse<C>, E>,
+    env_ptr: u32,
+    msg_ptr: u32,
+) -> u32
+where
+    Q: CustomQuery,
+    C: CustomMsg,
+    E: ToString,
+{
+    install_panic_handler();
+    let res = _do_ibc2_packet_timeout(
+        contract_fn,
+        env_ptr as *mut Region<Owned>,
+        msg_ptr as *mut Region<Owned>,
+    );
+    let v = to_json_vec(&res).unwrap();
+    Region::from_vec(v).to_heap_ptr() as u32
+}
+
 fn _do_instantiate<Q, M, C, E>(
     instantiate_fn: &dyn Fn(DepsMut<Q>, Env, MessageInfo, M) -> Result<Response<C>, E>,
     env_ptr: *mut Region<Owned>,
@@ -945,3 +975,26 @@ where
     let mut deps = make_dependencies();
     contract_fn(deps.as_mut(), env, msg).into()
 }
+
+#[cfg(feature = "ibc2")]
+fn _do_ibc2_packet_timeout<Q, C, E>(
+    contract_fn: &dyn Fn(DepsMut<Q>, Env, Ibc2PacketTimeoutMsg) -> Result<IbcBasicResponse<C>, E>,
+    env_ptr: *mut Region<Owned>,
+    msg_ptr: *mut Region<Owned>,
+) -> ContractResult<IbcBasicResponse<C>>
+where
+    Q: CustomQuery,
+    C: CustomMsg,
+    E: ToString,
+{
+    let env: Vec<u8> =
+        unsafe { Region::from_heap_ptr(ptr::NonNull::new(env_ptr).unwrap()).into_vec() };
+    let msg: Vec<u8> =
+        unsafe { Region::from_heap_ptr(ptr::NonNull::new(msg_ptr).unwrap()).into_vec() };
+
+    let env: Env = try_into_contract_result!(from_json(env));
+    let msg: Ibc2PacketTimeoutMsg = try_into_contract_result!(from_json(msg));
+
+    let mut deps = make_dependencies();
+    contract_fn(deps.as_mut(), env, msg).into()
+}

packages/std/src/ibc2.rs

@@ -89,6 +89,35 @@ impl Ibc2PacketReceiveMsg {
     }
 }
 
+/// The message that is passed into `ibc2_packet_timeout`
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
+#[non_exhaustive]
+pub struct Ibc2PacketTimeoutMsg {
+    pub payload: Ibc2Payload,
+    pub source_client: String,
+    pub destination_client: String,
+    pub packet_sequence: u64,
+    pub relayer: Addr,
+}
+
+impl Ibc2PacketTimeoutMsg {
+    pub fn new(
+        payload: Ibc2Payload,
+        source_client: String,
+        destination_client: String,
+        packet_sequence: u64,
+        relayer: Addr,
+    ) -> Self {
+        Self {
+            payload,
+            source_client,
+            destination_client,
+            packet_sequence,
+            relayer,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use serde_json::to_string;

packages/std/src/lib.rs

@@ -77,7 +77,7 @@ pub use crate::ibc::{
     IbcSourceCallbackMsg, IbcSrcCallback, IbcTimeout, IbcTimeoutBlock, IbcTimeoutCallbackMsg,
     TransferMsgBuilder,
 };
-pub use crate::ibc2::{Ibc2Msg, Ibc2PacketReceiveMsg, Ibc2Payload};
+pub use crate::ibc2::{Ibc2Msg, Ibc2PacketReceiveMsg, Ibc2PacketTimeoutMsg, Ibc2Payload};
 #[cfg(feature = "iterator")]
 pub use crate::iterator::{Order, Record};
 pub use crate::math::{
@@ -124,15 +124,15 @@ mod imports;
 #[cfg(target_arch = "wasm32")]
 mod memory; // Used by exports and imports only. This assumes pointers are 32 bit long, which makes it untestable on dev machines.
 
-#[cfg(all(feature = "ibc2", target_arch = "wasm32"))]
-pub use crate::exports::do_ibc2_packet_receive;
 #[cfg(all(feature = "cosmwasm_2_2", target_arch = "wasm32"))]
 pub use crate::exports::do_migrate_with_info;
 #[cfg(target_arch = "wasm32")]
 pub use crate::exports::{
     do_execute, do_ibc_destination_callback, do_ibc_source_callback, do_instantiate, do_migrate,
     do_query, do_reply, do_sudo,
 };
+#[cfg(all(feature = "ibc2", target_arch = "wasm32"))]
+pub use crate::exports::{do_ibc2_packet_receive, do_ibc2_packet_timeout};
 #[cfg(all(feature = "stargate", target_arch = "wasm32"))]
 pub use crate::exports::{
     do_ibc_channel_close, do_ibc_channel_connect, do_ibc_channel_open, do_ibc_packet_ack,

packages/std/src/testing/mock.rs

@@ -24,7 +24,7 @@ use crate::ibc::{
     IbcTimeoutBlock,
 };
 #[cfg(feature = "ibc2")]
-use crate::ibc2::{Ibc2PacketReceiveMsg, Ibc2Payload};
+use crate::ibc2::{Ibc2PacketReceiveMsg, Ibc2PacketTimeoutMsg, Ibc2Payload};
 #[cfg(feature = "cosmwasm_1_1")]
 use crate::query::SupplyResponse;
 use crate::query::{
@@ -532,6 +532,27 @@ pub fn mock_ibc2_packet_recv(data: &impl Serialize) -> StdResult<Ibc2PacketRecei
     ))
 }
 
+/// Creates a Ibc2PacketTimeoutMsg for testing ibc2_packet_timeout. You set a few key parameters that are
+/// often parsed. If you want to set more, use this as a default and mutate other fields.
+/// The difference from mock_ibc_packet_recv is if `my_channel_id` is src or dest.
+#[cfg(feature = "ibc2")]
+pub fn mock_ibc2_packet_timeout(data: &impl Serialize) -> StdResult<Ibc2PacketTimeoutMsg> {
+    let payload = Ibc2Payload {
+        source_port: "wasm2srcport".to_string(),
+        destination_port: "wasm2destport".to_string(),
+        version: "v2".to_string(),
+        encoding: "json".to_string(),
+        value: to_json_binary(data)?,
+    };
+    Ok(Ibc2PacketTimeoutMsg::new(
+        payload,
+        "source_client".to_string(),
+        "destination_client".to_string(),
+        1,
+        Addr::unchecked("relayer"),
+    ))
+}
+
 /// Creates a IbcPacket for testing ibc_packet_{ack,timeout}. You set a few key parameters that are
 /// often parsed. If you want to set more, use this as a default and mutate other fields.
 /// The difference from mock_ibc_packet_recv is if `my_channel_id` is src or dest.

packages/std/src/testing/mod.rs

@@ -13,8 +13,6 @@ pub use assertions::assert_approx_eq_impl;
 pub use assertions::assert_hash_works_impl;
 
 pub use message_info::message_info;
-#[cfg(feature = "ibc2")]
-pub use mock::mock_ibc2_packet_recv;
 #[cfg(feature = "cosmwasm_1_3")]
 pub use mock::DistributionQuerier;
 #[cfg(feature = "staking")]
@@ -24,6 +22,8 @@ pub use mock::{
     mock_wasmd_attr, BankQuerier, MockApi, MockQuerier, MockQuerierCustomHandlerResult,
     MOCK_CONTRACT_ADDR,
 };
+#[cfg(feature = "ibc2")]
+pub use mock::{mock_ibc2_packet_recv, mock_ibc2_packet_timeout};
 #[cfg(feature = "stargate")]
 pub use mock::{
     mock_ibc_channel, mock_ibc_channel_close_confirm, mock_ibc_channel_close_init,

packages/vm/src/cache.rs

@@ -340,7 +340,9 @@ where
             has_ibc_entry_points: REQUIRED_IBC_EXPORTS
                 .iter()
                 .all(|required| exports.contains(required.as_ref())),
-            has_ibc2_entry_points: exports.contains(REQUIRED_IBC2_EXPORT.as_ref()),
+            has_ibc2_entry_points: REQUIRED_IBC2_EXPORT
+                .iter()
+                .all(|required| exports.contains(required.as_ref())),
             entrypoints,
             required_capabilities: required_capabilities_from_module(&module)
                 .into_iter()
@@ -1530,7 +1532,7 @@ mod tests {
         let checksum5 = cache.store_code(IBC2, true, true).unwrap();
         let report5 = cache.analyze(&checksum5).unwrap();
         let mut ibc2_contract_entrypoints = BTreeSet::from([E::Instantiate, E::Query]);
-        ibc2_contract_entrypoints.extend([REQUIRED_IBC2_EXPORT]);
+        ibc2_contract_entrypoints.extend(REQUIRED_IBC2_EXPORT);
         assert_eq!(
             report5,
             AnalysisReport {

packages/vm/src/calls.rs

@@ -16,7 +16,7 @@ use cosmwasm_std::{
 };
 
 #[cfg(feature = "ibc2")]
-use cosmwasm_std::Ibc2PacketReceiveMsg;
+use cosmwasm_std::{Ibc2PacketReceiveMsg, Ibc2PacketTimeoutMsg};
 
 use crate::backend::{BackendApi, Querier, Storage};
 use crate::conversion::ref_to_u32;
@@ -61,7 +61,7 @@ mod read_limits {
     #[cfg(feature = "stargate")]
     pub const RESULT_IBC_PACKET_ACK: usize = 64 * MI;
     /// Max length (in bytes) of the result data from a ibc_packet_timeout call.
-    #[cfg(feature = "stargate")]
+    #[cfg(any(feature = "stargate", feature = "ibc2"))]
     pub const RESULT_IBC_PACKET_TIMEOUT: usize = 64 * MI;
     /// Max length (in bytes) of the result data from a ibc_source_callback call.
     pub const RESULT_IBC_SOURCE_CALLBACK: usize = 64 * MI;
@@ -104,7 +104,7 @@ mod deserialization_limits {
     #[cfg(feature = "stargate")]
     pub const RESULT_IBC_PACKET_ACK: usize = 256 * KI;
     /// Max length (in bytes) of the result data from a ibc_packet_timeout call.
-    #[cfg(feature = "stargate")]
+    #[cfg(any(feature = "stargate", feature = "ibc2"))]
     pub const RESULT_IBC_PACKET_TIMEOUT: usize = 256 * KI;
     /// Max length (in bytes) of the result data from a ibc_source_callback call.
     pub const RESULT_IBC_SOURCE_CALLBACK: usize = 256 * KI;
@@ -697,6 +697,45 @@ where
     )
 }
 
+#[cfg(feature = "ibc2")]
+pub fn call_ibc2_packet_timeout<A, S, Q, U>(
+    instance: &mut Instance<A, S, Q>,
+    env: &Env,
+    msg: &Ibc2PacketTimeoutMsg,
+) -> VmResult<ContractResult<IbcBasicResponse<U>>>
+where
+    A: BackendApi + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+    U: DeserializeOwned + CustomMsg,
+{
+    let env = to_vec(env)?;
+    let msg = to_vec(msg)?;
+    let data = call_ibc2_packet_timeout_raw(instance, &env, &msg)?;
+    let result = from_slice(&data, deserialization_limits::RESULT_IBC_PACKET_TIMEOUT)?;
+    Ok(result)
+}
+
+#[cfg(feature = "ibc2")]
+pub fn call_ibc2_packet_timeout_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
+    env: &[u8],
+    msg: &[u8],
+) -> VmResult<Vec<u8>>
+where
+    A: BackendApi + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
+    instance.set_storage_readonly(false);
+    call_raw(
+        instance,
+        "ibc2_packet_timeout",
+        &[env, msg],
+        read_limits::RESULT_IBC_PACKET_TIMEOUT,
+    )
+}
+
 pub fn call_ibc_source_callback_raw<A, S, Q>(
     instance: &mut Instance<A, S, Q>,
     env: &[u8],
@@ -1283,9 +1322,15 @@ mod tests {
     #[cfg(feature = "ibc2")]
     mod ibc2 {
         use super::*;
-        use cosmwasm_std::testing::mock_ibc2_packet_recv;
+        use cosmwasm_std::testing::{mock_ibc2_packet_recv, mock_ibc2_packet_timeout};
         static IBC2: &[u8] = include_bytes!("../testdata/ibc2.wasm");
 
+        #[derive(serde::Serialize)]
+        pub struct IbcPayload {
+            pub response_without_ack: bool,
+            pub send_async_ack_for_prev_msg: bool,
+        }
+
         #[test]
         fn call_ibc2_packet_receive_works() {
             // init
@@ -1296,9 +1341,29 @@ mod tests {
                 .unwrap()
                 .unwrap();
 
+            let ibc2_msg = IbcPayload {
+                response_without_ack: false,
+                send_async_ack_for_prev_msg: false,
+            };
+            let ibc2_timeout = mock_ibc2_packet_recv(&ibc2_msg).unwrap();
+            call_ibc2_packet_receive::<_, _, _, Empty>(&mut instance, &mock_env(), &ibc2_timeout)
+                .unwrap()
+                .unwrap();
+        }
+
+        #[test]
+        fn call_ibc2_packet_timeout_works() {
+            // init
+            let mut instance = mock_instance(IBC2, &[]);
+            let info = mock_info("creator", &[]);
+            let instantiate_msg = br#"{}"#;
+            call_instantiate::<_, _, _, Empty>(&mut instance, &mock_env(), &info, instantiate_msg)
+                .unwrap()
+                .unwrap();
+
             let ibc2_msg = br#"SomeRandomMsg"#;
-            let ibc2_msg = mock_ibc2_packet_recv(ibc2_msg).unwrap();
-            call_ibc2_packet_receive::<_, _, _, Empty>(&mut instance, &mock_env(), &ibc2_msg)
+            let ibc2_msg = mock_ibc2_packet_timeout(ibc2_msg).unwrap();
+            call_ibc2_packet_timeout::<_, _, _, Empty>(&mut instance, &mock_env(), &ibc2_msg)
                 .unwrap()
                 .unwrap();
         }

packages/vm/src/lib.rs

@@ -33,7 +33,10 @@ pub use crate::calls::{
     call_sudo_raw,
 };
 #[cfg(feature = "ibc2")]
-pub use crate::calls::{call_ibc2_packet_receive, call_ibc2_packet_receive_raw};
+pub use crate::calls::{
+    call_ibc2_packet_receive, call_ibc2_packet_receive_raw, call_ibc2_packet_timeout,
+    call_ibc2_packet_timeout_raw,
+};
 #[cfg(feature = "stargate")]
 pub use crate::calls::{
     call_ibc_channel_close, call_ibc_channel_close_raw, call_ibc_channel_connect,

packages/vm/src/static_analysis.rs

@@ -39,6 +39,8 @@ pub enum Entrypoint {
     IbcDestinationCallback,
     #[strum(serialize = "ibc2_packet_receive")]
     Ibc2PacketReceive,
+    #[strum(serialize = "ibc2_packet_timeout")]
+    Ibc2PacketTimeout,
 }
 
 // sort entrypoints by their &str representation
@@ -62,7 +64,8 @@ pub const REQUIRED_IBC_EXPORTS: &[Entrypoint] = &[
     Entrypoint::IbcPacketTimeout,
 ];
 
-pub const REQUIRED_IBC2_EXPORT: &Entrypoint = &Entrypoint::Ibc2PacketReceive;
+pub const REQUIRED_IBC2_EXPORT: &[Entrypoint] =
+    &[Entrypoint::Ibc2PacketReceive, Entrypoint::Ibc2PacketTimeout];
 
 /// A trait that allows accessing shared functionality of `parity_wasm::elements::Module`
 /// and `wasmer::Module` in a shared fashion.