[EASY] Remove Observation object

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

@@ -2,7 +2,7 @@
 
 use {
     crate::domain::{self},
-    std::collections::HashMap,
+    std::collections::{HashMap, HashSet},
 };
 
 #[derive(Debug)]
@@ -15,7 +15,7 @@ pub struct Auction {
     pub prices: domain::auction::Prices,
     /// JIT orders with surplus capturing JIT order owners should capture
     /// surplus if settled.
-    pub surplus_capturing_jit_order_owners: Vec<domain::eth::Address>,
+    pub surplus_capturing_jit_order_owners: HashSet<domain::eth::Address>,
 }
 
 impl Auction {

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

@@ -3,20 +3,14 @@
 //! A winning solution becomes a [`Settlement`] once it is executed on-chain.
 
 use {
-    super::competition,
     crate::{domain, domain::eth, infra},
+    std::collections::HashMap,
 };
 
 mod auction;
-mod observation;
 mod solution;
 mod transaction;
-pub use {
-    auction::Auction,
-    observation::Observation,
-    solution::Solution,
-    transaction::Transaction,
-};
+pub use {auction::Auction, solution::Solution, transaction::Transaction};
 
 /// A solution together with the `Auction` for which it was picked as a winner
 /// and executed on-chain.
@@ -80,13 +74,6 @@ impl Settlement {
                 score,
             );
         }
-        if score < promised_solution.score() {
-            return Err(Error::ScoreMismatch {
-                expected: promised_solution.score(),
-                got: score,
-            })
-            .map_err(with(auction_id));
-        }
 
         Ok(Self {
             solution,
@@ -95,15 +82,30 @@ impl Settlement {
         })
     }
 
-    /// Returns the observation of the settlement.
-    pub fn observation(&self) -> Observation {
-        Observation {
-            gas: self.transaction.gas,
-            gas_price: self.transaction.effective_gas_price,
-            surplus: self.solution.native_surplus(&self.auction),
-            fee: self.solution.native_fee(&self.auction.prices),
-            order_fees: self.solution.fees(&self.auction.prices),
-        }
+    /// The gas used by the settlement.
+    pub fn gas(&self) -> eth::Gas {
+        self.transaction.gas
+    }
+
+    /// The effective gas price at the time of settlement.
+    pub fn gas_price(&self) -> eth::EffectiveGasPrice {
+        self.transaction.effective_gas_price
+    }
+
+    /// Total surplus expressed in native token.
+    pub fn native_surplus(&self) -> eth::Ether {
+        self.solution.native_surplus(&self.auction)
+    }
+
+    /// Total fee expressed in native token.
+    pub fn native_fee(&self) -> eth::Ether {
+        self.solution.native_fee(&self.auction.prices)
+    }
+
+    /// Per order fees denominated in sell token. Contains all orders from the
+    /// settlement
+    pub fn order_fees(&self) -> HashMap<domain::OrderUid, Option<eth::SellTokenAmount>> {
+        self.solution.fees(&self.auction.prices)
     }
 }
 
@@ -131,11 +133,6 @@ pub enum Error {
         expected: eth::Address,
         got: eth::Address,
     },
-    #[error("score mismatch: expected competition score {expected}, settlement score {got}")]
-    ScoreMismatch {
-        expected: competition::Score,
-        got: competition::Score,
-    },
 }
 
 /// Errors that can occur when fetching data from the persistence layer.

crates/autopilot/src/on_settlement_event_updater.rs

@@ -194,49 +194,47 @@ impl Inner {
                 }
                 (Ok(settlement), Some(auction_data)) => {
                     // staging settlement properly built
-                    let observation = settlement.observation();
-                    if observation.surplus.0 != auction_data.surplus {
+                    let surplus = settlement.native_surplus();
+                    if surplus.0 != auction_data.surplus {
                         tracing::warn!(
                             ?auction_id,
-                            ?observation.surplus,
+                            ?surplus,
                             ?auction_data.surplus,
                             "automatic check error: surplus mismatch"
                         );
                     }
-                    if observation.fee.0 != auction_data.fee {
+                    let fee = settlement.native_fee();
+                    if fee.0 != auction_data.fee {
                         tracing::warn!(
                             ?auction_id,
-                            ?observation.fee,
+                            ?fee,
                             ?auction_data.fee,
                             "automatic check error: fee mismatch"
                         );
                     }
-                    if observation.order_fees.len() != auction_data.order_executions.len() {
+                    let order_fees = settlement.order_fees();
+                    if order_fees.len() != auction_data.order_executions.len() {
                         tracing::warn!(
                             ?auction_id,
-                            ?observation.order_fees,
+                            ?order_fees,
                             ?auction_data.order_executions,
                             "automatic check error: order_fees mismatch"
                         );
                     }
                     for fee in auction_data.order_executions {
-                        if !observation
-                            .order_fees
-                            .contains_key(&domain::OrderUid(fee.0 .0))
-                        {
+                        if !order_fees.contains_key(&domain::OrderUid(fee.0 .0)) {
                             tracing::warn!(
                                 ?auction_id,
                                 ?fee,
-                                ?observation.order_fees,
+                                ?order_fees,
                                 "automatic check error: order_fees missing"
                             );
                         } else {
-                            let observation_fee =
-                                observation.order_fees[&domain::OrderUid(fee.0 .0)];
-                            if observation_fee.unwrap_or_default().0 != fee.1 {
+                            let settlement_fee = order_fees[&domain::OrderUid(fee.0 .0)];
+                            if settlement_fee.unwrap_or_default().0 != fee.1 {
                                 tracing::warn!(
                                     ?auction_id,
-                                    ?observation_fee,
+                                    ?settlement_fee,
                                     ?fee,
                                     "automatic check error: order_fees value mismatch"
                                 );