@venusprotocol/isolated-pools 1.0.0-dev.8 → 1.0.0-dev.9

package/README.md

@@ -12,20 +12,10 @@ The first generation of lending pools, including the Venus Core Pool, aggregate
 
 ### PoolRegistry
 
-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.
+The Isolated Pools architecture centers around the `PoolRegistry` contract. The `PoolRegistry` maintains a directory of isolated lending pools and can perform actions like 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.
 
 ![image](https://user-images.githubusercontent.com/47150934/236290058-6b14a499-7afe-46e4-bca6-d72e3db8a28e.png)
 
-### Factories
-
-There are three factory contracts:
-
-- JumpRateModelFactory
-- VTokenProxyFactory
-- WhiteRateInterestModelFactory
-
-These contracts are designed to deploy contracts when adding markets to a pool. In particular, the `JumpRateModelFactory` and `WhiteRateInterestModelFactory` deploy contracts for the rate model based on which was chosen for the market. The `VtokenProxyFactory` is used to generate a new `vToken` proxy for each market when it is added to a pool.
-
 ### Risk Fund
 
 The risk fund concerns three main contracts:

package/contracts/Comptroller.sol

@@ -734,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)");

package/contracts/Pool/PoolRegistry.sol

@@ -2,24 +2,13 @@
 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";
 
 /**
@@ -47,27 +36,10 @@ import { ensureNonzeroAddress } from "../lib/validators.sol";
 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;
@@ -76,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.
      */
@@ -155,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
@@ -174,163 +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)
-        );
+        ensureNonzeroAddress(address(comptroller));
+        ensureNonzeroAddress(address(comptroller.oracle()));
 
-        proxyAddress = address(proxy);
-        Comptroller comptrollerProxy = Comptroller(proxyAddress);
-
-        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));
-
-        // Start transferring ownership to msg.sender
-        comptrollerProxy.transferOwnership(msg.sender);
+        comptroller.setCloseFactor(closeFactor);
+        comptroller.setLiquidationIncentive(liquidationIncentive);
+        comptroller.setMinLiquidatableCollateral(minLiquidatableCollateral);
 
-        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"
         );
 
-        require(input.initialSupply > 0, "PoolRegistry: initialSupply is zero");
-
-        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);
 
