Make driver access list fetch optional

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

@@ -1,5 +1,10 @@
 use {
-    super::{Error, Solution, encoding, trade::ClearingPrices},
+    super::{
+        Error,
+        Solution,
+        encoding,
+        trade::{self, ClearingPrices},
+    },
     crate::{
         domain::{
             self,
@@ -15,7 +20,7 @@ use {
     alloy::primitives::U256,
     eth_domain_types as eth,
     futures::future::try_join_all,
-    simulator::Simulator,
+    simulator::{self, Simulator},
     std::collections::{BTreeSet, HashMap, HashSet},
     tracing::instrument,
 };
@@ -148,23 +153,19 @@ impl Settlement {
         // The solution is to do access list estimation in two steps: first, simulate
         // moving 1 wei into every smart contract to get a partial access list, and then
         // use that partial access list to calculate the final access list.
-        let partial_access_lists = try_join_all(solution.user_trades().map(|trade| async {
-            if !trade.order().buys_eth() || !trade.order().pays_to_contract(eth).await? {
-                return Ok(Default::default());
-            }
-            let tx = eth::Tx {
-                from: solution.solver().address(),
-                to: trade.order().receiver(),
-                value: 1.into(),
-                input: Default::default(),
-                access_list: Default::default(),
-            };
-            Result::<_, Error>::Ok(simulator.access_list(&tx).await?)
-        }))
-        .await?;
-        let partial_access_list = partial_access_lists
-            .into_iter()
-            .fold(eth::AccessList::default(), |acc, list| acc.merge(list));
+        //
+        // A non-empty partial access list also signals that at least one trade
+        // strictly requires an access list. Conversely, an empty partial list
+        // means the access list is only a gas optimization for this settlement,
+        // so a fetch failure below can be tolerated.
+        let partial_access_list = try_join_all(
+            solution
+                .user_trades()
+                .map(|trade| partial_access_list_for(trade, &solution, eth, simulator)),
+        )
+        .await?
+        .into_iter()
+        .fold(eth::AccessList::default(), |acc, list| acc.merge(list));
 
         // Simulate the settlement and get the access list and gas.
         let (access_list, gas) = Self::simulate(
@@ -231,8 +232,25 @@ impl Settlement {
         let tx = tx.set_access_list(partial_access_list.to_owned());
 
         // Simulate the full access list, passing the partial access
-        // list into the simulation.
-        let access_list = simulator.access_list(&tx).await?;
+        // list into the simulation. If the partial list is empty, no trade
+        // strictly requires the access-list workaround, so a non-revert
+        // failure (transport, deserialization, ...) shouldn't abort the
+        // settlement: we can't reason about the outcome, but the on-chain
+        // tx would still succeed without the access list. Revert errors are
+        // propagated either way since they signal a real problem with the
+        // settlement.
+        let access_list = match simulator.access_list(&tx).await {
+            Ok(list) => list,
+            Err(simulator::Error::Other(err)) if partial_access_list.is_empty() => {
+                tracing::warn!(
+                    ?err,
+                    "access list estimation failed; continuing without it (no ETH->contract \
+                     trades)"
+                );
+                partial_access_list.clone()
+            }
+            Err(err) => return Err(err.into()),
+        };
         let tx = tx.set_access_list(access_list.clone());
 
         // Simulate the settlement using the full access list and get the gas used.
@@ -353,6 +371,28 @@ impl Settlement {
     }
 }
 
+/// Return the partial access list entries needed to forward 1 wei of ETH to a
+/// smart-contract receiver. Returns an empty access list when the trade does
+/// not trigger the gas-limit workaround (non-ETH buy or EOA receiver).
+async fn partial_access_list_for(
+    trade: &trade::Fulfillment,
+    solution: &Solution,
+    eth: &Ethereum,
+    simulator: &Simulator,
+) -> Result<eth::AccessList, Error> {
+    if !trade.order().buys_eth() || !trade.order().pays_to_contract(eth).await? {
+        return Ok(eth::AccessList::default());
+    }
+    let tx = eth::Tx {
+        from: solution.solver().address(),
+        to: trade.order().receiver(),
+        value: 1.into(),
+        input: Default::default(),
+        access_list: Default::default(),
+    };
+    Ok(simulator.access_list(&tx).await?)
+}
+
 /// Should the interactions be internalized?
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Internalization {