[VEN-2984] Flash loan implementation

contracts/Comptroller.sol

@@ -6,13 +6,14 @@
 import { AccessControlledV8 } from "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol";
 import { IPrime } from "@venusprotocol/venus-protocol/contracts/Tokens/Prime/Interfaces/IPrime.sol";
 
-import { ComptrollerInterface, Action } from "./ComptrollerInterface.sol";
+import { ComptrollerInterface, VTokenInterface, Action } from "./ComptrollerInterface.sol";
 import { ComptrollerStorage } from "./ComptrollerStorage.sol";
 import { ExponentialNoError } from "./ExponentialNoError.sol";
 import { VToken } from "./VToken.sol";
 import { RewardsDistributor } from "./Rewards/RewardsDistributor.sol";
 import { MaxLoopsLimitHelper } from "./MaxLoopsLimitHelper.sol";
 import { ensureNonzeroAddress } from "./lib/validators.sol";
+import { IFlashLoanReceiver } from "./Flashloan/interfaces/IFlashloanReceiver.sol";
 
 /**
  * @title Comptroller
@@ -47,7 +48,7 @@
 {
     // PoolRegistry, immutable to save on gas
     /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
     address public immutable poolRegistry;
 
     /// @notice Emitted when an account enters a market
     event MarketEntered(VToken indexed vToken, address indexed account);
@@ -100,9 +101,13 @@
 
     /// @notice Emitted when a market is unlisted
     event MarketUnlisted(address indexed vToken);
+
     /// @notice Emitted when the borrowing or redeeming delegate rights are updated for an account
     event DelegateUpdated(address indexed approver, address indexed delegate, bool approved);
 
+    /// @notice Emitted When the flash loan is successfully executed
+    event FlashLoanExecuted(address receiver, VTokenInterface[] assets, uint256[] amounts);
+
     /// @notice Thrown when collateral factor exceeds the upper bound
     error InvalidCollateralFactor();
 
@@ -163,6 +168,24 @@
     /// @notice Thrown when collateral factor is not zero
     error CollateralFactorIsNotZero();
 
+    /// @notice Thrown when the close factor is invalid
+    error InvalidCloseFactor();
+
+    /// @notice Thrown when the liquidation incentive is invalid
+    error InvalidLiquidationIncentive();
+
+    /// @notice Thrown when the VToken is invalid
+    error InvalidVToken();
+
+    /// @notice Thrown when the input is invalid
+    error InvalidInput();
+
+    /// @notice Thrown when the rewards distributor already exists
+    error RewardsDistributorAlreadyExists();
+
+    /// @notice Thrown when the market does not exist
+    error MarketNotExist();
+
     /**
      * @notice Thrown during the liquidation if user's total collateral amount is lower than
      *   a predefined threshold. In this case only batch liquidations (either liquidateAccount
@@ -199,6 +222,18 @@
     /// @notice Thrown if delegate approval status is already set to the requested value
     error DelegationStatusUnchanged();
 
+    /// @notice Thrown if invalid flashLoan params passed
+    error InvalidFlashLoanParams();
+
+    ///@notice Thrown if the flashLoan is not enabled for a particular market
+    error FlashLoanNotEnabled(address market);
+
+    ///@notice Thrown if repayment amount is insufficient
+    error InsufficientReypaymentBalance(address tokenAddress);
+
+    ///@notice Thrown if executeOperation failed
+    error ExecuteFlashLoanFailed();
+
     /// @param poolRegistry_ Pool registry address
     /// @custom:oz-upgrades-unsafe-allow constructor
     /// @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero
@@ -500,7 +535,7 @@
      * @param redeemAmount The amount of the underlying asset being redeemed
      * @param redeemTokens The number of tokens being redeemed
      */
     function redeemVerify(address vToken, address redeemer, uint256 redeemAmount, uint256 redeemTokens) external {
         if (address(prime) != address(0)) {
             prime.accrueInterestAndUpdateScore(redeemer, vToken);
         }
@@ -919,6 +954,68 @@
         }
     }
 
