Migrate driver

Author: squadgazzz

Cargo.lock

@@ -49,6 +49,7 @@ serde_json = { workspace = true }
 serde_with = { workspace = true }
 solvers-dto = { path = "../solvers-dto" }
 thiserror = { workspace = true }
+winner-selection = { path = "../winner-selection" }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "time"] }
 toml = { workspace = true }
 tower = { workspace = true }

crates/driver/Cargo.toml

@@ -285,13 +285,7 @@ impl Competition {
             .into_iter()
             .map(|settlement| {
                 observe::scoring(&settlement);
-                (
-                    settlement.score(
-                        &auction.native_prices(),
-                        auction.surplus_capturing_jit_order_owners(),
-                    ),
-                    settlement,
-                )
+                (settlement.score(&auction), settlement)
             })
             .collect_vec();
 
@@ -782,10 +776,7 @@ fn merge(
     merged.sort_by_key(|solution| {
         Reverse(
             solution
-                .scoring(
-                    &auction.native_prices(),
-                    auction.surplus_capturing_jit_order_owners(),
-                )
+                .scoring(&auction)
                 .map(|score| score.0)
                 .unwrap_or_default(),
         )

crates/driver/src/domain/competition/mod.rs

@@ -1,6 +1,5 @@
 use {
     self::trade::{ClearingPrices, Fee, Fulfillment},
-    super::auction,
     crate::{
         boundary,
         domain::{
@@ -30,10 +29,10 @@ use {
 pub mod encoding;
 pub mod fee;
 pub mod interaction;
-pub mod scoring;
 pub mod settlement;
 pub mod slippage;
 pub mod trade;
+pub mod winner_selection;
 
 pub use {error::Error, interaction::Interaction, settlement::Settlement, trade::Trade};
 
@@ -235,42 +234,10 @@ impl Solution {
     }
 
     /// JIT score calculation.
-    pub fn scoring(
-        &self,
-        native_prices: &auction::Prices,
-        surplus_capturing_jit_order_owners: &HashSet<eth::Address>,
-    ) -> Result<eth::Ether, error::Scoring> {
-        let mut trades = Vec::with_capacity(self.trades.len());
-        for trade in self.trades().iter().filter(|trade| {
-            self.trade_count_for_scorable(trade, surplus_capturing_jit_order_owners)
-        }) {
-            // Solver generated fulfillment does not include the fee in the executed amount
-            // for sell orders.
-            let executed = match trade.side() {
-                order::Side::Sell => (trade.executed().0 + trade.fee().0).into(),
-                order::Side::Buy => trade.executed(),
-            };
-            let buy = trade.buy();
-            let sell = trade.sell();
-            let uniform_prices = ClearingPrices {
-                sell: self
-                    .clearing_price(sell.token)
-                    .ok_or(error::Scoring::InvalidClearingPrices)?,
-                buy: self
-                    .clearing_price(buy.token)
-                    .ok_or(error::Scoring::InvalidClearingPrices)?,
-            };
-            trades.push(scoring::Trade::new(
-                sell,
-                buy,
-                trade.side(),
-                executed,
-                trade.custom_prices(&uniform_prices)?,
-                trade.protocol_fees(),
-            ))
-        }
-
-        scoring::compute_score(&trades, native_prices).map_err(error::Scoring::from)
+    ///
+    /// Uses winner-selection crate for score computation to deduplicate logic.
+    pub fn scoring(&self, auction: &competition::Auction) -> Result<eth::Ether, error::Scoring> {
+        winner_selection::compute_score(self, auction, self.weth)
     }
 
     /// Approval interactions necessary for encoding the settlement.
@@ -690,16 +657,6 @@ pub mod error {
         MissingPrice(TokenAddress),
     }
 
-    impl From<scoring::Error> for Scoring {
-        fn from(value: scoring::Error) -> Self {
-            match value {
-                scoring::Error::MissingPrice(e) => Self::MissingPrice(e),
-                scoring::Error::Math(e) => Self::Math(e),
-                scoring::Error::Scoring(e) => e,
-            }
-        }
-    }
-
     #[derive(Debug, thiserror::Error)]
     pub enum Trade {
         #[error("orders with non solver determined gas cost fees are not supported")]