making router more stable

Cargo.toml

@@ -21,7 +21,7 @@ todo = "warn"
 let_unit_value = "allow"
 
 [workspace.dependencies]
-
+displaydoc = {  version = "^0.2.0", default-features = false }
 cvm = { path = "./crates/cvm", default-features = false }
 blackbox_rs = { path = "./node/blackbox_rs", default-features = false }
 cvm-route = { path = "./crates/cvm-route", default-features = false }

mantis/node/Cargo.toml

@@ -24,6 +24,7 @@ cw-mantis-order = { workspace = true, features = [
     "std",
 ] }
 
+displaydoc = { workspace = true }
 cw-cvm-outpost = { workspace = true, features = ["std"] }
 cw-cvm-executor = { workspace = true, features = ["std"] }
 

mantis/node/src/error.rs

@@ -0,0 +1,13 @@
+use cosmwasm_std::Uint128;
+
+#[derive(Debug, displaydoc::Display)]
+pub enum MantisError {
+    /// `{order_id}` Matching order not found
+    MatchingOrderNotFound { order_id: Uint128 },
+    /// `{order_id}` Cow fill badly found because `{reason}`
+    CowFillBadlyFound { order_id: Uint128, reason: String },
+    /// Blackbox error: `{reason}`
+    BlackboxError { reason: String },
+}
+
+impl std::error::Error for MantisError {}

mantis/node/src/lib.rs

@@ -1,4 +1,5 @@
 #![feature(let_chains)]
+pub mod error;
 pub mod mantis;
 pub mod prelude;
 pub mod solver;

mantis/node/src/mantis/blackbox/mod.rs

@@ -9,7 +9,7 @@ use cvm_runtime::{
 use cw_cvm_outpost::msg::CvmGlt;
 use cw_mantis_order::{CrossChainPart, OrderItem, SolutionSubMsg};
 
-use crate::solver::router::shortest_path;
+use crate::{error::MantisError, solver::router::shortest_path};
 
 use super::{
     cosmos::client::Tip,
@@ -88,9 +88,9 @@ pub async fn get_routes(
     input: IntentBankInput,
     cvm_glt: &GetConfigResponse,
     salt: &[u8],
-) -> Vec<CvmInstruction> {
+) -> Result<Vec<CvmInstruction>, MantisError> {
     if route_provider == "shortest_path" {
-        return shortest_path::route(cvm_glt, input, salt);
+        Ok(shortest_path::route(cvm_glt, input, salt))
     } else {
         let blackbox: Client = Client::new(route_provider);
         let mut route = blackbox
@@ -102,13 +102,22 @@ pub async fn get_routes(
                 input.out_asset_id.to_string().as_str().into(),
             )
             .await
-            .expect("route found")
+            .map_err(|x| MantisError::BlackboxError {
+                reason: x.to_string(),
+            })?
             .into_inner()
             .pop()
-            .expect("at least one route");
+            .ok_or(MantisError::BlackboxError {
+                reason: "no routes".to_string(),
+            })?;
 
         log::info!("route: {:?}", route);
-        build_instructions(input.order_accounts, &route.next[0], cvm_glt, salt)
+        Ok(build_instructions(
+            input.order_accounts,
+            &route.next[0],
+            cvm_glt,
+            salt,
+        ))
     }
 }
 
@@ -180,9 +189,6 @@ pub async fn solve<Decider: Get<bool>>(
     let cows_per_pair = find_cows(&active_orders);
     let mut msgs = vec![];
 
-    // this we do just to avoid one pair to fail all others, really need to handle all errors gracefully or run solver(thread/process) per pair (i am for second)
-    let cows_per_pair = cows_per_pair.into_iter().take(1).collect::<Vec<_>>();
-
     for pair_solution in cows_per_pair {
         let salt = super::cosmos::cvm::calculate_salt(signing_key, tip, pair_solution.ab.clone());
         let cvm_program = if let Some(ref cvm_glt) = cvm_glt {
@@ -195,6 +201,13 @@ pub async fn solve<Decider: Get<bool>>(
             )
             .await;
 
+            if cvm_program.is_err() {
+                log::error!("cvm_program error: {:?}", cvm_program);
+                continue;
+            }
+
+            let cvm_program = cvm_program.expect("qed");
+
             Some(cvm_program)
         } else {
             None
@@ -230,21 +243,21 @@ async fn intent_banks_to_cvm_program(
     cvm_glt: &cw_cvm_outpost::msg::GetConfigResponse,
     router_api: &str,
     salt: &Vec<u8>,
-) -> CvmProgram {
+) -> Result<CvmProgram, MantisError> {
     let intents = IntentBankInput::find_intent_amount(
         pair_solution.cows.as_ref(),
         all_orders,
         pair_solution.optimal_price,
         cvm_glt,
         pair_solution.ab.clone(),
-    );
+    )?;
 
     log::info!(target:"mantis::solver::", "intents: {:?}", intents);
 
     let mut instructions = vec![];
 
     for intent in intents.into_iter().filter(|x| x.in_asset_amount.0.gt(&0)) {
-        let mut cvm_routes = get_routes(router_api, intent, cvm_glt, salt.as_ref()).await;
+        let mut cvm_routes = get_routes(router_api, intent, cvm_glt, salt.as_ref()).await?;
         instructions.append(&mut cvm_routes);
     }
 
@@ -254,5 +267,5 @@ async fn intent_banks_to_cvm_program(
         tag: salt.to_vec(),
         instructions,
     };
-    cvm_program
+    Ok(cvm_program)
 }

mantis/node/src/mantis/solve.rs

@@ -8,6 +8,7 @@ use mantis_cw::{DenomPair, OrderCoinPair};
 use num_rational::Ratio;
 
 use crate::{
+    error::MantisError,
     prelude::*,
     solver::cows::{orderbook::OrderList, solution::Solution},
 };
@@ -43,7 +44,7 @@ impl IntentBankInput {
         optimal_ratio: Ratio<u64>,
         cvm_glt: &GetConfigResponse,
         pair: DenomPair,
-    ) -> Vec<IntentBankInput> {
+    ) -> Result<Vec<IntentBankInput>, MantisError> {
         // native calculations
         let mut pair = OrderCoinPair::zero(pair.a, pair.b);
         let mut a_to_b = Vec::new();
@@ -55,11 +56,16 @@ impl IntentBankInput {
                     let mut order = orders
                         .iter()
                         .find(|x| x.order_id == cow.order_id)
-                        .expect("order")
+                        .ok_or(MantisError::MatchingOrderNotFound {
+                            order_id: cow.order_id,
+                        })?
                         .clone();
                     order
                         .fill(cow.cow_out_amount, optimal_ratio.into())
-                        .expect("off chain");
+                        .map_err(|x| MantisError::CowFillBadlyFound {
+                            order_id: cow.order_id,
+                            reason: x.to_string(),
+                        })?;
                     pair.add(&order.given);
 
                     if order.given.denom == pair.a.denom {
@@ -106,7 +112,7 @@ impl IntentBankInput {
                 IntentBankInput::new(b_asset, pair.b.amount.into(), a_asset, a_received.collect());
             intents.push(intent);
         }
-        intents
+        Ok(intents)
     }
 }