Handler Stateful Fuzz Tests #1892

ArnaudBand · 2024-06-27T11:29:52Z

ArnaudBand
Jun 27, 2024

Hello Devs, I'm making my first fuzz test. I'm testing the function invariant_protocolMustHaveMoreValueThanTotalSupply which tests the sum of wethvalue and wbtcvalue greater or equal totalSupply but It fails even if I use handler

Here is my test

    function invariant_protocolMustHaveMoreValueThanTotalSupply() public view {
      uint256 totalSupply = dsc.totalSupply();
      uint256 totalWethDeposited = ERC20Mock(weth).balanceOf(address(engine));
      uint256 totalWbtcDeposited = ERC20Mock(wbtc).balanceOf(address(engine));

      uint256 wethValue = engine.getUsdValue(weth, totalWethDeposited);
      uint256 wbtcValue = engine.getUsdValue(wbtc, totalWbtcDeposited);

      console.log("wethValue: %d", wethValue);
      console.log("wbtcValue: %d", wbtcValue);
      console.log("totalSupply: %d", totalSupply);

      assert(wethValue + wbtcValue >= totalSupply);
    }

Here is the handler contract

// SPDX-License-Identifier: SEE LICENSE IN LICENSE
pragma solidity ^0.8.26;

import {Test} from "forge-std/Test.sol";
import {DSCEngine} from "../../src/DSCEngine.sol";
import {DecentralizedStableCoin} from "../../src/DecentralizedStableCoin.sol";
import {ERC20Mock} from "../mocks/ERC20Mock.sol";

contract Handler is Test {

 DSCEngine engine;
 DecentralizedStableCoin dsc;

 ERC20Mock weth;
 ERC20Mock wbtc;

 uint256 MAX_DEPOSIT_SIZE = type(uint96).max; // The max uint96 value

 constructor(DSCEngine _engine, DecentralizedStableCoin _dsc) {
   engine = _engine;
   dsc = _dsc;

   address[] memory collateralTokens = engine.getCollateralTokens();
   weth = ERC20Mock(collateralTokens[0]);
   wbtc = ERC20Mock(collateralTokens[1]);
 }

 // redeem collateral <-
 function depositCollateral(uint256 collateralSeed, uint256 amountCollateral) public {
   amountCollateral = bound(amountCollateral, 1, MAX_DEPOSIT_SIZE);
   ERC20Mock collateral = _getCollateralFromSeed(collateralSeed);
   vm.startPrank(msg.sender);
   collateral.mint(msg.sender, amountCollateral);
   collateral.approve(address(engine), amountCollateral);
   engine.depositCollateral(address(collateral), amountCollateral);
   vm.stopPrank();
 }

 function _getCollateralFromSeed(uint256 seed) private view returns(ERC20Mock) {
   return seed % 2 == 0 ? weth : wbtc;
 }
}

Here is the error

Failing tests:
Encountered 1 failing test in test/fuzz/InvariantsTest.t.sol:InvariantsTest
[FAIL. Reason: invariant_protocolMustHaveMoreValueThanTotalSupply persisted failure revert]
        [Sequence]
                sender=0x00000000000000000000000000000000E90db8A3 addr=[src/DSCEngine.sol:DSCEngine]0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512 calldata=redeemCollateralForDsc(address,uint256,uint256) args=[0xf6493b3CA2C716E6B5e40E233534CC237c56dDd6, 61583321711932284334241230493870068036402704009442828937579480699 [6.158e64], 76945 [7.694e4]]
 invariant_protocolMustHaveMoreValueThanTotalSupply() (runs: 1, calls: 1, reverts: 1)

Encountered a total of 1 failing tests, 0 tests succeeded
@ArnaudBand ➜ /workspaces/cyfrin_updraft_course/foundry_defi_protocol (tst_test_get_func) $ forge test --match-test invariant_protocolMustHaveMoreValueThanTotalSupply -vvvv
[⠊] Compiling...
[⠘] Compiling 4 files with Solc 0.8.26
[⠃] Solc 0.8.26 finished in 1.63s
Compiler run successful!

Ran 1 test for test/fuzz/InvariantsTest.t.sol:InvariantsTest
[FAIL. Reason: invariant_protocolMustHaveMoreValueThanTotalSupply persisted failure revert]
        [Sequence]
                sender=0x00000000000000000000000000000000E90db8A3 addr=[src/DSCEngine.sol:DSCEngine]0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512 calldata=redeemCollateralForDsc(address,uint256,uint256) args=[0xf6493b3CA2C716E6B5e40E233534CC237c56dDd6, 61583321711932284334241230493870068036402704009442828937579480699 [6.158e64], 76945 [7.694e4]]
 invariant_protocolMustHaveMoreValueThanTotalSupply() (runs: 1, calls: 1, reverts: 1)
