I have two problems regarding the DSCEnigne test on the StableCoin project. #1992

YavorJJ · 2024-07-11T13:47:38Z

YavorJJ
Jul 11, 2024

Hello, two of my tests have been failing, and whatever I do and check it is not fixing.

here are my code files:

solidity
' ' '

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

import {DecentralizedStableCoin} from "./DecentralizedStableCoin.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

/**
 * @title DSCEngine
 * @author Yavor Rusinov
 *
 * The system is designed to be as minimal as possible, and have the tokens maintain a 1 token == $1 peg.
 * This stablecoin has the properties:
 * - Exogenous Collateral
 * - Dollar Pegged
 * - Algorithmically Stable
 *
 * It is similar to DAI if DAI had no governance, no fees, and was only backed by WETH and WBTC.
 *
 * Our DSC system should always be "overcollateralized". At no point, should the value of all collateral <= the $ backed value of all the DSC.
 *
 * @notice This contract is the core of the DSC System. It handles all the logic for mining and redeeming DSC, as well as depositing & withdrawing collateral.
 * @notice This contract is VERY loosely based on the MakerDAO DSS (DAI) system.
 */
contract DSCEngine is ReentrancyGuard {
    //////////////
    /// Errors
    //////////////
    error DSCEngine__NeedsMoreThanZero();
    error DSCEngine__TokenAddressesAndPriceFeedAddressesMustBeSameLength();
    error DSCEngine__NotAllowedToken();
    error DSCEngine__TransferFailed();
    error DSCEngine_BreaksHealthFactor(uint256 healthFactor);
    error DSCEngine__MintFailed();
    error DSCEngine__HealthFactorOk();
    error DSCEngine__HealthFactorNotImproved();
    error DSCEngine__BreaksHealthFactor();
   


    //////////////
    /// State Variables
    //////////////
    uint256 private constant ADDITIONAL_FEED_PRECISION = 1e10;
    uint256 private constant PRECISION = 1e18;
    uint256 private constant LIQUIDATION_THRESHOLD = 50; // 200% overcollateralized
    uint256 private constant LIQUIDATION_PRECISION = 100;
    uint256 private constant MIN_HEALTH_FACTOR = 1e18;
    uint256 private constant LIQUIDATION_BONUS = 10; // this means a 10% bonus for liquidating

    mapping(address => address) private s_priceFeeds;
    mapping(address => mapping(address => uint256)) private s_collateralDeposited;
    mapping(address => uint256) private s_DSCMinted;
    address[] private s_collateralTokens;

    DecentralizedStableCoin private immutable i_dsc;

    //////////////
    /// Events
    //////////////
    event CollateralDeposited(address indexed user, address indexed token, uint256 indexed amount);
    event CollateralRedeemed(address indexed redeemedFrom, address indexed redeemedTo, address indexed token, uint256 amount);

    //////////////
    /// Modifiers
    //////////////
    modifier moreThanZero(uint256 amount) {
        if (amount == 0) {
            revert DSCEngine__NeedsMoreThanZero();
        }
        _;
    }

    modifier isAllowedToken(address token) {
        if (s_priceFeeds[token] == address(0)) {
            revert DSCEngine__NotAllowedToken();
        }
        _;
    }

    //////////////
    /// Functions
    //////////////
    constructor(address[] memory tokenAddresses, address[] memory priceFeedAddresses, address dscAddress) {
        // USD Price Feeds
        if (tokenAddresses.length != priceFeedAddresses.length) {
            revert DSCEngine__TokenAddressesAndPriceFeedAddressesMustBeSameLength();
        }
        // For example ETH / USD, BTC / USD, MKR / USD, etc
        for (uint256 i = 0; i < tokenAddresses.length; i++) {
            s_priceFeeds[tokenAddresses[i]] = priceFeedAddresses[i];
            s_collateralTokens.push(tokenAddresses[i]);
        }
        i_dsc = DecentralizedStableCoin(dscAddress);
    }

    //////////////
    /// External Functions
    //////////////

    /*
    * @param tokenCollateralAddress The address of the token to deposit as collateral
    * @param amountCollateral The amount of collateral to deposit
    * @param amountDscToMint The amount of decentralized stablecoin to mint
    * @notice this function will deposit your collateral and mint DSC in one transaction
    */
    function depositCollateralAndMintDsc(address tokenCollateralAddress, uint256 amountCollateral, uint256 amountDscToMint) external {
        depositCollateral(tokenCollateralAddress, amountCollateral);
        mintDsc(amountDscToMint);
    }

    /**
     * @notice follows CEI
     * @param tokenCollateralAddress The address of the token to deposit as collateral
     * @param amountCollateral The amount of collateral to deposit
     */
    function depositCollateral(address tokenCollateralAddress, uint256 amountCollateral) public moreThanZero(amountCollateral) isAllowedToken(tokenCollateralAddress) nonReentrant {
        s_collateralDeposited[msg.sender][tokenCollateralAddress] += amountCollateral;
        emit CollateralDeposited(msg.sender, tokenCollateralAddress, amountCollateral);
        bool success = IERC20(tokenCollateralAddress).transferFrom(msg.sender, address(this), amountCollateral);
        if (!success) {
            revert DSCEngine__TransferFailed();
        }
    }

    /*
    * @param tokenCollateralAddress The collateral address to redeem
    * @param amountCollateral The amount of collateral to redeem
    * @param amountDscToBurn The amount of DSC to burn
    * This function burns DSC and redeems underlying collateral in one transaction
    */
    function redeemCollateralForDsc(address tokenCollateralAddress, uint256 amountCollateral, uint256 amountDscToBurn) external {
        burnDsc(amountDscToBurn);
        redeemCollateral(tokenCollateralAddress, amountCollateral);
        // redeemCollateral already checks health factor
    }

    // in order to redeem collateral:
    // 1. health factor must be over 1 AFTER collateral is pulled
    // DRY: Don't repeat yourself

    // CEI: Check, Effects, Interactions
    function redeemCollateral(address tokenCollateralAddress, uint256 amountCollateral) public moreThanZero(amountCollateral) nonReentrant {
        _redeemCollateral(msg.sender, msg.sender, tokenCollateralAddress, amountCollateral);
        _revertIfHealthFactorIsBroken(msg.sender);    
    }

    /**
     * @notice follows CEI
     * @param amountDscToMint The amount of decentralized stablecoin to mint
     * @notice they must have more collateral value than the minimum threshold
     */ 
    function mintDsc(uint256 amountDscToMint) public moreThanZero(amountDscToMint) nonReentrant {
        s_DSCMinted[msg.sender] += amountDscToMint;
        // if they minted too much ($150 DSC, $100 ETH)
        _revertIfHealthFactorIsBroken(msg.sender);
        bool minted = i_dsc.mint(msg.sender, amountDscToMint);
        if (!minted) {
            revert DSCEngine__MintFailed();
        }
    }

    function burnDsc(uint256 amount) public moreThanZero(amount) {
        _burnDsc(amount, msg.sender, msg.sender);
        _revertIfHealthFactorIsBroken(msg.sender); // I don't think this would ever hit..
    }

    // If we do start nearing undercollateralization, we need someone to liquidate positions 

    // $100 ETH backing $50 DSC
    // $20 ETH back $50 DSC <- DSC isn't worth $1 !!!

    // $75 backing $50 DSC 
    // Liquidator take $75 backing and burns off $50 DSC

    // If someone is almost undercollateralized, we pay you to liquidate them.

    /*
    * @param collateral The erc20 collateral address to liquidate from the user
    * @param user The user who has broken the health factor. Their _healthFactor should be below MIN_HEALTH_FACTOR
    * @param debtToCover The amount of DSC you want to burn to improve the users health factor
    * @notice You can partially liquidate a user. 
    * @notice You will get a liquidation bonus for taking the users funds.
    * @notice This function working assumes the protocol will be roughly 200% overcollateralized in order for this to work.
    * @notice A known bug would be if the protocol were 100% or less collateralized, then we wouldn't be able to incentive the liquidator.
    * @notice For example, if the price of the collateral plummeted before anyone could be liquidated.
    * 
    * Follows CEI: Checks, Effects, Interactions
    */
    function liquidate(address collateral, address user, uint256 debtToCover) external moreThanZero(debtToCover) nonReentrant {
        // need to check health factor of the user
        uint256 startingUserHealthFactor = _healthFactor(user);
        if (startingUserHealthFactor >= MIN_HEALTH_FACTOR) {
            revert DSCEngine__HealthFactorOk();
        }
        // We want to burn their DSC "debt"
        // And take their collateral
        // Bad User: $140 ETH, $100 DSC 
        // debtToCover = $100
        // $100 of DSC == ??? ETH?
        // 0.05 ETH 
        uint256 tokenAmountFromDebtCovered = getTokenAmountFromUsd(collateral, debtToCover);
        // And give them a 10% bonus
        // So we are giving the liquidator $110 of WETH for 100 DSC
        // We should implement a feature to liquidate in the event the protocol is insolvent 
        // And sweep extra amounts into a treasury

        // 0.05 * 0.1 = 0.005. Getting 0.055
        uint256 bonusCollateral = (tokenAmountFromDebtCovered * LIQUIDATION_BONUS) / LIQUIDATION_PRECISION;
        uint256 totalCollateralToRedeem = tokenAmountFromDebtCovered + bonusCollateral;
        _redeemCollateral(user, msg.sender, collateral, totalCollateralToRedeem);
        _burnDsc(debtToCover, user, msg.sender);

        uint256 endingUserHealthFactor = _healthFactor(user);
        if (endingUserHealthFactor <= startingUserHealthFactor) {
            revert DSCEngine__HealthFactorNotImproved();
        }
        _revertIfHealthFactorIsBroken(msg.sender);
    }

    function getHealthFactor() external view {}

    //////////////
    /// Private & Internal View Functions
    //////////////

    /*
    * @dev Low-level internal function, do not call unless the function calling it is 
    * checking for health factors being broken.
    */
    function _burnDsc(uint256 amountDscToBurn, address onBehalfOf, address dscFrom) private {
        s_DSCMinted[onBehalfOf] -= amountDscToBurn;
        bool success = i_dsc.transferFrom(dscFrom, address(this), amountDscToBurn);
        if (!success) {
            revert DSCEngine__TransferFailed();
        }
        i_dsc.burn(amountDscToBurn);
    }

    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();
        }
    }

    function _getAccountInformation(address user) private view returns (uint256 totalDscMinted, uint256 collateralValueInUsd) {
        totalDscMinted = s_DSCMinted[user];
        collateralValueInUsd = getAccountCollateralValue(user);
    }

    /**
     * Returns how close to liquidation a user is
     * If a user goes below 1, then they can get liquidated
     */
    function _healthFactor(address user) private view returns (uint256) {
        // total DSC minted 
        // total collateral VALUE
        (uint256 totalDscMinted, uint256 collateralValueInUsd) = _getAccountInformation(user);
       return _calculateHealthFactor(totalDscMinted, collateralValueInUsd);
    }


    function _revertIfHealthFactorIsBroken(address user) internal view {
        uint256 userHealthFactor = _healthFactor(user);
        if (userHealthFactor < MIN_HEALTH_FACTOR) {
            revert DSCEngine_BreaksHealthFactor(userHealthFactor);
        }
    }

    //////////////
    /// Public & External View Functions
    //////////////

    function getTokenAmountFromUsd(address token, uint256 usdAmountInWei) public view returns (uint256) {
        AggregatorV3Interface priceFeed = AggregatorV3Interface(s_priceFeeds[token]);
        (, int256 price, , , ) = priceFeed.latestRoundData();
        return (usdAmountInWei * PRECISION) / (uint256(price) * ADDITIONAL_FEED_PRECISION);
    }

    function getAccountCollateralValue(address user) public view returns (uint256 totalCollateralValueInUsd) {
        for (uint256 i = 0; i < s_collateralTokens.length; i++) {
            address token = s_collateralTokens[i];
            uint256 amount = s_collateralDeposited[user][token];
            totalCollateralValueInUsd += getUsdValue(token, amount);
        }
        return totalCollateralValueInUsd;
    }

    function getUsdValue(address token, uint256 amount) public view returns (uint256) {
        AggregatorV3Interface priceFeed = AggregatorV3Interface(s_priceFeeds[token]);
        (, int256 price, , , ) = priceFeed.latestRoundData();
        return ((uint256(price) * ADDITIONAL_FEED_PRECISION) * amount) / PRECISION;
    }

    function _calculateHealthFactor(uint256 totalDscMinted, uint256 collateralValueInUsd) internal pure returns (uint256) {
        if (totalDscMinted == 0) return type(uint256).max; 
        uint256 colalteralAdjustedForThreshold = (collateralValueInUsd * LIQUIDATION_THRESHOLD) / LIQUIDATION_PRECISION;
        return (colalteralAdjustedForThreshold * 1e18) / totalDscMinted;
    }    

    function getAccountInformation(address user) external view returns(uint256 totalDscMinted, uint256 collateralValueInUsd) {
        (totalDscMinted, collateralValueInUsd) = _getAccountInformation(user);
    }

    function getAdditionalFeedPrecision() external pure returns (uint256) {
        return ADDITIONAL_FEED_PRECISION;
    }

    function getPrecision() external pure returns (uint256) {
    return PRECISION;
  }

   function getLiquidationThreshold() external pure returns (uint256) {
    return LIQUIDATION_THRESHOLD;
   }

   function getLiquidationBonus() external pure returns (uint256) {
    return LIQUIDATION_BONUS;
   }

   function getLiquidationPrecision() external pure returns (uint256) {
    return LIQUIDATION_PRECISION;
   }

   function getMinHealthFactor() external pure returns (uint256) {
    return MIN_HEALTH_FACTOR;
   }

   function calculateHealthFactor(uint256 totalDscMinted, uint256 collateralValueInUsd) external pure returns (uint256) {
    return _calculateHealthFactor(totalDscMinted, collateralValueInUsd);
   }

    function getCollateralTokens() external view returns (address[] memory) {
    return s_collateralTokens;
}

