feat(invariant): assert all invariants by default (assert_all)

crates/config/src/invariant.rs

@@ -49,6 +49,10 @@ pub struct InvariantConfig {
     ///
     /// Example: `check_interval = 10` means assert after calls 10, 20, 30, ... and the last call.
     pub check_interval: u32,
+    /// Assert every invariant declared in the current test suite, continuing the campaign after
+    /// the first failure until all invariants have been broken (or normal limits are hit).
+    /// When `false`, the campaign aborts on the first broken invariant (legacy behavior).
+    pub assert_all: bool,
 }
 
 impl Default for InvariantConfig {
@@ -70,6 +74,7 @@ impl Default for InvariantConfig {
             max_time_delay: None,
             max_block_delay: None,
             check_interval: 1,
+            assert_all: true,
         }
     }
 }

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

@@ -220,6 +220,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,13 +1,14 @@
 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::{ASSERTION_FAILED_PREFIX, EMPTY_REVERT_DATA, RevertDecoder},
     evm::FoundryEvmNetwork,
 };
 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)]
@@ -17,16 +18,41 @@ 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 {
+        debug_assert!(invariants > 0, "invariant_fns must not be empty");
+        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(())
     }
 }
 
@@ -75,7 +101,8 @@ pub struct FailedInvariantCaseData {
 impl FailedInvariantCaseData {
     pub fn new<FEN: FoundryEvmNetwork>(
         invariant_contract: &InvariantContract<'_>,
-        invariant_config: &InvariantConfig,
+        shrink_run_limit: u32,
+        fail_on_revert: bool,
         targeted_contracts: &FuzzRunIdentifiedContracts,
         calldata: &[BasicTxDetails],
         call_result: RawCallResult<FEN>,
@@ -95,7 +122,7 @@ impl FailedInvariantCaseData {
                 revert_reason
             };
 
-        let func = invariant_contract.invariant_function;
+        let func = invariant_contract.primary_invariant_fn;
         debug_assert!(func.inputs.is_empty());
         let origin = func.name.as_str();
         Self {
@@ -108,8 +135,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,
             assertion_failure: false,
         }
     }