@venusprotocol/protocol-reserve 1.0.0-dev.5 → 1.0.0-dev.7

package/contracts/ProtocolReserve/ProtocolShareReserve.sol

@@ -9,7 +9,6 @@ import { MaxLoopsLimitHelper } from "@venusprotocol/isolated-pools/contracts/Max
 import { IProtocolShareReserve } from "../Interfaces/IProtocolShareReserve.sol";
 import { ComptrollerInterface } from "../Interfaces/ComptrollerInterface.sol";
 import { PoolRegistryInterface } from "../Interfaces/PoolRegistryInterface.sol";
-import { IPrime } from "../Interfaces/IPrime.sol";
 import { IVToken } from "../Interfaces/IVToken.sol";
 import { IIncomeDestination } from "../Interfaces/IIncomeDestination.sol";
 
@@ -27,17 +26,17 @@ contract ProtocolShareReserve is
     using SafeERC20Upgradeable for IERC20Upgradeable;
 
     /// @notice protocol income is categorized into two schemas.
-    /// The first schema is the default one
-    /// The second schema is for spread income from prime markets in core protocol
+    /// The first schema is for spread income
+    /// The second schema is for liquidation income
     enum Schema {
-        DEFAULT,
-        SPREAD_PRIME_CORE
+        PROTOCOL_RESERVES,
+        ADDITIONAL_REVENUE
     }
 
     struct DistributionConfig {
         Schema schema;
         /// @dev percenatge is represented without any scale
-        uint256 percentage;
+        uint8 percentage;
         address destination;
     }
 
@@ -53,13 +52,10 @@ contract ProtocolShareReserve is
     /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
     address public immutable vBNB;
 
-    /// @notice address of Prime contract
-    address public prime;
-
     /// @notice address of pool registry contract
     address public poolRegistry;
 
-    uint256 private constant MAX_PERCENT = 100;
+    uint8 public constant MAX_PERCENT = 100;
 
     /// @notice comptroller => asset => schema => balance
     mapping(address => mapping(address => mapping(Schema => uint256))) public assetsReserves;
@@ -73,9 +69,6 @@ contract ProtocolShareReserve is
     /// @notice Emitted when pool registry address is updated
     event PoolRegistryUpdated(address indexed oldPoolRegistry, address indexed newPoolRegistry);
 
