price decimals fix

Author: tusharr1411

script/HelperConfig.s.sol

@@ -16,8 +16,8 @@ contract HelperConfig is Script {
     }
 
     uint8 public constant DECIMALS = 8;
-    int256 public constant ETH_USD_PRICE = 2400e8;
-    int256 public constant BTC_USD_PRICE = 54000e8;
+    int256 public constant ETH_USD_PRICE = 2_000e8;
+    int256 public constant BTC_USD_PRICE = 80_000e8;
     uint256 public DEFAULT_ANVIL_KEY = 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80;
 
     NetworkConfig public activeNetworkConfig;
@@ -47,10 +47,12 @@ contract HelperConfig is Script {
 
         vm.startBroadcast();
         MockV3Aggregator ethUsdPriceFeed = new MockV3Aggregator(DECIMALS, ETH_USD_PRICE);
-        ERC20Mock wethMock = new ERC20Mock("WETH", "WETH", msg.sender, 1000e8);
+        //weth has 18 decimals on ethereum
+        ERC20Mock wethMock = new ERC20Mock("WETH", "WETH", uint8(18), msg.sender, 1000e18);
 
+        // wbt has 8 decimals on ethereum
         MockV3Aggregator btcUsdPriceFeed = new MockV3Aggregator(DECIMALS, BTC_USD_PRICE);
-        ERC20Mock wbtcMock = new ERC20Mock("WBTC", "WBTC", msg.sender, 1000e8);
+        ERC20Mock wbtcMock = new ERC20Mock("WBTC", "WBTC", uint8(8), msg.sender, 1000e8);
 
         vm.stopBroadcast();
 

src/DSCEngine.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.24;
 
 import {DecentralizedStableCoin} from "./DecentralizedStableCoin.sol";
 import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC20} from "src/interfaces/IERC20.sol";
 import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
 
 import {console} from "forge-std/Test.sol";
@@ -320,17 +320,18 @@ contract DSCEngine is ReentrancyGuard {
         return s_CollateralDeposited[user][collateral];
     }
 
+    //returns value of token in usd with 18 decimals
     function getUsdValue(address token, uint256 amount) public view returns (uint256) {
         AggregatorV3Interface priceFeed = AggregatorV3Interface(s_priceFeeds[token]);
         (, int256 price,,,) = priceFeed.latestRoundData();
-        return ((uint256(price) * ADITIONAL_FEED_PRECISION) * amount) / PRECISION;
+        return ((uint256(price) * ADITIONAL_FEED_PRECISION) * amount) / uint256(10 ** IERC20(token).decimals());
     }
 
+    //returns usd value(in 18 deciamls) to tokenAmount ( in token deciamls)
     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) * ADITIONAL_FEED_PRECISION);
