From 30cd6eeaba0b7ebdae849f216eaec104f6517955 Mon Sep 17 00:00:00 2001 From: Matthias Seitz Date: Thu, 1 Sep 2022 23:11:58 +0200 Subject: [PATCH] fix more breaking changes --- anvil/src/eth/api.rs | 8 ++--- anvil/src/eth/backend/db.rs | 10 ++++--- anvil/src/eth/backend/executor.rs | 12 +++----- anvil/src/eth/backend/genesis.rs | 10 +++++-- anvil/src/eth/backend/mem/fork_db.rs | 4 +-- anvil/src/eth/backend/mem/in_memory_db.rs | 2 +- anvil/src/eth/backend/mem/mod.rs | 30 +++++++++++-------- anvil/src/eth/backend/mem/state.rs | 3 +- anvil/tests/it/anvil_api.rs | 8 +++-- cli/src/cmd/forge/script/runner.rs | 14 +++++---- evm/src/executor/backend/in_memory_db.rs | 14 +++++---- evm/src/executor/backend/mod.rs | 4 +-- evm/src/executor/inspector/cheatcodes/mod.rs | 2 +- evm/src/executor/inspector/cheatcodes/util.rs | 2 -- evm/src/executor/mod.rs | 13 +++----- forge/src/runner.rs | 12 ++++---- forge/tests/it/invariant.rs | 4 +-- 17 files changed, 80 insertions(+), 72 deletions(-) diff --git a/anvil/src/eth/api.rs b/anvil/src/eth/api.rs index d62d7eb5d94a4..4a3fc79dbc884 100644 --- a/anvil/src/eth/api.rs +++ b/anvil/src/eth/api.rs @@ -1339,7 +1339,7 @@ impl EthApi { /// Handler for RPC call: `anvil_setBalance` pub async fn anvil_set_balance(&self, address: Address, balance: U256) -> Result<()> { node_info!("anvil_setBalance"); - self.backend.set_balance(address, balance).await; + self.backend.set_balance(address, balance).await?; Ok(()) } @@ -1348,7 +1348,7 @@ impl EthApi { /// Handler for RPC call: `anvil_setCode` pub async fn anvil_set_code(&self, address: Address, code: Bytes) -> Result<()> { node_info!("anvil_setCode"); - self.backend.set_code(address, code).await; + self.backend.set_code(address, code).await?; Ok(()) } @@ -1357,7 +1357,7 @@ impl EthApi { /// Handler for RPC call: `anvil_setNonce` pub async fn anvil_set_nonce(&self, address: Address, nonce: U256) -> Result<()> { node_info!("anvil_setNonce"); - self.backend.set_nonce(address, nonce).await; + self.backend.set_nonce(address, nonce).await?; Ok(()) } @@ -1371,7 +1371,7 @@ impl EthApi { val: H256, ) -> Result { node_info!("anvil_setStorageAt"); - self.backend.set_storage_at(address, slot, val).await; + self.backend.set_storage_at(address, slot, val).await?; Ok(true) } diff --git a/anvil/src/eth/backend/db.rs b/anvil/src/eth/backend/db.rs index c2f65648bbe98..4b27d5923ef1c 100644 --- a/anvil/src/eth/backend/db.rs +++ b/anvil/src/eth/backend/db.rs @@ -21,6 +21,7 @@ use foundry_evm::{ }; use hash_db::HashDB; use serde::{Deserialize, Serialize}; +use std::fmt; /// Type alias for the `HashDB` representation of the Database pub type AsHashDB = Box>>; @@ -68,6 +69,7 @@ pub trait Db: + Database + DatabaseCommit + MaybeHashDatabase + + fmt::Debug + Send + Sync { @@ -76,7 +78,7 @@ pub trait Db: /// Sets the nonce of the given address fn set_nonce(&mut self, address: Address, nonce: u64) -> DatabaseResult<()> { - let mut info = self.basic(address)?.ok_or(DatabaseError::MissingAccount(address))?; + let mut info = self.basic(address)?.unwrap_or_default(); info.nonce = nonce; self.insert_account(address, info); Ok(()) @@ -84,7 +86,7 @@ pub trait Db: /// Sets the balance of the given address fn set_balance(&mut self, address: Address, balance: U256) -> DatabaseResult<()> { - let mut info = self.basic(address)?.ok_or(DatabaseError::MissingAccount(address))?; + let mut info = self.basic(address)?.unwrap_or_default(); info.balance = balance; self.insert_account(address, info); Ok(()) @@ -92,7 +94,7 @@ pub trait Db: /// Sets the balance of the given address fn set_code(&mut self, address: Address, code: Bytes) -> DatabaseResult<()> { - let mut info = self.basic(address)?.ok_or(DatabaseError::MissingAccount(address))?; + let mut info = self.basic(address)?.unwrap_or_default(); let code_hash = if code.as_ref().is_empty() { KECCAK_EMPTY } else { @@ -137,7 +139,7 @@ pub trait Db: /// This is useful to create blocks without actually writing to the `Db`, but rather in the cache of /// the `CacheDB` see also /// [Backend::pending_block()](crate::eth::backend::mem::Backend::pending_block()) -impl + Send + Sync + Clone> Db for CacheDB { +impl + Send + Sync + Clone + fmt::Debug> Db for CacheDB { fn insert_account(&mut self, address: Address, account: AccountInfo) { self.insert_account_info(address, account) } diff --git a/anvil/src/eth/backend/executor.rs b/anvil/src/eth/backend/executor.rs index 78c50491d27ae..75a9d41c9001a 100644 --- a/anvil/src/eth/backend/executor.rs +++ b/anvil/src/eth/backend/executor.rs @@ -225,15 +225,11 @@ impl<'a, 'b, DB: Db + ?Sized, Validator: TransactionValidator> Iterator fn next(&mut self) -> Option { let transaction = self.pending.next()?; let sender = *transaction.pending_transaction.sender(); - let account = match self.db.basic(sender) { - Ok(Some(account)) => account, - Ok(None) => { - return Some(TransactionExecutionOutcome::DatabaseError( - transaction, - DatabaseError::MissingAccount(sender), - )) + let account = match self.db.basic(sender).map(|acc| acc.unwrap_or_default()) { + Ok(account) => account, + Err(err) => { + return { Some(TransactionExecutionOutcome::DatabaseError(transaction, err)) } } - Err(err) => return Some(TransactionExecutionOutcome::DatabaseError(transaction, err)), }; let env = self.env_for(&transaction.pending_transaction); // check that we comply with the block's gas limit diff --git a/anvil/src/eth/backend/genesis.rs b/anvil/src/eth/backend/genesis.rs index 96ba41d4cfd7e..849a4cf43676b 100644 --- a/anvil/src/eth/backend/genesis.rs +++ b/anvil/src/eth/backend/genesis.rs @@ -6,7 +6,7 @@ use ethers::{ types::{Address, U256}, }; use forge::revm::KECCAK_EMPTY; -use foundry_evm::revm::AccountInfo; +use foundry_evm::{executor::backend::DatabaseResult, revm::AccountInfo}; use parking_lot::Mutex; use std::sync::Arc; use tokio::sync::RwLockWriteGuard; @@ -47,7 +47,10 @@ impl GenesisConfig { } /// If an initial `genesis.json` was provided, this applies the account alloc to the db - pub fn apply_genesis_json_alloc(&self, mut db: RwLockWriteGuard<'_, dyn Db>) { + pub fn apply_genesis_json_alloc( + &self, + mut db: RwLockWriteGuard<'_, dyn Db>, + ) -> DatabaseResult<()> { if let Some(ref genesis) = self.genesis_init { for (addr, mut acc) in genesis.alloc.accounts.clone() { let storage = std::mem::take(&mut acc.storage); @@ -55,9 +58,10 @@ impl GenesisConfig { db.insert_account(addr, acc.into()); // insert all storage values for (k, v) in storage.iter() { - db.set_storage_at(addr, k.into_uint(), v.into_uint()); + db.set_storage_at(addr, k.into_uint(), v.into_uint())?; } } } + Ok(()) } } diff --git a/anvil/src/eth/backend/mem/fork_db.rs b/anvil/src/eth/backend/mem/fork_db.rs index ae8d15502bfff..b4a7aff59f56f 100644 --- a/anvil/src/eth/backend/mem/fork_db.rs +++ b/anvil/src/eth/backend/mem/fork_db.rs @@ -7,7 +7,7 @@ use ethers::prelude::H256; use forge::revm::Database; pub use foundry_evm::executor::fork::database::ForkedDatabase; use foundry_evm::executor::{ - backend::{snapshot::StateSnapshot, DatabaseError, DatabaseResult}, + backend::{snapshot::StateSnapshot, DatabaseResult}, fork::database::ForkDbSnapshot, }; @@ -19,7 +19,7 @@ impl Db for ForkedDatabase { fn set_storage_at(&mut self, address: Address, slot: U256, val: U256) -> DatabaseResult<()> { // this ensures the account is loaded first - let _ = Database::basic(self, address)?.ok_or(DatabaseError::MissingAccount(address))?; + let _ = Database::basic(self, address)?; self.database_mut().set_storage_at(address, slot, val) } diff --git a/anvil/src/eth/backend/mem/in_memory_db.rs b/anvil/src/eth/backend/mem/in_memory_db.rs index d8cb959768aee..5735e8b65cbb1 100644 --- a/anvil/src/eth/backend/mem/in_memory_db.rs +++ b/anvil/src/eth/backend/mem/in_memory_db.rs @@ -23,7 +23,7 @@ impl Db for MemDb { } fn set_storage_at(&mut self, address: Address, slot: U256, val: U256) -> DatabaseResult<()> { - Ok(self.inner.insert_account_storage(address, slot, val)?) + self.inner.insert_account_storage(address, slot, val) } fn insert_block_hash(&mut self, number: U256, hash: H256) { diff --git a/anvil/src/eth/backend/mem/mod.rs b/anvil/src/eth/backend/mem/mod.rs index e6236e221c625..7981c6ce000a4 100644 --- a/anvil/src/eth/backend/mem/mod.rs +++ b/anvil/src/eth/backend/mem/mod.rs @@ -177,7 +177,8 @@ impl Backend { active_snapshots: Arc::new(Mutex::new(Default::default())), }; - backend.apply_genesis().await; + // Note: this can only fail in forking mode, in which case we can't recover + backend.apply_genesis().await.expect("Failed to create genesis"); backend } @@ -196,7 +197,7 @@ impl Backend { fork_genesis_infos.clear(); for address in self.genesis.accounts.iter().copied() { - let mut info = db.basic(address)?.ok_or(DatabaseError::MissingAccount(address))?; + let mut info = db.basic(address)?.unwrap_or_default(); info.balance = self.genesis.balance; db.insert_account(address, info.clone()); @@ -210,7 +211,7 @@ impl Backend { } // apply the genesis.json alloc - self.genesis.apply_genesis_json_alloc(db); + self.genesis.apply_genesis_json_alloc(db)?; Ok(()) } @@ -241,7 +242,7 @@ impl Backend { pub async fn stop_impersonating(&self, addr: Address) -> DatabaseResult<()> { if let Some((Some(code_hash), code)) = self.cheats.stop_impersonating(&addr) { let mut db = self.db.write().await; - let mut account = db.basic(addr)?.ok_or(DatabaseError::MissingAccount(addr))?; + let mut account = db.basic(addr)?.unwrap_or_default(); account.code_hash = code_hash; account.code = code; db.insert_account(addr, account) @@ -261,7 +262,7 @@ impl Backend { /// Returns the `AccountInfo` from the database pub async fn get_account(&self, address: Address) -> DatabaseResult { - self.db.read().await.basic(address)?.ok_or(DatabaseError::MissingAccount(address)) + Ok(self.db.read().await.basic(address)?.unwrap_or_default()) } /// Whether we're forked off some remote client @@ -320,7 +321,7 @@ impl Backend { } // reset the genesis.json alloc - self.genesis.apply_genesis_json_alloc(db); + self.genesis.apply_genesis_json_alloc(db)?; Ok(()) } else { @@ -406,8 +407,13 @@ impl Backend { } /// Sets the value for the given slot of the given address - pub async fn set_storage_at(&self, address: Address, slot: U256, val: H256) { - self.db.write().await.set_storage_at(address, slot, val.into_uint()); + pub async fn set_storage_at( + &self, + address: Address, + slot: U256, + val: H256, + ) -> DatabaseResult<()> { + self.db.write().await.set_storage_at(address, slot, val.into_uint()) } /// Returns true for post London @@ -834,7 +840,7 @@ impl Backend { let to = if let Some(to) = request.to { to } else { - let nonce = state.basic(from)?.ok_or(DatabaseError::MissingAccount(from))?.nonce; + let nonce = state.basic(from)?.unwrap_or_default().nonce; get_contract_address(from, nonce) }; @@ -1310,7 +1316,7 @@ impl Backend { D: DatabaseRef, { trace!(target: "backend", "get code for {:?}", address); - let account = state.basic(address)?.ok_or(DatabaseError::MissingAccount(address))?; + let account = state.basic(address)?.unwrap_or_default(); if account.code_hash == KECCAK_EMPTY { // if the code hash is `KECCAK_EMPTY`, we check no further return Ok(Default::default()) @@ -1344,7 +1350,7 @@ impl Backend { D: DatabaseRef, { trace!(target: "backend", "get balance for {:?}", address); - Ok(state.basic(address)?.ok_or(DatabaseError::MissingAccount(address))?.balance) + Ok(state.basic(address)?.unwrap_or_default().balance) } /// Returns the nonce of the address @@ -1357,7 +1363,7 @@ impl Backend { ) -> Result { self.with_database_at(block_request, |db, _| { trace!(target: "backend", "get nonce for {:?}", address); - Ok(db.basic(address)?.ok_or(DatabaseError::MissingAccount(address))?.nonce.into()) + Ok(db.basic(address)?.unwrap_or_default().nonce.into()) }) .await? } diff --git a/anvil/src/eth/backend/mem/state.rs b/anvil/src/eth/backend/mem/state.rs index d2ef1c809906e..d2e8371024cf1 100644 --- a/anvil/src/eth/backend/mem/state.rs +++ b/anvil/src/eth/backend/mem/state.rs @@ -119,8 +119,7 @@ where { let mut cache_db = CacheDB::new(state); for (account, account_overrides) in overrides.iter() { - let mut account_info = - cache_db.basic(*account)?.ok_or(DatabaseError::MissingAccount(*account))?; + let mut account_info = cache_db.basic(*account)?.unwrap_or_default(); if let Some(nonce) = account_overrides.nonce { account_info.nonce = nonce; diff --git a/anvil/tests/it/anvil_api.rs b/anvil/tests/it/anvil_api.rs index b6d354c5c35dd..a1a6c684555c9 100644 --- a/anvil/tests/it/anvil_api.rs +++ b/anvil/tests/it/anvil_api.rs @@ -55,15 +55,19 @@ async fn can_set_storage() { #[tokio::test(flavor = "multi_thread")] async fn can_impersonate_account() { + crate::init_tracing(); let (api, handle) = spawn(NodeConfig::test()).await; let provider = handle.http_provider(); let impersonate = Address::random(); let to = Address::random(); let val = 1337u64; - + let funding = U256::from(1e18 as u64); // fund the impersonated account - api.anvil_set_balance(impersonate, U256::from(1e18 as u64)).await.unwrap(); + api.anvil_set_balance(impersonate, funding).await.unwrap(); + + let balance = api.balance(impersonate, None).await.unwrap(); + assert_eq!(balance, funding); let tx = TransactionRequest::new().from(impersonate).to(to).value(val); diff --git a/cli/src/cmd/forge/script/runner.rs b/cli/src/cmd/forge/script/runner.rs index b0d85ac0ded4c..5b9e643ec9a91 100644 --- a/cli/src/cmd/forge/script/runner.rs +++ b/cli/src/cmd/forge/script/runner.rs @@ -38,7 +38,7 @@ impl ScriptRunner { if !is_broadcast { if self.sender == Config::DEFAULT_SENDER { // We max out their balance so that they can deploy and make calls. - self.executor.set_balance(self.sender, U256::MAX); + self.executor.set_balance(self.sender, U256::MAX)?; } if need_create2_deployer { @@ -46,10 +46,10 @@ impl ScriptRunner { } } - self.executor.set_nonce(self.sender, sender_nonce.as_u64()); + self.executor.set_nonce(self.sender, sender_nonce.as_u64())?; // We max out their balance so that they can deploy and make calls. - self.executor.set_balance(CALLER, U256::MAX); + self.executor.set_balance(CALLER, U256::MAX)?; // Deploy libraries let mut traces: Vec<(TraceKind, CallTraceArena)> = libraries @@ -78,7 +78,7 @@ impl ScriptRunner { .map_err(|err| eyre::eyre!("Failed to deploy script:\n{}", err))?; traces.extend(constructor_traces.map(|traces| (TraceKind::Deployment, traces)).into_iter()); - self.executor.set_balance(address, self.initial_balance); + self.executor.set_balance(address, self.initial_balance)?; // Optionally call the `setUp` function let (success, gas_used, labeled_addresses, transactions, debug) = if !setup { @@ -113,8 +113,10 @@ impl ScriptRunner { // any broadcasts, then the EVM cheatcode module hasn't corrected the nonce. // So we have to if transactions.is_none() || transactions.as_ref().unwrap().is_empty() { - self.executor - .set_nonce(self.sender, sender_nonce.as_u64() + libraries.len() as u64); + self.executor.set_nonce( + self.sender, + sender_nonce.as_u64() + libraries.len() as u64, + )?; } ( diff --git a/evm/src/executor/backend/in_memory_db.rs b/evm/src/executor/backend/in_memory_db.rs index 89876a00871b5..807e2791ceae1 100644 --- a/evm/src/executor/backend/in_memory_db.rs +++ b/evm/src/executor/backend/in_memory_db.rs @@ -5,8 +5,10 @@ use ethers::{ types::Address, }; use hashbrown::HashMap as Map; -use revm::{db::DatabaseRef, Account, AccountInfo, Bytecode, Database, DatabaseCommit}; -use revm::db::{CacheDB, EmptyDB}; +use revm::{ + db::{CacheDB, DatabaseRef, EmptyDB}, + Account, AccountInfo, Bytecode, Database, DatabaseCommit, +}; use crate::executor::snapshot::Snapshots; @@ -30,6 +32,7 @@ impl Default for MemDb { impl DatabaseRef for MemDb { type Error = DatabaseError; fn basic(&self, address: Address) -> Result, Self::Error> { + dbg!("basic"); DatabaseRef::basic(&self.inner, address) } @@ -49,6 +52,7 @@ impl DatabaseRef for MemDb { impl Database for MemDb { type Error = DatabaseError; fn basic(&mut self, address: Address) -> Result, Self::Error> { + dbg!("basic mut"); Database::basic(&mut self.inner, address) } @@ -71,10 +75,10 @@ impl DatabaseCommit for MemDb { } } - /// An empty database that always returns default values when queried. /// -/// This is just a simple wrapper for `revm::EmptyDB` but implements `DatabaseError` instead, this way we can unify all different `Database` impls +/// This is just a simple wrapper for `revm::EmptyDB` but implements `DatabaseError` instead, this +/// way we can unify all different `Database` impls #[derive(Debug, Default, Clone)] pub struct EmptyDBWrapper(EmptyDB); @@ -93,4 +97,4 @@ impl DatabaseRef for EmptyDBWrapper { fn block_hash(&self, number: U256) -> Result { Ok(self.0.block_hash(number)?) } -} \ No newline at end of file +} diff --git a/evm/src/executor/backend/mod.rs b/evm/src/executor/backend/mod.rs index 85d16e3cc61bf..63570bae62d37 100644 --- a/evm/src/executor/backend/mod.rs +++ b/evm/src/executor/backend/mod.rs @@ -574,9 +574,7 @@ impl Backend { let mut journaled_state = self.fork_init_journaled_state.clone(); for loaded_account in loaded_accounts.iter().copied() { trace!(?loaded_account, "replacing account on init"); - let fork_account = fork - .db - .basic(loaded_account)? + let fork_account = Database::basic(&mut fork.db, loaded_account)? .ok_or(DatabaseError::MissingAccount(loaded_account))?; let init_account = journaled_state.state.get_mut(&loaded_account).expect("exists; qed"); diff --git a/evm/src/executor/inspector/cheatcodes/mod.rs b/evm/src/executor/inspector/cheatcodes/mod.rs index d25a4249c6e72..57acdd18a086f 100644 --- a/evm/src/executor/inspector/cheatcodes/mod.rs +++ b/evm/src/executor/inspector/cheatcodes/mod.rs @@ -47,7 +47,7 @@ mod fuzz; mod snapshot; /// Utility cheatcodes (`sign` etc.) pub mod util; -pub use util::{DEFAULT_CREATE2_DEPLOYER, MISSING_CREATE2_DEPLOYER}; +pub use util::DEFAULT_CREATE2_DEPLOYER; mod config; use crate::executor::backend::RevertDiagnostic; diff --git a/evm/src/executor/inspector/cheatcodes/util.rs b/evm/src/executor/inspector/cheatcodes/util.rs index 552ccfcded8aa..14b9381e6ea65 100644 --- a/evm/src/executor/inspector/cheatcodes/util.rs +++ b/evm/src/executor/inspector/cheatcodes/util.rs @@ -26,8 +26,6 @@ const DEFAULT_DERIVATION_PATH_PREFIX: &str = "m/44'/60'/0'/0/"; pub const DEFAULT_CREATE2_DEPLOYER: H160 = H160([ 78, 89, 180, 72, 71, 179, 121, 87, 133, 136, 146, 12, 167, 143, 191, 38, 192, 180, 149, 108, ]); -pub const MISSING_CREATE2_DEPLOYER: &str = - "CREATE2 Deployer not present on this chain. [0x4e59b44847b379578588920ca78fbf26c0b4956c]"; // keccak(Error(string)) pub static REVERT_PREFIX: [u8; 4] = [8, 195, 121, 160]; diff --git a/evm/src/executor/mod.rs b/evm/src/executor/mod.rs index ec033a4c0597d..c3e15b073423f 100644 --- a/evm/src/executor/mod.rs +++ b/evm/src/executor/mod.rs @@ -157,8 +157,7 @@ impl Executor { /// Set the balance of an account. pub fn set_balance(&mut self, address: Address, amount: U256) -> DatabaseResult<&mut Self> { trace!(?address, ?amount, "setting account balance"); - let mut account = - self.backend_mut().basic(address)?.ok_or(DatabaseError::MissingAccount(address))?; + let mut account = self.backend_mut().basic(address)?.unwrap_or_default(); account.balance = amount; self.backend_mut().insert_account_info(address, account); @@ -167,13 +166,12 @@ impl Executor { /// Gets the balance of an account pub fn get_balance(&self, address: Address) -> DatabaseResult { - Ok(self.backend().basic(address)?.ok_or(DatabaseError::MissingAccount(address))?.balance) + Ok(self.backend().basic(address)?.map(|acc| acc.balance).unwrap_or_default()) } /// Set the nonce of an account. pub fn set_nonce(&mut self, address: Address, nonce: u64) -> DatabaseResult<&mut Self> { - let mut account = - self.backend_mut().basic(address)?.ok_or(DatabaseError::MissingAccount(address))?; + let mut account = self.backend_mut().basic(address)?.unwrap_or_default(); account.nonce = nonce; self.backend_mut().insert_account_info(address, account); @@ -561,10 +559,7 @@ impl Executor { ) -> Result { // Construct a new VM with the state changeset let mut backend = self.backend().clone_empty(); - backend.insert_account_info( - address, - self.backend().basic(address)?.ok_or(DatabaseError::MissingAccount(address))?, - ); + backend.insert_account_info(address, self.backend().basic(address)?.unwrap_or_default()); backend.commit(state_changeset); let executor = Executor::new(backend, self.env.clone(), self.inspector_config.clone(), self.gas_limit); diff --git a/forge/src/runner.rs b/forge/src/runner.rs index e47d5d2035508..11a716f035502 100644 --- a/forge/src/runner.rs +++ b/forge/src/runner.rs @@ -76,11 +76,11 @@ impl<'a> ContractRunner<'a> { trace!(?setup, "Setting test contract"); // We max out their balance so that they can deploy and make calls. - self.executor.set_balance(self.sender, U256::MAX); - self.executor.set_balance(CALLER, U256::MAX); + self.executor.set_balance(self.sender, U256::MAX)?; + self.executor.set_balance(CALLER, U256::MAX)?; // We set the nonce of the deployer accounts to 1 to get the same addresses as DappTools - self.executor.set_nonce(self.sender, 1); + self.executor.set_nonce(self.sender, 1)?; // Deploy libraries let mut traces = Vec::with_capacity(self.predeploy_libs.len()); @@ -136,9 +136,9 @@ impl<'a> ContractRunner<'a> { // Now we set the contracts initial balance, and we also reset `self.sender`s and `CALLER`s // balance to the initial balance we want - self.executor.set_balance(address, self.initial_balance); - self.executor.set_balance(self.sender, self.initial_balance); - self.executor.set_balance(CALLER, self.initial_balance); + self.executor.set_balance(address, self.initial_balance)?; + self.executor.set_balance(self.sender, self.initial_balance)?; + self.executor.set_balance(CALLER, self.initial_balance)?; self.executor.deploy_create2_deployer()?; diff --git a/forge/tests/it/invariant.rs b/forge/tests/it/invariant.rs index 731b39d51cdd6..83fc165e31e38 100644 --- a/forge/tests/it/invariant.rs +++ b/forge/tests/it/invariant.rs @@ -159,8 +159,8 @@ fn test_invariant_shrink() { .expect("`InvariantInnerContract` should have failed with a counterexample."); match counter { - CounterExample::Single(_) => assert!(false, "CounterExample should be a sequence."), + CounterExample::Single(_) => panic!("CounterExample should be a sequence."), // `fuzz_seed` at 100 makes this sequence shrinkable from 4 to 2. - CounterExample::Sequence(sequence) => assert!(sequence.len() == 2), + CounterExample::Sequence(sequence) => assert_eq!(sequence.len(), 2), }; }