Logs:
  wethValue: 0
  wbtcValue: 0
  totalSupply: 0

Traces:
  [10933380] InvariantsTest::setUp()
    ├─ [4456062] → new DeployDSC@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
    │   └─ ← [Return] 22144 bytes of code
    ├─ [5157217] DeployDSC::run()
    │   ├─ [3339508] → new HelperConfig@0x104fBc016F4bb334D775a19E8A6510109AC63E00
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   ├─ [372255] → new MockV3Aggregator@0x90193C961A926261B756D1E5bb255e67ff9498A1
    │   │   │   └─ ← [Return] 1082 bytes of code
    │   │   ├─ [516505] → new ERC20Mock@0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Return] 2117 bytes of code
    │   │   ├─ [372255] → new MockV3Aggregator@0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
    │   │   │   └─ ← [Return] 1082 bytes of code
    │   │   ├─ [516505] → new ERC20Mock@0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Return] 2117 bytes of code
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   └─ ← [Return] 6360 bytes of code
    │   ├─ [912] HelperConfig::activeNetworkConfig() [staticcall]
    │   │   └─ ← [Return] MockV3Aggregator: [0x90193C961A926261B756D1E5bb255e67ff9498A1], MockV3Aggregator: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], ERC20Mock: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76], 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    │   ├─ [0] VM::startBroadcast(<pk>)
    │   │   └─ ← [Return] 
    │   ├─ [591455] → new DecentralizedStableCoin@0x5FbDB2315678afecb367f032d93F642f64180aa3
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)
    │   │   └─ ← [Return] 2610 bytes of code
    │   ├─ [985796] → new DSCEngine@0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
    │   │   └─ ← [Return] 4246 bytes of code
    │   ├─ [2424] DecentralizedStableCoin::transferOwnership(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, newOwner: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   └─ ← [Stop] 
    │   ├─ [0] VM::stopBroadcast()
    │   │   └─ ← [Return] 
    │   └─ ← [Return] DecentralizedStableCoin: [0x5FbDB2315678afecb367f032d93F642f64180aa3], DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], HelperConfig: [0x104fBc016F4bb334D775a19E8A6510109AC63E00]
    ├─ [912] HelperConfig::activeNetworkConfig() [staticcall]
    │   └─ ← [Return] MockV3Aggregator: [0x90193C961A926261B756D1E5bb255e67ff9498A1], MockV3Aggregator: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], ERC20Mock: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76], 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    ├─ [1065237] → new Handler@0x2e234DAe75C793f67A35089C9d99245E1C58470b
    │   ├─ [1378] DSCEngine::getCollateralTokens() [staticcall]
    │   │   └─ ← [Return] [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76]
    │   └─ ← [Return] 4641 bytes of code
    └─ ← [Stop] 

  [2793] DSCEngine::redeemCollateralForDsc(0xf6493b3CA2C716E6B5e40E233534CC237c56dDd6, 61583321711932284334241230493870068036402704009442828937579480699 [6.158e64], 76945 [7.694e4])
    └─ ← [Revert] panic: arithmetic underflow or overflow (0x11)

  [63620] InvariantsTest::invariant_protocolMustHaveMoreValueThanTotalSupply()
    ├─ [2349] DecentralizedStableCoin::totalSupply() [staticcall]
    │   └─ ← [Return] 0
    ├─ [2607] ERC20Mock::balanceOf(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512]) [staticcall]
    │   └─ ← [Return] 0
    ├─ [2607] ERC20Mock::balanceOf(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512]) [staticcall]
    │   └─ ← [Return] 0
    ├─ [15140] DSCEngine::getUsdValue(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 0) [staticcall]
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Return] 0
    ├─ [15140] DSCEngine::getUsdValue(ERC20Mock: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76], 0) [staticcall]
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 4000000000000 [4e12], 1, 1, 1
    │   └─ ← [Return] 0
    ├─ [0] console::log("wethValue: %d", 0) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log("wbtcValue: %d", 0) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log("totalSupply: %d", 0) [staticcall]
    │   └─ ← [Stop] 
    └─ ← [Stop] 

Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 2.57ms (773.69µs CPU time)

