Migrate token_list to alloy

Author: jmg-duarte

crates/autopilot/src/arguments.rs

@@ -141,7 +141,7 @@ pub struct Arguments {
     /// Hardcoded list of trusted tokens to use in addition to
     /// `trusted_tokens_url`.
     #[clap(long, env, use_value_delimiter = true)]
-    pub trusted_tokens: Option<Vec<H160>>,
+    pub trusted_tokens: Option<Vec<Address>>,
 
     /// Time interval after which the trusted tokens list needs to be updated.
     #[clap(
@@ -677,9 +677,9 @@ impl FromStr for FeePolicy {
 #[derive(Debug, Clone)]
 pub struct CowAmmConfig {
     /// Which contract to index for CoW AMM deployment events.
-    pub factory: H160,
+    pub factory: Address,
     /// Which helper contract to use for interfacing with the indexed CoW AMMs.
-    pub helper: H160,
+    pub helper: Address,
     /// At which block indexing should start on the factory.
     pub index_start: u64,
 }

crates/autopilot/src/run.rs

@@ -491,8 +491,8 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         cow_amm_registry
             .add_listener(
                 config.index_start,
-                config.factory.into_alloy(),
-                config.helper.into_alloy(),
+                config.factory,
+                config.helper,
                 db_write.pool.clone(),
             )
             .await;

crates/autopilot/src/run_loop.rs

@@ -29,7 +29,7 @@ use {
     ::observe::metrics,
     anyhow::{Context, Result},
     database::order_events::OrderEventLabel,
-    ethrpc::block_stream::BlockInfo,
+    ethrpc::{alloy::conversions::IntoLegacy, block_stream::BlockInfo},
     futures::{FutureExt, TryFutureExt},
     itertools::Itertools,
     model::solver_competition::{
@@ -580,7 +580,12 @@ impl RunLoop {
     ) -> Vec<competition::Participant<Unranked>> {
         let request = solve::Request::new(
             auction,
-            &self.trusted_tokens.all(),
+            &self
+                .trusted_tokens
+                .all()
+                .into_iter()
+                .map(IntoLegacy::into_legacy)
+                .collect(),
             self.config.solve_deadline,
         );
 

crates/autopilot/src/shadow.rs

@@ -23,7 +23,7 @@ use {
     },
     ::observe::metrics,
     anyhow::Context,
-    ethrpc::block_stream::CurrentBlockWatcher,
+    ethrpc::{alloy::conversions::IntoLegacy, block_stream::CurrentBlockWatcher},
     itertools::Itertools,
     num::{CheckedSub, Saturating},
     shared::token_list::AutoUpdatingTokenList,
@@ -178,7 +178,16 @@ impl RunLoop {
     /// Runs the solver competition, making all configured drivers participate.
     #[instrument(skip_all)]
     async fn competition(&self, auction: &domain::Auction) -> Vec<Participant<Unranked>> {
-        let request = solve::Request::new(auction, &self.trusted_tokens.all(), self.solve_deadline);
+        let request = solve::Request::new(
+            auction,
+            &self
+                .trusted_tokens
+                .all()
+                .into_iter()
+                .map(IntoLegacy::into_legacy)
+                .collect(),
+            self.solve_deadline,
+        );
 
         futures::future::join_all(
             self.drivers

crates/shared/src/token_list.rs

@@ -1,6 +1,6 @@
 use {
+    alloy::primitives::Address,
     anyhow::Result,
-    ethcontract::H160,
     prometheus::IntCounterVec,
     reqwest::{Client, Url},
     serde::Deserialize,
@@ -18,12 +18,12 @@ pub struct TokenListConfiguration {
     pub chain_id: u64,
     pub client: Client,
     pub update_interval: Duration,
-    pub hardcoded: Vec<H160>,
+    pub hardcoded: Vec<Address>,
 }
 
 impl TokenListConfiguration {
     #[instrument(skip_all)]
-    async fn get_external_list(&self) -> Result<HashSet<H160>> {
+    async fn get_external_list(&self) -> Result<HashSet<Address>> {
         let model: TokenListModel = if let Some(url) = &self.url {
             self.client.get(url.clone()).send().await?.json().await?
         } else {
@@ -32,7 +32,7 @@ impl TokenListConfiguration {
         Ok(self.get_list(model.tokens))
     }
 
-    fn get_list(&self, tokens: Vec<TokenModel>) -> HashSet<H160> {
+    fn get_list(&self, tokens: Vec<TokenModel>) -> HashSet<Address> {
         tokens
             .into_iter()
             .filter(|token| token.chain_id == self.chain_id)
@@ -43,7 +43,7 @@ impl TokenListConfiguration {
 }
 #[derive(Clone, Debug, Default)]
 pub struct AutoUpdatingTokenList {
-    tokens: Arc<RwLock<HashSet<H160>>>,
+    tokens: Arc<RwLock<HashSet<Address>>>,
 }
 
 impl AutoUpdatingTokenList {
@@ -91,17 +91,17 @@ impl AutoUpdatingTokenList {
         Self { tokens }
     }
 
-    pub fn new(tokens: HashSet<H160>) -> Self {
+    pub fn new(tokens: HashSet<Address>) -> Self {
         Self {
             tokens: Arc::new(RwLock::new(tokens)),
         }
     }
 
-    pub fn contains(&self, address: &H160) -> bool {
+    pub fn contains(&self, address: &Address) -> bool {
         self.tokens.read().unwrap().contains(address)
     }
 
-    pub fn all(&self) -> HashSet<H160> {
+    pub fn all(&self) -> HashSet<Address> {
         self.tokens.read().unwrap().clone()
     }
 }
@@ -118,7 +118,7 @@ struct TokenListModel {
 #[serde(rename_all = "camelCase")]
 struct TokenModel {
     chain_id: u64,
-    address: H160,
+    address: Address,
 }
 
 #[derive(prometheus_metric_storage::MetricStorage, Clone, Debug)]
@@ -130,7 +130,7 @@ struct Metrics {
 
 #[cfg(test)]
 pub mod tests {
-    use {super::*, ethrpc::alloy::conversions::IntoLegacy};
+    use {super::*, alloy::primitives::address};
 
     // https://github.com/Uniswap/token-lists/blob/master/test/schema/example.tokenlist.json
     const EXAMPLE_LIST: &str = r#"
@@ -194,11 +194,11 @@ pub mod tests {
                 tokens: vec![
                     TokenModel {
                         chain_id: 1,
-                        address: testlib::tokens::USDC.into_legacy(),
+                        address: testlib::tokens::USDC,
                     },
                     TokenModel {
                         chain_id: 4,
-                        address: addr!("39AA39c021dfbaE8faC545936693aC917d5E7563"),
+                        address: address!("39AA39c021dfbaE8faC545936693aC917d5E7563"),
                     }
                 ]
             }
@@ -217,9 +217,9 @@ pub mod tests {
         };
         let tokens = config.get_list(list.tokens);
         let instance = AutoUpdatingTokenList::new(tokens);
-        assert!(instance.contains(&testlib::tokens::USDC.into_legacy()));
+        assert!(instance.contains(&testlib::tokens::USDC));
         // Chain ID 4
-        assert!(!instance.contains(&addr!("39AA39c021dfbaE8faC545936693aC917d5E7563")),);
+        assert!(!instance.contains(&address!("39AA39c021dfbaE8faC545936693aC917d5E7563")));
     }
 
     #[ignore]
@@ -234,13 +234,13 @@ pub mod tests {
             hardcoded: Default::default(),
         };
         let tokens = config.get_external_list().await.unwrap();
-        assert!(tokens.contains(&testlib::tokens::USDC.into_legacy()));
-        let gc_token = addr!("39AA39c021dfbaE8faC545936693aC917d5E7563");
+        assert!(tokens.contains(&testlib::tokens::USDC));
+        let gc_token = address!("39AA39c021dfbaE8faC545936693aC917d5E7563");
         assert!(!tokens.contains(&gc_token));
 
         config.chain_id = 4;
         let tokens = config.get_list(list.tokens);
-        assert!(!tokens.contains(&testlib::tokens::USDC.into_legacy()));
+        assert!(!tokens.contains(&testlib::tokens::USDC));
         assert!(tokens.contains(&gc_token));
     }
 }