Error in Fuzz tests in stablecoin

[heheboii11]

This is my Handler.t.sol file

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

import {Test} from "forge-std/Test.sol";
import {StdInvariant} from "forge-std/StdInvariant.sol";
import {DSCEngine} from "../../src/DSCEngine.sol";
import {HelperConfig} from "../../script/HelperConfig.s.sol";
import {console} from "forge-std/console.sol";
import {decentralisedstablecoin} from "../../src/DecentralisedStableCoin.sol";
import {DeployDsc} from "../../script/DeployDSC.s.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20Mock} from "@openzeppelin/contracts/mocks/ERC20Mock.sol";

contract Handler is Test {
    DSCEngine engine;
    decentralisedstablecoin coin;
    ERC20Mock weth;
    ERC20Mock wbtc;
    ERC20Mock erc;
    uint256 MaxAmountOfCollateral = type(uint96).max;

    constructor(DSCEngine _engine, decentralisedstablecoin _coin) {
        engine = _engine;
        coin = _coin;
        address[] memory CollateralAddress = engine.getCollateraddress();
        weth = ERC20Mock(CollateralAddress[0]);
        wbtc = ERC20Mock(CollateralAddress[1]);
    }

    function mintdsc(uint256 amount) public {
        (uint256 totaldscminted, uint256 collateralvalue) = engine.getAccountinfo(msg.sender);
        int256 MaxDsccanmint = (int256(collateralvalue) / 2 - int256(totaldscminted));
        if (MaxDsccanmint < 0) {
            return;
        }

        amount = bound(amount, 0, uint256(MaxDsccanmint));
        if (amount == 0) {
            return;
        }
        vm.startPrank(msg.sender);
        engine.MintDSC(amount);
        vm.stopPrank();
    }

    function depositCollateral(uint256 CollateralSeed, uint256 amountofCollateral) public {
        ERC20Mock collateral = getCollateralSeed(CollateralSeed);
        amountofCollateral = bound(amountofCollateral, 1, MaxAmountOfCollateral);
        console.log("ADDRESS:", address(collateral));
        vm.startPrank(msg.sender);
        //collateral.mint(msg.sender, amountofCollateral);
        deal(address(collateral), msg.sender, amountofCollateral);
        ERC20Mock(collateral).approve(address(engine), amountofCollateral);
        console.log("Balance:", ERC20Mock(collateral).balanceOf(address(msg.sender)));
        engine.depositCollateral(address(collateral), amountofCollateral);
        vm.stopPrank();
    }

    function Collateralredeem(uint256 CollateralSeed, uint256 amountofCollateral) public {
        ERC20Mock collateral = getCollateralSeed(CollateralSeed);
        //uint256 DScValueInCollateral =
        uint256 Maxredeem = engine.getCollateralwithUser(address(collateral), msg.sender);
        /// in here we have tweek a bit that we have to check DSC that are already minted and deduct from maxAmount

        amountofCollateral = bound(amountofCollateral, 0, Maxredeem);
        if (amountofCollateral == 0) {
            return;
        }
        vm.startPrank(msg.sender);
        engine.redeemcollateral(address(collateral), amountofCollateral);
        vm.stopPrank();
    }

    //helper functions

    function getCollateralSeed(uint256 CollateralSeed) private view returns (ERC20Mock) {
        if (CollateralSeed % 2 == 0) {
            return weth;
        } else {
            return wbtc;
        }
    }
}

and while running the fuzz test withfail_on_revert true, I am getting this error

