Failing when setting fail on revert = true. #1863

hard1k7724 · 2024-06-21T12:13:06Z

hard1k7724
Jun 21, 2024

When I run my handler test it passes with 0 reverts, but when I set fail on revert to true, it throws an error : Ran 1 test for test/fuzz/Invariants.t.sol:Invariants
[FAIL. Reason: invariant_protocolMustHaveMoreValueThanTotalSupply persisted failure revert]
[Sequence]
sender=0x0000000000000000000000000000000000000dd9 addr=[test/fuzz/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=depositCollateral(address,uint256) args=[0xDDeaa6F253cBb8855a7a7f17eddD32FE40b61b41, 115792089237316195423570985008687907853269984665640564039457584007913129639933 [1.157e77]]
invariant_protocolMustHaveMoreValueThanTotalSupply() (runs: 1, calls: 1, reverts: 1)
Traces:
[10898465] Invariants::setUp()
├─ [4420818] → new DeployDSC@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
│ └─ ← [Return] 21968 bytes of code
├─ [5156465] DeployDSC::run()
│ ├─ [3336984] → new HelperConfig@0x104fBc016F4bb334D775a19E8A6510109AC63E00
│ │ ├─ [0] VM::startBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [372455] → new MockV3Aggregator@0x90193C961A926261B756D1E5bb255e67ff9498A1
│ │ │ └─ ← [Return] 1083 bytes of code
│ │ ├─ [516543] → new ERC20Mock@0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
│ │ │ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
│ │ │ └─ ← [Return] 2117 bytes of code
│ │ ├─ [372455] → new MockV3Aggregator@0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
│ │ │ └─ ← [Return] 1083 bytes of code
│ │ ├─ [516543] → new ERC20Mock@0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76
│ │ │ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
│ │ │ └─ ← [Return] 2117 bytes of code
│ │ ├─ [0] VM::stopBroadcast()
│ │ │ └─ ← [Return]
│ │ └─ ← [Return] 6345 bytes of code
│ ├─ [912] HelperConfig::activeNetworkConfig() [staticcall]
│ │ └─ ← [Return] MockV3Aggregator: [0x90193C961A926261B756D1E5bb255e67ff9498A1], MockV3Aggregator: [0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3], ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], ERC20Mock: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76], 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
│ ├─ [0] VM::startBroadcast()
│ │ └─ ← [Return]
│ ├─ [591465] → new DecentralizedStableCoin@0x5FbDB2315678afecb367f032d93F642f64180aa3
│ │ ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)
│ │ └─ ← [Return] 2610 bytes of code
│ ├─ [987600] → new DSCEngine@0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
│ │ └─ ← [Return] 4255 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]
├─ [1066148] → new Handler@0x2e234DAe75C793f67A35089C9d99245E1C58470b
│ ├─ [1291] DSCEngine::getCollateralTokens() [staticcall]
│ │ └─ ← [Return] [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76]
│ └─ ← [Return] 4646 bytes of code
└─ ← [Stop]

[235] Handler::depositCollateral(0xDDeaa6F253cBb8855a7a7f17eddD32FE40b61b41, 115792089237316195423570985008687907853269984665640564039457584007913129639933 [1.157e77])
└─ ← [Revert] EvmError: Revert

