workz

Author: dzmitry-lahoda

contracts/cosmwasm/outpost/src/contract/execute.rs

@@ -13,7 +13,7 @@ use cosmwasm_std::{
     entry_point, wasm_execute, Addr, BankMsg, Coin, CosmosMsg, Deps, DepsMut, Env, MessageInfo,
     Response, StdError,
 };
-use cvm_route::asset::{AssetReference, AssetToNetwork};
+use cvm_route::asset::{AssetReference,  NetworkAssetItem};
 use cw20::{Cw20Contract, Cw20ExecuteMsg};
 
 use cvm_runtime::{
@@ -97,12 +97,12 @@ fn handle_config_msg(
         ConfigSubMsg::ForceRemoveAsset { asset_id } => {
             assets::force_remove_asset(auth, deps, asset_id)
         }
-        ConfigSubMsg::ForceAssetToNetworkMap(AssetToNetwork {
-            this_asset,
-            other_network,
-            other_asset,
+        ConfigSubMsg::ForceAssetToNetworkMap(NetworkAssetItem {
+            to_network_id,
+            from_asset_id,
+            to_asset_id,
         }) => {
-            assets::force_asset_to_network_map(auth, deps, this_asset, other_network, other_asset)
+            assets::force_asset_to_network_map(auth, deps, from_asset_id, to_network_id, to_asset_id)
         }
         ConfigSubMsg::ForceNetwork(msg) => network::force_network(auth, deps, msg),
         ConfigSubMsg::ForceInstantiate { user_origin, salt } => {

crates/cvm-route/src/asset.rs

@@ -1,28 +1,6 @@
 use crate::{prelude::*, transport::ForeignAssetId};
 use cvm::{AssetId, NetworkId};
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
-#[serde(rename_all = "snake_case")]
-#[cfg_attr(
-    feature = "json-schema", // all(feature = "json-schema", not(target_arch = "wasm32")),
-    derive(schemars::JsonSchema)
-)]
-pub struct AssetToNetwork {
-    pub this_asset: AssetId,
-    pub other_network: NetworkId,
-    pub other_asset: AssetId,
-}
-
-impl AssetToNetwork {
-    pub fn new(this_asset: AssetId, other_network: NetworkId, other_asset: AssetId) -> Self {
-        Self {
-            this_asset,
-            other_network,
-            other_asset,
-        }
-    }
-}
-
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(rename_all = "snake_case")]
 #[cfg_attr(

crates/cvm-runtime/src/outpost/config.rs

@@ -1,5 +1,5 @@
 use cvm_route::{
-    asset::{AssetItem, AssetToNetwork}, exchange::ExchangeItem, transport::NetworkToNetworkItem,
+    asset::{AssetItem, NetworkAssetItem}, exchange::ExchangeItem, transport::NetworkToNetworkItem,
     venue::AssetsVenueItem,
 };
 
@@ -103,7 +103,7 @@ pub enum ConfigSubMsg {
     /// Permissioned message (gov or admin) to force set asset information.
     ForceAsset(AssetItem),
 
-    ForceAssetToNetworkMap(AssetToNetwork),
+    ForceAssetToNetworkMap(NetworkAssetItem),
 
     ForceExchange(ExchangeItem),
 

mantis/node/tests/cvms.rs

@@ -2,13 +2,13 @@ use bounded_collections::Get;
 use cosmrs::tendermint::block::Height;
 use cosmwasm_std::{Addr, Coin, Coins, Empty};
 use cvm_route::{
-    asset::{AssetItem, AssetReference, NetworkAssetItem},
+    asset::{self, AssetItem, AssetReference, NetworkAssetItem},
     exchange::ExchangeItem,
     transport::{NetworkToNetworkItem, OtherNetworkItem},
     venue::AssetsVenueItem,
 };
 use cw_cvm_outpost::msg::{CvmGlt, HereItem, NetworkItem, OutpostId};
-use cw_mantis_order::{OrderItem, OrderSubMsg};
+use cw_mantis_order::{OrderItem, OrderSubMsg, SolutionSubMsg};
 use cw_multi_test::{App, Bank, BankKeeper, Contract, ContractWrapper, Executor};
 use mantis_node::mantis::cosmos::{client::Tip, signer::from_mnemonic};
 use serde::de;
@@ -39,15 +39,15 @@ async fn cvm_devnet_case() {
     let cw_cvm_outpost_code_id = centauri.store_code(Box::new(cw_cvm_outpost_wasm));
     let cw_cvm_executor_code_id = centauri.store_code(Box::new(cw_cvm_executor_wasm));
 
-    let admin = Addr::unchecked("juno1g2rahf5846rxzp3fwlswy08fz8ccuwk03k57y");
+    let sender = Addr::unchecked("juno1g2rahf5846rxzp3fwlswy08fz8ccuwk03k57y");
     let cw_cvm_outpost_instantiate = cw_cvm_outpost::msg::InstantiateMsg(HereItem {
         network_id: 3.into(),
-        admin: admin.clone(),
+        admin: sender.clone(),
     });
     let cw_cvm_outpost_contract = centauri
         .instantiate_contract(
             cw_cvm_outpost_code_id,
-            admin.clone(),
+            sender.clone(),
             &cw_cvm_outpost_instantiate,
             &[],
             "composable_cvm_outpost",
@@ -56,23 +56,21 @@ async fn cvm_devnet_case() {
         .unwrap();
 
     let cw_mantis_order_instantiate = cw_mantis_order::sv::InstantiateMsg {
-        admin: Some(admin.clone()),
+        admin: Some(sender.clone()),
         cvm_address: cw_cvm_outpost_contract.clone(),
     };
 
     let cw_mantis_contract = centauri
         .instantiate_contract(
             cw_mantis_order_code_id,
-            admin,
+            sender.clone(),
             &cw_mantis_order_instantiate,
             &[],
             "composable_mantis_order",
             None,
         )
         .unwrap();
 
-    let sender = Addr::unchecked("juno16g2rahf5846rxzp3fwlswy08fz8ccuwk03k57y");
-
     let ACoin = |x: u128| Coin {
         denom: "a".to_string(),
         amount: x.into(),
@@ -102,7 +100,7 @@ async fn cvm_devnet_case() {
         owner: sender.clone(),
         msg: a_to_b_msg.clone(),
         given: ACoin(100),
-        order_id: 1u128.into(),
+        order_id: 0u128.into(),
     };
 
     let b_to_a_msg = OrderSubMsg {
@@ -116,7 +114,7 @@ async fn cvm_devnet_case() {
         owner: sender.clone(),
         msg: b_to_a_msg.clone(),
         given: BCoin(1000),
-        order_id: 2u128.into(),
+        order_id: 1u128.into(),
     };
 
     centauri
@@ -244,18 +242,66 @@ async fn cvm_devnet_case() {
 
     let mut config_messages = vec![];
 
-    for network_item in cvm_glt {
-        let config_message = cw_cvm_outpost::msg::ConfigSubMsg::ForceNetwork(network_item);
+    for network in cvm_glt.networks.clone().into_iter() {
+        let config_message = cw_cvm_outpost::msg::ConfigSubMsg::ForceNetwork(network);
+        config_messages.push(config_message);
+    }
+
+    for asset in cvm_glt.assets.clone().into_iter() {
+        let config_message = cw_cvm_outpost::msg::ConfigSubMsg::ForceAsset(asset);
+        config_messages.push(config_message);
+    }
+
+    for network_to_network in cvm_glt.network_to_networks.clone().into_iter() {
+        let config_message =
+            cw_cvm_outpost::msg::ConfigSubMsg::ForceNetworkToNetwork(network_to_network);
+        config_messages.push(config_message);
+    }
+
+    for exchange in cvm_glt.exchanges.clone().into_iter() {
+        let config_message = cw_cvm_outpost::msg::ConfigSubMsg::ForceExchange(exchange);
+        config_messages.push(config_message);
+    }
+
+    for asset_venue in cvm_glt.asset_venue_items.clone().into_iter() {
+        let config_message = cw_cvm_outpost::msg::ConfigSubMsg::ForceAssetsVenue(asset_venue);
+        config_messages.push(config_message);
+    }
+
+    for network_asset in cvm_glt.network_assets.clone().into_iter() {
+        let config_message =
+            cw_cvm_outpost::msg::ConfigSubMsg::ForceAssetToNetworkMap(network_asset);
         config_messages.push(config_message);
     }
 
     let force_config = cw_cvm_outpost::msg::ExecuteMsg::Config(
         cw_cvm_outpost::msg::ConfigSubMsg::Force(config_messages),
     );
 
-    let solution =
-        mantis_node::mantis::blackbox::solve::<True>(active_orders, &alice, &tip, cvm_glt.into(), router)
-            .await;
+    centauri
+        .execute_contract(
+            sender.clone(),
+            cw_cvm_outpost_contract.clone(),
+            &force_config,
+            &[],
+        )
+        .unwrap();
+
+    let solution = mantis_node::mantis::blackbox::solve::<True>(
+        active_orders,
+        &alice,
+        &tip,
+        cvm_glt.into(),
+        router,
+    )
+    .await;
+
+    centauri.execute_contract(
+        sender.clone(),
+        cw_mantis_contract.clone(),
+        &solution[0],
+        &[],
+    ).unwrap();
 
     panic!("solution: {:?}", solution);
 }