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

contracts/Comptroller/ComptrollerInterface.sol

@@ -193,6 +193,7 @@ interface ComptrollerInterface {
 
     function getDynamicLiquidationIncentive(
         address market,
+        address borrower,
         uint256 liquidationThresholdAvg,
         uint256 healthFactor
     ) external view returns (uint256);

contracts/Comptroller/Diamond/facets/FacetBase.sol

@@ -264,6 +264,20 @@ contract FacetBase is IFacetBase, ComptrollerV19Storage, 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
@@ -312,4 +326,43 @@ contract FacetBase is IFacetBase, ComptrollerV19Storage, 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
+        );
+    }
 }

contracts/Comptroller/Diamond/facets/MarketFacet.sol

@@ -467,22 +467,24 @@ contract MarketFacet is IMarketFacet, FacetBase {
      * @dev Calculates incentive based on provided health factor and liquidation threshold average,
      *      without reading borrower's account state from storage
      * @param vToken The address of the vToken to be seized
+     * @param borrower The address of the borrower
      * @param liquidationThresholdAvg The average liquidation threshold for the borrower
      * @param healthFactor The health factor of the borrower
      * @return incentive The dynamic liquidation incentive for the borrower, scaled by 1e18
      */
     function getDynamicLiquidationIncentive(
         address vToken,
+        address borrower,
         uint256 liquidationThresholdAvg,
         uint256 healthFactor
     ) external view returns (uint256 incentive) {
-        Market storage market = getCorePoolMarket(vToken);
+        uint256 effectiveLiquidationIncentive = this.getEffectiveLiquidationIncentive(borrower,vToken);
 
         incentive = liquidationManager.calculateDynamicLiquidationIncentive(
             vToken,
             healthFactor,
             liquidationThresholdAvg,
-            market.maxLiquidationIncentiveMantissa
+            effectiveLiquidationIncentive
         );
     }
 
@@ -498,7 +500,7 @@ contract MarketFacet is IMarketFacet, FacetBase {
         address borrower,
         address vToken
     ) external view returns (uint256 incentive) {
-        Market storage market = getCorePoolMarket(vToken);
+        uint256 effectiveLiquidationIncentive = this.getEffectiveLiquidationIncentive(borrower,vToken);
         (
             uint256 err,
             ComptrollerLensInterface.AccountSnapshot memory snapshot
@@ -517,7 +519,7 @@ contract MarketFacet is IMarketFacet, FacetBase {
             vToken,
             snapshot.healthFactor,
             snapshot.liquidationThresholdAvg,
-            market.maxLiquidationIncentiveMantissa
+            effectiveLiquidationIncentive
         );
     }
 
@@ -575,20 +577,6 @@ contract MarketFacet is IMarketFacet, FacetBase {
         else revert InvalidWeightingStrategy(weightingStrategy);
     }
 
-    /**
-     * @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 full list of vTokens for a given pool ID.
      * @param poolId The ID of the pool whose vTokens are being queried.
@@ -786,41 +774,4 @@ contract MarketFacet is IMarketFacet, FacetBase {
         emit PoolMarketInitialized(poolId, vToken);
     }
 
-    /**
-     * @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
-        );
-    }
 }

contracts/Comptroller/Diamond/facets/PolicyFacet.sol

@@ -305,14 +305,14 @@ contract PolicyFacet is IPolicyFacet, XVSRewardsHelper {
             return uint256(Error.INSUFFICIENT_SHORTFALL);
         }
 
-        Market storage marketCollateral = getCorePoolMarket(vTokenCollateral);
+        uint256 effectiveLiquidationIncentive = this.getEffectiveLiquidationIncentive(borrower, vTokenCollateral);
         uint256 closeFactor = liquidationManager.calculateDynamicCloseFactor(
             vTokenBorrowed,
             borrowBalance,
             snapshot.liquidationThresholdAvg,
             snapshot.totalCollateral,
             snapshot.dynamicLiquidationIncentiveMantissa,
-            marketCollateral.maxLiquidationIncentiveMantissa
+            effectiveLiquidationIncentive
         );
 
         // The liquidator may not repay more than what is allowed by the closeFactor

contracts/Comptroller/Diamond/facets/SetterFacet.sol

@@ -618,57 +618,6 @@ contract SetterFacet is ISetterFacet, FacetBase {
         xvsVToken = xvsVToken_;
     }
 
-    /**
-     * @notice This function is used to set the liquidation manager address which is responsible for managing
-     *         liquidations in the protocol.
-     * @dev Allows the contract admin to set the liquidation manager address used by the Comptroller
-     * @param liquidationManager_ The new liquidation manager address
-     */
-    function __setLiquidationManager(
-        address liquidationManager_
-    ) internal compareAddress(address(liquidationManager), liquidationManager_) {
-        ensureNonzeroAddress(liquidationManager_);
-        emit NewLiquidationManager(liquidationManager, LiquidationManager(liquidationManager_));
-        liquidationManager = LiquidationManager(liquidationManager_);
-    }
-
-    /**
-     * @notice Set the max liquidation incentive for a market
-     * @param poolId The ID of the pool.
-     * @param vToken The market to set the max liquidation incentive for
-     * @param newMaxLiquidationIncentive The new max liquidation incentive, scaled by 1e18
-     * @return uint256 0=success, otherwise reverted
-     */
-    function __setMarketMaxLiquidationIncentive(
-        uint96 poolId,
-        address vToken,
-        uint256 newMaxLiquidationIncentive
-    )
-        internal
-        compareValue(
-            _poolMarkets[getPoolMarketIndex(poolId, vToken)].maxLiquidationIncentiveMantissa,
-            newMaxLiquidationIncentive
-        )
-        returns (uint256)
-    {
-        // Check if pool exists
-        if (poolId > lastPoolId) revert PoolDoesNotExist(poolId);
-
-        Market storage market = _poolMarkets[getPoolMarketIndex(poolId, vToken)];
-        ensureListed(market);
-
-        require(newMaxLiquidationIncentive >= mantissaOne, "incentive < mantissaOne");
-        // Emit event with old incentive, new incentive
-        emit NewMarketLiquidationIncentive(
-            poolId,
-            vToken,
-            market.maxLiquidationIncentiveMantissa,
-            newMaxLiquidationIncentive
-        );
-        // Set liquidation incentive to new incentive
-        market.maxLiquidationIncentiveMantissa = newMaxLiquidationIncentive;
-        return uint256(Error.NO_ERROR);
-    }
 
     /**
      * @notice Adds/Removes an account to the flash loan whitelist
@@ -810,6 +759,59 @@ contract SetterFacet is ISetterFacet, FacetBase {
         m.isBorrowAllowed = borrowAllowed;
     }
 
+
+    /**
+     * @notice This function is used to set the liquidation manager address which is responsible for managing
+     *         liquidations in the protocol.
+     * @dev Allows the contract admin to set the liquidation manager address used by the Comptroller
+     * @param liquidationManager_ The new liquidation manager address
+     */
+    function __setLiquidationManager(
+        address liquidationManager_
+    ) internal compareAddress(address(liquidationManager), liquidationManager_) {
+        ensureNonzeroAddress(liquidationManager_);
+        emit NewLiquidationManager(liquidationManager, LiquidationManager(liquidationManager_));
+        liquidationManager = LiquidationManager(liquidationManager_);
+    }
+
+    /**
+     * @notice Set the max liquidation incentive for a market
+     * @param poolId The ID of the pool.
+     * @param vToken The market to set the max liquidation incentive for
+     * @param newMaxLiquidationIncentive The new max liquidation incentive, scaled by 1e18
+     * @return uint256 0=success, otherwise reverted
+     */
+    function __setMarketMaxLiquidationIncentive(
+        uint96 poolId,
+        address vToken,
+        uint256 newMaxLiquidationIncentive
+    )
+        internal
+        compareValue(
+            _poolMarkets[getPoolMarketIndex(poolId, vToken)].maxLiquidationIncentiveMantissa,
+            newMaxLiquidationIncentive
+        )
+        returns (uint256)
+    {
+        // Check if pool exists
+        if (poolId > lastPoolId) revert PoolDoesNotExist(poolId);
+
+        Market storage market = _poolMarkets[getPoolMarketIndex(poolId, vToken)];
+        ensureListed(market);
+
+        require(newMaxLiquidationIncentive >= mantissaOne, "incentive < mantissaOne");
+        // Emit event with old incentive, new incentive
+        emit NewMarketLiquidationIncentive(
+            poolId,
+            vToken,
+            market.maxLiquidationIncentiveMantissa,
+            newMaxLiquidationIncentive
+        );
+        // Set liquidation incentive to new incentive
+        market.maxLiquidationIncentiveMantissa = newMaxLiquidationIncentive;
+        return uint256(Error.NO_ERROR);
+    }
+
     /**
      * @dev Updates the valid price oracle. Used by _setPriceOracle and setPriceOracle
      * @param newOracle The new price oracle to be set

contracts/Comptroller/Diamond/interfaces/IFacetBase.sol

@@ -35,6 +35,8 @@ interface IFacetBase {
      */
     function getXVSAddress() external view returns (address);
 
+    function getEffectiveLiquidationIncentive(address account, address vToken) external view returns (uint256);
+
     function getPoolMarketIndex(uint96 poolId, address vToken) external pure returns (PoolMarketId);
 
     function corePoolId() external pure returns (uint96);

contracts/Comptroller/Diamond/interfaces/IMarketFacet.sol

@@ -105,6 +105,7 @@ interface IMarketFacet {
 
     function getDynamicLiquidationIncentive(
         address vToken,
+        address borrower,
         uint256 liquidationThresholdAvg,
         uint256 healthFactor
     ) external view returns (uint256);
@@ -115,7 +116,6 @@ interface IMarketFacet {
         WeightFunction weightingStrategy
     ) external view returns (uint256);
 
-    function getEffectiveLiquidationIncentive(address account, address vToken) external view returns (uint256);
 
     function getPoolVTokens(uint96 poolId) external view returns (address[] memory);
 }

contracts/InterfacesV8.sol

@@ -80,6 +80,7 @@ interface IComptroller {
 
     function getDynamicLiquidationIncentive(
         address vToken,
+        address borrower,
         uint256 liquidationThresholdAvg,
         uint256 healthFactor
     ) external view returns (uint256);

contracts/Lens/ComptrollerLens.sol

@@ -321,12 +321,11 @@ contract ComptrollerLens is ComptrollerLensInterface, ComptrollerErrorReporter,
             VToken asset = assets[i];
 
             // Read the balances and exchange rate from the vToken
-            (vars.err, vars.vTokenBalance, vars.borrowBalance, vars.exchangeRateMantissa) = asset.getAccountSnapshot(
+            (errorCode, vars.vTokenBalance, vars.borrowBalance, vars.exchangeRateMantissa) = asset.getAccountSnapshot(
                 account
             );
 
-            if (vars.err != 0) {
-                errorCode = vars.err;
+            if (errorCode != 0) {
                 return (errorCode, snapshot);
             }
 

contracts/Liquidator/Liquidator.sol

@@ -266,11 +266,14 @@ contract Liquidator is Ownable2StepUpgradeable, ReentrancyGuardUpgradeable, Liqu
             address(vTokenCollateral),
             repayAmount
         );
+
         uint256 totalIncentive = comptroller.getDynamicLiquidationIncentive(
             address(vTokenCollateral),
+            borrower,
             snapshot.liquidationThresholdAvg,
             snapshot.healthFactor
         );
+
         snapshot.dynamicLiquidationIncentiveMantissa = totalIncentive;
 
         _checkForceVAILiquidate(vToken, borrower);

contracts/Tokens/VTokens/legacy/ComptrollerInterface.sol

@@ -94,7 +94,6 @@ contract ComptrollerInterface {
     /*** Liquidity/Liquidation Calculations ***/
 
     function liquidateCalculateSeizeTokens(
-        address borrower,
         address vTokenBorrowed,
         address vTokenCollateral,
         uint repayAmount
@@ -103,7 +102,6 @@ contract ComptrollerInterface {
     function setMintedVAIOf(address owner, uint amount) external returns (uint);
 
     function liquidateVAICalculateSeizeTokens(
-        address borrower,
         address vTokenCollateral,
         uint repayAmount
     ) external view returns (uint, uint);