Update SolverEngine API docs

crates/driver/src/infra/solver/dto/notification.rs

@@ -4,7 +4,7 @@ use {
             competition::{auction, solution},
             eth,
         },
-        infra::{notify, notify::SimulationSucceededAtLeastOnce},
+        infra::notify,
         util::serialize,
     },
     serde::Serialize,
@@ -25,41 +25,39 @@ impl Notification {
             kind: match kind {
                 notify::Kind::Timeout => Kind::Timeout,
                 notify::Kind::EmptySolution => Kind::EmptySolution,
-                notify::Kind::SimulationFailed(block, tx, simulated_once) => {
-                    Kind::SimulationFailed(
-                        block.0,
-                        Tx {
+                notify::Kind::SimulationFailed(block, tx, succeeded_once) => {
+                    Kind::SimulationFailed {
+                        block: block.0,
+                        tx: Tx {
                             from: tx.from.into(),
                             to: tx.to.into(),
                             input: tx.input.into(),
                             value: tx.value.into(),
                             access_list: tx.access_list.into(),
                         },
-                        simulated_once,
-                    )
-                }
-                notify::Kind::ScoringFailed(notify::ScoreKind::ZeroScore) => {
-                    Kind::ScoringFailed(ScoreKind::ZeroScore)
+                        succeeded_once,
+                    }
                 }
+                notify::Kind::ScoringFailed(notify::ScoreKind::ZeroScore) => Kind::ZeroScore,
                 notify::Kind::ScoringFailed(notify::ScoreKind::ScoreHigherThanQuality(
                     score,
                     quality,
-                )) => Kind::ScoringFailed(ScoreKind::ScoreHigherThanQuality {
+                )) => Kind::ScoreHigherThanQuality {
                     score: score.0.get(),
                     quality: quality.0,
-                }),
+                },
                 notify::Kind::ScoringFailed(notify::ScoreKind::SuccessProbabilityOutOfRange(
                     success_probability,
-                )) => Kind::ScoringFailed(ScoreKind::SuccessProbabilityOutOfRange {
+                )) => Kind::SuccessProbabilityOutOfRange {
                     probability: success_probability,
-                }),
+                },
                 notify::Kind::ScoringFailed(notify::ScoreKind::ObjectiveValueNonPositive(
                     quality,
                     gas_cost,
-                )) => Kind::ScoringFailed(ScoreKind::ObjectiveValueNonPositive {
+                )) => Kind::ObjectiveValueNonPositive {
                     quality: quality.0,
                     gas_cost: gas_cost.get().0,
-                }),
+                },
                 notify::Kind::NonBufferableTokensUsed(tokens) => Kind::NonBufferableTokensUsed {
                     tokens: tokens.into_iter().map(|token| token.0 .0).collect(),
                 },
@@ -69,16 +67,16 @@ impl Notification {
                     }
                 }
                 notify::Kind::DuplicatedSolutionId => Kind::DuplicatedSolutionId,
-                notify::Kind::Settled(kind) => Kind::Settled(match kind {
-                    notify::Settlement::Success(hash) => Settlement::Success {
+                notify::Kind::Settled(kind) => match kind {
+                    notify::Settlement::Success(hash) => Kind::Success {
                         transaction: hash.0,
                     },
-                    notify::Settlement::Revert(hash) => Settlement::Revert {
+                    notify::Settlement::Revert(hash) => Kind::Revert {
                         transaction: hash.0,
                     },
-                    notify::Settlement::SimulationRevert => Settlement::SimulationRevert,
-                    notify::Settlement::Fail => Settlement::Fail,
-                }),
+                    notify::Settlement::SimulationRevert => Kind::Cancelled,
+                    notify::Settlement::Fail => Kind::Fail,
+                },
             },
         }
     }