function getDsc() external view returns (address) {
    return address(i_dsc);
}

function getCollateralTokenPriceFeed(address token) external view returns (address) {
    return s_priceFeeds[token];
}

function getHealthFactor(address user) external view returns (uint256) {
    return _healthFactor(user);
}

 function getCollateralBalanceOfUser(address user, address token) external view returns (uint256) {
    return s_collateralDeposited[user][token];
}

}

solidity
' ' '
this is the test dscengine:
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import {Test} from "forge-std/Test.sol";
import {DeployDSC} from "../../script/DeployDSC.s.sol";
import {DecentralizedStableCoin} from "../../src/DecentralizedStableCoin.sol";
import {DSCEngine} from "../../src/DSCEngine.sol";
import {HelperConfig} from "../../script/HelperConfig.s.sol";
import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";
import { MockV3Aggregator } from "../mocks/MockV3Aggregator.sol";
import { Test, console } from "forge-std/Test.sol";
import { StdCheats } from "forge-std/StdCheats.sol";

contract DSCEngineTest is Test {
DeployDSC deployer;
DecentralizedStableCoin dsc;
DSCEngine dsce;
HelperConfig config;
address ethUsdPriceFeed;
address weth;
address btcUsdPriceFeed;

 address public USER = makeAddr("user");
uint256 amountCollateral = 10 ether;
uint256 public constant STARTING_ERC20_BALANCE = 10 ether;
uint256 public constant AMOUNT_DSC_TO_BURN = 10 ether;
uint256 amountToMint = 100 ether;
address public user = address(1);

uint256 public constant LIQUIDATION_THRESHOLD = 50;


// Liquidation
address public liquidator = makeAddr("liquidator");
uint256 public collateralToCover = 20 ether;

function setUp() public {
    deployer = new DeployDSC();
    (dsc, dsce, config) = deployer.run();
    (ethUsdPriceFeed, btcUsdPriceFeed, weth, ,) = config.activeNetworkconfig();

    ERC20Mock(weth).mint(USER, STARTING_ERC20_BALANCE);
}

////////
//Construction Tests
address[] public tokenAddresses;
address[] public priceFeedAddresses;

function testRevertsIfTokenLengthDoesntMatchPriceFeeds() public {
    tokenAddresses.push(weth);
    priceFeedAddresses.push(ethUsdPriceFeed);
    priceFeedAddresses.push(ethUsdPriceFeed);

    vm.expectRevert(DSCEngine.DSCEngine__TokenAddressesAndPriceFeedAddressesMustBeSameLength.selector);
    new DSCEngine(tokenAddresses, priceFeedAddresses, address(dsc));
}


////////
//Price Tests

 function testGetUsdValue() public {
    uint256 ethAmount = 15e18;
    // 15e18 * 2000/ETH = 30,000e18;
    uint256 expectedUsd = 30000e18;
    uint256 actualUsd = dsce.getUsdValue(weth, ethAmount);
    assertEq(expectedUsd, actualUsd);
 }

 function testgetTokenAmountFromUsd() public {
      uint256 usdAmount = 100 ether;
      uint256 expectedWeth = 0.05 ether;
      uint256 actualWeth = dsce.getTokenAmountFromUsd(weth, usdAmount);
      assertEq(expectedWeth, actualWeth);
 }

 function testRevertsWithUnapprovedCollateral() public {
    ERC20Mock ranToken = new ERC20Mock("RAN", "RAN", USER, amountCollateral);
    vm.startPrank(USER);
    vm.expectRevert(DSCEngine.DSCEngine__NotAllowedToken.selector);
    dsce.depositCollateral(address(ranToken), amountCollateral);
    vm.stopPrank();
 }

 modifier depositedCollateral() {
     vm.startPrank(USER);
     ERC20Mock(weth).approve(address(dsce), amountCollateral);
     dsce.depositCollateral(weth, amountCollateral);
     vm.stopPrank();
     _;
 }

 function testCanDepositCollateralAndGetAccountInfo() public depositedCollateral {
    (uint256 totalDscMinted, uint256 collateralValueInUsd) = dsce.getAccountInformation(USER);

    uint256 expectedTotalDscMinted = 0;
    uint256 expectedDepositAmount = dsce.getTokenAmountFromUsd(weth, collateralValueInUsd);
    assertEq(totalDscMinted, expectedTotalDscMinted);
    assertEq(amountCollateral, expectedDepositAmount);
 }
 
////////
//depositCollateral Tests

function testRevertsIfCollateralZero() public {
   vm.startPrank(USER);
   ERC20Mock(weth).approve(address(dsce), amountCollateral);

   vm.expectRevert(DSCEngine.DSCEngine__NeedsMoreThanZero.selector);
   dsce.depositCollateral(weth, 0);
   vm.stopPrank();
}

 function testUserCanDepositWithoutMinting () public depositedCollateral {
    uint256 userBalance = dsc.balanceOf(USER);
    assertEq(userBalance, 0);
 }

 function testRevertsIfMintedDscBreaksHealthFactor() public {
    (, int256 price,,,) = MockV3Aggregator(ethUsdPriceFeed).latestRoundData();
    amountToMint = (amountCollateral * (uint256(price) * dsce.getAdditionalFeedPrecision())) / dsce.getPrecision();
    vm.startPrank(USER);
    ERC20Mock(weth).approve(address(dsce), amountCollateral);

    uint256 expectedHealthFactor = 
        dsce.calculateHealthFactor(dsce.getUsdValue(weth, amountCollateral), amountToMint);
        vm.expectRevert(abi.encodeWithSelector(DSCEngine.DSCEngine__BreaksHealthFactor.selector));
        dsce.depositCollateralAndMintDsc(weth, amountCollateral, amountToMint);
        vm.stopPrank();
 }




 modifier depositedCollateralAndMintedDsc() {
     vm.startPrank(USER);
     ERC20Mock(weth).approve(address(dsce), amountCollateral);
     dsce.depositCollateralAndMintDsc(weth, amountCollateral, amountToMint);
     vm.stopPrank();
     _;
 }


 function testCanMintWithDepositedCollateral() public depositedCollateralAndMintedDsc {
    uint256 userBalance = dsc.balanceOf(USER);
    assertEq(userBalance, amountToMint);
 }

 function testRevertsIfMintAmountIsZero() public {
    vm.startPrank(USER);
    ERC20Mock(weth).approve(address(dsce), amountCollateral);
    dsce.depositCollateralAndMintDsc(weth, amountCollateral, amountToMint);
    vm.expectRevert(DSCEngine.DSCEngine__NeedsMoreThanZero.selector);
    dsce.mintDsc(0);
    vm.stopPrank();
 }

 function testRevertsIfMintAmountBreaksHealthFactor() public depositedCollateral {
    // 0xe580cc6100000000000000000000000000000000000000000000000006f05b59d3b20000
    // 0xe580cc6100000000000000000000000000000000000000000000003635c9adc5dea00000
    (, int256 price,,,) = MockV3Aggregator(ethUsdPriceFeed).latestRoundData();
    amountToMint = (amountCollateral * (uint256(price) * dsce.getAdditionalFeedPrecision())) / dsce.getPrecision();

    vm.startPrank(USER);
    uint256 expectedHealthFactor =
        dsce.calculateHealthFactor(amountToMint, dsce.getUsdValue(weth, amountCollateral));
    vm.expectRevert(abi.encodeWithSelector(DSCEngine.DSCEngine__BreaksHealthFactor.selector, expectedHealthFactor));
    dsce.mintDsc(amountToMint);
    vm.stopPrank();
}


 function testCanMintDsc() public depositedCollateral {
    vm.prank(USER);
    dsce.mintDsc(amountToMint);

    uint256 userBalance = dsc.balanceOf(USER);
    assertEq(userBalance, amountToMint);
 }


 function testRevertsIfBurnAmountIsZero() public {
    vm.startPrank(USER);
    ERC20Mock(weth).approve(address(dsce), amountCollateral);
    dsce.depositCollateralAndMintDsc(weth, amountCollateral, amountToMint);
    vm.expectRevert(DSCEngine.DSCEngine__NeedsMoreThanZero.selector);
    dsce.burnDsc(0);
    vm.stopPrank();
 }

 function testCantBurnMoreThanUserHas() public {
    vm.prank(USER);
    vm.expectRevert();
    dsce.burnDsc(1);
 }


 function testCanBurnDsc() public depositedCollateralAndMintedDsc {
    vm.startPrank(USER);
    dsc.approve(address(dsce), amountToMint);
    dsce.burnDsc(amountToMint);
    vm.stopPrank();

    uint256 userBalance = dsc.balanceOf(USER);
    assertEq(userBalance, 0);
 }

  function testRevertsIfRedeemAmountIsZero() public {
    vm.startPrank(USER);
    ERC20Mock(weth).approve(address(dsce), amountCollateral);
    dsce.depositCollateralAndMintDsc(weth, amountCollateral, amountToMint);
    vm.expectRevert(DSCEngine.DSCEngine__NeedsMoreThanZero.selector);
    dsce.redeemCollateral(weth, 0);
    vm.stopPrank();
  }


  function testCanRedeemCollateral() public depositedCollateral {
    vm.startPrank(USER);
    dsce.redeemCollateral(weth, amountCollateral);
    uint256 userBalance = ERC20Mock(weth).balanceOf(USER);
    assertEq(userBalance, amountCollateral);
    vm.stopPrank();
  }


  function testMustRedeemMoreThanZero() public depositedCollateralAndMintedDsc {
    vm.startPrank(USER);
    dsc.approve(address(dsce), amountToMint);
    vm.expectRevert(DSCEngine.DSCEngine__NeedsMoreThanZero.selector);
    dsce.redeemCollateralForDsc(weth, 0, amountToMint);
    vm.stopPrank();
  }

  function testCanRedeemDepositedCollateral() public {
    vm.startPrank(USER);
    ERC20Mock(weth).approve(address(dsce), amountCollateral);
    dsce.depositCollateralAndMintDsc(weth, amountCollateral, amountToMint);    
    dsc.approve(address(dsce), amountToMint);
    dsce.redeemCollateralForDsc(weth, amountCollateral, amountToMint);
    vm.stopPrank();

    uint256 userBalance = dsc.balanceOf(USER);
    assertEq(userBalance, 0);

}

 function testProperlyReportsHealthFactor() public depositedCollateralAndMintedDsc {
    uint256 expectedHealthFactor = 100 ether;
    uint256 healthFactor = dsce.getHealthFactor(USER);
    // $100 minted with $20,000 collateral at 50% liquidation threshold
    // means that we must have $200 collateral at all times.
    // $20,000 * 0.5 = 10,000
    // 10,000 / 100 = 100 health factor
    assertEq(healthFactor, expectedHealthFactor);
 }


 function testHealthFactorCanGoBelowOne() public depositedCollateralAndMintedDsc {
    int256 ethUsdUpdatePrice = 18e8; // 1 ETH = 18 USD
    // Remember, we need $150 at all times if we have $100 debt

    MockV3Aggregator(ethUsdPriceFeed).updateAnswer(ethUsdUpdatePrice);

    uint256 userHealthFactor = dsce.getHealthFactor(USER);
    // $180 collateral / 200 debt = 0.9
    assert(userHealthFactor == 0.9 ether);
 }


 function testCantLiquidateGoodHealthFactor() public depositedCollateralAndMintedDsc {
    ERC20Mock(weth).mint(liquidator, collateralToCover);

    vm.startPrank(liquidator);
    ERC20Mock(weth).approve(address(dsce), collateralToCover);
    dsce.depositCollateralAndMintDsc(weth, collateralToCover, amountToMint);
    dsc.approve(address(dsce), amountToMint);

    vm.expectRevert(DSCEngine.DSCEngine__HealthFactorOk.selector);
    dsce.liquidate(weth, USER, amountToMint);
    vm.stopPrank();
 }


 modifier liquidated() {
    vm.startPrank(USER);
    ERC20Mock(weth).approve(address(dsce), amountCollateral);
    dsce.depositCollateralAndMintDsc(weth, amountCollateral, amountToMint);
    vm.stopPrank();
    int256 ethUsdUpdatedPrice = 18e8; // 1 ETH = 18 USD

    MockV3Aggregator(ethUsdPriceFeed).updateAnswer(ethUsdUpdatedPrice);
    uint256 userHealthFactor = dsce.getHealthFactor(USER);

    ERC20Mock(weth).mint(liquidator, collateralToCover);

    vm.startPrank(liquidator);
    ERC20Mock(weth).approve(address(dsce), collateralToCover);
    dsce.depositCollateralAndMintDsc(weth, collateralToCover, amountToMint);
    dsc.approve(address(dsce), amountToMint);
    dsc.approve(address(dsce), amountToMint);
    dsce.liquidate(weth, USER, amountToMint); // We are covering their whole debt
    vm.stopPrank();
    _;
 }

 function testLiquidationPayoutIsCorrect() public liquidated {
     uint256 liquidatorWethBalance = ERC20Mock(weth).balanceOf(liquidator);
     uint256 expectedWeth = dsce.getTokenAmountFromUsd(weth, amountToMint) +
     (dsce.getTokenAmountFromUsd(weth, amountToMint) / dsce.getLiquidationBonus());
     uint256 hardCodedExpected = 6111111111111111110;
     assertEq(liquidatorWethBalance, hardCodedExpected);
     assertEq(liquidatorWethBalance, expectedWeth);
 }


 function testUserStillHasSomeEthAfterLiquidation() public liquidated {
     // Get how much WETH the user lost
     uint256 amountLiquidated = dsce.getTokenAmountFromUsd(weth, amountToMint) +
     (dsce.getTokenAmountFromUsd(weth, amountToMint) / dsce.getLiquidationBonus());

     uint256 usdAmountLiquidated = dsce.getUsdValue(weth, amountLiquidated);
     uint256 expectedUserCollateralValueInUsd = dsce.getUsdValue(weth, amountCollateral) - (usdAmountLiquidated);

     (, uint256 userCollateralValueInUsd) = dsce.getAccountInformation(USER);
     uint256 hardCodedExpectedValue = 70_000_000_000_000_000_020;
     assertEq(userCollateralValueInUsd, expectedUserCollateralValueInUsd);
     assertEq(userCollateralValueInUsd, hardCodedExpectedValue);
 }


 function testLiquidatorTakesOnUsersDebt() public liquidated {
    (uint256 liquidatorDscMinted,) = dsce.getAccountInformation(liquidator);
    assertEq(liquidatorDscMinted, amountToMint);
 }


 function testUserHasNoMoreDebt() public liquidated {
    (uint256 userDscMinted,) = dsce.getAccountInformation(USER);
    assertEq(userDscMinted, 0);
 }


 function testGetCollateralTokenPriceFeed() public {
    address priceFeed = dsce.getCollateralTokenPriceFeed(weth);
    assertEq(priceFeed, ethUsdPriceFeed);
 }


 function testGetCollateralTokens() public {
    address priceFeed = dsce.getCollateralTokenPriceFeed(weth);
    assertEq(priceFeed, ethUsdPriceFeed);
 }


 function testGetMinHealthFactor() public {
     address[] memory collateralTokens = dsce.getCollateralTokens();
     assertEq(collateralTokens[0], weth);
 } 

 function testGetLiquidationThreshold() public {
    uint256 liquidationThreshold = dsce.getLiquidationThreshold();
    assertEq(liquidationThreshold, LIQUIDATION_THRESHOLD);
 }

 function testgetAccountCollateralValueFromInformation() public depositedCollateral {
    (, uint256 collateralValue) = dsce.getAccountInformation(USER);
    uint256 expectedCollateralValue = dsce.getUsdValue(weth, amountCollateral);
    assertEq(collateralValue, expectedCollateralValue);
 }

 function testGetCollateralBalanceOfUser() public {
    vm.startBroadcast(USER);
    ERC20Mock(weth).approve(address(dsce), amountCollateral);
    dsce.depositCollateral(weth, amountCollateral);
    vm.stopPrank();
    uint256 collateralBalance = dsce.getCollateralBalanceOfUser(USER, weth);
    assertEq(collateralBalance, amountCollateral);
 }


 function testGetAccountCollateralValue() public {
    vm.startPrank(USER);
    ERC20Mock(weth).approve(address(dsce), amountCollateral);
    dsce.depositCollateral(weth, amountCollateral);
    vm.stopPrank();
    uint256 collateralValue = dsce.getAccountCollateralValue(USER);
    uint256 expectedCollateralValue = dsce.getUsdValue(weth, amountCollateral);
    assertEq(collateralValue, expectedCollateralValue);
 }



 function testGetDsc() public {
    address dscAddress = dsce.getDsc();
    assertEq(dscAddress, address(dsc));
 }

}

