refactor(minor-axelarnet-gateway): simplify the initial implementation

Cargo.toml

@@ -62,6 +62,7 @@ strum = { version = "0.25", default-features = false, features = ["derive"] }
 interchain-token-service = { version = "^0.1.0", path = "interchain-token-service" }
 goldie = { version = "0.5" }
 axelarnet-gateway = { version = "^0.1.0", path = "contracts/axelarnet-gateway" }
+cw-multi-test = "1.2.0"
 
 [workspace.lints.clippy]
 arithmetic_side_effects = "deny"

contracts/axelarnet-gateway/Cargo.toml

@@ -39,6 +39,7 @@ cosmwasm-std = { workspace = true }
 cw-storage-plus = { workspace = true }
 cw2 = { workspace = true }
 error-stack = { workspace = true }
+itertools = { workspace = true }
 msgs-derive = { workspace = true }
 report = { workspace = true }
 router-api = { workspace = true }
@@ -48,7 +49,8 @@ sha3 = { workspace = true }
 thiserror = { workspace = true }
 
 [dev-dependencies]
-cw-multi-test = "0.15.1"
+cw-multi-test = { workspace = true }
+goldie = { workspace = true }
 
 [lints]
 workspace = true

contracts/axelarnet-gateway/src/executable.rs → contracts/axelarnet-gateway/src/clients/external.rs

@@ -1,5 +1,6 @@
+use axelar_wasm_std::address;
 use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{HexBinary, WasmMsg};
+use cosmwasm_std::{Deps, HexBinary, WasmMsg};
 use router_api::{Address, CrossChainId};
 
 /// `AxelarExecutableMsg` is a struct containing the args used by the axelarnet gateway to execute a destination contract on Axelar.
@@ -11,39 +12,47 @@ pub struct AxelarExecutableMsg {
     pub payload: HexBinary,
 }
 
-/// Crate-specific `ExecuteMsg` type wraps the `AxelarExecutableMsg` for the AxelarExecutable client.
+/// By convention, amplifier-compatible contracts must expose this `Execute` variant.
+/// Due to identical json serialization, we can imitate it here so the gateway can call it.
 #[cw_serde]
-pub enum AxelarExecutableExecuteMsg {
+pub enum ExecuteMsg {
     /// Execute the message at the destination contract with the corresponding payload.
     Execute(AxelarExecutableMsg),
 }
 
-impl<'a> From<client::Client<'a, AxelarExecutableExecuteMsg, ()>> for AxelarExecutableClient<'a> {
-    fn from(client: client::Client<'a, AxelarExecutableExecuteMsg, ()>) -> Self {
-        AxelarExecutableClient { client }
-    }
+pub struct CrossChainExecutor<'a> {
+    client: client::Client<'a, ExecuteMsg, ()>,
 }
 
-pub struct AxelarExecutableClient<'a> {
-    client: client::Client<'a, AxelarExecutableExecuteMsg, ()>,
-}
+impl<'a> CrossChainExecutor<'a> {
+    pub fn new(deps: Deps<'a>, destination: &str) -> error_stack::Result<Self, address::Error> {
+        let destination = address::validate_cosmwasm_address(deps.api, destination)?;
+        Ok(CrossChainExecutor {
+            client: client::Client::new(deps.querier, destination),
+        })
+    }
 
-impl<'a> AxelarExecutableClient<'a> {
-    pub fn execute(
+    pub fn prepare_execute_msg(
         &self,
         cc_id: CrossChainId,
         source_address: Address,
         payload: HexBinary,
     ) -> WasmMsg {
         self.client
-            .execute(&AxelarExecutableExecuteMsg::Execute(AxelarExecutableMsg {
+            .execute(&ExecuteMsg::Execute(AxelarExecutableMsg {
                 cc_id,
                 source_address,
                 payload,
             }))
     }
 }
 
+impl<'a> From<client::Client<'a, ExecuteMsg, ()>> for CrossChainExecutor<'a> {
+    fn from(client: client::Client<'a, ExecuteMsg, ()>) -> Self {
+        CrossChainExecutor { client }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use cosmwasm_std::testing::MockQuerier;
@@ -54,20 +63,21 @@ mod test {
     #[test]
     fn execute_message() {
         let (querier, addr) = setup();
-        let client: AxelarExecutableClient =
+        let client: CrossChainExecutor =
             client::Client::new(QuerierWrapper::new(&querier), addr.clone()).into();
 
         let cc_id = CrossChainId::new("source-chain", "message-id").unwrap();
         let source_address: Address = "source-address".parse().unwrap();
         let payload = HexBinary::from(vec![1, 2, 3]);
 
-        let msg = client.execute(cc_id.clone(), source_address.clone(), payload.clone());
+        let msg =
+            client.prepare_execute_msg(cc_id.clone(), source_address.clone(), payload.clone());
 
         assert_eq!(
             msg,
             WasmMsg::Execute {
                 contract_addr: addr.to_string(),
-                msg: to_json_binary(&AxelarExecutableExecuteMsg::Execute(AxelarExecutableMsg {
+                msg: to_json_binary(&ExecuteMsg::Execute(AxelarExecutableMsg {
                     cc_id,
                     source_address,
                     payload,

contracts/axelarnet-gateway/src/clients/mod.rs

@@ -0,0 +1,5 @@
+mod external;
+mod gateway;
+
+pub use external::*;
+pub use gateway::Client as GatewayClient;