Migrate solver's ethcontract::Account to alloy

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

@@ -21,7 +21,6 @@ use {
         },
         util::{Bytes, math},
     },
-    ethrpc::alloy::conversions::IntoAlloy,
     futures::{StreamExt, future::Either, stream::FuturesUnordered},
     itertools::Itertools,
     std::{
@@ -128,7 +127,7 @@ impl Competition {
         let mut auction = Arc::unwrap_or_clone(tasks.auction.await);
 
         let settlement_contract = *self.eth.contracts().settlement().address();
-        let solver_address = self.solver.account().address().into_alloy();
+        let solver_address = self.solver.address();
         let order_sorting_strategies = self.order_sorting_strategies.clone();
 
         // Add the CoW AMM orders to the auction

crates/driver/src/domain/competition/solution/mod.rs

@@ -15,6 +15,7 @@ use {
             solver::{ManageNativeToken, Solver},
         },
     },
+    alloy::network::TxSigner,
     chrono::Utc,
     futures::future::try_join_all,
     itertools::Itertools,

crates/driver/src/domain/eth/mod.rs

@@ -1,5 +1,6 @@
 use {
     crate::util::{Bytes, conv::u256::U256Ext},
+    alloy::rpc::types::TransactionRequest,
     derive_more::{From, Into},
     ethrpc::alloy::conversions::{IntoAlloy, IntoLegacy},
     itertools::Itertools,
@@ -92,8 +93,71 @@ impl From<AccessList> for web3::types::AccessList {
     }
 }
 
+impl IntoIterator for AccessList {
+    type IntoIter = std::collections::hash_map::IntoIter<Address, HashSet<StorageKey>>;
+    type Item = (Address, HashSet<StorageKey>);
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+impl<I> FromIterator<(Address, I)> for AccessList
+where
+    I: IntoIterator<Item = B256>,
+{
+    fn from_iter<T: IntoIterator<Item = (Address, I)>>(iter: T) -> Self {
+        Self(
+            iter.into_iter()
+                .map(|(address, i)| {
+                    (
+                        address,
+                        i.into_iter().map(StorageKey).collect::<HashSet<_>>(),
+                    )
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<alloy::eips::eip2930::AccessList> for AccessList {
+    fn from(value: alloy::eips::eip2930::AccessList) -> Self {
+        Self(
+            value
+                .0
+                .into_iter()
+                .map(|item| {
+                    (
+                        item.address,
+                        item.storage_keys
+                            .into_iter()
+                            .map(StorageKey)
+                            .collect::<HashSet<_>>(),
+                    )
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<AccessList> for alloy::eips::eip2930::AccessList {
+    fn from(value: AccessList) -> Self {
+        Self(
+            value
+                .into_iter()
+                .map(
+                    |(address, storage_keys)| alloy::eips::eip2930::AccessListItem {
+                        address,
+                        storage_keys: storage_keys.into_iter().map(|k| k.0).collect(),
+                    },
+                )
+                .collect(),
+        )
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Into, From)]
-struct StorageKey(pub B256);
+pub struct StorageKey(pub B256);
 
 // TODO This type should probably use Ethereum::is_contract to verify during
 // construction that it does indeed point to a contract
@@ -377,6 +441,17 @@ impl std::fmt::Debug for Tx {
     }
 }
 
+impl From<Tx> for TransactionRequest {
+    fn from(value: Tx) -> Self {
+        TransactionRequest::default()
+            .from(value.from)
+            .to(value.to)
+            .value(value.value.0)
+            .input(value.input.0.into())
+            .access_list(value.access_list.into())
+    }
+}
+
 impl Tx {
     pub fn set_access_list(self, access_list: AccessList) -> Self {
         Self {

crates/driver/src/domain/mempools.rs

@@ -272,7 +272,7 @@ impl Mempools {
         mempool: &infra::mempool::Mempool,
         original_tx_gas_price: eth::GasPrice,
         solver: &Solver,
-        nonce: eth::U256,
+        nonce: u64,
     ) -> Result<TxId, Error> {
         let fallback_gas_price = original_tx_gas_price * GAS_PRICE_BUMP;
         let replacement_gas_price = self
@@ -319,7 +319,7 @@ impl Mempools {
         &self,
         mempool: &infra::Mempool,
         solver: &Solver,
-        nonce: eth::U256,
+        nonce: u64,
     ) -> anyhow::Result<Option<eth::GasPrice>> {
         let pending_tx = match mempool
             .find_pending_tx_in_mempool(solver.address(), nonce)

crates/driver/src/infra/config/file/load.rs

@@ -9,11 +9,11 @@ use {
             mempool,
             notify,
             simulator,
-            solver::{self, BadTokenDetection, SolutionMerging},
+            solver::{self, Account, BadTokenDetection, SolutionMerging},
         },
     },
+    alloy::signers::{aws::AwsSigner, local::PrivateKeySigner},
     chain::Chain,
-    ethrpc::alloy::conversions::IntoLegacy,
     futures::future::join_all,
     number::conversions::big_decimal_to_big_rational,
     std::path::Path,
@@ -52,22 +52,24 @@ pub async fn load(chain: Chain, path: &Path) -> infra::Config {
     );
     infra::Config {
         solvers: join_all(config.solvers.into_iter().map(|solver_config| async move {
-            let account = match solver_config.account {
-                file::Account::PrivateKey(private_key) => ethcontract::Account::Offline(
-                    ethcontract::PrivateKey::from_raw(private_key.0).unwrap(),
-                    None,
-                ),
-                file::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
-                            .unwrap_or_else(|_| panic!("Unable to load KMS account {key_id:?}"));
-                    ethcontract::Account::Kms(account, None)
+            let account: Account = match solver_config.account {
+                file::Account::PrivateKey(private_key) => {
+                    PrivateKeySigner::from_bytes(&private_key)
+                        .expect(
+                            "private key should
+                                            be valid",
+                        )
+                        .into()
                 }
-                file::Account::Address(address) => {
-                    ethcontract::Account::Local(address.into_legacy(), None)
+                file::Account::Kms(arn) => {
+                    let sdk_config = alloy::signers::aws::aws_config::load_from_env().await;
+                    let client = alloy::signers::aws::aws_sdk_kms::Client::new(&sdk_config);
+                    AwsSigner::new(client, arn.0, config.chain_id)
+                        .await
+                        .expect("unable to load kms account {arn:?}")
+                        .into()
                 }
+                file::Account::Address(address) => Account::Address(address),
             };
             solver::Config {
                 endpoint: solver_config.endpoint,

crates/driver/src/infra/config/file/mod.rs

@@ -1,7 +1,7 @@
 pub use load::load;
 use {
     crate::{domain::eth, infra, util::serialize},
-    alloy::primitives::Address,
+    alloy::{eips::BlockNumberOrTag, primitives::Address},
     number::serialization::HexOrDecimalU256,
     reqwest::Url,
     serde::{Deserialize, Deserializer, Serialize},
@@ -144,6 +144,16 @@ impl From<BlockNumber> for web3::types::BlockNumber {
     }
 }
 
+impl From<BlockNumber> for BlockNumberOrTag {
+    fn from(value: BlockNumber) -> Self {
+        match value {
+            BlockNumber::Pending => Self::Pending,
+            BlockNumber::Latest => Self::Latest,
+            BlockNumber::Earliest => Self::Earliest,
+        }
+    }
+}
+
 #[serde_as]
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "kebab-case")]
@@ -332,9 +342,9 @@ enum Account {
     PrivateKey(eth::B256),
     /// AWS KMS is used to sign transactions. Expects the key identifier.
     Kms(#[serde_as(as = "serde_with::DisplayFromStr")] Arn),
-    /// An address is used to identify the account for signing, relying on the
-    /// connected node's account management features. This can also be used to
-    /// start the driver in a dry-run mode.
+    /// Used to start the driver in the dry-run mode. This account type is
+    /// *unable* to sign transactions as alloy does not support *implicit*
+    /// node-side signing.
     Address(eth::Address),
 }