[VEN-2323] Unlist Market

contracts/Comptroller.sol

@@ -47,7 +47,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);
@@ -98,6 +98,9 @@
     /// @notice Emitted when forced liquidation is enabled or disabled for a market
     event IsForcedLiquidationEnabledUpdated(address indexed vToken, bool enable);
 
+    /// @notice Emitted when a market is unlisted
+    event MarketUnlisted(VToken vToken);
+
     /// @notice Thrown when collateral factor exceeds the upper bound
     error InvalidCollateralFactor();
 
@@ -199,6 +202,46 @@
         return results;
     }
 
+    /**
+     * @notice Unlist an market by setting isListed to false
+     * @dev Pauses all actions, sets borrow/supply caps to 0 and sets collateral factor to 0.
+     * @param market The address of the market (token) to unlist
+     * @return uint256 Always NO_ERROR for compatibility with Venus core tooling
+     */
+    function unlistMarket(address market) external returns (uint256) {
+        _checkAccessAllowed("unlistMarket(address)");
+
+        Market storage _market = markets[market];
+
+        if (!_market.isListed) {
+            revert MarketNotListed(market);
+        }
+
+        _setActionPaused(market, Action.BORROW, true);
+        _setActionPaused(market, Action.MINT, true);
+        _setActionPaused(market, Action.REDEEM, true);
+        _setActionPaused(market, Action.REPAY, true);
+        _setActionPaused(market, Action.ENTER_MARKET, true);
+        _setActionPaused(market, Action.LIQUIDATE, true);
+
+        borrowCaps[market] = 0;
+        supplyCaps[market] = 0;
+
+        VToken vToken = VToken(market);
+
+        emit NewSupplyCap(vToken, 0);
+        emit NewBorrowCap(vToken, 0);
+
+        emit NewCollateralFactor(vToken, _market.collateralFactorMantissa, 0);
+        _market.collateralFactorMantissa = 0;
+
+        _market.isListed = false;
+
+        emit MarketUnlisted(vToken);
+
+        return NO_ERROR;
+    }
+
     /**
      * @notice Removes asset from sender's account liquidity calculation; disabling them as collateral
      * @dev Sender must not have an outstanding borrow balance in the asset,
@@ -352,7 +395,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);
         }
@@ -719,7 +762,7 @@
      * @custom:access Not restricted
      */
     function healAccount(address user) external {
-        VToken[] memory userAssets = accountAssets[user];
+        VToken[] memory userAssets = getAssetsIn(user);
         uint256 userAssetsCount = userAssets.length;
 
         address liquidator = msg.sender;
@@ -830,12 +873,12 @@
             );
         }
 
-        VToken[] memory borrowMarkets = accountAssets[borrower];
+        VToken[] memory borrowMarkets = getAssetsIn(borrower);
         uint256 marketsCount = borrowMarkets.length;
 
         for (uint256 i; i < marketsCount; ++i) {
             (, uint256 borrowBalance, ) = _safeGetAccountSnapshot(borrowMarkets[i], borrower);
             require(borrowBalance == 0, "Nonzero borrow balance after liquidation");
         }
     }
 
@@ -847,8 +890,8 @@
      */
     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");
 
         uint256 oldCloseFactorMantissa = closeFactorMantissa;
         closeFactorMantissa = newCloseFactorMantissa;