when I type forge test these two functions are creating problems, and I am stuck on them for almost a day: testRevertsIfMintAmountBreaksHealthFactor and testRevertsIfMintedDscBreaksHealthFactor.

here is what the terminal gives me:

' ' '
Love to hear from all you, any feedback can be helpful :)

EngrPips · 2024-07-11T13:53:58Z

EngrPips
Jul 11, 2024

Hello @YavorJJ, Run those two tests that failed separately and run them with the -vvvv flag. Show the output of the test so we can be able to see what is actually wrong. One at a time would be fine

5 replies

YavorJJ Jul 11, 2024
Author

Ran 1 test for test/unit/DSCEngine.t.sol:DSCEngineTest
[FAIL. Reason: Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != 0x6c1c366600000000000000000000000000000000000000000000000006f05b59d3b20000] testRevertsIfMintAmountBreaksHealthFactor() (gas: 186975)
Traces:
[10032592] DSCEngineTest::setUp()
├─ [4597863] → new @0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
│ └─ ← [Return] 22852 bytes of code
├─ [5229130] 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f::run()
│ ├─ [3411454] → new @0x104fBc016F4bb334D775a19E8A6510109AC63E00
│ │ ├─ [0] VM::startBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [372255] → new @0x90193C961A926261B756D1E5bb255e67ff9498A1
│ │ │ └─ ← [Return] 1082 bytes of code
│ │ ├─ [516505] → new @0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
│ │ │ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f, value: 100000000000 [1e11])
│ │ │ └─ ← [Return] 2117 bytes of code
│ │ ├─ [0] VM::stopBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [0] VM::startBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [372255] → new @0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
│ │ │ └─ ← [Return] 1082 bytes of code
│ │ ├─ [516505] → new @0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76
│ │ │ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f, value: 100000000000 [1e11])
│ │ │ └─ ← [Return] 2117 bytes of code
│ │ ├─ [0] VM::stopBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [0] VM::envUint("DEFAULT_ANVIL_KEY") [staticcall]
│ │ │ └─ ← [Return]
│ │ └─ ← [Return] 6714 bytes of code
│ ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkconfig() [staticcall]
│ │ └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
│ ├─ [0] VM::startBroadcast()
│ │ └─ ← [Return]
│ ├─ [591455] → new @0x5FbDB2315678afecb367f032d93F642f64180aa3
│ │ ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)
│ │ └─ ← [Return] 2610 bytes of code
│ ├─ [985596] → new @0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
│ │ └─ ← [Return] 4245 bytes of code
│ ├─ [2424] 0x5FbDB2315678afecb367f032d93F642f64180aa3::transferOwnership(0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512)
│ │ ├─ emit OwnershipTransferred(previousOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, newOwner: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512)
│ │ └─ ← [Stop]
│ ├─ [0] VM::stopBroadcast()
│ │ └─ ← [Return]
│ └─ ← [Return] 0x5FbDB2315678afecb367f032d93F642f64180aa3, 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 0x104fBc016F4bb334D775a19E8A6510109AC63E00
├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkconfig() [staticcall]
│ └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
├─ [24912] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::mint(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 10000000000000000000 [1e19])
│ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], value: 10000000000000000000 [1e19])
│ └─ ← [Stop]
└─ ← [Stop]

