Always quote with limit orders rebased

crates/driver/src/domain/quote.rs

@@ -151,9 +151,7 @@ impl Order {
             solver::Liquidity::Skip => Default::default(),
         };
 
-        let auction = self
-            .single_order_auction(eth, tokens, solver.quote_using_limit_orders())
-            .await?;
+        let auction = self.single_order_auction(eth, tokens).await?;
         let auction = competition
             .risk_detector
             .filter_unsupported_orders_in_auction(auction)
@@ -193,7 +191,6 @@ impl Order {
         &self,
         eth: &Ethereum,
         tokens: &infra::tokens::Fetcher,
-        quote_using_limit_orders: bool,
     ) -> Result<competition::Auction, Error> {
         let tokens = tokens.get(&[self.buy().token, self.sell().token]).await;
 
@@ -213,11 +210,9 @@ impl Order {
                     buy: self.buy(),
                     sell: self.sell(),
                     side: self.side,
-                    kind: if quote_using_limit_orders {
-                        competition::order::Kind::Limit
-                    } else {
-                        competition::order::Kind::Market
-                    },
+                    // Quotes always use limit orders so that the engine
+                    // determines the fee (see `Order::solver_determines_fee`).
+                    kind: competition::order::Kind::Limit,
                     pre_interactions: Default::default(),
                     post_interactions: Default::default(),
                     sell_token_balance: competition::order::SellTokenBalance::Erc20,

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

@@ -77,7 +77,6 @@ pub async fn load(chain: Chain, path: &Path) -> infra::Config {
                 },
                 request_headers: solver_config.request_headers,
                 fee_handler: solver_config.fee_handler,
-                quote_using_limit_orders: solver_config.quote_using_limit_orders,
                 fast_path_enabled: solver_config.fast_path_enabled,
                 merge_solutions: match solver_config.merge_solutions {
                     true => SolutionMerging::Allowed {

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

@@ -275,10 +275,6 @@ struct SolverConfig {
     #[serde(default)]
     fee_handler: FeeHandler,
 
-    /// Use limit orders for quoting
-    #[serde(default)]
-    quote_using_limit_orders: bool,
-
     /// Whether this solver supports fast-path (out-of-competition) execution.
     #[serde(default)]
     fast_path_enabled: bool,

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

@@ -186,9 +186,6 @@ pub struct Config {
     pub request_headers: HashMap<String, String>,
     /// Determines whether the `solver` or the `driver` handles the fees
     pub fee_handler: FeeHandler,
-    /// Use limit orders for quoting
-    /// TODO: Remove once all solvers are moved to use limit orders for quoting
-    pub quote_using_limit_orders: bool,
     /// Whether this solver supports fast-path (out-of-competition) execution.
     pub fast_path_enabled: bool,
     pub merge_solutions: SolutionMerging,
@@ -320,11 +317,6 @@ impl Solver {
         self.config.timeouts
     }
 
-    /// Use limit orders for quoting instead of market orders
-    pub fn quote_using_limit_orders(&self) -> bool {
-        self.config.quote_using_limit_orders
-    }
-
     /// Whether this solver supports fast-path (out-of-competition) execution.
     pub fn fast_path_enabled(&self) -> bool {
         self.config.fast_path_enabled
@@ -601,7 +593,6 @@ mod tests {
             },
             request_headers: Default::default(),
             fee_handler: FeeHandler::Driver,
-            quote_using_limit_orders: false,
             fast_path_enabled: false,
             merge_solutions: SolutionMerging::Forbidden,
             s3: None,

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

@@ -30,26 +30,25 @@ fn extract_buy_amount(response_body: &str, sell_amount: eth::U256) -> eth::U256
     sell_amount * price_low / price_high
 }
 
-/// Run a matrix of tests for all meaningful combinations of order kind and
-/// side, verifying that they get quoted successfully.
+/// Run a matrix of tests for all meaningful order sides, verifying that they
+/// get quoted successfully. Quotes always use limit orders, so there is no
+/// order-kind dimension.
 #[tokio::test]
 #[ignore]
 async fn matrix() {
     for side in [order::Side::Buy, order::Side::Sell] {
-        for kind in [order::Kind::Market, order::Kind::Limit] {
-            let test = tests::setup()
-                .name(format!("{side:?} {kind:?}"))
-                .pool(ab_pool())
-                .order(ab_order().side(side).kind(kind))
-                .solution(ab_solution())
-                .quote()
-                .done()
-                .await;
-
-            let quote = test.quote().await;
-
-            quote.ok().amount().interactions();
-        }
+        let test = tests::setup()
+            .name(format!("{side:?}"))
+            .pool(ab_pool())
+            .order(ab_order().side(side))
+            .solution(ab_solution())
+            .quote()
+            .done()
+            .await;
+
+        let quote = test.quote().await;
+
+        quote.ok().amount().interactions();
     }
 }
 

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

@@ -318,7 +318,7 @@ impl Default for Order {
             partial: Default::default(),
             created: u32::MIN,
             valid_to: u32::MAX,
-            kind: order::Kind::Market,
+            kind: order::Kind::Limit,
             solver_fee: Default::default(),
             name: Default::default(),
             surplus_factor: DEFAULT_SURPLUS_FACTOR.ether().into_wei(),

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

@@ -172,7 +172,6 @@ impl Solver {
                 },
                 "partiallyFillable": matches!(quote.order.partial, Partial::Yes { .. }),
                 "class": match quote.order.kind {
-                    _ if config.quote => "market",
                     order::Kind::Market => "market",
                     order::Kind::Limit => "limit",
                 },

crates/e2e/src/setup/colocation.rs

@@ -128,22 +128,14 @@ pub fn start_driver(
     contracts: &Contracts,
     solvers: Vec<SolverEngine>,
     liquidity: LiquidityProvider,
-    quote_using_limit_orders: bool,
 ) -> JoinHandle<()> {
-    start_driver_with_config_override(
-        contracts,
-        solvers,
-        liquidity,
-        quote_using_limit_orders,
-        None,
-    )
+    start_driver_with_config_override(contracts, solvers, liquidity, None)
 }
 
 pub fn start_driver_with_config_override(
     contracts: &Contracts,
     solvers: Vec<SolverEngine>,
     liquidity: LiquidityProvider,
-    quote_using_limit_orders: bool,
     config_override: Option<&str>,
 ) -> JoinHandle<()> {
     let base_tokens: HashSet<_> = solvers
@@ -181,7 +173,6 @@ endpoint = "{endpoint}"
 relative-slippage = "0.1"
 account = "{account}"
 merge-solutions = {merge_solutions}
-quote-using-limit-orders = {quote_using_limit_orders}
 enable-simulation-bad-token-detection = true
 enable-metrics-bad-order-detection = true
 http-time-buffer = "100ms"

crates/e2e/src/setup/services.rs

@@ -273,7 +273,6 @@ impl<'a> Services<'a> {
                 .await,
             ],
             colocation::LiquidityProvider::UniswapV2,
-            false,
         );
 
         let test_quoter = ExternalSolver::new("test_quoter", "http://localhost:11088/test_solver");
@@ -406,7 +405,6 @@ impl<'a> Services<'a> {
             self.contracts,
             solvers,
             colocation::LiquidityProvider::UniswapV2,
-            false,
         );
 
         self.start_autopilot(Some(Duration::from_secs(11)), autopilot_config)

crates/e2e/tests/e2e/autopilot_leader.rs

@@ -76,7 +76,6 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) {
             .await,
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     let services = Services::new(&onchain).await;

crates/e2e/tests/e2e/buffers.rs

@@ -62,7 +62,6 @@ async fn onchain_settlement_without_liquidity(web3: Web3) {
             .await,
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
     let services = Services::new(&onchain).await;
     services

crates/e2e/tests/e2e/ethflow.rs

@@ -545,7 +545,8 @@ async fn eth_flow_indexing_after_refund(web3: Web3) {
     let services = Services::new(&onchain).await;
     services.start_protocol(solver).await;
 
-    // Create an order that only exists to be cancelled.
+    // Create an order that only exists to be cancelled. It still needs a
+    // realistic amount: solvers don't quote dust that can't cover the gas fee.
     let valid_to = timestamp_of_current_block_in_seconds(&web3.provider)
         .await
         .unwrap()
@@ -554,7 +555,7 @@ async fn eth_flow_indexing_after_refund(web3: Web3) {
         &test_submit_quote(
             &services,
             &(EthFlowTradeIntent {
-                sell_amount: alloy::primitives::U256::from(42),
+                sell_amount: 1u64.eth(),
                 buy_token: *dai.address(),
                 receiver: Address::repeat_byte(42),
             })

crates/e2e/tests/e2e/jit_orders.rs

@@ -88,7 +88,6 @@ async fn single_limit_order_test(web3: Web3) {
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     // We start the quoter as the baseline solver, and the mock solver as the

crates/e2e/tests/e2e/limit_orders.rs

@@ -503,7 +503,6 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) {
             .await,
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     let services = Services::new(&onchain).await;
@@ -746,7 +745,6 @@ async fn too_many_limit_orders_test(web3: Web3) {
             .await,
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     services
@@ -849,7 +847,6 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) {
             .await,
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     services

crates/e2e/tests/e2e/liquidity.rs

@@ -193,7 +193,6 @@ async fn zero_ex_liquidity(web3: Web3) {
         colocation::LiquidityProvider::ZeroEx {
             api_port: zeroex_api_port,
         },
-        false,
     );
 
     services

crates/e2e/tests/e2e/liquidity_source_notification.rs

@@ -193,7 +193,6 @@ async fn liquidity_source_notification(web3: Web3) {
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
         Some(&format!(
             r#"
 [liquidity-sources-notifier]

crates/e2e/tests/e2e/order_cancellation.rs

@@ -68,7 +68,6 @@ async fn order_cancellation(web3: Web3) {
             .await,
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
     services
         .start_autopilot(

crates/e2e/tests/e2e/parallel_settlement.rs

@@ -87,7 +87,6 @@ async fn test_parallel_settlement_submission(web3: Web3) {
         onchain.contracts(),
         vec![solver_engine],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     // Wait for the driver to become available.

crates/e2e/tests/e2e/place_order_with_quote.rs

@@ -240,7 +240,6 @@ async fn fallback_native_price_estimator(web3: Web3) {
             .await,
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     let (manual_shutdown, control) = ShutdownController::new_manual_shutdown();

crates/e2e/tests/e2e/pool_indexer.rs

@@ -463,7 +463,6 @@ max-pools-to-initialize = 10
             onchain.contracts(),
             vec![baseline_solver],
             colocation::LiquidityProvider::UniswapV2,
-            false,
             Some(&config_override),
         );
 

crates/e2e/tests/e2e/quoting.rs

@@ -348,7 +348,6 @@ async fn quote_timeout(web3: Web3) {
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     /// The default quote timeout used when the user does not override it.
@@ -530,7 +529,6 @@ async fn quote_custom_solver_errors(web3: Web3) {
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     services
@@ -656,7 +654,6 @@ async fn native_price_custom_solver_errors(web3: Web3) {
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     services
@@ -770,7 +767,6 @@ async fn quote_custom_solver_errors_prioritized(web3: Web3) {
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     services

crates/e2e/tests/e2e/solver_competition.rs

@@ -93,7 +93,6 @@ async fn solver_competition(web3: Web3) {
             .await,
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     let services = Services::new(&onchain).await;
@@ -279,7 +278,6 @@ async fn wrong_solution_submission_address(web3: Web3) {
             .await,
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     let services = Services::new(&onchain).await;
@@ -446,7 +444,6 @@ async fn store_filtered_solutions(web3: Web3) {
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     // We start the quoter as the baseline solver, and the mock solver as the
@@ -734,7 +731,6 @@ async fn cannot_replace_order_bid_on_by_non_winning_solution(web3: Web3) {
             },
         ],
         colocation::LiquidityProvider::UniswapV2,
-        false,
     );
 
     let config = Configuration::test_no_drivers();

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

@@ -116,7 +116,11 @@ impl Swap {
         simulator: &infra::dex::Simulator,
         gas_offset: eth::Gas,
     ) -> Option<solution::Solution> {
-        let gas = if order.class == order::Class::Limit {
+        // Only simulate gas for limit orders (whose fee depends on it) in
+        // proper auctions, i.e. when the auction has a sell token price. For
+        // quotes and market orders we use the gas indicated by the DEX to save
+        // time.
+        let gas = if order.class == order::Class::Limit && sell_token.is_some() {
             match simulator.gas(order.owner(), &self).await {
                 Ok(value) => value,
                 Err(infra::dex::simulator::Error::SettlementContractIsOwner) => self.gas,
@@ -126,8 +130,6 @@ impl Swap {
                 }
             }
         } else {
-            // We are fine with just using heuristic gas for market orders,
-            // since it doesn't really play a role in the final solution.
             self.gas
         };