test of statefulFuzz_testInvariantBreaksHandler keeps failing with unfamiliar error

[Shawon-Mandal]

I ran forge test --mt statefulFuzz_testInvariantBreaksHandler -vvvv from my terminal after setting up the test function of
statefulFuzz_testInvariantBreaksHandler .But now I am getting this error

Encountered 1 failing test in test/handler/Invariant.t.sol:AttemptedBreakTest
[FAIL. Reason: EvmError: Revert] statefulFuzz_testInvariantBreaksHandler() (runs: 65, calls: 2048, reverts: 2048)

I can't seem to figure out why is it reverting every time it was called.

Here is the output of my terminal

forge test --mt statefulFuzz_testInvariantBreaksHandler -vvvv
[⠒] Compiling...
No files changed, compilation skipped

Ran 1 test for test/handler/Invariant.t.sol:AttemptedBreakTest
[FAIL. Reason: EvmError: Revert] statefulFuzz_testInvariantBreaksHandler() (runs: 65, calls: 2048, reverts: 2048)
Traces:
  [2590951] AttemptedBreakTest::setUp()
    ├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
    │   └─ ← [Return] 
    ├─ [564670] → new YeildERC20@0x7BD1119CEC127eeCDBa5DCA7d1Bd59986f6d7353
    │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], value: 1000000000000000000000000 [1e24])
    │   └─ ← [Return] 2351 bytes of code
    ├─ [430367] → new MockUSDC@0x5929B14F2984bBE5309c2eC9E7819060C31c970f
    │   └─ ← [Return] 1924 bytes of code
    ├─ [251] YeildERC20::INITIAL_SUPPLY() [staticcall]
    │   └─ ← [Return] 1000000000000000000000000 [1e24]
    ├─ [46789] MockUSDC::mint(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 1000000000000000000000000 [1e24])
    │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], value: 1000000000000000000000000 [1e24])
    │   └─ ← [Stop] 
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return] 
    ├─ [1171763] → new Handler@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
    │   └─ ← [Return] 5296 bytes of code
    └─ ← [Stop] 

Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 307.82ms (306.18ms CPU time)

