fix: convert auctions in InMemoryStore to DashMap

auction-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "auction-server"
-version = "0.34.2"
+version = "0.34.3"
 edition = "2021"
 license-file = "license.txt"
 
@@ -63,6 +63,7 @@ tokio-metrics = { version = "0.4.2", features = ["rt"] }
 clickhouse = { version = "0.13.2", features = ["time", "uuid", "native-tls", "inserter"] }
 sha2 = "0.10.9"
 tokio-tungstenite = { workspace = true, features = ["native-tls"] }
+dashmap = "6.1.0"
 
 [dev-dependencies]
 mockall = "0.13.1"

auction-server/src/auction/repository/add_auction.rs

@@ -6,11 +6,7 @@ use {
 impl Repository {
     #[tracing::instrument(skip_all)]
     async fn add_in_memory_auction(&self, auction: entities::Auction) {
-        self.in_memory_store
-            .auctions
-            .write()
-            .await
-            .insert(auction.id, auction);
+        self.in_memory_store.auctions.insert(auction.id, auction);
     }
 
     // NOTE: Do not call this function directly. Instead call `add_auction` from `Service`.

auction-server/src/auction/repository/conclude_auction.rs

@@ -10,7 +10,7 @@ impl Repository {
     pub async fn conclude_auction(&self, auction_id: entities::AuctionId) -> anyhow::Result<()> {
         tracing::Span::current().record("auction_id", auction_id.to_string());
         self.db.conclude_auction(auction_id).await?;
-        self.remove_in_memory_auction(auction_id).await;
+        self.remove_in_memory_auction(auction_id);
         Ok(())
     }
 }

auction-server/src/auction/repository/get_in_memory_auction_by_bid_id.rs

@@ -4,12 +4,11 @@ use {
 };
 
 impl Repository {
-    pub async fn get_in_memory_auction_bid_by_bid_id(
+    pub fn get_in_memory_auction_bid_by_bid_id(
         &self,
         bid_id: entities::BidId,
     ) -> Option<entities::Bid> {
         self.get_in_memory_auctions()
-            .await
             .into_iter()
             .find_map(|auction| auction.bids.iter().find(|bid| bid.id == bid_id).cloned())
     }

auction-server/src/auction/repository/get_in_memory_auction_by_id.rs

@@ -4,15 +4,13 @@ use {
 };
 
 impl Repository {
-    pub async fn get_in_memory_auction_by_id(
+    pub fn get_in_memory_auction_by_id(
         &self,
         auction_id: entities::AuctionId,
     ) -> Option<entities::Auction> {
         self.in_memory_store
             .auctions
-            .read()
-            .await
             .get(&auction_id)
-            .cloned()
+            .map(|auction_ref| auction_ref.clone())
     }
 }

auction-server/src/auction/repository/get_in_memory_auctions.rs

@@ -4,13 +4,11 @@ use {
 };
 
 impl Repository {
-    pub async fn get_in_memory_auctions(&self) -> Vec<entities::Auction> {
+    pub fn get_in_memory_auctions(&self) -> Vec<entities::Auction> {
         self.in_memory_store
             .auctions
-            .read()
-            .await
-            .values()
-            .cloned()
+            .iter()
+            .map(|entry| entry.value().clone())
             .collect()
     }
 }

auction-server/src/auction/repository/mod.rs

@@ -5,6 +5,7 @@ use {
         entities::ChainId,
     },
     axum_prometheus::metrics,
+    dashmap::DashMap,
     solana_sdk::pubkey::Pubkey,
     std::collections::{
         HashMap,
@@ -66,7 +67,7 @@ pub struct ChainStoreEvm {}
 #[derive(Debug)]
 pub struct InMemoryStore {
     pub pending_bids: RwLock<HashMap<PermissionKeySvm, Vec<entities::Bid>>>,
-    pub auctions:     RwLock<HashMap<entities::AuctionId, entities::Auction>>,
+    pub auctions:     DashMap<entities::AuctionId, entities::Auction>,
 
     pub auction_lock: Mutex<HashMap<PermissionKeySvm, entities::AuctionLock>>,
     pub bid_lock:     Mutex<HashMap<entities::BidId, entities::BidLock>>,
@@ -78,7 +79,7 @@ impl Default for InMemoryStore {
     fn default() -> Self {
         Self {
             pending_bids: RwLock::new(HashMap::new()),
-            auctions:     RwLock::new(HashMap::new()),
+            auctions:     DashMap::new(),
             auction_lock: Mutex::new(HashMap::new()),
             bid_lock:     Mutex::new(HashMap::new()),
             chain_store:  ChainStoreSvm::default(),
@@ -110,7 +111,7 @@ impl Repository {
     pub(super) async fn update_metrics(&self) {
         let label = [("chain_id", self.chain_id.to_string())];
         let store = &self.in_memory_store;
-        metrics::gauge!("in_memory_auctions", &label).set(store.auctions.read().await.len() as f64);
+        metrics::gauge!("in_memory_auctions", &label).set(store.auctions.len() as f64);
         metrics::gauge!("in_memory_pending_bids", &label)
             .set(store.pending_bids.read().await.len() as f64);
         metrics::gauge!("in_memory_auction_locks", &label)

auction-server/src/auction/repository/remove_in_memory_auction.rs

@@ -5,12 +5,8 @@ use {
 
 impl Repository {
     #[tracing::instrument(skip_all, fields(auction_id))]
-    pub async fn remove_in_memory_auction(&self, auction_id: entities::AuctionId) {
+    pub fn remove_in_memory_auction(&self, auction_id: entities::AuctionId) {
         tracing::Span::current().record("auction_id", auction_id.to_string());
-        self.in_memory_store
-            .auctions
-            .write()
-            .await
-            .remove(&auction_id);
+        self.in_memory_store.auctions.remove(&auction_id);
     }
 }

auction-server/src/auction/repository/update_bid_status.rs

@@ -10,14 +10,14 @@ use {
 impl Repository {
     // Find the in memory auction which contains the bid and update the bid status
     #[tracing::instrument(skip_all)]
-    async fn update_in_memory_auction_bid(
+    fn update_in_memory_auction_bid(
         &self,
         bid: &entities::Bid,
         new_status: entities::BidStatusSvm,
     ) {
         if let Some(auction_id) = new_status.get_auction_id() {
-            let mut write_guard = self.in_memory_store.auctions.write().await;
-            if let Some(auction) = write_guard.get_mut(&auction_id) {
+            if let Some(mut auction_ref) = self.in_memory_store.auctions.get_mut(&auction_id) {
+                let auction = auction_ref.value_mut();
                 let bid_index = auction.bids.iter().position(|b| b.id == bid.id);
                 if let Some(index) = bid_index {
                     auction.bids[index].status = new_status;
@@ -36,7 +36,7 @@ impl Repository {
             self.db.update_bid_status(&bid, &new_status).await?;
         if is_updated && !new_status.is_pending() {
             self.remove_in_memory_pending_bids(&[bid.clone()]).await;
-            self.update_in_memory_auction_bid(&bid, new_status).await;
+            self.update_in_memory_auction_bid(&bid, new_status);
         }
         Ok((is_updated, conclusion_time_new))
     }

auction-server/src/auction/repository/update_in_memory_auction.rs

@@ -7,9 +7,8 @@ impl Repository {
     #[tracing::instrument(skip_all, fields(auction_id))]
     pub async fn update_in_memory_auction(&self, auction: entities::Auction) {
         tracing::Span::current().record("auction_id", auction.id.to_string());
-        let mut write_guard = self.in_memory_store.auctions.write().await;
-        match write_guard.get_mut(&auction.id) {
-            Some(a) => {
+        match self.in_memory_store.auctions.get_mut(&auction.id) {
+            Some(mut a) => {
                 *a = auction;
             }
             None => {

auction-server/src/auction/service/cancel_bid.rs

@@ -27,7 +27,6 @@ impl Service {
         let bid = self
             .repo
             .get_in_memory_auction_bid_by_bid_id(input.bid_id)
-            .await
             .ok_or(RestError::BadParameters(
                 "Bid is only cancellable in awaiting_signature state".to_string(),
             ))?;

auction-server/src/auction/service/conclude_auction.rs

@@ -41,11 +41,7 @@ impl Service {
         .await;
 
         // Refetch the auction from the in-memory store to check if all bids are finalized
-        if let Some(auction) = self
-            .repo
-            .get_in_memory_auction_by_id(input.auction.id)
-            .await
-        {
+        if let Some(auction) = self.repo.get_in_memory_auction_by_id(input.auction.id) {
             if auction.bids.iter().all(|bid| bid.status.is_concluded()) {
                 self.repo
                     .conclude_auction(auction.id)
@@ -122,7 +118,7 @@ impl Service {
         let mut interval = Self::get_conclusion_interval();
         loop {
             interval.tick().await;
-            if let Some(auction) = self.repo.get_in_memory_auction_by_id(auction_id).await {
+            if let Some(auction) = self.repo.get_in_memory_auction_by_id(auction_id) {
                 if let Err(e) = self
                     .conclude_auction(ConcludeAuctionInput { auction })
                     .await

auction-server/src/auction/service/get_auction_by_id.rs

@@ -8,9 +8,7 @@ pub struct GetAuctionByIdInput {
 }
 
 impl Service {
-    pub async fn get_auction_by_id(&self, input: GetAuctionByIdInput) -> Option<entities::Auction> {
-        self.repo
-            .get_in_memory_auction_by_id(input.auction_id)
-            .await
+    pub fn get_auction_by_id(&self, input: GetAuctionByIdInput) -> Option<entities::Auction> {
+        self.repo.get_in_memory_auction_by_id(input.auction_id)
     }
 }

auction-server/src/auction/service/submit_quote.rs

@@ -34,13 +34,12 @@ const MIN_DEADLINE_BUFFER_SECS: i64 = 2;
 
 impl Service {
     #[tracing::instrument(skip_all)]
-    async fn get_winner_bid_for_submission(
+    fn get_winner_bid_for_submission(
         &self,
         auction_id: entities::AuctionId,
     ) -> Result<(entities::Auction, entities::Bid), RestError> {
         let auction: entities::Auction = self
             .get_auction_by_id(GetAuctionByIdInput { auction_id })
-            .await
             .ok_or(RestError::BadParameters("Quote not found. The provided reference ID may be invalid, already finalized on-chain, or canceled.".to_string()))?;
 
         let winner_bid = auction
@@ -66,7 +65,7 @@ impl Service {
         let mut bid = bid;
         self.add_relayer_signature(&mut bid);
         let auction = self.get_auction_by_id(GetAuctionByIdInput {auction_id: auction.id,
-        }).await.ok_or_else(|| {
+        }).ok_or_else(|| {
             tracing::error!(auction_id = %auction.id, "Auction not found when getting most recent version");
             RestError::TemporarilyUnavailable
         })?;
@@ -95,7 +94,8 @@ impl Service {
         let _lock = lock.lock().await;
 
         // Make sure the bid is still not cancelled, we also get the latest saved version of the auction
-        let (auction, bid_latest_version) = self.get_winner_bid_for_submission(auction.id).await?;
+        // TODO: we probably don't need to get the auction and bid again, can probably use the one we have from the call to get_winner_bid_for_submission in submit_quote
+        let (auction, bid_latest_version) = self.get_winner_bid_for_submission(auction.id)?;
         if bid_latest_version.status.is_submitted() {
             return Ok(());
         }
@@ -200,7 +200,7 @@ impl Service {
         &self,
         input: SubmitQuoteInput,
     ) -> Result<VersionedTransaction, RestError> {
-        let (auction, winner_bid) = self.get_winner_bid_for_submission(input.auction_id).await?;
+        let (auction, winner_bid) = self.get_winner_bid_for_submission(input.auction_id)?;
 
         let mut bid = winner_bid.clone();
         tracing::Span::current().record("bid_id", bid.id.to_string());

auction-server/src/auction/service/workers.rs

@@ -141,7 +141,7 @@ impl Service {
                                 self.task_tracker.spawn({
                                     let service = self.clone();
                                     async move {
-                                        let in_memory_auctions = service.repo.get_in_memory_auctions().await;
+                                        let in_memory_auctions = service.repo.get_in_memory_auctions();
                                         let auctions = in_memory_auctions.iter().filter(|auction| {
                                             auction.bids.iter().any(|bid| {
                                                 bid.chain_data.transaction.signatures[0] == signature