feat: invariant tests

.github/workflows/invariants.yml

@@ -0,0 +1,45 @@
+name: Echidna-Invariants
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+env:
+  FOUNDRY_PROFILE: invariant
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  echidna:
+    name: Echidna-Invariants (${{ matrix.mode }})
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        mode: [property, assertion]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Run Foundry setup
+        uses: bgd-labs/github-workflows/.github/actions/foundry-setup@main
+        with:
+          FOUNDRY_VERSION: nightly
+
+      - name: Run Forge Build
+        run: forge build --build-info
+
+      - name: Run Echidna ${{ matrix.mode == 'property' && 'Property' || 'Assertion' }} Mode
+        uses: crytic/echidna-action@v2
+        with:
+          files: invariants/protocol-suite/Tester.t.sol
+          contract: Tester
+          config: invariants/protocol-suite/_config/echidna_config_ci.yaml
+          test-mode: ${{ matrix.mode == 'assertion' && 'assertion' || '' }}

.github/workflows/invariants_hub.yml

@@ -0,0 +1,45 @@
+name: Echidna-Invariants-Hub
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+env:
+  FOUNDRY_PROFILE: invariant
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  echidna:
+    name: Echidna-Invariants (${{ matrix.mode }})
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        mode: [property, assertion]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Run Foundry setup
+        uses: bgd-labs/github-workflows/.github/actions/foundry-setup@main
+        with:
+          FOUNDRY_VERSION: nightly
+
+      - name: Run Forge Build
+        run: forge build --build-info
+
+      - name: Run Echidna ${{ matrix.mode == 'property' && 'Property' || 'Assertion' }} Mode
+        uses: crytic/echidna-action@v2
+        with:
+          files: invariants/hub-suite/Tester.t.sol
+          contract: Tester
+          config: invariants/hub-suite/_config/echidna_config_ci.yaml
+          test-mode: ${{ matrix.mode == 'assertion' && 'assertion' || '' }}

.gitignore

@@ -23,4 +23,11 @@ lcov*
 report/
 
 .DS_Store
+
+# Invariant testing artifacts
+_corpus/
+crytic-export/
+slither_results.json
+
 .venv/
+.mcp.json

Makefile

@@ -29,3 +29,38 @@ coverage :
 	make coverage-clean
 	make coverage-report
 	make coverage-badge
+
+# Echidna
+echidna:
+	FOUNDRY_PROFILE=invariant echidna . --contract invariants/protocol-suite/Tester.t.sol:Tester --config ./invariants/protocol-suite/_config/echidna_config.yaml
+echidna-assert:
+	FOUNDRY_PROFILE=invariant echidna . --contract invariants/protocol-suite/Tester.t.sol:Tester --test-mode assertion --config ./invariants/protocol-suite/_config/echidna_config.yaml
+echidna-explore:
+	FOUNDRY_PROFILE=invariant echidna . --contract invariants/protocol-suite/Tester.t.sol:Tester --test-mode exploration --config ./invariants/protocol-suite/_config/echidna_config.yaml
+
+echidna-hub:
+	FOUNDRY_PROFILE=invariant echidna . --contract invariants/hub-suite/Tester.t.sol:Tester --config ./invariants/hub-suite/_config/echidna_config.yaml
+echidna-hub-assert:
+	FOUNDRY_PROFILE=invariant echidna . --contract invariants/hub-suite/Tester.t.sol:Tester --test-mode assertion --config ./invariants/hub-suite/_config/echidna_config.yaml
+echidna-hub-explore:
+	FOUNDRY_PROFILE=invariant echidna . --contract invariants/hub-suite/Tester.t.sol:Tester --test-mode exploration --config ./invariants/hub-suite/_config/echidna_config.yaml
+
+# Medusa
+medusa:
+	FOUNDRY_PROFILE=invariant medusa fuzz --config ./medusa.protocol.json
+medusa-hub:
+	FOUNDRY_PROFILE=invariant medusa fuzz --config ./medusa.hub.json
+
+foundry-invariants:
+	FOUNDRY_PROFILE=invariant forge test --mc TesterFoundry -vvv 
+
+# Results
+runes-echidna:
+	runes convert ./invariants/protocol-suite/_corpus/echidna/default/_data/corpus/reproducers --output ./invariants/protocol-suite/replays
+runes-medusa:
+	runes convert ./invariants/protocol-suite/_corpus/medusa/ --output ./invariants/protocol-suite/replays
+
+runes-echidna-hub:
+	runes convert ./invariants/hub-suite/_corpus/echidna/default/_data/corpus/reproducers --output ./invariants/hub-suite/replays
+runes-medusa-hub:
+	runes convert ./invariants/hub-suite/_corpus/medusa/ --output ./invariants/hub-suite/replays

