Why is every call reverting ?

[Jain-Sameer]

While doing the DeFi section, I am on the start of the Statefull Fuzz Testing.

My code is behaving very weird.

// have our invariants/properties of the system that must hold

//what are our invariants ? 
// 1. total supply of dsc should be less than the total value of collateral
// 2. getter view functions should never revert

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {Test, console} from "../../lib/forge-std/src/Test.sol";
import {StdInvariant} from "../../lib/forge-std/src/StdInvariant.sol";
import {DeployDSC} from "../../script/DeployDSC.s.sol";
import {HelperConfig} from "../../script/HelperConfig.s.sol";
import {DecentralisedStableCoin} from "../../src/DecentralisedStableCoin.sol";
import {DSCEngine} from "../../src/DSCEngine.sol";
import {IERC20} from "../../lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
import {Handler} from "../fuzz/Handler.t.sol";
contract Invariants is StdInvariant, Test {
    DSCEngine dscEngine;
    DecentralisedStableCoin dsc;
    HelperConfig config;
    DeployDSC deployer;
    Handler handler;
    address weth;
    address wbtc;
    function setUp () external {
        deployer = new DeployDSC();
        (dsc, dscEngine, config) = deployer.run();
        (, , weth, wbtc, ) = config.activeNetworkConfig();
        handler = new Handler(dscEngine, dsc);
        console.log("setUP() completed");
        targetContract(address(handler));

        // dont call redeemCollateral unless there is something to redeem
    }

    function invariant_protocolMustHaveMoreValueThanTotalSupply() public view {
        //get value of all the collateral in the protocol
        console.log("test completed");
        //compare it to all the debt (dsc)
        uint256 totalSupply = dsc.totalSupply();
        uint256 wethDeposited = IERC20(weth).balanceOf(address(dscEngine));
        uint256 wbtcDeposited = IERC20(wbtc).balanceOf(address(dscEngine));

        uint256 wethValue = dscEngine.getUSDValue(weth, wethDeposited);
        uint256 wbtcValue = dscEngine.getUSDValue(wbtc, wbtcDeposited);

        assert(wethValue+wbtcValue >= totalSupply);
    }
}

pragma solidity ^0.8.19;

import {Test, console} from "../../lib/forge-std/src/Test.sol";
import {DSCEngine} from "../../src/DSCEngine.sol";
import {DecentralisedStableCoin} from "../../src/DecentralisedStableCoin.sol";

contract Handler is Test {
    DSCEngine dscEngine;
    DecentralisedStableCoin dsc;

    constructor(DSCEngine _dscEngine, DecentralisedStableCoin _dsc) {
        dscEngine = _dscEngine;
        dsc = _dsc;
        console.log("Handler constructor");

    }

    // redeemCollateral
    function depositCollateral(address collateral, uint256 amountCollateral) public {
        console.log("Handler function");
        dscEngine.depositCollateral(collateral, amountCollateral);
    }
}

When I use, revert_on_fail = false , the code doesn't reach the depositCollateral function. But when revert_on_fail = true, the code behaves as expected.

while the option is set to false, I don't get any other function expect the test function inside the staticall tree.
also, when running the test -

[PASS] invariant_protocolMustHaveMoreValueThanTotalSupply() (runs: 128, calls: 16384, reverts: 16384) Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 461.51ms (458.87ms CPU time)

This is what I get. Shouldn't be case, at least some of the calls shouldn't revert.

[EngrPips]

Patrick explained this stuff in the course, and it is obvious you don't understand it. When you set revert_on_fail = false to false that means you are telling the fuzzer not to revert even thou the process failed, and the fuzzer should only revert when the invariant is violated, but the calls might not be able to get to the point where it will check the invariant in all the process because the calls had failed for many other reasons, but you instructed the fuzzer not to revert so it will keep running and eventually it will pass.

I will advice that you go at extremely slow pace for that section as it is very technical.

[Jain-Sameer]