@@ -345,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);
     }
 
     /**
@@ -457,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");
     }

package/contracts/lib/imports.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+// This file is needed to make hardhat and typechain generate artifacts for
+// contracts we depend on (e.g. in tests or deployments) but not use directly.
+// Another way to do this would be to use hardhat-dependency-compiler, but
+// since we only have a couple of dependencies, installing a separate package
+// seems an overhead.
+
+import { UpgradeableBeacon } from "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol";
+import { BeaconProxy } from "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";

package/dist/deploy/006-deploy-factories.js

@@ -1,12 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const hardhat_1 = require("hardhat");
-const ADDRESS_ONE = "0x0000000000000000000000000000000000000001";
-const treasuryAddresses = {
-    hardhat: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
-    bsctestnet: "0xFEA1c651A47FE29dB9b1bf3cC1f224d8D9CFF68C",
-    bscmainnet: "0xF322942f644A996A617BD29c16bd7d231d9F35E9", // Venus Treasury
-};
 const acmAddresses = {
     bsctestnet: "0x45f8a08F534f34A97187626E05d4b6648Eeaa9AA",
     bscmainnet: "0x4788629ABc6cFCA10F9f969efdEAa1cF70c23555",
@@ -23,24 +17,6 @@ const func = async function (hre) {
     else {
         accessControlManager = await hardhat_1.ethers.getContract("AccessControlManager");
     }
-    const vBep20Factory = await deploy("VTokenProxyFactory", {
-        from: deployer,
-        args: [],
-        log: true,
-        autoMine: true, // speed up deployment on local network (ganache, hardhat), no effect on live networks
-    });
-    const jumpRateModelFactory = await deploy("JumpRateModelFactory", {
-        from: deployer,
-        args: [],
-        log: true,
-        autoMine: true,
-    });
-    const whitePaperRateFactory = await deploy("WhitePaperInterestRateModelFactory", {
-        from: deployer,
-        args: [],
-        log: true,
-        autoMine: true,
-    });
     await deploy("PoolRegistry", {
         from: deployer,
         contract: "PoolRegistry",
@@ -49,14 +25,7 @@ const func = async function (hre) {
             proxyContract: "OpenZeppelinTransparentProxy",
             execute: {
                 methodName: "initialize",
-                args: [
-                    vBep20Factory.address,
-                    jumpRateModelFactory.address,
-                    whitePaperRateFactory.address,
-                    ADDRESS_ONE,
-                    treasuryAddresses[hre.network.name],
-                    accessControlManager.address,
-                ],
+                args: [accessControlManager.address],
             },
             upgradeIndex: 0,
         },

package/dist/deploy/007-access-control-configure.js

@@ -10,7 +10,6 @@ const func = async function (hre) {
     const { deploy } = deployments;
     const { deployer } = await getNamedAccounts();
     const poolRegistry = await hardhat_1.ethers.getContract("PoolRegistry");
-    const vBep20Factory = await hardhat_1.ethers.getContract("VTokenProxyFactory");
     let accessControlManager;
     if (hre.network.live) {
         const networkName = hre.network.name === "bscmainnet" ? "bscmainnet" : "bsctestnet";
@@ -51,15 +50,12 @@ const func = async function (hre) {
     tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "supportMarket(address)", poolRegistry.address);
     await tx.wait();
     console.log("DEFAULT_ADMIN | PoolRegistry       | supportMarket(address)");
-    tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "setInterestRateModel(address)", vBep20Factory.address);
-    await tx.wait();
-    console.log("DEFAULT_ADMIN | VTokenProxyFactory | setInterestRateModel(address)");
     tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "swapPoolsAssets(address[],uint256[],address[][])", deployer);
     await tx.wait();
     console.log("DEFAULT_ADMIN | Deployer           | swapPoolsAssets(address[],uint256[])");
-    tx = await accessControlManager.giveCallPermission(poolRegistry.address, "createRegistryPool(string,address,uint256,uint256,uint256,address,uint256,address)", deployer);
+    tx = await accessControlManager.giveCallPermission(poolRegistry.address, "addPool(string,address,uint256,uint256,uint256)", deployer);
     await tx.wait();
-    console.log("PoolRegistry  | Deployer           | createRegistryPool(string,address,uint256,uint256,uint256,address,uint256,address)");
+    console.log("PoolRegistry  | Deployer           | addPool(string,address,uint256,uint256,uint256)");
     tx = await accessControlManager.giveCallPermission(poolRegistry.address, "addMarket(AddMarketInput)", deployer);
     await tx.wait();
     console.log("PoolRegistry  | Deployer           | addMarket(AddMarketInput)");

package/dist/deploy/009-deploy-pools.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const utils_1 = require("ethers/lib/utils");
 const hardhat_1 = require("hardhat");
 const deploymentConfig_1 = require("../helpers/deploymentConfig");
+const deploymentConfig_2 = require("../helpers/deploymentConfig");
+const ADDRESS_ONE = "0x0000000000000000000000000000000000000001";
 const treasuryAddresses = {
+    hardhat: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
     bsctestnet: "0xFEA1c651A47FE29dB9b1bf3cC1f224d8D9CFF68C",
     bscmainnet: "0xF322942f644A996A617BD29c16bd7d231d9F35E9", // Venus Treasury
 };
@@ -10,6 +15,9 @@ const acmAddresses = {
     bsctestnet: "0x45f8a08F534f34A97187626E05d4b6648Eeaa9AA",
     bscmainnet: "0x4788629ABc6cFCA10F9f969efdEAa1cF70c23555",
 };
+const mantissaToBps = (num) => {
+    return ethers_1.BigNumber.from(num).div((0, utils_1.parseUnits)("1", 14)).toString();
+};
 const func = async function (hre) {
     const { deployments, getNamedAccounts } = hre;
     const { deploy } = deployments;
@@ -34,15 +42,15 @@ const func = async function (hre) {
         log: true,
         autoMine: true,
     });
-    const ComptrollerBeacon = await deploy("ComptrollerBeacon", {
-        contract: "Beacon",
+    const comptrollerBeacon = await deploy("ComptrollerBeacon", {
+        contract: "UpgradeableBeacon",
         from: deployer,
         args: [comptrollerImpl.address],
         log: true,
         autoMine: true,
     });
     // VToken Beacon
-    const vTokenImpl = await deploy("VtokenImpl", {
+    const vTokenImpl = await deploy("VTokenImpl", {
         contract: "VToken",
         from: deployer,
         args: [],
@@ -50,27 +58,41 @@ const func = async function (hre) {
         autoMine: true,
     });
     const vTokenBeacon = await deploy("VTokenBeacon", {
-        contract: "Beacon",
+        contract: "UpgradeableBeacon",
         from: deployer,
         args: [vTokenImpl.address],
         log: true,
         autoMine: true,
     });
     const { tokensConfig, poolConfig } = await (0, deploymentConfig_1.getConfig)(hre.network.name);
-    let pools = await poolRegistry.callStatic.getAllPools();
+    const pools = await poolRegistry.callStatic.getAllPools();
     for (let i = 0; i < poolConfig.length; i++) {
         const pool = poolConfig[i];
         let comptrollerProxy;
         if (i >= pools.length) {
+            // Deploying a proxy for Comptroller
+            console.log("Deploying a proxy for Comptroller");
+            const Comptroller = await hardhat_1.ethers.getContractFactory("Comptroller");
+            comptrollerProxy = await deploy(`Comptroller_${pool.name}`, {
+                from: deployer,
+                contract: "BeaconProxy",
+                args: [
+                    comptrollerBeacon.address,
+                    Comptroller.interface.encodeFunctionData("initialize", [maxLoopsLimit, accessControlManager.address]),
+                ],
+                log: true,
+                autoMine: true,
+            });
+            // Deploying a proxy for Comptroller
+            console.log("Setting price oracle for Comptroller");
+            const comptroller = await hardhat_1.ethers.getContractAt("Comptroller", comptrollerProxy.address);
+            tx = await comptroller.setPriceOracle(priceOracle.address);
+            await tx.wait();
             // Create pool
             console.log("Registering new pool with name " + pool.name);
-            tx = await poolRegistry.createRegistryPool(pool.name, ComptrollerBeacon.address, pool.closeFactor, pool.liquidationIncentive, pool.minLiquidatableCollateral, priceOracle.address, maxLoopsLimit, accessControlManager.address);
+            tx = await poolRegistry.addPool(pool.name, comptroller.address, pool.closeFactor, pool.liquidationIncentive, pool.minLiquidatableCollateral);
             await tx.wait();
             console.log("New Pool Registered");
-            pools = await poolRegistry.callStatic.getAllPools();
-            comptrollerProxy = await hardhat_1.ethers.getContractAt("Comptroller", pools[i].comptroller);
-            tx = await comptrollerProxy.acceptOwnership();
-            await tx.wait();
         }
         else {
             comptrollerProxy = await hardhat_1.ethers.getContractAt("Comptroller", pools[i].comptroller);
@@ -90,26 +112,65 @@ const func = async function (hre) {
                 tokenContract = await hardhat_1.ethers.getContractAt("@openzeppelin/contracts/token/ERC20/ERC20.sol:ERC20", token.tokenAddress);
                 // Make sure that deployer has at least `initialSupply` balance of the token
             }
+            let rateModelAddress;
+            if (rateModel === deploymentConfig_2.InterestRateModels.JumpRate.toString()) {
+                const [b, m, j, k] = [baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_].map(mantissaToBps);
+                const rateModelName = `JumpRateModelV2_base${b}bps_slope${m}bps_jump${j}bps_kink${k}bps`;
+                console.log(`Deploying interest rate model ${rateModelName}`);
+                const result = await deploy(rateModelName, {
+                    from: deployer,
+                    contract: "JumpRateModelV2",
+                    args: [baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_, accessControlManager.address],
+                    log: true,
+                    autoMine: true,
+                });
+                rateModelAddress = result.address;
+            }
+            else {
+                const [b, m] = [baseRatePerYear, multiplierPerYear].map(mantissaToBps);
+                const rateModelName = `WhitePaperInterestRateModel_base${b}bps_slope${m}bps`;
+                console.log(`Deploying interest rate model ${rateModelName}`);
+                const result = await deploy(rateModelName, {
+                    from: deployer,
+                    contract: "WhitePaperInterestRateModel",
+                    args: [baseRatePerYear, multiplierPerYear],
+                    log: true,
+                    autoMine: true,
+                });
+                rateModelAddress = result.address;
+            }
+            console.log(`Deploying VToken proxy for ${symbol}`);
+            const VToken = await hardhat_1.ethers.getContractFactory("VToken");
+            const underlyingDecimals = Number(await tokenContract.decimals());
+            const vTokenDecimals = 8;
+            const args = [
+                tokenContract.address,
+                comptrollerProxy.address,
+                rateModelAddress,
+                (0, utils_1.parseUnits)("1", underlyingDecimals + 18 - vTokenDecimals),
+                name,
+                symbol,
+                vTokenDecimals,
+                deployer,
+                accessControlManager.address,
+                [treasuryAddresses[hre.network.name], ADDRESS_ONE],
+                reserveFactor,
+            ];
+            const vToken = await deploy(`VToken_${name}`, {
+                from: deployer,
+                contract: "BeaconProxy",
+                args: [vTokenBeacon.address, VToken.interface.encodeFunctionData("initialize", args)],
+                log: true,
+                autoMine: true,
+            });
             console.log("Approving PoolRegistry for: " + initialSupply);
             tx = await tokenContract.approve(poolRegistry.address, initialSupply);
             await tx.wait(1);
             console.log("Adding market " + name + " to pool " + pool.name);
             tx = await poolRegistry.addMarket({
-                comptroller: comptrollerProxy.address,
-                asset: tokenContract.address,
-                decimals: 8,
-                name: name,
-                symbol: symbol,
-                rateModel: rateModel,
-                baseRatePerYear: baseRatePerYear,
-                multiplierPerYear: multiplierPerYear,
-                jumpMultiplierPerYear: jumpMultiplierPerYear,
-                kink_: kink_,
+                vToken: vToken.address,
                 collateralFactor: collateralFactor,
                 liquidationThreshold: liquidationThreshold,
-                reserveFactor: reserveFactor,
-                accessControlManager: accessControlManager.address,
-                beaconAddress: vTokenBeacon.address,
                 initialSupply: initialSupply,
                 vTokenReceiver: hre.network.name === "hardhat" ? deployer : treasuryAddresses[hre.network.name],
                 supplyCap: supplyCap,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venusprotocol/isolated-pools",
-  "version": "1.0.0-dev.8",
+  "version": "1.0.0-dev.9",
   "description": "",
   "files": [
     "artifacts",

package/artifacts/@openzeppelin/contracts/access/AccessControl.sol/AccessControl.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/8c02b3a8e3642dffe55772a8d2bed46f.json"
-}