[159475] DSCEngineTest::testRevertsIfMintAmountBreaksHealthFactor()
├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [24739] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::approve(0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 10000000000000000000 [1e19])
│ ├─ emit Approval(owner: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], spender: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, value: 10000000000000000000 [1e19])
│ └─ ← [Return] true
├─ [63438] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::depositCollateral(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 10000000000000000000 [1e19])
│ ├─ emit CollateralDeposited(user: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], token: 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, amount: 10000000000000000000 [1e19])
│ ├─ [30888] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::transferFrom(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 10000000000000000000 [1e19])
│ │ ├─ emit Transfer(from: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], to: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, value: 10000000000000000000 [1e19])
│ │ └─ ← [Return] true
│ └─ ← [Stop]
├─ [0] VM::stopPrank()
│ └─ ← [Return]
├─ [8993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
├─ [314] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getPrecision() [staticcall]
│ └─ ← [Return] 1000000000000000000 [1e18]
├─ [292] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getAdditionalFeedPrecision() [staticcall]
│ └─ ← [Return] 10000000000 [1e10]
├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [2591] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getUsdValue(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 10000000000000000000 [1e19]) [staticcall]
│ ├─ [993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Return] 20000000000000000000000 [2e22]
├─ [719] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::calculateHealthFactor(20000000000000000000000 [2e22], 20000000000000000000000 [2e22]) [staticcall]
│ └─ ← [Return] 500000000000000000 [5e17]
├─ [0] VM::expectRevert(DSCEngine__BreaksHealthFactor())
│ └─ ← [Return]
├─ [52892] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::mintDsc(20000000000000000000000 [2e22])
│ ├─ [993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ ├─ [8993] 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
│ └─ ← [Revert] DSCEngine_BreaksHealthFactor(500000000000000000 [5e17])
└─ ← [Revert] Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != 0x6c1c366600000000000000000000000000000000000000000000000006f05b59d3b20000

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

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

Failing tests:
Encountered 1 failing test in test/unit/DSCEngine.t.sol:DSCEngineTest
[FAIL. Reason: Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != 0x6c1c366600000000000000000000000000000000000000000000000006f05b59d3b20000] testRevertsIfMintAmountBreaksHealthFactor() (gas: 186975)

Encountered a total of 1 failing tests, 0 tests succeeded
yavorjr@DESKTOP-BFAHRIB:~/foundry-defi-stablecoin-f23$

2nd one:

[⠆] Compiling...
No files changed, compilation skipped

Ran 1 test for test/unit/DSCEngine.t.sol:DSCEngineTest
[FAIL. Reason: Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != l6f] testRevertsIfMintedDscBreaksHealthFactor() (gas: 185307)
Traces:
[10032592] DSCEngineTest::setUp()
├─ [4597863] → new @0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
│ └─ ← [Return] 22852 bytes of code
├─ [5229130] 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f::run()
│ ├─ [3411454] → new @0x104fBc016F4bb334D775a19E8A6510109AC63E00
│ │ ├─ [0] VM::startBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [372255] → new @0x90193C961A926261B756D1E5bb255e67ff9498A1
│ │ │ └─ ← [Return] 1082 bytes of code
│ │ ├─ [516505] → new @0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
│ │ │ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f, value: 100000000000 [1e11])
│ │ │ └─ ← [Return] 2117 bytes of code
│ │ ├─ [0] VM::stopBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [0] VM::startBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [372255] → new @0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
│ │ │ └─ ← [Return] 1082 bytes of code
│ │ ├─ [516505] → new @0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76
│ │ │ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f, value: 100000000000 [1e11])
│ │ │ └─ ← [Return] 2117 bytes of code
│ │ ├─ [0] VM::stopBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [0] VM::envUint("DEFAULT_ANVIL_KEY") [staticcall]
│ │ │ └─ ← [Return]
│ │ └─ ← [Return] 6714 bytes of code
│ ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkconfig() [staticcall]
│ │ └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
│ ├─ [0] VM::startBroadcast()
│ │ └─ ← [Return]
│ ├─ [591455] → new @0x5FbDB2315678afecb367f032d93F642f64180aa3
│ │ ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)
│ │ └─ ← [Return] 2610 bytes of code
│ ├─ [985596] → new @0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
│ │ └─ ← [Return] 4245 bytes of code
│ ├─ [2424] 0x5FbDB2315678afecb367f032d93F642f64180aa3::transferOwnership(0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512)
│ │ ├─ emit OwnershipTransferred(previousOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, newOwner: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512)
│ │ └─ ← [Stop]
│ ├─ [0] VM::stopBroadcast()
│ │ └─ ← [Return]
│ └─ ← [Return] 0x5FbDB2315678afecb367f032d93F642f64180aa3, 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 0x104fBc016F4bb334D775a19E8A6510109AC63E00
├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkconfig() [staticcall]
│ └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
├─ [24912] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::mint(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 10000000000000000000 [1e19])
│ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], value: 10000000000000000000 [1e19])
│ └─ ← [Stop]
└─ ← [Stop]

