Merge branch 'main' into jemalloc-profiling-support

Author: squadgazzz

crates/autopilot/src/database/onchain_order_events/mod.rs

@@ -499,9 +499,11 @@ where
                     gas_amount: quote.data.fee_parameters.gas_amount,
                     gas_price: quote.data.fee_parameters.gas_price,
                     sell_token_price: quote.data.fee_parameters.sell_token_price,
-                    sell_amount: u256_to_big_decimal(&quote.sell_amount),
-                    buy_amount: u256_to_big_decimal(&quote.buy_amount),
-                    solver: ByteArray(quote.data.solver.0),
+                    sell_amount: number::conversions::alloy::u256_to_big_decimal(
+                        &quote.sell_amount,
+                    ),
+                    buy_amount: number::conversions::alloy::u256_to_big_decimal(&quote.buy_amount),
+                    solver: ByteArray(*quote.data.solver.0),
                     verified: quote.data.verified,
                     metadata: quote.data.metadata.try_into()?,
                 }),
@@ -550,11 +552,11 @@ async fn get_quote(
     .map_err(|_| OnchainOrderPlacementError::Other)?;
 
     let parameters = QuoteSearchParameters {
-        sell_token: order_data.sell_token.into_legacy(),
-        buy_token: order_data.buy_token.into_legacy(),
-        sell_amount: order_data.sell_amount.into_legacy(),
-        buy_amount: order_data.buy_amount.into_legacy(),
-        fee_amount: order_data.fee_amount.into_legacy(),
+        sell_token: order_data.sell_token,
+        buy_token: order_data.buy_token,
+        sell_amount: order_data.sell_amount,
+        buy_amount: order_data.buy_amount,
+        fee_amount: order_data.fee_amount,
         kind: order_data.kind,
         signing_scheme: quote_signing_scheme,
         additional_gas: 0,
@@ -598,9 +600,9 @@ fn convert_onchain_order_placement(
     // executed fast (we don't want to reserve the user's ETH for too long)
     if quote.as_ref().is_ok_and(|quote| {
         !order_data.within_market(QuoteAmounts {
-            sell: quote.sell_amount,
-            buy: quote.buy_amount,
-            fee: quote.fee_amount,
+            sell: quote.sell_amount.into_legacy(),
+            buy: quote.buy_amount.into_legacy(),
+            fee: quote.fee_amount.into_legacy(),
         })
     }) {
         tracing::debug!(%order_uid, ?owner, "order is outside market price");
@@ -1091,8 +1093,8 @@ mod test {
         };
         let settlement_contract = H160::from([8u8; 20]);
         let quote = Quote {
-            sell_amount: sell_amount.into_legacy(),
-            buy_amount: (buy_amount / U256::from(2)).into_legacy(),
+            sell_amount,
+            buy_amount: buy_amount / U256::from(2),
             ..Default::default()
         };
         let order_uid = OrderUid([9u8; 56]);
@@ -1212,23 +1214,20 @@ mod test {
         let quote = Quote {
             id: Some(0i64),
             data: QuoteData {
-                sell_token: sell_token.into_legacy(),
-                buy_token: buy_token.into_legacy(),
-                quoted_sell_amount: sell_amount
-                    .checked_sub(U256::from(1))
-                    .unwrap()
-                    .into_legacy(),
-                quoted_buy_amount: buy_amount.checked_sub(U256::from(1)).unwrap().into_legacy(),
+                sell_token,
+                buy_token,
+                quoted_sell_amount: sell_amount.checked_sub(U256::from(1)).unwrap(),
+                quoted_buy_amount: buy_amount.checked_sub(U256::from(1)).unwrap(),
                 fee_parameters: FeeParameters {
                     gas_amount: 2.0f64,
                     gas_price: 3.0f64,
                     sell_token_price: 4.0f64,
                 },
                 ..Default::default()
             },
-            sell_amount: sell_amount.into_legacy(),
-            buy_amount: buy_amount.into_legacy(),
-            fee_amount: fee_amount.into_legacy(),
+            sell_amount,
+            buy_amount,
+            fee_amount,
         };
         let cloned_quote = quote.clone();
         order_quoter
@@ -1304,9 +1303,9 @@ mod test {
             gas_amount: quote.data.fee_parameters.gas_amount,
             gas_price: quote.data.fee_parameters.gas_price,
             sell_token_price: quote.data.fee_parameters.sell_token_price,
-            sell_amount: u256_to_big_decimal(&quote.sell_amount),
-            buy_amount: u256_to_big_decimal(&quote.buy_amount),
-            solver: ByteArray(quote.data.solver.0),
+            sell_amount: number::conversions::alloy::u256_to_big_decimal(&quote.sell_amount),
+            buy_amount: number::conversions::alloy::u256_to_big_decimal(&quote.buy_amount),
+            solver: ByteArray(*quote.data.solver.0),
             verified: quote.data.verified,
             metadata: quote.data.metadata.try_into().unwrap(),
         };

crates/autopilot/src/domain/quote/mod.rs

@@ -2,6 +2,7 @@ use {
     super::OrderUid,
     crate::{boundary::Amounts, domain::eth},
     alloy::primitives::Address,
+    ethrpc::alloy::conversions::IntoAlloy,
 };
 
 #[derive(Clone, Debug, PartialEq)]
@@ -16,9 +17,9 @@ pub struct Quote {
 impl From<&Quote> for Amounts {
     fn from(quote: &Quote) -> Self {
         Self {
-            sell: quote.sell_amount.into(),
-            buy: quote.buy_amount.into(),
-            fee: quote.fee.into(),
+            sell: quote.sell_amount.0.into_alloy(),
+            buy: quote.buy_amount.0.into_alloy(),
+            fee: quote.fee.0.into_alloy(),
         }
     }
 }

crates/autopilot/src/run_loop.rs

@@ -29,7 +29,10 @@ use {
     ::observe::metrics,
     anyhow::{Context, Result},
     database::order_events::OrderEventLabel,
-    ethrpc::{alloy::conversions::IntoLegacy, block_stream::BlockInfo},
+    ethrpc::{
+        alloy::conversions::{IntoAlloy, IntoLegacy},
+        block_stream::BlockInfo,
+    },
     futures::{FutureExt, TryFutureExt},
     itertools::Itertools,
     model::solver_competition::{
@@ -468,7 +471,7 @@ impl RunLoop {
             .enumerated()
             .map(|(index, participant)| SolverSettlement {
                 solver: participant.driver().name.clone(),
-                solver_address: participant.solution().solver().0,
+                solver_address: participant.solution().solver().0.into_alloy(),
                 score: Some(Score::Solver(participant.solution().score().get().0)),
                 ranking: index + 1,
                 orders: participant
@@ -477,15 +480,15 @@ impl RunLoop {
                     .iter()
                     .map(|(id, order)| Order::Colocated {
                         id: (*id).into(),
-                        sell_amount: order.executed_sell.into(),
-                        buy_amount: order.executed_buy.into(),
+                        sell_amount: order.executed_sell.0.into_alloy(),
+                        buy_amount: order.executed_buy.0.into_alloy(),
                     })
                     .collect(),
                 clearing_prices: participant
                     .solution()
                     .prices()
                     .iter()
-                    .map(|(token, price)| (token.0, price.get().into()))
+                    .map(|(token, price)| (token.0.into_alloy(), price.get().0.into_alloy()))
                     .collect(),
                 is_winner: participant.is_winner(),
                 filtered_out: participant.filtered_out(),
@@ -507,7 +510,7 @@ impl RunLoop {
                 prices: auction
                     .prices
                     .iter()
-                    .map(|(key, value)| ((*key).into(), value.get().into()))
+                    .map(|(key, value)| (key.0.into_alloy(), value.get().0.into_alloy()))
                     .collect(),
             },
             solutions,

crates/cow-amm/src/maintainers.rs

@@ -2,7 +2,10 @@ use {
     crate::{Amm, cache::Storage},
     contracts::alloy::ERC20,
     ethrpc::Web3,
-    futures::future::{join_all, select_ok},
+    futures::{
+        future::{join_all, select_ok},
+        stream::{FuturesUnordered, StreamExt},
+    },
     shared::maintenance::Maintaining,
     std::sync::Arc,
     tokio::sync::RwLock,
@@ -55,13 +58,20 @@ impl Maintaining for EmptyPoolRemoval {
                 amms_to_check.extend(storage.cow_amms().await);
             }
         }
-        let futures = amms_to_check.iter().map(|amm| async {
-            self.has_zero_balance(amm.clone())
-                .await
-                .then_some(*amm.address())
-        });
 
-        let empty_amms: Vec<_> = join_all(futures).await.into_iter().flatten().collect();
+        let empty_amms: Vec<_> = amms_to_check
+            .iter()
+            .map(|amm| {
+                let amm = amm.clone();
+                async move {
+                    let address = *amm.address();
+                    self.has_zero_balance(amm).await.then_some(address)
+                }
+            })
+            .collect::<FuturesUnordered<_>>()
+            .filter_map(std::future::ready)
+            .collect()
+            .await;
         if !empty_amms.is_empty() {
             tracing::debug!(amms = ?empty_amms, "removing AMMs with zero token balance");
             let lock = self.storage.read().await;

crates/driver/src/domain/competition/pre_processing.rs

@@ -60,7 +60,7 @@ pub struct Utilities {
     liquidity_fetcher: infra::liquidity::Fetcher,
     tokens: tokens::Fetcher,
     balance_fetcher: Arc<dyn BalanceFetching>,
-    cow_amm_cache: cow_amm::Cache,
+    cow_amm_cache: Option<cow_amm::Cache>,
 }
 
 impl std::fmt::Debug for Utilities {
@@ -390,12 +390,16 @@ impl Utilities {
     }
 
     async fn cow_amm_orders(self: Arc<Self>, auction: Arc<Auction>) -> Arc<Vec<Order>> {
+        let Some(ref cow_amm_cache) = self.cow_amm_cache else {
+            // CoW AMMs are not configured, return empty vec
+            return Default::default();
+        };
+
         let _timer = metrics::get().processing_stage_timer("cow_amm_orders");
         let _timer2 =
             observe::metrics::metrics().on_auction_overhead_start("driver", "cow_amm_orders");
 
-        let cow_amms = self
-            .cow_amm_cache
+        let cow_amms = cow_amm_cache
             .get_or_create_amms(&auction.surplus_capturing_jit_order_owners)
             .await;
 

crates/driver/src/domain/cow_amm.rs

@@ -24,7 +24,11 @@ pub struct Cache {
 }
 
 impl Cache {
-    pub fn new(web3: DynProvider, factory_mapping: HashMap<Address, Address>) -> Self {
+    pub fn new(web3: DynProvider, factory_mapping: HashMap<Address, Address>) -> Option<Self> {
+        if factory_mapping.is_empty() {
+            return None;
+        }
+
         let helper_by_factory = factory_mapping
             .into_iter()
             .map(|(factory, helper)| {
@@ -34,11 +38,11 @@ impl Cache {
                 )
             })
             .collect();
-        Self {
+        Some(Self {
             inner: RwLock::new(HashMap::new()),
             web3: web3.clone(),
             helper_by_factory,
-        }
+        })
     }
 
     /// Gets or creates AMM instances for the given surplus capturing JIT order

crates/e2e/tests/e2e/quote_verification.rs

@@ -175,9 +175,9 @@ async fn test_bypass_verification_for_rfq_quotes(web3: Web3) {
                         in_amount: NonZeroU256::new(12.into()).unwrap(),
                     },
                     &Verification {
-                        from: H160::from_str("0x73688c2b34bf6c09c125fed02fe92d17a94b897a").unwrap(),
+                        from: H160::from_str("0x73688c2b34bf6c09c125fed02fe92d17a94b897a").unwrap().into_alloy(),
                         receiver: H160::from_str("0x73688c2b34bf6c09c125fed02fe92d17a94b897a")
-                            .unwrap(),
+                            .unwrap().into_alloy(),
                         pre_interactions: vec![],
                         post_interactions: vec![],
                         sell_token_source: SellTokenSource::Erc20,

crates/model/src/order.rs

@@ -9,7 +9,7 @@ use {
         quote::QuoteId,
         signature::{self, EcdsaSignature, EcdsaSigningScheme, Signature},
     },
-    alloy::primitives::{Address, U512},
+    alloy::primitives::{Address, B256, U512},
     anyhow::{Result, anyhow},
     app_data::{AppDataHash, hash_full_app_data},
     bigdecimal::BigDecimal,
@@ -647,7 +647,7 @@ pub struct CancellationPayload {
 #[serde(rename_all = "camelCase")]
 pub struct EthflowData {
     pub user_valid_to: i64,
-    pub refund_tx_hash: Option<H256>,
+    pub refund_tx_hash: Option<B256>,
 }
 
 // We still want to have the `is_refunded` field in the JSON response to stay
@@ -663,7 +663,7 @@ impl ::serde::Serialize for EthflowData {
         #[serde(rename_all = "camelCase")]
         struct Extended {
             user_valid_to: i64,
-            refund_tx_hash: Option<H256>,
+            refund_tx_hash: Option<B256>,
             is_refunded: bool,
         }
 

crates/model/src/solver_competition.rs

@@ -1,8 +1,8 @@
 use {
     crate::{AuctionId, order::OrderUid},
-    alloy::primitives::B256,
+    alloy::primitives::{Address, B256},
     number::serialization::HexOrDecimalU256,
-    primitive_types::{H160, U256},
+    primitive_types::U256,
     serde::{Deserialize, Serialize},
     serde_with::serde_as,
     std::collections::BTreeMap,
@@ -36,7 +36,7 @@ pub struct SolverCompetitionAPI {
 pub struct CompetitionAuction {
     pub orders: Vec<OrderUid>,
     #[serde_as(as = "BTreeMap<_, HexOrDecimalU256>")]
-    pub prices: BTreeMap<H160, U256>,
+    pub prices: BTreeMap<Address, alloy::primitives::U256>,
 }
 
 #[serde_as]
@@ -45,13 +45,13 @@ pub struct CompetitionAuction {
 pub struct SolverSettlement {
     pub solver: String,
     #[serde(default)]
-    pub solver_address: H160,
+    pub solver_address: Address,
     #[serde(flatten)]
     pub score: Option<Score>,
     #[serde(default)]
     pub ranking: usize,
     #[serde_as(as = "BTreeMap<_, HexOrDecimalU256>")]
-    pub clearing_prices: BTreeMap<H160, U256>,
+    pub clearing_prices: BTreeMap<Address, alloy::primitives::U256>,
     pub orders: Vec<Order>,
     #[serde(default)]
     pub is_winner: bool,
@@ -106,16 +106,16 @@ pub enum Order {
         id: OrderUid,
         /// The effective amount that left the user's wallet including all fees.
         #[serde_as(as = "HexOrDecimalU256")]
-        sell_amount: U256,
+        sell_amount: alloy::primitives::U256,
         /// The effective amount the user received after all fees.
         #[serde_as(as = "HexOrDecimalU256")]
-        buy_amount: U256,
+        buy_amount: alloy::primitives::U256,
     },
     #[serde(rename_all = "camelCase")]
     Legacy {
         id: OrderUid,
         #[serde_as(as = "HexOrDecimalU256")]
-        executed_amount: U256,
+        executed_amount: alloy::primitives::U256,
     },
 }
 
@@ -189,28 +189,28 @@ mod tests {
                         OrderUid([0x33; 56]),
                     ],
                     prices: btreemap! {
-                        H160([0x11; 20]) => 1000.into(),
-                        H160([0x22; 20]) => 2000.into(),
-                        H160([0x33; 20]) => 3000.into(),
+                        Address::repeat_byte(0x11) => alloy::primitives::U256::from(1000),
+                        Address::repeat_byte(0x22) => alloy::primitives::U256::from(2000),
+                        Address::repeat_byte(0x33) => alloy::primitives::U256::from(3000),
                     },
                 },
                 solutions: vec![SolverSettlement {
                     solver: "2".to_string(),
-                    solver_address: H160([0x22; 20]),
+                    solver_address: Address::repeat_byte(0x22),
                     score: Some(Score::Solver(1.into())),
                     ranking: 1,
                     clearing_prices: btreemap! {
-                        H160([0x22; 20]) => 8.into(),
+                        Address::repeat_byte(0x22) => alloy::primitives::U256::from(8),
                     },
                     orders: vec![
                         Order::Colocated {
                             id: OrderUid([0x33; 56]),
-                            sell_amount: 12.into(),
-                            buy_amount: 13.into(),
+                            sell_amount: alloy::primitives::U256::from(12),
+                            buy_amount: alloy::primitives::U256::from(13),
                         },
                         Order::Legacy {
                             id: OrderUid([0x44; 56]),
-                            executed_amount: 14.into(),
+                            executed_amount: alloy::primitives::U256::from(14),
                         },
                     ],
                     is_winner: true,