Migrate autopilot to alloy

crates/autopilot/src/database/events.rs

@@ -9,7 +9,6 @@ use {
         byte_array::ByteArray,
         events::{Event, EventIndex, Invalidation, PreSignature, Settlement, Trade},
     },
-    ethcontract::EventMetadata,
     ethrpc::alloy::conversions::IntoLegacy,
     number::conversions::u256_to_big_decimal,
     std::convert::TryInto,
@@ -114,7 +113,7 @@ pub async fn replace_events(
     Ok(())
 }
 
-pub fn meta_to_event_index(meta: &EventMetadata) -> EventIndex {
+pub fn meta_to_event_index(meta: &ethcontract::EventMetadata) -> EventIndex {
     EventIndex {
         block_number: i64::try_from(meta.block_number).unwrap_or(i64::MAX),
         log_index: i64::try_from(meta.log_index).unwrap_or(i64::MAX),

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

@@ -27,7 +27,6 @@ use {
         onchain_broadcasted_orders::{OnchainOrderPlacement, OnchainOrderPlacementError},
         orders::{Order, OrderClass, insert_quotes},
     },
-    ethcontract::H160,
     ethrpc::{
         Web3,
         alloy::conversions::IntoLegacy,
@@ -73,7 +72,7 @@ pub struct OnchainOrderParser<EventData: Send + Sync, EventRow: Send + Sync> {
     quoter: Arc<dyn OrderQuoting>,
     custom_onchain_data_parser: Box<dyn OnchainOrderParsing<EventData, EventRow>>,
     domain_separator: DomainSeparator,
-    settlement_contract: H160,
+    settlement_contract: Address,
     metrics: &'static Metrics,
     trampoline: HooksTrampoline::Instance,
 }
@@ -89,7 +88,7 @@ where
         quoter: Arc<dyn OrderQuoting>,
         custom_onchain_data_parser: Box<dyn OnchainOrderParsing<EventData, EventRow>>,
         domain_separator: DomainSeparator,
-        settlement_contract: H160,
+        settlement_contract: Address,
         trampoline: HooksTrampoline::Instance,
     ) -> Self {
         OnchainOrderParser {
@@ -454,7 +453,7 @@ async fn parse_general_onchain_order_placement_data<I>(
     quoter: &'_ dyn OrderQuoting,
     order_placement_events_and_quotes_zipped: I,
     domain_separator: DomainSeparator,
-    settlement_contract: H160,
+    settlement_contract: Address,
     metrics: &'static Metrics,
 ) -> Vec<GeneralOnchainOrderPlacementData>
 where
@@ -489,7 +488,7 @@ where
                 order_data,
                 signing_scheme,
                 order_uid,
-                owner.into_legacy(),
+                owner,
                 settlement_contract,
                 metrics,
             );
@@ -592,8 +591,8 @@ fn convert_onchain_order_placement(
     order_data: OrderData,
     signing_scheme: SigningScheme,
     order_uid: OrderUid,
-    owner: H160,
-    settlement_contract: H160,
+    owner: Address,
+    settlement_contract: Address,
     metrics: &'static Metrics,
 ) -> (OnchainOrderPlacement, Order) {
     // eth flow orders are expected to be within the market price so they are
@@ -611,7 +610,7 @@ fn convert_onchain_order_placement(
 
     let order = database::orders::Order {
         uid: ByteArray(order_uid.0),
-        owner: ByteArray(owner.0),
+        owner: ByteArray(owner.0.0),
         creation_timestamp: Utc.timestamp_opt(event_timestamp, 0).unwrap(),
         sell_token: ByteArray(order_data.sell_token.0.0),
         buy_token: ByteArray(order_data.buy_token.0.0),
@@ -625,7 +624,7 @@ fn convert_onchain_order_placement(
         partially_fillable: order_data.partially_fillable,
         signature: order_placement.signature.data.to_vec(),
         signing_scheme: signing_scheme_into(signing_scheme),
-        settlement_contract: ByteArray(settlement_contract.0),
+        settlement_contract: ByteArray(settlement_contract.0.0),
         sell_token_balance: sell_token_source_into(order_data.sell_token_balance),
         buy_token_balance: buy_token_destination_into(order_data.buy_token_balance),
         cancellation_timestamp: None,
@@ -788,7 +787,6 @@ mod test {
         alloy::primitives::U256,
         contracts::alloy::CoWSwapOnchainOrders,
         database::{byte_array::ByteArray, onchain_broadcasted_orders::OnchainOrderPlacement},
-        ethcontract::H160,
         ethrpc::Web3,
         model::{
             DomainSeparator,
@@ -980,7 +978,7 @@ mod test {
                 },
             data: Default::default(),
         };
-        let settlement_contract = H160::from([8u8; 20]);
+        let settlement_contract = Address::repeat_byte(8);
         let quote = Quote::default();
         let order_uid = OrderUid([9u8; 56]);
         let signing_scheme = SigningScheme::Eip1271;
@@ -992,7 +990,7 @@ mod test {
             order_data,
             signing_scheme,
             order_uid,
-            owner.into_legacy(),
+            owner,
             settlement_contract,
             Metrics::get(),
         );
@@ -1033,7 +1031,7 @@ mod test {
             partially_fillable: expected_order_data.partially_fillable,
             signature: order_placement.signature.data.to_vec(),
             signing_scheme: signing_scheme_into(SigningScheme::Eip1271),
-            settlement_contract: ByteArray(settlement_contract.0),
+            settlement_contract: ByteArray(settlement_contract.0.into()),
             sell_token_balance: sell_token_source_into(expected_order_data.sell_token_balance),
             buy_token_balance: buy_token_destination_into(expected_order_data.buy_token_balance),
             cancellation_timestamp: None,
@@ -1091,7 +1089,7 @@ mod test {
                 },
             data: Default::default(),
         };
-        let settlement_contract = H160::from([8u8; 20]);
+        let settlement_contract = Address::repeat_byte(8);
         let quote = Quote {
             sell_amount,
             buy_amount: buy_amount / U256::from(2),
@@ -1106,7 +1104,7 @@ mod test {
             order_data,
             signing_scheme,
             order_uid,
-            owner.into_legacy(),
+            owner,
             settlement_contract,
             Metrics::get(),
         );
@@ -1147,7 +1145,7 @@ mod test {
             partially_fillable: expected_order_data.partially_fillable,
             signature: order_placement.signature.data.to_vec(),
             signing_scheme: signing_scheme_into(SigningScheme::Eip1271),
-            settlement_contract: ByteArray(settlement_contract.0),
+            settlement_contract: ByteArray(settlement_contract.0.into()),
             sell_token_balance: sell_token_source_into(expected_order_data.sell_token_balance),
             buy_token_balance: buy_token_destination_into(expected_order_data.buy_token_balance),
             cancellation_timestamp: None,
@@ -1269,7 +1267,7 @@ mod test {
             quoter: Arc::new(order_quoter),
             custom_onchain_data_parser: Box::new(custom_onchain_order_parser),
             domain_separator,
-            settlement_contract: H160::zero(),
+            settlement_contract: Address::ZERO,
             metrics: Metrics::get(),
         };
         let result = onchain_order_parser

crates/autopilot/src/domain/competition/winner_selection.rs

@@ -471,9 +471,7 @@ mod tests {
             },
             infra::Driver,
         },
-        alloy::primitives::{U256, address},
-        ethcontract::H160,
-        ethrpc::alloy::conversions::IntoAlloy,
+        alloy::primitives::{Address, U160, U256, address},
         hex_literal::hex,
         number::serialization::HexOrDecimalU256,
         serde::Deserialize,
@@ -1096,7 +1094,7 @@ mod tests {
     #[serde_as]
     #[derive(Deserialize, Debug)]
     struct TestCase {
-        pub tokens: Vec<(String, H160)>,
+        pub tokens: Vec<(String, Address)>,
         pub auction: TestAuction,
         pub solutions: HashMap<String, TestSolution>,
         pub expected_fair_solutions: Vec<String>,
@@ -1114,7 +1112,12 @@ mod tests {
             let arbitrator = create_test_arbitrator();
 
             // map (token id -> token address) for later reference during the test
-            let token_map: HashMap<String, H160> = self.tokens.iter().cloned().collect();
+            let token_map: HashMap<String, TokenAddress> = self
+                .tokens
+                .iter()
+                .cloned()
+                .map(|(id, address)| (id, address.into()))
+                .collect();
 
             // map (order id -> order) for later reference during the test
             let order_map: HashMap<String, Order> = self
@@ -1153,7 +1156,7 @@ mod tests {
                 prices
                     .iter()
                     .map(|(token_id, price)| {
-                        let token_address = token_map.get(token_id).unwrap().into_alloy().into();
+                        let token_address = *token_map.get(token_id).unwrap();
                         let price = create_price(*price);
                         (token_address, price)
                     })
@@ -1223,8 +1226,8 @@ mod tests {
             let reference_scores = arbitrator.compute_reference_scores(&ranking);
             assert_eq!(reference_scores.len(), self.expected_reference_scores.len());
             for (solver_id, expected_score) in &self.expected_reference_scores {
-                let solver_address = solver_map.get(solver_id).unwrap().into_alloy();
-                let score = reference_scores.get(&solver_address).unwrap();
+                let solver_address = solver_map.get(solver_id).unwrap();
+                let score = reference_scores.get(solver_address).unwrap();
                 assert_eq!(score.0, eth::Ether(*expected_score))
             }
         }
@@ -1274,27 +1277,27 @@ mod tests {
         }
     }
 
-    fn address(id: u64) -> H160 {
-        H160::from_low_u64_le(id)
+    fn address(id: u64) -> Address {
+        Address::from(U160::from(id))
     }
 
     fn create_order(
         uid: u64,
-        sell_token: H160,
+        sell_token: TokenAddress,
         sell_amount: eth::U256,
-        buy_token: H160,
+        buy_token: TokenAddress,
         buy_amount: eth::U256,
         side: order::Side,
     ) -> Order {
         Order {
             uid: create_order_uid(uid),
             sell: eth::Asset {
                 amount: sell_amount.into(),
-                token: sell_token.into_alloy().into(),
+                token: sell_token,
             },
             buy: eth::Asset {
                 amount: buy_amount.into(),
-                token: buy_token.into_alloy().into(),
+                token: buy_token,
             },
             protocol_fees: vec![],
             side,
@@ -1368,7 +1371,7 @@ mod tests {
 
     async fn create_solution(
         solution_id: u64,
-        solver_address: H160,
+        solver_address: Address,
         trades: Vec<(OrderUid, TradedOrder)>,
         prices: Option<HashMap<TokenAddress, Price>>,
     ) -> Participant<Unranked> {
@@ -1384,7 +1387,6 @@ mod tests {
         });
 
         let trade_order_map: HashMap<OrderUid, TradedOrder> = trades.into_iter().collect();
-        let solver_address = solver_address.into_alloy();
 
         let solution = Solution::new(solution_id, solver_address, trade_order_map, prices);
 

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

@@ -357,8 +357,7 @@ mod tests {
             eth,
             settlement::{OrderMatchKey, trade_to_key},
         },
-        alloy::primitives::address,
-        ethcontract::BlockId,
+        alloy::{eips::BlockId, primitives::address},
         hex_literal::hex,
         std::collections::{HashMap, HashSet},
     };

crates/autopilot/src/domain/settlement/transaction/mod.rs

@@ -3,10 +3,8 @@ use {
         boundary,
         domain::{self, auction::order, eth},
     },
-    alloy::sol_types::SolCall,
+    alloy::{eips::BlockId, sol_types::SolCall},
     contracts::alloy::{GPv2AllowListAuthentication, GPv2Settlement},
-    ethcontract::BlockId,
-    ethrpc::alloy::conversions::{IntoAlloy, IntoLegacy},
     std::collections::HashSet,
 };
 
@@ -38,7 +36,7 @@ impl Authenticator for GPv2AllowListAuthentication::Instance {
         // underlying call needs to happen on the same block the transaction happened.
         Ok(self
             .isSolver(prospective_solver)
-            .block(block.into_alloy())
+            .block(block)
             .call()
             .await
             .map_err(Error::Authentication)?)
@@ -84,7 +82,7 @@ impl Transaction {
         // In cases of solvers using EOA to submit solutions, the address is the sender
         // of the transaction. In cases of solvers using a smart contract to
         // submit solutions, the address is deduced from the calldata.
-        let block = BlockId::Number(transaction.block.0.into());
+        let block = BlockId::from(transaction.block.0);
         let solver = find_solver_address(authenticator, callers, block).await?;
 
         /// Number of bytes that may be appended to the calldata to store an
@@ -121,7 +119,7 @@ impl Transaction {
 
                 let mut trades = Vec::with_capacity(decoded_trades.len());
                 for trade in decoded_trades {
-                    let flags = tokenized::TradeFlags(trade.flags.into_legacy());
+                    let flags = tokenized::TradeFlags(trade.flags);
                     let sell_token_index = usize::try_from(trade.sellTokenIndex)
                         .expect("SC was able to look up this index");
                     let buy_token_index = usize::try_from(trade.buyTokenIndex)

crates/autopilot/src/domain/settlement/transaction/tokenized.rs

@@ -3,10 +3,9 @@ use {
         boundary,
         domain::{self, auction::order, eth},
     },
+    alloy::primitives::U256,
     app_data::AppDataHash,
     contracts::alloy::GPv2Settlement,
-    ethcontract::U256,
-    ethrpc::alloy::conversions::IntoLegacy,
 };
 
 /// Recover order uid from order data and signature
@@ -15,7 +14,7 @@ pub fn order_uid(
     tokens: &[alloy::primitives::Address],
     domain_separator: &eth::DomainSeparator,
 ) -> Result<domain::OrderUid, error::Uid> {
-    let flags = TradeFlags(trade.flags.into_legacy());
+    let flags = TradeFlags(trade.flags);
     let signature =
         crate::boundary::Signature::from_bytes(flags.signing_scheme(), &trade.signature.0)
             .map_err(error::Uid::Signature)?;

crates/autopilot/src/infra/solvers/mod.rs

@@ -1,9 +1,9 @@
 use {
     self::dto::{reveal, settle, solve},
     crate::{arguments::Account, domain::eth, infra::solvers::dto::notify, util},
+    alloy::signers::{Signer, aws::AwsSigner},
     anyhow::{Context, Result, anyhow},
     chrono::{DateTime, Utc},
-    ethrpc::alloy::conversions::IntoAlloy,
     observe::tracing::tracing_headers,
     reqwest::{Client, StatusCode},
     std::{sync::Arc, time::Duration},
@@ -48,15 +48,15 @@ impl Driver {
     ) -> Result<Self, Error> {
         let submission_address = match submission_account {
             Account::Kms(key_id) => {
-                let config = ethcontract::aws_config::load_from_env().await;
-                let account =
-                    ethcontract::transaction::kms::Account::new((&config).into(), &key_id.0)
-                        .await
-                        .map_err(|_| {
-                            tracing::error!(?name, ?key_id, "Unable to load KMS account");
-                            Error::UnableToLoadKmsAccount
-                        })?;
-                account.public_address().into_alloy()
+                let config = alloy::signers::aws::aws_config::load_from_env().await;
+                let client = alloy::signers::aws::aws_sdk_kms::Client::new(&config);
+                let account = AwsSigner::new(client, key_id.0.clone(), None)
+                    .await
+                    .map_err(|_| {
+                        tracing::error!(?name, ?key_id, "Unable to load KMS account");
+                        Error::UnableToLoadKmsAccount
+                    })?;
+                account.address()
             }
             Account::Address(address) => address,
         };

crates/autopilot/src/run.rs

@@ -28,11 +28,7 @@ use {
     chain::Chain,
     clap::Parser,
     contracts::alloy::{BalancerV2Vault, GPv2Settlement, IUniswapV3Factory, WETH9},
-    ethrpc::{
-        Web3,
-        alloy::conversions::IntoLegacy,
-        block_stream::block_number_to_block_number_hash,
-    },
+    ethrpc::{Web3, block_stream::block_number_to_block_number_hash},
     futures::StreamExt,
     model::DomainSeparator,
     num::ToPrimitive,
@@ -606,7 +602,7 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
             quoter.clone(),
             Box::new(custom_ethflow_order_parser),
             DomainSeparator::new(chain_id, *eth.contracts().settlement().address()),
-            eth.contracts().settlement().address().into_legacy(),
+            *eth.contracts().settlement().address(),
             eth.contracts().trampoline().clone(),
         );