foundry.toml

@@ -11,7 +11,7 @@ optimizer_runs = 444444444444
 bytecode_hash = "none"
 gas_snapshot_check = false
 gas_limit = 1099511627776
-dynamic_test_linking = true
+dynamic_test_linking = false # https://github.com/crytic/crytic-compile/issues/651#issuecomment-3813020679
 
 additional_compiler_profiles = [
   { name = "hub", optimizer = true, via_ir = true, optimizer_runs = 22_300 },
@@ -38,7 +38,7 @@ runs = 1000
 seed = "0x640"
 
 [profile.pr.fuzz]
-runs = 5000
+runs = 5 # todo revert
 
 [profile.ci.fuzz]
 runs = 10000
@@ -50,9 +50,17 @@ isolate = true
 
 [profile.coverage]
 optimizer = true
-optimizer_runs = 444444444444
+optimizer_runs = 200
+via_ir = false
+fuzz.runs = 5
+additional_compiler_profiles = []
+compilation_restrictions = []
+
+[profile.invariant]
+optimizer = true
+optimizer_runs = 200
 via_ir = false
-fuzz.runs = 50
+test = 'invariants/'
 additional_compiler_profiles = []
 compilation_restrictions = []
 

fuzz_parser.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+import re
+
+def parse_echidna_trace(trace):
+    """Parse Echidna trace and extract function calls, parameters, delays, and 'from' addresses."""
+    calls = []
+    last_address = None  # Track the last 'from' address
+
+    for line in trace.strip().splitlines():
+        # Parse function calls, including those with underscores
+        func_call = re.match(r"Tester\.([a-zA-Z0-9_]+)\(([^)]*)\)", line)
+        if func_call:
+            func_name = func_call.group(1)
+            params = func_call.group(2)
+
+            # Check for 'from' address
+            from_address = re.search(r"from: (0x[a-fA-F0-9]+)", line)
+            time_delay = re.search(r"Time delay: (\d+)", line)
+
+            # If we have a 'from' address, we need to set it up
+            if from_address:
+                address = from_address.group(1)
+                if address != last_address:
+                    # Only set up the actor if the address has changed
+                    calls.append(f"_setUpActor({address});")
+                    last_address = address
+
+            # Add the delay if it exists
+            if time_delay:
+                delay_time = time_delay.group(1)
+                calls.append(f"_delay({delay_time});")
+
+            # Add the function call
+            calls.append(f"Tester.{func_name}({params});")
+
+        # Handle special case of "*wait*" for a delay
+        elif "*wait*" in line:
+            time_delay = re.search(r"Time delay: (\d+)", line)
+            if time_delay:
+                delay_time = time_delay.group(1)
+                calls.append(f"_delay({delay_time});")
+
+    return calls
+
+def parse_medusa_trace(trace):
+    """Parse Medusa trace and extract function calls, parameters, block, time, and sender information."""
+    calls = []
+    last_address = None  # Track the last 'from' address
+    last_block = 0
+    last_time = 0
+
+    for line in trace.strip().splitlines():
+        # Skip empty lines
+        if not line.strip():
+            continue
+
+        # Parse Medusa format: number) Contract.function(types)(values) (metadata)
+        medusa_pattern = r"(?:\d+\))?\s*Tester\.([a-zA-Z0-9_]+)\([^)]*\)\(([^)]*)\)\s*\(block=(\d+),\s*time=(\d+).*sender=(0x[a-fA-F0-9]+)\)"
+        match = re.search(medusa_pattern, line)
+
+        if match:
+            func_name = match.group(1)
+            params = match.group(2)
+            block = int(match.group(3))
+            time = int(match.group(4))
+            address = match.group(5)
+
+            if (address == "0x10000"):
+                actor = "USER1"
+            elif (address == "0x20000"):
+                actor = "USER2"
+            elif (address == "0x30000"):
+                actor = "USER3"
+
+            # If sender address changed, set up the new actor
+            if address != last_address:
+                calls.append(f"_setUpActor({actor});")
+                last_address = address
+
+            # Add block/time delay if needed
+            if time > last_time:
+                # Medusa reports absolute timestamps, so we calculate the difference
+                # between consecutive transactions to determine the delay
+                time_diff = time - last_time
+                if time_diff > 0:
+                    calls.append(f"_delay({time_diff});")
+                last_time = time
+                last_block = block
+
+            # Add the function call
+            calls.append(f"Tester.{func_name}({params});")
+
+    return calls
+
+def detect_trace_format(trace):
+    """Detect whether the trace is in Echidna or Medusa format."""
+    # Check for Medusa format indicators (block=X, time=Y, sender=0xZ)
+    if re.search(r"\(block=\d+,\s*time=\d+.*sender=0x[a-fA-F0-9]+\)", trace):
+        return "medusa"
+    # Default to Echidna format
+    return "echidna"
+
+def generate_foundry_test(calls, test_name="test_replay"):
+    """Generate the Solidity test function code."""
+    test_code = [f"function {test_name}() public {{"]
+    test_code.extend(f"    {call}" for call in calls)
+    test_code.append("}")
+
+    return "\n".join(test_code)
+
+# Ask user to paste the trace
+print("Paste your Echidna or Medusa call trace below. Press Enter twice to finish:")
+trace = []
+while True:
+    line = input()
+    if line:
+        trace.append(line.strip())
+    else:
+        break
+trace = "\n".join(trace)
+
+# Detect format and parse the trace
+format_type = detect_trace_format(trace)
+if format_type == "medusa":
+    print("\nDetected Medusa trace format")
+    parsed_calls = parse_medusa_trace(trace)
+else:
+    print("\nDetected Echidna trace format")
+    parsed_calls = parse_echidna_trace(trace)
+
+# Generate the test
+solidity_test = generate_foundry_test(parsed_calls)
+
+# Output the generated Solidity test
+print("\nGenerated Foundry Test Function:\n")
+print(solidity_test)

invariants/hub-suite/HandlerAggregator.t.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+// Handler contracts
+import {HubHandler} from './handlers/HubHandler.t.sol';
+import {HubConfiguratorHandler} from './handlers/HubConfiguratorHandler.t.sol';
+import {DonationAttackHandler} from './handlers/simulators/DonationAttackHandler.t.sol';
+
+/// @notice Helper contract to aggregate all handler contracts for hub suite
+abstract contract HandlerAggregator is HubHandler, HubConfiguratorHandler, DonationAttackHandler {
+  function _setUpHandlers() internal {}
+}

invariants/hub-suite/Invariants.t.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import {HubInvariants} from './invariants/HubInvariants.t.sol';
+
+/// @title Invariants
+/// @notice Aggregator for hub invariants
+abstract contract Invariants is HubInvariants {
+  function invariant_INV_HUB() public returns (bool) {
+    uint256 assetCount = hub.getAssetCount();
+
+    for (uint256 i; i < assetCount; i++) {
+      // HUB
+      assert_INV_HUB_A(i);
+      assert_INV_HUB_B(i);
+      assert_INV_HUB_C(i);
+      assert_INV_HUB_E(i);
+      assert_INV_HUB_F(i);
+      assert_INV_HUB_GH(i);
+      assert_INV_HUB_I(i);
+      assert_INV_HUB_K(i);
+      assert_INV_HUB_O(i);
+      assert_INV_HUB_P(i);
+      for (uint256 j; j < NUMBER_OF_ACTORS; j++) {
+        assert_INV_HUB_ERC4626_A(i, actorAddresses[j]);
+        assert_INV_HUB_ERC4626_B(i, actorAddresses[j]);
+      }
+      assert_INV_HUB_ERC4626_C(i);
+      assert_INV_HUB_ERC4626_D(i);
+    }
+
+    return true;
+  }
+
+  function invariant_INV_HUB_AVAILABILITY() public returns (bool) {
+    uint256 assetCount = hub.getAssetCount();
+    for (uint256 i; i < assetCount; i++) {
+      assert_INV_HUB_AVAILABILITY_A(i);
+      assert_INV_HUB_AVAILABILITY_B(i);
+      assert_INV_HUB_AVAILABILITY_C(i);
+      assert_INV_HUB_AVAILABILITY_D(i);
+      assert_INV_HUB_AVAILABILITY_E(i);
+      for (uint256 j; j < NUMBER_OF_ACTORS; j++) {
+        assert_INV_HUB_AVAILABILITY_F(i, actorAddresses[j]);
+        assert_INV_HUB_AVAILABILITY_G(i, actorAddresses[j]);
+        assert_INV_HUB_AVAILABILITY_H(i, actorAddresses[j]);
+        assert_INV_HUB_AVAILABILITY_I(i, actorAddresses[j]);
+      }
+    }
+
+    return true;
+  }
+}