Risk calculation in solvers crate

crates/e2e/src/setup/colocation.rs

@@ -13,6 +13,7 @@ weth = "{weth:?}"
 base-tokens = []
 max-hops = 0
 max-partial-attempts = 5
+risk-parameters = [0,0,0,0]
         "#,
     ));
     let args = vec![

crates/solvers/config/example.balancer.toml

@@ -1,5 +1,6 @@
 absolute-slippage = "40000000000000000" # Denominated in wei, optional
 relative-slippage = "0.1" # Percentage in the [0, 1] range
+risk-parameters = [0,0,0,0]
 
 [dex]
 endpoint = "https://balancer.sor.eth/api"

crates/solvers/config/example.baseline.toml

@@ -4,3 +4,4 @@ chain-id = "1"
 base-tokens = []
 max-hops = 0
 max-partial-attempts = 5
+risk-parameters = [0,0,0,0]

crates/solvers/config/example.naive.toml

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

crates/solvers/config/example.oneinch.toml

@@ -1,4 +1,5 @@
 absolute-slippage = "40000000000000000" # Denominated in wei, optional
 relative-slippage = "0.1" # Percentage in the [0, 1] range
+risk-parameters = [0,0,0,0]
 [dex]
 chain-id = "1"

crates/solvers/config/example.paraswap.toml

@@ -1,5 +1,6 @@
 absolute-slippage = "40000000000000000" # Denominated in wei, optional
 relative-slippage = "0.1" # Percentage in the [0, 1] range
+risk-parameters = [0,0,0,0]
 [dex]
 exclude-dexs = [] # which dexs to ignore as liquidity sources
 address = "0xdd2e786980CD58ACc5F64807b354c981f4094936" # public address of the solver

crates/solvers/config/example.zeroex.toml

@@ -1,5 +1,6 @@
 absolute-slippage = "40000000000000000" # Denominated in wei, optional
 relative-slippage = "0.1" # Percentage in the [0, 1] range
+risk-parameters = [0,0,0,0]
 
 [dex]
 # See here how to get a free key: https://0x.org/docs/introduction/getting-started

crates/solvers/src/domain/dex/mod.rs

@@ -106,6 +106,7 @@ impl Swap {
         order: order::Order,
         gas_price: auction::GasPrice,
         sell_token: Option<auction::Price>,
+        score: solution::Score,
     ) -> Option<solution::Solution> {
         let allowance = self.allowance();
         let interactions = vec![solution::Interaction::Custom(solution::CustomInteraction {
@@ -125,7 +126,7 @@ impl Swap {
             interactions,
             gas: self.gas,
         }
-        .into_solution(gas_price, sell_token)
+        .into_solution(gas_price, sell_token, score)
     }
 }
 

crates/solvers/src/domain/mod.rs

@@ -5,5 +5,8 @@ pub mod dex;
 pub mod eth;
 pub mod liquidity;
 pub mod order;
+pub 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/solution.rs

@@ -1,6 +1,6 @@
 use {
     crate::{
-        domain::{auction, eth, liquidity, order},
+        domain::{auction, eth, liquidity, order, solution, Risk},
         util,
     },
     ethereum_types::{Address, U256},
@@ -22,6 +22,18 @@ impl Solution {
         Self { score, ..self }
     }
 
+    pub fn with_risk_adjusted_score(
+        self,
+        risk: &Risk,
+        gas: eth::Gas,
+        gas_price: auction::GasPrice,
+    ) -> Self {
+        let nmb_orders = self.trades.len();
+        self.with_score(Score::RiskAdjusted(
+            risk.success_probability(gas, gas_price, nmb_orders),
+        ))
+    }
+
     /// Returns `self` with eligible interactions internalized using the
     /// Settlement contract buffers.
     ///
@@ -111,6 +123,7 @@ impl Single {
         self,
         gas_price: auction::GasPrice,
         sell_token: Option<auction::Price>,
+        score: solution::Score,
     ) -> Option<Solution> {
         let Self {
             order,
@@ -183,7 +196,7 @@ impl Single {
             ]),
             trades: vec![Trade::Fulfillment(Fulfillment::new(order, executed, fee)?)],
             interactions,
-            score: Default::default(),
+            score,
         })
     }
 }
@@ -379,3 +392,13 @@ impl Default for Score {
         Self::RiskAdjusted(1.0)
     }
 }
+
+// initial tx gas used to call the settle function from the settlement contract
+pub const INITIALIZATION_COST: u64 = 32_000;
+/// minimum gas every settlement takes (isSolver)
+pub const SETTLEMENT: u64 = 7365;
+/// lower bound for an erc20 transfer.
+///
+/// Value was computed by taking 52 percentile median of `transfer()` costs
+/// of the 90% most traded tokens by volume in the month of Oct. 2021.
+pub const ERC20_TRANSFER: u64 = 27_513;

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

@@ -9,6 +9,7 @@ use {
     crate::{
         boundary,
         domain::{
+            self,
             auction,
             eth,
             liquidity,
@@ -44,6 +45,9 @@ 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,
 }
 
 impl Baseline {
@@ -54,6 +58,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,
         }))
     }
 
@@ -117,6 +122,12 @@ impl Inner {
                             output.amount = cmp::min(output.amount, order.buy.amount);
                         }
 
