Migrate price_estimation::Query to alloy

crates/alerter/src/lib.rs

@@ -92,7 +92,7 @@ impl OrderBookApi {
 // untouched.
 fn convert_eth_to_weth(token: Address) -> Address {
     const WETH: Address = address!("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2");
-    if token == Address::from_slice(&BUY_ETH_ADDRESS.0) {
+    if token.as_slice() == BUY_ETH_ADDRESS.as_bytes() {
         WETH
     } else {
         token

crates/shared/src/order_quoting.rs

@@ -17,6 +17,7 @@ use {
     chrono::{DateTime, Duration, Utc},
     database::quotes::{Quote as QuoteRow, QuoteKind},
     ethcontract::{H160, U256},
+    ethrpc::alloy::conversions::IntoAlloy,
     futures::TryFutureExt,
     gas_estimation::GasPriceEstimating,
     model::{
@@ -66,8 +67,8 @@ impl QuoteParameters {
 
         price_estimation::Query {
             verification: self.verification.clone(),
-            sell_token: self.sell_token,
-            buy_token: self.buy_token,
+            sell_token: self.sell_token.into_alloy(),
+            buy_token: self.buy_token.into_alloy(),
             in_amount,
             kind,
             block_dependent: true,
@@ -859,8 +860,8 @@ mod tests {
                         from: H160([3; 20]),
                         ..Default::default()
                     },
-                    sell_token: H160([1; 20]),
-                    buy_token: H160([2; 20]),
+                    sell_token: Address::new([1; 20]),
+                    buy_token: Address::new([2; 20]),
                     in_amount: NonZeroU256::try_from(100).unwrap(),
                     kind: OrderKind::Sell,
                     block_dependent: true,
@@ -1000,8 +1001,8 @@ mod tests {
                         from: H160([3; 20]),
                         ..Default::default()
                     },
-                    sell_token: H160([1; 20]),
-                    buy_token: H160([2; 20]),
+                    sell_token: Address::new([1; 20]),
+                    buy_token: Address::new([2; 20]),
                     in_amount: NonZeroU256::try_from(100).unwrap(),
                     kind: OrderKind::Sell,
                     block_dependent: true,
@@ -1136,8 +1137,8 @@ mod tests {
                         from: H160([3; 20]),
                         ..Default::default()
                     },
-                    sell_token: H160([1; 20]),
-                    buy_token: H160([2; 20]),
+                    sell_token: Address::new([1; 20]),
+                    buy_token: Address::new([2; 20]),
                     in_amount: NonZeroU256::try_from(42).unwrap(),
                     kind: OrderKind::Buy,
                     block_dependent: true,

crates/shared/src/order_validation.rs

@@ -187,9 +187,10 @@ impl From<CalculateQuoteError> for ValidationError {
             CalculateQuoteError::Price {
                 source: PriceEstimationError::UnsupportedToken { token, reason },
                 ..
-            } => {
-                ValidationError::Partial(PartialValidationError::UnsupportedToken { token, reason })
-            }
+            } => ValidationError::Partial(PartialValidationError::UnsupportedToken {
+                token: token.into_legacy(),
+                reason,
+            }),
             CalculateQuoteError::Price {
                 source: PriceEstimationError::ProtocolInternal(err),
                 ..
@@ -488,7 +489,7 @@ impl OrderValidating for OrderValidator {
         if has_same_buy_and_sell_token(&order, self.native_token.address()) {
             return Err(PartialValidationError::SameBuyAndSellToken);
         }
-        if order.sell_token == BUY_ETH_ADDRESS {
+        if order.sell_token.into_alloy() == BUY_ETH_ADDRESS.into_alloy() {
             return Err(PartialValidationError::InvalidNativeSellToken);
         }
 
@@ -857,7 +858,8 @@ pub enum OrderValidToError {
 /// This also checks for orders selling wrapped native token for native token.
 fn has_same_buy_and_sell_token(order: &PreOrderData, native_token: &Address) -> bool {
     order.sell_token == order.buy_token
-        || (order.sell_token == native_token.into_legacy() && order.buy_token == BUY_ETH_ADDRESS)
+        || (order.sell_token == native_token.into_legacy()
+            && order.buy_token.into_alloy() == BUY_ETH_ADDRESS.into_alloy())
 }
 
 /// Retrieves the quote for an order that is being created and verify that its

crates/shared/src/price_estimation/competition/mod.rs

@@ -248,11 +248,11 @@ mod tests {
             PriceEstimating,
             Query,
         },
+        alloy::primitives::Address,
         anyhow::anyhow,
         futures::channel::oneshot::channel,
         model::order::OrderKind,
         number::nonzero::U256 as NonZeroU256,
-        primitive_types::H160,
         std::time::Duration,
         tokio::time::sleep,
     };
@@ -262,44 +262,44 @@ mod tests {
         let queries = [
             Arc::new(Query {
                 verification: Default::default(),
-                sell_token: H160::from_low_u64_le(0),
-                buy_token: H160::from_low_u64_le(1),
+                sell_token: Address::with_last_byte(0),
+                buy_token: Address::with_last_byte(1),
                 in_amount: NonZeroU256::try_from(1).unwrap(),
                 kind: OrderKind::Buy,
                 block_dependent: false,
                 timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             }),
             Arc::new(Query {
                 verification: Default::default(),
-                sell_token: H160::from_low_u64_le(2),
-                buy_token: H160::from_low_u64_le(3),
+                sell_token: Address::with_last_byte(2),
+                buy_token: Address::with_last_byte(3),
                 in_amount: NonZeroU256::try_from(1).unwrap(),
                 kind: OrderKind::Sell,
                 block_dependent: false,
                 timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             }),
             Arc::new(Query {
                 verification: Default::default(),
-                sell_token: H160::from_low_u64_le(2),
-                buy_token: H160::from_low_u64_le(3),
+                sell_token: Address::with_last_byte(2),
+                buy_token: Address::with_last_byte(3),
                 in_amount: NonZeroU256::try_from(1).unwrap(),
                 kind: OrderKind::Buy,
                 block_dependent: false,
                 timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             }),
             Arc::new(Query {
                 verification: Default::default(),
-                sell_token: H160::from_low_u64_le(3),
-                buy_token: H160::from_low_u64_le(4),
+                sell_token: Address::with_last_byte(3),
+                buy_token: Address::with_last_byte(4),
                 in_amount: NonZeroU256::try_from(1).unwrap(),
                 kind: OrderKind::Buy,
                 block_dependent: false,
                 timeout: HEALTHY_PRICE_ESTIMATION_TIME,
             }),
             Arc::new(Query {
                 verification: Default::default(),
-                sell_token: H160::from_low_u64_le(5),
-                buy_token: H160::from_low_u64_le(6),
+                sell_token: Address::with_last_byte(5),
+                buy_token: Address::with_last_byte(6),
                 in_amount: NonZeroU256::try_from(1).unwrap(),
                 kind: OrderKind::Buy,
                 block_dependent: false,
@@ -344,7 +344,7 @@ mod tests {
             Ok(estimates[1].clone()),
             Err(PriceEstimationError::ProtocolInternal(anyhow!("b"))),
             Err(PriceEstimationError::UnsupportedToken {
-                token: H160([0; 20]),
+                token: Address::new([0; 20]),
                 reason: "".to_string(),
             }),
         ]);
@@ -388,8 +388,8 @@ mod tests {
     async fn racing_estimator_returns_early() {
         let query = Arc::new(Query {
             verification: Default::default(),
-            sell_token: H160::from_low_u64_le(0),
-            buy_token: H160::from_low_u64_le(1),
+            sell_token: Address::with_last_byte(0),
+            buy_token: Address::with_last_byte(1),
             in_amount: NonZeroU256::try_from(1).unwrap(),
             kind: OrderKind::Buy,
             block_dependent: false,
@@ -449,8 +449,8 @@ mod tests {
     async fn queries_stages_sequentially() {
         let query = Arc::new(Query {
             verification: Default::default(),
-            sell_token: H160::from_low_u64_le(0),
-            buy_token: H160::from_low_u64_le(1),
+            sell_token: Address::with_last_byte(0),
+            buy_token: Address::with_last_byte(1),
             in_amount: NonZeroU256::try_from(1).unwrap(),
             kind: OrderKind::Sell,
             block_dependent: false,
@@ -526,8 +526,8 @@ mod tests {
     async fn combines_stages_if_threshold_bigger_than_next_stage_length() {
         let query = Arc::new(Query {
             verification: Default::default(),
-            sell_token: H160::from_low_u64_le(0),
-            buy_token: H160::from_low_u64_le(1),
+            sell_token: Address::with_last_byte(0),
+            buy_token: Address::with_last_byte(1),
             in_amount: NonZeroU256::try_from(1).unwrap(),
             kind: OrderKind::Sell,
             block_dependent: false,

crates/shared/src/price_estimation/competition/quote.rs

@@ -9,6 +9,7 @@ use {
         QuoteVerificationMode,
     },
     anyhow::Context,
+    ethrpc::alloy::conversions::IntoLegacy,
     futures::future::{BoxFuture, FutureExt, TryFutureExt},
     model::order::OrderKind,
     primitive_types::{H160, U256},
@@ -26,7 +27,9 @@ impl PriceEstimating for CompetitionEstimator<Arc<dyn PriceEstimating>> {
                 OrderKind::Buy => query.sell_token,
                 OrderKind::Sell => query.buy_token,
             };
-            let get_context = self.ranking.provide_context(out_token, query.timeout);
+            let get_context = self
+                .ranking
+                .provide_context(out_token.into_legacy(), query.timeout);
 
             // Filter out 0 gas cost estimate because they are obviously wrong and would
             // likely win the price competition which would lead to us paying huge

crates/shared/src/price_estimation/factory.rs

@@ -30,7 +30,10 @@ use {
     anyhow::{Context as _, Result},
     contracts::alloy::WETH9,
     ethcontract::H160,
-    ethrpc::{alloy::conversions::IntoLegacy, block_stream::CurrentBlockWatcher},
+    ethrpc::{
+        alloy::conversions::{IntoAlloy, IntoLegacy},
+        block_stream::CurrentBlockWatcher,
+    },
     gas_estimation::GasPriceEstimating,
     number::nonzero::U256 as NonZeroU256,
     rate_limit::RateLimiter,
@@ -299,7 +302,7 @@ impl<'a> PriceEstimatorFactory<'a> {
     fn sanitized(&self, estimator: Arc<dyn PriceEstimating>) -> SanitizedPriceEstimator {
         SanitizedPriceEstimator::new(
             estimator,
-            self.network.native_token,
+            self.network.native_token.into_alloy(),
             self.components.bad_token_detector.clone(),
         )
     }

crates/shared/src/price_estimation/instrumented.rs

@@ -129,8 +129,8 @@ mod tests {
             MockPriceEstimating,
             PriceEstimationError,
         },
+        alloy::primitives::Address,
         anyhow::anyhow,
-        ethcontract::H160,
         model::order::OrderKind,
         number::nonzero::U256 as NonZeroU256,
     };
@@ -139,8 +139,8 @@ mod tests {
     async fn records_metrics_for_each_query() {
         let query = Arc::new(Query {
             verification: Default::default(),
-            sell_token: H160([1; 20]),
-            buy_token: H160([2; 20]),
+            sell_token: Address::new([1; 20]),
+            buy_token: Address::new([2; 20]),
             in_amount: NonZeroU256::try_from(3).unwrap(),
             kind: OrderKind::Sell,
             block_dependent: false,
@@ -152,7 +152,7 @@ mod tests {
             Ok(Estimate::default()),
             Err(PriceEstimationError::NoLiquidity),
             Err(PriceEstimationError::UnsupportedToken {
-                token: H160([0; 20]),
+                token: Address::new([0; 20]),
                 reason: "".to_string(),
             }),
             Err(PriceEstimationError::UnsupportedOrderType("".to_string())),

crates/shared/src/price_estimation/mod.rs

@@ -4,6 +4,7 @@ use {
         arguments::{self, display_option, display_secret_option},
         trade_finding::{Interaction, QuoteExecution},
     },
+    alloy::primitives::Address,
     anyhow::{Result, ensure},
     bigdecimal::BigDecimal,
     ethcontract::{H160, U256},
@@ -443,7 +444,7 @@ impl Display for Arguments {
 #[derive(Error, Debug)]
 pub enum PriceEstimationError {
     #[error("token {token:?} is not supported: {reason:}")]
-    UnsupportedToken { token: H160, reason: String },
+    UnsupportedToken { token: Address, reason: String },
 
     #[error("No liquidity")]
     NoLiquidity,
@@ -492,8 +493,8 @@ impl Clone for PriceEstimationError {
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Default, Serialize)]
 pub struct Query {
-    pub sell_token: H160,
-    pub buy_token: H160,
+    pub sell_token: Address,
+    pub buy_token: Address,
     /// For OrderKind::Sell amount is in sell_token and for OrderKind::Buy in
     /// buy_token.
     pub in_amount: NonZeroU256,

crates/shared/src/price_estimation/native/mod.rs

@@ -1,6 +1,7 @@
 use {
     crate::price_estimation::{PriceEstimating, PriceEstimationError, Query},
     bigdecimal::{BigDecimal, ToPrimitive},
+    ethrpc::alloy::conversions::IntoAlloy,
     futures::FutureExt,
     model::order::OrderKind,
     number::nonzero::U256 as NonZeroU256,
@@ -80,8 +81,8 @@ impl NativePriceEstimator {
     // TODO explain why we use BUY order type (shallow liquidity)
     fn query(&self, token: &H160, timeout: Duration) -> Query {
         Query {
-            sell_token: *token,
-            buy_token: self.native_token,
+            sell_token: token.into_alloy(),
+            buy_token: self.native_token.into_alloy(),
             in_amount: self.price_estimation_amount,
             kind: OrderKind::Buy,
             verification: Default::default(),
@@ -122,6 +123,7 @@ mod tests {
     use {
         super::*,
         crate::price_estimation::{Estimate, HEALTHY_PRICE_ESTIMATION_TIME, MockPriceEstimating},
+        alloy::primitives::Address,
         primitive_types::H160,
         std::str::FromStr,
     };
@@ -130,8 +132,8 @@ mod tests {
     async fn prices_dont_get_modified() {
         let mut inner = MockPriceEstimating::new();
         inner.expect_estimate().times(1).returning(|query| {
-            assert!(query.buy_token.to_low_u64_be() == 7);
-            assert!(query.sell_token.to_low_u64_be() == 3);
+            assert!(query.buy_token == Address::with_last_byte(7));
+            assert!(query.sell_token == Address::with_last_byte(3));
             async {
                 Ok(Estimate {
                     out_amount: 123_456_789_000_000_000u128.into(),
@@ -160,8 +162,8 @@ mod tests {
     async fn errors_get_propagated() {
         let mut inner = MockPriceEstimating::new();
         inner.expect_estimate().times(1).returning(|query| {
-            assert!(query.buy_token.to_low_u64_be() == 7);
-            assert!(query.sell_token.to_low_u64_be() == 2);
+            assert!(query.buy_token == Address::with_last_byte(7));
+            assert!(query.sell_token == Address::with_last_byte(2));
             async { Err(PriceEstimationError::NoLiquidity) }.boxed()
         });