test: add SECVinvariant depositValidator mock function

Author: samparsky

script/data/lido-data-sample-json

@@ -32,10 +32,7 @@ contract SimpleETHContributionVault {
   /// @param signatures array of validator signatures
   /// @param deposit_data_roots array of deposit data roots
   event DepositValidator(
-    bytes[] pubkeys, 
-    bytes[] withdrawal_credentials,
-    bytes[] signatures,
-    bytes32[] deposit_data_roots
+    bytes[] pubkeys, bytes[] withdrawal_credentials, bytes[] signatures, bytes32[] deposit_data_roots
   );
 
   /// @notice Emitted on user rage quit
@@ -49,7 +46,7 @@ contract SimpleETHContributionVault {
 
   /// @notice ETH2 deposit contract
   IETH2DepositContract public immutable depositContract;
-  
+
   /// @notice Address of gnosis safe
   address public immutable safe;
 
@@ -59,7 +56,6 @@ contract SimpleETHContributionVault {
   /// @notice tracks if validator have been activated
   bool public activated;
 
-
   modifier onlySafe() {
     if (msg.sender != safe) revert Unauthorized(msg.sender);
     _;

src/safe-modules/SimpleETHContributionVault.sol

@@ -5,9 +5,7 @@ import "forge-std/Test.sol";
 import {MockERC20} from "src/test/utils/mocks/MockERC20.sol";
 import {SimpleETHContributionVault} from "src/safe-modules/SimpleETHContributionVault.sol";
 
-
 contract SimpleETHContributionVaultTest is Test {
-
   error CannotRageQuit();
   error Unauthorized(address user);
 
@@ -74,12 +72,11 @@ contract SimpleETHContributionVaultTest is Test {
 
   function test_rageQuit() external {
     vm.deal(user1, ETH_STAKE);
-    
+
     vm.prank(user1);
     (bool _success,) = payable(contributionVault).call{value: ETH_STAKE}("");
     assertTrue(_success, "call failed");
 
-
     vm.expectEmit(false, false, false, true);
     emit RageQuit(user1, ETH_STAKE);
 
@@ -188,15 +185,21 @@ function getETHValidatorData()
   )
 {
   pubkeys = new bytes[](1);
-  pubkeys[0] =
-    bytes(abi.encodePacked(hex"83fa9495bb0944a74fc6a66e699039b66134b22a52a710f8d0f7cde318a2db3da40081a5867667389d206e21b5e37e52"));
+  pubkeys[0] = bytes(
+    abi.encodePacked(
+      hex"83fa9495bb0944a74fc6a66e699039b66134b22a52a710f8d0f7cde318a2db3da40081a5867667389d206e21b5e37e52"
+    )
+  );
 
   withdrawal_credentials = new bytes[](1);
-  withdrawal_credentials[0] = bytes(abi.encodePacked(hex"010000000000000000000000e839a3e9efb32c6a56ab7128e51056585275506c"));
+  withdrawal_credentials[0] =
+    bytes(abi.encodePacked(hex"010000000000000000000000e839a3e9efb32c6a56ab7128e51056585275506c"));
 
   signatures = new bytes[](1);
   signatures[0] = bytes(
-    abi.encodePacked(hex"95f00435e80e59a8fed41581e2050a3fe56272d6be845686ef014a57909c6621d7847fa550b77cb8e541b955f3c2ea031983d9e4336f215e75c8ba75d94e05f1e23460de6611a980ef629d3e32ca09cffaf2a63372496079b1ee22310d336ded")
+    abi.encodePacked(
+      hex"95f00435e80e59a8fed41581e2050a3fe56272d6be845686ef014a57909c6621d7847fa550b77cb8e541b955f3c2ea031983d9e4336f215e75c8ba75d94e05f1e23460de6611a980ef629d3e32ca09cffaf2a63372496079b1ee22310d336ded"
+    )
   );
 
   deposit_data_roots = new bytes32[](1);

src/test/safe/SimpleETHContributionVault.t.sol

@@ -1,91 +1,125 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.19;
+
 import {Test} from "forge-std/Test.sol";
 import {StdInvariant} from "forge-std/StdInvariant.sol";
 import {SimpleETHContributionVault} from "src/safe-modules/SimpleETHContributionVault.sol";
 import {CommonBase} from "forge-std/Base.sol";
 import {StdCheats} from "forge-std/StdCheats.sol";
 import {StdUtils} from "forge-std/StdUtils.sol";
+import {getETHValidatorData} from "../SimpleETHContributionVault.t.sol";
 
 contract MockDepositContract {
-    event Deposit (
-        bytes[] pubkeys,
-        bytes[] withdrawal_credentials,
-        bytes[] signatures,
-        bytes32[] deposit_data_roots
-    );
-    function depositValidator(
-        bytes[] calldata,
-        bytes[] calldata,
-        bytes[] calldata,
-        bytes32[] calldata
-    ) external payable {}
+  uint256 public ghost_depositSum;
+
+  event Deposit(bytes[] pubkeys, bytes[] withdrawal_credentials, bytes[] signatures, bytes32[] deposit_data_roots);
+
+  function deposit(bytes[] calldata, bytes[] calldata, bytes[] calldata, bytes32[] calldata) external payable {
+    ghost_depositSum += msg.value;
+  }
 }
 
-contract SECVHandler is CommonBase, StdCheats, StdUtils {
-    SimpleETHContributionVault public contributionVault;
+contract SECVMock is SimpleETHContributionVault {
+  constructor(address _safe, address eth2DepositContract) SimpleETHContributionVault(_safe, eth2DepositContract) {}
+
+  /// @notice Mock depositValidator function
+  function depositValidatorMock(
+    bytes[] calldata pubkeys,
+    bytes[] calldata withdrawal_credentials,
+    bytes[] calldata signatures,
+    bytes32[] calldata deposit_data_roots
+  ) external payable {
+    for (uint256 i = 0; i < 1;) {
+      depositContract.deposit{value: msg.value}(
+        pubkeys[i], withdrawal_credentials[i], signatures[i], deposit_data_roots[i]
+      );
+      unchecked {
+        i++;
+      }
+    }
+  }
+}
 
-    uint256 public constant ETH_SUPPLY = 100_000 ether;
+contract SECVBoundedHandler is CommonBase, StdCheats, StdUtils {
+  SECVMock public contributionVault;
 
-    uint256 public ghost_depositSum;
-    uint256 public ghost_rageQuitSum;
+  uint256 public constant ETH_SUPPLY = 1_000_000 ether;
 
-    receive() external payable {}
+  uint256 public ghost_depositSum;
+  uint256 public ghost_rageQuitSum;
 
-    constructor(SimpleETHContributionVault vault) {
-        contributionVault = vault;
-        deal(address(this), ETH_SUPPLY);
-    }
+  receive() external payable {}
 
-    function deposit(uint256 amount) external payable {
-        amount = bound(amount, 0, address(this).balance);
-        (bool _success,) = payable(contributionVault).call{value: amount}("");
-        assert(_success);
+  constructor(SECVMock vault) {
+    contributionVault = vault;
+    deal(address(this), ETH_SUPPLY);
+  }
 
-        ghost_depositSum += amount;
+  function deposit(uint256 amount) external payable {
+    amount = bound(amount, 0, address(this).balance);
+    (bool _success,) = payable(contributionVault).call{value: amount}("");
+    assert(_success);
 
-    }
+    ghost_depositSum += amount;
+  }
 
-    function rageQuit(uint256 amount) external payable {
-        amount = bound(amount, 0 , contributionVault.userBalances(address(this)));
-        contributionVault.rageQuit(address(this), amount);
+  function rageQuit(uint256 amount) external payable {
+    amount = bound(amount, 0, contributionVault.userBalances(address(this)));
+    contributionVault.rageQuit(address(this), amount);
 
-        ghost_rageQuitSum += amount;
-    }
+    ghost_rageQuitSum += amount;
+  }
+
+  function depositValidator(uint256 amount) external payable {
+    amount = bound(amount, 0, address(contributionVault).balance);
+    (
+      bytes[] memory pubkeys,
+      bytes[] memory withdrawal_credentials,
+      bytes[] memory signatures,
+      bytes32[] memory deposit_data_roots
+    ) = getETHValidatorData();
+
+    contributionVault.depositValidatorMock{value: amount}(
+      pubkeys, withdrawal_credentials, signatures, deposit_data_roots
+    );
+  }
 }
 
 contract SECVInvariant is Test {
+  MockDepositContract public mockDepositContract;
+  SECVMock public contributionVault;
+  SECVBoundedHandler public handler;
 
-    MockDepositContract public mockDepositContract;
-    SimpleETHContributionVault public contributionVault;
-    SECVHandler public handler;
-
-    address public safe;
+  address public safe;
 
-    function setUp() public {
-        safe = makeAddr("safe");
+  function setUp() public {
+    safe = makeAddr("safe");
 
-        mockDepositContract = new MockDepositContract(); 
-        contributionVault = new SimpleETHContributionVault(
+    mockDepositContract = new MockDepositContract();
+    contributionVault = new SECVMock(
             safe,
             address(mockDepositContract)
         );
-        handler = new SECVHandler(contributionVault);
+    handler = new SECVBoundedHandler(contributionVault);
 
-        targetContract(address(handler));
-    }
-
-    function invariant_balanceEqual() public {
-        assertEq(
-            handler.ETH_SUPPLY(),
-            address(handler).balance + contributionVault.userBalances(address(handler))
-        );
-    }
+    targetContract(address(handler));
+  }
 
-    function invariant_vaultIsSolvent() public {
-        assertEq(
-            address(contributionVault).balance,
-            handler.ghost_depositSum() - handler.ghost_rageQuitSum()
-        );
-    }
+  /// @notice This invariant checks that the sum of balances in the handler,
+  /// vault and mock deposit contract is equal
+  function invariant_balanceEqual() public {
+    assertEq(
+      handler.ETH_SUPPLY(),
+      address(handler).balance + contributionVault.userBalances(address(handler)) + address(mockDepositContract).balance
+    );
+  }
+
+  /// @notice This invariant checks that the vault is
+  /// always solvent when a user ragequits.
+  function invariant_vaultIsSolvent() public {
+    assertEq(
+      address(contributionVault).balance,
+      handler.ghost_depositSum() + mockDepositContract.ghost_depositSum() - handler.ghost_rageQuitSum()
+    );
+  }
 }