[185307] DSCEngineTest::testRevertsIfMintedDscBreaksHealthFactor()
├─ [8993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
├─ [314] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getPrecision() [staticcall]
│ └─ ← [Return] 1000000000000000000 [1e18]
├─ [292] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getAdditionalFeedPrecision() [staticcall]
│ └─ ← [Return] 10000000000 [1e10]
├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [24739] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::approve(0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 10000000000000000000 [1e19])
│ ├─ emit Approval(owner: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], spender: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, value: 10000000000000000000 [1e19])
│ └─ ← [Return] true
├─ [4591] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getUsdValue(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 10000000000000000000 [1e19]) [staticcall]
│ ├─ [993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Return] 20000000000000000000000 [2e22]
├─ [719] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::calculateHealthFactor(20000000000000000000000 [2e22], 20000000000000000000000 [2e22]) [staticcall]
│ └─ ← [Return] 500000000000000000 [5e17]
├─ [0] VM::expectRevert(DSCEngine__BreaksHealthFactor())
│ └─ ← [Return]
├─ [114164] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::depositCollateralAndMintDsc(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 10000000000000000000 [1e19], 20000000000000000000000 [2e22])
│ ├─ emit CollateralDeposited(user: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], token: 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, amount: 10000000000000000000 [1e19])
│ ├─ [30888] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::transferFrom(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 10000000000000000000 [1e19])
│ │ ├─ emit Transfer(from: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], to: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, value: 10000000000000000000 [1e19])
│ │ └─ ← [Return] true
│ ├─ [993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ ├─ [8993] 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
│ └─ ← [Revert] DSCEngine_BreaksHealthFactor(500000000000000000 [5e17])
└─ ← [Revert] Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != l6f

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

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

Failing tests:
Encountered 1 failing test in test/unit/DSCEngine.t.sol:DSCEngineTest
[FAIL. Reason: Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != l6f] testRevertsIfMintedDscBreaksHealthFactor() (gas: 185307)

Encountered a total of 1 failing tests, 0 tests succeeded

' ' '

1st is for testRevertsIfMintAmountBreaksHealthFactor
2nd is for testRevertsIfMintedDscBreaksHealthFactor

EngrPips Jul 11, 2024

Please put some effort into formatting properly so it will be easier for people to help you.

EngrPips Jul 11, 2024

testRevertsIfMintAmountBreaksHealthFactor

function testRevertsIfMintAmountBreaksHealthFactor() public depositedCollateral {
    // 0xe580cc6100000000000000000000000000000000000000000000000006f05b59d3b20000
    // 0xe580cc6100000000000000000000000000000000000000000000003635c9adc5dea00000
    (, int256 price,,,) = MockV3Aggregator(ethUsdPriceFeed).latestRoundData();
    amountToMint = (amountCollateral * (uint256(price) * dsce.getAdditionalFeedPrecision())) / dsce.getPrecision();

    vm.startPrank(USER);
    uint256 expectedHealthFactor =
        dsce.calculateHealthFactor(amountToMint, dsce.getUsdValue(weth, amountCollateral));
    vm.expectRevert(abi.encodeWithSelector(DSCEngine.DSCEngine__BreaksHealthFactor.selector, expectedHealthFactor));
    dsce.mintDsc(amountToMint);
    vm.stopPrank();
}

Ran 1 test for test/unit/DSCEngine.t.sol:DSCEngineTest
[FAIL. Reason: Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != 0x6c1c366600000000000000000000000000000000000000000000000006f05b59d3b20000] testRevertsIfMintAmountBreaksHealthFactor() (gas: 186975)
Traces:
[10032592] DSCEngineTest::setUp()
├─ [4597863] → new @0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
│ └─ ← [Return] 22852 bytes of code
├─ [5229130] 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f::run()
│ ├─ [3411454] → new @0x104fBc016F4bb334D775a19E8A6510109AC63E00
│ │ ├─ [0] VM::startBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [372255] → new @0x90193C961A926261B756D1E5bb255e67ff9498A1
│ │ │ └─ ← [Return] 1082 bytes of code
│ │ ├─ [516505] → new @0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
│ │ │ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f, value: 100000000000 [1e11])
│ │ │ └─ ← [Return] 2117 bytes of code
│ │ ├─ [0] VM::stopBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [0] VM::startBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [372255] → new @0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
│ │ │ └─ ← [Return] 1082 bytes of code
│ │ ├─ [516505] → new @0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76
│ │ │ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f, value: 100000000000 [1e11])
│ │ │ └─ ← [Return] 2117 bytes of code
│ │ ├─ [0] VM::stopBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [0] VM::envUint("DEFAULT_ANVIL_KEY") [staticcall]
│ │ │ └─ ← [Return]
│ │ └─ ← [Return] 6714 bytes of code
│ ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkconfig() [staticcall]
│ │ └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
│ ├─ [0] VM::startBroadcast()
│ │ └─ ← [Return]
│ ├─ [591455] → new @0x5FbDB2315678afecb367f032d93F642f64180aa3
│ │ ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)
│ │ └─ ← [Return] 2610 bytes of code
│ ├─ [985596] → new @0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
│ │ └─ ← [Return] 4245 bytes of code
│ ├─ [2424] 0x5FbDB2315678afecb367f032d93F642f64180aa3::transferOwnership(0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512)
│ │ ├─ emit OwnershipTransferred(previousOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, newOwner: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512)
│ │ └─ ← [Stop]
│ ├─ [0] VM::stopBroadcast()
│ │ └─ ← [Return]
│ └─ ← [Return] 0x5FbDB2315678afecb367f032d93F642f64180aa3, 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 0x104fBc016F4bb334D775a19E8A6510109AC63E00
├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkconfig() [staticcall]
│ └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
├─ [24912] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::mint(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 10000000000000000000 [1e19])
│ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], value: 10000000000000000000 [1e19])
│ └─ ← [Stop]
└─ ← [Stop]

