Add Support for Specifying Access Lists (#19)

* Add Support for Specifying Access Lists

* Document API Changes and Add E2E Test

README.md

@@ -232,11 +232,17 @@ export type SimulationRequest = {
  data?: string;
  gasLimit: number;
  value: string;
+ accessList?: AccessListItem[];
  blockNumber?: number; // if not specified, latest used,
  stateOverrides?: Record<string, StateOverride>;
  formatTrace?: boolean;
 };
 
+export type AccessListItem = {
+ address: string;
+ storageKeys: string[];
+};
+
 export type StateOverride = {
  balance?: string;
  nonce?: number;

src/evm.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use ethers::abi::{Address, Hash, Uint};
 use ethers::core::types::Log;
+use ethers::types::transaction::eip2930::AccessList;
 use ethers::types::Bytes;
 use foundry_config::Chain;
 use foundry_evm::executor::{fork::CreateFork, Executor};
@@ -18,6 +19,16 @@ use revm::DatabaseCommit;
 use crate::errors::{EvmError, OverrideError};
 use crate::simulation::CallTrace;
 
+#[derive(Debug, Clone)]
+pub struct CallRawRequest {
+ pub from: Address,
+ pub to: Address,
+ pub value: Option<Uint>,
+ pub data: Option<Bytes>,
+ pub access_list: Option<AccessList>,
+ pub format_trace: bool,
+}
+
 #[derive(Debug, Clone)]
 pub struct CallRawResult {
  pub gas_used: u64,
@@ -119,28 +130,22 @@ impl Evm {
  }
  }
 
- pub async fn call_raw(
- &mut self,
- from: Address,
- to: Address,
- value: Option<Uint>,
- data: Option<Bytes>,
- format_trace: bool,
- ) -> Result<CallRawResult, EvmError> {
+ pub async fn call_raw(&mut self, call: CallRawRequest) -> Result<CallRawResult, EvmError> {
+ self.set_access_list(call.access_list);
  let res = self
  .executor
  .call_raw(
- from,
- to,
- data.unwrap_or_default().0,
- value.unwrap_or_default(),
+ call.from,
+ call.to,
+ call.data.unwrap_or_default().0,
+ call.value.unwrap_or_default(),
  )
  .map_err(|err| {
  dbg!(&err);
  EvmError(err)
  })?;
 
- let formatted_trace = if format_trace {
+ let formatted_trace = if call.format_trace {
  let mut output = String::new();
  for trace in &mut res.traces.clone() {
  if let Some(identifier) = &mut self.etherscan_identifier {
@@ -218,28 +223,25 @@ impl Evm {
 
  pub async fn call_raw_committing(
  &mut self,
- from: Address,
- to: Address,
- value: Option<Uint>,
- data: Option<Bytes>,
+ call: CallRawRequest,
  gas_limit: u64,
- format_trace: bool,
  ) -> Result<CallRawResult, EvmError> {
  self.executor.set_gas_limit(gas_limit.into());
+ self.set_access_list(call.access_list);
  let res = self
  .executor
  .call_raw_committing(
- from,
- to,
- data.unwrap_or_default().0,
- value.unwrap_or_default(),
+ call.from,
+ call.to,
+ call.data.unwrap_or_default().0,
+ call.value.unwrap_or_default(),
  )
  .map_err(|err| {
  dbg!(&err);
  EvmError(err)
  })?;
 
- let formatted_trace = if format_trace {
+ let formatted_trace = if call.format_trace {
  let mut output = String::new();
  for trace in &mut res.traces.clone() {
  if let Some(identifier) = &mut self.etherscan_identifier {
@@ -286,4 +288,21 @@ impl Evm {
  pub fn get_chain_id(&self) -> Uint {
  self.executor.env().cfg.chain_id.into()
  }
+
+ fn set_access_list(&mut self, access_list: Option<AccessList>) {
+ self.executor.env_mut().tx.access_list = access_list
+ .unwrap_or_default()
+ .0
+ .into_iter()
+ .map(|item| {
+ (
+ h160_to_b160(item.address),
+ item.storage_keys
+ .into_iter()
+ .map(|key| u256_to_ru256(Uint::from_big_endian(key.as_bytes())))
+ .collect(),
+ )
+ })
+ .collect();
+ }
 }

src/simulation.rs

@@ -5,6 +5,7 @@ use std::sync::Arc;
 use dashmap::mapref::one::RefMut;
 use ethers::abi::{Address, Hash, Uint};
 use ethers::core::types::Log;
+use ethers::types::transaction::eip2930::AccessList;
 use ethers::types::Bytes;
 use foundry_evm::CallKind;
 use revm::interpreter::InstructionResult;
@@ -22,7 +23,7 @@ use crate::evm::StorageOverride;
 use crate::SharedSimulationState;
 
 use super::config::Config;
-use super::evm::Evm;
+use super::evm::{CallRawRequest, Evm};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -33,6 +34,7 @@ pub struct SimulationRequest {
  pub data: Option<Bytes>,
  pub gas_limit: u64,
  pub value: Option<PermissiveUint>,
+ pub access_list: Option<AccessList>,
  pub block_number: Option<u64>,
  pub state_overrides: Option<HashMap<Address, StateOverride>>,
  pub format_trace: Option<bool>,
@@ -189,25 +191,18 @@ async fn run(
  )?;
  }
 
+ let call = CallRawRequest {
+ from: transaction.from,
+ to: transaction.to,
+ value: transaction.value.map(Uint::from),
+ data: transaction.data,
+ access_list: transaction.access_list,
+ format_trace: transaction.format_trace.unwrap_or_default(),
+ };
  let result = if commit {
- evm.call_raw_committing(
- transaction.from,
- transaction.to,
- transaction.value.map(Uint::from),
- transaction.data,
- transaction.gas_limit,
- transaction.format_trace.unwrap_or_default(),
- )
- .await?
+ evm.call_raw_committing(call, transaction.gas_limit).await?
  } else {
- evm.call_raw(
- transaction.from,
- transaction.to,
- transaction.value.map(Uint::from),
- transaction.data,
- transaction.format_trace.unwrap_or_default(),
- )
- .await?
+ evm.call_raw(call).await?
  };
 
  Ok(SimulationResponse {

tests/api.rs

@@ -154,6 +154,58 @@ async fn post_simulate_zerox_swap() {
  assert!(body.success);
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn post_simulate_access_lists() {
+ let simulate_gas_used = |access_list: serde_json::Value| async move {
+ let filter = filter();
+
+ let json = serde_json::json!({
+ "chainId": 1,
+ "from": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
+ "to": "0x0000000000000000000000000000000000000000",
+ "gasLimit": 50000,
+ "accessList": access_list,
+ });
+
+ let res = warp::test::request()
+ .method("POST")
+ .path("/simulate")
+ .json(&json)
+ .reply(&filter)
+ .await;
+
+ assert_eq!(res.status(), 200);
+
+ serde_json::from_slice::<SimulationResponse>(res.body())
+ .unwrap()
+ .gas_used
+ };
+
+ const TX_COST: u64 = 21_000;
+ const ADDRESS_COST: u64 = 2400;
+ const STORAGE_KEY_COST: u64 = 1900;
+
+ assert_eq!(simulate_gas_used(serde_json::json!([])).await, TX_COST);
+ assert_eq!(
+ simulate_gas_used(serde_json::json!([
+ {
+ "address": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+ "storageKeys": [],
+ },
+ {
+ "address": "0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB",
+ "storageKeys": [
+ "0xfca351f4d96129454cfc8ef7930b638ac71fea35eb69ee3b8d959496beb04a33",
+ "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "0x0000000000000000000000000000000000000000000000000000000000000001",
+ ],
+ },
+ ]))
+ .await,
+ TX_COST + ADDRESS_COST * 2 + STORAGE_KEY_COST * 3,
+ );
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn post_simulate_state_overrides() {
  let filter = filter();