contracts-periphery: foundry tests for drip checks

Add foundry tests for the dripchecks. Each test suite
includes a fuzz test for the positive and negative cases.
This is a continuation of porting all contracts tests
to foundry for a unified developer testing environment.

packages/contracts-periphery/.gas-snapshot

@@ -13,6 +13,13 @@ AssetReceiverTest:test_withdrawETHwithAmount() (gas: 26108)
 AssetReceiverTest:test_attest_bulk() (gas: 611440)
 AssetReceiverTest:test_attest_individual() (gas: 538514)
 AssetReceiverTest:test_attest_single() (gas: 558962)
+CheckBalanceHighTest:testFuzz_check_fails(address,uint256) (runs: 256, μ: 12352, ~: 12382)
+CheckBalanceHighTest:testFuzz_check_succeeds(address,uint256) (runs: 256, μ: 10284, ~: 10284)
+CheckBalanceLowTest:testFuzz_check_fails(address,uint256) (runs: 256, μ: 10262, ~: 10262)
+CheckBalanceLowTest:testFuzz_check_succeeds(address,uint256) (runs: 256, μ: 12374, ~: 12404)
+CheckGelatoLowTest:testFuzz_check_fails(uint256,address) (runs: 256, μ: 34938, ~: 35871)
+CheckGelatoLowTest:testFuzz_check_succeeds(uint256,address) (runs: 256, μ: 18800, ~: 18800)
+CheckTrueTest:testFuzz_always_true_succeeds(bytes) (runs: 256, μ: 6539, ~: 6486)
 Drippie_Test:testFuzz_fails_unauthorized(address) (runs: 256, μ: 17073, ~: 17073)
 Drippie_Test:test_create_fails_twice() (gas: 169499)
 Drippie_Test:test_create_success() (gas: 184013)

packages/contracts-periphery/contracts/foundry-tests/CheckBalanceHigh.t.sol

+//SPDX-License-Identifier: MIT
+pragma solidity 0.8.16;
+
+import { Test } from "forge-std/Test.sol";
+import { CheckBalanceHigh } from "../universal/drippie/dripchecks/CheckBalanceHigh.sol";
+
+/**
+ * @title  CheckBalanceHighTest
+ * @notice Tests the CheckBalanceHigh contract via fuzzing both the success case
+ *         and the failure case.
+ */
+contract CheckBalanceHighTest is Test {
+    /**
+     * @notice An instance of the CheckBalanceHigh contract.
+     */
+    CheckBalanceHigh c;
+
+    /**
+     * @notice Deploy the `CheckTrue` contract.
+     */
+    function setUp() external {
+        c = new CheckBalanceHigh();
+    }
+
+    /**
+     * @notice Fuzz the `check` function and assert that it always returns true
+     *         when the target's balance is larger than the threshold.
+     */
+    function testFuzz_check_succeeds(address _target, uint256 _threshold) external {
+        CheckBalanceHigh.Params memory p = CheckBalanceHigh.Params({
+            target: _target,
+            threshold: _threshold
+        });
+
+        // prevent overflows
+        vm.assume(_threshold != type(uint256).max);
+        vm.deal(_target, _threshold + 1);
+
+        assertEq(c.check(abi.encode(p)), true);
+    }
+
+    /**
+     * @notice Fuzz the `check` function and assert that it always returns false
+     *         when the target's balance is smaller than the threshold.
+     */
+    function testFuzz_check_fails(address _target, uint256 _threshold) external {
+        CheckBalanceHigh.Params memory p = CheckBalanceHigh.Params({
+            target: _target,
+            threshold: _threshold
+        });
+
+        vm.assume(_target.balance < _threshold);
+
+        assertEq(c.check(abi.encode(p)), false);
+    }
+}

packages/contracts-periphery/contracts/foundry-tests/CheckBalanceLow.t.sol

+//SPDX-License-Identifier: MIT
+pragma solidity 0.8.16;
+
+import { Test } from "forge-std/Test.sol";
+import { CheckBalanceLow } from "../universal/drippie/dripchecks/CheckBalanceLow.sol";
+
+/**
+ * @title  CheckBalanceLowTest
+ * @notice Tests the CheckBalanceLow contract via fuzzing both the success case
+ *         and the failure case.
+ */
+contract CheckBalanceLowTest is Test {
+    /**
+     * @notice An instance of the CheckBalanceLow contract.
+     */
+    CheckBalanceLow c;
+
+    /**
+     * @notice Deploy the `CheckBalanceLow` contract.
+     */
+    function setUp() external {
+        c = new CheckBalanceLow();
+    }
+
+    /**
+     * @notice Fuzz the `check` function and assert that it always returns true
+     *         when the target's balance is smaller than the threshold.
+     */
+    function testFuzz_check_succeeds(address _target, uint256 _threshold) external {
+        CheckBalanceLow.Params memory p = CheckBalanceLow.Params({
+            target: _target,
+            threshold: _threshold
+        });
+
+        vm.assume(_target.balance < _threshold);
+
+        assertEq(c.check(abi.encode(p)), true);
+    }
+
+    /**
+     * @notice Fuzz the `check` function and assert that it always returns false
+     *         when the target's balance is larger than the threshold.
+     */
+    function testFuzz_check_fails(address _target, uint256 _threshold) external {
+        CheckBalanceLow.Params memory p = CheckBalanceLow.Params({
+            target: _target,
+            threshold: _threshold
+        });
+
+        // prevent overflows
+        vm.assume(_threshold != type(uint256).max);
+        vm.deal(_target, _threshold + 1);
+
+        assertEq(c.check(abi.encode(p)), false);
+    }
+}

