revert risk parameters

crates/solvers/config/example.baseline.toml

@@ -4,4 +4,5 @@ chain-id = "1"
 base-tokens = []
 max-hops = 0
 max-partial-attempts = 5
+risk-parameters = [0,0,0,0]
 # solution-gas-offset = 106391 # rough estimate of the settlement overhead

crates/solvers/config/example.naive.toml

@@ -0,0 +1 @@
+risk-parameters = [0,0,0,0]

crates/solvers/src/domain/mod.rs

@@ -5,5 +5,8 @@ pub mod eth;
 pub mod liquidity;
 pub mod notification;
 pub mod order;
+mod risk;
 pub mod solution;
 pub mod solver;
+
+pub use risk::Risk;

crates/solvers/src/domain/risk.rs

@@ -0,0 +1,26 @@
+use super::{auction::GasPrice, eth::Gas};
+
+/// Parameters that define the possibility of a revert when executing a
+/// solution.
+#[derive(Debug, Default, Clone)]
+pub struct Risk {
+    pub gas_amount_factor: f64,
+    pub gas_price_factor: f64,
+    pub nmb_orders_factor: f64,
+    pub intercept: f64,
+}
+
+impl Risk {
+    pub fn success_probability(
+        &self,
+        gas_amount: Gas,
+        gas_price: GasPrice,
+        nmb_orders: usize,
+    ) -> f64 {
+        let exponent = -self.intercept
+            - self.gas_amount_factor * gas_amount.0.to_f64_lossy() / 1_000_000.
+            - self.gas_price_factor * gas_price.0 .0.to_f64_lossy() / 10_000_000_000.
+            - self.nmb_orders_factor * nmb_orders as f64;
+        1. / (1. + exponent.exp())
+    }
+}

crates/solvers/src/domain/solver/baseline.rs

