Migrate BadTokenDetecting to alloy

Author: jmg-duarte

crates/autopilot/src/arguments.rs

@@ -81,11 +81,11 @@ pub struct Arguments {
     /// bad token detector thinks they are bad. Base tokens are
     /// automatically allowed.
     #[clap(long, env, use_value_delimiter = true)]
-    pub allowed_tokens: Vec<H160>,
+    pub allowed_tokens: Vec<Address>,
 
     /// List of token addresses to be ignored throughout service
     #[clap(long, env, use_value_delimiter = true)]
-    pub unsupported_tokens: Vec<H160>,
+    pub unsupported_tokens: Vec<Address>,
 
     /// Which estimators to use to estimate token prices in terms of the chain's
     /// native token. Estimators with the same name need to also be specified as

crates/autopilot/src/run.rs

@@ -326,8 +326,8 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         &args.shared.base_tokens,
     ));
     let mut allowed_tokens = args.allowed_tokens.clone();
-    allowed_tokens.extend(base_tokens.tokens().iter().copied());
-    allowed_tokens.push(model::order::BUY_ETH_ADDRESS);
+    allowed_tokens.extend(base_tokens.tokens().iter().map(|t| t.into_alloy()));
+    allowed_tokens.push(model::order::BUY_ETH_ADDRESS.into_alloy());
     let unsupported_tokens = args.unsupported_tokens.clone();
 
     let finder = token_owner_finder::init(

crates/autopilot/src/solvable_orders.rs

@@ -691,7 +691,7 @@ async fn find_unsupported_tokens(
             .map(|token| {
                 let bad_token = bad_token.clone();
                 async move {
-                    match bad_token.detect(token.into_legacy()).await {
+                    match bad_token.detect(token).await {
                         Ok(quality) => (!quality.is_good()).then_some(token),
                         Err(err) => {
                             tracing::warn!(
@@ -1313,7 +1313,7 @@ mod tests {
         let token0 = H160::from_low_u64_le(0);
         let token1 = H160::from_low_u64_le(1);
         let token2 = H160::from_low_u64_le(2);
-        let bad_token = Arc::new(ListBasedDetector::deny_list(vec![token0]));
+        let bad_token = Arc::new(ListBasedDetector::deny_list(vec![token0.into_alloy()]));
         let orders = vec![
             OrderBuilder::default()
                 .with_sell_token(token0)

crates/orderbook/src/arguments.rs

@@ -1,6 +1,5 @@
 use {
     alloy::primitives::Address,
-    primitive_types::H160,
     reqwest::Url,
     shared::{
         arguments::{display_option, display_secret_option},
@@ -78,7 +77,7 @@ pub struct Arguments {
 
     /// List of token addresses to be ignored throughout service
     #[clap(long, env, use_value_delimiter = true)]
-    pub unsupported_tokens: Vec<H160>,
+    pub unsupported_tokens: Vec<Address>,
 
     /// List of account addresses to be denied from order creation
     #[clap(long, env, use_value_delimiter = true)]
@@ -106,7 +105,7 @@ pub struct Arguments {
     /// bad token detector thinks they are bad. Base tokens are
     /// automatically allowed.
     #[clap(long, env, use_value_delimiter = true)]
-    pub allowed_tokens: Vec<H160>,
+    pub allowed_tokens: Vec<Address>,
 
     /// Skip EIP-1271 order signature validation on creation.
     #[clap(long, env, action = clap::ArgAction::Set, default_value = "false")]

crates/orderbook/src/run.rs

@@ -232,8 +232,8 @@ pub async fn run(args: Arguments) {
         &args.shared.base_tokens,
     ));
     let mut allowed_tokens = args.allowed_tokens.clone();
-    allowed_tokens.extend(base_tokens.tokens().iter().copied());
-    allowed_tokens.push(BUY_ETH_ADDRESS);
+    allowed_tokens.extend(base_tokens.tokens().iter().map(|t| t.into_alloy()));
+    allowed_tokens.push(BUY_ETH_ADDRESS.into_alloy());
     let unsupported_tokens = args.unsupported_tokens.clone();
 
     let uniswapv3_factory = IUniswapV3Factory::Instance::deployed(&web3.alloy)

crates/shared/src/bad_token/cache.rs

@@ -1,9 +1,9 @@
 use {
     super::{BadTokenDetecting, TokenQuality},
+    alloy::primitives::Address,
     anyhow::Result,
     dashmap::DashMap,
     futures::future::join_all,
-    primitive_types::H160,
     std::{
         ops::Div,
         sync::Arc,
@@ -14,15 +14,15 @@ use {
 
 pub struct CachingDetector {
     inner: Box<dyn BadTokenDetecting>,
-    cache: DashMap<H160, (Instant, TokenQuality)>,
+    cache: DashMap<Address, (Instant, TokenQuality)>,
     cache_expiry: Duration,
     prefetch_time: Duration,
 }
 
 #[async_trait::async_trait]
 impl BadTokenDetecting for CachingDetector {
     #[instrument(skip_all)]
-    async fn detect(&self, token: H160) -> Result<TokenQuality> {
+    async fn detect(&self, token: Address) -> Result<TokenQuality> {
         if let Some(quality) = self.get_from_cache(&token, Instant::now()) {
             return Ok(quality);
         }
@@ -53,13 +53,13 @@ impl CachingDetector {
         detector
     }
 
-    fn get_from_cache(&self, token: &H160, now: Instant) -> Option<TokenQuality> {
+    fn get_from_cache(&self, token: &Address, now: Instant) -> Option<TokenQuality> {
         let (instant, quality) = self.cache.get(token)?.value().clone();
         let still_valid = now.saturating_duration_since(instant) < self.cache_expiry;
         still_valid.then_some(quality)
     }
 
-    fn insert_many_into_cache(&self, tokens: impl Iterator<Item = (H160, TokenQuality)>) {
+    fn insert_many_into_cache(&self, tokens: impl Iterator<Item = (Address, TokenQuality)>) {
         let now = Instant::now();
         tokens.into_iter().for_each(|(token, quality)| {
             self.cache.insert(token, (now, quality));
@@ -134,7 +134,7 @@ mod tests {
 
         for _ in 0..2 {
             let result = detector
-                .detect(H160::from_low_u64_le(0))
+                .detect(Address::with_last_byte(0))
                 .now_or_never()
                 .unwrap();
             assert!(result.unwrap().is_good());
@@ -144,7 +144,7 @@ mod tests {
     #[tokio::test]
     async fn cache_expires() {
         let inner = MockBadTokenDetecting::new();
-        let token = H160::from_low_u64_le(0);
+        let token = Address::with_last_byte(0);
         let detector = CachingDetector::new(
             Box::new(inner),
             Duration::from_secs(2),
@@ -193,22 +193,22 @@ mod tests {
         );
 
         let result = detector
-            .detect(H160::from_low_u64_le(0))
+            .detect(Address::with_last_byte(0))
             .now_or_never()
             .unwrap();
         assert!(result.unwrap().is_good());
         // Check that the result is the same because we haven't reached the prefetch
         // time yet
         tokio::time::sleep(Duration::from_millis(100)).await;
         let result = detector
-            .detect(H160::from_low_u64_le(0))
+            .detect(Address::with_last_byte(0))
             .now_or_never()
             .unwrap();
         assert!(result.unwrap().is_good());
         // We wait so the prefetch fetches the data
         tokio::time::sleep(Duration::from_millis(70)).await;
         let result = detector
-            .detect(H160::from_low_u64_le(0))
+            .detect(Address::with_last_byte(0))
             .now_or_never()
             .unwrap();
         assert!(!result.unwrap().is_good());

crates/shared/src/bad_token/instrumented.rs

@@ -1,5 +1,6 @@
 use {
     super::{BadTokenDetecting, TokenQuality},
+    alloy::primitives::Address,
     anyhow::Result,
     prometheus::IntCounterVec,
     prometheus_metric_storage::MetricStorage,
@@ -33,7 +34,7 @@ pub struct InstrumentedBadTokenDetector {
 
 #[async_trait::async_trait]
 impl BadTokenDetecting for InstrumentedBadTokenDetector {
-    async fn detect(&self, token: ethcontract::H160) -> Result<TokenQuality> {
+    async fn detect(&self, token: Address) -> Result<TokenQuality> {
         let result = self
             .inner
             .detect(token)

crates/shared/src/bad_token/list_based.rs

@@ -1,7 +1,7 @@
 use {
     super::{BadTokenDetecting, TokenQuality},
+    alloy::primitives::Address,
     anyhow::Result,
-    primitive_types::H160,
     std::sync::Arc,
     tracing::instrument,
 };
@@ -15,16 +15,16 @@ pub enum UnknownTokenStrategy {
 
 /// Classify tokens with explicit allow and deny lists.
 pub struct ListBasedDetector {
-    allow_list: Vec<H160>,
-    deny_list: Vec<H160>,
+    allow_list: Vec<Address>,
+    deny_list: Vec<Address>,
     strategy: UnknownTokenStrategy,
 }
 
 impl ListBasedDetector {
     /// Panics if same token is both allowed and denied.
     pub fn new(
-        allow_list: Vec<H160>,
-        deny_list: Vec<H160>,
+        allow_list: Vec<Address>,
+        deny_list: Vec<Address>,
         strategy: UnknownTokenStrategy,
     ) -> Self {
         assert!(
@@ -38,7 +38,7 @@ impl ListBasedDetector {
         }
     }
 
-    pub fn deny_list(list: Vec<H160>) -> Self {
+    pub fn deny_list(list: Vec<Address>) -> Self {
         Self {
             allow_list: Vec::new(),
             deny_list: list,
@@ -50,7 +50,7 @@ impl ListBasedDetector {
 #[async_trait::async_trait]
 impl BadTokenDetecting for ListBasedDetector {
     #[instrument(skip_all)]
-    async fn detect(&self, token: ethcontract::H160) -> Result<TokenQuality> {
+    async fn detect(&self, token: Address) -> Result<TokenQuality> {
         if self.allow_list.contains(&token) {
             return Ok(TokenQuality::Good);
         }
@@ -80,19 +80,19 @@ mod tests {
         // Would panic if used.
         let inner = MockBadTokenDetecting::new();
         let detector = ListBasedDetector {
-            allow_list: vec![H160::from_low_u64_le(0)],
-            deny_list: vec![H160::from_low_u64_le(1)],
+            allow_list: vec![Address::with_last_byte(0)],
+            deny_list: vec![Address::with_last_byte(1)],
             strategy: UnknownTokenStrategy::Forward(Arc::new(inner)),
         };
 
         let result = detector
-            .detect(H160::from_low_u64_le(0))
+            .detect(Address::with_last_byte(0))
             .now_or_never()
             .unwrap();
         assert!(result.unwrap().is_good());
 
         let result = detector
-            .detect(H160::from_low_u64_le(1))
+            .detect(Address::with_last_byte(1))
             .now_or_never()
             .unwrap();
         assert!(!result.unwrap().is_good());
@@ -106,7 +106,7 @@ mod tests {
             strategy: UnknownTokenStrategy::Allow,
         };
         let result = detector
-            .detect(H160::from_low_u64_le(0))
+            .detect(Address::with_last_byte(0))
             .now_or_never()
             .unwrap();
         assert!(result.unwrap().is_good());
@@ -117,7 +117,7 @@ mod tests {
             strategy: UnknownTokenStrategy::Deny,
         };
         let result = detector
-            .detect(H160::from_low_u64_le(0))
+            .detect(Address::with_last_byte(0))
             .now_or_never()
             .unwrap();
         assert!(!result.unwrap().is_good());
@@ -138,7 +138,7 @@ mod tests {
         };
 
         let result = detector
-            .detect(H160::from_low_u64_le(0))
+            .detect(Address::with_last_byte(0))
             .now_or_never()
             .unwrap();
         assert!(result.unwrap().is_good());

crates/shared/src/bad_token/mod.rs

@@ -4,7 +4,7 @@ pub mod list_based;
 pub mod token_owner_finder;
 pub mod trace_call;
 
-use {anyhow::Result, primitive_types::H160};
+use {alloy::primitives::Address, anyhow::Result};
 
 /// How well behaved a token is.
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -29,5 +29,5 @@ impl TokenQuality {
 #[cfg_attr(any(test, feature = "test-util"), mockall::automock)]
 #[async_trait::async_trait]
 pub trait BadTokenDetecting: Send + Sync {
-    async fn detect(&self, token: H160) -> Result<TokenQuality>;
+    async fn detect(&self, token: Address) -> Result<TokenQuality>;
 }