[POC] Winner selection crate

Cargo.toml

@@ -95,6 +95,7 @@ solver = { path = "crates/solver" }
 solvers = { path = "crates/solvers" }
 solvers-dto = { path = "crates/solvers-dto" }
 testlib = { path = "crates/testlib" }
+winner-selection = { path = "crates/winner-selection" }
 time = "0.3.37"
 tiny-keccak = "2.0.2"
 tower = "0.4"

crates/autopilot/Cargo.toml

@@ -65,6 +65,7 @@ tower-http = { workspace = true, features = ["trace"] }
 tracing = { workspace = true }
 url = { workspace = true }
 web3 = { workspace = true }
+winner-selection = { workspace = true }
 
 [dev-dependencies]
 mockall = { workspace = true }

crates/autopilot/src/domain/competition/participant.rs

@@ -1,37 +1,31 @@
+pub use state::{RankType, Unscored};
 use {
     super::Score,
     crate::{domain::competition::Solution, infra},
+    ::winner_selection::state,
     std::sync::Arc,
 };
 
+pub type Scored = state::Scored<Score>;
+pub type Ranked = state::Ranked<Score>;
+
+/// A solver's solution paired with the driver, progressing through the winner
+/// selection process.
+///
+/// It uses the type-state pattern to enforce correct state
+/// transitions at compile time. The state parameter tracks progression through
+/// three phases:
+///
+/// 1. **Unscored**: Initial state when the solution is received from the driver
+/// 2. **Scored**: After computing surplus and fees for the solution
+/// 3. **Ranked**: After winner selection determines if this is a winner
 #[derive(Clone)]
 pub struct Participant<State = Ranked> {
     solution: Solution,
     driver: Arc<infra::Driver>,
     state: State,
 }
 
-#[derive(Clone)]
-pub struct Unscored;
-
-#[derive(Clone)]
-pub struct Scored {
-    pub(super) score: Score,
-}
-
-#[derive(Clone)]
-pub struct Ranked {
-    pub(super) rank_type: RankType,
-    pub(super) score: Score,
-}
-
-#[derive(Clone)]
-pub enum RankType {
-    Winner,
-    NonWinner,
-    FilteredOut,
-}
-
 impl<T> Participant<T> {
     pub fn solution(&self) -> &Solution {
         &self.solution
@@ -42,51 +36,29 @@ impl<T> Participant<T> {
     }
 }
 
-impl Participant<Unscored> {
-    pub fn new(solution: Solution, driver: Arc<infra::Driver>) -> Self {
-        Self {
-            solution,
-            driver,
-            state: Unscored,
-        }
-    }
+impl<State> state::HasState for Participant<State> {
+    type Next<NewState> = Participant<NewState>;
+    type State = State;
 
-    pub fn with_score(self, score: Score) -> Participant<Scored> {
+    fn with_state<NewState>(self, state: NewState) -> Self::Next<NewState> {
         Participant {
             solution: self.solution,
             driver: self.driver,
-            state: Scored { score },
+            state,
         }
     }
-}
 
-impl Participant<Scored> {
-    pub fn score(&self) -> Score {
-        self.state.score
-    }
-
-    pub fn with_rank(self, rank_type: RankType) -> Participant<Ranked> {
-        Participant {
-            solution: self.solution,
-            driver: self.driver,
-            state: Ranked {
-                rank_type,
-                score: self.state.score,
-            },
-        }
+    fn state(&self) -> &Self::State {
+        &self.state
     }
 }
 
-impl Participant<Ranked> {
-    pub fn score(&self) -> Score {
-        self.state.score
-    }
-
-    pub fn is_winner(&self) -> bool {
-        matches!(self.state.rank_type, RankType::Winner)
-    }
-
-    pub fn filtered_out(&self) -> bool {
-        matches!(self.state.rank_type, RankType::FilteredOut)
+impl Participant<Unscored> {
+    pub fn new(solution: Solution, driver: Arc<infra::Driver>) -> Self {
+        Self {
+            solution,
+            driver,
+            state: Unscored,
+        }
     }
 }