Add solver margin configuration to protect against negative slippage

crates/driver/src/domain/quote.rs

@@ -34,12 +34,14 @@ pub struct Quote {
 
 impl Quote {
     fn try_new(eth: &Ethereum, solution: competition::Solution) -> Result<Self, Error> {
+        let clearing_prices: HashMap<eth::Address, eth::U256> = solution
+            .clearing_prices()
+            .into_iter()
+            .map(|(token, amount)| (token.into(), amount))
+            .collect();
+
         Ok(Self {
-            clearing_prices: solution
-                .clearing_prices()
-                .into_iter()
-                .map(|(token, amount)| (token.into(), amount))
-                .collect(),
+            clearing_prices,
             pre_interactions: solution.pre_interactions().to_vec(),
             interactions: solution
                 .interactions()

crates/driver/src/infra/config/file/load.rs

@@ -147,6 +147,7 @@ pub async fn load(chain: Chain, path: &Path) -> infra::Config {
                     file::AtBlock::Latest => liquidity::AtBlock::Latest,
                     file::AtBlock::Finalized => liquidity::AtBlock::Finalized,
                 },
+                margin_bps: solver_config.margin_bps,
             }
         }))
         .await,

crates/driver/src/infra/config/file/mod.rs

@@ -312,6 +312,19 @@ struct SolverConfig {
     /// before the driver starts dropping new `/solve` requests.
     #[serde(default = "default_settle_queue_size")]
     settle_queue_size: usize,
+
+    /// Margin in basis points (0-10000). Applied to order limits sent to
+    /// solvers to make bids more conservative. For sell orders, increases
+    /// the minimum buy amount requirement. For buy orders, decreases the
+    /// maximum sell amount allowed. This forces solvers to find solutions
+    /// with enough surplus to cover the margin. Default: 0 (no margin).
+    ///
+    /// Note: This value should typically match the slippage tolerance
+    /// configured on external pricing APIs used by the solver. Setting a
+    /// higher margin than the expected negative slippage would unnecessarily
+    /// penalize orders.
+    #[serde(default)]
+    margin_bps: u32,
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize)]

crates/driver/src/infra/solver/dto/auction.rs

@@ -28,6 +28,7 @@ pub fn new(
     flashloan_hints: &HashMap<order::Uid, eth::Flashloan>,
     wrappers: &WrapperCalls,
     deadline: chrono::DateTime<chrono::Utc>,
+    margin_bps: u32,
 ) -> solvers_dto::auction::Auction {
     let mut tokens: HashMap<eth::Address, _> = auction
         .tokens()
@@ -110,6 +111,44 @@ pub fn new(
                         }
                     })
                 }
