Order -> Arc<Order> (#871)

## 📝 Summary

To avoid expensive clones, replaced Order with Arc<Order> in almost all
the code.
Notice that the Arc also enforces immutability, which is something good
for the Orders.


## ✅ I have completed the following steps:

* [X] Run `make lint`
* [X] Run `make test`
* [ ] Added tests (if applicable)

Author: ZanCorDX

crates/rbuilder-operator/src/clickhouse.rs

@@ -337,7 +337,7 @@ impl BidObserver for BuiltBlocksWriter {
             let mut used_bundle_hashes = Vec::new();
             let mut used_bundle_uuids = Vec::new();
             for res in &built_block_trace.included_orders {
-                if let Order::Bundle(bundle) = &res.order {
+                if let Order::Bundle(bundle) = res.order.as_ref() {
                     used_bundle_hashes
                         .push(bundle.external_hash.unwrap_or(bundle.hash).to_string());
                     used_bundle_uuids.push(bundle.uuid.to_string());

crates/rbuilder-primitives/src/lib.rs

@@ -1011,13 +1011,25 @@ impl SimValue {
 /// Order simulated (usually on top of block) + SimValue
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SimulatedOrder {
-    pub order: Order,
+    pub order: Arc<Order>,
     pub sim_value: SimValue,
     /// Info about read/write slots during the simulation to help figure out what the Order is doing.
     pub used_state_trace: Option<UsedStateTrace>,
 }
 
 impl SimulatedOrder {
+    pub fn new(
+        order: Arc<Order>,
+        sim_value: SimValue,
+        used_state_trace: Option<UsedStateTrace>,
+    ) -> Self {
+        Self {
+            order,
+            sim_value,
+            used_state_trace,
+        }
+    }
+
     pub fn id(&self) -> OrderId {
         self.order.id()
     }

crates/rbuilder/src/backtest/build_block/backtest_build_block.rs

@@ -219,7 +219,7 @@ fn print_orders_with_tx_hash(
         .iter()
         .map(|order_with_timestamp| &order_with_timestamp.order)
         .filter(|order| order.list_txs().iter().any(|(tx, _)| tx.hash() == tx_hash))
-        .for_each(print_order);
+        .for_each(|order| print_order(order));
     println!("\nSIM ORDERS:");
     sim_orders
         .iter()
@@ -241,7 +241,7 @@ fn print_order_execution_result(order_result: &ExecutionResult) {
         order_result.space_used.gas,
         format_ether(order_result.coinbase_profit),
     );
-    if let Order::Bundle(_) = order_result.order {
+    if let Order::Bundle(_) = order_result.order.as_ref() {
         for tx in order_result.tx_infos.iter().map(|info| &info.tx) {
             println!("      ↳ {:?}", tx.hash());
         }

crates/rbuilder/src/backtest/build_block/synthetic_orders.rs

@@ -5,6 +5,7 @@ use rbuilder_primitives::{
     Bundle, MempoolTx, Metadata, Order, TransactionSignedEcRecoveredWithBlobs, LAST_BUNDLE_VERSION,
 };
 use reth_provider::test_utils::MockNodeTypesWithDB;
+use std::sync::Arc;
 use uuid::Uuid;
 
 use super::backtest_build_block::{run_backtest_build_block, BuildBlockCfg, OrdersSource};
@@ -75,7 +76,7 @@ impl<ConfigType: LiveBuilderConfig> SyntheticOrdersSource<ConfigType> {
             )));
             orders.push(OrdersWithTimestamp {
                 timestamp_ms: 0,
-                order,
+                order: Arc::new(order),
             });
         }
 
@@ -106,7 +107,7 @@ impl<ConfigType: LiveBuilderConfig> SyntheticOrdersSource<ConfigType> {
             bundle.hash_slow();
             orders.push(OrdersWithTimestamp {
                 timestamp_ms: 0,
-                order: Order::Bundle(bundle),
+                order: Arc::new(Order::Bundle(bundle)),
             });
         }
 

crates/rbuilder/src/backtest/execute.rs

@@ -10,7 +10,7 @@ use crate::{
 };
 use alloy_eips::BlockNumHash;
 use alloy_primitives::U256;
-use rbuilder_primitives::{OrderId, SimulatedOrder};
+use rbuilder_primitives::{Order, OrderId, SimulatedOrder};
 use reth_chainspec::ChainSpec;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
@@ -95,10 +95,10 @@ pub fn backtest_prepare_orders_from_building_context<P>(
 where
     P: StateProviderFactory + Clone + 'static,
 {
-    let orders = available_orders
+    let orders: Vec<Arc<Order>> = available_orders
         .iter()
-        .map(|order| order.order.clone())
-        .collect::<Vec<_>>();
+        .map(|order| Arc::clone(&order.order))
+        .collect();
     for order in &orders {
         ctx.mempool_tx_detector.add_tx(order);
     }

crates/rbuilder/src/backtest/fetch/data_source.rs

@@ -7,6 +7,7 @@ use crate::{
 };
 use alloy_primitives::B256;
 use async_trait::async_trait;
+use std::sync::Arc;
 
 #[derive(Debug, Clone)]
 pub struct DatasourceData {
@@ -45,7 +46,7 @@ pub async fn get_full_slot_data_from_data(
             .into_iter()
             .map(|o| ReplaceableOrderPoolCommandWithTimestamp {
                 timestamp_ms: o.timestamp_ms,
-                command: ReplaceableOrderPoolCommand::Order(o.order),
+                command: ReplaceableOrderPoolCommand::Order(Arc::clone(&o.order)),
             })
             .collect(),
         built_block_data: data.built_block_data,

crates/rbuilder/src/backtest/fetch/mempool.rs

@@ -14,6 +14,7 @@ use rbuilder_primitives::{
     Order,
 };
 use sqlx::types::chrono::DateTime;
+use std::sync::Arc;
 use std::{
     fs::create_dir_all,
     path::{Path, PathBuf},
@@ -52,7 +53,7 @@ pub fn get_mempool_transactions(
 
             Some(OrdersWithTimestamp {
                 timestamp_ms,
-                order,
+                order: Arc::new(order),
             })
         })
         .collect())

crates/rbuilder/src/backtest/full_slot_block_data.rs

@@ -29,7 +29,7 @@ impl From<OrdersWithTimestamp> for ReplaceableOrderPoolCommandWithTimestamp {
     fn from(order: OrdersWithTimestamp) -> Self {
         ReplaceableOrderPoolCommandWithTimestamp {
             timestamp_ms: order.timestamp_ms,
-            command: ReplaceableOrderPoolCommand::Order(order.order),
+            command: ReplaceableOrderPoolCommand::Order(Arc::clone(&order.order)),
         }
     }
 }
@@ -116,7 +116,7 @@ impl FullSlotBlockData {
                         if included_orders_ids.remove(&order.id()) {
                             Some(OrdersWithTimestamp {
                                 timestamp_ms: command_ts.timestamp_ms,
-                                order: order.clone(),
+                                order: Arc::clone(order),
                             })
                         } else {
                             None
@@ -167,7 +167,7 @@ impl FullSlotBlockData {
             match command_ts.command {
                 ReplaceableOrderPoolCommand::Order(order) => {
                     order_id_to_timestamp.insert(order.id(), command_ts.timestamp_ms);
-                    order_manager.insert_order(order);
+                    order_manager.insert_order(Arc::clone(&order));
                 }
                 ReplaceableOrderPoolCommand::CancelBundle(replacement_data) => {
                     order_manager.remove_bundle(replacement_data);
@@ -181,7 +181,7 @@ impl FullSlotBlockData {
             .iter()
             .map(|o| OrdersWithTimestamp {
                 timestamp_ms: *order_id_to_timestamp.get(&o.id()).unwrap(),
-                order: o.clone(),
+                order: Arc::clone(o),
             })
             .collect();
 

crates/rbuilder/src/backtest/mod.rs

@@ -12,6 +12,7 @@ mod store;
 use ahash::HashMap;
 pub use backtest_build_range::run_backtest_build_range;
 use std::collections::HashSet;
+use std::sync::Arc;
 
 use crate::{mev_boost::BuilderBlockReceived, utils::offset_datetime_to_timestamp_ms};
 use alloy_consensus::Transaction as TransactionTrait;
@@ -38,15 +39,15 @@ impl From<OrdersWithTimestamp> for RawOrdersWithTimestamp {
     fn from(orders: OrdersWithTimestamp) -> Self {
         Self {
             timestamp_ms: orders.timestamp_ms,
-            order: orders.order.into(),
+            order: (*orders.order).clone().into(),
         }
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct OrdersWithTimestamp {
     pub timestamp_ms: u64,
-    pub order: Order,
+    pub order: Arc<Order>,
 }
 
 /// Historic data for a block.
@@ -171,7 +172,7 @@ impl BlockData {
         let mempool_txs = self
             .available_orders
             .iter()
-            .filter_map(|o| match &o.order {
+            .filter_map(|o| match o.order.as_ref() {
                 Order::Tx(tx) => Some(tx.tx_with_blobs.hash()),
                 _ => None,
             })

crates/rbuilder/src/backtest/redistribute/mod.rs

@@ -312,7 +312,7 @@ where
     let mut txs = 0;
     let mut bundles = 0;
     for ts_order in &block_data.available_orders {
-        match &ts_order.order {
+        match ts_order.order.as_ref() {
             Order::Bundle(_) => bundles += 1,
             Order::Tx(_) => txs += 1,
         }
@@ -449,7 +449,7 @@ struct AvailableOrders {
     included_orders_by_address: Vec<(Address, Vec<OrderId>)>,
     all_orders_by_address: HashMap<Address, Vec<OrderId>>,
     orders_id_to_address: HashMap<OrderId, Address>,
-    all_orders_by_id: HashMap<OrderId, Order>,
+    all_orders_by_id: HashMap<OrderId, Arc<Order>>,
     bundle_hash_by_id: HashMap<OrderId, B256>,
     order_sender_by_id: HashMap<OrderId, Address>,
 }
@@ -550,7 +550,7 @@ fn split_orders_by_identities(
 
     for order in &block_data.available_orders {
         let id = order.order.id();
-        if let Order::Bundle(bundle) = &order.order {
+        if let Order::Bundle(bundle) = order.order.as_ref() {
             bundle_hash_by_id.insert(id, bundle.external_hash.unwrap_or(bundle.hash));
         };
         order_sender_by_id.insert(id, order_sender(&order.order));
@@ -603,7 +603,7 @@ fn split_orders_by_identities(
         all_orders_by_id: block_data
             .available_orders
             .iter()
-            .map(|order| (order.order.id(), order.order.clone()))
+            .map(|order| (order.order.id(), Arc::clone(&order.order)))
             .collect(),
         bundle_hash_by_id,
         order_sender_by_id,