1use crate::{
26 constants::{CALLER, CHEATCODE_ADDRESS, DEFAULT_CREATE2_DEPLOYER},
27 evm::{
28 BackingDb, BlockContext, ChainFor, EthEvmNetwork, EvmEnvFor, EvmFactoryFor, ExecutedNested,
29 ExecutionLifecycle, ExecutionPhase, ForkDb, ForkInfo, ForkPosition, FoundryDatabase,
30 FoundryEvmExt, FoundryEvmFactory, FoundryEvmFor, FoundryEvmNetwork, FoundryExecutionHooks,
31 FoundryTxConversion, PersistentWrite, PreparedTx, SpecFor, StoredExt,
32 TransactionRequestFor, TxFor, TxResultFor, TypesFor, block_txs, evm_env, full_transactions,
33 merge_untracked_nested_changes,
34 },
35 fork::{BlockEnv, CreateFork, Fork as RemoteFork, ForkId, ForkResult, MultiFork},
36 opts::{EvmOpts, ExecutionSpecContext},
37 utils::{
38 apply_chain_and_block_specific_env_changes_for_chain,
39 apply_chain_specific_tx_replay_env_changes_for_chain, block_env_from_header,
40 },
41};
42use alloy_chains::{Chain, NamedChain};
43use alloy_consensus::{BlockHeader, Transaction as _, Typed2718, transaction::Recovered};
44use alloy_eips::BlockNumHash;
45use alloy_genesis::GenesisAccount;
46use alloy_network::{AnyNetwork, AnyRpcBlock, AnyRpcTransaction, TransactionResponse};
47use alloy_primitives::{
48 Address, B256, Bytes, ChainId, KECCAK256_EMPTY, TxKind, U256, keccak256,
49 map::{AddressMap, AddressSet, HashSet},
50 uint,
51};
52use alloy_rpc_types::{BlockNumberOrTag, BlockTransactions};
53use evm2::{
54 EvmFeatures, Inspector,
55 bytecode::Bytecode,
56 evm::{
57 AccountInfo, Cache, DbResult, DynDatabase, EmptyDB, InMemoryDB, PendingState, State,
58 StateSnapshot,
59 bal::{Bal, BlockAccessIndex},
60 },
61};
62use eyre::WrapErr;
63use foundry_common::{SYSTEM_TRANSACTION_TYPE, is_known_system_sender};
64use foundry_evm_networks::NetworkConfigs;
65pub use foundry_fork_db::{
66 AccountFetchPolicy, BlockchainDb, ForkBlock, ForkBlockEnv, SharedBackend,
67 cache::BlockchainDbMeta,
68};
69use std::{collections::BTreeMap, mem, sync::Arc, time::Instant};
70
71mod diagnostic;
72pub use diagnostic::RevertDiagnostic;
73
74mod bal;
75
76mod error;
77pub use error::{
78 BackendError, BackendResult, DatabaseError, DatabaseResult, TransactionValidationError,
79 handler_error, transaction_error,
80};
81
82mod cow;
83pub use cow::CowBackend;
84
85mod snapshot;
86pub use snapshot::RevertStateSnapshotAction;
87
88#[cfg(test)]
89mod tests;
90
91pub type LocalForkId = U256;
96
97pub type RpcForkDb = ForkDb<SharedBackend<AnyNetwork, BlockEnv>>;
99
100const DEFAULT_PERSISTENT_ACCOUNTS: [Address; 3] =
102 [CHEATCODE_ADDRESS, DEFAULT_CREATE2_DEPLOYER, CALLER];
103
104pub const GLOBAL_FAIL_SLOT: U256 =
109 uint!(0x6661696c65640000000000000000000000000000000000000000000000000000_U256);
110
111#[derive(Clone, Copy, Debug)]
113pub enum ForkAccountField {
114 Balance,
115 Nonce,
116 Code,
117}
118
119struct TransactionForkTarget {
121 fork_block: BlockNumHash,
123 transaction: AnyRpcTransaction,
125 block: AnyRpcBlock,
127 mined: bool,
129 index: Option<usize>,
131}
132
133#[derive(Clone, Debug)]
139pub struct Backend<FEN: FoundryEvmNetwork = EthEvmNetwork> {
140 networks: NetworkConfigs,
142 forks: MultiFork,
144 lifecycle: ExecutionLifecycle<EvmFactoryFor<FEN>>,
146 cheatcode_access: AddressSet,
148 caller: Option<Address>,
150 has_state_snapshot_failure: bool,
152 fork_block_number_override: Option<u64>,
154 bal: Option<(Arc<Bal>, BlockAccessIndex)>,
156}
157
158impl<FEN: FoundryEvmNetwork> Backend<FEN> {
159 pub fn spawn(fork: Option<CreateFork>, env: EvmEnvFor<FEN>) -> eyre::Result<Self> {
164 Self::new(MultiFork::spawn(), fork, env)
165 }
166
167 pub fn spawn_fork(
169 fork: CreateFork,
170 configure_env: impl FnOnce(&mut EvmEnvFor<FEN>, ExecutionSpecContext),
171 ) -> eyre::Result<Self> {
172 Self::new_fork(MultiFork::spawn(), fork, configure_env)
173 }
174
175 pub fn spawn_source(fork: Option<CreateFork>, local_env: EvmEnvFor<FEN>) -> eyre::Result<Self> {
178 match fork {
179 Some(fork) => Self::spawn_fork(fork, |_, _| {}),
180 None => Self::spawn(None, local_env),
181 }
182 }
183
184 fn new_fork(
186 forks: MultiFork,
187 fork: CreateFork,
188 configure_env: impl FnOnce(&mut EvmEnvFor<FEN>, ExecutionSpecContext),
189 ) -> eyre::Result<Self> {
190 let opts = &fork.evm_opts;
191 let resolved = forks.create_fork(fork.clone())?;
192 let context = resolved.fork.context();
193 let chain_id = opts.chain_id_override().unwrap_or(context.execution_chain_id);
194 let mut env = opts.fork_env_from_block::<FEN, AnyNetwork>(
195 chain_id,
196 context.source_chain_id,
197 &resolved.fork.block,
198 );
199 configure_env(
200 &mut env,
201 ExecutionSpecContext::fork(context.source_chain_id, context.hardfork),
202 );
203
204 let track = fork.evm_opts.networks.is_monad();
205 let mut backend = Self::with_fork_manager(forks, EmptyDB::default(), env);
206 let id = backend.insert_prepared_fork(fork.url, resolved, env, track)?;
207 let mut evm = backend.lifecycle.create_evm();
208 backend.lifecycle.select_fork(&mut evm, Some(id), ExecutionPhase::Boundary)?;
209 backend.lifecycle.park(evm);
210 Ok(backend)
211 }
212
213 pub fn new(
218 forks: MultiFork,
219 fork: Option<CreateFork>,
220 env: EvmEnvFor<FEN>,
221 ) -> eyre::Result<Self> {
222 trace!(target: "backend", forking_mode=?fork.is_some(), "creating executor backend");
223 let mut backend = Self::with_fork_manager(forks, EmptyDB::default(), env);
224 if let Some(fork) = fork {
225 let track = fork.evm_opts.networks.is_monad();
226 let id = backend.insert_fork(fork, Some(env), track)?;
227 let mut evm = backend.lifecycle.create_evm();
228 backend.lifecycle.select_fork(&mut evm, Some(id), ExecutionPhase::Boundary)?;
229 backend.lifecycle.park(evm);
230 }
231 Ok(backend)
232 }
233
234 pub fn with_db(db: impl BackingDb, env: EvmEnvFor<FEN>) -> Self {
236 Self::with_fork_manager(MultiFork::spawn(), db, env)
237 }
238
239 fn with_fork_manager(forks: MultiFork, db: impl BackingDb, env: EvmEnvFor<FEN>) -> Self {
240 let mut lifecycle = ExecutionLifecycle::new(EvmFactoryFor::<FEN>::default(), db, env);
241 for account in DEFAULT_PERSISTENT_ACCOUNTS {
242 lifecycle.forks_mut().add_persistent(account);
243 }
244 let evm = lifecycle.create_evm();
246 lifecycle.park(evm);
247 Self {
248 networks: NetworkConfigs::default(),
249 forks,
250 lifecycle,
251 cheatcode_access: AddressSet::default(),
252 caller: None,
253 has_state_snapshot_failure: false,
254 fork_block_number_override: None,
255 bal: None,
256 }
257 }
258
259 pub fn clone_with_fork_scope(&self) -> eyre::Result<Self> {
263 let mut backend = self.clone();
264 backend.forks = self.forks.scoped()?;
265 Ok(backend)
266 }
267
268 pub fn clone_empty(&self) -> Self {
270 self.clone_empty_with_env(self.lifecycle.active().env)
271 }
272
273 pub fn clone_empty_with_env(&self, env: EvmEnvFor<FEN>) -> Self {
279 let mut backend = Self::with_fork_manager(self.forks.clone(), EmptyDB::default(), env);
280 backend.set_networks(self.networks);
281 backend
282 }
283
284 pub fn replace_fork(
287 &mut self,
288 fork: Option<CreateFork>,
289 local_env: EvmEnvFor<FEN>,
290 ) -> eyre::Result<()> {
291 let networks = self.networks;
292 let forks = self.forks.clone();
293 *self = match fork {
294 Some(fork) => Self::new_fork(forks, fork, |_, _| {})?,
295 None => Self::new(forks, None, local_env)?,
296 };
297 self.set_networks(networks);
298 Ok(())
299 }
300
301 pub fn fork(&self) -> Option<RemoteFork> {
303 self.active_fork_info()?.remote.clone()
304 }
305
306 pub async fn env(
308 &self,
309 opts: &EvmOpts,
310 ) -> eyre::Result<(EvmEnvFor<FEN>, TransactionRequestFor<FEN>)> {
311 opts.env_at_fork::<FEN>(self.fork().as_ref()).await
312 }
313
314 pub async fn can_use_create2_deployer(&self, deployer: Address) -> eyre::Result<bool> {
316 let Some(fork) = self.fork() else {
317 return Ok(deployer == DEFAULT_CREATE2_DEPLOYER);
318 };
319 let mut request = self
320 .active_fork_options()
321 .ok_or_else(|| eyre::eyre!("active fork configuration is unavailable"))?;
322 request.evm_opts.create2_deployer = deployer;
323 request.evm_opts.can_use_create2_deployer_at(Some(&fork)).await
324 }
325
326 pub async fn transaction_count(&self, sender: Address) -> eyre::Result<u64> {
328 let request =
329 self.active_fork_options().ok_or_else(|| eyre::eyre!("backend is not forked"))?;
330 let fork = self.fork().ok_or_else(|| eyre::eyre!("backend is not forked over RPC"))?;
331 request.evm_opts.transaction_count_at_fork(sender, &fork).await
332 }
333
334 pub const fn networks(&self) -> NetworkConfigs {
336 self.networks
337 }
338
339 pub fn set_networks(&mut self, networks: NetworkConfigs) {
341 self.networks = networks;
342 let factory = self.lifecycle.factory().with_networks(networks);
343 self.lifecycle.set_factory(factory);
344 }
345
346 pub const fn set_fork_block_number_override(&mut self, block_number: u64) {
349 self.fork_block_number_override = Some(block_number);
350 }
351
352 pub const fn factory(&self) -> &EvmFactoryFor<FEN> {
354 self.lifecycle.factory()
355 }
356
357 pub const fn lifecycle(&self) -> &ExecutionLifecycle<EvmFactoryFor<FEN>> {
359 &self.lifecycle
360 }
361
362 pub fn evm_env(&self) -> EvmEnvFor<FEN> {
365 self.lifecycle.active().env
366 }
367
368 pub fn evm_env_mut(&mut self) -> &mut EvmEnvFor<FEN> {
370 &mut self.lifecycle.active_mut().env
371 }
372
373 pub fn set_spec_id(&mut self, spec: impl Into<SpecFor<FEN>>) -> &mut Self {
375 let env = self.evm_env();
376 *self.evm_env_mut() = self.lifecycle.factory().env_with_spec(env, spec.into());
377 self
378 }
379
380 pub fn create_evm<'a>(&self) -> FoundryEvmFor<'a, FEN> {
384 let mut evm = self.lifecycle.create_evm();
385 self.apply_bal(&mut evm);
386 evm
387 }
388
389 pub fn park(&mut self, evm: FoundryEvmFor<'_, FEN>) {
392 self.lifecycle.park(evm);
393 self.bal = None;
394 }
395
396 pub fn remove_prewarm(&mut self, state: &mut State<'_>, address: &Address) {
399 self.lifecycle.remove_prewarm(state, address);
400 }
401
402 pub fn take_persistent_warmth(&mut self) -> Vec<(Option<U256>, AddressMap<HashSet<U256>>)> {
405 self.lifecycle.take_persistent_warmth()
406 }
407
408 pub fn restore_persistent_warmth(
410 &mut self,
411 warmth: Vec<(Option<U256>, AddressMap<HashSet<U256>>)>,
412 ) {
413 self.lifecycle.restore_persistent_warmth(warmth);
414 }
415
416 pub fn inspect_commit<'a>(
418 &mut self,
419 tx: &Recovered<TxFor<FEN>>,
420 inspector: impl Inspector<TypesFor<FEN>> + 'a,
421 ) -> eyre::Result<TxResultFor<FEN>> {
422 let mut evm: FoundryEvmFor<'a, FEN> = self.create_evm();
423 evm.set_inspector(inspector);
424 evm.ext_mut().for_next_transaction(tx);
425 let result = evm.transact(tx).map_err(handler_error)?.commit();
426 evm.clear_inspector();
427 self.park(evm);
428 Ok(result)
429 }
430
431 pub fn initialize(&mut self, caller: Address, kind: TxKind) {
435 self.set_caller(caller);
436 let test_contract = match kind {
437 TxKind::Call(to) => to,
438 TxKind::Create => {
439 let nonce = self.basic(caller).ok().flatten().map_or(0, |account| account.nonce);
440 caller.create(nonce)
441 }
442 };
443 self.set_test_contract(test_contract);
444 }
445
446 pub fn basic(&self, address: Address) -> DbResult<Option<AccountInfo>> {
450 let mut account = self.lifecycle.accepted_db().get_account(&address)?;
451 if let Some(account) = &mut account
452 && account.code.is_none()
453 && !account.is_empty_code_hash()
454 {
455 account.code = Some(self.code_by_hash(account.code_hash)?);
456 }
457 Ok(account)
458 }
459
460 pub fn code_by_hash(&self, code_hash: B256) -> DbResult<Bytecode> {
462 self.lifecycle.accepted_db().get_code_by_hash(&code_hash)
463 }
464
465 pub fn storage(&self, address: Address, slot: U256) -> DbResult<U256> {
467 self.lifecycle.accepted_db().get_storage(&address, &slot)
468 }
469
470 pub fn block_hash(&self, number: U256) -> DbResult<B256> {
472 self.lifecycle.accepted_db().get_block_hash(&number)
473 }
474
475 pub fn insert_account_info(&mut self, address: Address, mut account: AccountInfo) {
479 let cache = self.lifecycle.accepted_mut();
480 if let Some(code) = account.code.take()
481 && !code.is_empty()
482 {
483 if account.is_empty_code_hash() || account.code_hash.is_zero() {
484 account.code_hash = code.hash_slow();
485 }
486 cache.contracts.insert(account.code_hash, code);
487 }
488 if account.code_hash.is_zero() {
489 account.code_hash = KECCAK256_EMPTY;
490 }
491 cache.accounts.insert(address, Some(account));
492 }
493
494 pub fn insert_account_storage(&mut self, address: Address, slot: U256, value: U256) {
498 self.lifecycle.accepted_mut().storage.entry(address).or_default().slots.insert(slot, value);
499 }
500
501 pub fn replace_account_storage(
506 &mut self,
507 address: Address,
508 storage: impl IntoIterator<Item = (U256, U256)>,
509 ) {
510 let account = self.lifecycle.accepted_mut().storage.entry(address).or_default();
511 account.wipe();
512 account.slots.extend(storage);
513 }
514
515 pub fn set_env(
518 &mut self,
519 evm: &mut FoundryEvmFor<'_, FEN>,
520 env: EvmEnvFor<FEN>,
521 phase: ExecutionPhase,
522 ) {
523 self.lifecycle.set_env(evm, env, phase);
524 }
525
526 pub fn commit_pending(&mut self, pending: &PendingState) {
531 let mut db =
532 InMemoryDB { cache: mem::take(self.lifecycle.accepted_mut()), ..Default::default() };
533 db.commit_pending(pending);
534 *self.lifecycle.accepted_mut() = db.cache;
535 }
536
537 pub fn set_test_contract(&mut self, account: Address) -> &mut Self {
543 trace!(?account, "setting test account");
544 self.lifecycle.forks_mut().add_persistent(account);
545 self.cheatcode_access.insert(account);
546 self
547 }
548
549 pub fn set_caller(&mut self, account: Address) -> &mut Self {
551 trace!(?account, "setting caller account");
552 self.caller = Some(account);
553 self.cheatcode_access.insert(account);
554 self
555 }
556
557 pub const fn has_state_snapshot_failure(&self) -> bool {
561 self.has_state_snapshot_failure
562 }
563
564 pub const fn set_state_snapshot_failure(&mut self, has_state_snapshot_failure: bool) {
566 self.has_state_snapshot_failure = has_state_snapshot_failure;
567 }
568
569 pub fn is_persistent(&self, account: &Address) -> bool {
573 self.lifecycle.forks().is_persistent(account)
574 }
575
576 pub fn add_persistent_account(&mut self, account: Address) -> bool {
578 trace!(?account, "add persistent account");
579 self.lifecycle.forks_mut().add_persistent(account)
580 }
581
582 pub fn remove_persistent_account(&mut self, account: &Address) -> bool {
584 trace!(?account, "remove persistent account");
585 self.lifecycle.forks_mut().remove_persistent(account)
586 }
587
588 pub fn extend_persistent_accounts(&mut self, accounts: impl IntoIterator<Item = Address>) {
590 for account in accounts {
591 self.add_persistent_account(account);
592 }
593 }
594
595 pub fn allow_cheatcode_access(&mut self, account: Address) -> bool {
597 trace!(?account, "allow cheatcode access");
598 self.cheatcode_access.insert(account)
599 }
600
601 pub fn has_cheatcode_access(&self, account: &Address) -> bool {
603 self.cheatcode_access.contains(account)
604 }
605
606 pub fn ensure_cheatcode_access(&self, account: &Address) -> Result<(), BackendError> {
608 if !self.has_cheatcode_access(account) {
609 return Err(BackendError::NoCheats(*account));
610 }
611 Ok(())
612 }
613
614 pub fn ensure_cheatcode_access_forking_mode(
616 &self,
617 account: &Address,
618 ) -> Result<(), BackendError> {
619 if self.is_forked_mode() {
620 return self.ensure_cheatcode_access(account);
621 }
622 Ok(())
623 }
624
625 pub const fn active_fork_id(&self) -> Option<LocalForkId> {
629 self.lifecycle.forks().active()
630 }
631
632 pub const fn is_forked_mode(&self) -> bool {
634 self.active_fork_id().is_some()
635 }
636
637 pub fn is_active_fork(&self, id: LocalForkId) -> bool {
639 self.active_fork_id() == Some(id)
640 }
641
642 pub fn active_fork_info(&self) -> Option<&ForkInfo> {
644 Some(&self.lifecycle.forks().get(self.active_fork_id()?)?.info)
645 }
646
647 pub fn active_fork_url(&self) -> Option<String> {
649 Some(self.active_fork_info()?.url.clone())
650 }
651
652 pub fn active_fork_options(&self) -> Option<CreateFork> {
654 self.forks.get_fork_options(self.active_fork_info()?.id.clone()).ok()?
655 }
656
657 pub fn active_fork_source_chain_id(&self) -> Option<u64> {
659 self.lifecycle.active().db.active_fork_source_chain_id()
660 }
661
662 pub fn active_fork_block_number(&self) -> Option<u64> {
664 if let Some(block_number) = self.fork_block_number_override {
665 return Some(block_number);
666 }
667 self.active_fork_info()?.block
668 }
669
670 pub fn ensure_fork(&self, id: Option<LocalForkId>) -> eyre::Result<LocalForkId> {
672 match id.or_else(|| self.active_fork_id()) {
673 Some(id) if self.lifecycle.forks().get(id).is_some() => Ok(id),
674 Some(id) => eyre::bail!("Requested fork `{id}` does not exist"),
675 None => eyre::bail!("No fork active"),
676 }
677 }
678
679 fn fork_info(&self, id: LocalForkId) -> eyre::Result<&ForkInfo> {
680 self.lifecycle
681 .forks()
682 .get(id)
683 .map(|entry| &entry.info)
684 .ok_or_else(|| eyre::eyre!("Requested fork `{id}` does not exist"))
685 }
686
687 fn set_fork_info(&mut self, id: LocalForkId, info: ForkInfo) {
688 self.lifecycle.forks_mut().get_mut(id).expect("fork exists").info = info;
689 }
690
691 fn fork_options(&self, id: &ForkId) -> eyre::Result<CreateFork> {
692 self.forks
693 .get_fork_options(id.clone())?
694 .ok_or_else(|| eyre::eyre!("Requested fork `{id}` does not exist"))
695 }
696
697 pub fn create_fork(&mut self, fork: CreateFork) -> eyre::Result<LocalForkId> {
701 trace!("create fork");
702 let track = self.tracks_position(&fork);
703 self.insert_fork(fork, None, track)
704 }
705
706 pub fn create_fork_at_transaction(
708 &mut self,
709 fork: CreateFork,
710 transaction: B256,
711 ) -> eyre::Result<LocalForkId> {
712 trace!(?transaction, "create fork at transaction");
713 let id = self.insert_fork(fork, None, false)?;
715 let spec = self.evm_env().spec;
716 let (db, env, cache, info, cursor, _) =
717 self.prepare_roll_to_transaction(id, transaction, spec)?;
718 self.lifecycle.replace_inactive(Some(id), db, env, cache)?;
719 self.set_fork_info(id, info);
720 if let Some((position, cursor)) = cursor {
721 self.retain_cursor(id, position, &cursor, None);
722 }
723 Ok(id)
724 }
725
726 pub fn create_select_fork(
728 &mut self,
729 fork: CreateFork,
730 evm: &mut FoundryEvmFor<'_, FEN>,
731 phase: ExecutionPhase,
732 ) -> eyre::Result<LocalForkId> {
733 let id = self.create_fork(fork)?;
734 self.select_fork(id, evm, phase)?;
735 Ok(id)
736 }
737
738 pub fn create_select_fork_at_transaction(
740 &mut self,
741 fork: CreateFork,
742 evm: &mut FoundryEvmFor<'_, FEN>,
743 phase: ExecutionPhase,
744 transaction: B256,
745 ) -> eyre::Result<LocalForkId> {
746 let id = self.create_fork_at_transaction(fork, transaction)?;
747 self.select_fork(id, evm, phase)?;
748 Ok(id)
749 }
750
751 pub fn select_fork(
756 &mut self,
757 id: LocalForkId,
758 evm: &mut FoundryEvmFor<'_, FEN>,
759 phase: ExecutionPhase,
760 ) -> eyre::Result<()> {
761 trace!(?id, "select fork");
762 self.ensure_fork(Some(id))?;
763 if self.is_active_fork(id) {
764 return Ok(());
765 }
766 let running = evm_env(evm);
767 let factory = self.lifecycle.factory().clone();
768 let context = self.lifecycle.forks_mut().context_mut(Some(id)).expect("fork exists");
769 let mut env = factory.env_with_spec(context.env, running.spec);
770 env.set_feature(EvmFeatures::FEE_CHARGE, running.version.feature(EvmFeatures::FEE_CHARGE));
771 context.env = env;
772 self.lifecycle.select_fork(evm, Some(id), phase)
773 }
774
775 pub fn roll_fork(
777 &mut self,
778 id: Option<LocalForkId>,
779 block_number: u64,
780 evm: &mut FoundryEvmFor<'_, FEN>,
781 phase: ExecutionPhase,
782 ) -> eyre::Result<()> {
783 trace!(?id, ?block_number, "roll fork");
784 let id = self.ensure_fork(id)?;
785 let info = self.fork_info(id)?.clone();
786 let options = self.fork_options(&info.id)?;
787 let ForkResult { id: fork_id, backend, fork: remote } =
788 self.forks.roll_fork(info.id.clone(), block_number)?;
789 let env = self.fork_env(&options.evm_opts, &remote, &remote.block, evm_env(evm).spec);
790 let cursor = if self.tracks_position(&options) {
792 Some(self.block_end_cursor(&backend, &remote, &env)?)
793 } else {
794 None
795 };
796 let db = ForkDb::new(backend, remote.context().source_chain_id);
797 self.roll_lifecycle_fork(evm, id, db, env, None, phase)?;
798 let block = Some(remote.number());
799 self.set_fork_info(
800 id,
801 ForkInfo { id: fork_id, url: info.url, block, remote: Some(remote), position: None },
802 );
803 if let Some((position, cursor)) = cursor {
804 self.retain_cursor(id, position, &cursor, Some(evm));
805 }
806 Ok(())
807 }
808
809 fn roll_lifecycle_fork(
814 &mut self,
815 evm: &mut FoundryEvmFor<'_, FEN>,
816 id: LocalForkId,
817 db: impl BackingDb,
818 env: EvmEnvFor<FEN>,
819 cache: Option<Cache>,
820 phase: ExecutionPhase,
821 ) -> eyre::Result<()> {
822 let active = self.is_active_fork(id);
823 let caller = self
824 .caller
825 .filter(|caller| active && self.lifecycle.forks_mut().add_persistent(*caller));
826 let result = self.lifecycle.roll_fork(evm, Some(id), db, env, cache, phase);
827 if let Some(caller) = caller {
828 self.lifecycle.forks_mut().remove_persistent(&caller);
829 }
830 result
831 }
832
833 pub fn roll_fork_to_transaction(
837 &mut self,
838 id: Option<LocalForkId>,
839 transaction: B256,
840 evm: &mut FoundryEvmFor<'_, FEN>,
841 phase: ExecutionPhase,
842 ) -> eyre::Result<()> {
843 trace!(?id, ?transaction, "roll fork to transaction");
844 let id = self.ensure_fork(id)?;
845 let (db, env, cache, info, cursor, replayed) =
846 self.prepare_roll_to_transaction(id, transaction, evm_env(evm).spec)?;
847 self.roll_lifecycle_fork(evm, id, db, env, cache, phase)?;
848 self.set_fork_info(id, info);
849 if let Some((position, cursor)) = cursor {
850 self.retain_cursor(id, position, &cursor, Some(evm));
851 }
852 if replayed && !self.is_active_fork(id) {
855 self.lifecycle.rebase_onto_inactive(evm, Some(id))?;
856 TypesFor::<FEN>::refresh_transaction(evm);
857 }
858 Ok(())
859 }
860
861 pub fn prepare_transact(
875 &self,
876 id: Option<LocalForkId>,
877 transaction: B256,
878 evm: &mut FoundryEvmFor<'_, FEN>,
879 depth: u16,
880 isolation_env: Option<&EvmEnvFor<FEN>>,
881 ) -> eyre::Result<(PreparedTx<TypesFor<FEN>>, CowBackend<'_, FEN>)> {
882 trace!(?id, ?transaction, "execute transaction");
883 let id = self.ensure_fork(id)?;
884 let info = self.fork_info(id)?;
885 eyre::ensure!(
886 !info.remote.as_ref().is_some_and(|remote| remote.state_by_number),
887 "transaction replay requires hash-addressed state; create a transaction-targeted fork \
888 or disable fork_state_by_number"
889 );
890 let source_chain_id = self.fork_source_chain_id(id)?;
891
892 let target = self.transaction_target(id, transaction)?;
896 let tx = TypesFor::<FEN>::tx_from_any_rpc(&target.transaction)?;
897 let active = self.is_active_fork(id);
898 let mut env = if active {
899 let mut env = evm_env(evm);
900 if let Some(outer) = isolation_env {
901 for feature in [
902 EvmFeatures::FEE_CHARGE,
903 EvmFeatures::BALANCE_CHECK,
904 EvmFeatures::BALANCE_TOP_UP,
905 ] {
906 env.set_feature(feature, outer.version.feature(feature));
907 }
908 }
909 env
910 } else {
911 self.lifecycle.forks().context(Some(id)).expect("fork exists").env
912 };
913 env.set_chain_id(source_chain_id);
916 env.block = block_env_from_header::<TypesFor<FEN>>(&target.block.header);
917 apply_chain_and_block_specific_env_changes_for_chain::<AnyNetwork, _>(
918 &mut env,
919 &target.block,
920 source_chain_id,
921 self.networks,
922 );
923 apply_chain_specific_tx_replay_env_changes_for_chain(&mut env, source_chain_id);
924 env.initial_call_depth = depth - TypesFor::<FEN>::tx_call_depth_offset(&tx);
925
926 let (ext, next) = if self.networks.is_monad() {
929 let index = target
930 .index
931 .ok_or_else(|| eyre::eyre!("transaction {transaction} has no block position"))?;
932 let transactions = full_transactions(&target.block)?;
933 let block = BlockNumHash::new(target.block.header.number(), target.block.header.hash);
934 let next = self
935 .fork_position(id)?
936 .after_transaction(
937 block,
938 target.block.header.parent_hash(),
939 index,
940 transactions.len(),
941 )
942 .ok_or_else(|| {
943 eyre::eyre!(
944 "transaction {transaction} does not immediately follow the canonical \
945 position of fork {id}"
946 )
947 })?;
948 let shared = self.shared_backend(id)?;
949 let context = block_context::<FEN>(&shared, &target.block)?;
950 let factory = self.lifecycle.factory();
951 let cursor = block_cursor::<FEN>(factory, &env, context.clone(), next)?;
952 let mut ext = factory.evm_ext(&env);
953 context.prepare(&mut ext, index);
954 ext.set_protocol_replay(true);
957 (Some(ext), Some((next, cursor)))
958 } else {
959 (None, None)
960 };
961 TypesFor::<FEN>::sync_transaction(evm);
963 let mut prepared = if active {
964 self.lifecycle.prepare_nested(evm, tx, Some(env), ext)
965 } else {
966 self.lifecycle.prepare_on_inactive(evm, Some(id), tx, Some(env), ext)?
967 };
968 if let Some((position, cursor)) = next {
969 prepared.set_cursor(id, position, cursor);
970 }
971
972 prepared.set_access_list(target.transaction.access_list().cloned());
973 let mut backend = CowBackend::new_borrowed(self);
974 if !active {
975 backend.lifecycle.activate_detached(Some(id));
977 }
978 backend.fork_block_number_override = Some(target.block.header.number());
979 Ok((prepared, backend))
980 }
981
982 pub fn transact_from_tx(
986 &mut self,
987 tx: &Recovered<TxFor<FEN>>,
988 evm: &mut FoundryEvmFor<'_, FEN>,
989 env: Option<EvmEnvFor<FEN>>,
990 inspector: Option<&mut dyn Inspector<TypesFor<FEN>>>,
991 ) -> eyre::Result<(TxResultFor<FEN>, Vec<PersistentWrite>)> {
992 trace!("execute signed transaction");
993 let mut executor = self.lifecycle.nested_evm(evm, tx, env, None);
994 if let Some(inspector) = inspector {
995 executor.set_inspector(inspector);
996 }
997 let executed = executor.transact(tx).map_err(transaction_error)?;
998 let (persistent, _) = merge_untracked_nested_changes(evm.state_mut(), &executed)?;
999 Ok((executed.result().clone(), persistent))
1000 }
1001
1002 pub fn prepare_nested(
1009 &self,
1010 tx: Recovered<TxFor<FEN>>,
1011 evm: &mut FoundryEvmFor<'_, FEN>,
1012 env: Option<EvmEnvFor<FEN>>,
1013 ) -> (PreparedTx<TypesFor<FEN>>, CowBackend<'_, FEN>) {
1014 trace!("execute signed transaction");
1015 TypesFor::<FEN>::sync_transaction(evm);
1017 (self.lifecycle.prepare_nested(evm, tx, env, None), CowBackend::new_borrowed(self))
1018 }
1019
1020 pub fn store_executed(
1026 &mut self,
1027 evm: &mut FoundryEvmFor<'_, FEN>,
1028 mut executed: ExecutedNested<TypesFor<FEN>>,
1029 ) -> TxResultFor<FEN> {
1030 let cursor = executed.take_cursor();
1031 let result = self.lifecycle.store_executed(executed);
1032 match cursor {
1033 Some((id, position, cursor)) if self.is_active_fork(id) => {
1034 self.retain_cursor(id, position, &cursor, Some(evm))
1035 }
1036 Some((id, position, cursor)) => {
1037 self.retain_cursor(id, position, &cursor, None);
1038 TypesFor::<FEN>::refresh_transaction(evm);
1039 }
1040 None => TypesFor::<FEN>::refresh_transaction(evm),
1041 }
1042 result
1043 }
1044
1045 pub fn diagnose_revert(
1069 &self,
1070 callee: Address,
1071 evm: &mut FoundryEvmFor<'_, FEN>,
1072 ) -> Option<RevertDiagnostic> {
1073 let active = self.active_fork_id()?;
1074 if self.lifecycle.forks().len() == 1 {
1075 return None;
1077 }
1078 if is_contract(evm.read_account_info(&callee).ok().flatten()) {
1079 return None;
1080 }
1081 let available_on = self
1082 .lifecycle
1083 .forks()
1084 .iter()
1085 .filter(|(id, entry)| {
1086 *id != active
1087 && is_contract(entry.context.accepted_db().get_account(&callee).ok().flatten())
1088 })
1089 .map(|(id, _)| id)
1090 .collect::<Vec<_>>();
1091 Some(if available_on.is_empty() {
1092 RevertDiagnostic::ContractDoesNotExist {
1093 contract: callee,
1094 active,
1095 persistent: self.is_persistent(&callee),
1096 }
1097 } else {
1098 RevertDiagnostic::ContractExistsOnOtherForks { contract: callee, active, available_on }
1099 })
1100 }
1101
1102 pub fn load_allocs(
1104 &self,
1105 allocs: &BTreeMap<Address, GenesisAccount>,
1106 evm: &mut FoundryEvmFor<'_, FEN>,
1107 ) -> Result<(), BackendError> {
1108 for (address, account) in allocs {
1109 self.clone_account(account, address, evm)?;
1110 }
1111 Ok(())
1112 }
1113
1114 pub fn clone_account(
1117 &self,
1118 source: &GenesisAccount,
1119 target: &Address,
1120 evm: &mut FoundryEvmFor<'_, FEN>,
1121 ) -> Result<(), BackendError> {
1122 let state = evm.state_mut();
1123 {
1124 let mut account = state.account(target)?;
1125 if let Some(code) = &source.code {
1126 account.set_code(keccak256(code), Bytecode::new_raw(code.clone()));
1127 }
1128 account.set_balance(source.balance);
1129 account.set_nonce(source.nonce.unwrap_or_default());
1130 account.touch();
1132 account.warm();
1133 }
1134 for (slot, value) in source.storage.iter().flatten() {
1135 let mut slot = state.storage_slot(target, (*slot).into())?;
1136 slot.warm();
1137 slot.set((*value).into());
1138 }
1139 Ok(())
1140 }
1141
1142 pub fn set_blockhash(&self, number: U256, hash: B256, evm: &mut FoundryEvmFor<'_, FEN>) {
1144 evm.state_mut().overlay_db_mut().insert_block_hash(&number, &hash);
1145 }
1146
1147 pub fn refresh_fork_account(
1153 &self,
1154 address: Address,
1155 field: ForkAccountField,
1156 evm: &mut FoundryEvmFor<'_, FEN>,
1157 ) -> Result<(), BackendError> {
1158 if !self.is_forked_mode() {
1159 return Ok(());
1160 }
1161 trace!(?address, ?field, "refresh fork account");
1162 let db = &self.lifecycle.active().db;
1163 db.evict_account(&address);
1164 let mut refreshed = db.clone_backing().get_account(&address)?.unwrap_or_default();
1165 if matches!(field, ForkAccountField::Code) && refreshed.code.is_none() {
1166 refreshed.code = Some(db.clone_backing().get_code_by_hash(&refreshed.code_hash)?);
1167 }
1168
1169 self.lifecycle.materialize(evm);
1170 let state = evm.state_mut();
1171 let cache = &mut state.overlay_db_mut().cache;
1172 if let Some(Some(cached)) = cache.accounts.get_mut(&address) {
1173 match field {
1174 ForkAccountField::Balance => cached.balance = refreshed.balance,
1175 ForkAccountField::Nonce => cached.nonce = refreshed.nonce,
1176 ForkAccountField::Code => {
1177 cached.code_hash = refreshed.code_hash;
1178 if let Some(code) = &refreshed.code {
1179 cache.contracts.insert(refreshed.code_hash, code.clone());
1180 }
1181 }
1182 }
1183 cached.code = None;
1184 }
1185 let mut account = state.account(&address)?;
1186 match field {
1187 ForkAccountField::Balance => account.override_balance(refreshed.balance),
1188 ForkAccountField::Nonce => account.override_nonce(refreshed.nonce),
1189 ForkAccountField::Code => {
1190 account.set_code(refreshed.code_hash, refreshed.code.unwrap_or_default())
1191 }
1192 }
1193 Ok(())
1194 }
1195
1196 pub fn refresh_fork_storage(
1202 &mut self,
1203 address: Address,
1204 slot: U256,
1205 evm: &mut FoundryEvmFor<'_, FEN>,
1206 ) -> Result<Option<PersistentWrite>, BackendError> {
1207 if !self.is_forked_mode() {
1208 return Ok(None);
1209 }
1210 trace!(?address, ?slot, "refresh fork storage");
1211 let db = &self.lifecycle.active().db;
1212 db.evict_storage(&address, &slot);
1213 let value = db.clone_backing().get_storage(&address, &slot)?;
1214
1215 self.lifecycle.materialize(evm);
1216 let state = evm.state_mut();
1217 if let Some(storage) = state.overlay_db_mut().cache.storage.get_mut(&address)
1218 && storage.slots.contains_key(&slot)
1219 {
1220 storage.slots.insert(slot, value);
1221 }
1222 let storage = state.storage(&address)?;
1223 let write = if storage.is_loaded(&slot) {
1224 storage.into_slot(slot)?.set(value);
1225 Some(PersistentWrite::Slot(address, slot, value))
1226 } else {
1227 None
1228 };
1229 self.lifecycle.refresh_switched_slot(&address, slot, value);
1230 Ok(write)
1231 }
1232
1233 pub fn prefetch_call(
1238 &self,
1239 caller: Address,
1240 target: Address,
1241 value: U256,
1242 input: Bytes,
1243 top_level: bool,
1244 ) {
1245 let context = self.lifecycle.active();
1246 context.db.prefetch_call(caller, target, value, input, context.cache.as_deref(), top_level);
1247 }
1248
1249 pub fn snapshot_state(&mut self, evm: &mut FoundryEvmFor<'_, FEN>) -> U256 {
1253 let id = self.lifecycle.snapshot(evm);
1254 trace!(target: "backend", "Created new snapshot {}", id);
1255 id
1256 }
1257
1258 pub fn revert_state(
1264 &mut self,
1265 id: U256,
1266 evm: &mut FoundryEvmFor<'_, FEN>,
1267 action: RevertStateSnapshotAction,
1268 phase: ExecutionPhase,
1269 ) -> Option<StateSnapshot> {
1270 trace!(?id, "revert snapshot");
1271 if !self.lifecycle.has_snapshot(id) {
1272 warn!(target: "backend", "No snapshot to revert for {}", id);
1273 return None;
1274 }
1275 if evm
1279 .state_mut()
1280 .storage_slot_untracked(&CHEATCODE_ADDRESS, &GLOBAL_FAIL_SLOT)
1281 .is_ok_and(|value| !value.is_zero())
1282 {
1283 self.has_state_snapshot_failure = true;
1284 }
1285 self.lifecycle.revert(evm, id, action, phase)
1286 }
1287
1288 pub fn delete_state_snapshot(&mut self, id: U256) -> bool {
1290 self.lifecycle.delete_snapshot(id)
1291 }
1292
1293 pub fn delete_state_snapshots(&mut self) {
1295 self.lifecycle.delete_snapshots();
1296 }
1297
1298 fn insert_fork(
1303 &mut self,
1304 fork: CreateFork,
1305 env: Option<EvmEnvFor<FEN>>,
1306 track: bool,
1307 ) -> eyre::Result<LocalForkId> {
1308 let url = fork.url.clone();
1309 let opts = fork.evm_opts.clone();
1310 let resolved = self.forks.create_fork(fork)?;
1311 let env = env.unwrap_or_else(|| {
1312 let remote = &resolved.fork;
1313 self.fork_env(&opts, remote, &remote.block, self.lifecycle.active().env.spec)
1314 });
1315 self.insert_prepared_fork(url, resolved, env, track)
1316 }
1317
1318 fn insert_prepared_fork(
1321 &mut self,
1322 url: String,
1323 resolved: ForkResult,
1324 env: EvmEnvFor<FEN>,
1325 track: bool,
1326 ) -> eyre::Result<LocalForkId> {
1327 let ForkResult { id, backend, fork: remote } = resolved;
1328 let cursor =
1329 if track { Some(self.block_end_cursor(&backend, &remote, &env)?) } else { None };
1330 let db = ForkDb::new(backend, remote.context().source_chain_id);
1331 let info = ForkInfo {
1332 id,
1333 url,
1334 block: Some(remote.number()),
1335 remote: Some(remote),
1336 position: None,
1337 };
1338 let id = self.lifecycle.create_fork(info, db, env);
1339 if let Some((position, cursor)) = cursor {
1340 self.retain_cursor(id, position, &cursor, None);
1341 }
1342 Ok(id)
1343 }
1344
1345 const fn tracks_position(&self, fork: &CreateFork) -> bool {
1347 self.networks.is_monad() || fork.evm_opts.networks.is_monad()
1348 }
1349
1350 fn fork_position(&self, id: LocalForkId) -> eyre::Result<ForkPosition> {
1353 let info = self.fork_info(id)?;
1354 info.position
1355 .or_else(|| info.remote.as_ref().map(|remote| ForkPosition::AfterBlock(remote.block())))
1356 .ok_or_else(|| eyre::eyre!("fork `{id}` has no canonical position"))
1357 }
1358
1359 fn block_end_cursor(
1361 &self,
1362 backend: &SharedBackend<AnyNetwork, BlockEnv>,
1363 remote: &RemoteFork,
1364 env: &EvmEnvFor<FEN>,
1365 ) -> eyre::Result<(ForkPosition, ChainFor<FEN>)> {
1366 let block = match &remote.block.transactions {
1367 BlockTransactions::Full(_) => AnyRpcBlock::clone(&remote.block),
1368 _ => backend
1369 .get_full_block(remote.hash())
1370 .wrap_err_with(|| format!("failed to fetch fork block {}", remote.hash()))?,
1371 };
1372 eyre::ensure!(
1373 block.header.hash == remote.hash() && block.header.number() == remote.number(),
1374 "fork block {} ({}) changed",
1375 remote.number(),
1376 remote.hash()
1377 );
1378 let position = ForkPosition::AfterBlock(remote.block());
1379 let context = block_context::<FEN>(backend, &block)?;
1380 Ok((position, block_cursor::<FEN>(self.lifecycle.factory(), env, context, position)?))
1381 }
1382
1383 fn retain_cursor(
1388 &mut self,
1389 id: LocalForkId,
1390 position: ForkPosition,
1391 cursor: &ChainFor<FEN>,
1392 evm: Option<&mut FoundryEvmFor<'_, FEN>>,
1393 ) {
1394 if self.is_active_fork(id)
1395 && let Some(evm) = evm
1396 {
1397 evm.ext_mut().adopt_cursor(cursor);
1398 TypesFor::<FEN>::refresh_transaction(evm);
1399 } else {
1400 let context = self.lifecycle.forks_mut().context_mut(Some(id)).expect("fork exists");
1401 let mut ext = context.ext.get();
1402 ext.adopt_cursor(cursor);
1403 context.ext = StoredExt::new(&ext);
1404 }
1405 self.lifecycle.forks_mut().get_mut(id).expect("fork exists").info.position = Some(position);
1406 }
1407
1408 fn fork_env(
1410 &self,
1411 opts: &EvmOpts,
1412 remote: &RemoteFork,
1413 block: &AnyRpcBlock,
1414 spec: SpecFor<FEN>,
1415 ) -> EvmEnvFor<FEN> {
1416 let context = remote.context();
1417 let chain_id = opts.chain_id_override().unwrap_or(context.execution_chain_id);
1418 let env =
1419 opts.fork_env_from_block::<FEN, AnyNetwork>(chain_id, context.source_chain_id, block);
1420 self.lifecycle.factory().env_with_spec(env, spec)
1421 }
1422
1423 fn fork_source_chain_id(&self, id: LocalForkId) -> eyre::Result<ChainId> {
1424 self.lifecycle
1425 .forks()
1426 .context(Some(id))
1427 .and_then(|context| context.db.active_fork_source_chain_id())
1428 .ok_or_else(|| eyre::eyre!("fork `{id}` is not backed by an RPC endpoint"))
1429 }
1430
1431 fn shared_backend(&self, id: LocalForkId) -> eyre::Result<SharedBackend<AnyNetwork, BlockEnv>> {
1432 let fork_id = self.fork_info(id)?.id.clone();
1433 self.forks
1434 .get_fork(fork_id.clone())?
1435 .ok_or_else(|| eyre::eyre!("fork `{fork_id}` is not backed by an RPC endpoint"))
1436 }
1437
1438 fn transaction_target(
1440 &self,
1441 id: LocalForkId,
1442 transaction: B256,
1443 ) -> eyre::Result<TransactionForkTarget> {
1444 let backend = self.shared_backend(id)?;
1445 let tx = backend.get_transaction(transaction)?;
1446 let Some(tx_block) = tx.block_number() else {
1447 eyre::ensure!(
1448 !self.networks.is_monad(),
1449 "transaction {transaction} is pending and has no canonical block context"
1450 );
1451 let block = backend.get_full_block(BlockNumberOrTag::Latest)?;
1452 let fork_block = BlockNumHash::new(block.header.number(), block.header.hash);
1453 return Ok(TransactionForkTarget {
1454 fork_block,
1455 transaction: tx,
1456 block,
1457 mined: false,
1458 index: None,
1459 });
1460 };
1461 let tx_block_hash = tx
1462 .block_hash()
1463 .ok_or_else(|| eyre::eyre!("mined transaction is missing its block hash"))?;
1464 let block = backend.get_full_block(tx_block_hash)?;
1465 eyre::ensure!(
1466 block.header.number() == tx_block && block.header.hash == tx_block_hash,
1467 "transaction block changed: expected {tx_block} ({tx_block_hash}), got {} ({})",
1468 block.header.number(),
1469 block.header.hash
1470 );
1471 let transactions = full_transactions(&block)?;
1472 let index = transactions.iter().position(|tx| tx.tx_hash() == transaction);
1473 eyre::ensure!(
1474 index.is_some(),
1475 "transaction {transaction} is missing from block {}",
1476 block.header.number()
1477 );
1478 let fork_block = BlockNumHash::new(
1480 tx_block
1481 .checked_sub(1)
1482 .ok_or_else(|| eyre::eyre!("cannot replay a transaction in the genesis block"))?,
1483 block.header.parent_hash(),
1484 );
1485 Ok(TransactionForkTarget { fork_block, transaction: tx, block, mined: true, index })
1486 }
1487
1488 #[expect(clippy::type_complexity)]
1492 fn prepare_roll_to_transaction(
1493 &self,
1494 id: LocalForkId,
1495 transaction: B256,
1496 spec: SpecFor<FEN>,
1497 ) -> eyre::Result<(
1498 RpcForkDb,
1499 EvmEnvFor<FEN>,
1500 Option<Cache>,
1501 ForkInfo,
1502 Option<(ForkPosition, ChainFor<FEN>)>,
1503 bool,
1504 )> {
1505 let info = self.fork_info(id)?.clone();
1506 let options = self.fork_options(&info.id)?;
1507 let target = self.transaction_target(id, transaction)?;
1508 let ForkResult { id: fork_id, backend, fork: remote } = self
1509 .forks
1510 .roll_fork_exact_with_bal(info.id.clone(), target.fork_block, target.mined)?;
1511 let source_chain_id = remote.context().source_chain_id;
1512 let env = self.fork_env(&options.evm_opts, &remote, &target.block, spec);
1513 let db = ForkDb::new(backend, source_chain_id);
1514 let mut cursor = None;
1515 let replayed = target.mined && target.index.is_some_and(|index| index > 0);
1516 let cache = if target.mined {
1517 let index = target.index.expect("mined transaction has a block position");
1518 let context = if self.networks.is_monad() {
1519 let context = block_context::<FEN>(db.inner(), &target.block)?;
1520 let block =
1521 BlockNumHash::new(target.block.header.number(), target.block.header.hash);
1522 let position = ForkPosition::BeforeTransaction { block, index };
1523 cursor = Some((
1524 position,
1525 block_cursor::<FEN>(self.lifecycle.factory(), &env, context.clone(), position)?,
1526 ));
1527 Some(context)
1528 } else {
1529 None
1530 };
1531 Some(self.replay_until(&db, env, &target.block, index, context, source_chain_id)?)
1532 } else {
1533 None
1534 };
1535 let block = Some(target.block.header.number());
1536 let info =
1537 ForkInfo { id: fork_id, url: info.url, block, remote: Some(remote), position: None };
1538 Ok((db, env, cache, info, cursor, replayed))
1539 }
1540
1541 fn replay_until(
1548 &self,
1549 db: &impl BackingDb,
1550 mut env: EvmEnvFor<FEN>,
1551 block: &AnyRpcBlock,
1552 index: usize,
1553 context: Option<BlockContext<FEN>>,
1554 source_chain_id: ChainId,
1555 ) -> eyre::Result<Cache> {
1556 let transactions = full_transactions(block)?;
1557 apply_chain_specific_tx_replay_env_changes_for_chain(&mut env, source_chain_id);
1558
1559 let now = Instant::now();
1560 let mut evm = self.lifecycle.factory().create_evm(db.clone_backing(), env);
1561 for (position, rpc_tx) in transactions[..index].iter().enumerate() {
1562 let is_system =
1563 is_known_system_sender(rpc_tx.from()) || rpc_tx.ty() == SYSTEM_TRANSACTION_TYPE;
1564 let tx = match TypesFor::<FEN>::tx_from_any_rpc(rpc_tx) {
1565 Ok(tx) => tx,
1566 Err(_) if is_system => continue,
1569 Err(err) => return Err(err),
1570 };
1571 let is_protocol = ChainFor::<FEN>::is_protocol_transaction(&tx);
1572 if is_system && rpc_tx.ty() != SYSTEM_TRANSACTION_TYPE && !is_protocol {
1573 continue;
1575 }
1576 match &context {
1577 Some(context) => context.prepare(evm.ext_mut(), position),
1578 None => evm.ext_mut().for_transaction(&tx),
1579 }
1580 evm.ext_mut().set_protocol_replay(is_protocol);
1582 trace!(tx=?rpc_tx.tx_hash(), "committing transaction");
1583 let _ = evm
1584 .transact(&tx)
1585 .map_err(handler_error)
1586 .wrap_err("backend: failed replaying transaction")?
1587 .commit();
1588 }
1589 trace!(elapsed=?now.elapsed(), count=index, "replayed transactions");
1590 Ok(mem::take(&mut evm.state_mut().overlay_db_mut().cache))
1591 }
1592}
1593
1594fn block_context<FEN: FoundryEvmNetwork>(
1596 backend: &SharedBackend<AnyNetwork, BlockEnv>,
1597 block: &AnyRpcBlock,
1598) -> eyre::Result<BlockContext<FEN>> {
1599 let parent = parent_block(backend, block)?;
1600 let grandparent =
1601 parent.as_ref().map(|parent| parent_block(backend, parent)).transpose()?.flatten();
1602 Ok(BlockContext::new(
1603 grandparent.as_ref().map(block_txs::<FEN>).transpose()?.unwrap_or_default(),
1604 parent.as_ref().map(block_txs::<FEN>).transpose()?.unwrap_or_default(),
1605 block_txs::<FEN>(block)?,
1606 ))
1607}
1608
1609fn block_cursor<FEN: FoundryEvmNetwork>(
1612 factory: &EvmFactoryFor<FEN>,
1613 env: &EvmEnvFor<FEN>,
1614 mut context: BlockContext<FEN>,
1615 position: ForkPosition,
1616) -> eyre::Result<ChainFor<FEN>> {
1617 let mut ext = factory.evm_ext(env);
1618 match position {
1619 ForkPosition::AfterBlock(_) => {
1620 context.advance_block();
1621 context.prepare(&mut ext, 0);
1622 }
1623 ForkPosition::BeforeTransaction { index, .. } => {
1624 context.before_transaction(index)?.prepare(&mut ext, index);
1625 }
1626 }
1627 Ok(ext)
1628}
1629
1630fn parent_block(
1632 backend: &SharedBackend<AnyNetwork, BlockEnv>,
1633 block: &AnyRpcBlock,
1634) -> eyre::Result<Option<AnyRpcBlock>> {
1635 let parent_hash = block.header.parent_hash();
1636 if parent_hash.is_zero() {
1637 return Ok(None);
1638 }
1639 let parent = backend
1640 .get_full_block(parent_hash)
1641 .wrap_err_with(|| format!("failed to fetch ancestor block {parent_hash}"))?;
1642 eyre::ensure!(
1643 parent.header.hash == parent_hash
1644 && Some(parent.header.number()) == block.header.number().checked_sub(1),
1645 "ancestor block {parent_hash} does not match its child"
1646 );
1647 Ok(Some(parent))
1648}
1649
1650fn is_contract(account: Option<AccountInfo>) -> bool {
1652 account.is_some_and(|account| !account.is_empty_code_hash() && !account.code_hash.is_zero())
1653}
1654
1655pub fn account_fetch_policy_for_source(
1663 source_chain_id: ChainId,
1664 network_profile: NetworkConfigs,
1665) -> AccountFetchPolicy {
1666 let source_chain = Chain::from_id(source_chain_id);
1667 let identifies_family = source_chain
1668 .named()
1669 .is_some_and(|chain| !matches!(chain, NamedChain::Dev | NamedChain::AnvilHardhat));
1670 let is_tempo = source_chain.is_tempo() || (!identifies_family && network_profile.is_tempo());
1671 if is_tempo {
1672 AccountFetchPolicy::RequireAccountInfoWithExtension
1673 } else {
1674 AccountFetchPolicy::Auto
1675 }
1676}