[159475] DSCEngineTest::testRevertsIfMintAmountBreaksHealthFactor()
├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [24739] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::approve(0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 10000000000000000000 [1e19])
│ ├─ emit Approval(owner: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], spender: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, value: 10000000000000000000 [1e19])
│ └─ ← [Return] true
├─ [63438] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::depositCollateral(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 10000000000000000000 [1e19])
│ ├─ emit CollateralDeposited(user: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], token: 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, amount: 10000000000000000000 [1e19])
│ ├─ [30888] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::transferFrom(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 10000000000000000000 [1e19])
│ │ ├─ emit Transfer(from: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], to: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, value: 10000000000000000000 [1e19])
│ │ └─ ← [Return] true
│ └─ ← [Stop]
├─ [0] VM::stopPrank()
│ └─ ← [Return]
├─ [8993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
├─ [314] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getPrecision() [staticcall]
│ └─ ← [Return] 1000000000000000000 [1e18]
├─ [292] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getAdditionalFeedPrecision() [staticcall]
│ └─ ← [Return] 10000000000 [1e10]
├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [2591] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getUsdValue(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 10000000000000000000 [1e19]) [staticcall]
│ ├─ [993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Return] 20000000000000000000000 [2e22]
├─ [719] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::calculateHealthFactor(20000000000000000000000 [2e22], 20000000000000000000000 [2e22]) [staticcall]
│ └─ ← [Return] 500000000000000000 [5e17]
├─ [0] VM::expectRevert(DSCEngine__BreaksHealthFactor())
│ └─ ← [Return]
├─ [52892] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::mintDsc(20000000000000000000000 [2e22])
│ ├─ [993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ ├─ [8993] 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
│ └─ ← [Revert] DSCEngine_BreaksHealthFactor(500000000000000000 [5e17])
└─ ← [Revert] Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != 0x6c1c366600000000000000000000000000000000000000000000000006f05b59d3b20000

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

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

Failing tests:
Encountered 1 failing test in test/unit/DSCEngine.t.sol:DSCEngineTest
[FAIL. Reason: Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != 0x6c1c366600000000000000000000000000000000000000000000000006f05b59d3b20000] testRevertsIfMintAmountBreaksHealthFactor() (gas: 186975)

Encountered a total of 1 failing tests, 0 tests succeeded
yavorjr@DESKTOP-BFAHRIB:~/foundry-defi-stablecoin-f23$

EngrPips Jul 11, 2024

testRevertsIfMintedDscBreaksHealthFactor

function testRevertsIfMintedDscBreaksHealthFactor() public {
    (, int256 price,,,) = MockV3Aggregator(ethUsdPriceFeed).latestRoundData();
    amountToMint = (amountCollateral * (uint256(price) * dsce.getAdditionalFeedPrecision())) / dsce.getPrecision();
    vm.startPrank(USER);
    ERC20Mock(weth).approve(address(dsce), amountCollateral);

    uint256 expectedHealthFactor = 
        dsce.calculateHealthFactor(dsce.getUsdValue(weth, amountCollateral), amountToMint);
        vm.expectRevert(abi.encodeWithSelector(DSCEngine.DSCEngine__BreaksHealthFactor.selector));
        dsce.depositCollateralAndMintDsc(weth, amountCollateral, amountToMint);
        vm.stopPrank();
 }

[⠆] Compiling...
No files changed, compilation skipped

Ran 1 test for test/unit/DSCEngine.t.sol:DSCEngineTest
[FAIL. Reason: Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != l6f] testRevertsIfMintedDscBreaksHealthFactor() (gas: 185307)
Traces:
[10032592] DSCEngineTest::setUp()
├─ [4597863] → new @0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
│ └─ ← [Return] 22852 bytes of code
├─ [5229130] 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f::run()
│ ├─ [3411454] → new @0x104fBc016F4bb334D775a19E8A6510109AC63E00
│ │ ├─ [0] VM::startBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [372255] → new @0x90193C961A926261B756D1E5bb255e67ff9498A1
│ │ │ └─ ← [Return] 1082 bytes of code
│ │ ├─ [516505] → new @0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496
│ │ │ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f, value: 100000000000 [1e11])
│ │ │ └─ ← [Return] 2117 bytes of code
│ │ ├─ [0] VM::stopBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [0] VM::startBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [372255] → new @0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3
│ │ │ └─ ← [Return] 1082 bytes of code
│ │ ├─ [516505] → new @0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76
│ │ │ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f, value: 100000000000 [1e11])
│ │ │ └─ ← [Return] 2117 bytes of code
│ │ ├─ [0] VM::stopBroadcast()
│ │ │ └─ ← [Return]
│ │ ├─ [0] VM::envUint("DEFAULT_ANVIL_KEY") [staticcall]
│ │ │ └─ ← [Return]
│ │ └─ ← [Return] 6714 bytes of code
│ ├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkconfig() [staticcall]
│ │ └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
│ ├─ [0] VM::startBroadcast()
│ │ └─ ← [Return]
│ ├─ [591455] → new @0x5FbDB2315678afecb367f032d93F642f64180aa3
│ │ ├─ emit OwnershipTransferred(previousOwner: 0x0000000000000000000000000000000000000000, newOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266)
│ │ └─ ← [Return] 2610 bytes of code
│ ├─ [985596] → new @0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
│ │ └─ ← [Return] 4245 bytes of code
│ ├─ [2424] 0x5FbDB2315678afecb367f032d93F642f64180aa3::transferOwnership(0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512)
│ │ ├─ emit OwnershipTransferred(previousOwner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, newOwner: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512)
│ │ └─ ← [Stop]
│ ├─ [0] VM::stopBroadcast()
│ │ └─ ← [Return]
│ └─ ← [Return] 0x5FbDB2315678afecb367f032d93F642f64180aa3, 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 0x104fBc016F4bb334D775a19E8A6510109AC63E00
├─ [912] 0x104fBc016F4bb334D775a19E8A6510109AC63E00::activeNetworkconfig() [staticcall]
│ └─ ← [Return] 0x90193C961A926261B756D1E5bb255e67ff9498A1, 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3, 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 0xDB8cFf278adCCF9E9b5da745B44E754fC4EE3C76, 77814517325470205911140941194401928579557062014761831930645393041380819009408 [7.781e76]
├─ [24912] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::mint(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 10000000000000000000 [1e19])
│ ├─ emit Transfer(from: 0x0000000000000000000000000000000000000000, to: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], value: 10000000000000000000 [1e19])
│ └─ ← [Stop]
└─ ← [Stop]

