feat: implement state overrides for EVM calls

common/src/network_spec.rs

@@ -1,6 +1,11 @@
 use std::{collections::HashMap, fmt::Debug, sync::Arc};
 
-use alloy::{eips::BlockId, network::Network, primitives::Address, rpc::types::Log};
+use alloy::{
+    eips::BlockId,
+    network::Network,
+    primitives::Address,
+    rpc::types::{state::StateOverride, Log},
+};
 use async_trait::async_trait;
 use revm::context::result::ExecutionResult;
 
@@ -27,5 +32,6 @@ pub trait NetworkSpec: Network {
         chain_id: u64,
         fork_schedule: ForkSchedule,
         block_id: BlockId,
+        state_overrides: Option<StateOverride>,
     ) -> Result<(ExecutionResult<Self::HaltReason>, HashMap<Address, Account>), EvmError>;
 }

core/src/client/api.rs

@@ -1,7 +1,10 @@
 use alloy::{
     eips::BlockId,
     primitives::{Address, Bytes, B256, U256},
-    rpc::types::{AccessListResult, EIP1186AccountProofResponse, Filter, Log, SyncStatus},
+    rpc::types::{
+        state::StateOverride, AccessListResult, EIP1186AccountProofResponse, Filter, Log,
+        SyncStatus,
+    },
 };
 use async_trait::async_trait;
 use eyre::Result;
@@ -53,12 +56,23 @@ pub trait HeliosApi<N: NetworkSpec>: Send + Sync + 'static {
         block_id: BlockId,
     ) -> Result<Option<Vec<N::ReceiptResponse>>>;
     // evm
-    async fn call(&self, tx: &N::TransactionRequest, block_id: BlockId) -> Result<Bytes>;
-    async fn estimate_gas(&self, tx: &N::TransactionRequest, block_id: BlockId) -> Result<u64>;
+    async fn call(
+        &self,
+        tx: &N::TransactionRequest,
+        block_id: BlockId,
+        state_overrides: Option<StateOverride>,
+    ) -> Result<Bytes>;
+    async fn estimate_gas(
+        &self,
+        tx: &N::TransactionRequest,
+        block_id: BlockId,
+        state_overrides: Option<StateOverride>,
+    ) -> Result<u64>;
     async fn create_access_list(
         &self,
         tx: &N::TransactionRequest,
         block_id: BlockId,
+        state_overrides: Option<StateOverride>,
     ) -> Result<AccessListResult>;
     // logs
     async fn get_logs(&self, filter: &Filter) -> Result<Vec<Log>>;

core/src/client/node.rs

@@ -6,8 +6,8 @@ use alloy::eips::{BlockId, BlockNumberOrTag};
 use alloy::network::BlockResponse;
 use alloy::primitives::{Address, Bytes, B256, U256};
 use alloy::rpc::types::{
-    AccessListItem, AccessListResult, EIP1186AccountProofResponse, EIP1186StorageProof, Filter,
-    Log, SyncInfo, SyncStatus,
+    state::StateOverride, AccessListItem, AccessListResult, EIP1186AccountProofResponse,
+    EIP1186StorageProof, Filter, Log, SyncInfo, SyncStatus,
 };
 use async_trait::async_trait;
 use eyre::{eyre, Result};
@@ -172,7 +172,12 @@ impl<N: NetworkSpec, C: Consensus<N::BlockResponse>, E: ExecutionProvider<N>> He
         self.consensus.wait_synced().await
     }
 
