feat(invariant): assert all invariants on continuous_run (merge upstream #12587)

crates/config/src/invariant.rs

@@ -37,18 +37,8 @@ pub struct InvariantConfig {
     pub timeout: Option<u32>,
     /// Display counterexample as solidity calls.
     pub show_solidity: bool,
-    /// Maximum time (in seconds) between generated txs.
-    pub max_time_delay: Option<u32>,
-    /// Maximum number of blocks elapsed between generated txs.
-    pub max_block_delay: Option<u32>,
-    /// Number of calls to execute between invariant assertions.
-    ///
-    /// - `0`: Only assert on the last call of each run (fastest, but may miss exact breaking call)
-    /// - `1` (default): Assert after every call (current behavior, most precise)
-    /// - `N`: Assert every N calls AND always on the last call
-    ///
-    /// Example: `check_interval = 10` means assert after calls 10, 20, 30, ... and the last call.
-    pub check_interval: u32,
+    /// Continue invariant run until all invariants declared in current test suite breaks.
+    pub continuous_run: bool,
 }
 
 impl Default for InvariantConfig {
@@ -67,9 +57,7 @@ impl Default for InvariantConfig {
             show_metrics: true,
             timeout: None,
             show_solidity: false,
-            max_time_delay: None,
-            max_block_delay: None,
-            check_interval: 1,
+            continuous_run: false,
         }
     }
 }

crates/evm/evm/src/executors/corpus.rs

@@ -210,6 +210,7 @@ pub(crate) struct CorpusMetrics {
 impl fmt::Display for CorpusMetrics {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(f)?;
+        writeln!(f, "      Edge coverage metrics:")?;
         writeln!(f, "        - cumulative edges seen: {}", self.cumulative_edges_seen)?;
         writeln!(f, "        - cumulative features seen: {}", self.cumulative_features_seen)?;
         writeln!(f, "        - corpus count: {}", self.corpus_count)?;

crates/evm/evm/src/executors/invariant/error.rs

@@ -1,10 +1,11 @@
 use super::InvariantContract;
 use crate::executors::RawCallResult;
+use alloy_json_abi::Function;
 use alloy_primitives::{Address, Bytes};
-use foundry_config::InvariantConfig;
 use foundry_evm_core::decode::RevertDecoder;
 use foundry_evm_fuzz::{BasicTxDetails, Reason, invariant::FuzzRunIdentifiedContracts};
 use proptest::test_runner::TestError;
+use std::{collections::HashMap, fmt};
 
 /// Stores information about failures and reverts of the invariant tests.
 #[derive(Clone, Default)]
@@ -14,16 +15,40 @@ pub struct InvariantFailures {
     /// The latest revert reason of a run.
     pub revert_reason: Option<String>,
     /// Maps a broken invariant to its specific error.
-    pub error: Option<InvariantFuzzError>,
+    pub errors: HashMap<String, InvariantFuzzError>,
 }
 
 impl InvariantFailures {
     pub fn new() -> Self {
         Self::default()
     }
 
-    pub fn into_inner(self) -> (usize, Option<InvariantFuzzError>) {
-        (self.reverts, self.error)
+    pub fn into_inner(self) -> (usize, HashMap<String, InvariantFuzzError>) {
+        (self.reverts, self.errors)
+    }
+
+    pub fn record_failure(&mut self, invariant: &Function, failure: InvariantFuzzError) {
+        self.errors.insert(invariant.name.clone(), failure);
+    }
+
+    pub fn has_failure(&self, invariant: &Function) -> bool {
+        self.errors.contains_key(&invariant.name)
+    }
+
+    pub fn get_failure(&self, invariant: &Function) -> Option<&InvariantFuzzError> {
+        self.errors.get(&invariant.name)
+    }
+
+    pub fn can_continue(&self, invariants: usize) -> bool {
+        self.errors.len() < invariants
+    }
+}
+
+impl fmt::Display for InvariantFailures {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f)?;
+        writeln!(f, "      ❌ Failures: {}", self.errors.len())?;
+        Ok(())
     }
 }
 
@@ -70,10 +95,11 @@ pub struct FailedInvariantCaseData {
 impl FailedInvariantCaseData {
     pub fn new(
         invariant_contract: &InvariantContract<'_>,
-        invariant_config: &InvariantConfig,
+        shrink_run_limit: u32,
+        fail_on_revert: bool,
         targeted_contracts: &FuzzRunIdentifiedContracts,
         calldata: &[BasicTxDetails],
-        call_result: RawCallResult,
+        call_result: &RawCallResult,
         inner_sequence: &[Option<BasicTxDetails>],
     ) -> Self {
         // Collect abis of fuzzed and invariant contracts to decode custom error.
@@ -82,7 +108,7 @@ impl FailedInvariantCaseData {
             .with_abi(invariant_contract.abi)
             .decode(call_result.result.as_ref(), call_result.exit_reason);
 
-        let func = invariant_contract.invariant_function;
+        let func = invariant_contract.invariant_fn;
         debug_assert!(func.inputs.is_empty());
         let origin = func.name.as_str();
         Self {
@@ -95,8 +121,8 @@ impl FailedInvariantCaseData {
             addr: invariant_contract.address,
             calldata: func.selector().to_vec().into(),
             inner_sequence: inner_sequence.to_vec(),
-            shrink_run_limit: invariant_config.shrink_run_limit,
-            fail_on_revert: invariant_config.fail_on_revert,
+            shrink_run_limit,
+            fail_on_revert,
         }
     }
 }