Filter limit orders during auction cutting

crates/autopilot/Cargo.toml

@@ -18,6 +18,7 @@ path = "src/main.rs"
 anyhow = { workspace = true }
 approx = "0.5"
 async-trait = { workspace = true }
+bigdecimal = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
 contracts = { path = "../contracts" }

crates/autopilot/src/arguments.rs

@@ -130,6 +130,9 @@ pub struct Arguments {
     /// in COW base units
     #[clap(long, env)]
     pub cip_14_reward_cap: Option<f64>,
+
+    #[clap(long, env, default_value = "0")]
+    pub limit_order_price_factor: f64,
 }
 
 impl std::fmt::Display for Arguments {

crates/autopilot/src/lib.rs

@@ -501,6 +501,9 @@ pub async fn main(args: arguments::Arguments) {
         risk_adjusted_rewards,
         args.ethflow_contract,
         args.max_surplus_fee_age * 2,
+        args.limit_order_price_factor
+            .try_into()
+            .expect("limit order price factor can't be converted to BigDecimal"),
     );
     solvable_orders_cache
         .update(block)

crates/autopilot/src/solvable_orders.rs

@@ -1,8 +1,15 @@
 use crate::{database::Postgres, risk_adjusted_rewards};
 use anyhow::{Context as _, Result};
+use bigdecimal::BigDecimal;
 use chrono::Utc;
 use futures::StreamExt;
-use model::{auction::Auction, order::Order, signature::Signature, time::now_in_epoch_seconds};
+use model::{
+    auction::Auction,
+    order::{Order, OrderClass},
+    signature::Signature,
+    time::now_in_epoch_seconds,
+};
+use number_conversions::u256_to_big_decimal;
 use primitive_types::{H160, H256, U256};
 use prometheus::{IntCounter, IntGauge};
 use shared::{
@@ -63,6 +70,7 @@ pub struct SolvableOrdersCache {
     reward_calculator: Option<risk_adjusted_rewards::Calculator>,
     ethflow_contract_address: H160,
     surplus_fee_age: Duration,
+    limit_order_price_factor: BigDecimal,
 }
 
 type Balances = HashMap<Query, U256>;
@@ -95,6 +103,7 @@ impl SolvableOrdersCache {
         reward_calculator: Option<risk_adjusted_rewards::Calculator>,
         ethflow_contract_address: H160,
         surplus_fee_age: Duration,
+        limit_order_price_factor: BigDecimal,
     ) -> Arc<Self> {
         let self_ = Arc::new(Self {
             min_order_validity_period,
@@ -117,6 +126,7 @@ impl SolvableOrdersCache {
             reward_calculator,
             ethflow_contract_address,
             surplus_fee_age,
+            limit_order_price_factor,
         });
         tokio::task::spawn(update_task(
             Arc::downgrade(&self_),
@@ -187,6 +197,9 @@ impl SolvableOrdersCache {
             self.metrics,
         )
         .await;
+
+        let orders = self.filter_mispriced_limit_orders(orders, &prices);
+
         let rewards = if let Some(calculator) = &self.reward_calculator {
             let rewards = calculator
                 .calculate_many(&orders)
@@ -236,6 +249,34 @@ impl SolvableOrdersCache {
     pub fn last_update_time(&self) -> Instant {
         self.cache.lock().unwrap().orders.update_time
     }
+
+    /// Filter out limit orders which are far enough outside the estimated native token price.
+    fn filter_mispriced_limit_orders(
+        &self,
+        mut orders: Vec<Order>,
+        prices: &BTreeMap<H160, U256>,
+    ) -> Vec<Order> {
+        orders.retain(|order| {
+            if order.metadata.class != OrderClass::Limit {
+                return true;
+            }
+
+            // Convert the sell and buy price to the native token (ETH) and make sure that sell
+            // with the surplus fee is higher than buy with the configurable price factor.
+            let sell_native = (order.data.sell_amount + order.metadata.surplus_fee)
+                * prices.get(&order.data.sell_token).unwrap();
+            let buy_native = order.data.buy_amount * prices.get(&order.data.buy_token).unwrap();
+            let sell_native = u256_to_big_decimal(&sell_native);
+            let buy_native = u256_to_big_decimal(&buy_native);
+            if sell_native >= buy_native * self.limit_order_price_factor.clone() {
+                true
+            } else {
+                tracing::debug!(order_uid = %order.metadata.uid, "limit order is outside market price, skipping");
+                false
+            }
+        });
+        orders
+    }
 }
 
 /// Filters all orders whose owners are in the set of "banned" users.

crates/e2e/tests/e2e/services.rs

@@ -257,6 +257,7 @@ impl OrderbookServices {
             None,
             H160::zero(),
             Default::default(),
+            0.97.try_into().unwrap(),
         );
         let order_validator = Arc::new(
             OrderValidator::new(