feat(axelarnet-gateway): move CallContractWithToken from the nexus gateway to axelarnet gateway (#624)

Author: fish-sammy

Cargo.lock

@@ -19,6 +19,7 @@ assert_ok = "1.0"
 axelar-wasm-std = { version = "^1.0.0", path = "packages/axelar-wasm-std" }
 axelar-wasm-std-derive = { version = "^1.0.0", path = "packages/axelar-wasm-std-derive" }
 axelarnet-gateway = { version = "^1.0.0", path = "contracts/axelarnet-gateway" }
+nexus-gateway = { version = "^1.0.0", path = "contracts/nexus-gateway" }
 bcs = "0.1.5"
 client = { version = "^1.0.0", path = "packages/client" }
 coordinator = { version = "^1.0.0", path = "contracts/coordinator" }

Cargo.toml

@@ -41,6 +41,7 @@ cw2 = { workspace = true }
 error-stack = { workspace = true }
 itertools = { workspace = true }
 msgs-derive = { workspace = true }
+nexus-gateway = { workspace = true, features = ["library"] }
 report = { workspace = true }
 router-api = { workspace = true }
 serde = { workspace = true }

contracts/axelarnet-gateway/Cargo.toml

@@ -154,6 +154,7 @@ mod test {
         let msg = InstantiateMsg {
             chain_name: "source-chain".parse().unwrap(),
             router_address: "router".to_string(),
+            nexus_gateway: "nexus-gateway".to_string(),
         };
 
         instantiate(deps, env, info, msg.clone()).unwrap();

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

@@ -55,6 +55,7 @@ pub fn instantiate(
     let config = Config {
         chain_name: msg.chain_name,
         router: address::validate_cosmwasm_address(deps.api, &msg.router_address)?,
+        nexus_gateway: address::validate_cosmwasm_address(deps.api, &msg.nexus_gateway)?,
     };
 
     state::save_config(deps.storage, &config)?;
@@ -76,7 +77,7 @@ pub fn execute(
         } => execute::call_contract(
             deps.storage,
             deps.querier,
-            info.sender,
+            info,
             execute::CallContractData {
                 destination_chain,
                 destination_address,

contracts/axelarnet-gateway/src/contract.rs

@@ -2,9 +2,13 @@ use std::str::FromStr;
 
 use axelar_core_std::nexus;
 use axelar_wasm_std::msg_id::HexTxHashAndEventIndex;
+use axelar_wasm_std::token::GetToken;
 use axelar_wasm_std::{address, FnExt, IntoContractError};
 use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{Addr, DepsMut, HexBinary, QuerierWrapper, Response, Storage};
+use cosmwasm_std::{
+    to_json_binary, Addr, DepsMut, HexBinary, MessageInfo, QuerierWrapper, Response, Storage,
+    WasmMsg,
+};
 use error_stack::{bail, ensure, report, Result, ResultExt};
 use itertools::Itertools;
 use router_api::client::Router;
@@ -47,6 +51,8 @@ pub enum Error {
     Nexus,
     #[error("nonce from the nexus module overflowed u32")]
     NonceOverflow,
+    #[error("invalid token received")]
+    InvalidToken,
 }
 
 #[cw_serde]
@@ -71,10 +77,14 @@ impl CallContractData {
 pub fn call_contract(
     storage: &mut dyn Storage,
     querier: QuerierWrapper,
-    sender: Addr,
+    info: MessageInfo,
     call_contract: CallContractData,
 ) -> Result<Response, Error> {
-    let Config { router, chain_name } = state::load_config(storage);
+    let Config {
+        router,
+        chain_name,
+        nexus_gateway,
+    } = state::load_config(storage);
 
     let client: nexus::Client = client::CosmosClient::new(querier).into();
     let nexus::query::TxHashAndNonceResponse { tx_hash, nonce } =
@@ -88,31 +98,42 @@ pub fn call_contract(
         ),
     )
     .change_context(Error::InvalidCrossChainId)?;
-    let source_address = Address::from_str(sender.as_str())
-        .change_context(Error::InvalidSourceAddress(sender.clone()))?;
+    let source_address = Address::from_str(info.sender.as_str())
+        .change_context(Error::InvalidSourceAddress(info.sender.clone()))?;
     let msg = call_contract.to_message(id, source_address);
 
     state::save_unique_routable_msg(storage, &msg.cc_id, &msg)
         .inspect_err(|err| panic_if_already_exists(err, &msg.cc_id))
         .change_context(Error::SaveRoutableMessage)?;
 
-    Ok(
-        route_to_router(storage, &Router::new(router), vec![msg.clone()])?.add_event(
-            AxelarnetGatewayEvent::ContractCalled {
-                msg,
-                payload: call_contract.payload,
-            }
-            .into(),
-        ),
-    )
+    let token = info.single_token().change_context(Error::InvalidToken)?;
+    let event = AxelarnetGatewayEvent::ContractCalled {
+        msg: msg.clone(),
+        payload: call_contract.payload,
+        token: token.clone(),
+    };
+    let res = match token {
+        None => route_to_router(storage, &Router::new(router), vec![msg])?,
+        Some(token) => Response::new().add_message(WasmMsg::Execute {
+            contract_addr: nexus_gateway.to_string(),
+            msg: to_json_binary(&nexus_gateway::msg::ExecuteMsg::RouteMessageWithToken(msg))
+                .expect("failed to serialize route message with token"),
+            funds: vec![token],
+        }),
+    }
+    .add_event(event.into());
+
+    Ok(res)
 }
 
 pub fn route_messages(
     storage: &mut dyn Storage,
     sender: Addr,
     msgs: Vec<Message>,
 ) -> Result<Response, Error> {
-    let Config { chain_name, router } = state::load_config(storage);
+    let Config {
+        chain_name, router, ..
+    } = state::load_config(storage);
     let router = Router::new(router);
 
     if sender == router.address {

contracts/axelarnet-gateway/src/contract/execute.rs

@@ -1,10 +1,12 @@
-use cosmwasm_std::{Attribute, Event, HexBinary};
+use axelar_wasm_std::event::EventExt;
+use cosmwasm_std::{Attribute, Coin, Event, HexBinary};
 use router_api::Message;
 
 pub enum AxelarnetGatewayEvent {
     ContractCalled {
         msg: Message,
         payload: HexBinary,
+        token: Option<Coin>,
     },
     /// Uses the same event name as `GatewayEvent` for consistency
     Routing {
@@ -18,10 +20,13 @@ pub enum AxelarnetGatewayEvent {
 impl From<AxelarnetGatewayEvent> for Event {
     fn from(other: AxelarnetGatewayEvent) -> Self {
         match other {
-            AxelarnetGatewayEvent::ContractCalled { msg, payload } => {
-                make_message_event("contract_called", msg)
-                    .add_attributes(vec![("payload", payload.to_string())])
-            }
+            AxelarnetGatewayEvent::ContractCalled {
+                msg,
+                payload,
+                token,
+            } => make_message_event("contract_called", msg)
+                .add_attribute("payload", payload.to_string())
+                .add_attribute_if_some("token", token.map(|token| token.to_string())),
             AxelarnetGatewayEvent::Routing { msg } => make_message_event("routing", msg),
             AxelarnetGatewayEvent::MessageExecuted { msg } => {
                 make_message_event("message_executed", msg)

contracts/axelarnet-gateway/src/events.rs

@@ -11,6 +11,8 @@ pub struct InstantiateMsg {
     pub chain_name: ChainName,
     /// Address of the router contract on axelar.
     pub router_address: String,
+    /// Address of the nexus gateway contract on axelar.
+    pub nexus_gateway: String,
 }
 
 #[cw_serde]

contracts/axelarnet-gateway/src/msg.rs

@@ -33,6 +33,7 @@ pub enum Error {
 pub struct Config {
     pub chain_name: ChainName,
     pub router: Addr,
+    pub nexus_gateway: Addr,
 }
 
 #[cw_serde]

contracts/axelarnet-gateway/src/state.rs

@@ -8,7 +8,7 @@ use axelarnet_gateway::StateError;
 use cosmwasm_std::testing::{
     mock_dependencies, mock_env, mock_info, MockQuerierCustomHandlerResult,
 };
-use cosmwasm_std::{ContractResult, DepsMut, HexBinary, Response, SystemResult};
+use cosmwasm_std::{Coin, ContractResult, DepsMut, HexBinary, Response, SystemResult};
 use rand::RngCore;
 use router_api::msg::ExecuteMsg as RouterExecuteMsg;
 use router_api::{CrossChainId, Message};
@@ -183,6 +183,7 @@ fn route_to_router_after_contract_call_with_tempered_data_fails() {
     utils::instantiate_contract(deps.as_mut()).unwrap();
     let response = utils::call_contract(
         deps.as_mut(),
+        mock_info("sender", &[]),
         destination_chain,
         destination_address,
         payload,
@@ -222,6 +223,7 @@ fn route_to_router_after_contract_call_succeeds_multiple_times() {
     utils::instantiate_contract(deps.as_mut()).unwrap();
     let response = utils::call_contract(
         deps.as_mut(),
+        mock_info("sender", &[]),
         destination_chain,
         destination_address,
         payload,
@@ -260,6 +262,7 @@ fn route_to_router_after_contract_call_ignores_duplicates() {
     utils::instantiate_contract(deps.as_mut()).unwrap();
     let response = utils::call_contract(
         deps.as_mut(),
+        mock_info("sender", &[]),
         destination_chain,
         destination_address,
         payload,
@@ -301,6 +304,7 @@ fn contract_call_returns_correct_message() {
 
     let response = assert_ok!(utils::call_contract(
         deps.as_mut(),
+        mock_info("sender", &[]),
         destination_chain,
         destination_address,
         payload,
@@ -309,6 +313,36 @@ fn contract_call_returns_correct_message() {
     goldie::assert_json!(msg)
 }
 
+#[test]
+fn contract_call_with_token_returns_correct_message() {
+    let tx_hash: [u8; 32] = [2; 32];
+    let nonce = 99;
+    let token = Coin::new(10, "axelar");
+
+    let mut deps = mock_dependencies();
+    deps.querier = deps
+        .querier
+        .with_custom_handler(reply_with_tx_hash_and_nonce(tx_hash, nonce));
+
+    let destination_chain = "destination-chain".parse().unwrap();
+    let destination_address = "destination-address".parse().unwrap();
+    let payload = vec![1, 2, 3].into();
+
+    utils::instantiate_contract(deps.as_mut()).unwrap();
+
+    let response = assert_ok!(utils::call_contract(
+        deps.as_mut(),
+        mock_info("sender", &[token]),
+        destination_chain,
+        destination_address,
+        payload,
+    ));
+    let msg = assert_ok!(inspect_response_msg::<nexus_gateway::msg::ExecuteMsg>(
+        response
+    ));
+    goldie::assert_json!(msg)
+}
+
 #[test]
 fn contract_call_returns_correct_events() {
     let tx_hash: [u8; 32] =
@@ -330,6 +364,7 @@ fn contract_call_returns_correct_events() {
     utils::instantiate_contract(deps.as_mut()).unwrap();
     let response = assert_ok!(utils::call_contract(
         deps.as_mut(),
+        mock_info("sender", &[]),
         destination_chain,
         destination_address,
         payload,

contracts/axelarnet-gateway/tests/execute.rs

@@ -21,6 +21,24 @@ fn invalid_router_address() {
     let msg = InstantiateMsg {
         chain_name: params::AXELARNET.parse().unwrap(),
         router_address: "".to_string(),
+        nexus_gateway: params::NEXUS_GATEWAY.parse().unwrap(),
+    };
+
+    assert_err_contains!(
+        contract::instantiate(deps.as_mut(), mock_env(), mock_info("sender", &[]), msg),
+        axelar_wasm_std::address::Error,
+        axelar_wasm_std::address::Error::InvalidAddress(..),
+    );
+}
+
+#[test]
+fn invalid_nexus_gateway_address() {
+    let mut deps = mock_dependencies();
+
+    let msg = InstantiateMsg {
+        chain_name: params::AXELARNET.parse().unwrap(),
+        router_address: params::ROUTER.parse().unwrap(),
+        nexus_gateway: "".to_string(),
     };
 
     assert_err_contains!(

contracts/axelarnet-gateway/tests/instantiate.rs

@@ -3,7 +3,8 @@ use axelar_wasm_std::response::inspect_response_msg;
 use axelarnet_gateway::msg::QueryMsg;
 use axelarnet_gateway::{contract, ExecutableMessage};
 use cosmwasm_std::testing::{
-    mock_dependencies, mock_env, MockApi, MockQuerier, MockQuerierCustomHandlerResult, MockStorage,
+    mock_dependencies, mock_env, mock_info, MockApi, MockQuerier, MockQuerierCustomHandlerResult,
+    MockStorage,
 };
 use cosmwasm_std::{from_json, ContractResult, Deps, OwnedDeps, SystemResult};
 use rand::RngCore;
@@ -90,6 +91,7 @@ fn populate_routable_messages(
         .map(|i| {
             let response = utils::call_contract(
                 deps.as_mut(),
+                mock_info("sender", &[]),
                 format!("destination-chain-{}", i).parse().unwrap(),
                 format!("destination-address-{}", i).parse().unwrap(),
                 vec![i].into(),

contracts/axelarnet-gateway/tests/query.rs

@@ -0,0 +1,12 @@
+{
+  "route_message_with_token": {
+    "cc_id": {
+      "source_chain": "axelarnet",
+      "message_id": "0x0202020202020202020202020202020202020202020202020202020202020202-99"
+    },
+    "source_address": "sender",
+    "destination_chain": "destination-chain",
+    "destination_address": "destination-address",
+    "payload_hash": "f1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c9239"
+  }
+}

contracts/axelarnet-gateway/tests/testdata/contract_call_with_token_returns_correct_message.golden

@@ -3,7 +3,7 @@ use axelarnet_gateway::msg::ExecuteMsg as GatewayExecuteMsg;
 use axelarnet_gateway::{contract, AxelarExecutableMsg};
 use cosmwasm_schema::cw_serde;
 use cosmwasm_std::testing::{mock_env, mock_info};
-use cosmwasm_std::{DepsMut, HexBinary, Response};
+use cosmwasm_std::{DepsMut, HexBinary, MessageInfo, Response};
 use router_api::{Address, ChainName, CrossChainId, Message};
 
 use crate::utils::params;
@@ -16,14 +16,15 @@ pub enum ExecuteMsg {
 
 pub fn call_contract(
     deps: DepsMut,
+    info: MessageInfo,
     destination_chain: ChainName,
     destination_address: Address,
     payload: HexBinary,
 ) -> Result<Response, ContractError> {
     contract::execute(
         deps,
         mock_env(),
-        mock_info("sender", &[]),
+        info,
         GatewayExecuteMsg::CallContract {
             destination_chain,
             destination_address,

contracts/axelarnet-gateway/tests/utils/execute.rs

@@ -14,6 +14,7 @@ pub fn instantiate_contract(deps: DepsMut) -> Result<Response, ContractError> {
         InstantiateMsg {
             chain_name: params::AXELARNET.parse().unwrap(),
             router_address: params::ROUTER.parse().unwrap(),
+            nexus_gateway: params::NEXUS_GATEWAY.parse().unwrap(),
         },
     )
 }