Ran 1 test suite in 1.54s (307.82ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/handler/Invariant.t.sol:AttemptedBreakTest
[FAIL. Reason: EvmError: Revert] statefulFuzz_testInvariantBreaksHandler() (runs: 65, calls: 2048, reverts: 2048)

Encountered a total of 1 failing tests, 0 tests succeeded 

[EngrPips]

Hello @Shawon-Mandal , can you please push your code to github and share the link with me so that i can set it up on my machine and try debug it. But actually what makes most sense to me considering every single call revert is that you didn't set up your handler properly and the fuzzer is running impossible scenarios either by trying to deposit on a token address that is not supported by the contract, trying to deposit with an address that doesn't have a token et cetera.

Push your code to github, i will clone and set it up locally on my machine and maybe i would be able to figure what is wrong

[Shawon-Mandal]

@EngrPips Thank you for your response. Here is me code repository : https://github.com/Shawon-Mandal/Handler-test

[EngrPips]

Hello @Shawon-Mandal, actually show your test file and your handler. With that, we can figure out what the issue is. I might not be chanced to set up the repo anytime soon, and I wouldn't like to leave you hanging

[Shawon-Mandal]

@EngrPips
Here is my Invariant.t.sol file

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {Test} from "forge-std/Test.sol";
import {StdInvariant} from "forge-std/StdInvariant.sol";
import {HandlerStatefulFuzzCatches} from "../../src/invariant-break/HandlerStatefulFuzzCatches.sol";
//src/invariant-break/HandlerStatefulFuzzCatches.sol
import {MockUSDC} from "../mocks/MockUSDC.sol";
import {YeildERC20} from "../mocks/YeildERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Handler} from "./Handler.t.sol";

contract AttemptedBreakTest is StdInvariant, Test {
    HandlerStatefulFuzzCatches handlerStatefulFuzzCatches;
    YeildERC20 yeildERC20;
    MockUSDC mockUSDC;
    IERC20[] supportedTokens; // we are importing it into this test because
    //it is set in the contstructor of handlerstatefulfuzzcatches.sol
    uint256 startingAmount;

    address owner = makeAddr("owner");
    Handler handler;

    function setUp() public {
        vm.startPrank(owner);
        //first we are going to launch these tokens

        yeildERC20 = new YeildERC20();
        mockUSDC = new MockUSDC();
        startingAmount = yeildERC20.INITIAL_SUPPLY();
        mockUSDC.mint(owner, startingAmount);
        vm.stopPrank();

        //we are pushing these tokens as suppoorted tokens
        supportedTokens.push(mockUSDC);
        supportedTokens.push(yeildERC20);
        // handlerStatefulFuzzCatches = new HandlerStatefulFuzzCatches(supportedTokens);
        // targetContract(address(handlerStatefulFuzzCatches));

        handler = new Handler(handlerStatefulFuzzCatches, mockUSDC, yeildERC20);

        bytes4[] memory selectors = new bytes4[](4);

        selectors[0] = handler.depositYeildERC20.selector;
        selectors[1] = handler.depositMockUSDC.selector;
        selectors[2] = handler.withdrawYeildERC20.selector;
        selectors[3] = handler.withdrawMockUSDC.selector;

        targetSelector(FuzzSelector({addr: address(handler), selectors: selectors}));
        targetContract(address(handler));
    }

    function statefulFuzz_testInvariantBreaksHandler() public {
        vm.startPrank(owner);
        handlerStatefulFuzzCatches.withdrawToken(mockUSDC);
        handlerStatefulFuzzCatches.withdrawToken(yeildERC20);
        //we're assuming that during the test it will call deposit and we will
        //withdraw the same amount of tokens using this .
        vm.stopPrank();

        assert(mockUSDC.balanceOf(address(handlerStatefulFuzzCatches)) == 0);
        assert(yeildERC20.balanceOf(address(handlerStatefulFuzzCatches)) == 0);
        //the balalnce of both of these tokens will return to zero.

        assert(mockUSDC.balanceOf(owner) == startingAmount);
        assert(yeildERC20.balanceOf(owner) == startingAmount);
        //the balance of the user will return to the same amount as it was before.
    }
}

And here is my handler.t.sol file

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {Test} from "forge-std/Test.sol";
import {HandlerStatefulFuzzCatches} from "../../src/invariant-break/HandlerStatefulFuzzCatches.sol";
import {YeildERC20} from "../mocks/YeildERC20.sol";
import {MockUSDC} from "../mocks/MockUSDC.sol";

contract Handler is Test {
    HandlerStatefulFuzzCatches handlerStatefulFuzzCatches;
    MockUSDC mockUSDC;
    YeildERC20 yeildERC20;
    address owner;

    constructor(HandlerStatefulFuzzCatches _handlerStatefulFuzzCatches, MockUSDC _mockUSDC, YeildERC20 _yeildERC20) {
        handlerStatefulFuzzCatches = _handlerStatefulFuzzCatches;
        mockUSDC = _mockUSDC;
        yeildERC20 = _yeildERC20;
        owner = yeildERC20.owner();
    }

    function depositYeildERC20(uint256 _amount) public {
        uint256 amount = bound(_amount, 0, yeildERC20.balanceOf(owner));
        //"bound" is a mathematical function for wrapping inputs of fuzz tests into a certain range
        /*example : _amount=0,amount will be 0
                    _amount=1,amount will be 1
                     _amount=2,amount will be 2
                    _amount=3,amount will be 3
        */
        vm.startPrank(owner);
        yeildERC20.approve(address(handlerStatefulFuzzCatches), amount);
        handlerStatefulFuzzCatches.depositToken(yeildERC20, amount);
        vm.stopPrank();
    }

    function depositMockUSDC(uint256 _amount) public {
        uint256 amount = bound(_amount, 0, mockUSDC.balanceOf(owner));
        vm.startPrank(owner);
        mockUSDC.approve(address(handlerStatefulFuzzCatches), amount);
        handlerStatefulFuzzCatches.depositToken(mockUSDC, amount);
        vm.stopPrank();
    }

    function withdrawYeildERC20() public {
        vm.startPrank(owner);
        handlerStatefulFuzzCatches.withdrawToken(yeildERC20);
        vm.stopPrank();
    }

    function withdrawMockUSDC() public {
        vm.startPrank(owner);
        handlerStatefulFuzzCatches.withdrawToken(mockUSDC);
        vm.stopPrank();
    }
}

[Shawon-Mandal]

I ran make command again hoping that everything would work properly after setting up the dependencies but now I am getting this error when running forge build and forge test -mt ...

 forge test --mt statefulFuzz_testInvariantBreaksHandler
Compiler run failed:
Warning (5159): "selfdestruct" has been deprecated. The underlying opcode will eventually undergo breaking changes, and its use is not recommended.
  --> src/mishandling-of-eth/SelfDestructMe.sol:45:9:
   |
45 |         selfdestruct(payable(address(target)));
   |         ^^^^^^^^^^^^

Warning (2018): Function state mutability can be restricted to view
  --> test/unit/ArithmeticTest.t.sol:39:5:
   |
39 |     function test_precisionLoss() public {
   |     ^ (Relevant source part starts here and spans across multiple lines).

Warning (2018): Function state mutability can be restricted to view
  --> test/unit/CentralizationTest.t.sol:20:5:
   |
20 |     function testSetUpCentralization() public {
   |     ^ (Relevant source part starts here and spans across multiple lines).

Warning (2018): Function state mutability can be restricted to view
  --> test/unit/OracleManipulation.t.sol:50:5:
   |
50 |     function testStartingPrice() public {
   |     ^ (Relevant source part starts here and spans across multiple lines).

Warning (2018): Function state mutability can be restricted to view
  --> test/unit/WeakRandomnessTest.t.sol:16:5:
   |
16 |     function test_guessRandomNumber() public {
   |     ^ (Relevant source part starts here and spans across multiple lines).

Error (6243): The "tload" instruction is only available for Cancun-compatible VMs (you are currently compiling for "paris").
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:237:22:
    |
237 |             value := tload(slot)
    |                      ^^^^^

Error (8678): Variable count for assignment to "value" does not match number of values (1 vs. 0)
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:237:13:
    |
237 |             value := tload(slot)
    |             ^^^^^^^^^^^^^^^^^^^^

Error (6243): The "tstore" instruction is only available for Cancun-compatible VMs (you are currently compiling for "paris").
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:247:13:
    |
247 |             tstore(slot, value)
    |             ^^^^^^

Error (6243): The "tload" instruction is only available for Cancun-compatible VMs (you are currently compiling for "paris").
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:257:22:
    |
257 |             value := tload(slot)
    |                      ^^^^^

Error (8678): Variable count for assignment to "value" does not match number of values (1 vs. 0)
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:257:13:
    |
257 |             value := tload(slot)
    |             ^^^^^^^^^^^^^^^^^^^^

Error (6243): The "tstore" instruction is only available for Cancun-compatible VMs (you are currently compiling for "paris").
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:267:13:
    |
267 |             tstore(slot, value)
    |             ^^^^^^

Error (6243): The "tload" instruction is only available for Cancun-compatible VMs (you are currently compiling for "paris").
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:277:22:
    |
277 |             value := tload(slot)
    |                      ^^^^^

Error (8678): Variable count for assignment to "value" does not match number of values (1 vs. 0)
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:277:13:
    |
277 |             value := tload(slot)
    |             ^^^^^^^^^^^^^^^^^^^^

Error (6243): The "tstore" instruction is only available for Cancun-compatible VMs (you are currently compiling for "paris").
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:287:13:
    |
287 |             tstore(slot, value)
    |             ^^^^^^

Error (6243): The "tload" instruction is only available for Cancun-compatible VMs (you are currently compiling for "paris").
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:297:22:
    |
297 |             value := tload(slot)
    |                      ^^^^^

Error (8678): Variable count for assignment to "value" does not match number of values (1 vs. 0)
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:297:13:
    |
297 |             value := tload(slot)
    |             ^^^^^^^^^^^^^^^^^^^^

Error (6243): The "tstore" instruction is only available for Cancun-compatible VMs (you are currently compiling for "paris").
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:307:13:
    |
307 |             tstore(slot, value)
    |             ^^^^^^

Error (6243): The "tload" instruction is only available for Cancun-compatible VMs (you are currently compiling for "paris").
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:317:22:
    |
317 |             value := tload(slot)
    |                      ^^^^^

Error (8678): Variable count for assignment to "value" does not match number of values (1 vs. 0)
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:317:13:
    |
317 |             value := tload(slot)
    |             ^^^^^^^^^^^^^^^^^^^^

Error (6243): The "tstore" instruction is only available for Cancun-compatible VMs (you are currently compiling for "paris").
   --> lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol:327:13:
    |
327 |             tstore(slot, value)
    |             ^^^^^^

Error: 
Compilation failed

[EngrPips]

Hello @Shawon-Mandal, In your foundry. toml please set evm_version to shanghai and retry. I am excited to hear back from you.

[Shawon-Mandal]

Like this? @EngrPips

[EngrPips]

Like shown below

Here is the link https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options to details on foundry. toml settings and configuration

[Shawon-Mandal]

@EngrPips Still getting the same error as last time

[Chinwuba22]

Good day @Shawon-Mandal , the issue seems to be from your setUp. You should set your handler as a global vairiable instead of in your setUp: https://github.com/Shawon-Mandal/Handler-test/blob/main/test/handler/Invariant.t.sol#L26

Also, handlerStatefulFuzzCatches was not deployed in your setup, you commented it out: https://github.com/Shawon-Mandal/Handler-test/blob/main/test/handler/Invariant.t.sol#L36

[Shawon-Mandal]

@Chinwuba22 Thank you. I had already changed handler as a global variable and tried again and got the same reverts as before.
Now, I uncommented the line you suggested and can't actually be sure if it works or not as I am getting this compilation error mentioned above. do you think you can suggest me any solutions?

[Chinwuba22]

It worked on my ends after doing the above I suggested.

[Shawon-Mandal]

I am getting this error after running make command in my terminal. Before this, everything worked perfectly fine

[Chinwuba22]

Running make also works perfectly fine here

[Chinwuba22]

The error above seems to be from what you added in your toml file maybe.

[Shawon-Mandal]

@Chinwuba22 I didn't add anything new in my toml file except for evm_version="Shanghai" a few moments ago

[Chinwuba22]

Try removing it

[Shawon-Mandal]

@Chinwuba22 after removing it I got this error again

[Shawon-Mandal]

@Chinwuba22 @EngrPips Thank you both of you. I solved my forge build command problem by setting evm_version="cancun" .
I found this here.

Also, my test error from before is finally resolved by implementing your (@Chinwuba22) suggestions about uncommenting handlerStatefulFuzzCatches and setting up my global variable correctly.

[EngrPips]

Awesome, I am glad you figured it out. Keep crushing it