[VEN-3321]: Liquidation Threshold and repay Improvements in Core Pool on BNB

contracts/Comptroller/ComptrollerInterface.sol

@@ -6,6 +6,8 @@ import { ResilientOracleInterface } from "@venusprotocol/oracle/contracts/interf
 
 import { VToken } from "../Tokens/VTokens/VToken.sol";
 import { VAIControllerInterface } from "../Tokens/VAI/VAIControllerInterface.sol";
+import { LiquidationManager } from "../LiquidationManager.sol";
+import { ComptrollerLensInterface } from "./ComptrollerLensInterface.sol";
 import { WeightFunction } from "./Diamond/interfaces/IFacetBase.sol";
 
 enum Action {
@@ -75,6 +77,15 @@ interface ComptrollerInterface {
         uint repayAmount
     ) external returns (uint);
 
+    function liquidateBorrowAllowed(
+        address vTokenBorrowed,
+        address vTokenCollateral,
+        address liquidator,
+        address borrower,
+        uint repayAmount,
+        ComptrollerLensInterface.AccountSnapshot memory snapshot
+    ) external returns (uint);
+
     function liquidateBorrowVerify(
         address vTokenBorrowed,
         address vTokenCollateral,
@@ -107,23 +118,25 @@ interface ComptrollerInterface {
     /*** Liquidity/Liquidation Calculations ***/
 
     function liquidateCalculateSeizeTokens(
+        address borrower,
         address vTokenBorrowed,
         address vTokenCollateral,
         uint repayAmount
     ) external view returns (uint, uint);
 
     function liquidateCalculateSeizeTokens(
-        address borrower,
         address vTokenBorrowed,
         address vTokenCollateral,
-        uint repayAmount
+        uint repayAmount,
+        uint liquidationIncentiveMantissa
     ) external view returns (uint, uint);
 
     function setMintedVAIOf(address owner, uint amount) external returns (uint);
 
     function liquidateVAICalculateSeizeTokens(
         address vTokenCollateral,
-        uint repayAmount
+        uint repayAmount,
+        uint liquidationIncentiveMantissa
     ) external view returns (uint, uint);
 
     function getXVSAddress() external view returns (address);
@@ -132,6 +145,8 @@ interface ComptrollerInterface {
 
     function oracle() external view returns (ResilientOracleInterface);
 
+    function liquidationManager() external view returns (LiquidationManager);
+
     function getAccountLiquidity(address) external view returns (uint, uint, uint);
 
     function getAssetsIn(address) external view returns (VToken[] memory);
@@ -168,8 +183,33 @@ interface ComptrollerInterface {
 
     function vaiMintRate() external view returns (uint);
 
+    function getDynamicLiquidationIncentive(address borrower, address market) external view returns (uint256);
+
+    function getDynamicLiquidationIncentive(
+        address market,
+        address borrower,
+        uint256 liquidationThresholdAvg,
+        uint256 healthFactor
+    ) external view returns (uint256);
+
+    function getCollateralFactor(address vToken) external view returns (uint256);
+
+    function getLiquidationThreshold(address vToken) external view returns (uint256);
+
+    function getHypotheticalHealthSnapshot(
+        address account,
+        VToken vTokenModify,
+        uint redeemTokens,
+        uint borrowAmount
+    ) external view returns (uint256, ComptrollerLensInterface.AccountSnapshot memory);
+
     function authorizedFlashLoan(address account) external view returns (bool);
 
+    function delegateAuthorizationFlashloan(
+        address account,
+        address market,
+        address delegate
+    ) external view returns (bool);
     function userPoolId(address account) external view returns (uint96);
 
     function getLiquidationIncentive(address vToken) external view returns (uint256);

contracts/Comptroller/ComptrollerLensInterface.sol

@@ -6,33 +6,64 @@ import { VToken } from "../Tokens/VTokens/VToken.sol";
 import { WeightFunction } from "./Diamond/interfaces/IFacetBase.sol";
 
 interface ComptrollerLensInterface {
+    struct AccountSnapshot {
+        // Total collateral value supplied by the account (USD, scaled by 1e18)
+        uint256 totalCollateral;
+        // Collateral value weighted by each asset's liquidation threshold or collateral factor (USD, scaled by 1e18)
+        uint256 weightedCollateral;
+        // Total borrowed value by the account (USD, scaled by 1e18)
+        uint256 totalBorrows;
+        // Amount of excess collateral available for borrowing (USD, scaled by 1e18)
+        uint256 liquidity;
+        // Amount by which the account is undercollateralized (USD, scaled by 1e18)
+        uint256 shortfall;
+        // Average liquidation threshold across all supplied assets (scaled by 1e18)
+        uint256 liquidationThresholdAvg;
+        // Health factor of the account, used to assess liquidation risk (scaled by 1e18)
+        uint256 healthFactor;
+        // Dynamic liquidation incentive factor applied during liquidations (scaled by 1e18)
+        uint256 dynamicLiquidationIncentiveMantissa;
+    }
+
+    // Just need to make borrower first then comptroller
     function liquidateCalculateSeizeTokens(
+        address borrower,
         address comptroller,
         address vTokenBorrowed,
         address vTokenCollateral,
-        uint actualRepayAmount
-    ) external view returns (uint, uint);
+        uint256 actualRepayAmount
+    ) external view returns (uint256, uint256);
 
     function liquidateCalculateSeizeTokens(
-        address borrower,
         address comptroller,
         address vTokenBorrowed,
         address vTokenCollateral,
-        uint actualRepayAmount
-    ) external view returns (uint, uint);
+        uint256 actualRepayAmount,
+        uint256 liquidationIncentiveMantissa
+    ) external view returns (uint256, uint256);
 
     function liquidateVAICalculateSeizeTokens(
         address comptroller,
         address vTokenCollateral,
-        uint actualRepayAmount
-    ) external view returns (uint, uint);
+        uint256 actualRepayAmount,
+        uint256 liquidationIncentiveMantissa
+    ) external view returns (uint256, uint256);
 
     function getHypotheticalAccountLiquidity(
         address comptroller,
         address account,
         VToken vTokenModify,
-        uint redeemTokens,
-        uint borrowAmount,
+        uint256 redeemTokens,
+        uint256 borrowAmount,
+        WeightFunction weightingStrategy
+    ) external view returns (uint256, uint256, uint256);
+
+    function getAccountHealthSnapshot(
+        address comptroller,
+        address account,
+        VToken vTokenModify,
+        uint256 redeemTokens,
+        uint256 borrowAmount,
         WeightFunction weightingStrategy
-    ) external view returns (uint, uint, uint);
+    ) external view returns (uint256, AccountSnapshot memory);
 }

contracts/Comptroller/ComptrollerStorage.sol

@@ -9,6 +9,7 @@ import { VToken } from "../Tokens/VTokens/VToken.sol";
 import { VAIControllerInterface } from "../Tokens/VAI/VAIControllerInterface.sol";
 import { ComptrollerLensInterface } from "./ComptrollerLensInterface.sol";
 import { IPrime } from "../Tokens/Prime/IPrime.sol";
+import { LiquidationManager } from "../LiquidationManager.sol";
 
 contract UnitrollerAdminStorage {
     /**
@@ -39,9 +40,9 @@ contract ComptrollerV1Storage is UnitrollerAdminStorage {
     ResilientOracleInterface public oracle;
 
     /**
-     * @notice Multiplier used to calculate the maximum repayAmount when liquidating a borrow
+     * @notice Multiplier used to calculate the maximum repayAmount when liquidating a borrow (deprecated)
      */
-    uint256 public closeFactorMantissa;
+    uint256 private __oldCloseFactorMantissaSlot;
 
     /**
      * @notice Multiplier representing the discount on collateral that a liquidator receives (deprecated)
@@ -78,7 +79,7 @@ contract ComptrollerV1Storage is UnitrollerAdminStorage {
          */
         uint256 liquidationThresholdMantissa;
         /// @notice discount on collateral that a liquidator receives when liquidating a borrow in this market
-        uint256 liquidationIncentiveMantissa;
+        uint256 maxLiquidationIncentiveMantissa;
         /// @notice The pool ID this market is associated with, Used to support pools/emodes
         uint96 poolId;
         /// @notice Flag  to restrict borrowing in certain pools/emodes.
@@ -328,3 +329,8 @@ contract ComptrollerV18Storage is ComptrollerV17Storage {
     /// @notice Whether flash loans are paused system-wide
     bool public flashLoanPaused;
 }
+
+contract ComptrollerV19Storage is ComptrollerV18Storage {
+    /// @notice The LiquidationManager contract address
+    LiquidationManager public liquidationManager;
+}

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 { ComptrollerV18Storage } from "../ComptrollerStorage.sol";
+import { ComptrollerV19Storage } from "../ComptrollerStorage.sol";
 
 /**
  * @title Diamond
  * @author Venus
  * @notice This contract contains functions related to facets
  */
-contract Diamond is IDiamondCut, ComptrollerV18Storage {
+contract Diamond is IDiamondCut, ComptrollerV19Storage {
     /// @notice Emitted when functions are added, replaced or removed to facets
     event DiamondCut(IDiamondCut.FacetCut[] _diamondCut);
 
@@ -72,7 +72,7 @@ contract Diamond is IDiamondCut, ComptrollerV18Storage {
      */
     function facetAddress(
         bytes4 functionSelector
-    ) external view returns (ComptrollerV18Storage.FacetAddressAndPosition memory) {
+    ) external view returns (ComptrollerV19Storage.FacetAddressAndPosition memory) {
         return _selectorToFacetAndPosition[functionSelector];
     }
 

contracts/Comptroller/Diamond/facets/FacetBase.sol

@@ -10,7 +10,8 @@ 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 { ComptrollerV18Storage } from "../../../Comptroller/ComptrollerStorage.sol";
+import { ComptrollerLensInterface } from "../../../Comptroller/ComptrollerLensInterface.sol";
+import { ComptrollerV19Storage } from "../../../Comptroller/ComptrollerStorage.sol";
 import { PoolMarketId } from "../../../Comptroller/Types/PoolMarketId.sol";
 import { IFacetBase, WeightFunction } from "../interfaces/IFacetBase.sol";
 
@@ -19,17 +20,14 @@ import { IFacetBase, WeightFunction } from "../interfaces/IFacetBase.sol";
  * @author Venus
  * @notice This facet contract contains functions related to access and checks
  */
-contract FacetBase is IFacetBase, ComptrollerV18Storage, ExponentialNoError, ComptrollerErrorReporter {
+contract FacetBase is IFacetBase, ComptrollerV19Storage, ExponentialNoError, ComptrollerErrorReporter {
     using SafeERC20 for IERC20;
 
     /// @notice The initial Venus index for a market
     uint224 public constant venusInitialIndex = 1e36;
+
     // poolId for core Pool
     uint96 public constant corePoolId = 0;
-    // closeFactorMantissa must be strictly greater than this value
-    uint256 internal constant closeFactorMinMantissa = 0.05e18; // 0.05
-    // closeFactorMantissa must not exceed this value
-    uint256 internal constant closeFactorMaxMantissa = 0.9e18; // 0.9
 
     /// @notice Emitted when an account enters a market
     event MarketEntered(VToken indexed vToken, address indexed account);
@@ -134,9 +132,9 @@ contract FacetBase is IFacetBase, ComptrollerV18Storage, ExponentialNoError, Com
     }
 
     /**
-     * @notice Determine what the account liquidity would be if the given amounts were redeemed/borrowed
-     * @param vTokenModify The market to hypothetically redeem/borrow in
+     * @notice Determine what the liquidity would be if the given amounts were redeemed/borrowed on the basis of collateral factor or liquidation threshold
      * @param account The account to determine liquidity for
+     * @param vTokenModify The market to hypothetically redeem/borrow in
      * @param redeemTokens The number of tokens to hypothetically redeem
      * @param borrowAmount The amount of underlying to hypothetically borrow
      * @param weightingStrategy The weighting strategy to use:
@@ -166,6 +164,37 @@ contract FacetBase is IFacetBase, ComptrollerV18Storage, ExponentialNoError, Com
         return (Error(err), liquidity, shortfall);
     }
 
+    /**
+     * @notice Internal function to get a snapshot of the health of an account
+     * @param account The account to get the health snapshot for
+     * @param vTokenModify The market to hypothetically redeem/borrow in
+     * @param redeemTokens The number of tokens to hypothetically redeem
+     * @param borrowAmount The amount of underlying to hypothetically borrow
+     * @param weightingStrategy The weighting strategy to use:
+     *                          - `WeightFunction.USE_COLLATERAL_FACTOR` to use collateral factor
+     *                          - `WeightFunction.USE_LIQUIDATION_THRESHOLD` to use liquidation threshold
+     * @return err Error code
+     * @return snapshot Snapshot of the account's health and collateral status
+     * @dev Note that we calculate the exchangeRateStored for each collateral vToken using stored data,
+     *  without calculating accumulated interest.
+     */
+    function _getHypotheticalHealthSnapshotInternal(
+        address account,
+        VToken vTokenModify,
+        uint256 redeemTokens,
+        uint256 borrowAmount,
+        WeightFunction weightingStrategy
+    ) internal view returns (uint256 err, ComptrollerLensInterface.AccountSnapshot memory snapshot) {
+        (err, snapshot) = comptrollerLens.getAccountHealthSnapshot(
+            address(this),
+            account,
+            vTokenModify,
+            redeemTokens,
+            borrowAmount,
+            weightingStrategy
+        );
+    }
+
     /**
      * @notice Add the market to the borrower's "assets in" for liquidity calculations
      * @param vToken The market to enter
@@ -235,6 +264,20 @@ contract FacetBase is IFacetBase, ComptrollerV18Storage, ExponentialNoError, Com
         return xvs;
     }
 
+    /**
+     * @notice Get the Effective Liquidation Incentive for a given account and market
+     * @dev The incentive is determined by the pool entered by the account and the specified vToken via
+     *      `getLiquidationParams()`. If the pool is inactive, or if the vToken is not configured in the
+     *      account's pool and `allowCorePoolFallback` is enabled, the core pool (poolId = 0) values are used
+     * @param account The account whose pool is used to determine the market's risk parameters
+     * @param vToken The address of the vToken market
+     * @return The liquidation Incentive for the vToken, scaled by 1e18
+     */
+    function getEffectiveLiquidationIncentive(address account, address vToken) external view returns (uint256) {
+        (, , uint256 li) = getLiquidationParams(userPoolId[account], vToken);
+        return li;
+    }
+
     /**
      * @notice Returns the unique market index for the given poolId and vToken pair
      * @dev Computes a unique key for a (poolId, market) pair used in the `_poolMarkets` mapping
@@ -283,4 +326,42 @@ contract FacetBase is IFacetBase, ComptrollerV18Storage, ExponentialNoError, Com
 
         return (uint256(err), liquidity, shortfall);
     }
+
+    /**
+     * @notice Returns only the core risk parameters (CF, LI, LT) for a vToken in a specific pool.
+     * @dev If the pool is inactive, or if the vToken is not configured in the given pool and
+     *      `allowCorePoolFallback` is enabled, falls back to the core pool (poolId = 0) values.
+     * @return collateralFactorMantissa The max borrowable percentage of collateral, in mantissa.
+     * @return liquidationThresholdMantissa The threshold at which liquidation is triggered, in mantissa.
+     * @return maxLiquidationIncentiveMantissa The max liquidation incentive allowed for this market, in mantissa.
+     */
+    function getLiquidationParams(
+        uint96 poolId,
+        address vToken
+    )
+        internal
+        view
+        returns (
+            uint256 collateralFactorMantissa,
+            uint256 liquidationThresholdMantissa,
+            uint256 maxLiquidationIncentiveMantissa
+        )
+    {
+        PoolData storage pool = pools[poolId];
+        Market storage market;
+
+        if (poolId == corePoolId || !pool.isActive) {
+            market = getCorePoolMarket(vToken);
+        } else {
+            PoolMarketId poolKey = getPoolMarketIndex(poolId, vToken);
+            Market storage poolMarket = _poolMarkets[poolKey];
+            market = (!poolMarket.isListed && pool.allowCorePoolFallback) ? getCorePoolMarket(vToken) : poolMarket;
+        }
+
+        return (
+            market.collateralFactorMantissa,
+            market.liquidationThresholdMantissa,
+            market.maxLiquidationIncentiveMantissa
+        );
+    }
 }