[FAIL: invariant_collateralgreaterThanDSC persisted failure revert]
        [Sequence]
                sender=0x0000000000000000068D95e41e85E7bC10fa45D1 addr=[test/Fuzz/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=depositCollateral(uint256,uint256) args=[23154911922604086471524518417751568975680419950198824690743055301732506533888 [2.315e76], 4262]
                sender=0x0000000000000000068D95e41e85E7bC10fa45D1 addr=[test/Fuzz/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=mintdsc(uint256) args=[115792089237316195423570985008687907853269984665640564039457584007913129639932 [1.157e77]]
                sender=0x0000000000000000068D95e41e85E7bC10fa45D1 addr=[test/Fuzz/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=Collateralredeem(uint256,uint256) args=[219228 [2.192e5], 1164005204 [1.164e9]]
 invariant_collateralgreaterThanDSC() (runs: 1, calls: 1, reverts: 1)
Logs:
  Bound result 4262
  ADDRESS: 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
  Balance: 4262
  Bound result 4261997
  Bound result 1580

Traces:
  [324893] Handler::depositCollateral(23154911922604086471524518417751568975680419950198824690743055301732506533888 [2.315e76], 4262)
    ├─ [0] console::log("Bound result", 4262) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log("ADDRESS:", ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] VM::startPrank(0x0000000000000000068D95e41e85E7bC10fa45D1)
    │   └─ ← [Return] 
    ├─ [2607] ERC20Mock::balanceOf(0x0000000000000000068D95e41e85E7bC10fa45D1) [staticcall]
    │   └─ ← [Return] 0
    ├─ [0] VM::record()
    │   └─ ← [Return] 
    ├─ [607] ERC20Mock::balanceOf(0x0000000000000000068D95e41e85E7bC10fa45D1) [staticcall]
    │   └─ ← [Return] 0
    ├─ [0] VM::accesses(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496])
    │   └─ ← [Return] [0x9300aeaca45e744f7134875d752d366089670f123f8175b59b033721cbc02e32], []
    ├─ [0] VM::load(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 0x9300aeaca45e744f7134875d752d366089670f123f8175b59b033721cbc02e32) [staticcall]
    │   └─ ← [Return] 0x0000000000000000000000000000000000000000000000000000000000000000
    ├─ emit WARNING_UninitedSlot(who: ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], slot: 66491194300025399493108091171551622097081091565944151924603000283572039855666 [6.649e76])
    ├─ [0] VM::load(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 0x9300aeaca45e744f7134875d752d366089670f123f8175b59b033721cbc02e32) [staticcall]
    │   └─ ← [Return] 0x0000000000000000000000000000000000000000000000000000000000000000
    ├─ [607] ERC20Mock::balanceOf(0x0000000000000000068D95e41e85E7bC10fa45D1) [staticcall]
    │   └─ ← [Return] 0
    ├─ [0] VM::store(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 0x9300aeaca45e744f7134875d752d366089670f123f8175b59b033721cbc02e32, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
    │   └─ ← [Return] 
    ├─ [607] ERC20Mock::balanceOf(0x0000000000000000068D95e41e85E7bC10fa45D1) [staticcall]
    │   └─ ← [Return] 115792089237316195423570985008687907853269984665640564039457584007913129639935 [1.157e77]
    ├─ [0] VM::store(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 0x9300aeaca45e744f7134875d752d366089670f123f8175b59b033721cbc02e32, 0x0000000000000000000000000000000000000000000000000000000000000000)
    │   └─ ← [Return] 
    ├─ emit SlotFound(who: ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], fsig: 0x70a08231, keysHash: 0x9300aeaca45e744f7134875d752d366089670f123f8175b59b033721cbc02e32, slot: 66491194300025399493108091171551622097081091565944151924603000283572039855666 [6.649e76])
    ├─ [0] VM::load(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 0x9300aeaca45e744f7134875d752d366089670f123f8175b59b033721cbc02e32) [staticcall]
    │   └─ ← [Return] 0x0000000000000000000000000000000000000000000000000000000000000000
    ├─ [0] VM::store(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 0x9300aeaca45e744f7134875d752d366089670f123f8175b59b033721cbc02e32, 0x00000000000000000000000000000000000000000000000000000000000010a6)
    │   └─ ← [Return] 
    ├─ [607] ERC20Mock::balanceOf(0x0000000000000000068D95e41e85E7bC10fa45D1) [staticcall]
    │   └─ ← [Return] 4262
    ├─ [24651] ERC20Mock::approve(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 4262)
    │   ├─ emit Approval(owner: 0x0000000000000000068D95e41e85E7bC10fa45D1, spender: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 4262)
    │   └─ ← [Return] true
    ├─ [607] ERC20Mock::balanceOf(0x0000000000000000068D95e41e85E7bC10fa45D1) [staticcall]
    │   └─ ← [Return] 4262
    ├─ [0] console::log("Balance:", 4262) [staticcall]
    │   └─ ← [Stop] 
    ├─ [60261] DSCEngine::depositCollateral(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 4262)
    │   ├─ emit Collateraldeposited(user: 0x0000000000000000068D95e41e85E7bC10fa45D1, token: ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], amount: 4262)
    │   ├─ [27689] ERC20Mock::transferFrom(0x0000000000000000068D95e41e85E7bC10fa45D1, DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 4262)
    │   │   ├─ emit Approval(owner: 0x0000000000000000068D95e41e85E7bC10fa45D1, spender: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 0)
    │   │   ├─ emit Transfer(from: 0x0000000000000000068D95e41e85E7bC10fa45D1, to: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 4262)
    │   │   └─ ← [Return] true
    │   └─ ← [Stop] 
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return] 
    └─ ← [Stop] 

  [141486] Handler::mintdsc(115792089237316195423570985008687907853269984665640564039457584007913129639932 [1.157e77])
    ├─ [43708] DSCEngine::getAccountinfo(0x0000000000000000068D95e41e85E7bC10fa45D1) [staticcall]
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   └─ ← [Return] 0, 8524000 [8.524e6]
    ├─ [0] console::log("Bound result", 4261997 [4.261e6]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] VM::startPrank(0x0000000000000000068D95e41e85E7bC10fa45D1)
    │   └─ ← [Return] 
    ├─ [84426] DSCEngine::MintDSC(4261997 [4.261e6])
    │   ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   ├─ [48965] decentralisedstablecoin::mint(0x0000000000000000068D95e41e85E7bC10fa45D1, 4261997 [4.261e6])
    │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x0000000000000000068D95e41e85E7bC10fa45D1, value: 4261997 [4.261e6])
    │   │   └─ ← [Return] true
    │   └─ ← [Stop] 
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return] 
    └─ ← [Stop] 

  [98750] Handler::Collateralredeem(219228 [2.192e5], 1164005204 [1.164e9])
    ├─ [2805] DSCEngine::getCollateralwithUser(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 0x0000000000000000068D95e41e85E7bC10fa45D1) [staticcall]
    │   └─ ← [Return] 4262
    ├─ [0] console::log("Bound result", 1580) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] VM::startPrank(0x0000000000000000068D95e41e85E7bC10fa45D1)
    │   └─ ← [Return] 
    ├─ [80848] DSCEngine::redeemcollateral(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 1580)
    │   ├─ emit CollateralRedeemed(from: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], to: 0x0000000000000000068D95e41e85E7bC10fa45D1, token: ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], amount: 1580)
    │   ├─ [29805] ERC20Mock::transfer(0x0000000000000000068D95e41e85E7bC10fa45D1, 1580)
    │   │   ├─ emit Transfer(from: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], to: 0x0000000000000000068D95e41e85E7bC10fa45D1, value: 1580)
    │   │   └─ ← [Return] true
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   └─ ← [Revert] DSCEngine__HealthFactorIsLessThan(629282470165980877 [6.292e17])
    └─ ← [Revert] DSCEngine__HealthFactorIsLessThan(629282470165980877 [6.292e17])

  [58809] InvariantTest::invariant_collateralgreaterThanDSC()
    ├─ [2349] decentralisedstablecoin::totalSupply() [staticcall]
    │   └─ ← [Return] 4261997 [4.261e6]
    ├─ [2607] ERC20Mock::balanceOf(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512]) [staticcall]
    │   └─ ← [Return] 4262
    ├─ [2607] ERC20Mock::balanceOf(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512]) [staticcall]
    │   └─ ← [Return] 0
    ├─ [15046] DSCEngine::getTokenValueInUSD(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 4262) [staticcall]
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Return] 8524000 [8.524e6]
    ├─ [15046] DSCEngine::getTokenValueInUSD(ERC20Mock: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], 0) [staticcall]
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   └─ ← [Return] 0
    └─ ← [Stop] 

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

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