Ran 1 test for test/fuzz/Invariants.t.sol:Invariants
[FAIL: custom error 0x68bc43a1]
        [Sequence]
                sender=0x00000000000000000000000000000000fa7626D5 addr=[test/fuzz/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=depositCollateral(address,uint256) args=[0x62582ee0a39848CBC1960514e939FC4e7BbE084F, 361567134766292 [3.615e14]]
 invariant_protocolMustHaveMoreValueThanTotalSupply() (runs: 0, calls: 0, reverts: 1)
Logs:
  Handler constructor
  setUP() completed
  Handler function
  test completed

Traces:
  [9898785] Invariants::setUp()
    ├─ [4023485] → new DeployDSC@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
    │   └─ ← [Return] 19984 bytes of code
    ├─ [4805210] DeployDSC::run()
    │   ├─ [3058502] → new HelperConfig@0x104fBc016F4bb334D775a19E8A6510109AC63E00
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← [Return]
    │   │   ├─ [362442] → new MockV3Aggregator@0x34A1D3fff3958843C43aD80F30b94c510645C316
    │   │   │   └─ ← [Return] 1033 bytes of code
    │   │   ├─ [436157] → new ERC20Mock@0x90193C961A926261B756D1E5bb255e67ff9498A1
    │   │   │   └─ ← [Return] 1953 bytes of code
    │   │   ├─ [362442] → new MockV3Aggregator@0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
    │   │   │   └─ ← [Return] 1033 bytes of code
    │   │   ├─ [436157] → new ERC20Mock@0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
    │   │   │   └─ ← [Return] 1953 bytes of code
    │   │   ├─ [46784] ERC20Mock::mint(DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], 100000000000 [1e11])
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Stop]
    │   │   ├─ [46784] ERC20Mock::mint(DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], 100000000000 [1e11])
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Stop]
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← [Return]
    │   │   └─ ← [Return] 5387 bytes of code
    │   ├─ [911] HelperConfig::activeNetworkConfig() [staticcall]
    │   │   └─ ← [Return] MockV3Aggregator: [0x34A1D3fff3958843C43aD80F30b94c510645C316], MockV3Aggregator: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], ERC20Mock: [0x90193C961A926261B756D1E5bb255e67ff9498A1], ERC20Mock: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    │   ├─ [0] VM::addr(<pk>) [staticcall]
    │   │   └─ ← [Return] 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
    │   ├─ [0] VM::startBroadcast(<pk>)
    │   │   └─ ← [Return]
    │   ├─ [573999] → new DecentralisedStableCoin@0x5FbDB2315678afecb367f032d93F642f64180aa3
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)
    │   │   └─ ← [Return] 2522 bytes of code
    │   ├─ [931112] → new DSCEngine@0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
    │   │   └─ ← [Return] 3973 bytes of code
    │   ├─ [2421] DecentralisedStableCoin::transferOwnership(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, newOwner: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   └─ ← [Stop]
    │   ├─ [0] VM::stopBroadcast()
    │   │   └─ ← [Return]
    │   └─ ← [Return] DecentralisedStableCoin: [0x5FbDB2315678afecb367f032d93F642f64180aa3], DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], HelperConfig: [0x104fBc016F4bb334D775a19E8A6510109AC63E00]
    ├─ [911] HelperConfig::activeNetworkConfig() [staticcall]
    │   └─ ← [Return] MockV3Aggregator: [0x34A1D3fff3958843C43aD80F30b94c510645C316], MockV3Aggregator: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], ERC20Mock: [0x90193C961A926261B756D1E5bb255e67ff9498A1], ERC20Mock: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    ├─ [813673] → new Handler@0x2e234DAe75C793f67A35089C9d99245E1C58470b
    │   ├─ [0] console::log("Handler constructor") [staticcall]
    │   │   └─ ← [Stop]
    │   └─ ← [Return] 3714 bytes of code
    ├─ [0] console::log("setUP() completed") [staticcall]
    │   └─ ← [Stop]
    └─ ← [Stop]

  [11092] Handler::depositCollateral(0x62582ee0a39848CBC1960514e939FC4e7BbE084F, 361567134766292 [3.615e14])
    ├─ [0] console::log("Handler function") [staticcall]
    │   └─ ← [Stop]
    ├─ [2646] DSCEngine::depositCollateral(0x62582ee0a39848CBC1960514e939FC4e7BbE084F, 361567134766292 [3.615e14])
    │   └─ ← [Revert] DSCEngine_NotAllowedToken()
    └─ ← [Revert] DSCEngine_NotAllowedToken()

  [61871] Invariants::invariant_protocolMustHaveMoreValueThanTotalSupply()
    ├─ [0] console::log("test completed") [staticcall]
    │   └─ ← [Stop]
    ├─ [2348] DecentralisedStableCoin::totalSupply() [staticcall]
    │   └─ ← [Return] 0
    ├─ [2559] ERC20Mock::balanceOf(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512]) [staticcall]
    │   └─ ← [Return] 0
    ├─ [2559] ERC20Mock::balanceOf(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512]) [staticcall]
    │   └─ ← [Return] 0
    ├─ [15059] DSCEngine::getUSDValue(ERC20Mock: [0x90193C961A926261B756D1E5bb255e67ff9498A1], 0) [staticcall]
    │   ├─ [8991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Return] 0
    ├─ [15059] DSCEngine::getUSDValue(ERC20Mock: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], 0) [staticcall]
    │   ├─ [8991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   └─ ← [Return] 0
    └─ ← [Stop]

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

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

Failing tests:
Encountered 1 failing test in test/fuzz/Invariants.t.sol:Invariants
[FAIL: custom error 0x68bc43a1]
        [Sequence]
                sender=0x00000000000000000000000000000000fa7626D5 addr=[test/fuzz/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=depositCollateral(address,uint256) args=[0x62582ee0a39848CBC1960514e939FC4e7BbE084F, 361567134766292 [3.615e14]]
 invariant_protocolMustHaveMoreValueThanTotalSupply() (runs: 0, calls: 0, reverts: 1)

Encountered a total of 1 failing tests, 0 tests succeeded

[Jain-Sameer]

@KMean you find out something in this ?

[EngrPips]

This looks kind of different from the stack trace when revert_on_fail = false.

[Jain-Sameer]

okay, so just now. I got the issue solved, should have just watched the whole video cos I was trying to match the results. Equinous helped me out on discord! Thanks guys for your time.

[EngrPips]

Awesome, Keep crushing it.