ICA Client testing

framework/Cargo.toml

@@ -62,6 +62,9 @@ cw-orch-polytone = { package = "abstract-cw-orch-polytone", version = "6.0.1" }
 polytone         = { package = "abstract-polytone", version = "2.0.0" }
 polytone-note    = { package = "abstract-polytone-note", version = "5.0.0" }
 
+## evm
+evm-note     = { version = "0.3.1", features = ["library"] }
+polytone-evm = { version = "0.3.0" }
 
 ## crates in order of publishing ## see docs/Publishing.md
 
@@ -71,6 +74,7 @@ abstract-standalone = { path = "packages/abstract-standalone", version = "0.26.0
 
 # Keep these as path, creates cirular dependency otherwise
 # Only need to re-publish all contracts if a re-publish of abstract-interface is required
+abstract-client    = { path = "packages/abstract-client" }
 abstract-interface = { path = "packages/abstract-interface" }
 ans-host           = { package = "abstract-ans-host", path = "contracts/native/ans-host" }
 module-factory     = { package = "abstract-module-factory", path = "contracts/native/module-factory" }
@@ -82,7 +86,6 @@ ibc-host   = { package = "abstract-ibc-host", path = "contracts/native/ibc-host"
 
 abstract-account = { path = "contracts/account", default-features = false }
 
-abstract-ica     = { version = "0.26.0", path = "packages/abstract-ica" }
 abstract-sdk     = { version = "0.26.0", path = "packages/abstract-sdk" }
 abstract-std     = { version = "0.26.0", path = "packages/abstract-std" }
 abstract-testing = { version = "0.26.0", path = "packages/abstract-testing" }

framework/contracts/account/Cargo.toml

@@ -41,8 +41,6 @@ cw2             = { workspace = true }
 semver          = { workspace = true }
 thiserror       = { workspace = true }
 
-abstract-ica = { workspace = true }
-
 abstract-xion = { workspace = true, optional = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

framework/contracts/account/src/execution.rs

@@ -170,7 +170,7 @@ pub fn ica_action(
             ))
         })?;
 