[63377] Invariants::invariant_protocolMustHaveMoreValueThanTotalSupply()
├─ [2349] DecentralizedStableCoin::totalSupply() [staticcall]
│ └─ ← [Return] 0
├─ [2607] ERC20Mock::balanceOf(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512]) [staticcall]
│ └─ ← [Return] 0
├─ [2607] ERC20Mock::balanceOf(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512]) [staticcall]
│ └─ ← [Return] 0
├─ [15045] DSCEngine::getUsdValue(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 0) [staticcall]
│ ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Return] 0
├─ [15045] DSCEngine::getUsdValue(ERC20Mock: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76], 0) [staticcall]
│ ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
│ └─ ← [Return] 0
├─ [0] console::log("weth value: ", 0) [staticcall]
│ └─ ← [Stop]
├─ [0] console::log("wbtc value: ", 0) [staticcall]
│ └─ ← [Stop]
├─ [0] console::log("Total Supply: ", 0) [staticcall]
│ └─ ← [Stop]
└─ ← [Stop]

Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 6.05ms (1.44ms CPU time)
The test:
`function invariant_protocolMustHaveMoreValueThanTotalSupply() public view {
// get the value of the allthe ollateral in the protocol
// compare it to all the debt(dsc)
uint256 totalSupply = dsc.totalSupply();
uint256 totalWethDeposited = IERC20(weth).balanceOf(address(dsce));
uint256 totalWBtcDeposited = IERC20(wbtc).balanceOf(address(dsce));

    uint256 wethValue = dsce.getUsdValue(weth, totalWethDeposited);
    uint256 wbtcValue = dsce.getUsdValue(wbtc, totalWBtcDeposited);

    console.log("weth value: ", wethValue);
    console.log("wbtc value: ", wbtcValue);
    console.log("Total Supply: ", totalSupply);

    assert(wethValue + wbtcValue >= totalSupply);
}`
Handler code: `pragma solidity ^0.8.18;

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

contract Handler is Test {
DSCEngine dsce;
DecentralizedStableCoin dsc;

ERC20Mock weth;
ERC20Mock wbtc;

uint256 MAX_DEPOSIT_SIZE = type(uint96).max; // this'll allow to get the max uint96 value

constructor(DSCEngine _dscEngine, DecentralizedStableCoin _dsc) {
    dsce = _dscEngine;
    dsc = _dsc;

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

function depositCollateral(
    uint256 collateralSeed,
    uint256 amountCollateral
) public {
    ERC20Mock collateral = _getCollateralFromSeed(collateralSeed);
    amountCollateral = bound(amountCollateral, 1, MAX_DEPOSIT_SIZE);

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

// Helper Functions
function _getCollateralFromSeed(
    uint256 collateralSeed
) private view returns (ERC20Mock) {
    if (collateralSeed % 2 == 0) {
        return weth;
    }
    return wbtc;
}

}`

EngrPips · 2024-06-21T12:40:17Z

EngrPips
Jun 21, 2024

function invariant_protocolMustHaveMoreValueThanTotalSupply() public view {
// get the value of the allthe ollateral in the protocol
// compare it to all the debt(dsc)
uint256 totalSupply = dsc.totalSupply();
uint256 totalWethDeposited = IERC20(weth).balanceOf(address(dsce));
uint256 totalWBtcDeposited = IERC20(wbtc).balanceOf(address(dsce));

    uint256 wethValue = dsce.getUsdValue(weth, totalWethDeposited);
    uint256 wbtcValue = dsce.getUsdValue(wbtc, totalWBtcDeposited);

    console.log("weth value: ", wethValue);
    console.log("wbtc value: ", wbtcValue);
    console.log("Total Supply: ", totalSupply);

    assert(wethValue + wbtcValue >= totalSupply);
}

pragma solidity ^0.8.18;
import {Test} from "forge-std/Test.sol";
import {DSCEngine} from "../../src/DSCEngine.sol";
import {DecentralizedStableCoin} from "../../src/DecentralizedStableCoin.sol";
import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";

