Fixed a bug with rates after a flashloan

TepNik · sakulstra · commit c0bd6b9ca327 · 2025-05-14T13:24:43.000+02:00
fix: adjust tests
diff --git a/docs/3.4/Aave-v3.4-features.md b/docs/3.4/Aave-v3.4-features.md
@@ -184,7 +184,7 @@ Solc was upgraded from `8.20` to `8.27`
 - `PoolLogic` contract:
   - The `PoolLogic` contract was extended with two methods `executeSyncIndexesState` & `executeSyncRatesState`, which simply replicate what was previously on the Pool itself. This is done to free some code-space on the pool itself.
 - `FlashLoanLogic` library:
-  - Now all fees from flash-loans are sent to the `RESERVE_TREASURY_ADDRESS`.
+  - Now all fees from flash-loans are accrued to the `RESERVE_TREASURY_ADDRESS`.
 - `MathUtils` library:
   - The `calculateCompoundedInterest` function was improved to be more accurate and gas efficient without changing the formula.
 
diff --git a/snapshots/Pool.Operations.json b/snapshots/Pool.Operations.json
@@ -1,11 +1,11 @@
 {
   "borrow: first borrow->borrowingEnabled": "244049",
   "borrow: recurrent borrow": "216250",
-  "flashLoan: flash loan for one asset": "143666",
+  "flashLoan: flash loan for one asset": "162275",
   "flashLoan: flash loan for one asset and borrow": "265661",
-  "flashLoan: flash loan for two assets": "234930",
+  "flashLoan: flash loan for two assets": "257324",
   "flashLoan: flash loan for two assets and borrow": "458805",
-  "flashLoanSimple: simple flash loan": "122132",
+  "flashLoanSimple: simple flash loan": "138173",
   "liquidationCall: deficit on liquidated asset": "354595",
   "liquidationCall: deficit on liquidated asset + other asset": "443653",
   "liquidationCall: full liquidation": "354595",
diff --git a/src/contracts/protocol/libraries/logic/FlashLoanLogic.sol b/src/contracts/protocol/libraries/logic/FlashLoanLogic.sol
@@ -218,18 +218,29 @@ library FlashLoanLogic {
     DataTypes.ReserveData storage reserve,
     DataTypes.FlashLoanRepaymentParams memory params
   ) internal {
-    reserve.virtualUnderlyingBalance += params.amount.toUint128();
+    uint256 amountPlusPremium = params.amount + params.totalPremium;
+
+    DataTypes.ReserveCache memory reserveCache = reserve.cache();
+    reserve.updateState(reserveCache);
+
+    reserve.accruedToTreasury += params
+      .totalPremium
+      .rayDiv(reserveCache.nextLiquidityIndex)
+      .toUint128();
+
+    reserve.updateInterestRatesAndVirtualBalance(
+      reserveCache,
+      params.asset,
+      amountPlusPremium,
+      0,
+      params.interestRateStrategyAddress
+    );
 
     IERC20(params.asset).safeTransferFrom(
       params.receiverAddress,
-      reserve.aTokenAddress,
-      params.amount
+      reserveCache.aTokenAddress,
+      amountPlusPremium
     );
-    if (params.totalPremium != 0) {
-      address treasury = IAToken(reserve.aTokenAddress).RESERVE_TREASURY_ADDRESS();
-
-      IERC20(params.asset).safeTransferFrom(params.receiverAddress, treasury, params.totalPremium);
-    }
 
     emit IPool.FlashLoan(
       params.receiverAddress,
diff --git a/tests/mocks/MockFlashLoanBorrowInsideFlashLoan.sol b/tests/mocks/MockFlashLoanBorrowInsideFlashLoan.sol
@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.10;
+
+import {IERC20} from '../../src/contracts/dependencies/openzeppelin/contracts/IERC20.sol';
+import {IPoolAddressesProvider} from '../../src/contracts/interfaces/IPoolAddressesProvider.sol';
+import {IPool} from '../../src/contracts/interfaces/IPool.sol';
+import {FlashLoanSimpleReceiverBase} from '../../src/contracts/misc/flashloan/base/FlashLoanSimpleReceiverBase.sol';
+import {MintableERC20} from '../../src/contracts/mocks/tokens/MintableERC20.sol';
+
+contract MockFlashLoanBorrowInsideFlashLoan is FlashLoanSimpleReceiverBase {
+  constructor(IPoolAddressesProvider provider) FlashLoanSimpleReceiverBase(provider) {}
+
+  function executeOperation(
+    address asset,
+    uint256 amount,
+    uint256 premium,
+    address /* initiator */,
+    bytes calldata /* params */
+  ) external returns (bool) {
+    IERC20(asset).approve(msg.sender, amount * 2 + premium);
+
+    uint256 underlyingBalance = IPool(msg.sender).getVirtualUnderlyingBalance(asset);
+
+    IPool(msg.sender).borrow({
+      asset: asset,
+      amount: (underlyingBalance * 9) / 10,
+      interestRateMode: 2,
+      referralCode: 0,
+      onBehalfOf: address(this)
+    });
+
+    return true;
+  }
+
+  function executeOperation(
+    address[] memory assets,
+    uint256[] memory amounts,
+    uint256[] memory premiums,
+    address /* initiator */,
+    bytes calldata /* params */
+  ) public returns (bool) {
+    for (uint256 i = 0; i < assets.length; i++) {
+      IERC20(assets[i]).approve(msg.sender, amounts[i] * 2 + premiums[i]);
+
+      uint256 underlyingBalance = IPool(msg.sender).getVirtualUnderlyingBalance(assets[i]);
+
+      IPool(msg.sender).borrow({
+        asset: assets[i],
+        amount: (underlyingBalance * 9) / 10,
+        interestRateMode: 2,
+        referralCode: 0,
+        onBehalfOf: address(this)
+      });
+    }
+
+    return true;
+  }
+}
diff --git a/tests/protocol/pool/Pool.FlashLoans.t.sol b/tests/protocol/pool/Pool.FlashLoans.t.sol
@@ -14,9 +14,11 @@ import {MockFlashLoanReceiver} from '../../../src/contracts/mocks/flashloan/Mock
 import {MockFlashLoanSimpleReceiver} from '../../../src/contracts/mocks/flashloan/MockSimpleFlashLoanReceiver.sol';
 import {IPoolAddressesProvider} from '../../../src/contracts/interfaces/IPoolAddressesProvider.sol';
 import {IPool} from '../../../src/contracts/interfaces/IPool.sol';
+import {IReserveInterestRateStrategy} from '../../../src/contracts/interfaces/IReserveInterestRateStrategy.sol';
 import {DataTypes} from '../../../src/contracts/protocol/libraries/types/DataTypes.sol';
 import {IERC20} from '../../../src/contracts/dependencies/openzeppelin/contracts/IERC20.sol';
 import {MockFlashLoanATokenReceiver} from '../../mocks/MockFlashLoanATokenReceiver.sol';
+import {MockFlashLoanBorrowInsideFlashLoan} from '../../mocks/MockFlashLoanBorrowInsideFlashLoan.sol';
 import {TestnetProcedures, TestReserveConfig} from '../../utils/TestnetProcedures.sol';
 
 contract PoolFlashLoansTests is TestnetProcedures {
@@ -329,6 +331,8 @@ contract PoolFlashLoansTests is TestnetProcedures {
     uint256 virtualUnderlyingBalanceBefore = contracts.poolProxy.getVirtualUnderlyingBalance(
       tokenList.usdx
     );
+    uint256 totalFee = contracts.poolProxy.FLASHLOAN_PREMIUM_TOTAL();
+    uint256 amount = 10e6;
 
     vm.prank(poolAdmin);
     TestnetERC20(tokenList.usdx).transferOwnership(address(mockFlashSimpleReceiver));
@@ -337,15 +341,18 @@ contract PoolFlashLoansTests is TestnetProcedures {
     contracts.poolProxy.flashLoanSimple(
       address(mockFlashSimpleReceiver),
       tokenList.usdx,
-      10e6,
+      amount,
       '0x',
       0
     );
 
     uint256 virtualUnderlyingBalanceAfter = contracts.poolProxy.getVirtualUnderlyingBalance(
       tokenList.usdx
     );
-    assertEq(virtualUnderlyingBalanceBefore, virtualUnderlyingBalanceAfter);
+    assertEq(
+      virtualUnderlyingBalanceBefore + (amount * totalFee) / 1e4,
+      virtualUnderlyingBalanceAfter
+    );
   }
 
   function test_flashloan_simple_2() public {
@@ -382,6 +389,7 @@ contract PoolFlashLoansTests is TestnetProcedures {
     uint256 virtualUnderlyingBalanceBefore = contracts.poolProxy.getVirtualUnderlyingBalance(
       assets[0]
     );
+    uint256 totalFee = contracts.poolProxy.FLASHLOAN_PREMIUM_TOTAL();
 
     vm.prank(alice);
     contracts.poolProxy.flashLoan(
@@ -397,7 +405,10 @@ contract PoolFlashLoansTests is TestnetProcedures {
     uint256 virtualUnderlyingBalanceAfter = contracts.poolProxy.getVirtualUnderlyingBalance(
       assets[0]
     );
-    assertEq(virtualUnderlyingBalanceBefore, virtualUnderlyingBalanceAfter);
+    assertEq(
+      virtualUnderlyingBalanceBefore + (amounts[0] * totalFee) / 1e4,
+      virtualUnderlyingBalanceAfter
+    );
   }
 
   function test_flashloan_multiple() public {
@@ -414,6 +425,7 @@ contract PoolFlashLoansTests is TestnetProcedures {
     uint256 virtualUnderlyingBalanceBefore1 = contracts.poolProxy.getVirtualUnderlyingBalance(
       assets[1]
     );
+    uint256 totalFee = contracts.poolProxy.FLASHLOAN_PREMIUM_TOTAL();
 
     vm.prank(alice);
     contracts.poolProxy.flashLoan(
@@ -433,8 +445,14 @@ contract PoolFlashLoansTests is TestnetProcedures {
       assets[1]
     );
 
-    assertEq(virtualUnderlyingBalanceBefore0, virtualUnderlyingBalanceAfter0);
-    assertEq(virtualUnderlyingBalanceBefore1, virtualUnderlyingBalanceAfter1);
+    assertEq(
+      virtualUnderlyingBalanceBefore0 + (amounts[0] * totalFee) / 1e4,
+      virtualUnderlyingBalanceAfter0
+    );
+    assertEq(
+      virtualUnderlyingBalanceBefore1 + (amounts[1] * totalFee) / 1e4,
+      virtualUnderlyingBalanceAfter1
+    );
   }
 
   function test_flashloan_borrow() public {
@@ -460,6 +478,148 @@ contract PoolFlashLoansTests is TestnetProcedures {
     );
   }
 
+  function test_flashloan_simple_borrow_inside_flashloan_and_check_rate_after() public {
+    MockFlashLoanBorrowInsideFlashLoan receiver = new MockFlashLoanBorrowInsideFlashLoan(
+      contracts.poolAddressesProvider
+    );
+
+    address asset = tokenList.usdx;
+    uint256 underlyingBalance = contracts.poolProxy.getVirtualUnderlyingBalance(asset);
+
+    vm.startPrank(carol);
+    contracts.poolProxy.borrow({
+      asset: asset,
+      amount: underlyingBalance / 5,
+      interestRateMode: 2,
+      referralCode: 0,
+      onBehalfOf: carol
+    });
+    IERC20(contracts.poolProxy.getReserveAToken(asset)).transfer(
+      address(receiver),
+      underlyingBalance / 2
+    );
+    vm.stopPrank();
+
+    underlyingBalance = contracts.poolProxy.getVirtualUnderlyingBalance(asset);
+    uint256 amount = (underlyingBalance * 9) / 10;
+
+    deal(asset, address(receiver), amount * 2);
+
+    DataTypes.ReserveDataLegacy memory reserveData = contracts.poolProxy.getReserveData(asset);
+    assertGt(reserveData.currentLiquidityRate, 0);
+    assertGt(reserveData.currentVariableBorrowRate, 0);
+
+    contracts.poolProxy.flashLoanSimple({
+      receiverAddress: address(receiver),
+      asset: asset,
+      amount: amount,
+      params: '',
+      referralCode: 0
+    });
+
+    reserveData = contracts.poolProxy.getReserveData(asset);
+
+    (uint256 nextLiquidityRate, uint256 nextVariableRate) = contracts
+      .defaultInterestRateStrategy
+      .calculateInterestRates(
+        DataTypes.CalculateInterestRatesParams({
+          unbacked: contracts.poolProxy.getReserveDeficit(asset),
+          liquidityAdded: 0,
+          liquidityTaken: 0,
+          totalDebt: IERC20(contracts.poolProxy.getReserveVariableDebtToken(asset)).totalSupply(),
+          reserveFactor: reserveData.configuration.getReserveFactor(),
+          reserve: asset,
+          usingVirtualBalance: true,
+          virtualUnderlyingBalance: contracts.poolProxy.getVirtualUnderlyingBalance(asset)
+        })
+      );
+    assertEq(reserveData.currentLiquidityRate, nextLiquidityRate);
+    assertEq(reserveData.currentVariableBorrowRate, nextVariableRate);
+  }
+
+  function test_flashloan_borrow_inside_flashloan_and_check_rate_after() public {
+    MockFlashLoanBorrowInsideFlashLoan receiver = new MockFlashLoanBorrowInsideFlashLoan(
+      contracts.poolAddressesProvider
+    );
+
+    address[] memory assets = new address[](2);
+    uint256[] memory underlyingBalances = new uint256[](2);
+    uint256[] memory amounts = new uint256[](2);
+    uint256[] memory interestRateModes = new uint256[](2);
+
+    assets[0] = tokenList.usdx;
+    assets[1] = tokenList.wbtc;
+
+    interestRateModes[0] = 0;
+    interestRateModes[1] = 0;
+
+    for (uint256 i = 0; i < assets.length; ++i) {
+      underlyingBalances[i] = contracts.poolProxy.getVirtualUnderlyingBalance(assets[i]);
+
+      vm.startPrank(carol);
+      contracts.poolProxy.borrow({
+        asset: assets[i],
+        amount: underlyingBalances[i] / 5,
+        interestRateMode: 2,
+        referralCode: 0,
+        onBehalfOf: carol
+      });
+
+      IERC20(contracts.poolProxy.getReserveAToken(assets[i])).transfer(
+        address(receiver),
+        underlyingBalances[i] / 2
+      );
+      vm.stopPrank();
+
+      underlyingBalances[i] = contracts.poolProxy.getVirtualUnderlyingBalance(assets[i]);
+
+      amounts[i] = (underlyingBalances[i] * 9) / 10;
+
+      deal(assets[i], address(receiver), amounts[i] * 2);
+
+      DataTypes.ReserveDataLegacy memory reserveData = contracts.poolProxy.getReserveData(
+        assets[i]
+      );
+
+      assertGt(reserveData.currentLiquidityRate, 0);
+      assertGt(reserveData.currentVariableBorrowRate, 0);
+    }
+
+    contracts.poolProxy.flashLoan({
+      receiverAddress: address(receiver),
+      assets: assets,
+      amounts: amounts,
+      interestRateModes: interestRateModes,
+      onBehalfOf: address(receiver),
+      params: '',
+      referralCode: 0
+    });
+
+    for (uint256 i = 0; i < assets.length; ++i) {
+      DataTypes.ReserveDataLegacy memory reserveData = contracts.poolProxy.getReserveData(
+        assets[i]
+      );
+
+      (uint256 nextLiquidityRate, uint256 nextVariableRate) = contracts
+        .defaultInterestRateStrategy
+        .calculateInterestRates(
+          DataTypes.CalculateInterestRatesParams({
+            unbacked: contracts.poolProxy.getReserveDeficit(assets[0]),
+            liquidityAdded: 0,
+            liquidityTaken: 0,
+            totalDebt: IERC20(contracts.poolProxy.getReserveVariableDebtToken(assets[0]))
+              .totalSupply(),
+            reserveFactor: reserveData.configuration.getReserveFactor(),
+            reserve: assets[0],
+            usingVirtualBalance: true,
+            virtualUnderlyingBalance: contracts.poolProxy.getVirtualUnderlyingBalance(assets[0])
+          })
+        );
+      assertEq(reserveData.currentLiquidityRate, nextLiquidityRate);
+      assertEq(reserveData.currentVariableBorrowRate, nextVariableRate);
+    }
+  }
+
   function test_revert_flashloan_borrow_stable() public {
     (
       address[] memory assets,