-    /// @notice Emitted when prime address is updated
-    event PrimeUpdated(address indexed oldPrime, address indexed newPrime);
-
     /// @notice Event emitted after the updation of the assets reserves.
     event AssetsReservesUpdated(
         address indexed comptroller,
@@ -106,16 +99,29 @@ contract ProtocolShareReserve is
     /// @notice Event emitted when distribution configuration is updated
     event DistributionConfigUpdated(
         address indexed destination,
-        uint256 oldPercentage,
-        uint256 newPercentage,
+        uint8 oldPercentage,
+        uint8 newPercentage,
         Schema schema
     );
 
     /// @notice Event emitted when distribution configuration is added
-    event DistributionConfigAdded(address indexed destination, uint256 percentage, Schema schema);
+    event DistributionConfigAdded(address indexed destination, uint8 percentage, Schema schema);
+
+    /// @notice Event emitted when distribution configuration is removed
+    event DistributionConfigRemoved(address indexed destination, uint8 percentage, Schema schema);
 
+    /**
+     * @dev Constructor to initialize the immutable variables
+     * @param _corePoolComptroller The address of core pool comptroller
+     * @param _wbnb The address of WBNB
+     * @param _vbnb The address of vBNB
+     */
     /// @custom:oz-upgrades-unsafe-allow constructor
-    constructor(address _corePoolComptroller, address _wbnb, address _vbnb) {
+    constructor(
+        address _corePoolComptroller,
+        address _wbnb,
+        address _vbnb
+    ) {
         if (_corePoolComptroller == address(0)) revert InvalidAddress();
         if (_wbnb == address(0)) revert InvalidAddress();
         if (_vbnb == address(0)) revert InvalidAddress();
@@ -150,33 +156,20 @@ contract ProtocolShareReserve is
         poolRegistry = _poolRegistry;
     }
 
-    /**
-     * @dev Prime contract address setter.
-     * @param _prime Address of the prime contract
-     */
-    function setPrime(address _prime) external onlyOwner {
-        if (_prime == address(0)) revert InvalidAddress();
-        emit PrimeUpdated(prime, _prime);
-        prime = _prime;
-    }
-
     /**
      * @dev Add or update destination targets based on destination address
      * @param configs configurations of the destinations.
      */
-    function addOrUpdateDistributionConfigs(DistributionConfig[] memory configs) external nonReentrant {
+    function addOrUpdateDistributionConfigs(DistributionConfig[] calldata configs) external nonReentrant {
         _checkAccessAllowed("addOrUpdateDistributionConfigs(DistributionConfig[])");
 
-        //we need to accrue and release funds to prime before updating the distribution configuration
-        //because prime relies on getUnreleasedFunds and its return value may change after config update
-        _accrueAndReleaseFundsToPrime();
-
         for (uint256 i = 0; i < configs.length; ) {
             DistributionConfig memory _config = configs[i];
-            require(_config.destination != address(0), "ProtocolShareReserve: Destination address invalid");
+            if (_config.destination == address(0)) revert InvalidAddress();
 
             bool updated = false;
-            for (uint256 j = 0; j < distributionTargets.length; ) {
+            uint256 distributionTargetsLength = distributionTargets.length;
+            for (uint256 j = 0; j < distributionTargetsLength; ) {
                 DistributionConfig storage config = distributionTargets[j];
 
                 if (_config.schema == config.schema && config.destination == _config.destination) {
@@ -210,14 +203,50 @@ contract ProtocolShareReserve is
         _ensureMaxLoops(distributionTargets.length);
     }
 
+    /**
+     * @dev Remove destionation target if percentage is 0
+     * @param schema schema of the configuration
+     * @param destination destination address of the configuration
+     */
+    function removeDistributionConfig(Schema schema, address destination) external {
+        _checkAccessAllowed("removeDistributionConfig(Schema,address)");
+
+        uint256 distributionIndex;
+        bool found = false;
+        for (uint256 i = 0; i < distributionTargets.length; ) {
+            DistributionConfig storage config = distributionTargets[i];
+
+            if (schema == config.schema && destination == config.destination && config.percentage == 0) {
+                found = true;
+                distributionIndex = i;
+                break;
+            }
+
+            unchecked {
+                ++i;
+            }
+        }
+
+        if (found) {
+            emit DistributionConfigRemoved(
+                distributionTargets[distributionIndex].destination,
+                distributionTargets[distributionIndex].percentage,
+                distributionTargets[distributionIndex].schema
+            );
+
+            distributionTargets[distributionIndex] = distributionTargets[distributionTargets.length - 1];
+            distributionTargets.pop();
+        }
+
+        _ensurePercentages();
+    }
+
     /**
      * @dev Release funds
      * @param comptroller the comptroller address of the pool
      * @param assets assets to be released to distribution targets
      */
-    function releaseFunds(address comptroller, address[] memory assets) external nonReentrant {
-        _accruePrimeInterest();
-
+    function releaseFunds(address comptroller, address[] calldata assets) external nonReentrant {
         for (uint256 i = 0; i < assets.length; ) {
             _releaseFund(comptroller, assets[i]);
 
@@ -240,7 +269,8 @@ contract ProtocolShareReserve is
         address destination,
         address asset
     ) external view returns (uint256) {
-        for (uint256 i = 0; i < distributionTargets.length; ) {
+        uint256 distributionTargetsLength = distributionTargets.length;
+        for (uint256 i = 0; i < distributionTargetsLength; ) {
             DistributionConfig storage _config = distributionTargets[i];
             if (_config.schema == schema && _config.destination == destination) {
                 uint256 total = assetsReserves[comptroller][asset][schema];
@@ -260,6 +290,27 @@ contract ProtocolShareReserve is
         return distributionTargets.length;
     }
 
+    /**
+     * @dev Used to find out the percentage distribution for a particular destination based on schema
+     * @param destination the destination address of the distribution target
+     * @param schema the schema of the distribution target
+     * @return percentage percentage distribution
+     */
+    function getPercentageDistribution(address destination, Schema schema) external view returns (uint256) {
+        uint256 distributionTargetsLength = distributionTargets.length;
+        for (uint256 i = 0; i < distributionTargetsLength; ) {
+            DistributionConfig memory config = distributionTargets[i];
+
+            if (config.destination == destination && config.schema == schema) {
+                return config.percentage;
+            }
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
     /**
      * @dev Update the reserve of the asset for the specific pool after transferring to the protocol share reserve.
      * @param comptroller  Comptroller address(pool)
@@ -278,7 +329,7 @@ contract ProtocolShareReserve is
             PoolRegistryInterface(poolRegistry).getVTokenForAsset(comptroller, asset) == address(0)
         ) revert InvalidAddress();
 
-        Schema schema = getSchema(comptroller, asset, incomeType);
+        Schema schema = _getSchema(incomeType);
         uint256 currentBalance = IERC20Upgradeable(asset).balanceOf(address(this));
         uint256 assetReserve = totalAssetReserve[asset];
 
@@ -294,39 +345,6 @@ contract ProtocolShareReserve is
         }
     }
 
-    /**
-     * @dev Fetches the list of prime markets and then accrues interest and
-     * releases the funds to prime for each market
-     */
-    function _accrueAndReleaseFundsToPrime() internal {
-        address[] memory markets = IPrime(prime).getAllMarkets();
-        for (uint256 i = 0; i < markets.length; ) {
-            address market = markets[i];
-            IPrime(prime).accrueInterest(market);
-            _releaseFund(CORE_POOL_COMPTROLLER, _getUnderlying(market));
-
-            unchecked {
-                ++i;
-            }
-        }
-    }
-
-    /**
-     * @dev Fetches the list of prime markets and then accrues interest
-     * to prime for each market
-     */
-    function _accruePrimeInterest() internal {
-        address[] memory markets = IPrime(prime).getAllMarkets();
-        for (uint256 i = 0; i < markets.length; ) {
-            address market = markets[i];
-            IPrime(prime).accrueInterest(market);
-
-            unchecked {
-                ++i;
-            }
-        }
-    }
-
     /**
      * @dev asset from a particular pool to be release to distribution targets
      * @param comptroller  Comptroller address(pool)
@@ -356,10 +374,12 @@ contract ProtocolShareReserve is
             uint256 transferAmount = (schemaBalances[uint256(_config.schema)] * _config.percentage) / MAX_PERCENT;
             totalTransferAmounts[uint256(_config.schema)] += transferAmount;
 
-            IERC20Upgradeable(asset).safeTransfer(_config.destination, transferAmount);
-            IIncomeDestination(_config.destination).updateAssetsState(comptroller, asset);
+            if (transferAmount != 0) {
+                IERC20Upgradeable(asset).safeTransfer(_config.destination, transferAmount);
+                IIncomeDestination(_config.destination).updateAssetsState(comptroller, asset);
 
-            emit AssetReleased(_config.destination, asset, _config.schema, _config.percentage, transferAmount);
+                emit AssetReleased(_config.destination, asset, _config.schema, _config.percentage, transferAmount);
+            }
 
             unchecked {
                 ++i;
@@ -387,30 +407,27 @@ contract ProtocolShareReserve is
     }
 
     /**
-     * @dev Returns the schema based on comptroller, asset and income type
-     * @param comptroller  Comptroller address(pool)
-     * @param asset Asset address.
+     * @dev Returns the schema based on income type
      * @param incomeType type of income
      * @return schema schema for distribution
      */
-    function getSchema(
-        address comptroller,
-        address asset,
-        IncomeType incomeType
-    ) internal view returns (Schema schema) {
-        schema = Schema.DEFAULT;
-        address vToken = IPrime(prime).vTokenForAsset(asset);
+    function _getSchema(IncomeType incomeType) internal view returns (Schema schema) {
+        schema = Schema.ADDITIONAL_REVENUE;
 
-        if (vToken != address(0) && comptroller == CORE_POOL_COMPTROLLER && incomeType == IncomeType.SPREAD) {
-            schema = Schema.SPREAD_PRIME_CORE;
+        if (incomeType == IncomeType.SPREAD) {
+            schema = Schema.PROTOCOL_RESERVES;
         }
     }
 
+    /**
+     * @dev This ensures that the total percentage of all the distribution targets is 100% or 0%
+     */
     function _ensurePercentages() internal view {
         uint256 totalSchemas = uint256(type(Schema).max) + 1;
-        uint256[] memory totalPercentages = new uint256[](totalSchemas);
+        uint8[] memory totalPercentages = new uint8[](totalSchemas);
 
-        for (uint256 i = 0; i < distributionTargets.length; ) {
+        uint256 distributionTargetsLength = distributionTargets.length;
+        for (uint256 i = 0; i < distributionTargetsLength; ) {
             DistributionConfig memory config = distributionTargets[i];
             totalPercentages[uint256(config.schema)] += config.percentage;
 

package/contracts/Test/Mocks/MockToken.sol

@@ -8,7 +8,11 @@ import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 contract MockToken is ERC20 {
     uint8 private immutable _decimals;
 
-    constructor(string memory name_, string memory symbol_, uint8 decimals_) ERC20(name_, symbol_) {
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        uint8 decimals_
+    ) ERC20(name_, symbol_) {
         _decimals = decimals_;
     }
 

package/deploy/1-deploy.ts

@@ -0,0 +1,64 @@
+import mainnetDeployments from "@venusprotocol/venus-protocol/networks/mainnet.json";
+import testnetDeployments from "@venusprotocol/venus-protocol/networks/testnet.json";
+import hre, { ethers } from "hardhat";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+const ADDRESSES: any = {
+  bsctestnet: {
+    vBNBAddress: testnetDeployments.Contracts.vBNB,
+    comptroller: testnetDeployments.Contracts.Unitroller,
+    WBNBAddress: "0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd",
+    timelock: testnetDeployments.Contracts.Timelock,
+    acm: "0x45f8a08F534f34A97187626E05d4b6648Eeaa9AA",
+  },
+  bscmainnet: {
+    vBNBAddress: mainnetDeployments.Contracts.vBNB,
+    comptroller: mainnetDeployments.Contracts.Unitroller,
+    WBNBAddress: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+    timelock: mainnetDeployments.Contracts.Timelock,
+    acm: "0x4788629ABc6cFCA10F9f969efdEAa1cF70c23555",
+  },
+  sepolia: {
+    vBNBAddress: ethers.constants.AddressZero,
+    comptroller: ethers.constants.AddressZero,
+    WBNBAddress: ethers.constants.AddressZero,
+    timelock: ethers.constants.AddressZero,
+    acm: ethers.constants.AddressZero,
+  },
+};
+
+module.exports = async ({ getNamedAccounts, deployments, network }: HardhatRuntimeEnvironment) => {
+  const { deploy } = deployments;
+  const { deployer } = await getNamedAccounts();
+
+  const networkName = network.name;
+
+  const { vBNBAddress, comptroller, WBNBAddress, timelock, acm } = ADDRESSES[networkName];
+  const loopsLimit = 20;
+
+  await deploy("ProtocolShareReserve", {
+    from: deployer,
+    log: true,
+    deterministicDeployment: false,
+    args: [comptroller, WBNBAddress, vBNBAddress],
+    proxy: {
+      owner: timelock,
+      proxyContract: "OpenZeppelinTransparentProxy",
+      execute: {
+        methodName: "initialize",
+        args: [acm, loopsLimit],
+      },
+    },
+  });
+
+  const psr = await hre.ethers.getContract("ProtocolShareReserve");
+  const psrOwner = await psr.owner();
+
+  if (psrOwner === deployer) {
+    const tx = await psr.transferOwnership(ADDRESSES[networkName].timelock);
+    await tx.wait();
+    console.log("Transferred ownership of PSR to Timelock");
+  }
+};
+
+module.exports.tags = ["deploy"];

package/deployments/bscmainnet/.chainId

@@ -0,0 +1 @@
+56