+    /**
+     * @notice Executes a flashLoan operation with the specified assets and amounts.
+     * @dev Transfer the specified assets to the receiver contract and ensures that the total repayment (amount + fee)
+     *      is returned by the receiver contract after the operation for each asset. The function performs checks to ensure the validity
+     *      of parameters, that flashLoans are enabled for the given assets, and that the total repayment is sufficient.
+     *      Reverts on invalid parameters, disabled flashLoans, or insufficient repayment.
+     * @param receiver The address of the contract that will receive the flashLoan and execute the operation.
+     * @param assets The addresses of the assets to be loaned.
+     * @param amounts The amounts of each asset to be loaned.
+     * @custom:requirements
+     *      - `assets.length` must be equal to `amounts.length`.
+     *      - `assets.length` and `amounts.length` must not be zero.
+     *      - The `receiver` address must not be the zero address.
+     *      - FlashLoans must be enabled for each asset.
+     *      - The `receiver` contract must repay the loan with the appropriate fee.
+     * @custom:reverts
+     *      - Reverts with `InvalidFlashLoanParams()` if parameter checks fail.
+     *      - Reverts with `FlashLoanNotEnabled(asset)` if flashLoans are disabled for any of the requested assets.
+     *      - Reverts with `ExecuteFlashLoanFailed` if the receiver contract fails to execute the operation.
+     *      - Reverts with `InsufficientReypaymentBalance(asset)` if the repayment (amount + fee) is insufficient after the operation.
+     */
+    function executeFlashLoan(
+        address receiver,
+        VTokenInterface[] calldata assets,
+        uint256[] calldata amounts
+    ) external override {
+        // Asset and amount length must be equals and not be zero
+        if (assets.length != amounts.length || assets.length == 0 || receiver == address(0)) {
+            revert InvalidFlashLoanParams();
+        }
+
+        uint256 len = assets.length;
+        uint256[] memory fees = new uint256[](len);
+        uint256[] memory balanceBefore = new uint256[](len);
+
+        for (uint256 j; j < len; ) {
+            (fees[j], ) = (assets[j]).calculateFee(receiver, amounts[j]);
+
+            // Transfer the asset
+            (balanceBefore[j]) = (assets[j]).transferUnderlying(receiver, amounts[j]);
+
+            unchecked {
+                ++j;
+            }
+        }
+
+        // Call the execute operation on receiver contract
+        if (!IFlashLoanReceiver(receiver).executeOperation(assets, amounts, fees, receiver, "")) {
+            revert ExecuteFlashLoanFailed();
+        }
+
+        for (uint256 k; k < len; ) {
+            (assets[k]).verifyBalance(balanceBefore[k], amounts[k] + fees[k]);
+
+            unchecked {
+                ++k;
+            }
+        }
+
+        emit FlashLoanExecuted(receiver, assets, amounts);
+    }
+
     /**
      * @notice Liquidates all borrows of the borrower. Callable only if the collateral is less than
      *   a predefined threshold, and the account collateral can be seized to cover all borrows. If
@@ -983,7 +1080,10 @@
 
         for (uint256 i; i < marketsCount; ++i) {
             (, uint256 borrowBalance, ) = _safeGetAccountSnapshot(borrowMarkets[i], borrower);
-            require(borrowBalance == 0, "Nonzero borrow balance after liquidation");
+            // require(borrowBalance == 0, "Nonzero borrow balance after liquidation");
+            if (borrowBalance > 0) {
+                revert NonzeroBorrowBalance();
+            }
         }
     }
 
@@ -995,8 +1095,11 @@
      */
     function setCloseFactor(uint256 newCloseFactorMantissa) external {
         _checkAccessAllowed("setCloseFactor(uint256)");
-        require(MAX_CLOSE_FACTOR_MANTISSA >= newCloseFactorMantissa, "Close factor greater than maximum close factor");
-        require(MIN_CLOSE_FACTOR_MANTISSA <= newCloseFactorMantissa, "Close factor smaller than minimum close factor");
+        if (MAX_CLOSE_FACTOR_MANTISSA < newCloseFactorMantissa || MIN_CLOSE_FACTOR_MANTISSA > newCloseFactorMantissa) {
+            revert InvalidCloseFactor();
+        }
+        // require(MAX_CLOSE_FACTOR_MANTISSA >= newCloseFactorMantissa, "Close factor greater than maximum close factor");
+        // require(MIN_CLOSE_FACTOR_MANTISSA <= newCloseFactorMantissa, "Close factor smaller than minimum close factor");
 
         uint256 oldCloseFactorMantissa = closeFactorMantissa;
         closeFactorMantissa = newCloseFactorMantissa;
@@ -1071,7 +1174,10 @@
      * @custom:access Controlled by AccessControlManager
      */
     function setLiquidationIncentive(uint256 newLiquidationIncentiveMantissa) external {
-        require(newLiquidationIncentiveMantissa >= MANTISSA_ONE, "liquidation incentive should be greater than 1e18");
+        if (newLiquidationIncentiveMantissa < MANTISSA_ONE) {
+            revert InvalidLiquidationIncentive();
+        }
+        // require(newLiquidationIncentiveMantissa >= MANTISSA_ONE, "liquidation incentive should be greater than 1e18");
 
         _checkAccessAllowed("setLiquidationIncentive(uint256)");
 
@@ -1099,7 +1205,11 @@
             revert MarketAlreadyListed(address(vToken));
         }
 
-        require(vToken.isVToken(), "Comptroller: Invalid vToken"); // Sanity check to make sure its really a VToken
+        if (!vToken.isVToken()) {
+            revert InvalidVToken();
+        }
+
+        // require(vToken.isVToken(), "Comptroller: Invalid vToken"); // Sanity check to make sure its really a VToken
 
         Market storage newMarket = markets[address(vToken)];
         newMarket.isListed = true;
@@ -1133,7 +1243,10 @@
         uint256 numMarkets = vTokens.length;
         uint256 numBorrowCaps = newBorrowCaps.length;
 
-        require(numMarkets != 0 && numMarkets == numBorrowCaps, "invalid input");
+        if (numMarkets == 0 || numMarkets != numBorrowCaps) {
+            revert InvalidInput();
+        }
+        // require(numMarkets != 0 && numMarkets == numBorrowCaps, "invalid input");
 
         _ensureMaxLoops(numMarkets);
 
@@ -1157,8 +1270,11 @@
         _checkAccessAllowed("setMarketSupplyCaps(address[],uint256[])");
         uint256 vTokensCount = vTokens.length;
 
-        require(vTokensCount != 0, "invalid number of markets");
-        require(vTokensCount == newSupplyCaps.length, "invalid number of markets");
+        if (vTokensCount == 0 || vTokensCount != newSupplyCaps.length) {
+            revert InvalidInput();
+        }
+        // require(vTokensCount != 0, "invalid number of markets");
+        // require(vTokensCount == newSupplyCaps.length, "invalid number of markets");
 
         _ensureMaxLoops(vTokensCount);
 
@@ -1216,7 +1332,10 @@
      * @custom:event Emits NewRewardsDistributor with distributor address
      */
     function addRewardsDistributor(RewardsDistributor _rewardsDistributor) external onlyOwner {
-        require(!rewardsDistributorExists[address(_rewardsDistributor)], "already exists");
+        if (rewardsDistributorExists[address(_rewardsDistributor)]) {
+            revert RewardsDistributorAlreadyExists();
+        }
+        // require(!rewardsDistributorExists[address(_rewardsDistributor)], "already exists");
 
         uint256 rewardsDistributorsLen = rewardsDistributors.length;
         _ensureMaxLoops(rewardsDistributorsLen + 1);
@@ -1493,7 +1612,7 @@
             }
         }
 
         assembly {
             mstore(assetsIn, len)
         }
 
