@venusprotocol/isolated-pools 1.0.0-dev.1 → 1.0.0-dev.11

package/contracts/BaseJumpRateModelV2.sol

@@ -8,8 +8,9 @@ import { BLOCKS_PER_YEAR, EXP_SCALE, MANTISSA_ONE } from "./lib/constants.sol";
 
 /**
  * @title Logic for Compound's JumpRateModel Contract V2.
- * @author Compound (modified by Dharma Labs, refactored by Arr00)
- * @notice Version 2 modifies Version 1 by enabling updateable parameters.
+ * @author Compound (modified by Dharma Labs, Arr00 and Venus)
+ * @notice An interest rate model with a steep increase after a certain utilization threshold called **kink** is reached.
+ * The parameters of this interest rate model can be adjusted by the owner. Version 2 modifies Version 1 by enabling updateable parameters.
  */
 abstract contract BaseJumpRateModelV2 is InterestRateModel {
     /**
@@ -134,7 +135,7 @@ abstract contract BaseJumpRateModelV2 is InterestRateModel {
         uint256 reserves,
         uint256 badDebt
     ) public pure returns (uint256) {
-        // Utilization rate is 0 when there are no borrows
+        // Utilization rate is 0 when there are no borrows and badDebt
         if ((borrows + badDebt) == 0) {
             return 0;
         }

package/contracts/Comptroller.sol

@@ -14,7 +14,27 @@ import { MaxLoopsLimitHelper } from "./MaxLoopsLimitHelper.sol";
 import { ensureNonzeroAddress } from "./lib/validators.sol";
 
 /**
- * @title Comptroller Contract
+ * @title Comptroller
+ * @author Venus
+ * @notice The Comptroller is designed to provide checks for all minting, redeeming, transferring, borrowing, lending, repaying, liquidating,
+ * and seizing done by the `vToken` contract. Each pool has one `Comptroller` checking these interactions across markets. When a user interacts
+ * with a given market by one of these main actions, a call is made to a corresponding hook in the associated `Comptroller`, which either allows
+ * or reverts the transaction. These hooks also update supply and borrow rewards as they are called. The comptroller holds the logic for assessing
+ * liquidity snapshots of an account via the collateral factor and liquidation threshold. This check determines the collateral needed for a borrow,
+ * as well as how much of a borrow may be liquidated. A user may borrow a portion of their collateral with the maximum amount determined by the
+ * markets collateral factor. However, if their borrowed amount exceeds an amount calculated using the market’s corresponding liquidation threshold,
+ * the borrow is eligible for liquidation.
+ *
+ * The `Comptroller` also includes two functions `liquidateAccount()` and `healAccount()`, which are meant to handle accounts that do not exceed
+ * the `minLiquidatableCollateral` for the `Comptroller`:
+ *
+ * - `healAccount()`: This function is called to seize all of a given user’s collateral, requiring the `msg.sender` repay a certain percentage
+ * of the debt calculated by `collateral/(borrows*liquidationIncentive)`. The function can only be called if the calculated percentage does not exceed
+ * 100%, because otherwise no `badDebt` would be created and `liquidateAccount()` should be used instead. The difference in the actual amount of debt
+ * and debt paid off is recorded as `badDebt` for each market, which can then be auctioned off for the risk reserves of the associated pool.
+ * - `liquidateAccount()`: This function can only be called if the collateral seized will cover all borrows of an account, as well as the liquidation
+ * incentive. Otherwise, the pool will incur bad debt, in which case the function `healAccount()` should be used instead. This function skips the logic
+ * verifying that the repay amount does not exceed the close factor.
  */
 contract Comptroller is
     Ownable2StepUpgradeable,
@@ -92,6 +112,9 @@ contract Comptroller is
     /// @notice Thrown when a market has an unexpected comptroller
     error ComptrollerMismatch();
 
+    /// @notice Thrown when user is not member of market
+    error MarketNotCollateral(address vToken, address user);
+
     /**
      * @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
@@ -158,10 +181,6 @@ contract Comptroller is
     function enterMarkets(address[] memory vTokens) external override returns (uint256[] memory) {
         uint256 len = vTokens.length;
 
-        uint256 accountAssetsLen = accountAssets[msg.sender].length;
-
-        _ensureMaxLoops(accountAssetsLen + len);
-
         uint256[] memory results = new uint256[](len);
         for (uint256 i; i < len; ++i) {
             VToken vToken = VToken(vTokens[i]);
@@ -334,9 +353,6 @@ contract Comptroller is
     ) external override {
         _checkActionPauseState(vToken, Action.BORROW);
 
-        //Update the prices of tokens
-        updatePrices(borrower);
-
         if (!markets[vToken].isListed) {
             revert MarketNotListed(address(vToken));
         }
@@ -344,11 +360,14 @@ contract Comptroller is
         if (!markets[vToken].accountMembership[borrower]) {
             // only vTokens may call borrowAllowed if borrower not in market
             _checkSenderIs(vToken);
-            _ensureMaxLoops(accountAssets[msg.sender].length + 1);
+
             // attempt to add borrower to the market or revert
             _addToMarket(VToken(msg.sender), borrower);
         }
 
+        // Update the prices of tokens
+        updatePrices(borrower);
+
         if (oracle.getUnderlyingPrice(vToken) == 0) {
             revert PriceError(address(vToken));
         }
@@ -442,7 +461,7 @@ contract Comptroller is
         // Action.SEIZE on it
         _checkActionPauseState(vTokenBorrowed, Action.LIQUIDATE);
 
-        //Update the prices of tokens
+        // Update the prices of tokens
         updatePrices(borrower);
 
         if (!markets[vTokenBorrowed].isListed) {
@@ -503,7 +522,9 @@ contract Comptroller is
         // Action.LIQUIDATE on it
         _checkActionPauseState(vTokenCollateral, Action.SEIZE);
 
-        if (!markets[vTokenCollateral].isListed) {
+        Market storage market = markets[vTokenCollateral];
+
+        if (!market.isListed) {
             revert MarketNotListed(vTokenCollateral);
         }
 
@@ -524,6 +545,10 @@ contract Comptroller is
             }
         }
 
+        if (!market.accountMembership[borrower]) {
+            revert MarketNotCollateral(vTokenCollateral, borrower);
+        }
+
         // Keep the flywheel moving
         uint256 rewardDistributorsCount = rewardsDistributors.length;
 
@@ -616,7 +641,7 @@ contract Comptroller is
         );
 
         Exp memory percentage = div_(collateral, scaledBorrows);
-        if (lessThanOrEqualExp(Exp({ mantissa: MANTISSA_ONE }), percentage)) {
+        if (lessThanExp(Exp({ mantissa: MANTISSA_ONE }), percentage)) {
             revert CollateralExceedsThreshold(scaledBorrows.mantissa, collateral.mantissa);
         }
 
@@ -676,7 +701,7 @@ contract Comptroller is
 
         uint256 ordersCount = orders.length;
 
-        _ensureMaxLoops(ordersCount);
+        _ensureMaxLoops(ordersCount / 2);
 
         for (uint256 i; i < ordersCount; ++i) {
             if (!markets[address(orders[i].vTokenBorrowed)].isListed) {
@@ -709,7 +734,7 @@ contract Comptroller is
      * @notice Sets the closeFactor to use when liquidating borrows
      * @param newCloseFactorMantissa New close factor, scaled by 1e18
      * @custom:event Emits NewCloseFactor on success
-     * @custom:access Only Governance
+     * @custom:access Controlled by AccessControlManager
      */
     function setCloseFactor(uint256 newCloseFactorMantissa) external {
         _checkAccessAllowed("setCloseFactor(uint256)");
@@ -1304,7 +1329,7 @@ contract Comptroller is
             return;
         }
 
-        //Update the prices of tokens
+        // Update the prices of tokens
         updatePrices(redeemer);
 
         /* Otherwise, perform a hypothetical liquidity check to guard against shortfall */

package/contracts/ComptrollerInterface.sol

@@ -6,6 +6,11 @@ import { ResilientOracleInterface } from "@venusprotocol/oracle/contracts/interf
 import { VToken } from "./VToken.sol";
 import { RewardsDistributor } from "./Rewards/RewardsDistributor.sol";
 
+/**
+ * @title ComptrollerInterface
+ * @author Venus
+ * @notice Interface implemented by the `Comptroller` contract.
+ */
 interface ComptrollerInterface {
     /*** Assets You Are In ***/
 
@@ -70,6 +75,11 @@ interface ComptrollerInterface {
     function getAllMarkets() external view returns (VToken[] memory);
 }
 
+/**
+ * @title ComptrollerViewInterface
+ * @author Venus
+ * @notice Interface implemented by the `Comptroller` contract, including only some util view functions.
+ */
 interface ComptrollerViewInterface {
     function markets(address) external view returns (bool, uint256);
 

package/contracts/ComptrollerStorage.sol

@@ -6,6 +6,11 @@ import { ResilientOracleInterface } from "@venusprotocol/oracle/contracts/interf
 import { VToken } from "./VToken.sol";
 import { RewardsDistributor } from "./Rewards/RewardsDistributor.sol";
 
+/**
+ * @title ComptrollerStorage
+ * @author Venus
+ * @notice Storage layout for the `Comptroller` contract.
+ */
 contract ComptrollerStorage {
     struct LiquidationOrder {
         VToken vTokenCollateral;

package/contracts/ErrorReporter.sol

@@ -1,6 +1,11 @@
 // SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.8.13;
 
+/**
+ * @title TokenErrorReporter
+ * @author Venus
+ * @notice Errors that can be thrown by the `VToken` contract.
+ */
 contract TokenErrorReporter {
     uint256 public constant NO_ERROR = 0; // support legacy return codes
 

package/contracts/ExponentialNoError.sol

@@ -62,13 +62,6 @@ contract ExponentialNoError {
         return left.mantissa < right.mantissa;
     }
 
-    /**
-     * @dev Checks if first Exp is less than or equal second Exp.
-     */
-    function lessThanOrEqualExp(Exp memory left, Exp memory right) internal pure returns (bool) {
-        return left.mantissa <= right.mantissa;
-    }
-
     function safe224(uint256 n, string memory errorMessage) internal pure returns (uint224) {
         require(n <= type(uint224).max, errorMessage);
         return uint224(n);

package/contracts/Lens/PoolLens.sol

@@ -12,6 +12,19 @@ import { PoolRegistryInterface } from "../Pool/PoolRegistryInterface.sol";
 import { PoolRegistry } from "../Pool/PoolRegistry.sol";
 import { RewardsDistributor } from "../Rewards/RewardsDistributor.sol";
 
+/**
+ * @title PoolLens
+ * @author Venus
+ * @notice The `PoolLens` contract is designed to retrieve important information for each registered pool. A list of essential information
+ * for all pools within the lending protocol can be acquired through the function `getAllPools()`. Additionally, the following records can be
+ * looked up for specific pools and markets:
+- the vToken balance of a given user;
+- the pool data (oracle address, associated vToken, liquidation incentive, etc) of a pool via its associated comptroller address;
+- the vToken address in a pool for a given asset;
+- a list of all pools that support an asset;
+- the underlying asset price of a vToken;
+- the metadata (exchange/borrow/supply rate, total supply, collateral factor, etc) of any vToken.
+ */
 contract PoolLens is ExponentialNoError {
     /**
      * @dev Struct for PoolDetails.

package/contracts/MaxLoopsLimitHelper.sol

@@ -1,6 +1,11 @@
 // SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.8.13;
 
+/**
+ * @title MaxLoopsLimitHelper
+ * @author Venus
+ * @notice Abstract contract used to avoid collection with too many items that would generate gas errors and DoS.
+ */
 abstract contract MaxLoopsLimitHelper {
     // Limit for the loops to avoid the DOS
     uint256 public maxLoopsLimit;

package/contracts/Pool/PoolRegistry.sol

@@ -2,54 +2,44 @@
 pragma solidity 0.8.13;
 
 import { Ownable2StepUpgradeable } from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
-import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
 import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
-import { BeaconProxy } from "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";
-import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import { ResilientOracleInterface } from "@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol";
-import { AccessControlManager } from "@venusprotocol/governance-contracts/contracts/Governance/AccessControlManager.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
 import { AccessControlledV8 } from "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol";
 
 import { PoolRegistryInterface } from "./PoolRegistryInterface.sol";
 import { Comptroller } from "../Comptroller.sol";
-import { VTokenProxyFactory } from "../Factories/VTokenProxyFactory.sol";
-import { JumpRateModelFactory } from "../Factories/JumpRateModelFactory.sol";
-import { WhitePaperInterestRateModelFactory } from "../Factories/WhitePaperInterestRateModelFactory.sol";
-import { WhitePaperInterestRateModel } from "../WhitePaperInterestRateModel.sol";
 import { VToken } from "../VToken.sol";
-import { InterestRateModel } from "../InterestRateModel.sol";
-import { Shortfall } from "../Shortfall/Shortfall.sol";
-import { VTokenInterface } from "../VTokenInterfaces.sol";
 import { ensureNonzeroAddress } from "../lib/validators.sol";
 
 /**
  * @title PoolRegistry
- * @notice PoolRegistry is a registry for Venus interest rate pools.
+ * @author Venus
+ * @notice The Isolated Pools architecture centers around the `PoolRegistry` contract. The `PoolRegistry` maintains a directory of isolated lending
+ * pools and can perform actions like creating and registering new pools, adding new markets to existing pools, setting and updating the pool's required
+ * metadata, and providing the getter methods to get information on the pools.
+ *
+ * Isolated lending has three main components: PoolRegistry, pools, and markets. The PoolRegistry is responsible for managing pools.
+ * It can create new pools, update pool metadata and manage markets within pools. PoolRegistry contains getter methods to get the details of
+ * any existing pool like `getVTokenForAsset` and `getPoolsSupportedByAsset`. It also contains methods for updating pool metadata (`updatePoolMetadata`)
+ * and setting pool name (`setPoolName`).
+ *
+ * The directory of pools is managed through two mappings: `_poolByComptroller` which is a hashmap with the comptroller address as the key and `VenusPool` as
+ * the value and `_poolsByID` which is an array of comptroller addresses. Individual pools can be accessed by calling `getPoolByComptroller` with the pool's
+ * comptroller address. `_poolsByID` is used to iterate through all of the pools.
+ *
+ * PoolRegistry also contains a map of asset addresses called `_supportedPools` that maps to an array of assets suppored by each pool. This array of pools by
+ * asset is retrieved by calling `getPoolsSupportedByAsset`.
+ *
+ * PoolRegistry registers new isolated pools in the directory with the `createRegistryPool` method. Isolated pools are composed of independent markets with
+ * specific assets and custom risk management configurations according to their markets.
  */
 contract PoolRegistry is Ownable2StepUpgradeable, AccessControlledV8, PoolRegistryInterface {
     using SafeERC20Upgradeable for IERC20Upgradeable;
 
-    enum InterestRateModels {
-        WhitePaper,
-        JumpRate
-    }
-
     struct AddMarketInput {
-        address comptroller;
-        address asset;
-        uint8 decimals;
-        string name;
-        string symbol;
-        InterestRateModels rateModel;
-        uint256 baseRatePerYear;
-        uint256 multiplierPerYear;
-        uint256 jumpMultiplierPerYear;
-        uint256 kink_;
+        VToken vToken;
         uint256 collateralFactor;
         uint256 liquidationThreshold;
-        uint256 reserveFactor;
-        AccessControlManager accessControlManager;
-        address beaconAddress;
         uint256 initialSupply;
         address vTokenReceiver;
         uint256 supplyCap;
@@ -58,31 +48,6 @@ contract PoolRegistry is Ownable2StepUpgradeable, AccessControlledV8, PoolRegist
 
     uint256 internal constant MAX_POOL_NAME_LENGTH = 100;
 
-    /**
-     * @notice VTokenProxyFactory contract address
-     */
-    VTokenProxyFactory public vTokenFactory;
-
-    /**
-     * @notice JumpRateModelFactory contract address
-     */
-    JumpRateModelFactory public jumpRateFactory;
-
-    /**
-     * @notice WhitePaperInterestRateModelFactory contract address
-     */
-    WhitePaperInterestRateModelFactory public whitePaperFactory;
-
-    /**
-     * @notice Shortfall contract address
-     */
-    Shortfall public shortfall;
-
-    /**
-     * @notice Shortfall contract address
-     */
-    address payable public protocolShareReserve;
-
     /**
      * @notice Maps pool's comptroller address to metadata.
      */
@@ -137,16 +102,6 @@ contract PoolRegistry is Ownable2StepUpgradeable, AccessControlledV8, PoolRegist
      */
     event MarketAdded(address indexed comptroller, address indexed vTokenAddress);
 
-    /**
-     * @notice Event emitted when shortfall contract address is changed
-     */
-    event NewShortfallContract(address indexed oldShortfall, address indexed newShortfall);
-
-    /**
-     * @notice Event emitted when protocol share reserve contract address is changed
-     */
-    event NewProtocolShareReserve(address indexed oldProtocolShareReserve, address indexed newProtocolShareReserve);
-
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor() {
         // Note that the contract is upgradeable. Use initialize() or reinitializers
@@ -156,161 +111,73 @@ contract PoolRegistry is Ownable2StepUpgradeable, AccessControlledV8, PoolRegist
 
     /**
      * @dev Initializes the deployer to owner
-     * @param vTokenFactory_ vToken factory address
-     * @param jumpRateFactory_ jump rate factory address
-     * @param whitePaperFactory_ white paper factory address
-     * @param protocolShareReserve_ protocol's shares reserve address
-     * @param shortfall_ Shortfall contract address
      * @param accessControlManager_ AccessControlManager contract address
-     * @custom:error ZeroAddressNotAllowed is thrown when shortfall contract address is zero
-     * @custom:error ZeroAddressNotAllowed is thrown when protocol share reserve address is zero
      */
-    function initialize(
-        VTokenProxyFactory vTokenFactory_,
-        JumpRateModelFactory jumpRateFactory_,
-        WhitePaperInterestRateModelFactory whitePaperFactory_,
-        Shortfall shortfall_,
-        address payable protocolShareReserve_,
-        address accessControlManager_
-    ) external initializer {
+    function initialize(address accessControlManager_) external initializer {
         __Ownable2Step_init();
         __AccessControlled_init_unchained(accessControlManager_);
-
-        vTokenFactory = vTokenFactory_;
-        jumpRateFactory = jumpRateFactory_;
-        whitePaperFactory = whitePaperFactory_;
-        _setShortfallContract(shortfall_);
-        _setProtocolShareReserve(protocolShareReserve_);
     }
 
     /**
-     * @notice Sets protocol share reserve contract address
-     * @param protocolShareReserve_ The address of the protocol share reserve contract
-     * @custom:error ZeroAddressNotAllowed is thrown when protocol share reserve address is zero
-     * @custom:access Only Governance
-     */
-    function setProtocolShareReserve(address payable protocolShareReserve_) external onlyOwner {
-        _setProtocolShareReserve(protocolShareReserve_);
-    }
-
-    /**
-     * @notice Sets shortfall contract address
-     * @param shortfall_ The address of the shortfall contract
-     * @custom:error ZeroAddressNotAllowed is thrown when shortfall contract address is zero
-     * @custom:access Only Governance
-     */
-    function setShortfallContract(Shortfall shortfall_) external onlyOwner {
-        _setShortfallContract(shortfall_);
-    }
-
-    /**
-     * @dev Deploys a new Venus pool and adds to the directory.
+     * @notice Adds a new Venus pool to the directory
+     * @dev Price oracle must be configured before adding a pool
      * @param name The name of the pool
-     * @param beaconAddress The upgradeable beacon contract address for Comptroller implementation
+     * @param comptroller Pool's Comptroller contract
      * @param closeFactor The pool's close factor (scaled by 1e18)
      * @param liquidationIncentive The pool's liquidation incentive (scaled by 1e18)
      * @param minLiquidatableCollateral Minimal collateral for regular (non-batch) liquidations flow
-     * @param priceOracle The pool's price oracle address
-     * @param maxLoopsLimit The maximum number of iterations the loops can perform
-     * @param accessControlManager AccessControlManager contract address
      * @return index The index of the registered Venus pool
-     * @return proxyAddress The the Comptroller proxy address
-     * @custom:error ZeroAddressNotAllowed is thrown when Comptroller beacon address is zero
+     * @custom:error ZeroAddressNotAllowed is thrown when Comptroller address is zero
      * @custom:error ZeroAddressNotAllowed is thrown when price oracle address is zero
      */
-    function createRegistryPool(
+    function addPool(
         string calldata name,
-        address beaconAddress,
+        Comptroller comptroller,
         uint256 closeFactor,
         uint256 liquidationIncentive,
-        uint256 minLiquidatableCollateral,
-        address priceOracle,
-        uint256 maxLoopsLimit,
-        address accessControlManager
-    ) external virtual returns (uint256 index, address proxyAddress) {
-        _checkAccessAllowed("createRegistryPool(string,address,uint256,uint256,uint256,address,uint256,address)");
+        uint256 minLiquidatableCollateral
+    ) external virtual returns (uint256 index) {
+        _checkAccessAllowed("addPool(string,address,uint256,uint256,uint256)");
         // Input validation
-        ensureNonzeroAddress(beaconAddress);
-        ensureNonzeroAddress(priceOracle);
-
-        BeaconProxy proxy = new BeaconProxy(
-            beaconAddress,
-            abi.encodeWithSelector(Comptroller.initialize.selector, maxLoopsLimit, accessControlManager)
-        );
-
-        proxyAddress = address(proxy);
-        Comptroller comptrollerProxy = Comptroller(proxyAddress);
+        ensureNonzeroAddress(address(comptroller));
+        ensureNonzeroAddress(address(comptroller.oracle()));
 
-        uint256 poolId = _registerPool(name, proxyAddress);
+        uint256 poolId = _registerPool(name, address(comptroller));
 
         // Set Venus pool parameters
-        comptrollerProxy.setCloseFactor(closeFactor);
-        comptrollerProxy.setLiquidationIncentive(liquidationIncentive);
-        comptrollerProxy.setMinLiquidatableCollateral(minLiquidatableCollateral);
-        comptrollerProxy.setPriceOracle(ResilientOracleInterface(priceOracle));
+        comptroller.setCloseFactor(closeFactor);
+        comptroller.setLiquidationIncentive(liquidationIncentive);
+        comptroller.setMinLiquidatableCollateral(minLiquidatableCollateral);
 
-        // Start transferring ownership to msg.sender
-        comptrollerProxy.transferOwnership(msg.sender);
-
-        return (poolId, proxyAddress);
+        return poolId;
     }
 
     /**
-     * @notice Add a market to an existing pool and then mint to provide initial supply.
-     * @param input The structure describing the parameters for adding a market to a pool.
-     * @custom:error ZeroAddressNotAllowed is thrown when Comptroller address is zero
-     * @custom:error ZeroAddressNotAllowed is thrown when asset address is zero
-     * @custom:error ZeroAddressNotAllowed is thrown when VToken beacon address is zero
+     * @notice Add a market to an existing pool and then mint to provide initial supply
+     * @param input The structure describing the parameters for adding a market to a pool
+     * @custom:error ZeroAddressNotAllowed is thrown when vToken address is zero
      * @custom:error ZeroAddressNotAllowed is thrown when vTokenReceiver address is zero
      */
     function addMarket(AddMarketInput memory input) external {
         _checkAccessAllowed("addMarket(AddMarketInput)");
-        ensureNonzeroAddress(input.comptroller);
-        ensureNonzeroAddress(input.asset);
-        ensureNonzeroAddress(input.beaconAddress);
+        ensureNonzeroAddress(address(input.vToken));
         ensureNonzeroAddress(input.vTokenReceiver);
+        require(input.initialSupply > 0, "PoolRegistry: initialSupply is zero");
+
+        VToken vToken = input.vToken;
+        address vTokenAddress = address(vToken);
+        address comptrollerAddress = address(vToken.comptroller());
+        Comptroller comptroller = Comptroller(comptrollerAddress);
+        address underlyingAddress = vToken.underlying();
+        IERC20Upgradeable underlying = IERC20Upgradeable(underlyingAddress);
 
+        require(_poolByComptroller[comptrollerAddress].creator != address(0), "PoolRegistry: Pool not registered");
         // solhint-disable-next-line reason-string
         require(
-            _vTokens[input.comptroller][input.asset] == address(0),
+            _vTokens[comptrollerAddress][underlyingAddress] == address(0),
             "PoolRegistry: Market already added for asset comptroller combination"
         );
 
-        InterestRateModel rate;
-        if (input.rateModel == InterestRateModels.JumpRate) {
-            rate = InterestRateModel(
-                jumpRateFactory.deploy(
-                    input.baseRatePerYear,
-                    input.multiplierPerYear,
-                    input.jumpMultiplierPerYear,
-                    input.kink_,
-                    input.accessControlManager
-                )
-            );
-        } else {
-            rate = InterestRateModel(whitePaperFactory.deploy(input.baseRatePerYear, input.multiplierPerYear));
-        }
-
-        Comptroller comptroller = Comptroller(input.comptroller);
-        uint256 underlyingDecimals = IERC20Metadata(input.asset).decimals();
-
-        VTokenProxyFactory.VTokenArgs memory initializeArgs = VTokenProxyFactory.VTokenArgs(
-            input.asset,
-            comptroller,
-            rate,
-            10**(underlyingDecimals + 18 - input.decimals),
-            input.name,
-            input.symbol,
-            input.decimals,
-            msg.sender,
-            input.accessControlManager,
-            VTokenInterface.RiskManagementInit(address(shortfall), protocolShareReserve),
-            input.beaconAddress,
-            input.reserveFactor
-        );
-
-        VToken vToken = vTokenFactory.deployVTokenProxy(initializeArgs);
-
         comptroller.supportMarket(vToken);
         comptroller.setCollateralFactor(vToken, input.collateralFactor, input.liquidationThreshold);
 
@@ -325,16 +192,15 @@ contract PoolRegistry is Ownable2StepUpgradeable, AccessControlledV8, PoolRegist
         comptroller.setMarketSupplyCaps(vTokens, newSupplyCaps);
         comptroller.setMarketBorrowCaps(vTokens, newBorrowCaps);
 
-        _vTokens[input.comptroller][input.asset] = address(vToken);
-        _supportedPools[input.asset].push(input.comptroller);
+        _vTokens[comptrollerAddress][underlyingAddress] = vTokenAddress;
+        _supportedPools[underlyingAddress].push(comptrollerAddress);
 
-        IERC20Upgradeable token = IERC20Upgradeable(input.asset);
-        uint256 amountToSupply = _transferIn(token, msg.sender, input.initialSupply);
-        token.approve(address(vToken), 0);
-        token.approve(address(vToken), amountToSupply);
+        uint256 amountToSupply = _transferIn(underlying, msg.sender, input.initialSupply);
+        underlying.approve(vTokenAddress, 0);
+        underlying.approve(vTokenAddress, amountToSupply);
         vToken.mintBehalf(input.vTokenReceiver, amountToSupply);
 
-        emit MarketAdded(address(comptroller), address(vToken));
+        emit MarketAdded(comptrollerAddress, vTokenAddress);
     }
 
     /**
@@ -437,20 +303,6 @@ contract PoolRegistry is Ownable2StepUpgradeable, AccessControlledV8, PoolRegist
         return balanceAfter - balanceBefore;
     }
 
-    function _setShortfallContract(Shortfall shortfall_) internal {
-        ensureNonzeroAddress(address(shortfall_));
-        address oldShortfall = address(shortfall);
-        shortfall = shortfall_;
-        emit NewShortfallContract(oldShortfall, address(shortfall_));
-    }
-
-    function _setProtocolShareReserve(address payable protocolShareReserve_) internal {
-        ensureNonzeroAddress(protocolShareReserve_);
-        address oldProtocolShareReserve = protocolShareReserve;
-        protocolShareReserve = protocolShareReserve_;
-        emit NewProtocolShareReserve(oldProtocolShareReserve, protocolShareReserve_);
-    }
-
     function _ensureValidName(string calldata name) internal pure {
         require(bytes(name).length <= MAX_POOL_NAME_LENGTH, "Pool's name is too large");
     }