feat: split ibc and xcall (#358)

* feat: split ibc

* feat: split xcall

* fix: split tests

* fix: fix build and fmt

* fix: sequence no from connection

* fix: fix reply form host

* fix: remove fee handler

* fix: storage keys

* fix: xcall forward

* fix: cleanup

---------

Co-authored-by: sabinchitrakar <immortal.infidel@gmail.com>

Author: ibrizsabin

Cargo.toml

@@ -7,6 +7,8 @@ members = [
     "libraries/rust/common",
     "contracts/cosmwasm-vm/cw-mock-dapp",
     "contracts/cosmwasm-vm/cw-mock-ibc-core",
+    "contracts/cosmwasm-vm/cw-xcall-ibc-connection",
+     "contracts/cosmwasm-vm/cw-xcall-app",
 ]
 
 [workspace.package]

contracts/cosmwasm-vm/cw-common/Cargo.toml

@@ -21,6 +21,8 @@ hex = { version = "0.4.3", default-features = false}
 common = { path="../../../libraries/rust/common" }
 ibc-proto = { version = "0.26.0", default-features = false, features = ["parity-scale-codec", "borsh"] }
 prost = { version = "0.11.8", default-features = false,features=["prost-derive"]}
+
 [dev-dependencies]
 getrandom = {version = "0.2.9", default-features = false, features = ["custom"]}
 test-utils={path="../../../libraries/rust/test-utils"}
+

contracts/cosmwasm-vm/cw-common/src/client_response.rs

@@ -312,3 +312,8 @@ pub struct LightClientResponse {
     pub message_info: MessageInfo,
     pub ibc_endpoint: CwEndPoint,
 }
+
+#[cw_serde]
+pub struct XcallPacketAck {
+    pub acknowledgement: Vec<u8>,
+}

contracts/cosmwasm-vm/cw-common/src/lib.rs

@@ -9,6 +9,8 @@ pub mod hex_string;
 pub mod ibc_types;
 pub mod raw_types;
 pub mod types;
+pub mod xcall_app_msg;
+pub mod xcall_connection_msg;
 pub mod xcall_msg;
 use cosmwasm_std::{from_binary, from_slice, Binary, StdError};
 use serde::de::DeserializeOwned;

contracts/cosmwasm-vm/cw-common/src/xcall_app_msg.rs

@@ -0,0 +1,41 @@
+use cosmwasm_schema::cw_serde;
+use cosmwasm_std::{
+    Binary, IbcChannelCloseMsg, IbcChannelConnectMsg, IbcChannelOpenMsg, IbcPacketAckMsg,
+    IbcPacketReceiveMsg, IbcPacketTimeoutMsg,
+};
+
+#[cw_serde]
+pub enum ExecuteMsg {
+    SetAdmin {
+        address: String,
+    },
+    SetProtocol {
+        value: u128,
+    },
+    SetProtocolFeeHandler {
+        address: String,
+    },
+    SendCallMessage {
+        to: String,
+        data: Vec<u8>,
+        rollback: Option<Vec<u8>>,
+    },
+    ReceiveCallMessage {
+        data: Vec<u8>,
+    },
+
+    ExecuteCall {
+        request_id: u128,
+    },
+
+    ExecuteRollback {
+        sequence_no: u128,
+    },
+    UpdateAdmin {
+        address: String,
+    },
+    RemoveAdmin {},
+    SetTimeoutHeight {
+        height: u64,
+    },
+}

contracts/cosmwasm-vm/cw-common/src/xcall_connection_msg.rs

@@ -0,0 +1,54 @@
+use cosmwasm_schema::cw_serde;
+use cosmwasm_std::{
+    IbcChannelCloseMsg, IbcChannelConnectMsg, IbcChannelOpenMsg, IbcPacketAckMsg,
+    IbcPacketReceiveMsg, IbcPacketTimeoutMsg,
+};
+
+#[cw_serde]
+pub enum ExecuteMsg {
+    SetAdmin {
+        address: String,
+    },
+    SetXCallHost {
+        address: String,
+    },
+    MessageFromXCall {
+        data: Vec<u8>,
+    },
+    SetIbcConfig {
+        ibc_config: Vec<u8>,
+    },
+    UpdateAdmin {
+        address: String,
+    },
+    RemoveAdmin {},
+    SetTimeoutHeight {
+        height: u64,
+    },
+
+    #[cfg(not(feature = "native_ibc"))]
+    IbcChannelOpen {
+        msg: IbcChannelOpenMsg,
+    },
+
+    #[cfg(not(feature = "native_ibc"))]
+    IbcChannelConnect {
+        msg: IbcChannelConnectMsg,
+    },
+    #[cfg(not(feature = "native_ibc"))]
+    IbcChannelClose {
+        msg: IbcChannelCloseMsg,
+    },
+    #[cfg(not(feature = "native_ibc"))]
+    IbcPacketReceive {
+        msg: IbcPacketReceiveMsg,
+    },
+    #[cfg(not(feature = "native_ibc"))]
+    IbcPacketAck {
+        msg: IbcPacketAckMsg,
+    },
+    #[cfg(not(feature = "native_ibc"))]
+    IbcPacketTimeout {
+        msg: IbcPacketTimeoutMsg,
+    },
+}

contracts/cosmwasm-vm/cw-ibc-core/src/context.rs

@@ -1,9 +1,9 @@
 use super::*;
 /// The `CwIbcCoreContext` struct represents the core context of a Cosmos SDK contract for
 /// inter-blockchain communication.
-/// 
+///
 /// Properties:
-/// 
+///
 /// * `block_height`: A storage item representing the current block height.
 /// * `cw_ibc_store`: `cw_ibc_store` is an instance of the `CwIbcStore` struct, which is used to manage
 /// the storage of the contract. It likely contains methods for reading and writing data to the

contracts/cosmwasm-vm/cw-ibc-core/src/contract.rs

@@ -12,28 +12,28 @@ const CONTRACT_NAME: &str = "crates.io:cw-ibc-core";
 const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
 
 impl<'a> CwIbcCoreContext<'a> {
-   /// The `instantiate` function initializes the contract and sets default values for channel, client,
-   /// and connection counters, as well as setting the contract owner.
-   /// 
-   /// Arguments:
-   /// 
-   /// * `deps`: A mutable reference to the dependencies of the contract, which includes access to the
-   /// storage, API, and other contracts.
-   /// * `_env`: _env is an object that represents the current blockchain environment, including
-   /// information such as the block height, time, and chain ID. It is passed as a parameter to the
-   /// instantiate function in the CosmWasm smart contract framework.
-   /// * `info`: MessageInfo is a struct that contains information about the message being executed,
-   /// such as the sender address, the amount of tokens sent with the message, and the message ID. It is
-   /// passed as a parameter to the instantiate function in order to set the owner of the contract.
-   /// * `_msg`: The `_msg` parameter is of type `InstantiateMsg` and represents the message sent by the
-   /// user to instantiate the contract. It contains any custom data or parameters required for the
-   /// contract initialization.
-   /// 
-   /// Returns:
-   /// 
-   /// A `Result<Response, ContractError>` is being returned. The `Response` contains an attribute
-   /// "method" with the value "instantiate". If there are no errors, the `Result` will be `Ok`,
-   /// otherwise it will be `Err(ContractError::Std)`.
+    /// The `instantiate` function initializes the contract and sets default values for channel, client,
+    /// and connection counters, as well as setting the contract owner.
+    ///
+    /// Arguments:
+    ///
+    /// * `deps`: A mutable reference to the dependencies of the contract, which includes access to the
+    /// storage, API, and other contracts.
+    /// * `_env`: _env is an object that represents the current blockchain environment, including
+    /// information such as the block height, time, and chain ID. It is passed as a parameter to the
+    /// instantiate function in the CosmWasm smart contract framework.
+    /// * `info`: MessageInfo is a struct that contains information about the message being executed,
+    /// such as the sender address, the amount of tokens sent with the message, and the message ID. It is
+    /// passed as a parameter to the instantiate function in order to set the owner of the contract.
+    /// * `_msg`: The `_msg` parameter is of type `InstantiateMsg` and represents the message sent by the
+    /// user to instantiate the contract. It contains any custom data or parameters required for the
+    /// contract initialization.
+    ///
+    /// Returns:
+    ///
+    /// A `Result<Response, ContractError>` is being returned. The `Response` contains an attribute
+    /// "method" with the value "instantiate". If there are no errors, the `Result` will be `Ok`,
+    /// otherwise it will be `Err(ContractError::Std)`.
     pub fn instantiate(
         &self,
         deps: DepsMut,
@@ -53,9 +53,9 @@ impl<'a> CwIbcCoreContext<'a> {
     }
 
     /// This function handles the execution of various IBC-related messages in a contract.
-    /// 
+    ///
     /// Arguments:
-    /// 
+    ///
     /// * `deps`: `deps` is a `DepsMut` object, which provides access to the contract's dependencies
     /// such as storage, querier, and API interfaces. It is used to interact with the blockchain and
     /// other contracts.
@@ -68,9 +68,9 @@ impl<'a> CwIbcCoreContext<'a> {
     /// * `msg`: The `msg` parameter in the `execute` function is of type `CoreExecuteMsg` and
     /// represents the message that the contract should execute. The function matches the type of the
     /// message and calls the appropriate function to handle it.
-    /// 
+    ///
     /// Returns:
-    /// 
+    ///
     /// a `Result<Response, ContractError>` where `Response` is a struct representing the response to a
     /// contract execution and `ContractError` is an enum representing possible errors that can occur
     /// during contract execution.
@@ -269,19 +269,19 @@ impl<'a> CwIbcCoreContext<'a> {
 
     /// This function handles different types of replies based on their ID and executes the
     /// corresponding function.
-    /// 
+    ///
     /// Arguments:
-    /// 
+    ///
     /// * `deps`: `deps` is a mutable reference to the dependencies of the contract, which includes
     /// access to the storage, API, and other modules. It is of type `DepsMut`.
     /// * `_env`: _env is an object of type `Env` which represents the environment in which the contract
     /// is executing. It contains information such as the current block height, the current time, and
     /// the address of the contract.
     /// * `message`: The `message` parameter is of type `Reply` and contains information about the reply
     /// being processed, including the ID of the reply and any associated data.
-    /// 
+    ///
     /// Returns:
-    /// 
+    ///
     /// a `Result<Response, ContractError>` where `Response` and `ContractError` are defined types.
     pub fn reply(
         &self,
@@ -343,16 +343,16 @@ impl<'a> CwIbcCoreContext<'a> {
     }
 
     /// This function calculates the fee for a given expected gas amount and gas price.
-    /// 
+    ///
     /// Arguments:
-    /// 
+    ///
     /// * `expected_gas`: `expected_gas` is an input parameter of type `u64` which represents the
     /// expected amount of gas required to execute a transaction on the blockchain. Gas is a unit of
     /// measurement for the computational effort required to execute a transaction or contract on the
     /// Ethereum network. The higher the gas limit, the more
-    /// 
+    ///
     /// Returns:
-    /// 
+    ///
     /// The function `calculate_fee` returns a `u128` value, which represents the calculated fee based
     /// on the expected gas and the gas price.
     pub fn calculate_fee(&self, expected_gas: u64) -> u128 {
@@ -362,9 +362,9 @@ impl<'a> CwIbcCoreContext<'a> {
     }
 
     /// This function calculates the gas price in Rust programming language.
-    /// 
+    ///
     /// Returns:
-    /// 
+    ///
     /// an unsigned 128-bit integer, which represents the gas price calculated based on the default gas
     /// numerator and gas adjustment numerator values.
     pub fn gas_price(&self) -> u128 {
@@ -376,16 +376,16 @@ impl<'a> CwIbcCoreContext<'a> {
     }
     /// The function updates the balance of each coin in a vector by subtracting a fee and returns the
     /// updated vector.
-    /// 
+    ///
     /// Arguments:
-    /// 
+    ///
     /// * `coins`: A vector of `Coin` structs representing the current balance of the user. Each `Coin`
     /// struct contains an amount and a denomination.
     /// * `fee`: The `fee` parameter is an unsigned 128-bit integer representing the amount of fee to be
     /// deducted from each coin's balance.
-    /// 
+    ///
     /// Returns:
-    /// 
+    ///
     /// a `Result` type with a vector of `Coin` objects as the successful result or a `ContractError` if
     /// there is an insufficient balance.
     pub fn update_fee(&self, coins: Vec<Coin>, fee: u128) -> Result<Vec<Coin>, ContractError> {
@@ -407,13 +407,13 @@ impl<'a> CwIbcCoreContext<'a> {
 
     /// This function converts a hexadecimal string to a Rust type that implements the Message trait and
     /// can be converted to another type using the TryFrom trait.
-    /// 
+    ///
     /// Arguments:
-    /// 
+    ///
     /// * `hex_str`: A hexadecimal string that represents the serialized bytes of a protobuf message.
-    /// 
+    ///
     /// Returns:
-    /// 
+    ///
     /// a `Result` with a generic type `T` which is the converted message from the raw bytes provided in
     /// the `HexString`. If the conversion is successful, it returns an `Ok` variant with the converted
     /// message. If there is an error during the conversion, it returns an `Err` variant with a
@@ -443,13 +443,13 @@ impl<'a> CwIbcCoreContext<'a> {
 
     /// The function converts a hexadecimal string to a Signer object and returns an error if the
     /// conversion fails.
-    /// 
+    ///
     /// Arguments:
-    /// 
+    ///
     /// * `str`: A hexadecimal string representing a signer address.
-    /// 
+    ///
     /// Returns:
-    /// 
+    ///
     /// This function returns a `Result` containing either a `Signer` or a `ContractError`.
     pub fn to_signer(str: &HexString) -> Result<Signer, ContractError> {
         let bytes = str.to_bytes().map_err(|e| ContractError::IbcDecodeError {

contracts/cosmwasm-vm/cw-ibc-core/src/helpers.rs

@@ -10,25 +10,25 @@ pub struct CwTemplateContract(pub Addr);
 
 impl CwTemplateContract {
     /// The function returns a clone of the address stored in a struct.
-    /// 
+    ///
     /// Returns:
-    /// 
+    ///
     /// The `addr` function returns a clone of the `Addr` object stored in the first field of `self`.
     pub fn addr(&self) -> Addr {
         self.0.clone()
     }
 
     /// This function takes a message, converts it to binary, and returns a CosmosMsg to execute the
     /// message on a contract.
-    /// 
+    ///
     /// Arguments:
-    /// 
+    ///
     /// * `msg`: The `msg` parameter is a generic type that implements the `Into` trait for the
     /// `cw_common::core_msg::ExecuteMsg` type. It represents the message that will be sent to the
     /// contract when the `call` function is executed. The `Into` trait allows for the message to
-    /// 
+    ///
     /// Returns:
-    /// 
+    ///
     /// a `StdResult` which can either be `Ok` with a `CosmosMsg` or `Err` with an error message.
     pub fn call<T: Into<cw_common::core_msg::ExecuteMsg>>(&self, msg: T) -> StdResult<CosmosMsg> {
         let msg = to_binary(&msg.into())?;