Core Contracts

Summary

The RToken.mint function computes a scaled amount using the rayDiv function but fails to utilize it during the actual minting process. Instead of minting tokens based on the scaled amount, the function mints tokens using the unscaled amountToMint. This discrepancy results in minted token amounts that do not accurately reflect the intended scaled value.

Vulnerability Details

1. Incorrect Usage of Unscaled Amount:

   In the mint function, the following scaling calculation is performed:

   uint256 amountScaled = amountToMint.rayDiv(index);

   However, when calling the internal mint function, the contract uses:

   _mint(onBehalfOf, amountToMint.toUint128());

   Instead of minting based on amountScaled, it mints using amountToMint, effectively bypassing the scaling.

2. Neglected Balance Increase Calculation:

   The function also computes a balanceIncrease:

   uint256 balanceIncrease = 0;

   if (_userState[onBehalfOf].index != 0 && _userState[onBehalfOf].index < index) {

   balanceIncrease = scaledBalance.rayMul(index) - scaledBalance.rayMul(_userState[onBehalfOf].index);

   }

   However, this calculated increase is not incorporated into the minting process or the final token balance update.

3. Inconsistent Token Minting:

   Due to the incorrect use of the unscaled amountToMint, the minted token amount does not represent the scaled value that accounts for the current liquidity index. This inconsistency can lead to discrepancies in user balances, affecting further interest accruals and reserve state calculations.

Impact

• Incorrect User Balances:
  Users receive a token amount that does not reflect the intended scaling, causing a mismatch between the deposited asset value and the minted RToken balance.

Proof-of-Concept (POC) Example

1. Normal Scenario:

   • A user intends to mint tokens by depositing 100 underlying units.

   • Given a certain liquidity index, the correct scaled amount should be:

     amountScaled = 100.rayDiv(index);

   • The expected behavior is that the user receives amountScaled RTokens.

2. Issue Manifestation:

   • The mint function, however, executes:

     _mint(onBehalfOf, amountToMint.toUint128());

   • This results in the user receiving 100 RTokens (the unscaled value) instead of the intended amountScaled.

3. Result:

   • The minted amount deviates from the scaled value, leading to incorrect token balances and reserve state calculations.

Tools Used

Manual review

Recommendations

1. Use Scaled Amount for Minting:

   • Modify the mint function to use amountScaled in the _mint call. For example:

     _mint(onBehalfOf, amountScaled.toUint128());

   • This ensures that the minted tokens accurately reflect the scaling based on the current liquidity index.

2. Incorporate Balance Increase (if Applicable):

   • Review and, if necessary, integrate the balanceIncrease calculation into the user’s balance update to ensure all state changes are accounted for.