anvil/eth/backend/
cheats.rs

1//! Support for "cheat codes" / bypass functions
2
3use alloy_evm::precompiles::{Precompile, PrecompileInput};
4use alloy_primitives::{
5    Address, B256, Bytes,
6    map::{AddressHashSet, foldhash::HashMap},
7};
8use parking_lot::RwLock;
9use revm::precompile::{
10    PrecompileHalt, PrecompileId, PrecompileOutput, PrecompileResult, call_eth_precompile,
11    secp256k1::ec_recover_run, utilities::right_pad,
12};
13use std::{borrow::Cow, sync::Arc};
14
15/// ID for the [`CheatEcrecover::precompile_id`] precompile.
16static PRECOMPILE_ID_CHEAT_ECRECOVER: PrecompileId =
17    PrecompileId::Custom(Cow::Borrowed("cheat_ecrecover"));
18
19/// Manages user modifications that may affect the node's behavior
20///
21/// Contains the state of executed, non-eth standard cheat code RPC
22#[derive(Clone, Debug, Default)]
23pub struct CheatsManager {
24    /// shareable state
25    state: Arc<RwLock<CheatsState>>,
26}
27
28impl CheatsManager {
29    /// Sets the account to impersonate
30    ///
31    /// Returns `true` if the account is already impersonated
32    pub fn impersonate(&self, addr: Address) -> bool {
33        trace!(target: "cheats", %addr, "start impersonating");
34        // When somebody **explicitly** impersonates an account we need to store it so we are able
35        // to return it from `eth_accounts`. That's why we do not simply call `is_impersonated()`
36        // which does not check that list when auto impersonation is enabled.
37        !self.state.write().impersonated_accounts.insert(addr)
38    }
39
40    /// Removes the account that from the impersonated set
41    pub fn stop_impersonating(&self, addr: &Address) {
42        trace!(target: "cheats", %addr, "stop impersonating");
43        self.state.write().impersonated_accounts.remove(addr);
44    }
45
46    /// Returns true if the `addr` is currently impersonated
47    pub fn is_impersonated(&self, addr: Address) -> bool {
48        if self.auto_impersonate_accounts() {
49            true
50        } else {
51            self.state.read().impersonated_accounts.contains(&addr)
52        }
53    }
54
55    /// Returns true is auto impersonation is enabled
56    pub fn auto_impersonate_accounts(&self) -> bool {
57        self.state.read().auto_impersonate_accounts
58    }
59
60    /// Sets the auto impersonation flag which if set to true will make the `is_impersonated`
61    /// function always return true
62    pub fn set_auto_impersonate_account(&self, enabled: bool) {
63        trace!(target: "cheats", "Auto impersonation set to {:?}", enabled);
64        self.state.write().auto_impersonate_accounts = enabled
65    }
66
67    /// Returns all accounts that are currently being impersonated.
68    pub fn impersonated_accounts(&self) -> AddressHashSet {
69        self.state.read().impersonated_accounts.clone()
70    }
71
72    /// Registers an override so that `ecrecover(signature)` returns `addr`.
73    pub fn add_recover_override(&self, sig: Bytes, addr: Address) {
74        self.state.write().signature_overrides.insert(sig, addr);
75    }
76
77    /// If an override exists for `sig`, returns the address; otherwise `None`.
78    pub fn get_recover_override(&self, sig: &Bytes) -> Option<Address> {
79        self.state.read().signature_overrides.get(sig).copied()
80    }
81
82    /// Returns true if any ecrecover overrides have been registered.
83    pub fn has_recover_overrides(&self) -> bool {
84        !self.state.read().signature_overrides.is_empty()
85    }
86
87    /// Sets the `prevrandao` value to use for the next mined block.
88    ///
89    /// This is a one-shot override that is consumed by the next block and applies to that block
90    /// only.
91    pub fn set_next_block_prevrandao(&self, prevrandao: B256) {
92        trace!(target: "cheats", %prevrandao, "set next block prevrandao");
93        let mut state = self.state.write();
94        state.prevrandao_generation = state.prevrandao_generation.wrapping_add(1);
95        state.next_block_prevrandao = Some(prevrandao);
96    }
97
98    /// Prepares the manually set `prevrandao` without consuming it.
99    pub(crate) fn prepare_next_block_prevrandao(&self) -> Option<PendingPrevrandao> {
100        let state = self.state.read();
101        state
102            .next_block_prevrandao
103            .map(|value| PendingPrevrandao { value, generation: state.prevrandao_generation })
104    }
105
106    /// Takes the manually set `prevrandao` value for forced replay mining.
107    pub fn take_next_block_prevrandao(&self) -> Option<B256> {
108        let mut state = self.state.write();
109        state.prevrandao_generation = state.prevrandao_generation.wrapping_add(1);
110        state.next_block_prevrandao.take()
111    }
112
113    /// Consumes a `prevrandao` override after the candidate using it was committed.
114    pub(crate) fn consume_next_block_prevrandao(&self, pending: PendingPrevrandao) {
115        let mut state = self.state.write();
116        if state.prevrandao_generation == pending.generation {
117            state.next_block_prevrandao.take();
118        }
119    }
120
121    /// Clears any manually set `prevrandao` value for the next block.
122    ///
123    /// Used on reset/revert so a set-but-unmined override does not leak into a later block,
124    /// mirroring how the next-block timestamp override is cleared by `TimeManager::reset`.
125    pub fn clear_next_block_prevrandao(&self) {
126        let mut state = self.state.write();
127        state.prevrandao_generation = state.prevrandao_generation.wrapping_add(1);
128        state.next_block_prevrandao.take();
129    }
130}
131
132/// Container type for all the state variables
133#[derive(Clone, Debug, Default)]
134pub struct CheatsState {
135    /// All accounts that are currently impersonated
136    pub impersonated_accounts: AddressHashSet,
137    /// If set to true will make the `is_impersonated` function always return true
138    pub auto_impersonate_accounts: bool,
139    /// Overrides for ecrecover: Signature => Address
140    pub signature_overrides: HashMap<Bytes, Address>,
141    /// The `prevrandao` value to use for the next mined block, if manually set via
142    /// `anvil_setNextBlockPrevRandao`.
143    pub next_block_prevrandao: Option<B256>,
144    /// Generation of the most recently installed `prevrandao` override.
145    prevrandao_generation: u64,
146}
147
148/// A `prevrandao` override reserved by a candidate block.
149#[derive(Clone, Copy, Debug)]
150pub(crate) struct PendingPrevrandao {
151    pub(crate) value: B256,
152    generation: u64,
153}
154
155impl CheatEcrecover {
156    pub const fn new(cheats: Arc<CheatsManager>) -> Self {
157        Self { cheats }
158    }
159}
160
161impl Precompile for CheatEcrecover {
162    fn call(&self, input: PrecompileInput<'_>) -> PrecompileResult {
163        if !self.cheats.has_recover_overrides() {
164            return Ok(call_eth_precompile(ec_recover_run, input.data, input.gas, input.reservoir));
165        }
166
167        const ECRECOVER_BASE: u64 = 3_000;
168        if input.gas < ECRECOVER_BASE {
169            return Ok(PrecompileOutput::halt(PrecompileHalt::OutOfGas, input.reservoir));
170        }
171        let padded = right_pad::<128>(input.data);
172        let v = padded[63];
173        let mut sig_bytes = [0u8; 65];
174        sig_bytes[..64].copy_from_slice(&padded[64..128]);
175        sig_bytes[64] = v;
176        let sig_bytes_wrapped = Bytes::copy_from_slice(&sig_bytes);
177        if let Some(addr) = self.cheats.get_recover_override(&sig_bytes_wrapped) {
178            let mut out = [0u8; 32];
179            out[12..].copy_from_slice(addr.as_slice());
180            return Ok(PrecompileOutput::new(
181                ECRECOVER_BASE,
182                Bytes::copy_from_slice(&out),
183                input.reservoir,
184            ));
185        }
186        Ok(call_eth_precompile(ec_recover_run, input.data, input.gas, input.reservoir))
187    }
188
189    fn precompile_id(&self) -> &PrecompileId {
190        &PRECOMPILE_ID_CHEAT_ECRECOVER
191    }
192
193    fn supports_caching(&self) -> bool {
194        false
195    }
196}
197
198/// A custom ecrecover precompile that supports cheat-based signature overrides.
199#[derive(Clone, Debug)]
200pub struct CheatEcrecover {
201    cheats: Arc<CheatsManager>,
202}
203
204#[cfg(test)]
205mod tests {
206    use super::*;
207
208    #[test]
209    fn candidate_consumes_only_its_prevrandao_override() {
210        let cheats = CheatsManager::default();
211        let value = B256::with_last_byte(1);
212        cheats.set_next_block_prevrandao(value);
213        let pending = cheats.prepare_next_block_prevrandao().unwrap();
214
215        cheats.set_next_block_prevrandao(value);
216        cheats.consume_next_block_prevrandao(pending);
217
218        assert_eq!(cheats.prepare_next_block_prevrandao().unwrap().value, value);
219    }
220
221    #[test]
222    fn impersonate_returns_false_then_true() {
223        let mgr = CheatsManager::default();
224        let addr = Address::from([1u8; 20]);
225        assert!(!mgr.impersonate(addr));
226        assert!(mgr.impersonate(addr));
227    }
228}
anvil/eth/backend/cheats.rs

anvil/eth/backend/
cheats.rs