contract Handler is Test {
DSCEngine dsce;
DecentralizedStableCoin dsc;

ERC20Mock weth;
ERC20Mock wbtc;

uint256 MAX_DEPOSIT_SIZE = type(uint96).max; // this'll allow to get the max uint96 value

constructor(DSCEngine _dscEngine, DecentralizedStableCoin _dsc) {
    dsce = _dscEngine;
    dsc = _dsc;

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

function depositCollateral(
    uint256 collateralSeed,
    uint256 amountCollateral
) public {
    ERC20Mock collateral = _getCollateralFromSeed(collateralSeed);
    amountCollateral = bound(amountCollateral, 1, MAX_DEPOSIT_SIZE);

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

// Helper Functions
function _getCollateralFromSeed(
    uint256 collateralSeed
) private view returns (ERC20Mock) {
    if (collateralSeed % 2 == 0) {
        return weth;
    }
    return wbtc;
}
}

0 replies

EngrPips · 2024-06-21T12:59:36Z

EngrPips
Jun 21, 2024

Hello @Juice-07, For one reason or another, your test uses a token unknown by the DSCEngine when it is trying to call depositCollateral on the handler contract.

Below are the addresses of known tokens by the DSCEngine

├─ [1291] DSCEngine::getCollateralTokens() [staticcall]
│ │ └─ ← [Return] [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76]
│ └─ ← [Return] 4646 bytes of code
└─ ← [Stop]

Below is the address that your test tried to use when it was called depositCollateral on the handler contract.

[235] Handler::depositCollateral(0xDDeaa6F253cBb8855a7a7f17eddD32FE40b61b41, 115792089237316195423570985008687907853269984665640564039457584007913129639933 [1.157e77])
└─ ← [Revert] EvmError: Revert

Can you figure out why that is happening? If not, I can share my test and all my setup for the test so you can see what you are not doing correctly.

Below is my output for the same test.

Ran 1 test for test/Invariant/InvariantTest.t.sol:InvariantTest
[FAIL. Reason: custom error 3ec9cfb8:]
        [Sequence]
                sender=0x00000000000000000000000000000000084F0bD5 addr=[test/Invariant/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=mint_and_deposit_collateral(bool,uint256) args=[false, 18060995156286468776532446943836546 [1.806e34]]
                sender=0x00000000000000000000000000000000084F0bD5 addr=[test/Invariant/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=mint_DSC(uint256) args=[11193090243552929100603648641620261555102366081199744750908252796 [1.119e64]]
 invariant_protocol_must_always_have_more_collateral_USD_amount_than_DSC_USD_amount() (runs: 42, calls: 5334, reverts: 1)
Logs:
  Bound Result 64001372256114370574481519611
  weth value is 0
  wbtc value is 128002744512228741148963039222000
  Bound Result 41980773572026271336443754021
  the total collateral value in usd is:  0
  the total DSC minted is:  41980773572026271336443754021
  the collateral amount for threshold is:  0
  the calculated health factor is:  0
  weth value is 0
  wbtc value is 128002744512228741148963039222000

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] 

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

  [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] 64001372256114370574481519611 [6.4e28]
    ├─ [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], 64001372256114370574481519611 [6.4e28]) [staticcall]
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Return] 128002744512228741148963039222000 [1.28e32]
    ├─ [0] console::log("weth value is %s", 0) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log("wbtc value is %s", 128002744512228741148963039222000 [1.28e32]) [staticcall]
    │   └─ ← [Stop] 
    └─ ← [Stop] 

  [110116] Handler::mint_DSC(11193090243552929100603648641620261555102366081199744750908252796 [1.119e64])
    ├─ [0] console::log("Bound Result", 41980773572026271336443754021 [4.198e28]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [41421] DSCEngine::get_account_collateral_value_in_USD(0x00000000000000000000000000000000084F0bD5) [staticcall]
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Return] 128002744512228741148963039222000 [1.28e32]
    ├─ [6421] DSCEngine::get_account_collateral_value_in_USD(0x00000000000000000000000000000000084F0bD5) [staticcall]
    │   ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   ├─ [993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Return] 128002744512228741148963039222000 [1.28e32]
    ├─ [2390] DecentralizedStableCoin::owner() [staticcall]
    │   └─ ← [Return] DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3]
    ├─ [0] VM::prank(DSCEngine: [0x5FbDB2315678afecb367f032d93F642f64180aa3])
    │   └─ ← [Return] 
    ├─ [41238] DSCEngine::mintDSC(41980773572026271336443754021 [4.198e28])
    │   ├─ [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: ", 41980773572026271336443754021 [4.198e28]) [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] 64001372256114370574481519611 [6.4e28]
    ├─ [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], 64001372256114370574481519611 [6.4e28]) [staticcall]
    │   ├─ [8993] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Return] 128002744512228741148963039222000 [1.28e32]
    ├─ [0] console::log("weth value is %s", 0) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log("wbtc value is %s", 128002744512228741148963039222000 [1.28e32]) [staticcall]
    │   └─ ← [Stop] 
    └─ ← [Stop] 

Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 5.71s (5.69s CPU time)

