Update the bids state which are not submitted to chain for an auction (#108)

Author: danimhr

auction-server/.sqlx/query-6ffd6feaa2f4f9163a37c6fe7ec414372506acd0ff572594702a491c17171cda.json renamed to auction-server/.sqlx/query-1a07b19befac7096f62aa512f2c33f6282c0565025ba9ede3325705de09ea145.json

@@ -1,6 +1,6 @@
 [package]
 name = "auction-server"
-version = "0.9.3"
+version = "0.9.4"
 edition = "2021"
 license-file = "license.txt"
 

auction-server/.sqlx/query-33f3dda525887ab92aef0d37e718b87f933cb30d568abbc87b8112e7ab30c1bf.json

@@ -0,0 +1 @@
+DROP INDEX bid_creation_time_idx;

auction-server/Cargo.lock

@@ -0,0 +1 @@
+CREATE INDEX bid_creation_time_idx ON bid (creation_time);

auction-server/Cargo.toml

@@ -323,6 +323,52 @@ async fn conclude_submitted_auctions(store: Arc<Store>, chain_id: String) {
     }
 }
 
+async fn broadcast_submitted_bids(
+    store: Arc<Store>,
+    bids: Vec<SimulatedBid>,
+    tx_hash: H256,
+    auction: models::Auction,
+) {
+    join_all(bids.iter().enumerate().map(|(i, bid)| {
+        store.broadcast_bid_status_and_update(
+            bid.to_owned(),
+            BidStatus::Submitted {
+                result: tx_hash,
+                index:  i as u32,
+            },
+            Some(&auction),
+        )
+    }))
+    .await;
+}
+
+async fn broadcast_lost_bids(
+    store: Arc<Store>,
+    bids: Vec<SimulatedBid>,
+    submitted_bids: Vec<SimulatedBid>,
+    tx_hash: Option<H256>,
+    auction: Option<&models::Auction>,
+) {
+    join_all(bids.iter().filter_map(|bid| {
+        if submitted_bids
+            .iter()
+            .any(|submitted_bid| bid.id == submitted_bid.id)
+        {
+            return None;
+        }
+
+        Some(store.broadcast_bid_status_and_update(
+            bid.clone(),
+            BidStatus::Lost {
+                result: tx_hash,
+                index:  None,
+            },
+            auction,
+        ))
+    }))
+    .await;
+}
+
 async fn submit_auction_for_bids<'a>(
     bids: Vec<SimulatedBid>,
     bid_collection_time: OffsetDateTime,
@@ -349,18 +395,7 @@ async fn submit_auction_for_bids<'a>(
     let winner_bids =
         get_winner_bids(&bids, permission_key.clone(), store.clone(), chain_store).await?;
     if winner_bids.is_empty() {
-        for bid in bids.iter() {
-            store
-                .broadcast_bid_status_and_update(
-                    bid.clone(),
-                    BidStatus::Lost {
-                        result: None,
-                        index:  None,
-                    },
-                    None,
-                )
-                .await?;
-        }
+        broadcast_lost_bids(store.clone(), bids, winner_bids, None, None).await;
         return Ok(());
     }
 
@@ -388,24 +423,21 @@ async fn submit_auction_for_bids<'a>(
         Ok(tx_hash) => {
             tracing::debug!("Submitted transaction: {:?}", tx_hash);
             auction = store.submit_auction(auction, tx_hash).await?;
-            join_all(winner_bids.iter().enumerate().map(|(i, bid)| {
-                // TODO update the status of bids to lost for those that are not going to be submitted to the chain for this auction
-                let (index, store, bid, auction) =
-                    (i as u32, store.clone(), bid.clone(), auction.clone());
-                async move {
-                    store
-                        .broadcast_bid_status_and_update(
-                            bid,
-                            BidStatus::Submitted {
-                                result: tx_hash,
-                                index,
-                            },
-                            Some(&auction),
-                        )
-                        .await
-                }
-            }))
-            .await;
+            tokio::join!(
+                broadcast_submitted_bids(
+                    store.clone(),
+                    winner_bids.clone(),
+                    tx_hash,
+                    auction.clone()
+                ),
+                broadcast_lost_bids(
+                    store.clone(),
+                    bids,
+                    winner_bids,
+                    Some(tx_hash),
+                    Some(&auction)
+                ),
+            );
         }
         Err(err) => {
             tracing::error!("Transaction failed to submit: {:?}", err);

auction-server/migrations/20240627160811_bid_creation_time_index.down.sql

@@ -747,20 +747,33 @@ impl Store {
             }
             BidStatus::Lost { result: _, index } => {
                 if let Some(auction) = auction {
-                    query_result = sqlx::query!(
-                        "UPDATE bid SET status = $1, bundle_index = $2, auction_id = $3 WHERE id = $4 AND status = 'submitted'",
-                        updated_status as _,
-                        index.map(|i| i as i32),
-                        auction.id,
-                        bid.id
-                    )
-                    .execute(&self.db)
-                    .await?;
+                    match index {
+                        Some(index) => {
+                            query_result = sqlx::query!(
+                                "UPDATE bid SET status = $1, bundle_index = $2, auction_id = $3 WHERE id = $4 AND status = 'submitted'",
+                                updated_status as _,
+                                index as i32,
+                                auction.id,
+                                bid.id
+                            )
+                            .execute(&self.db)
+                            .await?;
+                        }
+                        None => {
+                            query_result = sqlx::query!(
+                                "UPDATE bid SET status = $1, auction_id = $2 WHERE id = $3 AND status = 'pending'",
+                                updated_status as _,
+                                auction.id,
+                                bid.id
+                            )
+                            .execute(&self.db)
+                            .await?;
+                        }
+                    }
                 } else {
                     query_result = sqlx::query!(
-                        "UPDATE bid SET status = $1, bundle_index = $2 WHERE id = $3 AND status = 'pending'",
+                        "UPDATE bid SET status = $1 WHERE id = $2 AND status = 'pending'",
                         updated_status as _,
-                        index.map(|i| i as i32),
                         bid.id
                     )
                     .execute(&self.db)