Ran 1 test suite in 805.13ms (2.57ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/fuzz/InvariantsTest.t.sol:InvariantsTest
[FAIL. Reason: invariant_protocolMustHaveMoreValueThanTotalSupply persisted failure revert]
        [Sequence]
                sender=0x00000000000000000000000000000000E90db8A3 addr=[src/DSCEngine.sol:DSCEngine]0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512 calldata=redeemCollateralForDsc(address,uint256,uint256) args=[0xf6493b3CA2C716E6B5e40E233534CC237c56dDd6, 61583321711932284334241230493870068036402704009442828937579480699 [6.158e64], 76945 [7.694e4]]
 invariant_protocolMustHaveMoreValueThanTotalSupply() (runs: 1, calls: 1, reverts: 1)

Encountered a total of 1 failing tests, 0 tests succeeded

If you can help me, I will appreciate

Answered by ArnaudBand

Jun 28, 2024

Thank you @EngrPips for your support, I managed to fix the error.

View full answer

EngrPips · 2024-06-27T11:40:01Z

EngrPips
Jun 27, 2024

@ArnaudBand Please show your setup function.

9 replies

EngrPips Jun 27, 2024

Why is your test calling the DSCEngine contract directly instead of calling the handler?

[2793] DSCEngine::redeemCollateralForDsc(0xf6493b3CA2C716E6B5e40E233534CC237c56dDd6, 61583321711932284334241230493870068036402704009442828937579480699 [6.158e64], 76945 [7.694e4])
    └─ ← [Revert] panic: arithmetic underflow or overflow (0x11)

ArnaudBand Jun 27, 2024
Author

This is redeemCollateralForDsc function

    function redeemCollateralForDsc(address tokenCollateralAddress, uint256 amountCollateral, uint256 amountDscToBurn)
        external
    {
        burnDsc(amountDscToBurn);
        redeemCollateral(tokenCollateralAddress, amountCollateral);
    }

EngrPips Jun 27, 2024

I mean, your test is not supposed to be calling the DSCEngine directly at all. This is the stack trace when I run my own test. You can see that my calls are made to the Handler contract and not the DSCEngine.

Traces:
  [12722884] InvariantTest::setUp()
    ├─ [5036870] → new DeployDSCEngine@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
    │   └─ ← [Return] 25044 bytes of code
    ├─ [5858988] DeployDSCEngine::run()
    │   ├─ [749023] → new DecentralizedStableCoin@0x104fBc016F4bb334D775a19E8A6510109AC63E00
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: DeployDSCEngine: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f])
    │   │   └─ ← [Return] 3397 bytes of code
    │   ├─ [3709740] → new HelperConfig@0x037eDa3aDB1198021A9b2e88C22B464fD38db3f3
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   ├─ [658896] → new ERC20Mock@0x90193C961A926261B756D1E5bb255e67ff9498A1
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSCEngine: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000000000000 [1e20])
    │   │   │   └─ ← [Return] 2829 bytes of code
    │   │   ├─ [372455] → new MockV3Aggregator@0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
    │   │   │   └─ ← [Return] 1083 bytes of code
    │   │   ├─ [658896] → new ERC20Mock@0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSCEngine: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000000000000 [1e20])
    │   │   │   └─ ← [Return] 2829 bytes of code
    │   │   ├─ [372455] → new MockV3Aggregator@0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76
    │   │   │   └─ ← [Return] 1083 bytes of code
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   └─ ← [Return] 6891 bytes of code
    │   ├─ [912] HelperConfig::active_network_config() [staticcall]
    │   │   └─ ← [Return] ERC20Mock: [0x90193C961A926261B756D1E5bb255e67ff9498A1], ERC20Mock: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], MockV3Aggregator: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], MockV3Aggregator: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76], 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    │   ├─ [0] VM::startBroadcast(<pk>)
    │   │   └─ ← [Return] 
    │   ├─ [1136158] → new DSCEngine@0x5FbDB2315678afecb367f032d93F642f64180aa3
    │   │   └─ ← [Return] 4997 bytes of code
    │   ├─ [0] VM::stopBroadcast()
    │   │   └─ ← [Return] 
    │   ├─ [2446] DecentralizedStableCoin::transferOwnership(DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3])
    │   │   ├─ emit OwnershipTransferred(previousOwner: DeployDSCEngine: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], newOwner: DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3])
    │   │   └─ ← [Stop] 
    │   └─ ← [Return] DecentralizedStableCoin: [0x104fBc016F4bb334D775a19E8A6510109AC63E00], DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3], HelperConfig: [0x037eDa3aDB1198021A9b2e88C22B464fD38db3f3]
    ├─ [912] HelperConfig::active_network_config() [staticcall]
    │   └─ ← [Return] ERC20Mock: [0x90193C961A926261B756D1E5bb255e67ff9498A1], ERC20Mock: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], MockV3Aggregator: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], MockV3Aggregator: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76], 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    ├─ [1531962] → new Handler@0x2e234DAe75C793f67A35089C9d99245E1C58470b
    │   ├─ [1335] DSCEngine::get_collateral_tokens() [staticcall]
    │   │   └─ ← [Return] [0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3]
    │   ├─ [612] DSCEngine::get_the_price_feed_address_for_token(ERC20Mock: [0x90193C961A926261B756D1E5bb255e67ff9498A1]) [staticcall]
    │   │   └─ ← [Return] MockV3Aggregator: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496]
    │   ├─ [612] DSCEngine::get_the_price_feed_address_for_token(ERC20Mock: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3]) [staticcall]
    │   │   └─ ← [Return] MockV3Aggregator: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76]
    │   └─ ← [Return] 6740 bytes of code
    └─ ← [Stop] 

  [105643] Handler::mint_and_deposit_collateral(false, 659)
    ├─ [0] console::log("Bound Result", 659) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] VM::startPrank(0x0000000000000000dd9cFc42Bf690486e25D366d)
    │   └─ ← [Return] 
    ├─ [29528] ERC20Mock::mint(0x0000000000000000dd9cFc42Bf690486e25D366d, 659)
    │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x0000000000000000dd9cFc42Bf690486e25D366d, value: 659)
    │   └─ ← [Stop] 
    ├─ [24651] ERC20Mock::approve(DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3], 659)
    │   ├─ emit Approval(owner: 0x0000000000000000dd9cFc42Bf690486e25D366d, spender: DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3], value: 659)
    │   └─ ← [Return] true
    ├─ [60216] DSCEngine::depositCollateral(ERC20Mock: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], 659)
    │   ├─ emit collateral_deposited(_user: 0x0000000000000000dd9cFc42Bf690486e25D366d, address_of_collateral_token: ERC20Mock: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], _amount_deposited: 659)
    │   ├─ [27689] ERC20Mock::transferFrom(0x0000000000000000dd9cFc42Bf690486e25D366d, DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3], 659)
    │   │   ├─ emit Approval(owner: 0x0000000000000000dd9cFc42Bf690486e25D366d, spender: DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3], value: 0)
    │   │   ├─ emit Transfer(from: 0x0000000000000000dd9cFc42Bf690486e25D366d, to: DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3], value: 659)
    │   │   └─ ← [Return] true
    │   └─ ← [Stop] 
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return] 
    └─ ← [Stop] 

  [109707] Handler::mint_DSC(0)
    ├─ [0] console::log("Bound Result", 1) [staticcall]
    │   └─ ← [Stop] 
    ├─ [41421] DSCEngine::get_account_collateral_value_in_USD(0x0000000000000000dd9cFc42Bf690486e25D366d) [staticcall]
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Return] 1318000 [1.318e6]
    ├─ [6421] DSCEngine::get_account_collateral_value_in_USD(0x0000000000000000dd9cFc42Bf690486e25D366d) [staticcall]
    │   ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Return] 1318000 [1.318e6]
    ├─ [2390] DecentralizedStableCoin::owner() [staticcall]
    │   └─ ← [Return] DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3]
    ├─ [0] VM::prank(DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3])
    │   └─ ← [Return] 
    ├─ [41238] DSCEngine::mintDSC(1)
    │   ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   ├─ [0] console::log("the total collateral value in usd is: ", 0) [staticcall]
    │   │   └─ ← [Stop] 
    │   ├─ [0] console::log("the total DSC minted is: ", 1) [staticcall]
    │   │   └─ ← [Stop] 
    │   ├─ [0] console::log("the collateral amount for threshold is: ", 0) [staticcall]
    │   │   └─ ← [Stop] 
    │   ├─ [0] console::log("the calculated health factor is: ", 0) [staticcall]
    │   │   └─ ← [Stop] 
    │   └─ ← [Revert] DSCEngine__health_factor_is_broken()
    └─ ← [Revert] DSCEngine__health_factor_is_broken()

  [62680] InvariantTest::invariant_protocol_must_always_have_more_collateral_USD_amount_than_DSC_USD_amount()
    ├─ [2349] DecentralizedStableCoin::totalSupply() [staticcall]
    │   └─ ← [Return] 0
    ├─ [2607] ERC20Mock::balanceOf(DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3]) [staticcall]
    │   └─ ← [Return] 0
    ├─ [2607] ERC20Mock::balanceOf(DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3]) [staticcall]
    │   └─ ← [Return] 659
    ├─ [14985] DSCEngine::get_USD_value(ERC20Mock: [0x90193C961A926261B756D1E5bb255e67ff9498A1], 0) [staticcall]
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   └─ ← [Return] 0
    ├─ [14985] DSCEngine::get_USD_value(ERC20Mock: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], 659) [staticcall]
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Return] 1318000 [1.318e6]
    ├─ [0] console::log("weth value is %s", 0) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log("wbtc value is %s", 1318000 [1.318e6]) [staticcall]
    │   └─ ← [Stop] 
    └─ ← [Stop] 

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

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