+                // Apply margin by adjusting order limits (similar to volume fees).
+                // This forces solvers to find solutions with enough surplus to cover
+                // the margin applied during competition scoring.
+                if margin_bps > 0 {
+                    let factor = margin_bps as f64 / 10_000.0;
+                    match order.side {
+                        Side::Buy => {
+                            // For buy orders: reduce maximum sell amount
+                            if let Some(adjusted) =
+                                available.sell.amount.apply_factor(1.0 / (1.0 + factor))
+                            {
+                                available.sell.amount = adjusted;
+                            } else {
+                                tracing::warn!(
+                                    "applying margin bps {} led to sell amount underflow for \
+                                     order {:?}",
+                                    margin_bps,
+                                    order.uid
+                                );
+                            }
+                        }
+                        Side::Sell => {
+                            // For sell orders: increase minimum buy amount requirement
+                            if let Some(adjusted) =
+                                available.buy.amount.apply_factor(1.0 / (1.0 - factor))
+                            {
+                                available.buy.amount = adjusted;
+                            } else {
+                                tracing::warn!(
+                                    "applying margin bps {} led to buy amount overflow for order \
+                                     {:?}",
+                                    margin_bps,
+                                    order.uid
+                                );
+                            }
+                        }
+                    }
+                }
                 solvers_dto::auction::Order {
                     uid: order.uid.into(),
                     sell_token: available.sell.token.0.0,

crates/driver/src/infra/solver/mod.rs

@@ -187,6 +187,11 @@ pub struct Config {
     /// Defines at which block the liquidity needs to be fetched on /solve
     /// requests.
     pub fetch_liquidity_at_block: infra::liquidity::AtBlock,
+    /// Margin in basis points (0-10000). Applied to order limits sent to
+    /// solvers to make bids more conservative. For sell orders, increases
+    /// the minimum buy amount. For buy orders, decreases the maximum sell
+    /// amount. Default: 0 (no margin).
+    pub margin_bps: u32,
 }
 
 impl Solver {
@@ -277,6 +282,11 @@ impl Solver {
         self.config.fetch_liquidity_at_block.clone()
     }
 
+    /// Margin in basis points (0-10000) for conservative bidding.
+    pub fn margin_bps(&self) -> u32 {
+        self.config.margin_bps
+    }
+
     /// Make a POST request instructing the solver to solve an auction.
     /// Allocates at most `timeout` time for the solving.
     #[instrument(name = "solver_engine", skip_all)]
@@ -301,6 +311,7 @@ impl Solver {
             &flashloan_hints,
             &wrappers,
             auction.deadline(self.timeouts()).solvers(),
+            self.config.margin_bps,
         );
 
         let body = {

crates/driver/src/tests/cases/margin.rs

@@ -0,0 +1,47 @@
+//! Tests that verify margin is correctly applied to order limits before
+//! sending to solvers.
+
+use crate::{
+    domain::{competition::order, eth},
+    tests::{
+        self,
+        setup::{ab_order, ab_pool, ab_solution, test_solver},
+    },
+};
+
+/// Test that verifies the solver receives orders with adjusted limits when
+/// margin is applied.
+///
+/// For sell orders: the minimum buy amount is increased by the margin factor
+/// For buy orders: the maximum sell amount is reduced by the margin factor
+///
+/// The test works by setting up a solver mock that expects the adjusted amounts
+/// and will fail the assertion if the received amounts don't match.
+#[tokio::test]
+#[ignore]
+async fn margin_adjusts_order_limits() {
+    // Test with 1% margin (100 basis points)
+    let margin_bps = 100u32;
+
+    for side in [order::Side::Sell, order::Side::Buy] {
+        // Limit orders require solver-determined fees
+        let order = ab_order()
+            .kind(order::Kind::Limit)
+            .side(side)
+            .solver_fee(Some(eth::U256::from(500)));
+
+        let test = tests::setup()
+            .name(format!("Margin: {side:?}"))
+            .solvers(vec![test_solver().margin_bps(margin_bps)])
+            .pool(ab_pool())
+            .order(order.clone())
+            .solution(ab_solution())
+            .done()
+            .await;
+
+        // The solver mock will verify that the order limits are adjusted
+        // according to the margin. If the limits are not correctly adjusted,
+        // the mock will fail with an assertion error.
+        test.solve().await.ok().orders(&[order]);
+    }
+}

crates/driver/src/tests/cases/mod.rs

@@ -14,6 +14,7 @@ pub mod fees;
 mod flashloan_hints;
 pub mod internalization;
 pub mod jit_orders;
+pub mod margin;
 pub mod merge_settlements;
 pub mod multiple_drivers;
 pub mod multiple_solutions;

crates/driver/src/tests/setup/driver.rs

@@ -319,6 +319,7 @@ async fn create_config_file(
                http-time-buffer = "{}ms"
                fee-handler = {}
                merge-solutions = {}
+               margin-bps = {}
                "#,
             solver.name,
             addr,
@@ -333,6 +334,7 @@ async fn create_config_file(
             solver.timeouts.http_delay.num_milliseconds(),
             serde_json::to_string(&solver.fee_handler).unwrap(),
             solver.merge_solutions,
+            solver.margin_bps,
         )
         .unwrap();
     }

crates/driver/src/tests/setup/mod.rs

@@ -360,6 +360,8 @@ pub struct Solver {
     /// Whether or not solver is allowed to combine multiple solutions into a
     /// new one.
     merge_solutions: bool,
+    /// Margin in basis points (0-10000) for conservative bidding.
+    margin_bps: u32,
 }
 
 #[derive(Debug, Clone)]
@@ -386,6 +388,7 @@ pub fn test_solver() -> Solver {
         },
         fee_handler: FeeHandler::default(),
         merge_solutions: false,
+        margin_bps: 0,
     }
 }
 
@@ -424,6 +427,11 @@ impl Solver {
         self.merge_solutions = true;
         self
     }
+
+    pub fn margin_bps(mut self, margin_bps: u32) -> Self {
+        self.margin_bps = margin_bps;
+        self
+    }
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -963,6 +971,7 @@ impl Setup {
                 expected_surplus_capturing_jit_order_owners: surplus_capturing_jit_order_owners
                     .clone(),
                 allow_multiple_solve_requests: self.allow_multiple_solve_requests,
+                margin_bps: solver.margin_bps,
             })
             .await;
 

crates/driver/src/tests/setup/solver.rs

@@ -45,6 +45,8 @@ pub struct Config<'a> {
     pub private_key: PrivateKeySigner,
     pub expected_surplus_capturing_jit_order_owners: Vec<Address>,
     pub allow_multiple_solve_requests: bool,