Ran 1 test suite in 10.93s (5.71s 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: custom error 3ec9cfb8:]
        [Sequence]
                sender=0x00000000000000000000000000000000084F0bD5 addr=[test/Invariant/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=mint_and_deposit_collateral(bool,uint256) args=[false, 18060995156286468776532446943836546 [1.806e34]]
                sender=0x00000000000000000000000000000000084F0bD5 addr=[test/Invariant/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=mint_DSC(uint256) args=[11193090243552929100603648641620261555102366081199744750908252796 [1.119e64]]
 invariant_protocol_must_always_have_more_collateral_USD_amount_than_DSC_USD_amount() (runs: 42, calls: 5334, reverts: 1)

Encountered a total of 1 failing tests, 0 tests succeeded

I also have fail_on_revert set to true.

23 replies

hard1k7724 Jun 22, 2024
Author

@EngrPips, Sure. https://github.com/Juice-07/foundry-DeFi-StableCoin

EngrPips Jun 22, 2024

Thanks. I will clone this and debug it locally on my machine, and I will let you know whatever I find.

hard1k7724 Jun 24, 2024
Author

@EngrPips, did you find anything regarding the error ?

EngrPips Jun 24, 2024

I cloned the repo already and built it but haven't gotten the chance to debug but I will try to do that today.

hard1k7724 Jun 24, 2024
Author

Okay.

EngrPips · 2024-06-25T09:14:43Z

EngrPips
Jun 25, 2024

Hello @Juice-07, So I got the time to debug your code, and I think i found something. I wouldn't directly point you to what i found since you mentioned that you want to enhance your debugging skills. Compare my output for Handler::mint_and_deposit_collateral and yours and see if you catch anything.

My output for Handler::mint_and_deposit_collateral

[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]

Your output for Handler::mint_and_deposit_collateral

[124802] Handler::mintAndDepositCollateral(15253010732783067804194855451661709012757140991998531914879 [1.525e58], 109287051600633930442037615707777945433927314713 [1.092e47])
    ├─ [0] console::log("Bound result", 31176204170279910451729223793 [3.117e28]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [46789] ERC20Mock::mint(0x0000000000000000000000000000000000001007, 31176204170279910451729223793 [3.117e28])
    │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x0000000000000000000000000000000000001007, value: 31176204170279910451729223793 [3.117e28])
    │   └─ ← [Stop] 
    ├─ [24739] ERC20Mock::approve(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 31176204170279910451729223793 [3.117e28])
    │   ├─ emit Approval(owner: Handler: [0x2e234DAe75C793f67A35089C9d99245E1C58470b], spender: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 31176204170279910451729223793 [3.117e28])
    │   └─ ← [Return] true
    ├─ [36085] DSCEngine::depositCollateral(ERC20Mock: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76], 31176204170279910451729223793 [3.117e28])
    │   ├─ emit CollateralDeposited(user: Handler: [0x2e234DAe75C793f67A35089C9d99245E1C58470b], token: ERC20Mock: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76], amount: 31176204170279910451729223793 [3.117e28])
    │   ├─ [3773] ERC20Mock::transferFrom(Handler: [0x2e234DAe75C793f67A35089C9d99245E1C58470b], DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 31176204170279910451729223793 [3.117e28])
    │   │   └─ ← [Revert] ERC20InsufficientBalance(0x2e234DAe75C793f67A35089C9d99245E1C58470b, 0, 31176204170279910451729223793 [3.117e28])
    │   └─ ← [Revert] ERC20InsufficientBalance(0x2e234DAe75C793f67A35089C9d99245E1C58470b, 0, 31176204170279910451729223793 [3.117e28])
    └─ ← [Revert] ERC20InsufficientBalance(0x2e234DAe75C793f67A35089C9d99245E1C58470b, 0, 31176204170279910451729223793 [3.117e28])

