Why does patrick multiply the Eth price by ADDITIONAL_FEED_PRECISION and isnt the Usd Value skewed because of this operation?

[BigAlQ]

This is for the Stable Coin project

// SPDX-License-Identifier: MIT

// This is considered an Exogenous, Decentralized, Anchored (pegged), Crypto Collateralized low volitility coin

// Layout of Contract:
// version
// imports
// interfaces, libraries, contracts
// errors
// Type declarations
// State variables
// Events
// Modifiers
// Functions

// Layout of Functions:
// constructor
// receive function (if exists)
// fallback function (if exists)
// external
// public
// internal
// private 
// view & pure functions 

pragma solidity ^0.8.18;

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 "lib/chainlink-brownie-contracts/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

/**
    @title DSCEngine
    @author Alqasem Hasan 

    The system is designed to be as minimal as possible, and have the tokens maintain a 1 token == $1 peg. 

    This Stable Coin has the following 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 <= value of all the $ backed DSC.

    @notice This contract is the core of the DSC system. It handles all the logic for minting 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();
/*//////////////////////////////////////////////////////////////
                            STATE VARS
    //////////////////////////////////////////////////////////////*/
    uint256 private constant ADDITIONAL_FEED_PRECISION = 1e10;
    uint256 private constant PRECISION = 1e8;
                        
    mapping(address token => address priceFeed) private s_priceFeeds; 
    mapping(address user => mapping(address token => uint256 amount)) private s_collateralDeposited; // user => the token => how much of that token you have
    mapping(address user => uint256 amountDscMinted) private s_DSCMinted;
    address[] private s_collateralTokens; // array of all the tokens that can be used as collateral Ex ETH, WBTC, etc

    DecentralizedStableCoin private immutable i_dsc;
/*//////////////////////////////////////////////////////////////
                                EVENTS
    //////////////////////////////////////////////////////////////*/

    event CollateralDeposited(address indexed user, address indexed token, uint256 indexed amount);

    /*//////////////////////////////////////////////////////////////
                            MODIFIERS
    //////////////////////////////////////////////////////////////*/

    modifier moreThanZero(uint256 amount) {
        if(amount == 0){
            revert DSCEngine__NeedsMoreThanZero();
        }
        _;
    }
    modifier isAllowedToken(address tokenAddr){
        if (s_priceFeeds[tokenAddr] == address(0)) {
            revert DSCEngine__NotAllowedToken();

        }
        _;
    }

    /*//////////////////////////////////////////////////////////////
                            FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    constructor (
        address[] memory tokenAddresses,
        address[] memory priceFeedAddresses,
        address dscAddress
        ) {
        if (tokenAddresses.length != priceFeedAddresses.length ) {
            revert DSCEngine__TokenAddressesAndPriceFeedAddressesMustBeSameLength();
        }

        for(uint256 i = 0; i< tokenAddresses.length; i++) {
            s_priceFeeds[tokenAddresses[i]]= priceFeedAddresses[i];
            s_collateralTokens.push(tokenAddresses[i]); // array of all the tokens that can be used as collateral Ex ETH, WBTC, etc
        }

        i_dsc = DecentralizedStableCoin(dscAddress);
    }

    function depositCollateralAndMintDsc() external {}

    /*//////////////////////////////////////////////////////////////
                        EXTERNAL FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /*
    @notice followes CEI (Checks Effects Intereactions)
    @ 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
    ) external 
    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();
    }
    }

    function redeemCollateralForDsc() external {}

    // Threshold to let's say 150% 
    // $100 ETH -> $74 ETH   if the price of ETH tanks to 74$, then you are undercollaterlized!
    // $50 DSC
    // UNDERCOLLATERALIZED!!
    // Someone can give the smart contract $50 of DSC, and then get back 74$ worth of ETH   


    function redeemCollateral() external {}
    // To mint DSC, we need to check if the collateral value is greater > DSC amount. We will need Price feeds, values 
    
    /*
    @notice followes CEI (Checks Effects Intereactions)
    @param amountDSCToMint The amount of DSC to mint
    @notice they must have more collateral value than the minimum threshold
    */

    function mintDsc(uint256 amountDSCToMint) external moreThanZero(amountDSCToMint) nonReentrant() {
        s_DSCMinted[msg.sender] += amountDSCToMint;
        // revert if the minted $100 of DSC and $50 of ETH or Collateral 
        _revertIfHealthFactorIsBroken(msg.sender);
    }

    function burnDsc() external {} 

    function liquidate() external {}

    function getHealthFactor() external view {}

/*//////////////////////////////////////////////////////////////
                    PRIVATE AND INTERNAL VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    // these functions can only be accessed by this contract, and can't be called by other contracts or externally

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

    /**
    Returns how close a user is to liquadation  
    If a user goes below one, then they can get liquidated
    Health Factor = (Collateral In Eth * Liquadation Threshold) / DSC Minted
    */

    function _healthFactor(address user) private view returns (uint256) {
        // We need to get two things:
        // 1. The amount of DSC minted user and
        // 2. The value of the user's collateral
        (uint256 totalDSCMinted, uint256 collateralValueInUsd) = _getAccountInformation(user);
    }  

    function _revertIfHealthFactorIsBroken(address user) internal view {
        // 1. Check health factor, (do they have collateral > DSC)
        // 2. If not, revert
    } 
/*//////////////////////////////////////////////////////////////
                    PUBLIC AND EXTERNAL VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    function getAccountCollateralValueUSD(address user) public view returns (uint256 collateralValueInUsd) {
        for(uint256 i = 0; i < s_collateralTokens.length; i++){
            address token = s_collateralTokens[i]; // first get the collateral token in questions Ex WBTW
            uint256 amount = s_collateralDeposited[user][token]; // then get the amount of that token the user has Ex 50 WBTC
            collateralValueInUsd += getUsdValue(token,amount);
        }   
}

    function getUsdValue(address token, uint256 amount) public view returns (uint256){
        AggregatorV3Interface priceFeed = AggregatorV3Interface(s_priceFeeds[token]);
        (,int256 price,,,) = priceFeed.latestRoundData();
        // 1 ETH = $1000 
        // The returned value from ChainLink for the price will be 1000 * 1e8 (we are account for the decimals) 
        return ((uint256(price) * ADDITIONAL_FEED_PRECISION) * amount)/PRECISION; // Many ERC-20 tokens (like USDC, DAI) use 18 decimal places
                                                                                // By multiplying price by ADDITIONAL_FEED_PRECISION (1e10), we scale the value to 18 decimals, matching the common ERC-20 token standard
    }

}

[EngrPips]

Patrick did the multiplication so that we are consistent with the use of 18 decimals throughout our contract.

[KMean]

@BigAlQ you got a good point here, you can also find some info from auditors about it, but I think that formula has been changed in the final repo to be

 return ((usdAmountInWei * PRECISION) / (uint256(price) * ADDITIONAL_FEED_PRECISION));

Said that I'm not sure where you get your PRECISION to be 1e8? In the video PRECISION is 1e18.
I think this codebase has been or is beeing audited so maybe things will change.