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

package/contracts/Pool/PoolRegistryInterface.sol

@@ -1,9 +1,14 @@
 // SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.8.13;
 
+/**
+ * @title PoolRegistryInterface
+ * @author Venus
+ * @notice Interface implemented by `PoolRegistry`.
+ */
 interface PoolRegistryInterface {
     /**
-     * @dev Struct for a Venus interest rate pool.
+     * @notice Struct for a Venus interest rate pool.
      */
     struct VenusPool {
         string name;
@@ -14,7 +19,7 @@ interface PoolRegistryInterface {
     }
 
     /**
-     * @dev Struct for a Venus interest rate pool metadata.
+     * @notice Struct for a Venus interest rate pool metadata.
      */
     struct VenusPoolMetaData {
         string category;
@@ -22,18 +27,18 @@ interface PoolRegistryInterface {
         string description;
     }
 
-    /*** get All Pools in PoolRegistry ***/
+    /// @notice Get all pools in PoolRegistry
     function getAllPools() external view returns (VenusPool[] memory);
 
-    /*** get a Pool by comptrollerAddress ***/
+    /// @notice Get a pool by comptroller address
     function getPoolByComptroller(address comptroller) external view returns (VenusPool memory);
 
-    /*** get VToken in the Pool for an Asset ***/
+    /// @notice Get the address of the VToken contract in the Pool where the underlying token is the provided asset
     function getVTokenForAsset(address comptroller, address asset) external view returns (address);
 
-    /*** get Pools supported by Asset ***/
+    /// @notice Get the addresss of the Pools supported that include a market for the provided asset
     function getPoolsSupportedByAsset(address asset) external view returns (address[] memory);
 
-    /*** get metadata of a Pool by comptroller ***/
+    /// @notice Get the metadata of a Pool by comptroller address
     function getVenusPoolMetadata(address comptroller) external view returns (VenusPoolMetaData memory);
 }

package/contracts/Rewards/RewardsDistributor.sol

@@ -11,6 +11,21 @@ import { VToken } from "../VToken.sol";
 import { Comptroller } from "../Comptroller.sol";
 import { MaxLoopsLimitHelper } from "../MaxLoopsLimitHelper.sol";
 
+/**
+ * @title `RewardsDistributor`
+ * @author Venus
+ * @notice Contract used to configure, track and distribute rewards to users based on their actions (borrows and supplies) in the protocol.
+ * Users can receive additional rewards through a `RewardsDistributor`. Each `RewardsDistributor` proxy is initialized with a specific reward
+ * token and `Comptroller`, which can then distribute the reward token to users that supply or borrow in the associated pool.
+ * Authorized users can set the reward token borrow and supply speeds for each market in the pool. This sets a fixed amount of reward
+ * token to be released each block for borrowers and suppliers, which is distributed based on a user’s percentage of the borrows or supplies
+ * respectively. The owner can also set up reward distributions to contributor addresses (distinct from suppliers and borrowers) by setting
+ * their contributor reward token speed, which similarly allocates a fixed amount of reward token per block.
+ *
+ * The owner has the ability to transfer any amount of reward tokens held by the contract to any other address. Rewards are not distributed
+ * automatically and must be claimed by a user calling `claimRewardToken()`. Users should be aware that it is up to the owner and other centralized
+ * entities to ensure that the `RewardsDistributor` holds enough tokens to distribute the accumulated rewards of users and contributors.
+ */
 contract RewardsDistributor is ExponentialNoError, Ownable2StepUpgradeable, AccessControlledV8, MaxLoopsLimitHelper {
     using SafeERC20Upgradeable for IERC20Upgradeable;
 

package/contracts/RiskFund/IProtocolShareReserve.sol

@@ -1,6 +1,11 @@
 // SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.8.13;
 
+/**
+ * @title IProtocolShareReserve
+ * @author Venus
+ * @notice Interface implemented by `ProtocolShareReserve`.
+ */
 interface IProtocolShareReserve {
     function updateAssetsState(address comptroller, address asset) external;
 }

package/contracts/RiskFund/IRiskFund.sol

@@ -1,6 +1,11 @@
 // SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.8.13;
 
+/**
+ * @title IRiskFund
+ * @author Venus
+ * @notice Interface implemented by `RiskFund`.
+ */
 interface IRiskFund {
     function swapPoolsAssets(
         address[] calldata markets,

package/contracts/RiskFund/ProtocolShareReserve.sol

@@ -11,6 +11,11 @@ import { ReserveHelpers } from "./ReserveHelpers.sol";
 import { IRiskFund } from "./IRiskFund.sol";
 import { ensureNonzeroAddress } from "../lib/validators.sol";
 
+/**
+ * @title ProtocolShareReserve
+ * @author Venus
+ * @notice Contract used to store and distribute the reserves generated in the markets.
+ */
 contract ProtocolShareReserve is Ownable2StepUpgradeable, ExponentialNoError, ReserveHelpers, IProtocolShareReserve {
     using SafeERC20Upgradeable for IERC20Upgradeable;
 

package/contracts/RiskFund/ReserveHelpers.sol

@@ -8,6 +8,11 @@ import { ensureNonzeroAddress } from "../lib/validators.sol";
 import { ComptrollerInterface } from "../ComptrollerInterface.sol";
 import { PoolRegistryInterface } from "../Pool/PoolRegistryInterface.sol";
 
+/**
+ * @title ReserveHelpers
+ * @author Venus
+ * @notice Contract with basic features to track/hold different assets for different Comptrollers.
+ */
 contract ReserveHelpers {
     using SafeERC20Upgradeable for IERC20Upgradeable;
 

package/contracts/RiskFund/RiskFund.sol

@@ -19,6 +19,9 @@ import { MaxLoopsLimitHelper } from "../MaxLoopsLimitHelper.sol";
 import { ensureNonzeroAddress } from "../lib/validators.sol";
 
 /**
+ * @title ReserveHelpers
+ * @author Venus
+ * @notice Contract with basic features to track/hold different assets for different Comptrollers.
  * @dev This contract does not support BNB.
  */
 contract RiskFund is
@@ -48,9 +51,6 @@ contract RiskFund is
     /// @notice Emitted when PancakeSwap router contract address is updated
     event PancakeSwapRouterUpdated(address indexed oldPancakeSwapRouter, address indexed newPancakeSwapRouter);
 
-    /// @notice Emitted when min amount out for PancakeSwap is updated
-    event AmountOutMinUpdated(uint256 oldAmountOutMin, uint256 newAmountOutMin);
-
     /// @notice Emitted when minimum amount to convert is updated
     event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert);
 
@@ -156,7 +156,7 @@ contract RiskFund is
      * @notice Swap array of pool assets into base asset's tokens of at least a minimum amount
      * @param markets Array of vTokens whose assets to swap for base asset
      * @param amountsOutMin Minimum amount to receive for swap
-     * @param paths A path conststing of PCS token pairs for each swap
+     * @param paths A path consisting of PCS token pairs for each swap
      * @return Number of swapped tokens
      * @custom:error ZeroAddressNotAllowed is thrown if PoolRegistry contract address is not configured
      */
@@ -236,7 +236,7 @@ contract RiskFund is
      * @param vToken VToken
      * @param comptroller Comptroller address
      * @param amountOutMin Minimum amount to receive for swap
-     * @param path A path for the swap conststing of PCS token pairs
+     * @param path A path for the swap consisting of PCS token pairs
      * @return Number of swapped tokens.
      */
     function _swapAsset(

package/contracts/Shortfall/IShortfall.sol

@@ -1,6 +1,11 @@
 // SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.8.13;
 
+/**
+ * @title IShortfall
+ * @author Venus
+ * @notice Interface implemented by `Shortfall`.
+ */
 interface IShortfall {
     function convertibleBaseAsset() external returns (address);
 }

package/contracts/Shortfall/Shortfall.sol

@@ -17,6 +17,16 @@ import { PoolRegistryInterface } from "../Pool/PoolRegistryInterface.sol";
 import { ensureNonzeroAddress } from "../lib/validators.sol";
 import { EXP_SCALE } from "../lib/constants.sol";
 
+/**
+ * @title Shortfall
+ * @author Venus
+ * @notice Shortfall is an auction contract designed to auction off the `convertibleBaseAsset` accumulated in `RiskFund`. The `convertibleBaseAsset`
+ * is auctioned in exchange for users paying off the pool's bad debt. An auction can be started by anyone once a pool's bad debt has reached a minimum value.
+ * This value is set and can be changed by the authorized accounts. If the pool’s bad debt exceeds the risk fund plus a 10% incentive, then the auction winner
+ * is determined by who will pay off the largest percentage of the pool's bad debt. The auction winner then exchanges for the entire risk fund. Otherwise,
+ * if the risk fund covers the pool's bad debt plus the 10% incentive, then the auction winner is determined by who will take the smallest percentage of the
+ * risk fund in exchange for paying off all the pool's bad debt.
+ */
 contract Shortfall is Ownable2StepUpgradeable, AccessControlledV8, ReentrancyGuardUpgradeable, IShortfall {
     using SafeERC20Upgradeable for IERC20Upgradeable;
 
@@ -45,12 +55,13 @@ contract Shortfall is Ownable2StepUpgradeable, AccessControlledV8, ReentrancyGua
         uint256 highestBidBlock;
         uint256 startBidBps;
         mapping(VToken => uint256) marketDebt;
+        mapping(VToken => uint256) bidAmount;
     }
 
     /// @dev Max basis points i.e., 100%
     uint256 private constant MAX_BPS = 10000;
 
-    uint256 private constant DEFAULT_NEXT_BIDDER_BLOCK_LIMIT = 10;
+    uint256 private constant DEFAULT_NEXT_BIDDER_BLOCK_LIMIT = 100;
 
     uint256 private constant DEFAULT_WAIT_FOR_FIRST_BIDDER = 100;
 
@@ -174,13 +185,20 @@ contract Shortfall is Ownable2StepUpgradeable, AccessControlledV8, ReentrancyGua
      * @notice Place a bid greater than the previous in an ongoing auction
      * @param comptroller Comptroller address of the pool
      * @param bidBps The bid percent of the risk fund or bad debt depending on auction type
+     * @param auctionStartBlock The block number when auction started
      * @custom:event Emits BidPlaced event on success
      */
-    function placeBid(address comptroller, uint256 bidBps) external nonReentrant {
+    function placeBid(
+        address comptroller,
+        uint256 bidBps,
+        uint256 auctionStartBlock
+    ) external nonReentrant {
         Auction storage auction = auctions[comptroller];
 
+        require(auction.startBlock == auctionStartBlock, "auction has been restarted");
         require(_isStarted(auction), "no on-going auction");
         require(!_isStale(auction), "auction is stale, restart it");
+        require(bidBps > 0, "basis points cannot be zero");
         require(bidBps <= MAX_BPS, "basis points cannot be more than 10000");
         require(
             (auction.auctionType == AuctionType.LARGE_POOL_DEBT &&
@@ -197,22 +215,20 @@ contract Shortfall is Ownable2StepUpgradeable, AccessControlledV8, ReentrancyGua
             VToken vToken = VToken(address(auction.markets[i]));
             IERC20Upgradeable erc20 = IERC20Upgradeable(address(vToken.underlying()));
 
-            if (auction.auctionType == AuctionType.LARGE_POOL_DEBT) {
-                if (auction.highestBidder != address(0)) {
-                    uint256 previousBidAmount = ((auction.marketDebt[auction.markets[i]] * auction.highestBidBps) /
-                        MAX_BPS);
-                    erc20.safeTransfer(auction.highestBidder, previousBidAmount);
-                }
+            if (auction.highestBidder != address(0)) {
+                erc20.safeTransfer(auction.highestBidder, auction.bidAmount[auction.markets[i]]);
+            }
+            uint256 balanceBefore = erc20.balanceOf(address(this));
 
+            if (auction.auctionType == AuctionType.LARGE_POOL_DEBT) {
                 uint256 currentBidAmount = ((auction.marketDebt[auction.markets[i]] * bidBps) / MAX_BPS);
                 erc20.safeTransferFrom(msg.sender, address(this), currentBidAmount);
             } else {
-                if (auction.highestBidder != address(0)) {
-                    erc20.safeTransfer(auction.highestBidder, auction.marketDebt[auction.markets[i]]);
-                }
-
                 erc20.safeTransferFrom(msg.sender, address(this), auction.marketDebt[auction.markets[i]]);
             }
+
+            uint256 balanceAfter = erc20.balanceOf(address(this));
+            auction.bidAmount[auction.markets[i]] = balanceAfter - balanceBefore;
         }
 
         auction.highestBidder = msg.sender;
@@ -226,7 +242,6 @@ contract Shortfall is Ownable2StepUpgradeable, AccessControlledV8, ReentrancyGua
      * @notice Close an auction
      * @param comptroller Comptroller address of the pool
      * @custom:event Emits AuctionClosed event on successful close
-     * @custom:event Errors if auctions are paused
      */
     function closeAuction(address comptroller) external nonReentrant {
         Auction storage auction = auctions[comptroller];
@@ -246,14 +261,10 @@ contract Shortfall is Ownable2StepUpgradeable, AccessControlledV8, ReentrancyGua
             VToken vToken = VToken(address(auction.markets[i]));
             IERC20Upgradeable erc20 = IERC20Upgradeable(address(vToken.underlying()));
 
-            if (auction.auctionType == AuctionType.LARGE_POOL_DEBT) {
-                uint256 bidAmount = ((auction.marketDebt[auction.markets[i]] * auction.highestBidBps) / MAX_BPS);
-                erc20.safeTransfer(address(auction.markets[i]), bidAmount);
-                marketsDebt[i] = bidAmount;
-            } else {
-                erc20.safeTransfer(address(auction.markets[i]), auction.marketDebt[auction.markets[i]]);
-                marketsDebt[i] = auction.marketDebt[auction.markets[i]];
-            }
+            uint256 balanceBefore = erc20.balanceOf(address(auction.markets[i]));
+            erc20.safeTransfer(address(auction.markets[i]), auction.bidAmount[auction.markets[i]]);
+            uint256 balanceAfter = erc20.balanceOf(address(auction.markets[i]));
+            marketsDebt[i] = balanceAfter - balanceBefore;
 
             auction.markets[i].badDebtRecovered(marketsDebt[i]);
         }
@@ -295,11 +306,11 @@ contract Shortfall is Ownable2StepUpgradeable, AccessControlledV8, ReentrancyGua
      * @notice Restart an auction
      * @param comptroller Address of the pool
      * @custom:event Emits AuctionRestarted event on successful restart
-     * @custom:event Errors if auctions are paused
      */
     function restartAuction(address comptroller) external {
         Auction storage auction = auctions[comptroller];
 
+        require(!auctionsPaused, "auctions are paused");
         require(_isStarted(auction), "no on-going auction");
         require(_isStale(auction), "you need to wait for more time for first bidder");
 

package/contracts/VToken.sol

@@ -15,8 +15,30 @@ import { IProtocolShareReserve } from "./RiskFund/IProtocolShareReserve.sol";
 import { ensureNonzeroAddress } from "./lib/validators.sol";
 
 /**
- * @title Venus VToken Contract
- * @author Venus Dev Team
+ * @title VToken
+ * @author Venus
+ * @notice Each asset that is supported by a pool is integrated through an instance of the `VToken` contract. As outlined in the protocol overview,
+ * each isolated pool creates its own `vToken` corresponding to an asset. Within a given pool, each included `vToken` is referred to as a market of
+ * the pool. The main actions a user regularly interacts with in a market are:
+
+- mint/redeem of vTokens;
+- transfer of vTokens;
+- borrow/repay a loan on an underlying asset;
+- liquidate a borrow or liquidate/heal an account.
+
+ * A user supplies the underlying asset to a pool by minting `vTokens`, where the corresponding `vToken` amount is determined by the `exchangeRate`.
+ * The `exchangeRate` will change over time, dependent on a number of factors, some of which accrue interest. Additionally, once users have minted
+ * `vToken` in a pool, they can borrow any asset in the isolated pool by using their `vToken` as collateral. In order to borrow an asset or use a `vToken`
+ * as collateral, the user must be entered into each corresponding market (else, the `vToken` will not be considered collateral for a borrow). Note that
+ * a user may borrow up to a portion of their collateral determined by the market’s collateral factor. However, if their borrowed amount exceeds an amount
+ * calculated using the market’s corresponding liquidation threshold, the borrow is eligible for liquidation. When a user repays a borrow, they must also
+ * pay off interest accrued on the borrow.
+ * 
+ * The Venus protocol includes unique mechanisms for healing an account and liquidating an account. These actions are performed in the `Comptroller`
+ * and consider all borrows and collateral for which a given account is entered within a market. These functions may only be called on an account with a
+ * total collateral amount that is no larger than a universal `minLiquidatableCollateral` value, which is used for all markets within a `Comptroller`.
+ * Both functions settle all of an account’s borrows, but `healAccount()` may add `badDebt` to a vToken. For more detail, see the description of
+ * `healAccount()` and `liquidateAccount()` in the `Comptroller` summary section below.
  */
 contract VToken is
     Ownable2StepUpgradeable,
@@ -846,31 +868,31 @@ contract VToken is
 
         uint256 redeemTokens;
         uint256 redeemAmount;
+
         /* If redeemTokensIn > 0: */
         if (redeemTokensIn > 0) {
             /*
              * We calculate the exchange rate and the amount of underlying to be redeemed:
              *  redeemTokens = redeemTokensIn
-             *  redeemAmount = redeemTokensIn x exchangeRateCurrent
              */
             redeemTokens = redeemTokensIn;
-            redeemAmount = mul_ScalarTruncate(exchangeRate, redeemTokensIn);
         } else {
             /*
              * We get the current exchange rate and calculate the amount to be redeemed:
              *  redeemTokens = redeemAmountIn / exchangeRate
-             *  redeemAmount = redeemAmountIn
              */
             redeemTokens = div_(redeemAmountIn, exchangeRate);
 
             uint256 _redeemAmount = mul_(redeemTokens, exchangeRate);
             if (_redeemAmount != 0 && _redeemAmount != redeemAmountIn) redeemTokens++; // round up
-            redeemAmount = redeemAmountIn;
         }
 
-        // Revert if tokens is zero and amount is nonzero or token is nonzero and amount is zero
-        if ((redeemTokens == 0 && redeemAmount > 0) || (redeemTokens != 0 && redeemAmount == 0)) {
-            revert("redeemTokens or redeemAmount is zero");
+        // redeemAmount = exchangeRate * redeemTokens
+        redeemAmount = mul_ScalarTruncate(exchangeRate, redeemTokens);
+
+        // Revert if amount is zero
+        if (redeemAmount == 0) {
+            revert("redeemAmount is zero");
         }
 
         /* Fail if redeem not allowed */

package/contracts/VTokenInterfaces.sol

@@ -7,6 +7,11 @@ import { ResilientOracleInterface } from "@venusprotocol/oracle/contracts/interf
 import { ComptrollerInterface } from "./ComptrollerInterface.sol";
 import { InterestRateModel } from "./InterestRateModel.sol";
 
+/**
+ * @title VTokenStorage
+ * @author Venus
+ * @notice Storage layout used by the `VToken` contract
+ */
 // solhint-disable-next-line max-states-count
 contract VTokenStorage {
     /**
@@ -130,6 +135,11 @@ contract VTokenStorage {
     uint256[50] private __gap;
 }
 
+/**
+ * @title VTokenInterface
+ * @author Venus
+ * @notice Interface implemented by the `VToken` contract
+ */
 abstract contract VTokenInterface is VTokenStorage {
     struct RiskManagementInit {
         address shortfall;

package/contracts/WhitePaperInterestRateModel.sol

@@ -90,7 +90,7 @@ contract WhitePaperInterestRateModel 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/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/contracts/test/MockDeflationaryToken.sol

@@ -0,0 +1,113 @@
+pragma solidity 0.8.13;
+
+contract MockDeflatingToken {
+    string public constant NAME = "Deflating Test Token";
+    string public constant SYMBOL = "DTT";
+    uint8 public constant DECIMALS = 18;
+    uint256 public totalSupply;
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    bytes32 public DOMAIN_SEPARATOR;
+    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
+    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
+    mapping(address => uint256) public nonces;
+
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    constructor(uint256 _totalSupply) {
+        uint256 chainId;
+        assembly {
+            chainId := chainid()
+        }
+        DOMAIN_SEPARATOR = keccak256(
+            abi.encode(
+                keccak256("EIP712Domain(string NAME,string version,uint256 chainId,address verifyingContract)"),
+                keccak256(bytes(NAME)),
+                keccak256(bytes("1")),
+                chainId,
+                address(this)
+            )
+        );
+        _mint(msg.sender, _totalSupply);
+    }
+
+    function approve(address spender, uint256 value) external returns (bool) {
+        _approve(msg.sender, spender, value);
+        return true;
+    }
+
+    function transfer(address to, uint256 value) external returns (bool) {
+        _transfer(msg.sender, to, value);
+        return true;
+    }
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 value
+    ) external returns (bool) {
+        if (allowance[from][msg.sender] != type(uint256).max) {
+            allowance[from][msg.sender] = allowance[from][msg.sender] - value;
+        }
+        _transfer(from, to, value);
+        return true;
+    }
+
+    function permit(
+        address owner,
+        address spender,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external {
+        require(deadline >= block.timestamp, "EXPIRED");
+        bytes32 digest = keccak256(
+            abi.encodePacked(
+                "\x19\x01",
+                DOMAIN_SEPARATOR,
+                keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))
+            )
+        );
+        address recoveredAddress = ecrecover(digest, v, r, s);
+        require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNATURE");
+        _approve(owner, spender, value);
+    }
+
+    function _mint(address to, uint256 value) internal {
+        totalSupply = totalSupply + value;
+        balanceOf[to] = balanceOf[to] + value;
+        emit Transfer(address(0), to, value);
+    }
+
+    function _burn(address from, uint256 value) internal {
+        balanceOf[from] = balanceOf[from] - value;
+        totalSupply = totalSupply - value;
+        emit Transfer(from, address(0), value);
+    }
+
+    function _approve(
+        address owner,
+        address spender,
+        uint256 value
+    ) private {
+        allowance[owner][spender] = value;
+        emit Approval(owner, spender, value);
+    }
+
+    function _transfer(
+        address from,
+        address to,
+        uint256 value
+    ) private {
+        uint256 burnAmount = value / 100;
+        _burn(from, burnAmount);
+        uint256 transferAmount = value - burnAmount;
+        balanceOf[from] = balanceOf[from] - transferAmount;
+        balanceOf[to] = balanceOf[to] + transferAmount;
+        emit Transfer(from, to, transferAmount);
+    }
+}

package/dist/deploy/001-deploy-mock-tokens.d.ts

@@ -0,0 +1,3 @@
+import { DeployFunction } from "hardhat-deploy/types";
+declare const func: DeployFunction;
+export default func;

package/dist/deploy/001-deploy-mock-tokens.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const deploymentConfig_1 = require("../helpers/deploymentConfig");
+const func = async function (hre) {
+    const { deployments, getNamedAccounts } = hre;
+    const { deploy } = deployments;
+    const { deployer } = await getNamedAccounts();
+    const { tokensConfig } = await (0, deploymentConfig_1.getConfig)(hre.network.name);
+    for (const token of tokensConfig) {
+        if (token.isMock) {
+            const contractName = `Mock${token.symbol}`;
+            await deploy(contractName, {
+                from: deployer,
+                contract: "MockToken",
+                args: [token.name, token.symbol, token.decimals],
+                log: true,
+                autoMine: true, // speed up deployment on local network (ganache, hardhat), no effect on live networks
+            });
+        }
+    }
+};
+func.tags = ["MockTokens"];
+exports.default = func;

package/dist/deploy/002-price-oracle.d.ts

@@ -0,0 +1,2 @@
+import deployOracle from "@venusprotocol/oracle/dist/deploy/1-deploy-oracles";
+export default deployOracle;

package/dist/deploy/002-price-oracle.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1_deploy_oracles_1 = __importDefault(require("@venusprotocol/oracle/dist/deploy/1-deploy-oracles"));
+_1_deploy_oracles_1.default.tags = ["OracleDeploy"];
+_1_deploy_oracles_1.default.skip = async (hre) => hre.network.live;
+exports.default = _1_deploy_oracles_1.default;

package/dist/deploy/003-price-oracle-configure-feeds.d.ts

@@ -0,0 +1,2 @@
+import configureOracleFeeds from "@venusprotocol/oracle/dist/deploy/2-configure-feeds";
+export default configureOracleFeeds;

package/dist/deploy/003-price-oracle-configure-feeds.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _2_configure_feeds_1 = __importDefault(require("@venusprotocol/oracle/dist/deploy/2-configure-feeds"));
+_2_configure_feeds_1.default.tags = ["Oracle"];
+_2_configure_feeds_1.default.skip = async (hre) => hre.network.live;
+exports.default = _2_configure_feeds_1.default;

package/{deploy/004-swap-router.ts → dist/deploy/004-swap-router.d.ts}

@@ -1,5 +1,2 @@
 import deployOracle from "@venusprotocol/venus-protocol/deploy/005-deploy-swaprouter";
-
-deployOracle.tags = ["SwapRouter", "il"];
-
 export default deployOracle;

package/dist/deploy/004-swap-router.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _005_deploy_swaprouter_1 = __importDefault(require("@venusprotocol/venus-protocol/deploy/005-deploy-swaprouter"));
+_005_deploy_swaprouter_1.default.tags = ["SwapRouter", "il"];
+exports.default = _005_deploy_swaprouter_1.default;

package/dist/deploy/005-access-control.d.ts

@@ -0,0 +1,3 @@
+import { DeployFunction } from "hardhat-deploy/types";
+declare const func: DeployFunction;
+export default func;

package/dist/deploy/005-access-control.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const func = async function (hre) {
+    const { deployments, getNamedAccounts } = hre;
+    const { deploy } = deployments;
+    const { deployer } = await getNamedAccounts();
+    await deploy("AccessControlManager", {
+        from: deployer,
+        args: [],
+        log: true,
+        autoMine: true,
+    });
+};
+func.tags = ["AccessControl", "il"];
+func.skip = async (hre) => hre.network.live;
+exports.default = func;

package/dist/deploy/006-deploy-factories.d.ts

@@ -0,0 +1,3 @@
+import { DeployFunction } from "hardhat-deploy/types";
+declare const func: DeployFunction;
+export default func;