New database tables for auction and solver competition

crates/autopilot/src/database/competition.rs

@@ -47,9 +47,13 @@ impl super::Postgres {
 
         let mut ex = self.pool.begin().await.context("begin")?;
 
-        database::solver_competition::save(&mut ex, competition.auction_id, json)
-            .await
-            .context("solver_competition::save")?;
+        database::solver_competition::save_solver_competition(
+            &mut ex,
+            competition.auction_id,
+            json,
+        )
+        .await
+        .context("solver_competition::save_solver_competition")?;
 
         database::settlement_scores::insert(
             &mut ex,

crates/autopilot/src/infra/persistence/dto/order.rs

@@ -359,3 +359,12 @@ impl From<FeePolicy> for domain::fee::Policy {
         }
     }
 }
+
+impl From<domain::auction::order::Side> for database::orders::OrderKind {
+    fn from(side: domain::auction::order::Side) -> Self {
+        match side {
+            domain::auction::order::Side::Buy => Self::Buy,
+            domain::auction::order::Side::Sell => Self::Sell,
+        }
+    }
+}

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

@@ -19,6 +19,7 @@ use {
             SigningScheme as DbSigningScheme,
         },
         settlement_observations::Observation,
+        solver_competition::{Order, Solution},
     },
     domain::auction::order::{
         BuyTokenDestination as DomainBuyTokenDestination,
@@ -127,6 +128,70 @@ impl Persistence {
             .map_err(DatabaseError)
     }
 
+    /// Save all valid solutions that participated in the competition for an
+    /// auction.
+    pub async fn save_solutions(
+        &self,
+        auction_id: domain::auction::Id,
+        solutions: &[domain::competition::Participant],
+    ) -> Result<(), DatabaseError> {
+        let _timer = Metrics::get()
+            .database_queries
+            .with_label_values(&["save_solutions"])
+            .start_timer();
+
+        let mut ex = self.postgres.pool.begin().await?;
+
+        database::solver_competition::save(
+            &mut ex,
+            auction_id,
+            &solutions
+                .iter()
+                .enumerate()
+                .map(|(uid, participant)| {
+                    let solution = Solution {
+                        uid: uid.try_into().context("uid overflow")?,
+                        id: i64::try_from(participant.solution().id()).context("block overflow")?,
+                        solver: ByteArray(participant.solution().solver().0 .0),
+                        is_winner: participant.is_winner(),
+                        score: u256_to_big_decimal(&participant.solution().score().get().0),
+                        orders: participant
+                            .solution()
+                            .orders()
+                            .iter()
+                            .map(|(order_uid, order)| Order {
+                                uid: ByteArray(order_uid.0),
+                                sell_token: ByteArray(order.sell.token.0 .0),
+                                buy_token: ByteArray(order.buy.token.0 .0),
+                                limit_sell: u256_to_big_decimal(&order.sell.amount.0),
+                                limit_buy: u256_to_big_decimal(&order.buy.amount.0),
+                                executed_sell: u256_to_big_decimal(&order.executed_sell.0),
+                                executed_buy: u256_to_big_decimal(&order.executed_buy.0),
+                                side: order.side.into(),
+                            })
+                            .collect(),
+                        price_tokens: participant
+                            .solution()
+                            .prices()
+                            .keys()
+                            .map(|token| ByteArray(token.0 .0))
+                            .collect(),
+                        price_values: participant
+                            .solution()
+                            .prices()
+                            .values()
+                            .map(|price| u256_to_big_decimal(&price.get().0))
+                            .collect(),
+                    };
+                    Ok::<_, DatabaseError>(solution)
+                })
+                .collect::<Result<Vec<_>, DatabaseError>>()?,
+        )
+        .await?;
+
+        Ok(ex.commit().await?)
+    }
+
     /// Saves the surplus capturing jit order owners to the DB
     pub async fn save_surplus_capturing_jit_order_owners(
         &self,
@@ -227,6 +292,52 @@ impl Persistence {
         Ok(database::settlements::already_processed(&mut ex, auction_id).await?)
     }
 
+    /// Save auction related data to the database.
+    pub async fn save_auction(
+        &self,
+        auction: &domain::Auction,
+        deadline: u64, // to become part of the auction struct
+    ) -> Result<(), DatabaseError> {
+        let _timer = Metrics::get()
+            .database_queries
+            .with_label_values(&["save_auction"])
+            .start_timer();
+
+        let mut ex = self.postgres.pool.begin().await?;
+
+        database::auction::save(
+            &mut ex,
+            database::auction::Auction {
+                id: auction.id,
+                block: i64::try_from(auction.block).context("block overflow")?,
+                deadline: i64::try_from(deadline).context("deadline overflow")?,
+                order_uids: auction
+                    .orders
+                    .iter()
+                    .map(|order| ByteArray(order.uid.0))
+                    .collect(),
+                price_tokens: auction
+                    .prices
+                    .keys()
+                    .map(|token| ByteArray(token.0 .0))
+                    .collect(),
+                price_values: auction
+                    .prices
+                    .values()
+                    .map(|price| u256_to_big_decimal(&price.get().0))
+                    .collect(),
+                surplus_capturing_jit_order_owners: auction
+                    .surplus_capturing_jit_order_owners
+                    .iter()
+                    .map(|owner| ByteArray(owner.0 .0))
+                    .collect(),
+            },
+        )
+        .await?;
+
+        Ok(ex.commit().await?)
+    }
+
     /// Get auction data.
     pub async fn get_auction(
         &self,
@@ -655,14 +766,7 @@ impl Persistence {
                                     valid_to: i64::from(jit_order.valid_to),
                                     app_data: ByteArray(jit_order.app_data.0),
                                     fee_amount: u256_to_big_decimal(&jit_order.fee_amount.0),
-                                    kind: match jit_order.side {
-                                        domain::auction::order::Side::Buy => {
-                                            database::orders::OrderKind::Buy
-                                        }
-                                        domain::auction::order::Side::Sell => {
-                                            database::orders::OrderKind::Sell
-                                        }
-                                    },
+                                    kind: jit_order.side.into(),
                                     partially_fillable: jit_order.partially_fillable,
                                     signature: jit_order.signature.to_bytes(),
                                     receiver: ByteArray(jit_order.receiver.0 .0),

crates/autopilot/src/run_loop.rs

@@ -494,6 +494,19 @@ impl RunLoop {
             competition_table,
         };
 
+        if let Err(err) = futures::try_join!(
+            self.persistence
+                .save_auction(auction, block_deadline)
+                .map_err(|e| e.0.context("failed to save auction")),
+            self.persistence
+                .save_solutions(auction.id, solutions)
+                .map_err(|e| e.0.context("failed to save solutions")),
+        ) {
+            // Don't error if saving of auction and solution fails, until stable.
+            // Various edge cases with JIT orders verifiable only in production.
+            tracing::warn!(?err, "failed to save new competition data");
+        }
+
         tracing::trace!(?competition, "saving competition");
         futures::try_join!(
             self.persistence

crates/database/src/auction.rs

@@ -1,4 +1,8 @@
-use sqlx::{types::JsonValue, PgConnection};
+use {
+    crate::{Address, OrderUid},
+    bigdecimal::BigDecimal,
+    sqlx::{types::JsonValue, PgConnection},
+};
 
 pub type AuctionId = i64;
 
@@ -31,9 +35,46 @@ RETURNING id;
     Ok(id)
 }
 
+#[derive(Debug, Clone, PartialEq, sqlx::FromRow)]
+pub struct Auction {
+    pub id: AuctionId,
+    pub block: i64,
+    pub deadline: i64,
+    pub order_uids: Vec<OrderUid>,
+    // External native prices
+    pub price_tokens: Vec<Address>,
+    pub price_values: Vec<BigDecimal>,
+    pub surplus_capturing_jit_order_owners: Vec<Address>,
+}
+
+pub async fn save(ex: &mut PgConnection, auction: Auction) -> Result<(), sqlx::Error> {
+    const QUERY: &str = r#"
+INSERT INTO competition_auctions (id, block, deadline, order_uids, price_tokens, price_values, surplus_capturing_jit_order_owners)
+VALUES ($1, $2, $3, $4, $5, $6, $7)
+    ;"#;
+
+    sqlx::query(QUERY)
+        .bind(auction.id)
+        .bind(auction.block)
+        .bind(auction.deadline)
+        .bind(auction.order_uids)
+        .bind(auction.price_tokens)
+        .bind(auction.price_values)
+        .bind(auction.surplus_capturing_jit_order_owners)
+        .execute(ex)
+        .await?;
+
+    Ok(())
+}
+
+pub async fn fetch(ex: &mut PgConnection, id: AuctionId) -> Result<Option<Auction>, sqlx::Error> {
+    const QUERY: &str = r#"SELECT * FROM competition_auctions WHERE id = $1;"#;
+    sqlx::query_as(QUERY).bind(id).fetch_optional(ex).await
+}
+
 #[cfg(test)]
 mod tests {
-    use {super::*, sqlx::Connection};
+    use {super::*, crate::byte_array::ByteArray, sqlx::Connection};
 
     #[tokio::test]
     #[ignore]
@@ -54,5 +95,20 @@ mod tests {
         let (id, value_) = load_most_recent(&mut db).await.unwrap().unwrap();
         assert_eq!(value, value_);
         assert_eq!(id_, id);
+
+        // let's assume the second auction contains a valid competition data so it's
+        // meaningful to save it into `competition_auctions` table as well
+        let auction = Auction {
+            id: id_,
+            block: 1,
+            deadline: 2,
+            order_uids: vec![ByteArray([1u8; 56])],
+            price_tokens: vec![ByteArray([1u8; 20])],
+            price_values: vec![BigDecimal::from(1)],
+            surplus_capturing_jit_order_owners: vec![ByteArray([1u8; 20])],
+        };
+        save(&mut db, auction.clone()).await.unwrap();
+        let auction_ = fetch(&mut db, id_).await.unwrap().unwrap();
+        assert_eq!(auction, auction_);
     }
 }

crates/database/src/lib.rs

@@ -58,6 +58,7 @@ pub const TABLES: &[&str] = &[
     "order_quotes",
     "solver_competitions",
     "auctions",
+    "competition_auctions",
     "onchain_placed_orders",
     "ethflow_orders",
     "order_execution",