Wrap orders and quotes in Arc to make clones cheap

Author: MartinquaXD

crates/autopilot/src/boundary/mod.rs

@@ -22,7 +22,12 @@ pub use {
     },
     shared::order_validation::{Amounts, is_order_outside_market_price},
 };
-use {crate::domain, ethrpc::Web3, std::collections::HashMap, url::Url};
+use {
+    crate::domain,
+    ethrpc::Web3,
+    std::{collections::HashMap, sync::Arc},
+    url::Url,
+};
 
 pub mod events;
 pub mod order;
@@ -33,8 +38,8 @@ pub fn web3_client(ethrpc: &Url, ethrpc_args: &shared::ethrpc::Arguments) -> Web
 }
 
 pub struct SolvableOrders {
-    pub orders: HashMap<domain::OrderUid, model::order::Order>,
-    pub quotes: HashMap<domain::OrderUid, domain::Quote>,
+    pub orders: HashMap<domain::OrderUid, Arc<model::order::Order>>,
+    pub quotes: HashMap<domain::OrderUid, Arc<domain::Quote>>,
     pub latest_settlement_block: u64,
     /// Used as a checkpoint - meaning at this point in time
     /// **at least** the stored orders were present in the system.

crates/autopilot/src/database/auction.rs

@@ -11,7 +11,7 @@ use {
         event_storing_helpers::{create_db_search_parameters, create_quote_row},
         order_quoting::{QuoteData, QuoteSearchParameters, QuoteStoring},
     },
-    std::{collections::HashMap, ops::DerefMut},
+    std::{collections::HashMap, ops::DerefMut, sync::Arc},
 };
 
 #[async_trait::async_trait]
@@ -75,11 +75,11 @@ impl Postgres {
         sqlx::query("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ")
             .execute(ex.deref_mut())
             .await?;
-        let orders: HashMap<domain::OrderUid, Order> =
+        let orders: HashMap<domain::OrderUid, Arc<Order>> =
             database::orders::solvable_orders(&mut ex, i64::from(min_valid_to))
                 .map(|result| match result {
                     Ok(order) => full_order_into_model_order(order)
-                        .map(|order| (domain::OrderUid(order.metadata.uid.0), order)),
+                        .map(|order| (domain::OrderUid(order.metadata.uid.0), Arc::new(order))),
                     Err(err) => Err(anyhow::Error::from(err)),
                 })
                 .try_collect()

crates/autopilot/src/database/quotes.rs

@@ -8,7 +8,7 @@ use {
     database::byte_array::ByteArray,
     shared::maintenance::Maintaining,
     sqlx::types::chrono::{DateTime, Utc},
-    std::collections::HashMap,
+    std::{collections::HashMap, sync::Arc},
 };
 
 impl Postgres {
@@ -29,7 +29,7 @@ impl Postgres {
     pub async fn read_quotes(
         &self,
         orders: impl Iterator<Item = &domain::OrderUid>,
-    ) -> Result<HashMap<domain::OrderUid, domain::Quote>, sqlx::Error> {
+    ) -> Result<HashMap<domain::OrderUid, Arc<domain::Quote>>, sqlx::Error> {
         let _timer = super::Metrics::get()
             .database_queries
             .with_label_values(&["read_quotes"])
@@ -47,7 +47,7 @@ impl Postgres {
                         tracing::warn!(?order_uid, ?err, "failed to convert quote from db")
                     })
                     .ok()
-                    .map(|quote| (order_uid, quote))
+                    .map(|quote| (order_uid, Arc::new(quote)))
             })
             .collect();
 

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

@@ -507,8 +507,11 @@ impl Persistence {
                         .iter()
                         .cloned()
                         .map(|policy| {
-                            dto::fee_policy::try_into_domain(policy, quotes.get(order))
-                                .map_err(|err| error::Auction::InvalidFeePolicy(err, *order))
+                            dto::fee_policy::try_into_domain(
+                                policy,
+                                quotes.get(order).map(|v| &**v),
+                            )
+                            .map_err(|err| error::Auction::InvalidFeePolicy(err, *order))
                         })
                         .collect::<Result<Vec<_>, _>>()?,
                     None => vec![],
@@ -541,8 +544,8 @@ impl Persistence {
     /// order creation timestamp, and minimum validity period.
     pub async fn solvable_orders_after(
         &self,
-        mut current_orders: HashMap<domain::OrderUid, model::order::Order>,
-        mut current_quotes: HashMap<domain::OrderUid, domain::Quote>,
+        mut current_orders: HashMap<domain::OrderUid, Arc<model::order::Order>>,
+        mut current_quotes: HashMap<domain::OrderUid, Arc<domain::Quote>>,
         after_timestamp: DateTime<Utc>,
         after_block: u64,
         min_valid_to: u32,
@@ -570,7 +573,7 @@ impl Persistence {
 
         // Fetch the orders that were updated after the given block and were created or
         // cancelled after the given timestamp.
-        let next_orders: HashMap<domain::OrderUid, model::order::Order> = {
+        let next_orders: HashMap<domain::OrderUid, Arc<model::order::Order>> = {
             let _timer = Metrics::get()
                 .database_queries
                 .with_label_values(&["open_orders_after"])
@@ -583,7 +586,7 @@ impl Persistence {
             )
             .map(|result| match result {
                 Ok(order) => full_order_into_model_order(order)
-                    .map(|order| (domain::OrderUid(order.metadata.uid.0), order)),
+                    .map(|order| (domain::OrderUid(order.metadata.uid.0), Arc::new(order))),
                 Err(err) => Err(anyhow::Error::from(err)),
             })
             .try_collect()
@@ -657,7 +660,7 @@ impl Persistence {
                 let order_uid = domain::OrderUid(quote.order_uid.0);
                 match dto::quote::into_domain(quote) {
                     Ok(quote) => {
-                        current_quotes.insert(order_uid, quote);
+                        current_quotes.insert(order_uid, Arc::new(quote));
                     }
                     Err(err) => tracing::warn!(?order_uid, ?err, "failed to convert quote from db"),
                 }