Failing tests:
Encountered 1 failing test in test/Fuzz/Invariants.t.sol:InvariantTest
[FAIL: invariant_collateralgreaterThanDSC persisted failure revert]
        [Sequence]
                sender=0x0000000000000000068D95e41e85E7bC10fa45D1 addr=[test/Fuzz/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=depositCollateral(uint256,uint256) args=[23154911922604086471524518417751568975680419950198824690743055301732506533888 [2.315e76], 4262]
                sender=0x0000000000000000068D95e41e85E7bC10fa45D1 addr=[test/Fuzz/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=mintdsc(uint256) args=[115792089237316195423570985008687907853269984665640564039457584007913129639932 [1.157e77]]
                sender=0x0000000000000000068D95e41e85E7bC10fa45D1 addr=[test/Fuzz/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=Collateralredeem(uint256,uint256) args=[219228 [2.192e5], 1164005204 [1.164e9]]
 invariant_collateralgreaterThanDSC() (runs: 1, calls: 1, reverts: 1)

As far as I can see, in here it is getting reverted because of the healthfactor is getting broken as it is obvious because it is calling redeem collateral after depositing collateral and minting dsc and because of this the healthfactor is getting broken. Can anyone please help me to guide through this problem.

[EngrPips]

Hello @heheboii11, There is nothing wrong with the Fuzzer calling depositCollateral, then mintDsc, and then redeemCollateral, as that seems like a very reasonable call chain for the protocol. So, I advise you to take the time to study the stack trace below and maybe use console.log to print out values and see what is going wrong and what values are weird. Debugging is part of the job, and you really need to get good at it.

[98750] Handler::Collateralredeem(219228 [2.192e5], 1164005204 [1.164e9])
    ├─ [2805] DSCEngine::getCollateralwithUser(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 0x0000000000000000068D95e41e85E7bC10fa45D1) [staticcall]
    │   └─ ← [Return] 4262
    ├─ [0] console::log("Bound result", 1580) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] VM::startPrank(0x0000000000000000068D95e41e85E7bC10fa45D1)
    │   └─ ← [Return] 
    ├─ [80848] DSCEngine::redeemcollateral(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 1580)
    │   ├─ emit CollateralRedeemed(from: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], to: 0x0000000000000000068D95e41e85E7bC10fa45D1, token: ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], amount: 1580)
    │   ├─ [29805] ERC20Mock::transfer(0x0000000000000000068D95e41e85E7bC10fa45D1, 1580)
    │   │   ├─ emit Transfer(from: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], to: 0x0000000000000000068D95e41e85E7bC10fa45D1, value: 1580)
    │   │   └─ ← [Return] true
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   └─ ← [Revert] DSCEngine__HealthFactorIsLessThan(629282470165980877 [6.292e17])
    └─ ← [Revert] DSCEngine__HealthFactorIsLessThan(629282470165980877 [6.292e17])

[Blockchain-Oracle]

your test is actually corrects based on the implementation i wonder how @PatrickAlphaC got away with that in the video.

your trying to redeem collateral and haven't burn the dsc minted ??
if you try comment out the Collateralredeem your code should work as expected
(fail_on_revert = true this shouldn't brake)

or make sure implement the burn function in the handler or do some bounds making sure , when
user try to redeem collateral shouldn't break health factor

and note this line of code
uint256 Maxredeem = engine.getCollateralwithUser(address(collateral), msg.sender);
only checks for the total collateral deposit , not the total deposit user can withdraw that wont break health factor

[EngrPips]

Interesting

[Blockchain-Oracle]

happy coding ;)

[EngrPips]

Indeed.