+                        let score = solution::Score::RiskAdjusted(self.risk.success_probability(
+                            route.gas(),
+                            auction.gas_price,
+                            1,
+                        ));
+
                         Some(
                             solution::Single {
                                 order: order.clone(),
@@ -125,7 +136,7 @@ impl Inner {
                                 interactions,
                                 gas: route.gas(),
                             }
-                            .into_solution(auction.gas_price, sell_token)?
+                            .into_solution(auction.gas_price, sell_token, score)?
                             .with_buffers_internalizations(&auction.tokens),
                         )
                     })

crates/solvers/src/domain/solver/dex/mod.rs

@@ -3,6 +3,7 @@
 
 use {
     crate::{
+        domain,
         domain::{auction, dex::slippage, order, solution, solver::dex::fills::Fills},
         infra,
     },
@@ -26,6 +27,9 @@ pub struct Dex {
     /// Helps to manage the strategy to fill orders (especially partially
     /// fillable orders).
     fills: Fills,
+
+    /// Parameters used to calculate the revert risk of a solution.
+    risk: domain::Risk,
 }
 
 impl Dex {
@@ -35,6 +39,7 @@ impl Dex {
             slippage: config.slippage,
             concurrent_requests: config.concurrent_requests,
             fills: Fills::new(config.smallest_partial_fill),
+            risk: config.risk,
         }
     }
 
@@ -108,7 +113,9 @@ impl Dex {
 
         let uid = order.uid;
         let sell = tokens.reference_price(&order.sell.token);
-        let Some(solution) = swap.into_solution(order.clone(), gas_price, sell) else {
+        let score =
+            solution::Score::RiskAdjusted(self.risk.success_probability(swap.gas, gas_price, 1));
+        let Some(solution) = swap.into_solution(order.clone(), gas_price, sell, score) else {
             tracing::debug!("no solution for swap");
             return None;
         };

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

@@ -8,17 +8,27 @@
 use {
     crate::{
         boundary,
-        domain::{auction, liquidity, order, solution},
+        domain::{self, auction, eth, liquidity, order, solution},
+        infra::config,
     },
     std::collections::HashMap,
 };
 
-pub struct Naive;
+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::naive::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> {
+        let risk = self.risk.clone();
         // Make sure to push the CPU-heavy code to a separate thread in order to
         // not lock up the [`tokio`] runtime and cause it to slow down handling
         // the real async things.
@@ -28,7 +38,19 @@ impl Naive {
             let groups = group_by_token_pair(&auction);
             groups
                 .values()
-                .filter_map(|group| boundary::naive::solve(&group.orders, group.liquidity))
+                .filter_map(|group| {
+                    boundary::naive::solve(&group.orders, group.liquidity).map(|solution| {
+                        let gas = solution::INITIALIZATION_COST
+                            + solution::SETTLEMENT
+                            + solution::ERC20_TRANSFER * solution.trades.len() as u64 * 2
+                            + group.liquidity.gas.0.as_u64(); // this is pessimistic in case the pool is not used
+                        solution.with_risk_adjusted_score(
+                            &risk,
+                            eth::Gas(gas.into()),
+                            auction.gas_price,
+                        )
+                    })
+                })
                 .map(|solution| solution.with_buffers_internalizations(&auction.tokens))
                 .collect()
         })

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/file.rs

@@ -1,6 +1,6 @@
 use {
     crate::{
-        domain::eth,
+        domain::{eth, Risk},
         infra::{config::unwrap_or_log, contracts},
         util::serialize,
     },
@@ -37,6 +37,10 @@ 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),
 }
 
 /// Load the driver configuration from a TOML file.
@@ -71,5 +75,11 @@ pub async fn load(path: &Path) -> super::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,
+        },
     }
 }

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

@@ -1,4 +1,4 @@
-use crate::domain::eth;
+use crate::domain::{eth, Risk};
 
 pub mod file;
 
@@ -7,4 +7,5 @@ pub struct Config {
     pub base_tokens: Vec<eth::TokenAddress>,
     pub max_hops: usize,
     pub max_partial_attempts: usize,
+    pub risk: Risk,
 }

crates/solvers/src/infra/config/dex/file.rs

@@ -2,7 +2,7 @@
 
 use {
     crate::{
-        domain::{dex::slippage, eth},
+        domain::{dex::slippage, eth, Risk},
         infra::config::unwrap_or_log,
     },
     bigdecimal::BigDecimal,
@@ -34,6 +34,10 @@ struct Config {
     #[serde(default = "default_smallest_partial_fill")]
     smallest_partial_fill: eth::U256,
 
+    /// 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),
+
     /// Settings specific to the wrapped dex API.
     dex: toml::Value,
 }
@@ -73,6 +77,12 @@ pub async fn load<T: DeserializeOwned>(path: &Path) -> (super::Config, T) {
         .expect("invalid slippage limits"),
         concurrent_requests: config.concurrent_requests,
         smallest_partial_fill: eth::Ether(config.smallest_partial_fill),
+        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,
+        },
     };
 
     (config, dex)

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

@@ -5,12 +5,13 @@ pub mod paraswap;
 pub mod zeroex;
 
 use {
-    crate::domain::{dex::slippage, eth},
+    crate::domain::{dex::slippage, eth, Risk},
     std::num::NonZeroUsize,
 };
 
 pub struct Config {
     pub slippage: slippage::Limits,
     pub concurrent_requests: NonZeroUsize,
     pub smallest_partial_fill: eth::Ether,
+    pub risk: Risk,
 }

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

@@ -3,6 +3,7 @@ use std::fmt::Debug;
 pub mod baseline;
 pub mod dex;
 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