[VEN-2895]: Flash loan implementation

contracts/Comptroller/ComptrollerInterface.sol

@@ -44,6 +44,14 @@ interface ComptrollerInterface {
 
     function borrowVerify(address vToken, address borrower, uint borrowAmount) external;
 
+    function executeFlashLoan(
+        address payable initiator,
+        address payable receiver,
+        VToken[] calldata vTokens,
+        uint256[] calldata amounts,
+        bytes calldata param
+    ) external;
+
     function repayBorrowAllowed(
         address vToken,
         address payer,
@@ -160,6 +168,8 @@ interface ComptrollerInterface {
 
     function vaiMintRate() external view returns (uint);
 
+    function authorizedFlashLoan(address account) external view returns (bool);
+
     function userPoolId(address account) external view returns (uint96);
 
     function getLiquidationIncentive(address vToken) external view returns (uint256);

contracts/Comptroller/ComptrollerStorage.sol

@@ -320,3 +320,16 @@ contract ComptrollerV17Storage is ComptrollerV16Storage {
      */
     uint96 public lastPoolId;
 }
+
+contract ComptrollerV18Storage is ComptrollerV17Storage {
+    struct FlashLoanData {
+        uint256[] totalFees;
+        uint256[] protocolFees;
+        uint256[] balanceAfterTransfer;
+        uint256[] actualRepayments;
+        uint256[] remainingDebts;
+    }
+
+    /// @notice Mapping of accounts authorized to execute flash loans
+    mapping(address => bool) public authorizedFlashLoan;
+}

contracts/Comptroller/Diamond/Diamond.sol

@@ -4,14 +4,14 @@ pragma solidity 0.8.25;
 
 import { IDiamondCut } from "./interfaces/IDiamondCut.sol";
 import { Unitroller } from "../Unitroller.sol";
-import { ComptrollerV17Storage } from "../ComptrollerStorage.sol";
+import { ComptrollerV18Storage } from "../ComptrollerStorage.sol";
 
 /**
  * @title Diamond
  * @author Venus
  * @notice This contract contains functions related to facets
  */
-contract Diamond is IDiamondCut, ComptrollerV17Storage {
+contract Diamond is IDiamondCut, ComptrollerV18Storage {
     /// @notice Emitted when functions are added, replaced or removed to facets
     event DiamondCut(IDiamondCut.FacetCut[] _diamondCut);
 
@@ -72,7 +72,7 @@ contract Diamond is IDiamondCut, ComptrollerV17Storage {
      */
     function facetAddress(
         bytes4 functionSelector
-    ) external view returns (ComptrollerV17Storage.FacetAddressAndPosition memory) {
+    ) external view returns (ComptrollerV18Storage.FacetAddressAndPosition memory) {
         return _selectorToFacetAndPosition[functionSelector];
     }
 

contracts/Comptroller/Diamond/facets/FacetBase.sol

@@ -10,7 +10,7 @@ import { VToken } from "../../../Tokens/VTokens/VToken.sol";
 import { ComptrollerErrorReporter } from "../../../Utils/ErrorReporter.sol";
 import { ExponentialNoError } from "../../../Utils/ExponentialNoError.sol";
 import { IVAIVault, Action } from "../../../Comptroller/ComptrollerInterface.sol";
-import { ComptrollerV17Storage } from "../../../Comptroller/ComptrollerStorage.sol";
+import { ComptrollerV18Storage } from "../../../Comptroller/ComptrollerStorage.sol";
 import { PoolMarketId } from "../../../Comptroller/Types/PoolMarketId.sol";
 import { IFacetBase, WeightFunction } from "../interfaces/IFacetBase.sol";
 
@@ -19,7 +19,7 @@ import { IFacetBase, WeightFunction } from "../interfaces/IFacetBase.sol";
  * @author Venus
  * @notice This facet contract contains functions related to access and checks
  */
-contract FacetBase is IFacetBase, ComptrollerV17Storage, ExponentialNoError, ComptrollerErrorReporter {
+contract FacetBase is IFacetBase, ComptrollerV18Storage, ExponentialNoError, ComptrollerErrorReporter {
     using SafeERC20 for IERC20;
 
     /// @notice The initial Venus index for a market

contracts/Comptroller/Diamond/facets/PolicyFacet.sol

@@ -7,9 +7,12 @@ import { Action } from "../../ComptrollerInterface.sol";
 import { IPolicyFacet } from "../interfaces/IPolicyFacet.sol";
 
 import { XVSRewardsHelper } from "./XVSRewardsHelper.sol";
+import { IFlashLoanReceiver } from "../../../FlashLoan/interfaces/IFlashLoanReceiver.sol";
 import { PoolMarketId } from "../../../Comptroller/Types/PoolMarketId.sol";
 import { WeightFunction } from "../interfaces/IFacetBase.sol";
 
+import { IProtocolShareReserve } from "../../../external/IProtocolShareReserve.sol";
+
 /**
  * @title PolicyFacet
  * @author Venus
@@ -23,6 +26,9 @@ contract PolicyFacet is IPolicyFacet, XVSRewardsHelper {
     /// @notice Emitted when a new supply-side XVS speed is calculated for a market
     event VenusSupplySpeedUpdated(VToken indexed vToken, uint256 newSpeed);
 
+    // @notice Emitted When the flash loan is successfully executed
+    event FlashLoanExecuted(address receiver, VToken[] assets, uint256[] amounts);
+
     /**
      * @notice Checks if the account should be allowed to mint tokens in the given market
      * @param vToken The market to verify the mint against
@@ -42,6 +48,7 @@ contract PolicyFacet is IPolicyFacet, XVSRewardsHelper {
         uint256 vTokenSupply = VToken(vToken).totalSupply();
         Exp memory exchangeRate = Exp({ mantissa: VToken(vToken).exchangeRateStored() });
         uint256 nextTotalSupply = mul_ScalarTruncateAddUInt(exchangeRate, vTokenSupply, mintAmount);
+
         require(nextTotalSupply <= supplyCap, "market supply cap reached");
 
         // Keep the flywheel moving
@@ -147,6 +154,7 @@ contract PolicyFacet is IPolicyFacet, XVSRewardsHelper {
         if (err != Error.NO_ERROR) {
             return uint256(err);
         }
+
         if (shortfall != 0) {
             return uint256(Error.INSUFFICIENT_LIQUIDITY);
         }
@@ -370,6 +378,202 @@ contract PolicyFacet is IPolicyFacet, XVSRewardsHelper {
         }
     }
 
+    /**
+     * @notice Executes a flashLoan operation with the requested assets.
+     * @dev Transfer the specified assets to the receiver contract and handles repayment.
+     * @param initiator The address of the EOA who initiated the flash loan.
+     * @param receiver The address of the contract that will receive the flashLoan amount and execute the operation.
+     * @param vTokens The addresses of the vToken assets to be loaned.
+     * @param underlyingAmounts The amounts of each underlying assets to be loaned.
+     * @param param The bytes passed in the executeOperation call.
+     * @custom:error FlashLoanNotEnabled is thrown if the flash loan is not enabled for the asset.
+     * @custom:error InvalidAmount is thrown if the requested amount is zero.
+     * @custom:error NoAssetsRequested is thrown if no assets are requested for the flash loan.
+     * @custom:error InvalidFlashLoanParams is thrown if the flash loan params are invalid.
+     * @custom:error SenderNotAuthorizedForFlashLoan is thrown if the sender is not authorized to use flashloan.
+     * @custom:event Emits FlashLoanExecuted on success
+     */
+    function executeFlashLoan(
+        address payable initiator,
+        address payable receiver,
+        VToken[] memory vTokens,
+        uint256[] memory underlyingAmounts,
+        bytes memory param
+    ) external {
+        for (uint256 i; i < vTokens.length; i++) {
+            if (!(vTokens[i]).isFlashLoanEnabled()) revert FlashLoanNotEnabled();
+            if (underlyingAmounts[i] == 0) revert InvalidAmount();
+        }
+        // vTokens array must not be empty
+        if (vTokens.length == 0) {
+            revert NoAssetsRequested();
+        }
+        // All arrays must have the same length and not be zero
+        if (vTokens.length != underlyingAmounts.length) {
+            revert InvalidFlashLoanParams();
+        }
+
+        ensureNonzeroAddress(receiver);
+
+        if (!authorizedFlashLoan[initiator]) {
+            revert SenderNotAuthorizedForFlashLoan(initiator);
+        }
+
+        // Execute flash loan phases
+        _executeFlashLoanPhases(initiator, receiver, vTokens, underlyingAmounts, param);
+
+        emit FlashLoanExecuted(receiver, vTokens, underlyingAmounts);
+    }
+
+    /**
+     * @notice Executes all flash loan phases
+     */
+    function _executeFlashLoanPhases(
+        address payable initiator,
+        address payable receiver,
+        VToken[] memory vTokens,
+        uint256[] memory underlyingAmounts,
+        bytes memory param
+    ) internal returns (FlashLoanData memory flashLoanData) {
+        // Initialize arrays
+        flashLoanData.totalFees = new uint256[](vTokens.length);
+        flashLoanData.protocolFees = new uint256[](vTokens.length);
+        flashLoanData.balanceAfterTransfer = new uint256[](vTokens.length);
+        flashLoanData.actualRepayments = new uint256[](vTokens.length);
+        flashLoanData.remainingDebts = new uint256[](vTokens.length);
+
+        // Phase 1: Calculate fees and transfer assets
+        _executePhase1(receiver, vTokens, underlyingAmounts, flashLoanData);
+        // Phase 2: Execute operations on receiver contract
+        uint256[] memory tokensApproved = _executePhase2(
+            initiator,
+            receiver,
+            vTokens,
+            underlyingAmounts,
+            flashLoanData.totalFees,
+            param
+        );
+        // Phase 3: Handles repayment
+        _executePhase3(initiator, receiver, vTokens, tokensApproved, flashLoanData);
+
+        return flashLoanData;
+    }
+
+    /**
+     * @notice Phase 1: Calculate fees and transfer assets to receiver
+     */
+    function _executePhase1(
+        address payable receiver,
+        VToken[] memory vTokens,
+        uint256[] memory underlyingAmounts,
+        FlashLoanData memory flashLoanData
+    ) internal {
+        for (uint256 j = 0; j < vTokens.length; j++) {
+            (flashLoanData.totalFees[j], flashLoanData.protocolFees[j]) = vTokens[j].calculateFlashLoanFee(
+                underlyingAmounts[j]
+            );
+
+            // Transfer the asset to receiver
+            flashLoanData.balanceAfterTransfer[j] = vTokens[j].transferOutUnderlying(receiver, underlyingAmounts[j]);
+        }
+    }
+
+    /**
+     * @notice Phase 2: Execute operations on receiver contract
+     */
+    function _executePhase2(
+        address payable initiator,
+        address payable receiver,
+        VToken[] memory vTokens,
+        uint256[] memory underlyingAmounts,
+        uint256[] memory totalFees,
+        bytes memory param
+    ) internal returns (uint256[] memory) {
+        (bool success, uint256[] memory tokensApproved) = IFlashLoanReceiver(receiver).executeOperation(
+            vTokens,
+            underlyingAmounts,
+            totalFees,
+            initiator,
+            param
+        );
+
+        if (!success) {
+            revert ExecuteFlashLoanFailed();
+        }
+        return tokensApproved;
+    }
+
+    /**
+     * @notice Phase 3: Handles repayment based on full or partial repayment
+     * @dev If full repayment is made, transfer protocol fee to protocol share reserve and update state.
+     *      If partial repayment is made, create an ongoing debt position for the unpaid balance.
+     */
+    function _executePhase3(
+        address payable initiator,
+        address payable receiver,
+        VToken[] memory vTokens,
+        uint256[] memory underlyingAmounts,
+        FlashLoanData memory flashLoanData
+    ) internal {
+        for (uint256 k = 0; k < vTokens.length; k++) {
+            _handleFlashLoan(
+                vTokens[k],
+                initiator,
+                receiver,
+                underlyingAmounts[k],
+                flashLoanData.totalFees[k],
+                flashLoanData.protocolFees[k]
+            );
+        }
+    }
+
+    /**
+     * @notice Handles the repayment and fee logic for a flash loan.
+     * @dev Transfers the repaid amount from the receiver, checks if the full amount plus fee is repaid,
+     *      and either settles the protocol fee or creates an ongoing debt position for any unpaid balance.
+     *      Updates the protocol share reserve state if the protocol fee is transferred.
+     * @param vToken The vToken contract for the asset being flash loaned.
+     * @param initiator The address of the EOA who initiated the flash loan.
+     * @param receiver The address that received the flash loan and is repaying.
+     * @param amountRepayed The amount repaid by the receiver (principal + fee).
+     * @param totalFee The total fee charged for the flash loan.
+     * @param protocolFee The portion of the total fee allocated to the protocol.
+     */
+    function _handleFlashLoan(
+        VToken vToken,
+        address payable initiator,
+        address payable receiver,
+        uint256 amountRepayed,
+        uint256 totalFee,
+        uint256 protocolFee
+    ) internal {
+        uint256 borrowedFlashLoanAmount = vToken.flashLoanAmount();
+        // Must repay full amount + fee
+        vToken.transferInUnderlyingAndVerify(receiver, amountRepayed);
+
+        if (borrowedFlashLoanAmount + totalFee > amountRepayed) {
+            // If there is any unpaid balance, it becomes an ongoing debt
+            uint256 leftUnpaidBalance = (borrowedFlashLoanAmount + totalFee) - amountRepayed;
+            uint256 accrueResult = vToken.accrueInterest();
+            require(accrueResult == 0, "Failed to accrue interest");
+
+            uint256 debtError = vToken.borrowDebtPosition(initiator, leftUnpaidBalance);
+            if (debtError != 0) {
+                revert FailedToCreateDebtPosition();
+            }
+        } else {
+            // Transfer protocol fee to protocol share reserve
+            vToken.transferOutUnderlying(vToken.protocolShareReserve(), protocolFee);
+
+            // Update protocol share reserve state
+            IProtocolShareReserve(vToken.protocolShareReserve()).updateAssetsState(
+                address(vToken.comptroller()),
+                address(vToken.underlying()),
+                IProtocolShareReserve.IncomeType.FLASHLOAN
+            );
+        }
+    }
+
     /**
      * @notice Checks if the account should be allowed to transfer tokens in the given market
      * @param vToken The market to verify the transfer against

contracts/Comptroller/Diamond/facets/SetterFacet.sol

@@ -102,6 +102,9 @@ contract SetterFacet is ISetterFacet, FacetBase {
     /// @notice Emitted when XVS vToken address is changed
     event NewXVSVToken(address indexed oldXVSVToken, address indexed newXVSVToken);
 
+    /// @notice Emitted when an account's flash loan whitelist status is updated
+    event IsAccountFlashLoanWhitelisted(address indexed account, bool indexed isWhitelisted);
+
     /// @notice Emitted when liquidation threshold for a market in a pool is changed by admin
     event NewLiquidationThreshold(
         uint96 indexed poolId,
@@ -618,6 +621,19 @@ contract SetterFacet is ISetterFacet, FacetBase {
         xvsVToken = xvsVToken_;
     }
 
+    /**
+     * @notice Adds/Removes an account to the flash loan whitelist
+     * @param account The account to authorize for flash loans
+     * @param _isWhiteListed True to whitelist the account for flash loans, false to remove from whitelist
+     */
+    function setWhiteListFlashLoanAccount(address account, bool _isWhiteListed) external {
+        ensureAllowed("setWhiteListFlashLoanAccount(address,bool)");
+        ensureNonzeroAddress(account);
+
+        authorizedFlashLoan[account] = _isWhiteListed;
+        emit IsAccountFlashLoanWhitelisted(account, _isWhiteListed);
+    }
+
     /**
      * @notice Updates the label for a specific pool (excluding the Core Pool)
      * @param poolId ID of the pool to update

contracts/Comptroller/Diamond/interfaces/IPolicyFacet.sol

@@ -89,6 +89,14 @@ interface IPolicyFacet {
         uint256[] calldata borrowSpeeds
     ) external;
 
+    function executeFlashLoan(
+        address payable initiator,
+        address payable receiver,
+        VToken[] calldata vTokens,
+        uint256[] calldata amounts,
+        bytes calldata param
+    ) external;
+
     function getBorrowingPower(
         address account
     ) external view returns (uint256 error, uint256 liquidity, uint256 shortfall);

contracts/Comptroller/Diamond/interfaces/ISetterFacet.sol

@@ -94,6 +94,8 @@ interface ISetterFacet {
 
     function _setXVSVToken(address xvsVToken_) external;
 
+    function setWhiteListFlashLoanAccount(address account, bool _isWhiteListed) external;
+
     function setIsBorrowAllowed(uint96 poolId, address vToken, bool borrowAllowed) external;
 
     function setPoolActive(uint96 poolId, bool active) external;