packages/contracts-periphery/contracts/foundry-tests/CheckGelatoLow.t.sol

+//SPDX-License-Identifier: MIT
+pragma solidity 0.8.16;
+
+import { Test } from "forge-std/Test.sol";
+import {
+    CheckGelatoLow,
+    IGelatoTreasury
+} from "../universal/drippie/dripchecks/CheckGelatoLow.sol";
+
+/**
+ * @title  MockGelatoTreasury
+ * @notice Mocks the Gelato treasury for testing purposes. Allows arbitrary
+ *         setting of user balances.
+ */
+contract MockGelatoTreasury is IGelatoTreasury {
+    mapping(address => mapping(address => uint256)) private tokenBalances;
+
+    function setTokenBalance(
+        address _user,
+        address _token,
+        uint256 _balance
+    ) external {
+        tokenBalances[_token][_user] = _balance;
+    }
+
+    function userTokenBalance(address _user, address _token) external view returns (uint256) {
+        return tokenBalances[_token][_user];
+    }
+}
+
+/**
+ * @title  CheckGelatoLowTest
+ * @notice Tests the CheckBalanceHigh contract via fuzzing both the success case
+ *         and the failure case.
+ */
+contract CheckGelatoLowTest is Test {
+    /**
+     * @notice An instance of the CheckGelatoLow contract.
+     */
+    CheckGelatoLow c;
+
+    /**
+     * @notice An instance of the MockGelatoTreasury contract.
+     */
+    MockGelatoTreasury gelato;
+
+    /**
+     * @notice The account Gelato uses to represent ether
+     */
+    address internal constant eth = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+
+    /**
+     * @notice Deploy the `CheckGelatoLow` and `MockGelatoTreasury` contracts.
+     */
+    function setUp() external {
+        c = new CheckGelatoLow();
+        gelato = new MockGelatoTreasury();
+    }
+
+    /**
+     * @notice Fuzz the `check` function and assert that it always returns true
+     *         when the user's balance in the treasury is less than the threshold.
+     */
+    function testFuzz_check_succeeds(uint256 _threshold, address _recipient) external {
+        CheckGelatoLow.Params memory p = CheckGelatoLow.Params({
+            treasury: address(gelato),
+            threshold: _threshold,
+            recipient: _recipient
+        });
+
+        vm.assume(gelato.userTokenBalance(_recipient, eth) < _threshold);
+
+        assertEq(c.check(abi.encode(p)), true);
+    }
+
+    /**
+     * @notice Fuzz the `check` function and assert that it always returns false
+     *         when the user's balance in the treasury is greater than or equal
+     *         to the threshold.
+     */
+    function testFuzz_check_fails(uint256 _threshold, address _recipient) external {
+        CheckGelatoLow.Params memory p = CheckGelatoLow.Params({
+            treasury: address(gelato),
+            threshold: _threshold,
+            recipient: _recipient
+        });
+
+        gelato.setTokenBalance(_recipient, eth, _threshold);
+
+        assertEq(c.check(abi.encode(p)), false);
+    }
+}

packages/contracts-periphery/contracts/foundry-tests/CheckTrue.t.sol

+//SPDX-License-Identifier: MIT
+pragma solidity 0.8.16;
+
+import { Test } from "forge-std/Test.sol";
+import { CheckTrue } from "../universal/drippie/dripchecks/CheckTrue.sol";
+
+/**
+ * @title  CheckTrueTest
+ * @notice Ensures that the CheckTrue DripCheck contract always returns true.
+ */
+contract CheckTrueTest is Test {
+    /**
+     * @notice An instance of the CheckTrue contract.
+     */
+    CheckTrue c;
+
+    /**
+     * @notice Deploy the `CheckTrue` contract.
+     */
+    function setUp() external {
+        c = new CheckTrue();
+    }
+
+    /**
+     * @notice Fuzz the `check` function and assert that it always returns true.
+     */
+    function testFuzz_always_true_succeeds(bytes memory input) external {
+        assertEq(c.check(input), true);
+    }
+}