feat: Add support for IBCv2 Sent entry point

Author: kulikthebird

CHANGELOG.md

@@ -27,6 +27,8 @@ and this project adheres to
 - cosmwasm-std: Add `cosmwasm_std::testing::Envs`, which is an `Env` factory for
   testing environments. It auto-increments block heights and timestamps. It
   allows for advanced configurations such as custom address prefixes. ([#2442])
+- cosmwasm-std: Add `Ibc2PacketSentMsg` message - ([#2477])
+- cosmwasm-vm: Add `ibc2_packet_sent` entrypoint ([#2477])
 
 ## Changed
 
@@ -125,6 +127,7 @@ and this project adheres to
 [#2467]: https://github.com/CosmWasm/cosmwasm/pull/2467
 [#2472]: https://github.com/CosmWasm/cosmwasm/pull/2472
 [#2473]: https://github.com/CosmWasm/cosmwasm/pull/2473
+[#2477]: https://github.com/CosmWasm/cosmwasm/pull/2477
 
 ## [2.2.0] - 2024-12-17
 

contracts/ibc2/src/contract.rs

@@ -120,3 +120,26 @@ pub fn ibc2_packet_timeout(
 
     Ok(IbcBasicResponse::default())
 }
+
+#[entry_point]
+pub fn ibc2_packet_sent(
+    deps: DepsMut,
+    _env: Env,
+    msg: Ibc2PacketSentMsg,
+) -> StdResult<IbcBasicResponse> {
+    let data = deps
+        .storage
+        .get(STATE_KEY)
+        .ok_or_else(|| StdError::generic_err("State not found."))?;
+    let state: State = from_json(data)?;
+
+    deps.storage.set(
+        STATE_KEY,
+        &to_json_vec(&State {
+            last_packet_sent: msg,
+            ..state
+        })?,
+    );
+
+    Ok(IbcBasicResponse::default())
+}

contracts/ibc2/src/state.rs

@@ -7,6 +7,7 @@ pub struct State {
     pub ibc2_packet_timeout_counter: u32,
     pub last_source_client: String,
     pub last_packet_seq: u64,
+    pub last_packet_sent: Ibc2PacketSentMsg,
 }
 
 pub const STATE_KEY: &[u8] = b"state";

packages/std/src/exports/exports.rs

@@ -583,6 +583,36 @@ where
     Region::from_vec(v).to_heap_ptr() as u32
 }
 
+/// do_ibc2_packet_sent is designed for use with #[entry_point] to make a "C" extern
+///
+/// contract_fn is called when there is an Ibc2 payload on port belonging
+/// to this contract waiting to be verified before sending it to another
+/// blockchain.
+///
+/// - `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_sent<Q, C, E>(
+    contract_fn: &dyn Fn(DepsMut<Q>, Env, Ibc2PacketSentMsg) -> 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_sent(
+        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>,
@@ -984,6 +1014,29 @@ where
     contract_fn(deps.as_mut(), env, msg).into()
 }
 
+#[cfg(feature = "ibc2")]
+fn _do_ibc2_packet_sent<Q, C, E>(
+    contract_fn: &dyn Fn(DepsMut<Q>, Env, Ibc2PacketSentMsg) -> Result<IbcBasicResponse<C>, E>,
+    env_ptr: *mut Region<Owned>,
+    msg_ptr: *mut Region<Owned>,
+) -> ContractResult<IbcReceiveResponse<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: Ibc2PacketSentMsg = try_into_contract_result!(from_json(msg));
+
+    let mut deps = deps_from_imports();
+    contract_fn(deps.as_mut(), env, msg).into()
+}
+
 /// Makes all bridges to external dependencies (i.e. Wasm imports) that are injected by the VM
 fn deps_from_imports<Q>() -> OwnedDeps<ExternalStorage, ExternalApi, ExternalQuerier, Q>
 where

packages/std/src/exports/mod.rs

@@ -10,7 +10,7 @@ pub use exports::{
     do_query, do_reply, do_sudo,
 };
 #[cfg(feature = "ibc2")]
-pub use exports::{do_ibc2_packet_receive, do_ibc2_packet_timeout};
+pub use exports::{do_ibc2_packet_receive, do_ibc2_packet_timeout, do_ibc2_packet_sent};
 #[cfg(feature = "stargate")]
 pub use exports::{
     do_ibc_channel_close, do_ibc_channel_connect, do_ibc_channel_open, do_ibc_packet_ack,

packages/std/src/ibc2.rs

@@ -132,6 +132,46 @@ impl Ibc2PacketTimeoutMsg {
     }
 }
 
+/// Ibc2PacketSentMsg represents a payload sent event in the IBC2 protocol.
+/// Since sending IBCv2 packets are permissionless, the IBC protocol indtroduce
+/// the extra entry point, where application can verify the message sent from
+/// a given port ID.
+/// 
+/// It includes details about the source and destination clients, and the sequence
+/// number of the packet.
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
+#[non_exhaustive]
+pub struct Ibc2PacketSentMsg {
+    /// The payload to be sent.
+    pub payload: Ibc2Payload,
+    /// The identifier of the client that originally sent the packet.
+    pub source_client: String,
+    /// The identifier of the client that was the intended recipient.
+    pub destination_client: String,
+    /// The sequence number of the sent packet.
+    pub packet_sequence: u64,
+    /// The address of the signer that sent the packet.
+    pub signer: Addr,
+}
+
+impl Ibc2PacketSentMsg {
+    pub fn new(
+        payload: Ibc2Payload,
+        source_client: String,
+        destination_client: String,
+        packet_sequence: u64,
+        signer: Addr,
+    ) -> Self {
+        Self {
+            payload,
+            source_client,
+            destination_client,
+            packet_sequence,
+            signer,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use serde_json::to_string;

packages/std/src/lib.rs

@@ -129,7 +129,7 @@ pub use crate::exports::{
     do_query, do_reply, do_sudo,
 };
 #[cfg(all(feature = "exports", target_arch = "wasm32", feature = "ibc2"))]
-pub use crate::exports::{do_ibc2_packet_receive, do_ibc2_packet_timeout};
+pub use crate::exports::{do_ibc2_packet_receive, do_ibc2_packet_timeout, do_ibc2_packet_sent};
 #[cfg(all(feature = "exports", target_arch = "wasm32", feature = "stargate"))]
 pub use crate::exports::{
     do_ibc_channel_close, do_ibc_channel_connect, do_ibc_channel_open, do_ibc_packet_ack,

packages/vm/src/calls.rs

@@ -67,6 +67,8 @@ mod read_limits {
     pub const RESULT_IBC_SOURCE_CALLBACK: usize = 64 * MI;
     /// Max length (in bytes) of the result data from a ibc_destination_callback call.
     pub const RESULT_IBC_DESTINATION_CALLBACK: usize = 64 * MI;
+    #[cfg(feature = "ibc2")]
+    pub const RESULT_IBC2_PACKET_SENT: usize = 64 * MI;
 }
 
 /// The limits for the JSON deserialization.
@@ -110,6 +112,9 @@ mod deserialization_limits {
     pub const RESULT_IBC_SOURCE_CALLBACK: usize = 256 * KI;
     /// Max length (in bytes) of the result data from a ibc_destination_callback call.
     pub const RESULT_IBC_DESTINATION_CALLBACK: usize = 256 * KI;
+    /// Max length (in bytes) of the result data from a ibc_packet_receive call.
+    #[cfg(any(feature = "ibc2"))]
+    pub const RESULT_IBC2_PACKET_SENT: usize = 256 * KI;
 }
 
 pub fn call_instantiate<A, S, Q, U>(
@@ -693,7 +698,7 @@ where
         instance,
         "ibc2_packet_receive",
         &[env, msg],
-        read_limits::RESULT_IBC_PACKET_RECEIVE,
+        read_limits::RESULT_IBC2_PACKET_SENT,
     )
 }
 
@@ -736,6 +741,46 @@ where
     )
 }
 
+
+#[cfg(feature = "ibc2")]
+pub fn call_ibc2_packet_sent_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_sent",
+        &[env, msg],
+        read_limits::RESULT_IBC2_PACKET_SENT,
+    )
+}
+
+#[cfg(feature = "ibc2")]
+pub fn call_ibc2_packet_sent<A, S, Q, U>(
+    instance: &mut Instance<A, S, Q>,
+    env: &Env,
+    msg: &Ibc2PacketSentMsg,
+) -> 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_sent_raw(instance, &env, &msg)?;
+    let result = from_slice(&data, deserialization_limits::RESULT_IBC2_PACKET_SENT)?;
+    Ok(result)
+}
+
 pub fn call_ibc_source_callback_raw<A, S, Q>(
     instance: &mut Instance<A, S, Q>,
     env: &[u8],
@@ -1367,5 +1412,25 @@ mod tests {
                 .unwrap()
                 .unwrap();
         }
+
+        #[test]
+        fn call_ibc2_packet_sent_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 = IbcPayload {
+                response_without_ack: false,
+                send_async_ack_for_prev_msg: false,
+            };
+            let ibc2_sent = mock_ibc2_packet_sent(&ibc2_msg).unwrap();
+            call_ibc2_packet_sent::<_, _, _, Empty>(&mut instance, &mock_env(), &ibc2_sent)
+                .unwrap()
+                .unwrap();
+        }
     }
 }

packages/vm/src/lib.rs

@@ -35,7 +35,7 @@ pub use crate::calls::{
 #[cfg(feature = "ibc2")]
 pub use crate::calls::{
     call_ibc2_packet_receive, call_ibc2_packet_receive_raw, call_ibc2_packet_timeout,
-    call_ibc2_packet_timeout_raw,
+    call_ibc2_packet_timeout_raw, call_ibc2_packet_sent, call_ibc2_packet_sent_raw,
 };
 #[cfg(feature = "stargate")]
 pub use crate::calls::{

packages/vm/src/static_analysis.rs

@@ -41,6 +41,8 @@ pub enum Entrypoint {
     Ibc2PacketReceive,
     #[strum(serialize = "ibc2_packet_timeout")]
     Ibc2PacketTimeout,
+    #[strum(serialize = "ibc2_packet_sent")]
+    Ibc2PacketSent,
 }
 
 // sort entrypoints by their &str representation