Confusion regarding the specific operation of the liquidity function in the DEFI chapter.

[jupiter-Pulin]

Since this is a reward for us as liquidators, and we are using DSC to cover the debt of the liquidated user, shouldn't our DSC also decrease accordingly, and then we take the collateral that the liquidated user has pledged? For example: If the user has pledged $200 worth of ETH => 100 DSC, and if the collateral value decreases to $150 worth of ETH, then as the liquidator, we need to take the user's collateral. In other words, we need to use the 100 DSC we hold to claim the user's $150 worth of ETH. After that, our DSC account should also decrease by 100 DSC. However, this function doesn't implement this; it only decreases the user's account. I believe we should add the following line: s_DSCMinted[dscFrom] -= amountDscToBurn;

/*  
 * @param collateral: The ERC20 token address of the collateral you're using to make the protocol solvent again.  
 * This is collateral that you're going to take from the user who is insolvent.  
 * In return, you have to burn your DSC to pay off their debt, but you don't pay off your own.  
 * @param user: The user who is insolvent. They have to have a _healthFactor below MIN_HEALTH_FACTOR  
 * @param debtToCover: The amount of DSC you want to burn to cover the user's debt.  
 *  
 * @notice: You can partially liquidate a user.  
 * @notice: You will get a 10% LIQUIDATION_BONUS for taking the users funds.  
 * @notice: This function working assumes that the protocol will be roughly 150% overcollateralized in order for this  
 * to work.  
 * @notice: A known bug would be if the protocol was only 100% collateralized, we wouldn't be able to liquidate  
 * anyone. For example, if the price of the collateral plummeted before anyone could be liquidated.  
 */
function liquidate(
    address collateral,
    address user,
    uint256 debtToCover
)
    external
    isAllowedToken(collateral)
    moreThanZero(debtToCover)
    nonReentrant
{
    uint256 startingUserHealthFactor = _healthFactor(user);
    if (startingUserHealthFactor >= 1e18) {
        revert DSCEngine__HealthFactorOk();
    }
    uint256 tokenAmountFromDebtCovered = getTokenAmountFromUsd(collateral, debtToCover);
    uint256 bonusCollateral = (tokenAmountFromDebtCovered * 10) / 100;
    _redeemCollateral(collateral, tokenAmountFromDebtCovered + bonusCollateral, user, msg.sender);
    _burnDsc(debtToCover, user, msg.sender);
    uint256 endingUserHealthFactor = _healthFactor(user);
    // This conditional should never hit, but just in case
    if (endingUserHealthFactor <= startingUserHealthFactor) {
        revert DSCEngine__HealthFactorNotImproved();
    }
    revertIfHealthFactorIsBroken(msg.sender);
}



function _burnDsc(uint256 amountDscToBurn, address onBehalfOf, address dscFrom) private {
    s_DSCMinted[onBehalfOf] -= amountDscToBurn;
    //should add this ???
// s_DSCMinted[dscFrom] -= amountDscToBurn;  
    bool success = i_dsc.transferFrom(dscFrom, address(this), amountDscToBurn); 
    i_dsc.burn(amountDscToBurn);
}

function getTokenAmountFromUsd(address token, uint256 usdAmountInWei) public view returns (uint256) {
    AggregatorV3Interface priceFeed = AggregatorV3Interface(s_priceFeeds[token]);
    (, int256 price,,,) = priceFeed.staleCheckLatestRoundData();

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

[EngrPips]

Hello @jupiter-Pulin, I think your claim that we don't burn the DSC of the liquidator when they try to liquidate unhealthy users is wrong. We indeed burn their DSC, as shown in the code below.

function _burnDsc(uint256 amountDscToBurn, address onBehalfOf, address dscFrom) private {
    s_DSCMinted[onBehalfOf] -= amountDscToBurn;
    //should add this ???
// s_DSCMinted[dscFrom] -= amountDscToBurn;  
    bool success = i_dsc.transferFrom(dscFrom, address(this), amountDscToBurn); 
    i_dsc.burn(amountDscToBurn);
}

In the above code, the msg.sender is the address that called the liquidate function, and it is the liquidator address that we passed as the address we will be burning DSC from, as shown in the code below.

_burnDsc(debtToCover, user, msg.sender);

I want you to understand that the DSC we are burning from the liquidator is not a debt they minted with the protocol but rather some DSC they got some other way, so we can't do what you suggest, which is s_DSCMinted[dscFrom] -= amountDscToBurn; because they didn't mint DSC on the DSCEngine and there is nothing to subtract. Please ask questions if anything is still confusing.

[jupiter-Pulin]

Oh! I see now. Only the staker will have debt, which is reflected in the mapping:

s_DSCMinted

As for us as liquidators, we may not necessarily obtain DSC tokens through staking;
we might have purchased them in some permission transfer. Therefore, we should not add this piece of code:

 s_DSCMinted[dscFrom] -= amountDscToBurn;

[EngrPips]

Exactly, You get the gist, but sincerely speaking, the codebase is far from perfect so there are a lot of improvements that could be made.

[jupiter-Pulin]

ok , thanks so much !!!!!

[EngrPips]

Anytime, Friend. Keep crushing it.