Failing tests:
Encountered 1 failing test in test/Invariant/InvariantTest.t.sol:InvariantTest
[FAIL. Reason: invariant_protocol_must_always_have_more_collateral_USD_amount_than_DSC_USD_amount persisted failure revert]
        [Sequence]
                sender=0x0000000000000000dd9cFc42Bf690486e25D366d addr=[test/Invariant/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=mint_and_deposit_collateral(bool,uint256) args=[false, 659]
                sender=0x0000000000000000dd9cFc42Bf690486e25D366d addr=[test/Invariant/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=mint_DSC(uint256) args=[0]
 invariant_protocol_must_always_have_more_collateral_USD_amount_than_DSC_USD_amount() (runs: 1, calls: 1, reverts: 1)

Encountered a total of 1 failing tests, 0 tests succeeded

ArnaudBand Jun 28, 2024
Author

Thank you @EngrPips for your support, I managed to fix the error.

Answer selected by ArnaudBand

EngrPips Jun 28, 2024

Glad you figured it out. Keep crushing it.

EngrPips Jul 11, 2024

Hello @AllenOps08, So your issue arises when your handler calls the depositCollateral function because you did not bound the amount of tokens that the fuzzer will throw at the function. So, in the case of the specific test that you ran, the fuzzer threw 2.821 x 10^67 as the amount token to mint, which works fine as it is not greater than the maximum value a uint256 can hold, which is around (1.1157 x 10^76). After depositCollateral finished executing, the test returned into Invariants::invariant_protocolMustHaveMoreValueThanTotalSupply to do the necessary assertions and confirm that the test passed. In the process of doing that, it had to convert the token minted to its USD value as shown here DSCEngine::getUsdInValue(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 28211925323630272853478772013007940709805564668204041229433519538105 [2.821e67]) [staticcall], So it got the USD price for the token and had to multiply the amount of token minted by the USD value of the token (2 x 10^11). On doing the multiplication, the resulting value exceeds what a tuint256 can hold, and an overflow occurred; hence, the test reverted with └─ ← [Revert] panic: arithmetic underflow or overflow (0x11). Finally, you can look at my depositCollateral function below to see how I bound the amount of tokens that can be minted to prevent this issue.

function mint_and_deposit_collateral(bool _pick_weth ,uint256 _amount_of_collateral) public {
        _amount_of_collateral = bound(_amount_of_collateral, 1, MAX_DEPOSIT_SIZE);
        ERC20Mock collateral = randomly_determine_token(_pick_weth);

        vm.startPrank(msg.sender);
        collateral.mint(msg.sender, _amount_of_collateral);
        collateral.approve(address(dsc_engine), _amount_of_collateral);
        dsc_engine.depositCollateral(address(collateral), _amount_of_collateral);
        vm.stopPrank();
    }

AllenOps08 Jul 11, 2024

Thanks , bounding the variable worked.

EngrPips Jul 11, 2024

Indeed.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Handler Stateful Fuzz Tests #1892

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Replies: 1 comment 9 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

Handler Stateful Fuzz Tests #1892

Replies: 1 comment · 9 replies

ArnaudBand Jun 27, 2024 Author

ArnaudBand Jun 28, 2024 Author

Replies: 1 comment 9 replies

ArnaudBand Jun 27, 2024
Author

ArnaudBand Jun 28, 2024
Author