CoinEngine and Test Update

Author: Vivkzz

src/CoinEngine.sol

@@ -50,6 +50,8 @@ contract CoinEngine is ReentrancyGuard {
     error CoinEngine_TransferFailed();
     error CoinEngine_HealthFactorBroken();
     error CoinEngine_TokenAddressAndPriceFeedAddressLengthDontMatch();
+    error CoinEngine_HealtFactorIsGood();
+    error CoinEngine_HealthFactorNotImproved();
 
     ///////////////////
     // Types
@@ -66,6 +68,7 @@ contract CoinEngine is ReentrancyGuard {
     uint256 private constant ADDITIONAL_FEED_PRECISION = 1e10;
     uint256 private constant LIQUIDATION_THRESOLD = 50;
     uint256 private constant LIQUIDATION_PRECISION = 100;
+    uint256 private constant LIQUIDATION_BONUS = 10;
 
     /// @dev Mapping of token address to price feed address
     mapping(address tokenCollateralAddress => address priceFeed) private s_priceFeeds;
@@ -80,6 +83,7 @@ contract CoinEngine is ReentrancyGuard {
     // Events
     ///////////////////
     event CollateralDeposited(address indexed user, address indexed tokenCollateralAddress, uint256 amount);
+    event CollateralRedeemed(address indexed redeemFrom, address indexed redeemTo, address token, uint256 amount);
 
     ///////////////////
     // Modifiers
@@ -154,13 +158,13 @@ contract CoinEngine is ReentrancyGuard {
 
     function mintSc(uint256 amountToMint) public nonReentrant moreThanZero(amountToMint) {
         s_scMinted[msg.sender] += amountToMint;
-        _revertIfHealtFactorIsBroken(msg.sender);
+        _revertIfHealthFactorIsBroken(msg.sender);
     }
 
     //  Burn you own SC.
     function burnSC(uint256 amount) external moreThanZero(amount) {
         _burnSc(amount, msg.sender, msg.sender);
-        _revertIfHealtFactorIsBroken(msg.sender); // technically not needed to do this
+        _revertIfHealthFactorIsBroken(msg.sender); // technically not needed to do this
     }
 
     function redeemCollateral(address tokenCollateralAddress, uint256 amountCollateral)
@@ -171,7 +175,28 @@ contract CoinEngine is ReentrancyGuard {
     {
         s_collateralDeposited[msg.sender][tokenCollateralAddress] -= amountCollateral;
         _redeemCollateral(tokenCollateralAddress, amountCollateral, msg.sender, msg.sender);
-        _revertIfHealtFactorIsBroken(msg.sender);
+        _revertIfHealthFactorIsBroken(msg.sender);
+    }
+
+    function liquidate(uint256 debtToCover, address tokenCollateralAddress, address user) external {
+        uint256 startingHealthFactor = _getUserHealthFactor(user);
+
+        if (startingHealthFactor > MIN_HEALTH_FACTOR) {
+            revert CoinEngine_HealtFactorIsGood();
+        }
+        uint256 tokenAmountToCoverFromDebt = getTokenValueFromUSD(debtToCover, tokenCollateralAddress);
+        uint256 bonusCollateral = (tokenAmountToCoverFromDebt * LIQUIDATION_BONUS) / LIQUIDATION_PRECISION;
+
+        _redeemCollateral(tokenCollateralAddress, tokenAmountToCoverFromDebt + bonusCollateral, user, msg.sender);
+        _burnSc(debtToCover, user, msg.sender);
+
+        uint256 endingUserHealthFactor = _getUserHealthFactor(user);
+
+        // This condtional will not hit
+        if (endingUserHealthFactor < startingHealthFactor) {
+            revert CoinEngine_HealthFactorNotImproved();
+        }
+        _revertIfHealthFactorIsBroken(msg.sender);
     }
 
     //////////////////////////////
@@ -200,6 +225,7 @@ contract CoinEngine is ReentrancyGuard {
         private
     {
         s_collateralDeposited[from][tokenCollateralAddress] -= amountCollateral;
+        emit CollateralRedeemed(from, to, tokenCollateralAddress, amountCollateral);
         (bool success) = IERC20(tokenCollateralAddress).transfer(to, amountCollateral);
         if (!success) {
             revert CoinEngine_TransferFailed();
@@ -213,7 +239,7 @@ contract CoinEngine is ReentrancyGuard {
         return ((uint256(price) * ADDITIONAL_FEED_PRECISION) * amount) / PRECISION;
     }
 
-    function _revertIfHealtFactorIsBroken(address user) internal view {
+    function _revertIfHealthFactorIsBroken(address user) internal view {
         uint256 userHealthFactor = _getUserHealthFactor(user);
         if (userHealthFactor < MIN_HEALTH_FACTOR) {
             revert CoinEngine_HealthFactorBroken();
@@ -248,16 +274,30 @@ contract CoinEngine is ReentrancyGuard {
         pure
         returns (uint256)
     {
-        // if (totalSCMinted == 0) return type(uint256).max;
+        if (totalSCMinted == 0) return type(uint256).max;
         uint256 collateralThresold = (collateralValueInUSD * LIQUIDATION_THRESOLD) / LIQUIDATION_PRECISION;
         return (collateralThresold * PRECISION) / totalSCMinted;
     }
 
     /////////////////////////////////////////////
     // External & Public View & Pure Functions
     /////////////////////////////////////////////
+    function getTokenValueFromUSD(uint256 amountSC, address tokenAddress) public view returns (uint256) {
+        AggregatorV3Interface priceFeed = AggregatorV3Interface(s_priceFeeds[tokenAddress]);
+        (, int256 price,,,) = priceFeed.latestRoundData();
+
+        return ((amountSC * PRECISION) / (uint256(price) * ADDITIONAL_FEED_PRECISION));
+    }
 
     function getValueUSD(address tokenAddress, uint256 amount) external view returns (uint256) {
         return _getValueUSD(tokenAddress, amount);
     }
+
+    function getAccountInformation(address user)
+        external
+        view
+        returns (uint256 totalSCMinted, uint256 collateralValueInUSD)
+    {
+        (totalSCMinted, collateralValueInUSD) = _getAccountInformation(user);
+    }
 }

test/SCEngine.t.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity 0.8;
+
+import {Test} from "forge-std/Test.sol";
+import {DeploySC} from "script/DeploySC.s.sol";
+import {CoinEngine} from "src/CoinEngine.sol";
+import {StableCoin} from "src/StableCoin.sol";
+import {HelperConfig} from "script/HelperConfig.s.sol";
+import {ERC20Mock} from "../mocks/ERC20Mock.sol";
+
+contract SCEngine is Test {
+    CoinEngine ce;
+    StableCoin sc;
+    HelperConfig config;
+
+    address weth;
+    address ethPriceFeed;
+    address btcPriceFeed;
+    address constant USER = address(1);
+    uint256 constant AMOUNT_COLLATERAL = 10 ether;
+
+    function setUp() public {
+        DeploySC deployer = new DeploySC();
+        (sc, ce, config) = deployer.run();
+        (ethPriceFeed,, weth,,) = config.activeNetworkConfig();
+
+        ERC20Mock(weth).mint(USER, 1000e18);
+    }
+
+    ///////////////////////
+    // Constructor Tests //
+    ///////////////////////
+    address[] public tokenAddresses;
+    address[] public priceFeedAddresses;
+
+    function testIfTokenLengthDoesntMatchPriceFeeds() public {
+        tokenAddresses.push(weth);
+        priceFeedAddresses.push(ethPriceFeed);
+        priceFeedAddresses.push(btcPriceFeed);
+        vm.expectRevert(CoinEngine.CoinEngine_TokenAddressAndPriceFeedAddressLengthDontMatch.selector);
+        new CoinEngine(tokenAddresses, priceFeedAddresses, address(sc));
+    }
+
+    //////////////////
+    // Price Tests //
+    //////////////////
+
+    function testGetTokenValueFromUSD() public view {
+        uint256 amountSc = 100 ether; // 100e18
+        uint256 expectEthValue = 0.05 ether;
+        uint256 actualEthValue = ce.getTokenValueFromUSD(amountSc, weth);
+        assertEq(expectEthValue, actualEthValue);
+    }
+
+    function testGetUsdValue() public view {
+        uint256 ethAmount = 1 ether;
+        // 1 ETH = $2000, with 18 decimals precision
+        uint256 expectedUsd = 2000e18;
+
+        uint256 actualUsd = ce.getValueUSD(weth, ethAmount);
+        assertEq(actualUsd, expectedUsd, "USD value incorrect");
+    }
+
+    ///////////////////////////////////////
+    // depositCollateral Tests //
+    ///////////////////////////////////////
+    function testRevertIfCollateralIsZero() public {
+        vm.startPrank(USER);
+        ERC20Mock(weth).approve(address(ce), AMOUNT_COLLATERAL);
+
+        vm.expectRevert(CoinEngine.CoinEngine_AmountShouldMoreThanZero.selector);
+        ce.depositCollateral(weth, 0);
+        vm.stopPrank();
+    }
+
+    function testRevertsWithUnapprovedCollateral() public {
+        ERC20Mock tempToken = new ERC20Mock("TESTToken", "TST", USER, 1000e18);
+        vm.expectRevert(abi.encodeWithSelector(CoinEngine.CoinEngine_isAllowedToken.selector, address(tempToken)));
+        ce.depositCollateral(address(tempToken), AMOUNT_COLLATERAL);
+    }
+
+    function testCanDepositeCollateralAndGetUSERInfo() public {
+        vm.startPrank(USER);
+        ERC20Mock(weth).approve(address(ce), AMOUNT_COLLATERAL);
+        ce.depositCollateral(weth, AMOUNT_COLLATERAL);
+        vm.stopPrank();
+
+        (uint256 totalSCMinted, uint256 collateralValueInUSD) = ce.getAccountInformation(USER);
+        uint256 expectedTotalSCMinted = 0;
+        uint256 expectedDepositedValueinUSD = ce.getTokenValueFromUSD(collateralValueInUSD, weth);
+        vm.assertEq(expectedTotalSCMinted, totalSCMinted);
+        vm.assertEq(expectedDepositedValueinUSD, AMOUNT_COLLATERAL);
+    }
+}