[EASY] Remove unused code (#2977)

# Description
Related to supporting multiple winners per Auction.

`get_winning_solution` was initially added to implement part of the
circuit breaker functionalities - recover winning solution during
competition, make sure the quality of proposed versus delivered solution
is respected etc. Since this functionality is not used currently,
decided to remove it until circuit breaker is implemented, which
resolves to few places less to support multiple settlements.

We can easily revert the PR from git history when needed.

Author: sunce86

crates/autopilot/src/domain/settlement/mod.rs

@@ -151,19 +151,10 @@ pub enum Error {
 pub enum InconsistentData {
     #[error("auction not found in the persistence layer")]
     AuctionNotFound,
-    #[error("proposed solution not found in the persistence layer")]
-    SolutionNotFound,
     #[error("invalid fee policy fetched from persistence layer: {0} for order: {1}")]
     InvalidFeePolicy(infra::persistence::dto::fee_policy::Error, domain::OrderUid),
     #[error("invalid fetched price from persistence layer for token: {0:?}")]
     InvalidPrice(eth::TokenAddress),
-    #[error(
-        "invalid score fetched from persistence layer for a coresponding competition solution, \
-         err: {0}"
-    )]
-    InvalidScore(anyhow::Error),
-    #[error("invalid solver competition data fetched from persistence layer: {0}")]
-    InvalidSolverCompetition(anyhow::Error),
 }
 
 impl From<infra::persistence::error::Auction> for Error {
@@ -183,24 +174,6 @@ impl From<infra::persistence::error::Auction> for Error {
     }
 }
 
-impl From<infra::persistence::error::Solution> for Error {
-    fn from(err: infra::persistence::error::Solution) -> Self {
-        match err {
-            infra::persistence::error::Solution::DatabaseError(err) => Self::Infra(err.into()),
-            infra::persistence::error::Solution::NotFound => {
-                Self::InconsistentData(InconsistentData::SolutionNotFound)
-            }
-            infra::persistence::error::Solution::InvalidScore(err) => {
-                Self::InconsistentData(InconsistentData::InvalidScore(err))
-            }
-            infra::persistence::error::Solution::InvalidSolverCompetition(err) => {
-                Self::InconsistentData(InconsistentData::InvalidSolverCompetition(err))
-            }
-            infra::persistence::error::Solution::InvalidPrice(_) => todo!(),
-        }
-    }
-}
-
 impl From<infra::persistence::DatabaseError> for Error {
     fn from(err: infra::persistence::DatabaseError) -> Self {
         Self::Infra(err.0)

crates/autopilot/src/infra/persistence/mod.rs

@@ -2,7 +2,7 @@ use {
     crate::{
         boundary,
         database::{order_events::store_order_events, Postgres},
-        domain::{self, competition, eth},
+        domain::{self, eth},
         infra::persistence::dto::AuctionId,
     },
     anyhow::Context,
@@ -26,7 +26,7 @@ use {
     },
     futures::{StreamExt, TryStreamExt},
     number::conversions::{big_decimal_to_u256, u256_to_big_decimal, u256_to_big_uint},
-    primitive_types::{H160, H256},
+    primitive_types::H256,
     shared::db_order_conversions::full_order_into_model_order,
     std::{
         collections::{HashMap, HashSet},
@@ -313,94 +313,6 @@ impl Persistence {
         })
     }
 
-    /// Returns the proposed solver solution that won the competition for a
-    /// given auction.
-    ///
-    /// It is expected for a solution to exist, so missing data is considered an
-    /// error.
-    ///
-    /// Returns error for old non-colocated auctions.
-    pub async fn get_winning_solution(
-        &self,
-        auction_id: domain::auction::Id,
-    ) -> Result<domain::competition::Solution, error::Solution> {
-        let _timer = Metrics::get()
-            .database_queries
-            .with_label_values(&["get_competition_winner"])
-            .start_timer();
-
-        let mut ex = self
-            .postgres
-            .pool
-            .begin()
-            .await
-            .map_err(error::Solution::DatabaseError)?;
-
-        let competition = database::settlement_scores::fetch(&mut ex, auction_id)
-            .await
-            .map_err(error::Solution::DatabaseError)?
-            .ok_or(error::Solution::NotFound)?;
-
-        let winner = H160(competition.winner.0).into();
-        let score = competition::Score::new(
-            big_decimal_to_u256(&competition.winning_score)
-                .ok_or(error::Solution::InvalidScore(anyhow::anyhow!(
-                    "database score"
-                )))?
-                .into(),
-        )
-        .map_err(|err| error::Solution::InvalidScore(anyhow::anyhow!("score, {}", err)))?;
-
-        let solution = {
-            // TODO: stabilize the solver competition table to get promised solution.
-            let solver_competition = database::solver_competition::load_by_id(&mut ex, auction_id)
-                .await
-                .map_err(error::Solution::DatabaseError)?
-                .ok_or(error::Solution::NotFound)?;
-            let competition: model::solver_competition::SolverCompetitionDB =
-                serde_json::from_value(solver_competition.json)
-                    .context("deserialize SolverCompetitionDB")
-                    .map_err(error::Solution::InvalidSolverCompetition)?;
-            let winning_solution = competition
-                .solutions
-                .last()
-                .ok_or(error::Solution::NotFound)?;
-            let mut orders = HashMap::new();
-            for order in winning_solution.orders.iter() {
-                match order {
-                    model::solver_competition::Order::Colocated {
-                        id,
-                        sell_amount,
-                        buy_amount,
-                    } => {
-                        orders.insert(
-                            domain::OrderUid(id.0),
-                            competition::TradedAmounts {
-                                sell: (*sell_amount).into(),
-                                buy: (*buy_amount).into(),
-                            },
-                        );
-                    }
-                    model::solver_competition::Order::Legacy {
-                        id: _,
-                        executed_amount: _,
-                    } => return Err(error::Solution::NotFound),
-                }
-            }
-            let mut prices = HashMap::new();
-            for (token, price) in winning_solution.clearing_prices.clone().into_iter() {
-                prices.insert(
-                    token.into(),
-                    domain::auction::Price::new(price.into())
-                        .map_err(|_| error::Solution::InvalidPrice(eth::TokenAddress(token)))?,
-                );
-            }
-            competition::Solution::new(winner, score, orders, prices)
-        };
-
-        Ok(solution)
-    }
-
     /// Computes solvable orders based on the latest observed block number,
     /// order creation timestamp, and minimum validity period.
     pub async fn solvable_orders_after(
@@ -746,18 +658,4 @@ pub mod error {
         #[error("invalid price fetched from database for token: {0:?}")]
         InvalidPrice(eth::TokenAddress),
     }
-
-    #[derive(Debug, thiserror::Error)]
-    pub enum Solution {
-        #[error("failed communication with the database: {0}")]
-        DatabaseError(#[from] sqlx::Error),
-        #[error("solution not found")]
-        NotFound,
-        #[error("invalid score fetched from database: {0}")]
-        InvalidScore(anyhow::Error),
-        #[error("invalid price fetched from database for token: {0:?}")]
-        InvalidPrice(eth::TokenAddress),
-        #[error("invalid solver competition data fetched from database: {0}")]
-        InvalidSolverCompetition(anyhow::Error),
-    }
 }