Rework comments

crates/driver/src/domain/competition/mod.rs

@@ -5,7 +5,7 @@ use {
         Mempools,
     },
     crate::{
-        domain::{competition::solution::Settlement, eth, Liquidity},
+        domain::{competition::solution::Settlement, eth},
         infra::{
             self,
             blockchain::Ethereum,
@@ -55,10 +55,7 @@ pub struct Competition {
 
 impl Competition {
     /// Solve an auction as part of this competition.
-    pub async fn solve(
-        &self,
-        auction: &Auction,
-    ) -> Result<(Option<Solved>, Vec<Liquidity>), Error> {
+    pub async fn solve(&self, auction: &Auction) -> Result<Option<Solved>, Error> {
         let liquidity = match self.solver.liquidity() {
             solver::Liquidity::Fetch => {
                 self.liquidity
@@ -208,7 +205,7 @@ impl Competition {
         let settlement = match settlement {
             Some(settlement) => settlement,
             // Don't wait for the deadline because we can't produce a solution anyway.
-            None => return Ok((score, liquidity)),
+            None => return Ok(score),
         };
 
         // Re-simulate the solution on every new block until the deadline ends to make
@@ -240,7 +237,7 @@ impl Competition {
             let _ = tokio::time::timeout(remaining, simulate_on_new_blocks).await;
         }
 
-        Ok((score, liquidity))
+        Ok(score)
     }
 
     pub async fn reveal(&self) -> Result<Revealed, Error> {

crates/driver/src/domain/eth/gas.rs

@@ -71,10 +71,6 @@ impl GasPrice {
             .into()
     }
 
-    pub fn base(&self) -> FeePerGas {
-        self.base
-    }
-
     pub fn max(&self) -> FeePerGas {
         self.max
     }

crates/driver/src/infra/api/mod.rs

@@ -1,4 +1,3 @@
-pub use routes::Auction;
 use {
     crate::{
         domain::{self, Mempools},

crates/driver/src/infra/api/routes/mod.rs

@@ -6,7 +6,6 @@ mod reveal;
 mod settle;
 mod solve;
 
-pub use solve::Auction;
 pub(super) use {
     healthz::healthz,
     info::info,

crates/driver/src/infra/api/routes/solve/dto/auction.rs

@@ -8,7 +8,7 @@ use {
         infra::{solver::Timeouts, tokens, Ethereum},
         util::serialize,
     },
-    serde::{Deserialize, Serialize},
+    serde::Deserialize,
     serde_with::serde_as,
 };
 
@@ -188,7 +188,7 @@ impl From<auction::Error> for Error {
 }
 
 #[serde_as]
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct Auction {
     #[serde_as(as = "serde_with::DisplayFromStr")]
@@ -205,7 +205,7 @@ impl Auction {
 }
 
 #[serde_as]
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 struct Token {
     pub address: eth::H160,
@@ -215,7 +215,7 @@ struct Token {
 }
 
 #[serde_as]
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 struct Order {
     #[serde_as(as = "serialize::Hex")]
@@ -249,15 +249,15 @@ struct Order {
     signature: Vec<u8>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 enum Kind {
     Sell,
     Buy,
 }
 
 #[serde_as]
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 struct Interaction {
     target: eth::H160,
@@ -267,7 +267,7 @@ struct Interaction {
     call_data: Vec<u8>,
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[derive(Debug, Default, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 enum SellTokenBalance {
     #[default]
@@ -276,15 +276,15 @@ enum SellTokenBalance {
     External,
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[derive(Debug, Default, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 enum BuyTokenBalance {
     #[default]
     Erc20,
     Internal,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Deserialize)]
 #[serde(rename_all = "lowercase", deny_unknown_fields)]
 enum SigningScheme {
     Eip712,
@@ -293,15 +293,15 @@ enum SigningScheme {
     Eip1271,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 enum Class {
     Market,
     Limit,
     Liquidity,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 enum FeePolicy {
     #[serde(rename_all = "camelCase")]
@@ -317,7 +317,7 @@ enum FeePolicy {
 }
 
 #[serde_as]
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct Quote {
     #[serde_as(as = "serialize::U256")]

crates/driver/src/infra/api/routes/solve/mod.rs

@@ -1,6 +1,6 @@
 mod dto;
 
-pub use dto::{Auction, AuctionError};
+pub use dto::AuctionError;
 use {
     crate::infra::{
         api::{Error, State},
@@ -23,27 +23,17 @@ async fn route(
     let handle_request = async {
         observe::auction(auction_id);
         let start = Instant::now();
-        let auction = auction.0;
-        let domain_auction = auction
-            .clone()
+        let auction = auction
+            .0
             .into_domain(state.eth(), state.tokens(), state.timeouts())
             .await
             .tap_err(|err| {
                 observe::invalid_dto(err, "auction");
             })?;
         tracing::debug!(elapsed = ?start.elapsed(), "auction task execution time");
-        let domain_auction = state.pre_processor().prioritize(domain_auction).await;
+        let auction = state.pre_processor().prioritize(auction).await;
         let competition = state.competition();
-        let result = match competition.solve(&domain_auction).await {
-            Ok((result, liquidity)) => {
-                state
-                    .solver()
-                    .persistence()
-                    .archive_auction(auction, liquidity);
-                Ok(result)
-            }
-            Err(e) => Err(e),
-        };
+        let result = competition.solve(&auction).await;
         observe::solved(state.solver().name(), &result);
         Ok(axum::Json(dto::Solved::new(result?, &competition.solver)))
     };

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

@@ -1,69 +1,10 @@
 use {
-    crate::{
-        domain::liquidity::{self},
-        infra::{api::Auction, solver::Config},
-    },
-    number::serialization::HexOrDecimalU256,
-    primitive_types::U256,
-    serde::{Deserialize, Serialize},
-    serde_with::serde_as,
+    crate::{domain::competition::auction::Id, infra::solver::Config},
+    serde::Deserialize,
     std::sync::Arc,
     tracing::Instrument,
 };
 
-#[serde_as]
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct AuctionWithLiquidity {
-    auction: Auction,
-    liquidity: Vec<Liquidity>,
-}
-
-#[serde_as]
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct Liquidity {
-    id: usize,
-    #[serde_as(as = "HexOrDecimalU256")]
-    gas: U256,
-    kind: Kind,
-}
-
-impl From<liquidity::Liquidity> for Liquidity {
-    fn from(value: liquidity::Liquidity) -> Self {
-        Self {
-            id: value.id.into(),
-            gas: value.gas.into(),
-            kind: value.kind.into(),
-        }
-    }
-}
-
-#[serde_as]
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-enum Kind {
-    UniswapV2,
-    UniswapV3,
-    BalancerV2Stable,
-    BalancerV2Weighted,
-    Swapr,
-    ZeroEx,
-}
-
-impl From<liquidity::Kind> for Kind {
-    fn from(value: liquidity::Kind) -> Self {
-        match value {
-            liquidity::Kind::UniswapV2(_) => Self::UniswapV2,
-            liquidity::Kind::UniswapV3(_) => Self::UniswapV3,
-            liquidity::Kind::BalancerV2Stable(_) => Self::BalancerV2Stable,
-            liquidity::Kind::BalancerV2Weighted(_) => Self::BalancerV2Weighted,
-            liquidity::Kind::Swapr(_) => Self::Swapr,
-            liquidity::Kind::ZeroEx(_) => Self::ZeroEx,
-        }
-    }
-}
-
 #[derive(Clone, Debug, Default, Deserialize)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct S3 {
@@ -104,21 +45,17 @@ impl Persistence {
 
     /// Saves the given auction with liquidity with fire and forget mentality
     /// (non-blocking operation)
-    pub fn archive_auction(&self, auction: Auction, liquidity: Vec<liquidity::Liquidity>) {
+    pub fn archive_auction(&self, auction_id: Option<Id>, body: &str) {
         let Some(uploader) = self.s3.clone() else {
             return;
         };
-        let auction_id = auction.id();
-        let auction_with_liquidity = AuctionWithLiquidity {
-            auction,
-            liquidity: liquidity.into_iter().map(Into::into).collect(),
+        let Some(id) = auction_id else {
+            return;
         };
+        let body = body.to_string();
         tokio::spawn(
             async move {
-                match uploader
-                    .upload(auction_id.to_string(), auction_with_liquidity)
-                    .await
-                {
+                match uploader.upload(id.to_string(), body).await {
                     Ok(key) => {
                         tracing::info!(?key, "uploaded auction to s3");
                     }

crates/driver/src/infra/solver/mod.rs

@@ -202,6 +202,7 @@ impl Solver {
             self.config.fee_handler,
         ))
         .unwrap();
+        self.persistence.archive_auction(auction.id(), &body);
         let url = shared::url::join(&self.config.endpoint, "solve");
         super::observe::solver_request(&url, &body);
         let mut req = self