Merge branch 'cowprotocol:main' into main

Author: xdecentralix

crates/autopilot/src/arguments.rs

@@ -232,9 +232,17 @@ pub struct Arguments {
     #[clap(long, env, default_value = "0s", value_parser = humantime::parse_duration)]
     pub run_loop_native_price_timeout: Duration,
 
-    #[clap(long, env, default_value = "20")]
+    #[clap(long, env)]
+    /// When set, enables combinatorial auctions for auctions with a deadline
+    /// later than this timestamp.
+    // TODO: Remove after the cutover has fully taken effect.
+    pub combinatorial_auctions_cutover: Option<chrono::DateTime<chrono::Utc>>,
+
+    #[clap(long, env, default_value = "1")]
     /// The maximum number of winners per auction. Each winner will be allowed
     /// to settle their winning orders at the same time.
+    /// This setting only applies to auctions occurring after
+    /// `combinatorial_auctions_cutover`.
     pub max_winners_per_auction: NonZeroUsize,
 
     #[clap(long, env, default_value = "3")]
@@ -372,6 +380,7 @@ impl std::fmt::Display for Arguments {
             cow_amm_configs,
             max_run_loop_delay,
             run_loop_native_price_timeout,
+            combinatorial_auctions_cutover,
             max_winners_per_auction,
             archive_node_url,
             max_solutions_per_solver,
@@ -440,6 +449,10 @@ impl std::fmt::Display for Arguments {
             f,
             "run_loop_native_price_timeout: {run_loop_native_price_timeout:?}"
         )?;
+        writeln!(
+            f,
+            "combinatorial_auctions_cutover: {combinatorial_auctions_cutover:?}"
+        )?;
         writeln!(f, "max_winners_per_auction: {max_winners_per_auction:?}")?;
         writeln!(f, "archive_node_url: {archive_node_url:?}")?;
         writeln!(f, "max_solutions_per_solver: {max_solutions_per_solver:?}")?;

crates/autopilot/src/database/competition.rs

@@ -19,6 +19,8 @@ use {
 #[derive(Clone, Default, Debug)]
 pub struct Competition {
     pub auction_id: AuctionId,
+    // TODO: remove when `settlement_scores` table is no longer used
+    pub legacy: Option<LegacyScore>,
     pub reference_scores: HashMap<eth::Address, Score>,
     /// Addresses to which the CIP20 participation rewards will be payed out.
     /// Usually the same as the solver addresses.
@@ -58,6 +60,33 @@ impl super::Postgres {
             .await
             .context("solver_competition::save")?;
 
+        // TODO: this is deprecated and needs to be removed once the solver team has
+        // switched to the reference_scores table.
+        // If we enable combinatorial auctions before that switch the solver rewards
+        // payout will be blocked until the switch happens since no data would be
+        // stored in the old format anymore.
+        if let Some(legacy) = &competition.legacy {
+            database::settlement_scores::insert(
+                &mut ex,
+                database::settlement_scores::Score {
+                    auction_id: competition.auction_id,
+                    winner: ByteArray(legacy.winner.0),
+                    winning_score: u256_to_big_decimal(&legacy.winning_score),
+                    reference_score: u256_to_big_decimal(&legacy.reference_score),
+                    block_deadline: competition
+                        .block_deadline
+                        .try_into()
+                        .context("convert block deadline")?,
+                    simulation_block: competition
+                        .competition_simulation_block
+                        .try_into()
+                        .context("convert simulation block")?,
+                },
+            )
+            .await
+            .context("settlement_scores::insert")?;
+        }
+
         let reference_scores: Vec<_> = competition
             .reference_scores
             .iter()

…c/domain/competition/winner_selection.rs …tition/winner_selection/combinatorial.rscrates/autopilot/src/domain/competition/winner_selection.rs renamed to crates/autopilot/src/domain/competition/winner_selection/combinatorial.rs crates/autopilot/src/domain/competition/winner_selection.rs renamed to crates/autopilot/src/domain/competition/winner_selection/combinatorial.rs

@@ -24,6 +24,7 @@
 //! That is effectively a measurement of how much better each order got executed
 //! because solver S participated in the competition.
 use {
+    super::{Arbitrator, PartitionedSolutions, Ranking},
     crate::domain::{
         self,
         OrderUid,
@@ -47,43 +48,7 @@ use {
     },
 };
 
-/// Implements auction arbitration in 3 phases:
-/// 1. filter unfair solutions
-/// 2. mark winners
-/// 3. compute reference scores
-///
-/// The functions assume the `Arbitrator` is the only one
-/// changing the ordering or the `participants`.
-impl Arbitrator {
-    /// Runs the entire auction mechanism on the passed in solutions.
-    pub fn arbitrate(
-        &self,
-        participants: Vec<Participant<Unranked>>,
-        auction: &domain::Auction,
-    ) -> Ranking {
-        let partitioned = self.partition_unfair_solutions(participants, auction);
-        let filtered_out = partitioned
-            .discarded
-            .into_iter()
-            .map(|participant| participant.rank(Ranked::FilteredOut))
-            .collect();
-
-        let mut ranked = self.mark_winners(partitioned.kept);
-        ranked.sort_by_key(|participant| {
-            (
-                // winners before non-winners
-                std::cmp::Reverse(participant.is_winner()),
-                // high score before low score
-                std::cmp::Reverse(participant.solution().computed_score().cloned()),
-            )
-        });
-        Ranking {
-            filtered_out,
-            ranked,
-        }
-    }
-
-    /// Removes unfair solutions from the set of all solutions.
+impl Arbitrator for Config {
     fn partition_unfair_solutions(
         &self,
         mut participants: Vec<Participant<Unranked>>,
@@ -134,8 +99,6 @@ impl Arbitrator {
         }
     }
 
-    /// Picks winners and sorts all solutions where winners come before
-    /// non-winners and higher scores come before lower scores.
     fn mark_winners(&self, participants: Vec<Participant<Unranked>>) -> Vec<Participant> {
         let winner_indexes = self.pick_winners(participants.iter().map(|p| p.solution()));
         participants
@@ -151,9 +114,7 @@ impl Arbitrator {
             .collect()
     }
 
-    /// Computes the reference scores which are used to compute
-    /// rewards for the winning solvers.
-    pub fn compute_reference_scores(&self, ranking: &Ranking) -> HashMap<eth::Address, Score> {
+    fn compute_reference_scores(&self, ranking: &Ranking) -> HashMap<eth::Address, Score> {
         let mut reference_scores = HashMap::default();
 
         for participant in &ranking.ranked {
@@ -189,7 +150,9 @@ impl Arbitrator {
 
         reference_scores
     }
+}
 
+impl Config {
     /// Returns indices of winning solutions.
     /// Assumes that `solutions` is sorted by score descendingly.
     /// This logic was moved into a helper function to avoid a ton of `.clone()`
@@ -349,7 +312,7 @@ fn score_by_token_pair(solution: &Solution, auction: &Auction) -> Result<ScoreBy
     Ok(scores)
 }
 
-pub struct Arbitrator {
+pub struct Config {
     pub max_winners: usize,
     pub weth: WrappedNativeToken,
 }
@@ -415,48 +378,6 @@ type ScoreByDirection = HashMap<DirectedTokenPair, Score>;
 /// of the auction.
 type ScoresBySolution = HashMap<SolutionKey, ScoreByDirection>;
 
-pub struct Ranking {
-    /// Solutions that were discarded because they were malformed
-    /// in some way or deemed unfair by the selection mechanism.
-    filtered_out: Vec<Participant<Ranked>>,
-    /// Final ranking of the solutions that passed the fairness
-    /// check. Winners come before non-winners and higher total
-    /// scores come before lower scores.
-    ranked: Vec<Participant<Ranked>>,
-}
-
-impl Ranking {
-    /// All solutions including the ones that got filtered out.
-    pub fn all(&self) -> impl Iterator<Item = &Participant<Ranked>> {
-        self.ranked.iter().chain(&self.filtered_out)
-    }
-
-    /// Enumerates all solutions. The index is used as solution UID.
-    pub fn enumerated(&self) -> impl Iterator<Item = (usize, &Participant<Ranked>)> {
-        self.all().enumerate()
-    }
-
-    /// All solutions that won the right to get executed.
-    pub fn winners(&self) -> impl Iterator<Item = &Participant<Ranked>> {
-        self.ranked.iter().filter(|p| p.is_winner())
-    }
-
-    /// All solutions that were not filtered out but also did not win.
-    pub fn non_winners(&self) -> impl Iterator<Item = &Participant<Ranked>> {
-        self.ranked.iter().filter(|p| !p.is_winner())
-    }
-
-    /// All solutions that passed the filtering step.
-    pub fn ranked(&self) -> impl Iterator<Item = &Participant<Ranked>> {
-        self.ranked.iter()
-    }
-}
-
-struct PartitionedSolutions {
-    kept: Vec<Participant<Unranked>>,
-    discarded: Vec<Participant<Unranked>>,
-}
-
 #[cfg(test)]
 mod tests {
     use {
@@ -469,7 +390,14 @@ mod tests {
                     Price,
                     order::{self, AppDataHash},
                 },
-                competition::{Participant, Score, Solution, TradedOrder, Unranked},
+                competition::{
+                    Participant,
+                    Score,
+                    Solution,
+                    TradedOrder,
+                    Unranked,
+                    winner_selection::Arbitrator,
+                },
                 eth::{self, TokenAddress},
             },
             infra::Driver,
@@ -1268,8 +1196,8 @@ mod tests {
         pub buy_amount: eth::U256,
     }
 
-    fn create_test_arbitrator() -> super::Arbitrator {
-        super::Arbitrator {
+    fn create_test_arbitrator() -> super::Config {
+        super::Config {
             max_winners: 10,
             weth: H160::from_slice(&hex!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")).into(),
         }