@@ -9,6 +9,7 @@ use {
     crate::{
         boundary,
         domain::{
+            self,
             auction,
             eth,
             liquidity,
@@ -31,6 +32,7 @@ pub struct Config {
     pub base_tokens: Vec<eth::TokenAddress>,
     pub max_hops: usize,
     pub max_partial_attempts: usize,
+    pub risk: domain::Risk,
     pub solution_gas_offset: eth::SignedGas,
 }
 
@@ -55,6 +57,10 @@ struct Inner {
     /// Basically we continuously halve the amount to execute until we find a
     /// valid solution or exceed this count.
     max_partial_attempts: usize,
+
+    /// Parameters used to calculate the revert risk of a solution.
+    risk: domain::Risk,
+
     /// Units of gas that get added to the gas estimate for executing a
     /// computed trade route to arrive at a gas estimate for a whole settlement.
     solution_gas_offset: eth::SignedGas,
@@ -68,6 +74,7 @@ impl Baseline {
             base_tokens: config.base_tokens.into_iter().collect(),
             max_hops: config.max_hops,
             max_partial_attempts: config.max_partial_attempts,
+            risk: config.risk,
             solution_gas_offset: config.solution_gas_offset,
         }))
     }

crates/solvers/src/domain/solver/naive.rs

@@ -8,14 +8,26 @@
 use {
     crate::{
         boundary,
-        domain::{auction, eth, liquidity, order, solution},
+        domain::{self, auction, eth, liquidity, order, solution},
     },
     std::collections::HashMap,
 };
 
-pub struct Naive;
+pub struct Config {
+    pub risk: domain::Risk,
+}
+
+pub struct Naive {
+    /// Parameters used to calculate the revert risk of a solution.
+    risk: domain::Risk,
+}
 
 impl Naive {
+    /// Creates a new naive solver for the specified configuration.
+    pub fn new(config: Config) -> Self {
+        Self { risk: config.risk }
+    }
+
     /// Solves the specified auction, returning a vector of all possible
     /// solutions.
     pub async fn solve(&self, auction: auction::Auction) -> Vec<solution::Solution> {

crates/solvers/src/infra/cli.rs

@@ -36,7 +36,10 @@ pub enum Command {
         config: PathBuf,
     },
     /// optimistically batch similar orders and get difference from AMMs
-    Naive,
+    Naive {
+        #[clap(long, env)]
+        config: PathBuf,
+    },
     /// forward auction to solver implementing the legacy HTTP interface
     Legacy {
         #[clap(long, env)]

crates/solvers/src/infra/config/baseline.rs

@@ -1,6 +1,6 @@
 use {
     crate::{
-        domain::{eth, solver::baseline},
+        domain::{eth, solver::baseline, Risk},
         infra::{config::unwrap_or_log, contracts},
         util::serialize,
     },
@@ -38,6 +38,11 @@ struct Config {
     /// The maximum number of pieces to divide partially fillable limit orders
     /// when trying to solve it against baseline liquidity.
     max_partial_attempts: usize,
+
+    /// Parameters used to calculate the revert risk of a solution.
+    /// (gas_amount_factor, gas_price_factor, nmb_orders_factor, intercept)
+    risk_parameters: (f64, f64, f64, f64),
+
     /// Units of gas that get added to the gas estimate for executing a
     /// computed trade route to arrive at a gas estimate for a whole settlement.
     #[serde(default = "default_gas_offset")]
@@ -76,6 +81,12 @@ pub async fn load(path: &Path) -> baseline::Config {
             .collect(),
         max_hops: config.max_hops,
         max_partial_attempts: config.max_partial_attempts,
+        risk: Risk {
+            gas_amount_factor: config.risk_parameters.0,
+            gas_price_factor: config.risk_parameters.1,
+            nmb_orders_factor: config.risk_parameters.2,
+            intercept: config.risk_parameters.3,
+        },
         solution_gas_offset: config.solution_gas_offset.into(),
     }
 }

crates/solvers/src/infra/config/mod.rs

@@ -2,6 +2,7 @@ use std::fmt::Debug;
 
 pub mod baseline;
 pub mod legacy;
+pub mod naive;
 
 /// Unwraps result or logs a `TOML` parsing error.
 fn unwrap_or_log<T, E, P>(result: Result<T, E>, path: &P) -> T

crates/solvers/src/infra/config/naive.rs

@@ -0,0 +1,40 @@
+use {
+    crate::{
+        domain::{solver::naive, Risk},
+        infra::config::unwrap_or_log,
+    },
+    serde::Deserialize,
+    serde_with::serde_as,
+    std::path::Path,
+    tokio::fs,
+};
+
+#[serde_as]
+#[derive(Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+struct Config {
+    /// Parameters used to calculate the revert risk of a solution.
+    /// (gas_amount_factor, gas_price_factor, nmb_orders_factor, intercept)
+    risk_parameters: (f64, f64, f64, f64),
+}
+
+/// Load the driver configuration from a TOML file.
+///
+/// # Panics
+///
+/// This method panics if the config is invalid or on I/O errors.
+pub async fn load(path: &Path) -> naive::Config {
+    let data = fs::read_to_string(path)
+        .await
+        .unwrap_or_else(|e| panic!("I/O error while reading {path:?}: {e:?}"));
+    // Not printing detailed error because it could potentially leak secrets.
+    let config = unwrap_or_log(toml::de::from_str::<Config>(&data), &path);
+    naive::Config {
+        risk: Risk {
+            gas_amount_factor: config.risk_parameters.0,
+            gas_price_factor: config.risk_parameters.1,
+            nmb_orders_factor: config.risk_parameters.2,
+            intercept: config.risk_parameters.3,
+        },
+    }
+}

crates/solvers/src/run.rs

@@ -33,7 +33,10 @@ async fn run_with(args: cli::Args, bind: Option<oneshot::Sender<SocketAddr>>) {
             let config = config::baseline::load(&config).await;
             Solver::Baseline(solver::Baseline::new(config))
         }
-        cli::Command::Naive => Solver::Naive(solver::Naive),
+        cli::Command::Naive { config } => {
+            let config = config::naive::load(&config).await;
+            Solver::Naive(solver::Naive::new(config))
+        }
         cli::Command::Legacy { config } => {
             let config = config::legacy::load(&config).await;
             Solver::Legacy(solver::Legacy::new(config))

crates/solvers/src/tests/baseline/bal_liquidity.rs

@@ -12,6 +12,7 @@ async fn weighted() {
                 base-tokens = []
                 max-hops = 0
                 max-partial-attempts = 1
+                risk-parameters = [0,0,0,0]
             "#
             .to_owned(),
         ),
@@ -133,6 +134,7 @@ async fn weighted_v3plus() {
                 base-tokens = []
                 max-hops = 0
                 max-partial-attempts = 1
+                risk-parameters = [0,0,0,0]
             "#
             .to_owned(),
         ),
@@ -247,6 +249,7 @@ async fn stable() {
                 base-tokens = []
                 max-hops = 0
                 max-partial-attempts = 1
+                risk-parameters = [0,0,0,0]
             "#
             .to_owned(),
         ),
@@ -414,6 +417,7 @@ async fn composable_stable_v4() {
                 base-tokens = []
                 max-hops = 0
                 max-partial-attempts = 1
+                risk-parameters = [0,0,0,0]
             "#
             .to_owned(),
         ),

crates/solvers/src/tests/baseline/buy_order_rounding.rs

@@ -118,6 +118,7 @@ async fn balancer_weighted() {
                 base-tokens = ["0x9c58bacc331c9aa871afd802db6379a98e80cedb"]
                 max-hops = 1
                 max-partial-attempts = 1
+                risk-parameters = [0,0,0,0]
             "#
             .to_owned(),
         ),
@@ -284,6 +285,7 @@ async fn balancer_weighted_v3plus() {
                 base-tokens = []
                 max-hops = 0
                 max-partial-attempts = 1
+                risk-parameters = [0,0,0,0]
             "#
             .to_owned(),
         ),
@@ -398,6 +400,7 @@ async fn distant_convergence() {
                 base-tokens = []
                 max-hops = 0
                 max-partial-attempts = 1
+                risk-parameters = [0,0,0,0]
             "#
             .to_owned(),
         ),
@@ -512,6 +515,7 @@ async fn same_path() {
                 base-tokens = ["0x9c58bacc331c9aa871afd802db6379a98e80cedb"]
                 max-hops = 0
                 max-partial-attempts = 1
+                risk-parameters = [0,0,0,0]
             "#
             .to_owned(),
         ),
@@ -662,6 +666,7 @@ async fn balancer_stable() {
                 base-tokens = []
                 max-hops = 0
                 max-partial-attempts = 1
+                risk-parameters = [0,0,0,0]
             "#
             .to_owned(),
         ),

crates/solvers/src/tests/naive/extract_deepest_pool.rs

@@ -13,7 +13,11 @@ use {crate::tests, serde_json::json};
 
 #[tokio::test]
 async fn test() {
-    let engine = tests::SolverEngine::new("naive", tests::Config::None).await;
+    let engine = tests::SolverEngine::new(
+        "naive",
+        tests::Config::String(r#"risk-parameters = [0,0,0,0]"#.to_owned()),
+    )
+    .await;
 
     let solution = engine
         .solve(json!({

crates/solvers/src/tests/naive/filters_out_of_price_orders.rs

@@ -5,7 +5,11 @@ use {crate::tests, serde_json::json};
 
 #[tokio::test]
 async fn sell_orders_on_both_sides() {
-    let engine = tests::SolverEngine::new("naive", tests::Config::None).await;
+    let engine = tests::SolverEngine::new(
+        "naive",
+        tests::Config::String(r#"risk-parameters = [0,0,0,0]"#.to_owned()),
+    )
+    .await;
 
     let solution = engine
         .solve(json!({

crates/solvers/src/tests/naive/limit_order_price.rs

@@ -5,7 +5,11 @@ use {crate::tests, serde_json::json};
 
 #[tokio::test]
 async fn test() {
-    let engine = tests::SolverEngine::new("naive", tests::Config::None).await;
+    let engine = tests::SolverEngine::new(
+        "naive",
+        tests::Config::String(r#"risk-parameters = [0,0,0,0]"#.to_owned()),
+    )
+    .await;
 
     let solution = engine
         .solve(json!({

crates/solvers/src/tests/naive/matches_orders.rs

@@ -5,7 +5,11 @@ use {crate::tests, serde_json::json};
 
 #[tokio::test]
 async fn sell_orders_on_both_sides() {
-    let engine = tests::SolverEngine::new("naive", tests::Config::None).await;
+    let engine = tests::SolverEngine::new(
+        "naive",
+        tests::Config::String(r#"risk-parameters = [0,0,0,0]"#.to_owned()),
+    )
+    .await;
 
     let solution = engine
         .solve(json!({
@@ -108,7 +112,11 @@ async fn sell_orders_on_both_sides() {
 
 #[tokio::test]
 async fn sell_orders_on_one_side() {
-    let engine = tests::SolverEngine::new("naive", tests::Config::None).await;
+    let engine = tests::SolverEngine::new(
+        "naive",
+        tests::Config::String(r#"risk-parameters = [0,0,0,0]"#.to_owned()),
+    )
+    .await;
 
     let solution = engine
         .solve(json!({
@@ -211,7 +219,11 @@ async fn sell_orders_on_one_side() {
 
 #[tokio::test]
 async fn buy_orders_on_both_sides() {
-    let engine = tests::SolverEngine::new("naive", tests::Config::None).await;
+    let engine = tests::SolverEngine::new(
+        "naive",
+        tests::Config::String(r#"risk-parameters = [0,0,0,0]"#.to_owned()),
+    )
+    .await;
 
     let solution = engine
         .solve(json!({
@@ -314,7 +326,11 @@ async fn buy_orders_on_both_sides() {
 
 #[tokio::test]
 async fn buy_and_sell_orders() {
-    let engine = tests::SolverEngine::new("naive", tests::Config::None).await;
+    let engine = tests::SolverEngine::new(
+        "naive",
+        tests::Config::String(r#"risk-parameters = [0,0,0,0]"#.to_owned()),
+    )
+    .await;
 
     let solution = engine
         .solve(json!({

crates/solvers/src/tests/naive/reserves_too_small.rs

@@ -5,7 +5,11 @@ use {crate::tests, serde_json::json};
 
 #[tokio::test]
 async fn test() {
-    let engine = tests::SolverEngine::new("naive", tests::Config::None).await;
+    let engine = tests::SolverEngine::new(
+        "naive",
+        tests::Config::String(r#"risk-parameters = [0,0,0,0]"#.to_owned()),
+    )
+    .await;
 
     let solution = engine
         .solve(json!({