-    async fn call(&self, tx: &N::TransactionRequest, block_id: BlockId) -> Result<Bytes> {
+    async fn call(
+        &self,
+        tx: &N::TransactionRequest,
+        block_id: BlockId,
+        state_overrides: Option<StateOverride>,
+    ) -> Result<Bytes> {
         self.check_blocktag_age(&block_id).await?;
         let (result, ..) = N::transact(
             tx,
@@ -181,6 +186,7 @@ impl<N: NetworkSpec, C: Consensus<N::BlockResponse>, E: ExecutionProvider<N>> He
             self.get_chain_id().await,
             self.fork_schedule,
             block_id,
+            state_overrides,
         )
         .await?;
 
@@ -195,7 +201,12 @@ impl<N: NetworkSpec, C: Consensus<N::BlockResponse>, E: ExecutionProvider<N>> He
         Ok(res)
     }
 
-    async fn estimate_gas(&self, tx: &N::TransactionRequest, block_id: BlockId) -> Result<u64> {
+    async fn estimate_gas(
+        &self,
+        tx: &N::TransactionRequest,
+        block_id: BlockId,
+        state_overrides: Option<StateOverride>,
+    ) -> Result<u64> {
         self.check_blocktag_age(&block_id).await?;
 
         let (result, ..) = N::transact(
@@ -205,6 +216,7 @@ impl<N: NetworkSpec, C: Consensus<N::BlockResponse>, E: ExecutionProvider<N>> He
             self.get_chain_id().await,
             self.fork_schedule,
             block_id,
+            state_overrides,
         )
         .await?;
 
@@ -215,6 +227,7 @@ impl<N: NetworkSpec, C: Consensus<N::BlockResponse>, E: ExecutionProvider<N>> He
         &self,
         tx: &N::TransactionRequest,
         block: BlockId,
+        state_overrides: Option<StateOverride>,
     ) -> Result<AccessListResult> {
         self.check_blocktag_age(&block).await?;
 
@@ -225,6 +238,7 @@ impl<N: NetworkSpec, C: Consensus<N::BlockResponse>, E: ExecutionProvider<N>> He
             self.get_chain_id().await,
             self.fork_schedule,
             block,
+            state_overrides,
         )
         .await?;
 

core/src/jsonrpc/mod.rs

@@ -7,7 +7,8 @@ use alloy::network::{BlockResponse, ReceiptResponse, TransactionResponse};
 use alloy::primitives::{Address, Bytes, B256, U256, U64};
 use alloy::rpc::json_rpc::RpcObject;
 use alloy::rpc::types::{
-    AccessListResult, EIP1186AccountProofResponse, Filter, FilterChanges, Log, SyncStatus,
+    state::StateOverride, AccessListResult, EIP1186AccountProofResponse, Filter, FilterChanges,
+    Log, SyncStatus,
 };
 use eyre::{eyre, Result};
 use jsonrpsee::{
@@ -84,14 +85,25 @@ trait EthRpc<
     #[method(name = "getCode")]
     async fn get_code(&self, address: Address, block: BlockId) -> Result<Bytes, ErrorObjectOwned>;
     #[method(name = "call")]
-    async fn call(&self, tx: TXR, block: BlockId) -> Result<Bytes, ErrorObjectOwned>;
+    async fn call(
+        &self,
+        tx: TXR,
+        block: BlockId,
+        state_overrides: Option<StateOverride>,
+    ) -> Result<Bytes, ErrorObjectOwned>;
     #[method(name = "estimateGas")]
-    async fn estimate_gas(&self, tx: TXR, block: BlockId) -> Result<U64, ErrorObjectOwned>;
+    async fn estimate_gas(
+        &self,
+        tx: TXR,
+        block: BlockId,
+        state_overrides: Option<StateOverride>,
+    ) -> Result<U64, ErrorObjectOwned>;
     #[method(name = "createAccessList")]
     async fn create_access_list(
         &self,
         tx: TXR,
         block: BlockId,
+        state_overrides: Option<StateOverride>,
     ) -> Result<AccessListResult, ErrorObjectOwned>;
     #[method(name = "chainId")]
     async fn chain_id(&self) -> Result<U64, ErrorObjectOwned>;
@@ -238,16 +250,22 @@ impl<N: NetworkSpec>
         &self,
         tx: N::TransactionRequest,
         block: BlockId,
+        state_overrides: Option<StateOverride>,
     ) -> Result<Bytes, ErrorObjectOwned> {
-        convert_err(self.client.call(&tx, block).await)
+        convert_err(self.client.call(&tx, block, state_overrides).await)
     }
 
     async fn estimate_gas(
         &self,
         tx: N::TransactionRequest,
         block: BlockId,
+        state_overrides: Option<StateOverride>,
     ) -> Result<U64, ErrorObjectOwned> {
-        let res = self.client.estimate_gas(&tx, block).await.map(U64::from);
+        let res = self
+            .client
+            .estimate_gas(&tx, block, state_overrides)
+            .await
+            .map(U64::from);
 
         convert_err(res)
     }
@@ -256,8 +274,13 @@ impl<N: NetworkSpec>
         &self,
         tx: N::TransactionRequest,
         block: BlockId,
+        state_overrides: Option<StateOverride>,
     ) -> Result<AccessListResult, ErrorObjectOwned> {
-        convert_err(self.client.create_access_list(&tx, block).await)
+        convert_err(
+            self.client
+                .create_access_list(&tx, block, state_overrides)
+                .await,
+        )
     }
 
     async fn chain_id(&self) -> Result<U64, ErrorObjectOwned> {

ethereum/src/evm.rs

@@ -4,7 +4,7 @@ use alloy::{
     consensus::{BlockHeader, TxType},
     eips::BlockId,
     network::TransactionBuilder,
-    rpc::types::{Block, Header, Transaction, TransactionRequest},
+    rpc::types::{state::StateOverride, Block, Header, Transaction, TransactionRequest},
 };
 use eyre::Result;
 use revm::{
@@ -53,8 +53,9 @@ impl<E: ExecutionProvider<Ethereum>> EthereumEvm<E> {
         &mut self,
         tx: &TransactionRequest,
         validate_tx: bool,
+        state_overrides: Option<StateOverride>,
     ) -> Result<(ExecutionResult, HashMap<Address, Account>), EvmError> {
-        let mut db = ProofDB::new(self.block_id, self.execution.clone());
+        let mut db = ProofDB::new(self.block_id, self.execution.clone(), state_overrides);
         _ = db.state.prefetch_state(tx, validate_tx).await;
 
         // Track iterations for debugging

ethereum/src/spec.rs

@@ -8,7 +8,7 @@ use alloy::{
     eips::{BlockId, Encodable2718},
     network::{BuildResult, Network, NetworkWallet, TransactionBuilder, TransactionBuilderError},
     primitives::{Address, Bytes, ChainId, TxKind, U256},
-    rpc::types::{AccessList, Log, TransactionRequest},
+    rpc::types::{state::StateOverride, AccessList, Log, TransactionRequest},
 };
 use async_trait::async_trait;
 use revm::context::result::{ExecutionResult, HaltReason};
@@ -104,10 +104,11 @@ impl NetworkSpec for Ethereum {
         chain_id: u64,
         fork_schedule: ForkSchedule,
         block_id: BlockId,
+        state_overrides: Option<StateOverride>,
     ) -> Result<(ExecutionResult, HashMap<Address, Account>), EvmError> {
         let mut evm = EthereumEvm::new(execution, chain_id, fork_schedule, block_id);
 
-        evm.transact_inner(tx, validate_tx).await
+        evm.transact_inner(tx, validate_tx, state_overrides).await
     }
 }
 

examples/call.rs

@@ -65,7 +65,9 @@ async fn main() -> eyre::Result<()> {
         ..Default::default()
     };
 
-    let result = client.call(&tx, BlockNumberOrTag::Latest.into()).await?;
+    let result = client
+        .call(&tx, BlockNumberOrTag::Latest.into(), None)
+        .await?;
     info!("[HELIOS] DAI total supply: {:?}", result);
 
     Ok(())

helios-ts/lib.ts

@@ -211,13 +211,13 @@ export class HeliosProvider {
         return this.#client.get_proof(req.params[0], req.params[1], req.params[2]);
       }
       case "eth_call": {
-        return this.#client.call(req.params[0], req.params[1]);
+        return this.#client.call(req.params[0], req.params[1], req.params[2]);
       }
       case "eth_estimateGas": {
-        return this.#client.estimate_gas(req.params[0], req.params[1]);
+        return this.#client.estimate_gas(req.params[0], req.params[1], req.params[2]);
       }
       case "eth_createAccessList": {
-        return this.#client.create_access_list(req.params[0], req.params[1]);
+        return this.#client.create_access_list(req.params[0], req.params[1], req.params[2]);
       }
       case "eth_gasPrice": {
         return this.#client.gas_price();

helios-ts/src/ethereum.rs

@@ -7,7 +7,7 @@ use std::str::FromStr;
 use alloy::eips::{BlockId, BlockNumberOrTag};
 use alloy::hex::{self, FromHex};
 use alloy::primitives::{Address, B256, U256};
-use alloy::rpc::types::{Filter, TransactionRequest};
+use alloy::rpc::types::{state::StateOverride, Filter, TransactionRequest};
 use eyre::Result;
 use url::Url;
 use wasm_bindgen::prelude::*;
@@ -321,29 +321,50 @@ impl EthereumClient {
     }
 
     #[wasm_bindgen]
-    pub async fn call(&self, opts: JsValue, block: JsValue) -> Result<String, JsError> {
+    pub async fn call(
+        &self,
+        opts: JsValue,
+        block: JsValue,
+        state_overrides: JsValue,
+    ) -> Result<String, JsError> {
         let opts: TransactionRequest = serde_wasm_bindgen::from_value(opts)?;
         let block: BlockId = serde_wasm_bindgen::from_value(block)?;
-        let res = map_err(self.inner.call(&opts, block).await)?;
+        let state_overrides: Option<StateOverride> =
+            serde_wasm_bindgen::from_value(state_overrides)?;
+        let res = map_err(self.inner.call(&opts, block, state_overrides).await)?;
         Ok(format!("0x{}", hex::encode(res)))
     }
 
     #[wasm_bindgen]
-    pub async fn estimate_gas(&self, opts: JsValue, block: JsValue) -> Result<u32, JsError> {
+    pub async fn estimate_gas(
+        &self,
+        opts: JsValue,
+        block: JsValue,
+        state_overrides: JsValue,
+    ) -> Result<u32, JsError> {
         let opts: TransactionRequest = serde_wasm_bindgen::from_value(opts)?;
         let block: BlockId = serde_wasm_bindgen::from_value(block)?;
-        Ok(map_err(self.inner.estimate_gas(&opts, block).await)? as u32)
+        let state_overrides: Option<StateOverride> =
+            serde_wasm_bindgen::from_value(state_overrides)?;
+        Ok(map_err(self.inner.estimate_gas(&opts, block, state_overrides).await)? as u32)
     }
 
     #[wasm_bindgen]
     pub async fn create_access_list(
         &self,
         opts: JsValue,
         block: JsValue,
+        state_overrides: JsValue,
     ) -> Result<JsValue, JsError> {
         let opts: TransactionRequest = serde_wasm_bindgen::from_value(opts)?;
         let block: BlockId = serde_wasm_bindgen::from_value(block)?;
-        let access_list_result = map_err(self.inner.create_access_list(&opts, block).await)?;
+        let state_overrides: Option<StateOverride> =
+            serde_wasm_bindgen::from_value(state_overrides)?;
+        let access_list_result = map_err(
+            self.inner
+                .create_access_list(&opts, block, state_overrides)
+                .await,
+        )?;
         Ok(serde_wasm_bindgen::to_value(&access_list_result)?)
     }