+    /// Margin in basis points (0-10000) for conservative bidding.
+    pub margin_bps: u32,
 }
 
 impl Solver {
@@ -89,6 +91,14 @@ impl Solver {
                             _ => {}
                         }
                     }
+                    // Apply margin: reduce sell amount for buy orders
+                    if config.margin_bps > 0 {
+                        let factor = config.margin_bps as f64 / 10_000.0;
+                        current_sell_amount = eth::TokenAmount(current_sell_amount)
+                            .apply_factor(1.0 / (1.0 + factor))
+                            .unwrap()
+                            .0;
+                    }
                     current_sell_amount.to_string()
                 }
                 _ => quote.sell_amount().to_string(),
@@ -115,6 +125,14 @@ impl Solver {
                             _ => {}
                         }
                     }
+                    // Apply margin: increase buy amount for sell orders
+                    if config.margin_bps > 0 {
+                        let factor = config.margin_bps as f64 / 10_000.0;
+                        current_buy_amount = eth::TokenAmount(current_buy_amount)
+                            .apply_factor(1.0 / (1.0 - factor))
+                            .unwrap()
+                            .0;
+                    }
                     current_buy_amount.to_string()
                 }
                 _ => quote.buy_amount().to_string(),

crates/e2e/src/setup/colocation.rs

@@ -14,6 +14,7 @@ pub struct SolverEngine {
     pub account: TestAccount,
     pub base_tokens: Vec<Address>,
     pub merge_solutions: bool,
+    pub margin_bps: u32,
 }
 
 pub async fn start_baseline_solver(
@@ -23,6 +24,27 @@ pub async fn start_baseline_solver(
     base_tokens: Vec<Address>,
     max_hops: usize,
     merge_solutions: bool,
+) -> SolverEngine {
+    start_baseline_solver_with_margin(
+        name,
+        account,
+        weth,
+        base_tokens,
+        max_hops,
+        merge_solutions,
+        0,
+    )
+    .await
+}
+
+pub async fn start_baseline_solver_with_margin(
+    name: String,
+    account: TestAccount,
+    weth: Address,
+    base_tokens: Vec<Address>,
+    max_hops: usize,
+    merge_solutions: bool,
+    margin_bps: u32,
 ) -> SolverEngine {
     let encoded_base_tokens = encode_base_tokens(base_tokens.clone());
     let config_file = config_tmp_file(format!(
@@ -43,6 +65,7 @@ uni-v3-node-url = "http://localhost:8545"
         account,
         base_tokens,
         merge_solutions,
+        margin_bps,
     }
 }
 
@@ -140,6 +163,7 @@ pub fn start_driver_with_config_override(
                  endpoint,
                  base_tokens: _,
                  merge_solutions,
+                 margin_bps,
              }| {
                 let account = account.signer.to_bytes();
                 format!(
@@ -155,6 +179,7 @@ enable-simulation-bad-token-detection = true
 enable-metrics-bad-token-detection = true
 http-time-buffer = "100ms"
 solving-share-of-deadline = 1.0
+margin-bps = {margin_bps}
 "#
                 )
             },

crates/e2e/src/setup/services.rs

@@ -336,6 +336,7 @@ impl<'a> Services<'a> {
             endpoint: external_solver_endpoint,
             base_tokens: vec![],
             merge_solutions: true,
+            margin_bps: 0,
         }];
 
         let (autopilot_args, api_args) = if run_baseline {

crates/e2e/tests/e2e/cow_amm.rs

@@ -171,6 +171,7 @@ async fn cow_amm_jit(web3: Web3) {
                 endpoint: mock_solver.url.clone(),
                 base_tokens: vec![],
                 merge_solutions: true,
+                margin_bps: 0,
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
@@ -534,6 +535,7 @@ async fn cow_amm_driver_support(web3: Web3) {
                 endpoint: mock_solver.url.clone(),
                 base_tokens: vec![],
                 merge_solutions: true,
+                margin_bps: 0,
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
@@ -801,6 +803,7 @@ async fn cow_amm_opposite_direction(web3: Web3) {
                 endpoint: mock_solver.url.clone(),
                 base_tokens: vec![],
                 merge_solutions: true,
+                margin_bps: 0,
             },
         ],
         colocation::LiquidityProvider::UniswapV2,

crates/e2e/tests/e2e/jit_orders.rs

@@ -78,6 +78,7 @@ async fn single_limit_order_test(web3: Web3) {
                 endpoint: mock_solver.url.clone(),
                 base_tokens: vec![*token.address()],
                 merge_solutions: true,
+                margin_bps: 0,
             },
         ],
         colocation::LiquidityProvider::UniswapV2,