-    let res: abstract_ica::msg::IcaActionResult = deps.querier.query(
+    let res: abstract_std::ica_client::IcaActionResult = deps.querier.query(
         &WasmQuery::Smart {
             contract_addr: ica_client_address.into(),
             msg: action_query,
@@ -508,7 +508,7 @@ mod test {
     }
 
     mod ica_action {
-        use abstract_ica::msg::IcaActionResult;
+        use abstract_std::ica_client::IcaActionResult;
         use abstract_std::ICA_CLIENT;
         use cosmwasm_std::{Binary, Empty};
 

framework/contracts/native/ica-client/Cargo.toml

@@ -19,7 +19,6 @@ default = ["export"]
 export  = []
 
 [dependencies]
-abstract-ica    = { workspace = true }
 abstract-macros = { workspace = true }
 abstract-sdk    = { workspace = true }
 abstract-std    = { workspace = true }
@@ -30,8 +29,14 @@ cw2             = { workspace = true }
 semver          = { workspace = true }
 thiserror       = { workspace = true }
 
-evm-note     = { version = "0.1.0", features = ["library"] }
-polytone-evm = "0.1.0"
+evm-note     = { workspace = true }
+polytone-evm = { workspace = true }
+
+alloy                       = { version = "0.12.6", default-features = false }
+alloy-sol-types             = { version = "0.8.23", default-features = false }
+ibc-union-spec              = { git = "https://github.com/AbstractSDK/union", branch = "adair/ibc-query-responses" }
+ucs03-zkgm                  = { git = "https://github.com/AbstractSDK/union", branch = "adair/ibc-query-responses", features = ["library"] }
+ucs03-zkgm-token-minter-api = { git = "https://github.com/AbstractSDK/union", branch = "adair/ibc-query-responses" }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 workspace-hack = { version = "0.1", path = "../../../workspace-hack" }

framework/contracts/native/ica-client/examples/schema.rs

@@ -1,4 +1,4 @@
-use abstract_ica::msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
+use abstract_std::ica_client::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
 use cosmwasm_schema::write_api;
 
 fn main() {

framework/contracts/native/ica-client/src/chain_types/evm.rs

@@ -1,15 +1,20 @@
-use abstract_ica::EVM_NOTE_ID;
+use std::{num::NonZeroU32, str::FromStr};
+
 use abstract_sdk::{
     feature_objects::{AnsHost, RegistryContract},
     Resolve,
 };
 use abstract_std::{
     ibc::PACKET_LIFETIME,
+    ica_client::EVM_NOTE_ID,
     native_addrs,
     objects::{module::ModuleInfo, ChannelEntry, ContractEntry, TruncatedChainId},
 };
+use alloy::primitives::U256;
+use alloy_sol_types::SolValue;
 use cosmwasm_std::{
-    wasm_execute, Addr, Binary, Coin, CosmosMsg, Deps, Env, HexBinary, QuerierWrapper, WasmMsg,
+    wasm_execute, Addr, Binary, Coin, CosmosMsg, Deps, Env, HexBinary, QuerierWrapper, StdError,
+    Uint256, Uint64, WasmMsg,
 };
 use evm_note::msg::{CallbackRequest, EvmMsg};
 
@@ -39,15 +44,21 @@ pub fn send_funds(
     deps: Deps,
     env: &Env,
     evm_chain: &TruncatedChainId,
-    funds: Vec<Coin>,
+    account_address: &Addr,
+    mut funds: Vec<Coin>,
     receiver: Option<Binary>,
     memo: Option<String>,
+    salt: Uint256,
 ) -> IcaClientResult<CosmosMsg> {
+    if funds.len() != 1 {
+        panic!("Currently only single funds supported");
+    }
+    let funds = funds.pop().unwrap();
     // Identify the remote recipient for the funds
     let abstract_code_id =
         native_addrs::abstract_code_id(&deps.querier, env.contract.address.clone())?;
 
-    let receiver: HexBinary = match receiver {
+    let receiver: Vec<u8> = match receiver {
         Some(r) => r.into(),
         None => {
             let registry = RegistryContract::new(deps, abstract_code_id)?;
@@ -62,7 +73,7 @@ pub fn send_funds(
             )?;
 
             match remote_acc {
-                Some(remote) => HexBinary::from_hex(&remote)?,
+                Some(remote) => remote.into_bytes(),
                 None => return Err(IcaClientError::NoRecipient {}),
             }
         }
@@ -73,48 +84,95 @@ pub fn send_funds(
     // Resolve the transfer channel id for the given chain
     let ucs_channel_entry = ChannelEntry {
         connected_chain: evm_chain.clone(),
-        protocol: types::UCS01_PROTOCOL.to_string(),
+        protocol: types::UCS03_ZKGM_PROTOCOL.to_string(),
     };
-    let ics20_channel_id = ucs_channel_entry.resolve(&deps.querier, &ans_host)?;
+    let channel_id = ucs_channel_entry.resolve(&deps.querier, &ans_host)?;
+    let channel_id =
+        NonZeroU32::from_str(&channel_id).map_err(|e| StdError::generic_err(e.to_string()))?;
 
     // Resolve the transfer channel id for the given chain
     let ucs_contract_entry = ContractEntry {
-        contract: types::UCS01_FORWARDER_CONTRACT.to_string(),
-        protocol: types::UCS01_PROTOCOL.to_string(),
+        contract: types::UCS03_ZKGM_CONTRACT.to_string(),
+        protocol: types::UCS03_ZKGM_PROTOCOL.to_string(),
     };
-    let ucs_forwarder_addr = ucs_contract_entry.resolve(&deps.querier, &ans_host)?;
-
-    // Construct forward packet on the forwarder
-    let forwarder_msg = wasm_execute(
-        ucs_forwarder_addr.clone(),
-        &types::Ucs01ForwarderExecuteMsg::Transfer {
-            channel: ics20_channel_id.clone(),
-            receiver: receiver.clone(),
-            memo: memo.unwrap_or_default(),
-            timeout: Some(3600),
+    let ucs03_zkgm_addr = ucs_contract_entry.resolve(&deps.querier, &ans_host)?;
+
+    let quote_token: ucs03_zkgm::msg::PredictWrappedTokenResponse = deps.querier.query_wasm_smart(
+        &ucs03_zkgm_addr,
+        &ucs03_zkgm::msg::QueryMsg::PredictWrappedToken {
+            path: U256::ZERO.to_string(),
+            channel_id: channel_id.into(),
+            token: funds.denom.clone().into_bytes().into(),
         },
-        funds,
-    )?
-    .into();
+    )?;
+
+    let minter: Addr = deps
+        .querier
+        .query_wasm_smart(&ucs03_zkgm_addr, &ucs03_zkgm::msg::QueryMsg::GetMinter {})?;
+
+    let metadata_response: ucs03_zkgm_token_minter_api::MetadataResponse =
+        deps.querier.query_wasm_smart(
+            &minter,
+            &ucs03_zkgm_token_minter_api::QueryMsg::Metadata {
+                denom: funds.denom.clone(),
+            },
+        )?;
+
+    let timeout_timestamp = env.block.time.plus_days(2).nanos();
+    let amount: U256 = funds.amount.u128().try_into().unwrap();
+
+    // Construct instruction
+    let instruction = ucs03_zkgm::com::Instruction {
+        version: ucs03_zkgm::com::INSTR_VERSION_1,
+        opcode: ucs03_zkgm::com::OP_FUNGIBLE_ASSET_ORDER,
+        operand: ucs03_zkgm::com::FungibleAssetOrder {
+            sender: account_address.to_string().into_bytes().into(),
+            receiver: receiver.into(),
+            base_token: funds.denom.clone().into_bytes().into(),
+            base_amount: amount,
+            base_token_symbol: metadata_response.symbol,
+            base_token_name: metadata_response.name,
+            base_token_decimals: metadata_response.decimals,
+            // origin on this chain
+            base_token_path: U256::ZERO,
+            quote_token: quote_token.wrapped_token.into(),
+            quote_amount: amount,
+        }
+        .abi_encode_params()
+        .into(),
+    };
+    // Construct send packet on the ucs03zkgm
+    let msg = ucs03_zkgm::msg::ExecuteMsg::Send {
+        channel_id: channel_id.into(),
+        // Setting non zero timeout height results in revert
+        timeout_height: Uint64::zero(),
+        timeout_timestamp: ibc_union_spec::Timestamp::from_nanos(timeout_timestamp),
+        salt: salt.to_be_bytes().into(),
+        instruction: instruction.abi_encode_params().into(),
+    };
+
+    let send_msg = wasm_execute(ucs03_zkgm_addr, &msg, vec![funds])?;
 
-    Ok(forwarder_msg)
+    Ok(send_msg.into())
 }
 
 fn evm_note_addr(vc: &RegistryContract, querier: &QuerierWrapper) -> IcaClientResult<Addr> {
-    let evm_note_entry =
-        ModuleInfo::from_id(EVM_NOTE_ID, abstract_ica::POLYTONE_EVM_VERSION.parse()?)?;
+    let evm_note_entry = ModuleInfo::from_id(
+        EVM_NOTE_ID,
+        abstract_std::ica_client::POLYTONE_EVM_VERSION.parse()?,
+    )?;
 
     vc.query_module(evm_note_entry, querier)?
         .reference
         .unwrap_native()
         .map_err(Into::into)
 }
 
-pub(crate) mod types {
+pub mod types {
     use super::*;
 
-    pub const UCS01_PROTOCOL: &str = "ucs01";
-    pub const UCS01_FORWARDER_CONTRACT: &str = "forwarder";
+    pub const UCS03_ZKGM_PROTOCOL: &str = "ucs03";
+    pub const UCS03_ZKGM_CONTRACT: &str = "ucs03zkgm";
 
     #[cosmwasm_schema::cw_serde]
     pub enum Ucs01ForwarderExecuteMsg {

framework/contracts/native/ica-client/src/contract.rs

@@ -97,10 +97,7 @@ mod tests {
         let mut deps = mock_dependencies();
         let env = mock_env_validated(deps.api);
         let abstr = AbstractMockAddrs::new(deps.api);
-        let msg = InstantiateMsg {
-            ans_host_address: abstr.ans_host.to_string(),
-            registry_address: abstr.registry.to_string(),
-        };
+        let msg = InstantiateMsg {};
         let info = message_info(&abstr.owner, &[]);
         let res = instantiate(deps.as_mut(), env.clone(), info, msg).unwrap();
         assert!(res.messages.is_empty());

framework/contracts/native/ica-client/src/lib.rs

@@ -2,8 +2,8 @@
 
 pub mod contract;
 pub mod error;
-pub use abstract_ica::msg;
-mod chain_types;
+pub use abstract_std::ica_client as msg;
+pub mod chain_types;
 mod queries;
 
 #[cfg(test)]
@@ -19,10 +19,7 @@ mod test_common {
 
     pub fn mock_init(deps: &mut OwnedDeps<MockStorage, MockApi, MockQuerier>) -> IcaClientResult {
         let abstr = AbstractMockAddrs::new(deps.api);
-        let msg = InstantiateMsg {
-            ans_host_address: abstr.ans_host.to_string(),
-            registry_address: abstr.registry.to_string(),
-        };
+        let msg = InstantiateMsg {};
         let info = message_info(&abstr.owner, &[]);
         let env = mock_env_validated(deps.api);