@@ -923,7 +966,7 @@
      * @custom:access Controlled by AccessControlManager
      */
     function setLiquidationIncentive(uint256 newLiquidationIncentiveMantissa) external {
         require(newLiquidationIncentiveMantissa >= MANTISSA_ONE, "liquidation incentive should be greater than 1e18");
 
         _checkAccessAllowed("setLiquidationIncentive(uint256)");
 
@@ -1214,17 +1257,6 @@
 
     /*** Assets You Are In ***/
 
-    /**
-     * @notice Returns the assets an account has entered
-     * @param account The address of the account to pull assets for
-     * @return A list with the assets the account has entered
-     */
-    function getAssetsIn(address account) external view returns (VToken[] memory) {
-        VToken[] memory assetsIn = accountAssets[account];
-
-        return assetsIn;
-    }
-
     /**
      * @notice Returns whether the given account is entered in a given market
      * @param account The address of the account to check
@@ -1316,7 +1348,7 @@
      * @param account Address of the account to get associated tokens with
      */
     function updatePrices(address account) public {
-        VToken[] memory vTokens = accountAssets[account];
+        VToken[] memory vTokens = getAssetsIn(account);
         uint256 vTokensCount = vTokens.length;
 
         ResilientOracleInterface oracle_ = oracle;
@@ -1336,6 +1368,33 @@
         return _actionPaused[market][action];
     }
 
+    /**
+     * @notice Returns the assets an account has entered
+     * @param account The address of the account to pull assets for
+     * @return A list with the assets the account has entered
+     */
+    function getAssetsIn(address account) public view returns (VToken[] memory) {
+        uint256 len = 0;
+        for (uint256 i = 0; i < accountAssets[account].length; i++) {
+            Market storage market = markets[address(accountAssets[account][i])];
+            if (market.isListed) {
+                len++;
+            }
+        }
+
+        VToken[] memory assetsIn = new VToken[](len);
+        uint256 index = 0;
+        for (uint256 i = 0; i < accountAssets[account].length; i++) {
+            Market storage market = markets[address(accountAssets[account][i])];
+            if (market.isListed) {
+                assetsIn[index] = accountAssets[account][i];
+                index++;
+            }
+        }
+
+        return assetsIn;
+    }
+
     /**
      * @notice Add the market to the borrower's "assets in" for liquidity calculations
      * @param vToken The market to enter
@@ -1465,7 +1524,7 @@
         function(VToken) internal view returns (Exp memory) weight
     ) internal view returns (AccountLiquiditySnapshot memory snapshot) {
         // For each asset the account is in
-        VToken[] memory assets = accountAssets[account];
+        VToken[] memory assets = getAssetsIn(account);
         uint256 assetsCount = assets.length;
 
         for (uint256 i; i < assetsCount; ++i) {

deploy/017-deploy-comptroller.ts

@@ -0,0 +1,24 @@
+import { ethers } from "hardhat";
+import { DeployFunction } from "hardhat-deploy/types";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployments, getNamedAccounts } = hre;
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+  const poolRegistry = await ethers.getContract("PoolRegistry");
+
+  console.log(deployer);
+
+  await deploy("ComptrollerImpl", {
+    contract: "Comptroller",
+    from: deployer,
+    args: [poolRegistry.address],
+    log: true,
+    autoMine: true,
+  });
+};
+
+func.tags = ["ComptrollerUpgrade"];
+
+export default func;

deployments/bsctestnet.json

@@ -110,7 +110,7 @@
       ]
     },
     "ComptrollerImpl": {
-      "address": "0x329Bc34E6A46243d21955A4369cD66bdD52E6C22",
+      "address": "0x3cE617FCeb5e9Ed622F73b483aC7c94053795197",
       "abi": [
         {
           "inputs": [
@@ -485,6 +485,19 @@
           "name": "MarketSupported",
           "type": "event"
         },
+        {
+          "anonymous": false,
+          "inputs": [
+            {
+              "indexed": false,
+              "internalType": "contract VToken",
+              "name": "vToken",
+              "type": "address"
+            }
+          ],
+          "name": "MarketUnlisted",
+          "type": "event"
+        },
         {
           "anonymous": false,
           "inputs": [
@@ -2054,6 +2067,25 @@
           "stateMutability": "nonpayable",
           "type": "function"
         },
+        {
+          "inputs": [
+            {
+              "internalType": "address",
+              "name": "market",
+              "type": "address"
+            }
+          ],
+          "name": "unlistMarket",
+          "outputs": [
+            {
+              "internalType": "uint256",
+              "name": "",
+              "type": "uint256"
+            }
+          ],
+          "stateMutability": "nonpayable",
+          "type": "function"
+        },
         {
           "inputs": [
             {