Arithmetic underflow/overflow error

[Logicalboy101]

Hey, thanks for opening.
I keep getting this error when my invariant test calls redeemCollateral from the handler:

Traces:
  [194928] Handler::depositCollateral(465038 [4.65e5], 1607388025699303352671572946393198540150500166276174215428163619 [1.607e63])
    ├─ [0] console::log("Bound result", 36115437416960531843700016354 [3.611e28]) [staticcall]
    │   └─ ← [Stop]
    ├─ [0] VM::startPrank(0x000000000000000000000000000000000000019a)
    │   └─ ← [Return]
    ├─ [46789] ERC20Mock::mint(0x000000000000000000000000000000000000019a, 36115437416960531843700016354 [3.611e28])
    │   ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x000000000000000000000000000000000000019a, value: 36115437416960531843700016354 [3.611e28])
    │   └─ ← [Stop]
    ├─ [24739] ERC20Mock::approve(DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 36115437416960531843700016354 [3.611e28])
    │   ├─ emit Approval(owner: 0x000000000000000000000000000000000000019a, spender: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 36115437416960531843700016354 [3.611e28])
    │   └─ ← [Return] true
    ├─ [60774] DSCEngine::depositCollateral(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 36115437416960531843700016354 [3.611e28])
    │   ├─ emit CollateralDeposited(user: 0x000000000000000000000000000000000000019a, token: ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], amount: 36115437416960531843700016354 [3.611e28])
    │   ├─ [26062] ERC20Mock::transferFrom(0x000000000000000000000000000000000000019a, DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], 36115437416960531843700016354 [3.611e28])
    │   │   ├─ emit Transfer(from: 0x000000000000000000000000000000000000019a, to: DSCEngine: [0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512], value: 36115437416960531843700016354 [3.611e28])
    │   │   └─ ← [Return] true
    │   └─ ← [Stop]
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return]
    └─ ← [Stop]

  [28005] Handler::redeemCollateral(75378271680337074555070076670754627242662969111118124051249842109322181620 [7.537e73], 233399826203273427687728589052 [2.333e29])
    ├─ [2782] DSCEngine::getAmountDeposited(0x000000000000000000000000000000000000019a, ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496]) [staticcall]
    │   └─ ← [Return] 36115437416960531843700016354 [3.611e28]
    ├─ [0] console::log("Collateral Deposited: ", 36115437416960531843700016354 [3.611e28]) [staticcall]
    │   └─ ← [Stop]
    ├─ [0] console::log("Bound result", 16707201701510236625528490922 [1.67e28]) [staticcall]
    │   └─ ← [Stop]
    ├─ [12296] DSCEngine::redeemCollateral(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 16707201701510236625528490922 [1.67e28])
    │   └─ ← [Revert] panic: arithmetic underflow or overflow (0x11)
    └─ ← [Revert] panic: arithmetic underflow or overflow (0x11)

This is the handler:

// SPDX-License-Identifier: MIT

// Handler is going to narrow down the way we call functions

pragma solidity ^0.8.18;

import { Test, console } 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;

    ERC20Mock weth;
    ERC20Mock wbtc;

    address[] public usersWithCollateralDeposited;

    uint256 public timesMintIsCalled;
    uint256 public constant MAX_DEPOSIT_SIZE = type(uint96).max;
    MockV3Aggregator public ethUsdPriceFeed;
    

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

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

        ethUsdPriceFeed = MockV3Aggregator(dsce.getCollateralTokenPricefeed(address(weth)));
    }

    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);
        if (amountCollateral < 1e18){
            return;
        }
        dsce.depositCollateral(address(collateral), amountCollateral);
        usersWithCollateralDeposited.push(msg.sender);
        vm.stopPrank();
    }

    function mintDsc(uint256 amount, uint256 addressSeed) public {
        if (usersWithCollateralDeposited.length == 0){
            return;
        }

        address sender = usersWithCollateralDeposited[addressSeed % usersWithCollateralDeposited.length]; 
        
        (uint256 totalDscMinted, uint256 collateralDepositedInUsd) = dsce.getAccountInformation(sender);

        int256 maxDscToMint = (int256(collateralDepositedInUsd) / 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 redeemCollateral(uint256 collateralSeed, uint256 amountCollateral) public {
 
        ERC20Mock collateral = _getCollateralFromSeed(collateralSeed);
        uint256 maxCollateralToRedeem = dsce.getAmountDeposited(msg.sender, address(collateral));
        console.log("Collateral Deposited: ", maxCollateralToRedeem);
        amountCollateral = bound(amountCollateral, 0, maxCollateralToRedeem);

         
        if (amountCollateral == 0){
            return;
        }
        dsce.redeemCollateral(address(collateral), amountCollateral);
    }

    // This brakes our test suite!!!!!
    // function updateCollateralPrice(uint96 newPrice) public {
    //     int256 newPriceInt = int256(uint256(newPrice));
    //     ethUsdPriceFeed.updateAnswer(newPriceInt);
    // }

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

This is redeemCollateral function

    function redeemCollateral(address tokenCollateralAddress, uint256 amountCollateral)
        public
        moreThanZero(amountCollateral)
        nonReentrant
        AllowedToken(tokenCollateralAddress)
    {
        _redeemCollateral(msg.sender, msg.sender, tokenCollateralAddress, amountCollateral);
        _revertIfHealthFactorIsBroken(msg.sender);
    }

This is _redeemCollateral function:

function _redeemCollateral(address from, address to, address tokenCollateralAddress, uint256 amountCollateral)
        private
    {
        s_collateralDeposited[from][tokenCollateralAddress] -= amountCollateral;
        emit CollateralRedeemed(from, to, tokenCollateralAddress, amountCollateral);

        bool success = IERC20(tokenCollateralAddress).transfer(to, amountCollateral);
        if (!success) {
            revert DSCEngine__TransferFailed();
        }

        _revertIfHealthFactorIsBroken(msg.sender);
    }

[EngrPips]

Hello @Logicalboy101, The error is coming from the redeemCollateral function inside your DSCEngine contract, I will advice that you use cosole.log inside that function to see if there are values that are weird in the function process.

├─ [12296] DSCEngine::redeemCollateral(ERC20Mock: [0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496], 16707201701510236625528490922 [1.67e28])
    │   └─ ← [Revert] panic: arithmetic underflow or overflow (0x11)
    └─ ← [Revert] panic: arithmetic underflow or overflow (0x11)

[BhamlaPrince]

@Logicalboy101 Can you please tell me what was your error. I have same problem but i am unable to find the error.

[EngrPips]

@Logicalboy101 Can you please tell me what was your error. I have same problem but i am unable to find the error.

You may want to use console.log to view all of the values that you used for calculation inside the redeemCollateral function and see what value is weird.

[BhamlaPrince]

@Logicalboy101 Can you please tell me what was your error. I have same problem but i am unable to find the error.

You may want to use console.log to view all of the values that you used for calculation inside the redeemCollateral function and see what value is weird.

not Getting it

[EngrPips]

How do you mean you are not getting console.log?

[NicolasTfile]

@Logicalboy101 Can you please tell me what was your error. I have same problem but i am unable to find the error.

You may want to use console.log to view all of the values that you used for calculation inside the redeemCollateral function and see what value is weird.

not Getting it

Inside your handler's redeemCollateral function, Include vm.prank(msg.sender) just before you call redeemCollateral()

The msg.sender address needs to be the same that is passed to DSCEngine. That should solve the arithmetic underflow/overflow issue.