Refactor order filter controlling autopilot flags (#3901)

# Description

We are trying to accommodate flashloan testing by disabling balance and
signature filtering in the autopilot. The problem is that it is
legitimate to not have the required sell token balance as it comes from
the flashloan executed in pre-interactions. Similarly it is legitimate
that on 1271 orders the signature checks only succeeds after
pre-interactions with the flashloan have executed.

By disabling these checks in the autopilot we are effectively moving
them onto the driver and potentially introducing performance problems in
it.

# Changes

- [x] Removed `disable_order_filtering` flag that would switch off both
balance and signature filtering
- [x] Introduced `disable_order_balance_filter` flag to control
filtering on insufficient balance
- [x] Introduced `disable_1271_order_sig_filter` to disable filtering on
signatures of 1271 orders

Author: fafk

crates/autopilot/src/arguments.rs

@@ -255,14 +255,16 @@ pub struct Arguments {
     #[clap(flatten)]
     pub db_based_solver_participation_guard: DbBasedSolverParticipationGuardConfig,
 
-    /// Configures whether the autopilot is supposed to do any non-trivial
-    /// order filtering (e.g. based on balances or EIP-1271 signature validity).
+    /// Configures whether the autopilot filters out orders with insufficient
+    /// balances.
     #[clap(long, env, default_value = "false", action = clap::ArgAction::Set)]
-    pub disable_order_filtering: bool,
+    pub disable_order_balance_filter: bool,
 
-    // Filter out orders that have not been presigned even if disable_order_filtering is turned on.
+    // Configures whether the autopilot filters out EIP-1271 orders even if their signatures are
+    // invalid. This is useful as a workaround to let flashloan orders go through as they rely
+    // on preHooks behing executed to make the signatures valid.
     #[clap(long, env, default_value = "false", action = clap::ArgAction::Set)]
-    pub force_presign_order_filtering: bool,
+    pub disable_1271_order_sig_filter: bool,
 
     /// Enables the usage of leader lock in the database
     /// The second instance of autopilot will act as a follower
@@ -399,9 +401,9 @@ impl std::fmt::Display for Arguments {
             archive_node_url,
             max_solutions_per_solver,
             db_based_solver_participation_guard,
-            disable_order_filtering,
+            disable_order_balance_filter,
+            disable_1271_order_sig_filter,
             enable_leader_lock,
-            force_presign_order_filtering,
         } = self;
 
         write!(f, "{shared}")?;
@@ -476,10 +478,13 @@ impl std::fmt::Display for Arguments {
             f,
             "db_based_solver_participation_guard: {db_based_solver_participation_guard:?}"
         )?;
-        writeln!(f, "disable_order_filtering: {disable_order_filtering}")?;
         writeln!(
             f,
-            "force_presign_order_filtering: {force_presign_order_filtering}"
+            "disable_order_balance_filter: {disable_order_balance_filter}"
+        )?;
+        writeln!(
+            f,
+            "disable_1271_order_sig_filter: {disable_1271_order_sig_filter}"
         )?;
         writeln!(f, "enable_leader_lock: {enable_leader_lock}")?;
         Ok(())

crates/autopilot/src/run.rs

@@ -542,8 +542,8 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         cow_amm_registry.clone(),
         args.run_loop_native_price_timeout,
         eth.contracts().settlement().address().into_legacy(),
-        args.disable_order_filtering,
-        args.force_presign_order_filtering,
+        args.disable_order_balance_filter,
+        args.disable_1271_order_sig_filter,
     );
 
     let liveness = Arc::new(Liveness::new(args.max_auction_age));

crates/autopilot/src/solvable_orders.rs

@@ -101,8 +101,8 @@ pub struct SolvableOrdersCache {
     cow_amm_registry: cow_amm::Registry,
     native_price_timeout: Duration,
     settlement_contract: H160,
-    disable_order_filters: bool,
-    force_presign_order_filtering: bool,
+    disable_order_balance_filter: bool,
+    disable_1271_order_sig_filter: bool,
 }
 
 type Balances = HashMap<Query, U256>;
@@ -128,8 +128,8 @@ impl SolvableOrdersCache {
         cow_amm_registry: cow_amm::Registry,
         native_price_timeout: Duration,
         settlement_contract: H160,
-        disable_order_filters: bool,
-        force_presign_order_filtering: bool,
+        disable_order_balance_filter: bool,
+        disable_1271_order_sig_filter: bool,
     ) -> Arc<Self> {
         Arc::new(Self {
             min_order_validity_period,
@@ -147,8 +147,8 @@ impl SolvableOrdersCache {
             cow_amm_registry,
             native_price_timeout,
             settlement_contract,
-            disable_order_filters,
-            force_presign_order_filtering,
+            disable_order_balance_filter,
+            disable_1271_order_sig_filter,
         })
     }
 
@@ -194,7 +194,7 @@ impl SolvableOrdersCache {
             )
         };
 
-        let orders = if self.disable_order_filters {
+        let orders = if self.disable_order_balance_filter {
             orders
         } else {
             let orders = orders_with_balance(orders, &balances, self.settlement_contract);
@@ -326,7 +326,7 @@ impl SolvableOrdersCache {
                 self.balance_fetcher.get_balances(&queries),
             )
             .await;
-        if self.disable_order_filters {
+        if self.disable_order_balance_filter {
             return Default::default();
         }
 
@@ -392,12 +392,11 @@ impl SolvableOrdersCache {
         counter: &mut OrderFilterCounter,
         invalid_order_uids: &mut HashSet<OrderUid>,
     ) -> Vec<Order> {
-        let filter_invalid_signatures = async {
-            if self.disable_order_filters && !self.force_presign_order_filtering {
-                return Default::default();
-            }
-            find_invalid_signature_orders(&orders, self.signature_validator.as_ref()).await
-        };
+        let filter_invalid_signatures = find_invalid_signature_orders(
+            &orders,
+            self.signature_validator.as_ref(),
+            self.disable_1271_order_sig_filter,
+        );
 
         let (banned_user_orders, invalid_signature_orders, unsupported_token_orders) = tokio::join!(
             self.timed_future(
@@ -484,11 +483,17 @@ async fn get_native_prices(
 async fn find_invalid_signature_orders(
     orders: &[Order],
     signature_validator: &dyn SignatureValidating,
+    disable_1271_order_sig_filter: bool,
 ) -> Vec<OrderUid> {
     let mut invalid_orders = vec![];
     let mut signature_check_futures = FuturesUnordered::new();
 
     for order in orders {
+        if let Signature::Eip1271(_) = &order.signature
+            && disable_1271_order_sig_filter
+        {
+            continue;
+        }
         if matches!(
             order.metadata.status,
             model::order::OrderStatus::PresignaturePending
@@ -1304,11 +1309,16 @@ mod tests {
             .returning(|_| Ok(()));
 
         let invalid_signature_orders =
-            find_invalid_signature_orders(&orders, &signature_validator).await;
+            find_invalid_signature_orders(&orders, &signature_validator, false).await;
         assert_eq!(
             invalid_signature_orders,
             vec![OrderUid::from_parts(H256([4; 32]), H160([44; 20]), 4)]
         );
+        let invalid_signature_orders_with_1271_filter_disabled =
+            find_invalid_signature_orders(&orders, &signature_validator, true).await;
+        // if we switch off the 1271 filter no orders should be returned as containing
+        // invalid signatures
+        assert_eq!(invalid_signature_orders_with_1271_filter_disabled, vec![]);
     }
 
     #[test]