Call with state overrides (#983)

Using `eth_call` together with state overrides is pretty useful and
widely supported thing. Currently we need to use very ugly workaround in
https://github.com/cowprotocol/services to use state overrides with
`ethcontract-rs`.
In order to make everyone's lives easier it makes the most sense to make
`call_with_state_overrides` a first class citizen in `ethcontract-rs`.

- I added the `StateOverride` struct which defines the format of things
that can be overriden
- I added `call_with_state_overrides` on `MethodCallBuilder` and
`ViewCallBuilder`
- unfortunately does the `web3` crate not have any nice helper functions
for using state overrides so I implemented the call with the underlying
logic that the `web3` crate would have called

### Test Plan
I tested this by pointing the ethcontract dependency in the cowprotocol
repo to a local checkout with this patch and did a manual test to make
sure things work. Given that we are about to completely abandon this
crate I think it's fine to check in a test specific for this.

Author: MartinquaXD

ethcontract/src/contract/method.rs

@@ -2,11 +2,13 @@
 //! intended to be used directly but to be used by a contract `Instance` with
 //! [Instance::method](ethcontract::contract::Instance::method).
 
+use crate::state_overrides::StateOverrides;
 use crate::transaction::{Account, GasPrice, TransactionBuilder, TransactionResult};
 use crate::{batch::CallBatch, errors::MethodError, tokens::Tokenize};
 use ethcontract_common::abi::{Function, Token};
 use std::marker::PhantomData;
-use web3::types::{AccessList, Address, BlockId, Bytes, CallRequest, U256};
+use web3::helpers::CallFuture;
+use web3::types::{AccessList, Address, BlockId, BlockNumber, Bytes, CallRequest, U256};
 use web3::Transport;
 use web3::{api::Web3, BatchTransport};
 
@@ -152,6 +154,14 @@ impl<T: Transport, R: Tokenize> MethodBuilder<T, R> {
     pub async fn call(self) -> Result<R, MethodError> {
         self.view().call().await
     }
+
+    /// Same as [`call`] but allows to also specify state overrides with the call.
+    pub async fn call_with_state_overrides(
+        self,
+        overrides: &StateOverrides,
+    ) -> Result<R, MethodError> {
+        self.view().call_with_state_overrides(overrides).await
+    }
 }
 
 /// Data used for building a contract method call. The view method builder can't
@@ -243,6 +253,20 @@ impl<T: Transport, R: Tokenize> ViewMethodBuilder<T, R> {
         convert_response::<_, R>(future, function).await
     }
 
+    /// Same as [`call`] but also allows to specify state overrides for the call.
+    pub async fn call_with_state_overrides(
+        self,
+        overrides: &StateOverrides,
+    ) -> Result<R, MethodError> {
+        let transport = &self.m.web3.transport().clone();
+        let (function, call, block) = self.decompose();
+        let req = web3::helpers::serialize(&call);
+        let block = web3::helpers::serialize(&block.unwrap_or_else(|| BlockNumber::Latest.into()));
+        let overrides = web3::helpers::serialize(overrides);
+        let future = CallFuture::new(transport.execute("eth_call", vec![req, block, overrides]));
+        convert_response::<_, R>(future, function).await
+    }
+
     /// Adds this view method to a batch. Allows execution with other contract calls in one roundtrip
     /// The returned future only resolve once `batch` is resolved. Panics, if `batch` is dropped before
     /// executing

ethcontract/src/lib.rs

@@ -99,6 +99,7 @@ pub mod errors;
 mod int;
 pub mod log;
 pub mod secret;
+pub mod state_overrides;
 pub mod tokens;
 pub mod transaction;
 pub mod transport;

ethcontract/src/state_overrides.rs

@@ -0,0 +1,37 @@
+//! Contains data structures needed to specify
+//! state overrides for `eth_call`s.
+
+use primitive_types::{H160, H256, U256};
+use serde::Serialize;
+use std::collections::HashMap;
+use web3::types::{Bytes, U64};
+
+/// State overrides.
+pub type StateOverrides = HashMap<H160, StateOverride>;
+
+/// State override object.
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StateOverride {
+    /// Fake balance to set for the account before executing the call.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub balance: Option<U256>,
+
+    /// Fake nonce to set for the account before executing the call.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nonce: Option<U64>,
+
+    /// Fake EVM bytecode to inject into the account before executing the call.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub code: Option<Bytes>,
+
+    /// Fake key-value mapping to override **all** slots in the account storage
+    /// before executing the call.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub state: Option<HashMap<H256, H256>>,
+
+    /// Fake key-value mapping to override **individual** slots in the account
+    /// storage before executing the call.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub state_diff: Option<HashMap<H256, H256>>,
+}