@@ -1554,7 +1673,10 @@
      * @param paused The new paused state (true=paused, false=unpaused)
      */
     function _setActionPaused(address market, Action action, bool paused) internal {
-        require(markets[market].isListed, "cannot pause a market that is not listed");
+        if (!markets[market].isListed) {
+            revert MarketNotExist();
+        }
+        // require(markets[market].isListed, "cannot pause a market that is not listed");
         _actionPaused[market][action] = paused;
         emit ActionPausedMarket(VToken(market), action, paused);
     }

contracts/ComptrollerInterface.sol

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: BSD-3-Clause
 pragma solidity ^0.8.25;
 
 import { ResilientOracleInterface } from "@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol";
 
 import { VToken } from "./VToken.sol";
 import { RewardsDistributor } from "./Rewards/RewardsDistributor.sol";
+import { VTokenInterface } from "./VTokenInterfaces.sol";
 
 enum Action {
     MINT,
@@ -55,11 +56,11 @@
         address borrower
     ) external;
 
     function borrowVerify(address vToken, address borrower, uint borrowAmount) external;
 
     function mintVerify(address vToken, address minter, uint mintAmount, uint mintTokens) external;
 
     function redeemVerify(address vToken, address redeemer, uint redeemAmount, uint redeemTokens) external;
 
     function repayBorrowVerify(
         address vToken,
@@ -90,6 +91,8 @@
 
     function preTransferHook(address vToken, address src, address dst, uint256 transferTokens) external;
 
+    function executeFlashLoan(address receiver, VTokenInterface[] calldata assets, uint256[] calldata amounts) external;
+
     function isComptroller() external view returns (bool);
 
     /*** Liquidity/Liquidation Calculations ***/

contracts/ErrorReporter.sol

@@ -46,4 +46,9 @@ contract TokenErrorReporter {
     error ReduceReservesCashValidation();
 
     error SetInterestRateModelFreshCheck();
+
+    error FlashLoanNotEnabled(address);
+    error ExecuteFlashLoanFailed();
+    error InvalidComptroller(address comptroller);
+    error InsufficientReypaymentBalance(address tokenAddress);
 }

contracts/Flashloan/base/FlashloanReceiverBase.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.25;
+
+import { IFlashLoanReceiver } from "../interfaces/IFlashloanReceiver.sol";
+import { ComptrollerInterface } from "../../ComptrollerInterface.sol";
+
+/// @title FlashLoanReceiverBase
+/// @notice A base contract for implementing flashLoan receiver logic.
+/// @dev This abstract contract provides the necessary structure for inheriting contracts to implement the `IFlashLoanReceiver` interface.
+///      It stores a reference to the Comptroller contract, which manages various aspects of the protocol.
+abstract contract FlashLoanReceiverBase is IFlashLoanReceiver {
+    /// @notice The Comptroller contract that governs the protocol.
+    /// @dev This immutable variable stores the address of the Comptroller contract, which cannot be changed after deployment.
+    ComptrollerInterface public immutable COMPTROLLER;
+
+    /**
+     * @notice Constructor to initialize the base contract with the Comptroller address.
+     * @param comptroller_ The address of the Comptroller contract that oversees the protocol.
+     */
+    constructor(ComptrollerInterface comptroller_) {
+        COMPTROLLER = comptroller_;
+    }
+}

contracts/Flashloan/base/FlashloanSimpleReceiverBase.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.25;
+
+import { IFlashLoanSimpleReceiver } from "../interfaces/IFlashloanSimpleReceiver.sol";
+import { VTokenInterface } from "../../VTokenInterfaces.sol";
+
+/**
+ * @title FlashLoanSimpleReceiverBase
+ * @author Venus
+ * @notice Base contract to develop a flashLoan-receiver contract.
+ * @dev This contract serves as a foundational contract for implementing custom flash loan receiver logic.
+ * Inheritors of this contract need to implement the `executeOperation` function defined in the `IFlashLoanSimpleReceiver` interface.
+ */
+abstract contract FlashLoanSimpleReceiverBase is IFlashLoanSimpleReceiver {
+    /// @notice The VToken contract used to initiate and handle flash loan
+    /// @dev This is an immutable reference to the VTokenInterface, which enables the flash loan functionality.
+    VTokenInterface public immutable VTOKEN;
+
+    /// @notice Initializes the base contract by setting the VToken address
+    /// @param vToken_ The address of the VToken contract that supports flash loan
+    constructor(VTokenInterface vToken_) {
+        VTOKEN = vToken_;
+    }
+}

contracts/Flashloan/interfaces/IFlashloanReceiver.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.25;
+
+import { VTokenInterface } from "../../VTokenInterfaces.sol";
+
+/// @title IFlashLoanReceiver
+/// @notice Interface for flashLoan receiver contract, which execute custom logic with flash-borrowed assets.
+/// @dev This interface defines the method that must be implemented by any contract wishing to interact with the flashLoan system.
+///      Contracts must ensure they have the means to repay both the flashLoan amount and the associated premium (fee).
+interface IFlashLoanReceiver {
+    /**
+     * @notice Executes an operation after receiving the flash-borrowed assets.
+     * @dev Implementation of this function must ensure the borrowed amount plus the premium (fee) is repaid within the same transaction.
+     * @param assets The addresses of the assets that were flash-borrowed.
+     * @param amounts The amounts of each of the flash-borrowed assets.
+     * @param premiums The premiums (fees) associated with each flash-borrowed asset.
+     * @param initiator The address that initiated the flashLoan operation.
+     * @param param Additional parameters encoded as bytes. These can be used to pass custom data to the receiver contract.
+     * @return True if the operation succeeds and the borrowed amount plus the premium is repaid, false otherwise.
+     */
+    function executeOperation(
+        VTokenInterface[] calldata assets,
+        uint256[] calldata amounts,
+        uint256[] calldata premiums,
+        address initiator,
+        bytes calldata param
+    ) external returns (bool);
+}

contracts/Flashloan/interfaces/IFlashloanSimpleReceiver.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.25;
+
+interface IFlashLoanSimpleReceiver {
+    /**
+     * @notice Executes an operation after receiving the flash-borrowed asset
+     * @dev Ensure that the contract can return the debt + premium, e.g., has
+     *      enough funds to repay and has to transfer the debt + premium to the VToken
+     * @param asset The address of the flash-borrowed asset
+     * @param amount The amount of the flash-borrowed asset
+     * @param premium The premium (fee) associated with flash-borrowed asset.
+     * @param initiator The address that initiated the flashLoan operation
+     * @param param The byte-encoded param passed when initiating the flashLoan
+     * @return True if the execution of the operation succeeds, false otherwise
+     */
+    function executeOperation(
+        address asset,
+        uint256 amount,
+        uint256 premium,
+        address initiator,
+        bytes calldata param
+    ) external returns (bool);
+}