Make access lists for tradable balance simulations configurable (cowprotocol#3549)

# Description
[The current
config](https://github.com/cowprotocol/services/blob/503a50b93a641d936df5767de0fb6dcf377414a7/crates/driver/src/infra/config/file/mod.rs#L23-L26)
that controls access lists feature usage for simulations doesn't affect
the tradable balance simulations. This is also important for chains that
don't support access lists(e.g. ZKSync). This PR fixes it.

## How to test
Will be tested on Lens.

Author: squadgazzz

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

@@ -46,6 +46,7 @@ pub struct Utilities {
     signature_validator: Arc<dyn SignatureValidating>,
     app_data_retriever: Option<order::app_data::AppDataRetriever>,
     liquidity_fetcher: infra::liquidity::Fetcher,
+    disable_access_list_simulation: bool,
 }
 
 impl std::fmt::Debug for Utilities {
@@ -102,6 +103,7 @@ impl DataAggregator {
         eth: infra::Ethereum,
         app_data_retriever: Option<order::app_data::AppDataRetriever>,
         liquidity_fetcher: infra::liquidity::Fetcher,
+        disable_access_list_simulation: bool,
     ) -> Self {
         let signature_validator = shared::signature_validator::validator(
             eth.web3(),
@@ -117,6 +119,7 @@ impl DataAggregator {
                 signature_validator,
                 app_data_retriever,
                 liquidity_fetcher,
+                disable_access_list_simulation,
             }),
             control: Mutex::new(ControlBlock {
                 auction: auction::Id(0),
@@ -204,8 +207,12 @@ impl Utilities {
             |(trader, token, source, interactions)| {
                 let token_contract = tokens.get(&token);
                 let token_contract = token_contract.expect("all tokens were created earlier");
-                let fetch_balance =
-                    token_contract.tradable_balance(trader.into(), source, interactions);
+                let fetch_balance = token_contract.tradable_balance(
+                    trader.into(),
+                    source,
+                    interactions,
+                    self.disable_access_list_simulation,
+                );
 
                 async move {
                     let balance = fetch_balance.await;

crates/driver/src/infra/api/mod.rs

@@ -46,6 +46,7 @@ impl Api {
         shutdown: impl Future<Output = ()> + Send + 'static,
         order_priority_strategies: Vec<OrderPriorityStrategy>,
         app_data_retriever: Option<AppDataRetriever>,
+        disable_access_list_simulation: bool,
     ) -> Result<(), hyper::Error> {
         // Add middleware.
         let mut app = axum::Router::new().layer(tower::ServiceBuilder::new().layer(
@@ -57,6 +58,7 @@ impl Api {
             self.eth.clone(),
             app_data_retriever.clone(),
             self.liquidity.clone(),
+            disable_access_list_simulation,
         ));
 
         let order_sorting_strategies =

crates/driver/src/infra/blockchain/token.rs

@@ -87,12 +87,18 @@ impl Erc20 {
         trader: eth::Address,
         source: order::SellTokenBalance,
         interactions: &[eth::Interaction],
+        disable_access_list_simulation: bool,
     ) -> Result<eth::TokenAmount, Error> {
         if interactions.is_empty() {
             self.tradable_balance_simple(trader, source).await
         } else {
-            self.tradable_balance_simulated(trader, source, interactions)
-                .await
+            self.tradable_balance_simulated(
+                trader,
+                source,
+                interactions,
+                disable_access_list_simulation,
+            )
+            .await
         }
     }
 
@@ -104,6 +110,7 @@ impl Erc20 {
         trader: eth::Address,
         source: order::SellTokenBalance,
         interactions: &[eth::Interaction],
+        disable_access_lists: bool,
     ) -> Result<eth::TokenAmount, Error> {
         let balance_helper = self.ethereum.contracts().balance_helper();
         let mut method = balance_helper.balance(
@@ -127,18 +134,21 @@ impl Erc20 {
                 })
                 .collect(),
         );
-        // Create the access list for the balance simulation
-        let access_list_call = contracts::storage_accessible::call(
-            method.tx.to.unwrap(),
-            contracts::bytecode!(contracts::support::Balances),
-            method.tx.data.clone().unwrap(),
-        );
-        let access_list = self
-            .ethereum
-            .create_access_list(access_list_call)
-            .await
-            .ok();
-        method.tx.access_list = access_list.map(Into::into);
+        // Create the access list for the balance simulation only if they are enabled
+        // system-wide.
+        if !disable_access_lists {
+            let access_list_call = contracts::storage_accessible::call(
+                method.tx.to.unwrap(),
+                contracts::bytecode!(contracts::support::Balances),
+                method.tx.data.clone().unwrap(),
+            );
+            let access_list = self
+                .ethereum
+                .create_access_list(access_list_call)
+                .await
+                .ok();
+            method.tx.access_list = access_list.map(Into::into);
+        }
         let (_, _, effective_balance, can_transfer) = contracts::storage_accessible::simulate(
             contracts::bytecode!(contracts::support::Balances),
             method,

crates/driver/src/run.rs

@@ -96,6 +96,7 @@ async fn run_with(args: cli::Args, addr_sender: Option<oneshot::Sender<SocketAdd
         },
         config.order_priority_strategies,
         app_data_retriever,
+        config.disable_access_list_simulation,
     );
 
     futures::pin_mut!(serve);