Looking forward to hearing from you

13 replies

hard1k7724 Jun 27, 2024
Author

@EngrPips , actually it was there at first but you told me to modify my codebase according to yours, so before pushing it to github I made changes in the file to make it look like yours.

EngrPips Jun 27, 2024

So, do you still have it in your local file? because clearly, it was called in the test you just showed me the output.

hard1k7724 Jun 27, 2024
Author

No I dont. Here is my local file

//SPDX-License-Identifier:MIT
// Handler is going to narrow down the way we call function

pragma solidity ^0.8.18;

import {Test} from "forge-std/Test.sol";
import {DSCEngine} from "../../src/DSCEngine.sol";
import {DecentralizedStableCoin} from "../../src/DecentralizedStableCoin.sol";
import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";
import {MockV3Aggregator} from "../mocks/MockV3Aggregator.sol";

contract Handler is Test {
    DSCEngine dsce;
    DecentralizedStableCoin dsc;
    MockV3Aggregator public ethUsdPriceFeed;
    MockV3Aggregator public btcUsdPriceFeed;
    ERC20Mock weth;
    ERC20Mock wbtc;

    uint256 public timesMintIsCalled;
    address[] public usersWithCollateralDeposited;

    uint256 MAX_DEPOSIT_SIZE = type(uint96).max; // this'll allow to get the max uint96 value

    constructor(DSCEngine _dscEngine, DecentralizedStableCoin _dsc) {
        dsce = _dscEngine;
        dsc = _dsc;

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

        ethUsdPriceFeed = MockV3Aggregator(
            dsce.getCollateralTokenPriceFeed(address(weth))
        );
        btcUsdPriceFeed = MockV3Aggregator(
            dsce.getCollateralTokenPriceFeed(address(wbtc))
        );
    }

    function mintDsc(uint256 amount, uint256 addressSeed) public {
        if (usersWithCollateralDeposited.length == 0) {
            return;
        }
        address sender = usersWithCollateralDeposited[
            addressSeed % usersWithCollateralDeposited.length
        ];
        (uint256 totalDscMinted, uint256 collateralValueInUsd) = dsce
            .getAccountInformation(sender);
        int256 maxDscToMint = (int256(collateralValueInUsd) / 2) -
            int256(totalDscMinted);
        if (maxDscToMint < 0) {
            return;
        }

        amount = bound(amount, 0, uint256(maxDscToMint));
        if (amount == 0) {
            return;
        }
        vm.startPrank(sender);
        dsce.mintDsc(amount);
        vm.stopPrank();
        timesMintIsCalled++;
    }

    function mintAndDepositCollateral(
        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(dsce), amountCollateral);
        dsce.depositCollateral(address(collateral), amountCollateral);
        usersWithCollateralDeposited.push(msg.sender);
        vm.stopPrank();
    }

    function redeemCollateral(
        uint256 collateralSeed,
        uint256 amountCollateral
    ) public {
        ERC20Mock collateral = _getCollateralFromSeed(collateralSeed);
        uint256 maxCollateralToRedeem = dsce.getCollateralBalanceOfUser(
            address(collateral),
            msg.sender
        );

        amountCollateral = bound(amountCollateral, 0, maxCollateralToRedeem);
        if (amountCollateral == 0) {
            return;
        }
        vm.prank(msg.sender);
        dsce.redeemCollateral(address(collateral), amountCollateral);
    }

    // Helper Functions
    function _getCollateralFromSeed(
        uint256 collateralSeed
    ) private view returns (ERC20Mock) {
        if (collateralSeed % 2 == 0) {
            return weth;
        }
        return wbtc;
    }
}

EngrPips Jun 27, 2024

Now, could you re-run the test and send the output?

hard1k7724 Jun 27, 2024
Author

