duplicated arithmetic multiplication during calculating variable and stable debt?

[bnb-scs]

Have a question about the stable and variable debt calculating logic in the _mintToTreasury() function.

https://github.com/aave/protocol-v2/blob/release/aave-v2-ethereum/contracts/protocol/libraries/logic/ReserveLogic.sol#L274-L311

it seems the passed in scaledVariableDebt has already multiplied by the reserve.variableBorrowIndex factor in ReserveLogic.sol, why do multiply it by previousVariableBorrowIndex (and newVariableBorrowIndex) again in _mintToTreasury()? the resulting variable debt would be the principal debt supply multiply twice the variableBorrowIndex

    //calculate the last principal variable debt
    vars.previousVariableDebt = scaledVariableDebt.rayMul(previousVariableBorrowIndex);

    //calculate the new total supply after accumulation of the index
    vars.currentVariableDebt = scaledVariableDebt.rayMul(newVariableBorrowIndex);

For stable debt, vars.currentStableDebt and vars.previousStableDebt seem to be the same, where IStableDebtToken(reserve.stableDebtTokenAddress).getSupplyData() calculates the current stable debt by multiply the principleSupply and the compoundedInterest, whereas previousStableDebt is calculated using exactly the same formula with the same avgrate and same stableSupplyUpdatedTimestamp, so these two variables should be always the same?

[0xCh1no]

Part 1: Why is scaledVariableDebt multiplied again by variableBorrowIndex?

The scaledVariableDebt passed into _mintToTreasury() is not currently multiplied by the index. It represents the principal debt in scaled form, meaning:

*variableDebt = scaledVariableDebt * reserve.variableBorrowIndex

However, in _mintToTreasury(), this is what happens:

*vars.previousVariableDebt = scaledVariableDebt.rayMul(previousVariableBorrowIndex);
vars.currentVariableDebt = scaledVariableDebt.rayMul(newVariableBorrowIndex);

---

But why use both previous and new?

The idea here is to calculate the interest accrued since the last update, that is:

previousVariableDebt → how much the nominal debt was at the last update.

currentVariableDebt → how much the nominal debt is now, with the latest index.

The difference between the two represents the accrued interest, which is what will be minted to the treasury (mintToTreasury).

In other words, scaledVariableDebt is multiplied by both indexes — but not at the same time. It’s used to compare values across two different moments in time to calculate the change in debt.

---

Part 2: Why do previousStableDebt and currentStableDebt seem to be the same?
You correctly observed that the calculation looks like this:

*(uint256 principalStableDebt,
uint256 currentStableDebt,
uint256 avgStableRate,
uint256 stableSupplyUpdatedTimestamp) = IStableDebtToken(reserve.stableDebtTokenAddress).getSupplyData();

vars.previousStableDebt = principalStableDebt.rayMul(
InterestMath.calculateCompoundedInterest(
avgStableRate, stableSupplyUpdatedTimestamp, block.timestamp
)
);

And this seems to produce the same value as currentStableDebt.

Why?
getSupplyData() returns:

currentStableDebt, which is internally calculated as:

*principalSupply * compoundedInterest

Meanwhile, outside the function, we are reconstructing that same calculation manually using the same inputs — so the result will be identical (except for possible micro-timing differences if run extremely close together).

Key takeaway:

The reason for keeping both previousStableDebt and currentStableDebt is to be consistent with the variable debt model, but in the case of stable debt, they will indeed be the same, since everything is updated within the same block, and no indexes have changed between the calls.

---

TL;DR
scaledVariableDebt isn’t yet multiplied — the function does it using the old and new indexes separately to calculate the interest accrued since last time.

For stable debt, currentStableDebt and previousStableDebt will be the same because they’re calculated within the same block and no parameters (like timestamps) have changed between them.