[185307] DSCEngineTest::testRevertsIfMintedDscBreaksHealthFactor()
├─ [8993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
├─ [314] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getPrecision() [staticcall]
│ └─ ← [Return] 1000000000000000000 [1e18]
├─ [292] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getAdditionalFeedPrecision() [staticcall]
│ └─ ← [Return] 10000000000 [1e10]
├─ [0] VM::startPrank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
│ └─ ← [Return]
├─ [24739] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::approve(0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 10000000000000000000 [1e19])
│ ├─ emit Approval(owner: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], spender: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, value: 10000000000000000000 [1e19])
│ └─ ← [Return] true
├─ [4591] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::getUsdValue(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 10000000000000000000 [1e19]) [staticcall]
│ ├─ [993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ └─ ← [Return] 20000000000000000000000 [2e22]
├─ [719] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::calculateHealthFactor(20000000000000000000000 [2e22], 20000000000000000000000 [2e22]) [staticcall]
│ └─ ← [Return] 500000000000000000 [5e17]
├─ [0] VM::expectRevert(DSCEngine__BreaksHealthFactor())
│ └─ ← [Return]
├─ [114164] 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512::depositCollateralAndMintDsc(0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, 10000000000000000000 [1e19], 20000000000000000000000 [2e22])
│ ├─ emit CollateralDeposited(user: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], token: 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496, amount: 10000000000000000000 [1e19])
│ ├─ [30888] 0xA8452Ec99ce0C64f20701dB7dD3abDb607c00496::transferFrom(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, 10000000000000000000 [1e19])
│ │ ├─ emit Transfer(from: user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], to: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512, value: 10000000000000000000 [1e19])
│ │ └─ ← [Return] true
│ ├─ [993] 0x90193C961A926261B756D1E5bb255e67ff9498A1::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
│ ├─ [8993] 0xBb2180ebd78ce97360503434eD37fcf4a1Df61c3::latestRoundData() [staticcall]
│ │ └─ ← [Return] 1, 100000000000 [1e11], 1, 1, 1
│ └─ ← [Revert] DSCEngine_BreaksHealthFactor(500000000000000000 [5e17])
└─ ← [Revert] Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != l6f

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

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

Failing tests:
Encountered 1 failing test in test/unit/DSCEngine.t.sol:DSCEngineTest
[FAIL. Reason: Error != expected error: 0x8b5c142b00000000000000000000000000000000000000000000000006f05b59d3b20000 != l6f] testRevertsIfMintedDscBreaksHealthFactor() (gas: 185307)

Encountered a total of 1 failing tests, 0 tests succeeded

EngrPips Jul 11, 2024

Hey @YavorJJ, If it is difficult to get the custom error revert to work, just save yourself some stress and use vm.expectRevert() all the tests should pass that way.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

I have two problems regarding the DSCEnigne test on the StableCoin project. #1992

{{title}}

Replies: 1 comment 5 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

Select a reply

I have two problems regarding the DSCEnigne test on the StableCoin project. #1992

YavorJJ Jul 11, 2024

Replies: 1 comment · 5 replies

EngrPips Jul 11, 2024

YavorJJ Jul 11, 2024 Author

EngrPips Jul 11, 2024

EngrPips Jul 11, 2024

EngrPips Jul 11, 2024

EngrPips Jul 11, 2024

YavorJJ
Jul 11, 2024

Replies: 1 comment 5 replies

EngrPips
Jul 11, 2024

YavorJJ Jul 11, 2024
Author