forge test --mt invariant_protocolMustHaveMoreValueThanTotalSupply -vvvv
[⠆] Compiling...
No files changed, compilation skipped

Ran 1 test for test/fuzz/Invariants.t.sol:Invariants
[FAIL. Reason: invariant_protocolMustHaveMoreValueThanTotalSupply persisted failure revert]
        [Sequence]
                sender=0x0000000000000000000000000000000000000dd9 addr=[test/fuzz/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=depositCollateral(address,uint256) args=[0xDDeaa6F253cBb8855a7a7f17eddD32FE40b61b41, 115792089237316195423570985008687907853269984665640564039457584007913129639933 [1.157e77]]
 invariant_protocolMustHaveMoreValueThanTotalSupply() (runs: 1, calls: 1, reverts: 1)
Traces:
  [11306151] Invariants::setUp()
    ├─ [4426627] → new DeployDSC@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
    │   └─ ← [Return] 21997 bytes of code
    ├─ [5162275] DeployDSC::run()
    │   ├─ [3336984] → new <unknown>@0x104fBc016F4bb334D775a19E8A6510109AC63E00
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   ├─ [372455] → new <unknown>@0x90193C961A926261B756D1E5bb255e67ff9498A1
    │   │   │   └─ ← [Return] 1083 bytes of code
    │   │   ├─ [516543] → new <unknown>@0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Return] 2117 bytes of code
    │   │   ├─ [372455] → new <unknown>@0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
    │   │   │   └─ ← [Return] 1083 bytes of code
    │   │   ├─ [516543] → new <unknown>@0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76
    │   │   │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: DeployDSC: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], value: 100000000000 [1e11])
    │   │   │   └─ ← [Return] 2117 bytes of code
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   └─ ← [Return] 6345 bytes of code
    │   ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkConfig() [staticcall]
    │   │   └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    │   ├─ [0] VM::startBroadcast(<pk>)
    │   │   └─ ← [Return] 
    │   ├─ [591465] → new <unknown>@0x5FbDB2315678afecb367f032d93F642f64180aa3
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)
    │   │   └─ ← [Return] 2610 bytes of code
    │   ├─ [993407] → new DSCEngine@0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
    │   │   └─ ← [Return] 4284 bytes of code
    │   ├─ [2424] 0x5FbDB2315678afecb367f032d93F642f64180aa3::transferOwnership(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   ├─ emit OwnershipTransferred(previousOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, newOwner: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512])
    │   │   └─ ← [Stop] 
    │   ├─ [0] VM::stopBroadcast()
    │   │   └─ ← [Return] 
    │   └─ ← [Return] 0x5FbDB2315678afecb367f032d93F642f64180aa3, DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 0x104fBc016F4bb334D775a19E8A6510109AC63E00
    ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkConfig() [staticcall]
    │   └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
    ├─ [1417745] → new Handler@0x2e234DAe75C793f67A35089C9d99245E1C58470b
    │   ├─ [1291] DSCEngine::getCollateralTokens() [staticcall]
    │   │   └─ ← [Return] [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76]
    │   ├─ [639] DSCEngine::getCollateralTokenPriceFeed(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496) [staticcall]
    │   │   └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1
    │   ├─ [639] DSCEngine::getCollateralTokenPriceFeed(0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76) [staticcall]
    │   │   └─ ← [Return] 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
    │   └─ ← [Return] 6168 bytes of code
    └─ ← [Stop] 

  [235] Handler::depositCollateral(0xDDeaa6F253cBb8855a7a7f17eddD32FE40b61b41, 115792089237316195423570985008687907853269984665640564039457584007913129639933 [1.157e77])
    └─ ← [Revert] EvmError: Revert

  [76394] Invariants::invariant_protocolMustHaveMoreValueThanTotalSupply()
    ├─ [2349] 0x5FbDB2315678afecb367f032d93F642f64180aa3::totalSupply() [staticcall]
    │   └─ ← [Return] 0
    ├─ [2607] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::balanceOf(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512]) [staticcall]
    │   └─ ← [Return] 0
    ├─ [2607] 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76::balanceOf(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512]) [staticcall]
    │   └─ ← [Return] 0
    ├─ [18769] DSCEngine::getUsdValue(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0) [staticcall]
    │   ├─ [12723] OracleLib::staleCheckLatestRoundData() [delegatecall]
    │   │   ├─ [8993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
    │   │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Return] 0
    ├─ [16269] DSCEngine::getUsdValue(0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 0) [staticcall]
    │   ├─ [12723] OracleLib::staleCheckLatestRoundData() [delegatecall]
    │   │   ├─ [8993] 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3::latestRoundData() [staticcall]
    │   │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   │   └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
    │   └─ ← [Return] 0
    ├─ [0] console::log("weth value: ", 0) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log("wbtc value: ", 0) [staticcall]
    │   └─ ← [Stop] 
    ├─ [0] console::log("Total Supply: ", 0) [staticcall]
    │   └─ ← [Stop] 
    ├─ [2362] Handler::timesMintIsCalled() [staticcall]
    │   └─ ← [Return] 0
    ├─ [0] console::log("Times Mint Called: ", 0) [staticcall]
    │   └─ ← [Stop] 
    └─ ← [Stop] 

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