@@ -95,42 +93,17 @@ pub struct Notification {
 
 #[serde_as]
 #[derive(Debug, Serialize)]
-#[serde(rename_all = "lowercase")]
+#[serde(rename_all = "lowercase", tag = "kind")]
 pub enum Kind {
     Timeout,
     EmptySolution,
     DuplicatedSolutionId,
-    SimulationFailed(BlockNo, Tx, SimulationSucceededAtLeastOnce),
-    ScoringFailed(ScoreKind),
-    NonBufferableTokensUsed {
-        tokens: BTreeSet<eth::H160>,
-    },
-    SolverAccountInsufficientBalance {
-        #[serde_as(as = "serialize::U256")]
-        required: eth::U256,
+    #[serde(rename_all = "camelCase")]
+    SimulationFailed {
+        block: BlockNo,
+        tx: Tx,
+        succeeded_once: bool,
     },
-    Settled(Settlement),
-}
-
-type BlockNo = u64;
-
-#[serde_as]
-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Tx {
-    pub from: eth::H160,
-    pub to: eth::H160,
-    #[serde_as(as = "serialize::Hex")]
-    pub input: Vec<u8>,
-    #[serde_as(as = "serialize::U256")]
-    pub value: eth::U256,
-    pub access_list: AccessList,
-}
-
-#[serde_as]
-#[derive(Debug, Serialize)]
-#[serde(rename_all = "lowercase")]
-pub enum ScoreKind {
     ZeroScore,
     ScoreHigherThanQuality {
         #[serde_as(as = "serialize::U256")]
@@ -148,14 +121,34 @@ pub enum ScoreKind {
         #[serde_as(as = "serialize::U256")]
         gas_cost: eth::U256,
     },
+    NonBufferableTokensUsed {
+        tokens: BTreeSet<eth::H160>,
+    },
+    SolverAccountInsufficientBalance {
+        #[serde_as(as = "serialize::U256")]
+        required: eth::U256,
+    },
+    Success {
+        transaction: eth::H256,
+    },
+    Revert {
+        transaction: eth::H256,
+    },
+    Cancelled,
+    Fail,
 }
 
+type BlockNo = u64;
+
 #[serde_as]
 #[derive(Debug, Serialize)]
-#[serde(rename_all = "lowercase")]
-pub enum Settlement {
-    Success { transaction: eth::H256 },
-    Revert { transaction: eth::H256 },
-    SimulationRevert,
-    Fail,
+#[serde(rename_all = "camelCase")]
+pub struct Tx {
+    pub from: eth::H160,
+    pub to: eth::H160,
+    #[serde_as(as = "serialize::Hex")]
+    pub input: Vec<u8>,
+    #[serde_as(as = "serialize::U256")]
+    pub value: eth::U256,
+    pub access_list: AccessList,
 }

crates/driver/src/infra/solver/dto/solution.rs

@@ -200,9 +200,9 @@ impl Solutions {
                         Score::Solver { score } => {
                             competition::solution::SolverScore::Solver(score)
                         }
-                        Score::RiskAdjusted(success_probability) => {
-                            competition::solution::SolverScore::RiskAdjusted(success_probability)
-                        }
+                        Score::RiskAdjusted {
+                            success_probability,
+                        } => competition::solution::SolverScore::RiskAdjusted(success_probability),
                     },
                     weth,
                 )
@@ -377,11 +377,12 @@ enum SigningScheme {
 
 #[serde_as]
 #[derive(Debug, Deserialize)]
-#[serde(rename_all = "lowercase", deny_unknown_fields)]
+#[serde(rename_all = "lowercase", deny_unknown_fields, tag = "kind")]
 pub enum Score {
     Solver {
         #[serde_as(as = "serialize::U256")]
         score: eth::U256,
     },
-    RiskAdjusted(f64),
+    #[serde(rename_all = "camelCase")]
+    RiskAdjusted { success_probability: f64 },
 }

crates/driver/src/tests/cases/score_competition.rs

@@ -12,7 +12,7 @@ async fn solver_score_winner() {
         .pool(ab_pool())
         .order(ab_order())
         .solution(ab_solution().score(Score::Solver { score: 2902421280589416499u128.into()})) // higher than objective value
-        .solution(ab_solution().score(Score::RiskAdjusted(0.4)))
+        .solution(ab_solution().score(Score::RiskAdjusted{ success_probability: 0.4}))
         .done()
         .await;
 
@@ -31,7 +31,9 @@ async fn risk_adjusted_score_winner() {
         .solution(ab_solution().score(Score::Solver {
             score: DEFAULT_SCORE_MIN.into(),
         }))
-        .solution(ab_solution().score(Score::RiskAdjusted(0.9)))
+        .solution(ab_solution().score(Score::RiskAdjusted {
+            success_probability: 0.9,
+        }))
         .done()
         .await;
 

crates/driver/src/tests/setup/mod.rs

@@ -56,18 +56,21 @@ pub enum Partial {
 
 #[serde_as]
 #[derive(Debug, Clone, serde::Serialize)]
-#[serde(rename_all = "lowercase")]
+#[serde(rename_all = "lowercase", tag = "kind")]
 pub enum Score {
     Solver {
         #[serde_as(as = "serialize::U256")]
         score: eth::U256,
     },
-    RiskAdjusted(f64),
+    #[serde(rename_all = "camelCase")]
+    RiskAdjusted { success_probability: f64 },
 }
 
 impl Default for Score {
     fn default() -> Self {
-        Self::RiskAdjusted(1.0)
+        Self::RiskAdjusted {
+            success_probability: 1.0,
+        }
     }
 }
 

crates/shared/src/http_solver/model.rs

@@ -7,7 +7,7 @@ use {
     ethcontract::{Bytes, H160},
     model::{
         auction::AuctionId,
-        order::{Interactions, OrderData, OrderUid},
+        order::{OrderData, OrderUid},
         ratio_as_decimal,
         signature::Signature,
     },
@@ -347,8 +347,6 @@ pub struct NativeLiquidityOrder {
     pub data: OrderData,
     #[serde(flatten)]
     pub signature: Signature,
-    #[serde(default)]
-    pub interactions: Interactions,
 }
 
 #[serde_as]
@@ -1166,7 +1164,6 @@ mod tests {
                         ..Default::default()
                     },
                     signature: Signature::Eip1271(vec![1, 2, 3, 4]),
-                    interactions: Default::default(),
                 },
                 exec_sell_amount: 50.into(),
                 exec_buy_amount: 51.into(),

crates/solver/src/solver/http_solver/settlement.rs

@@ -338,7 +338,7 @@ fn convert_foreign_liquidity_orders(
                 },
                 data: liquidity.order.data,
                 signature: liquidity.order.signature,
-                interactions: liquidity.order.interactions,
+                interactions: Default::default(),
             };
             let converted = order_converter.normalize_limit_order(BalancedOrder::full(order))?;
             Ok(ExecutedLimitOrder {
@@ -609,7 +609,6 @@ mod tests {
                     ..Default::default()
                 },
                 signature: Signature::PreSign,
-                interactions: Default::default(),
             },
             exec_sell_amount: 101.into(),
             exec_buy_amount: 102.into(),