+        return (usdAmountInWei * uint256(10 ** IERC20(token).decimals())) / (uint256(price) * ADITIONAL_FEED_PRECISION);
     }
 
     function getPriceFeedFromToken(address tokenAddress) public view returns (address) {

src/interfaces/IERC20.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
+
+pragma solidity ^0.8.20;
+
+/**
+ * @dev Interface of the ERC20 standard as defined in the EIP.
+ */
+interface IERC20 {
+    /**
+     * @dev Emitted when `value` tokens are moved from one account (`from`) to
+     * another (`to`).
+     *
+     * Note that `value` may be zero.
+     */
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    /**
+     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
+     * a call to {approve}. `value` is the new allowance.
+     */
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+
+    /**
+     * @dev Returns the value of tokens in existence.
+     */
+    function totalSupply() external view returns (uint256);
+
+    /**
+     * @dev Returns the deciamls used in token
+     */
+    function decimals() external view returns (uint8);
+
+    /**
+     * @dev Returns the value of tokens owned by `account`.
+     */
+    function balanceOf(address account) external view returns (uint256);
+
+    /**
+     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transfer(address to, uint256 value) external returns (bool);
+
+    /**
+     * @dev Returns the remaining number of tokens that `spender` will be
+     * allowed to spend on behalf of `owner` through {transferFrom}. This is
+     * zero by default.
+     *
+     * This value changes when {approve} or {transferFrom} are called.
+     */
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    /**
+     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
+     * caller's tokens.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * IMPORTANT: Beware that changing an allowance with this method brings the risk
+     * that someone may use both the old and the new allowance by unfortunate
+     * transaction ordering. One possible solution to mitigate this race
+     * condition is to first reduce the spender's allowance to 0 and set the
+     * desired value afterwards:
+     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+     *
+     * Emits an {Approval} event.
+     */
+    function approve(address spender, uint256 value) external returns (bool);
+
+    /**
+     * @dev Moves a `value` amount of tokens from `from` to `to` using the
+     * allowance mechanism. `value` is then deducted from the caller's
+     * allowance.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transferFrom(address from, address to, uint256 value) external returns (bool);
+}

test/fuzz/Handler.t.sol

@@ -45,7 +45,7 @@ contract Handler is Test {
         uint256 maxCollateralToRedeem = engine.getAccountCollateralBalance(msg.sender, address(weth));
         collateralAmount = bound(collateralAmount, 0, maxCollateralToRedeem);
 
-        if(collateralAmount ==0){
+        if (collateralAmount == 0) {
             return; // aur use vm.assume
         }
 

test/mocks/ERC20Mock.sol

@@ -4,11 +4,21 @@ pragma solidity ^0.8.24;
 import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 contract ERC20Mock is ERC20 {
-    constructor(string memory name, string memory symbol, address initialAccount, uint256 initialBalance)
-        payable
-        ERC20(name, symbol)
-    {
+    uint8 i_deciamls;
+
+    constructor(
+        string memory name,
+        string memory symbol,
+        uint8 deciamls,
+        address initialAccount,
+        uint256 initialBalance
+    ) payable ERC20(name, symbol) {
         _mint(initialAccount, initialBalance);
+        i_deciamls = deciamls;
+    }
+
+    function decimals() public view override returns (uint8) {
+        return i_deciamls;
     }
 
     function mint(address account, uint256 amount) public {

test/unit/DSCEngineTest.t.sol

@@ -2,7 +2,7 @@
 
 pragma solidity ^0.8.24;
 
-import {Test, console} from "forge-std/Test.sol";
+import {Test, console, console2} from "forge-std/Test.sol";
 
 import {DeployDSC} from "script/DeployDSC.s.sol";
 import {DecentralizedStableCoin} from "../../src/DecentralizedStableCoin.sol";
@@ -44,10 +44,20 @@ contract DSCEngineTest is Test {
     uint256 public constant MINT_DSC_AMOUNT = 100e18; // 100 USD
     uint256 public constant COLLATERAL_TO_COVER = 20 ether;
 
+    uint256 constant WBTC_PRECISION = 1e8;
+    uint256 constant WETH_PRECISION = 1e18;
+    uint256 constant PRICEFEED_PRECISION = 1e8;
+    uint256 public currentEthPrice;
+    uint256 public currentBtcPrice;
+
     function setUp() public {
         deployer = new DeployDSC();
         (dsc, engine, helperConfig) = deployer.run();
         (ethUsdPriceFeed, btcUsdPriceFeed, weth, wbtc, deployerKey) = helperConfig.activeNetworkConfig();
+        (, int256 ethPrice,,,) = MockV3Aggregator(ethUsdPriceFeed).latestRoundData();
+        currentEthPrice = uint256(ethPrice);
+        (, int256 btcPrice,,,) = MockV3Aggregator(btcUsdPriceFeed).latestRoundData();
+        currentBtcPrice = uint256(btcPrice);
         ERC20Mock(weth).mint(USER, STARTING_ERC20_BALANCE); // 100 weth
         ERC20Mock(wbtc).mint(USER, STARTING_ERC20_BALANCE); // 100 wbtc
 
@@ -70,20 +80,22 @@ contract DSCEngineTest is Test {
     //////////////////////////////////////////////
     ///          View Function Tests           ///
     //////////////////////////////////////////////
-    function test_GetUsdValue() public view {
-        uint256 ethAmount = 2;
-        uint256 expectedValue = 2 * 2400;
-        uint256 actualValue = engine.getUsdValue(weth, ethAmount);
-        console.log("Value in USD: %d", actualValue);
+    function test_getUsdValue() public view {
+        uint256 btcAmount = 2e8;
+        uint256 expectedValue = btcAmount * currentBtcPrice * 1e18 / (WBTC_PRECISION * PRICEFEED_PRECISION);
+        //                                                   / wbtc decimals * priceFeedDecimals
+        uint256 actualValue = engine.getUsdValue(wbtc, btcAmount);
+        console.log("expected value :", expectedValue);
+        console.log("actual value :", actualValue);
         assert(expectedValue == actualValue);
     }
 
     function test_getTokenAmountFromUsd() public view {
-        uint256 usdAmount = 2400 * 1e18;
-        uint256 expectedValue = (2400 * 1e18) / 2400;
-        uint256 actualValue = engine.getTokenAmountFromUsd(weth, usdAmount);
+        uint256 usdAmount = 80_000 * 1e18;
+        uint256 expectedBtc = usdAmount * WBTC_PRECISION * PRICEFEED_PRECISION / (currentBtcPrice * 1e18);
+        uint256 actualValue = engine.getTokenAmountFromUsd(wbtc, usdAmount);
         console.log("Value in ETH: %d", actualValue);
-        assert(expectedValue == actualValue);
+        assert(expectedBtc == actualValue);
     }
 
     function test_getAccountCollateralValue() public view {}