Ran 1 test suite in 5.62s (16.90ms 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. Reason: invariant_protocolMustHaveMoreValueThanTotalSupply persisted failure revert]
        [Sequence]
                sender=0x0000000000000000000000000000000000000dd9 addr=[test/fuzz/Handler.t.sol:Handler]0x2e234DAe75C793f67A35089C9d99245E1C58470b calldata=depositCollateral(address,uint256) args=[0xDDeaa6F253cBb8855a7a7f17eddD32FE40b61b41, 115792089237316195423570985008687907853269984665640564039457584007913129639933 [1.157e77]]
 invariant_protocolMustHaveMoreValueThanTotalSupply() (runs: 1, calls: 1, reverts: 1)

Encountered a total of 1 failing tests, 0 tests succeeded

EngrPips · 2024-06-27T20:25:42Z

EngrPips
Jun 27, 2024

I am really confused, lol. Where is the below coming from? If you don't have depositCollateral in your Handler contract.

[235] Handler::depositCollateral(0xDDeaa6F253cBb8855a7a7f17eddD32FE40b61b41, 115792089237316195423570985008687907853269984665640564039457584007913129639933 [1.157e77])
    └─ ← [Revert] EvmError: Revert

7 replies

EngrPips Jun 28, 2024

I am not sure, How and why this running in your own test.

[235] Handler::depositCollateral(0xDDeaa6F253cBb8855a7a7f17eddD32FE40b61b41, 115792089237316195423570985008687907853269984665640564039457584007913129639933 [1.157e77])
    └─ ← [Revert] EvmError: Revert

This is what runs for me

[124802] Handler::mintAndDepositCollateral(15253010732783067804194855451661709012757140991998531914879 [1.525e58], 109287051600633930442037615707777945433927314713 [1.092e47])
    ├─ [0] console::log("Bound result", 31176204170279910451729223793 [3.117e28]) [staticcall]
    │   └─ ← [Stop] 
    ├─ [46789] ERC20Mock::mint(0x0000000000000000000000000000000000001007, 31176204170279910451729223793 [3.117e28])
    │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x0000000000000000000000000000000000001007, value: 31176204170279910451729223793 [3.117e28])
    │   └─ ← [Stop] 
    ├─ [24739] ERC20Mock::approve(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 31176204170279910451729223793 [3.117e28])
    │   ├─ emit Approval(owner: Handler: [0x2e234DAe75C793f67A35089C9d99245E1C58470b], spender: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 31176204170279910451729223793 [3.117e28])
    │   └─ ← [Return] true
    ├─ [36085] DSCEngine::depositCollateral(ERC20Mock: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76], 31176204170279910451729223793 [3.117e28])
    │   ├─ emit CollateralDeposited(user: Handler: [0x2e234DAe75C793f67A35089C9d99245E1C58470b], token: ERC20Mock: [0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76], amount: 31176204170279910451729223793 [3.117e28])
    │   ├─ [3773] ERC20Mock::transferFrom(Handler: [0x2e234DAe75C793f67A35089C9d99245E1C58470b], DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 31176204170279910451729223793 [3.117e28])
    │   │   └─ ← [Revert] ERC20InsufficientBalance(0x2e234DAe75C793f67A35089C9d99245E1C58470b, 0, 31176204170279910451729223793 [3.117e28])
    │   └─ ← [Revert] ERC20InsufficientBalance(0x2e234DAe75C793f67A35089C9d99245E1C58470b, 0, 31176204170279910451729223793 [3.117e28])
    └─ ← [Revert] ERC20InsufficientBalance(0x2e234DAe75C793f67A35089C9d99245E1C58470b, 0, 31176204170279910451729223793 [3.117e28])

