Allow multiple ibc messages to be executed on host chain (#316)

* Added multiple messages to ibc action

* Removed multiple ibc client messages per proxy call

* Changelog

* Added multiple message data forwarding

* Resolve merge issue

* Update WASM & Schemas [skip ci]

* Update CI

---------

Co-authored-by: Kayanski <kowalski.kowalskin@gmail.com>
Co-authored-by: Kayanski <44806566+Kayanski@users.noreply.github.com>
Co-authored-by: CircleCI <circleci@example.com>

Author: 3 people

framework/artifacts/abstract_account_factory.wasm

@@ -1,8 +1,8 @@
-e87f5611c58944512dd88d26441d97d61ae1d459be6c3835e1e4181ed9df1f40  abstract_account_factory.wasm
-336233ca7487dd5a557ca69650d2e5f8fce499d81b39773b9c0c6abd403f2bb5  abstract_ans_host.wasm
-b3822190e0ab5b49e65587ccceaa88664134325bbdfd9b080c35d2eca9e098ba  abstract_ibc_client.wasm
-31ba0dd2f903205822ad068ec734a72f615b813a318017510939504802352fec  abstract_ibc_host.wasm
-02d314a4de51756f8d306e0596076bceb684e29eec576b1b3895f215b3b96b12  abstract_manager.wasm
-8ddb7cc45c35aed03c016f437f4130f0f0096b9bba6814b6a4a058afb6df6fcb  abstract_module_factory.wasm
-7d2af1e6592a3f2d468e2958c02de21ad2573528d961a77a3bc91a3c8612e087  abstract_proxy.wasm
-46de44a932793283046b65f3900aeaf8ca92b67a21d24fc6740e42f35987b701  abstract_version_control.wasm
+72aa875df6c2a783d4593352e466cfbd72a58a96408e3a7d5d121304ba08ab12  abstract_account_factory.wasm
+eb93f35d6aa8b9ad96ae641e77c51dd8efb89981c512a4d21df655b0e5235b27  abstract_ans_host.wasm
+7f86b7486fcc4430763f303ee18c0f0ad170991edfdad639819539871142836b  abstract_ibc_client.wasm
+dea2280769325f2f8804273077c9552fe95e06f3b765c78394c4f2d82686f3d4  abstract_ibc_host.wasm
+794ba247cf1dbb8647d505fcb1ec08b6411fe91ec9afcf80e36cd5024e878ec5  abstract_manager.wasm
+108b0f2994f3e249a4ecd1101e7c3d81beb941bd92e520840572d42deccb178f  abstract_module_factory.wasm
+a6c81713723ae5ab5b9e9b8f476e30d8aefad16760250dde8305791c33fad389  abstract_proxy.wasm
+cd1785ac5e325c3302c487a7d8b7797241fb711de2f20631cc75cd17b6005c75  abstract_version_control.wasm

framework/artifacts/abstract_ans_host.wasm

@@ -47,11 +47,7 @@ pub fn execute_module_action_response(
 
 /// Executes IBC actions forwarded by whitelisted contracts
 /// Calls the messages on the IBC client (ensuring permission)
-pub fn execute_ibc_action(
-    deps: DepsMut,
-    msg_info: MessageInfo,
-    msgs: Vec<IbcClientMsg>,
-) -> ProxyResult {
+pub fn execute_ibc_action(deps: DepsMut, msg_info: MessageInfo, msg: IbcClientMsg) -> ProxyResult {
     let state = STATE.load(deps.storage)?;
     if !state.modules.contains(&msg_info.sender) {
         return Err(ProxyError::SenderNotWhitelisted {});
@@ -64,19 +60,15 @@ pub fn execute_ibc_action(
                 "ibc_client not found on manager. Add it under the {IBC_CLIENT} name."
             ))
         })?;
-    let client_msgs: Result<Vec<_>, _> = msgs
-        .into_iter()
-        .map(|execute_msg| {
-            let funds_to_send = if let IbcClientMsg::SendFunds { funds, .. } = &execute_msg {
-                funds.to_vec()
-            } else {
-                vec![]
-            };
-            wasm_execute(&ibc_client_address, &execute_msg, funds_to_send)
-        })
-        .collect();
 
-    Ok(ProxyResponse::action("execute_ibc_action").add_messages(client_msgs?))
+    let funds_to_send = if let IbcClientMsg::SendFunds { funds, .. } = &msg {
+        funds.to_vec()
+    } else {
+        vec![]
+    };
+    let client_msg = wasm_execute(ibc_client_address, &msg, funds_to_send)?;
+
+    Ok(ProxyResponse::action("execute_ibc_action").add_message(client_msg))
 }
 
 /// Update the stored vault asset information
@@ -415,12 +407,12 @@ mod test {
                 .unwrap();
 
             let msg = ExecuteMsg::IbcAction {
-                msgs: vec![abstract_std::ibc_client::ExecuteMsg::Register {
+                msg: abstract_std::ibc_client::ExecuteMsg::Register {
                     host_chain: "juno".into(),
                     base_asset: None,
                     namespace: None,
                     install_modules: vec![],
-                }],
+                },
             };
 
             let not_whitelisted_info = mock_info(TEST_MANAGER, &[]);
@@ -471,10 +463,10 @@ mod test {
 
             let funds = coins(10, "denom");
             let msg = ExecuteMsg::IbcAction {
-                msgs: vec![abstract_std::ibc_client::ExecuteMsg::SendFunds {
+                msg: abstract_std::ibc_client::ExecuteMsg::SendFunds {
                     host_chain: "juno".to_owned(),
                     funds: funds.clone(),
-                }],
+                },
             };
 
             let not_whitelisted_info = mock_info(TEST_MANAGER, &[]);

framework/artifacts/abstract_ibc_client.wasm

@@ -76,7 +76,7 @@ pub fn execute(deps: DepsMut, _env: Env, info: MessageInfo, msg: ExecuteMsg) ->
     match msg {
         ExecuteMsg::ModuleAction { msgs } => execute_module_action(deps, info, msgs),
         ExecuteMsg::ModuleActionWithData { msg } => execute_module_action_response(deps, info, msg),
-        ExecuteMsg::IbcAction { msgs } => execute_ibc_action(deps, info, msgs),
+        ExecuteMsg::IbcAction { msg } => execute_ibc_action(deps, info, msg),
         ExecuteMsg::SetAdmin { admin } => set_admin(deps, info, &admin),
         ExecuteMsg::AddModules { modules } => add_modules(deps, info, modules),
         ExecuteMsg::RemoveModule { module } => remove_module(deps, info, module),

framework/artifacts/abstract_ibc_host.wasm

@@ -444,6 +444,7 @@ mod tests {
 
     mod remote_action {
         use super::*;
+        use std::str::FromStr;
 
         use abstract_std::{
             ibc_host::{self, HostAction, InternalAction},
@@ -465,11 +466,11 @@ mod tests {
             let msg = ExecuteMsg::RemoteAction {
                 host_chain: chain_name.to_string(),
                 action: HostAction::Dispatch {
-                    manager_msg: manager::ExecuteMsg::UpdateInfo {
+                    manager_msgs: vec![manager::ExecuteMsg::UpdateInfo {
                         name: None,
                         description: None,
                         link: None,
-                    },
+                    }],
                 },
             };
 
@@ -533,11 +534,11 @@ mod tests {
             )?;
 
             let action = HostAction::Dispatch {
-                manager_msg: manager::ExecuteMsg::UpdateInfo {
+                manager_msgs: vec![manager::ExecuteMsg::UpdateInfo {
                     name: None,
                     description: None,
                     link: None,
-                },
+                }],
             };
 
             let msg = ExecuteMsg::RemoteAction {

framework/artifacts/abstract_manager.wasm

@@ -80,18 +80,24 @@ pub fn receive_register(
 pub fn receive_dispatch(
     _deps: DepsMut,
     account: AccountBase,
-    manager_msg: manager::ExecuteMsg,
+    manager_msgs: Vec<manager::ExecuteMsg>,
 ) -> HostResult {
     // execute the message on the manager
-    let manager_call_msg = wasm_execute(account.manager, &manager_msg, vec![])?;
+    let msgs = manager_msgs
+        .into_iter()
+        .map(|msg| wasm_execute(&account.manager, &msg, vec![]))
+        .collect::<Result<Vec<_>, _>>()?;
 
-    // We want to forward the data that this execution gets
-    let submsg = SubMsg::reply_on_success(manager_call_msg, RESPONSE_REPLY_ID);
+    let response = Response::new()
+        .add_attribute("action", "receive_dispatch")
+        // This is used to forward the data of the calling message
+        // This means that only the last present data of will be forwarded
+        .add_submessages(
+            msgs.into_iter()
+                .map(|m| SubMsg::reply_on_success(m.clone(), RESPONSE_REPLY_ID)),
+        );
 
-    // Polytone handles all the necessary
-    Ok(Response::new()
-        .add_submessage(submsg)
-        .add_attribute("action", "receive_dispatch"))
+    Ok(response)
 }
 
 /// processes PacketMsg::SendAllBack variant

framework/artifacts/abstract_module_factory.wasm

@@ -54,8 +54,8 @@ pub fn handle_host_action(
             // If this account already exists, we can propagate the action
             if let Ok(account) = account_commands::get_account(deps.as_ref(), &account_id) {
                 match action {
-                    HostAction::Dispatch { manager_msg } => {
-                        receive_dispatch(deps, account, manager_msg)
+                    HostAction::Dispatch { manager_msgs } => {
+                        receive_dispatch(deps, account, manager_msgs)
                     }
                     HostAction::Helpers(helper_action) => match helper_action {
                         HelperAction::SendAllBack => {

framework/artifacts/abstract_proxy.wasm

@@ -284,11 +284,11 @@ fn account_action() -> anyhow::Result<()> {
         .ibc_execute(
             AccountId::local(account_sequence),
             HostAction::Dispatch {
-                manager_msg: abstract_std::manager::ExecuteMsg::ProposeOwner {
+                manager_msgs: vec![abstract_std::manager::ExecuteMsg::ProposeOwner {
                     owner: GovernanceDetails::Monarchy {
                         monarch: mock.addr_make("new_owner").to_string(),
                     },
-                },
+                }],
             },
             proxy_addr.to_string(),
         )
@@ -336,11 +336,11 @@ fn execute_action_with_account_creation() -> anyhow::Result<()> {
         .ibc_execute(
             AccountId::local(account_sequence),
             HostAction::Dispatch {
-                manager_msg: abstract_std::manager::ExecuteMsg::ProposeOwner {
+                manager_msgs: vec![abstract_std::manager::ExecuteMsg::ProposeOwner {
                     owner: GovernanceDetails::Monarchy {
                         monarch: mock.addr_make("new_owner").to_string(),
                     },
-                },
+                }],
             },
             mock.addr_make("proxy_address").to_string(),
         )

framework/artifacts/abstract_version_control.wasm

@@ -9,6 +9,7 @@
 - Added helper functions `assert_registered` and `is_registered` to the ANS client API.
 - Added method `module_info` for querying and verifying wether an address is a module to the ModuleRegistry API.
 - Added default IBC-Client installation on remote modules inside Client and Account interfaces
+- Send multiple message simultaneously through IBC
 
 ### Changed
 
@@ -20,6 +21,7 @@
 ### Removed
 
 - unused `custom_swap` of `DexCommand`
+- Send multiple messages to multiple IBC connected chains in one manager message. 
 
 ## [0.21.0] - 2024-02-20
 

framework/artifacts/checksums.txt

@@ -576,12 +576,12 @@ impl<Chain: CwEnv> Account<Chain> {
                 &abstract_std::manager::ExecuteMsg::ExecOnModule {
                     module_id: PROXY.to_owned(),
                     exec_msg: to_json_binary(&abstract_std::proxy::ExecuteMsg::IbcAction {
-                        msgs: vec![ibc_client::ExecuteMsg::Register {
+                        msg: ibc_client::ExecuteMsg::Register {
                             host_chain: host_chain.into(),
                             base_asset,
                             namespace,
                             install_modules,
-                        }],
+                        },
                     })
                     .map_err(AbstractInterfaceError::from)?,
                 },

framework/contracts/account/proxy/src/commands.rs

@@ -200,15 +200,15 @@ impl<Chain: CwEnv> Manager<Chain> {
     {
         let result = self.exec_on_module(
             to_json_binary(&abstract_std::proxy::ExecuteMsg::IbcAction {
-                msgs: vec![abstract_std::ibc_client::ExecuteMsg::Register {
+                msg: abstract_std::ibc_client::ExecuteMsg::Register {
                     host_chain: host_chain.into(),
                     base_asset: None,
                     namespace: None,
                     install_modules: vec![ModuleInstallConfig::new(
                         ModuleInfo::from_id_latest(IBC_CLIENT)?,
                         None,
                     )],
-                }],
+                },
             })?,
             PROXY.to_string(),
             &[],
@@ -224,10 +224,12 @@ impl<Chain: CwEnv> Manager<Chain> {
     ) -> Result<<Chain as cw_orch::prelude::TxHandler>::Response, crate::AbstractInterfaceError>
     {
         let msg = abstract_std::proxy::ExecuteMsg::IbcAction {
-            msgs: vec![abstract_std::ibc_client::ExecuteMsg::RemoteAction {
+            msg: abstract_std::ibc_client::ExecuteMsg::RemoteAction {
                 host_chain: host_chain.into(),
-                action: HostAction::Dispatch { manager_msg: msg },
-            }],
+                action: HostAction::Dispatch {
+                    manager_msgs: vec![msg],
+                },
+            },
         };
 
         self.execute_on_module(PROXY, msg)
@@ -241,15 +243,15 @@ impl<Chain: CwEnv> Manager<Chain> {
     ) -> Result<<Chain as cw_orch::prelude::TxHandler>::Response, crate::AbstractInterfaceError>
     {
         let msg = abstract_std::proxy::ExecuteMsg::IbcAction {
-            msgs: vec![abstract_std::ibc_client::ExecuteMsg::RemoteAction {
+            msg: abstract_std::ibc_client::ExecuteMsg::RemoteAction {
                 host_chain: host_chain.into(),
                 action: HostAction::Dispatch {
-                    manager_msg: ExecuteMsg::ExecOnModule {
+                    manager_msgs: vec![ExecuteMsg::ExecOnModule {
                         module_id: module_id.to_string(),
                         exec_msg: msg,
-                    },
+                    }],
                 },
-            }],
+            },
         };
 
         self.execute_on_module(PROXY, msg)
@@ -261,10 +263,10 @@ impl<Chain: CwEnv> Manager<Chain> {
     ) -> Result<<Chain as cw_orch::prelude::TxHandler>::Response, crate::AbstractInterfaceError>
     {
         let msg = abstract_std::proxy::ExecuteMsg::IbcAction {
-            msgs: vec![abstract_std::ibc_client::ExecuteMsg::RemoteAction {
+            msg: abstract_std::ibc_client::ExecuteMsg::RemoteAction {
                 host_chain: host_chain.into(),
                 action: HostAction::Helpers(HelperAction::SendAllBack),
-            }],
+            },
         };
 
         self.execute_on_module(PROXY, msg)