Merge pull request #7 from xdecentralix/sync/upstream-merge-20250808

Sync/upstream merge 20250808

Author: xdecentralix

crates/autopilot/src/arguments.rs

@@ -232,17 +232,9 @@ pub struct Arguments {
     #[clap(long, env, default_value = "0s", value_parser = humantime::parse_duration)]
     pub run_loop_native_price_timeout: Duration,
 
-    #[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")]
+    #[clap(long, env, default_value = "20")]
     /// 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")]
@@ -380,7 +372,6 @@ 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,
@@ -449,10 +440,6 @@ 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,8 +19,6 @@ 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.
@@ -60,33 +58,6 @@ 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()

crates/autopilot/src/database/mod.rs

@@ -1,4 +1,5 @@
 use {
+    num::ToPrimitive,
     sqlx::{Executor, PgConnection, PgPool},
     std::{num::NonZeroUsize, time::Duration},
     tracing::Instrument,
@@ -27,12 +28,34 @@ pub struct Postgres {
 
 impl Postgres {
     pub async fn new(url: &str, insert_batch_size: NonZeroUsize) -> sqlx::Result<Self> {
+        let pool = PgPool::connect(url).await?;
+
+        Self::start_db_metrics_job(pool.clone());
+
         Ok(Self {
-            pool: PgPool::connect(url).await?,
+            pool,
             config: Config { insert_batch_size },
         })
     }
 
+    fn start_db_metrics_job(pool: PgPool) {
+        tokio::spawn(async move {
+            let mut ticker = tokio::time::interval(Duration::from_secs(5));
+            loop {
+                ticker.tick().await;
+
+                let Some(idle) = pool.num_idle().to_i64() else {
+                    tracing::error!("Failed to get number of idle connections from the pool");
+                    continue;
+                };
+                let active = i64::from(pool.size()) - idle;
+
+                Metrics::get().active_connections.set(active);
+                Metrics::get().idle_connections.set(idle);
+            }
+        });
+    }
+
     pub async fn with_defaults() -> sqlx::Result<Self> {
         Self::new("postgresql://", NonZeroUsize::new(500).unwrap()).await
     }
@@ -118,6 +141,14 @@ struct Metrics {
     /// Timing of db queries.
     #[metric(name = "autopilot_database_queries", labels("type"))]
     database_queries: prometheus::HistogramVec,
+
+    /// Number of active connections in the database pool.
+    #[metric(name = "database_active_connections")]
+    active_connections: prometheus::IntGauge,
+
+    /// Number of idle connections in the database pool.
+    #[metric(name = "database_idle_connections")]
+    idle_connections: prometheus::IntGauge,
 }
 
 impl Metrics {

crates/autopilot/src/database/onchain_order_events/ethflow_events.rs

@@ -26,6 +26,7 @@ use {
     hex_literal::hex,
     sqlx::{PgPool, types::BigDecimal},
     std::{collections::HashMap, convert::TryInto},
+    tracing::instrument,
     web3::types::U64,
 };
 
@@ -160,6 +161,7 @@ async fn settlement_deployment_block_number_hash(
 /// The block from which to start indexing eth-flow events. Note that this
 /// function is expected to be used at the start of the services and will panic
 /// if it cannot retrieve the information it needs.
+#[instrument(skip_all)]
 pub async fn determine_ethflow_indexing_start(
     skip_event_sync_start: &Option<BlockNumberHash>,
     ethflow_indexing_start: Option<u64>,
@@ -201,6 +203,7 @@ pub async fn determine_ethflow_indexing_start(
 /// # Panics
 /// Note that this function is expected to be used at the start of the services
 /// and will panic  if it cannot retrieve the information it needs.
+#[instrument(skip_all)]
 pub async fn determine_ethflow_refund_indexing_start(
     skip_event_sync_start: &Option<BlockNumberHash>,
     ethflow_indexing_start: Option<u64>,

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

@@ -24,7 +24,6 @@
 //! 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,
@@ -48,7 +47,43 @@ use {
     },
 };
 
-impl Arbitrator for Config {
+/// 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.
     fn partition_unfair_solutions(
         &self,
         mut participants: Vec<Participant<Unranked>>,
@@ -99,6 +134,8 @@ impl Arbitrator for Config {
         }
     }
 
+    /// 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
@@ -114,7 +151,9 @@ impl Arbitrator for Config {
             .collect()
     }
 
-    fn compute_reference_scores(&self, ranking: &Ranking) -> HashMap<eth::Address, Score> {
+    /// 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> {
         let mut reference_scores = HashMap::default();
 
         for participant in &ranking.ranked {
@@ -150,9 +189,7 @@ impl Arbitrator for Config {
 
         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()`
@@ -312,7 +349,7 @@ fn score_by_token_pair(solution: &Solution, auction: &Auction) -> Result<ScoreBy
     Ok(scores)
 }
 
-pub struct Config {
+pub struct Arbitrator {
     pub max_winners: usize,
     pub weth: WrappedNativeToken,
 }
@@ -378,6 +415,48 @@ 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 {
@@ -390,14 +469,7 @@ mod tests {
                     Price,
                     order::{self, AppDataHash},
                 },
-                competition::{
-                    Participant,
-                    Score,
-                    Solution,
-                    TradedOrder,
-                    Unranked,
-                    winner_selection::Arbitrator,
-                },
+                competition::{Participant, Score, Solution, TradedOrder, Unranked},
                 eth::{self, TokenAddress},
             },
             infra::Driver,
@@ -1196,8 +1268,8 @@ mod tests {
         pub buy_amount: eth::U256,
     }
 
-    fn create_test_arbitrator() -> super::Config {
-        super::Config {
+    fn create_test_arbitrator() -> super::Arbitrator {
+        super::Arbitrator {
             max_winners: 10,
             weth: H160::from_slice(&hex!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")).into(),
         }