hard1k7724 Jun 28, 2024
Author

This really is confusing. still can you tell me how'd you debug that error on your machine?

EngrPips Jun 29, 2024

Honestly, I will say restart the writing of the test, Follow Patrick step by step, and I believe you will break free from this issue.

hard1k7724 Jun 30, 2024
Author

Okay, Will do so. Thank you tho @EngrPips .

EngrPips Jun 30, 2024

You are welcome. I am looking forward to hearing from you on how that plays out.

Blockchain-Oracle · 2025-01-09T18:16:41Z

Blockchain-Oracle
Jan 9, 2025

@EngrPips , I completely understand how confusing this can be. The reason the transaction is failing is likely because the function is trying to interact with an address that either doesn’t exist or doesn’t have the function implemented. I’ve encountered this issue a few times myself.

I know your question is likely related to the tokenAddress being passed into the constructor ?
of dscEngine. However, if you console.log the address being interacted with, you’ll likely see the issue clearly. I’ve experienced this scenario before.
This mostly occurs when your Using a function to return a contract instance e.g

ERC20Mock erc20Mock = ERC20Mock(tokenAddress);

like his case

function _getCollateralFromSeed(
    uint256 collateralSeed
) private view returns (ERC20Mock) {
    if (collateralSeed % 2 == 0) {
        return weth;
    }
    return wbtc;
}

ERC20Mock erc20MocK = _gerCollateralFreomSeed(seed);
console.log(address(erc20Mock));//

A potential fix would be to clear the cache using forge clean. Another alternative is to ensure you directly instantiating a contract from an address which might also help avoid this issue.

ERC20Mock(address(erc20Mock)).whatever();

in his case would be return address instead of ERC20Mock in _getCollateralFromSeed

function _getCollateralFromSeed(
    uint256 collateralSeed
) private view returns (address) {
    if (collateralSeed % 2 == 0) {
        return collateralTokens[0];
    }
    return collateralTokens[1];
}

address erc20MocKAddress = _gerCollateralFreomSeed(seed);
console.log(address(erc20Mock));

1 reply

EngrPips Jan 9, 2025

Great heads-up.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Failing when setting fail on revert = true. #1863

{{title}}

Replies: 5 comments 44 replies

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

Failing when setting fail on revert = true. #1863

Replies: 5 comments · 44 replies

hard1k7724 Jun 22, 2024 Author

hard1k7724 Jun 24, 2024 Author

hard1k7724 Jun 24, 2024 Author

hard1k7724 Jun 27, 2024 Author

hard1k7724 Jun 27, 2024 Author

hard1k7724 Jun 27, 2024 Author

hard1k7724 Jun 28, 2024 Author

hard1k7724 Jun 30, 2024 Author

Replies: 5 comments 44 replies

hard1k7724 Jun 22, 2024
Author

hard1k7724 Jun 24, 2024
Author

hard1k7724 Jun 24, 2024
Author

hard1k7724 Jun 27, 2024
Author

hard1k7724 Jun 27, 2024
Author

hard1k7724 Jun 27, 2024
Author

hard1k7724 Jun 28, 2024
Author

hard1k7724 Jun 30, 2024
Author