@venusprotocol/protocol-reserve 1.0.0-dev.1

package/contracts/ProtocolReserve/ProtocolShareReserve.sol

@@ -0,0 +1,378 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+import { SafeERC20Upgradeable, IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { AccessControlledV8 } from "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol";
+
+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";
+
+error InvalidAddress();
+error UnsupportedAsset();
+error InvalidTotalPercentage();
+
+contract ProtocolShareReserve is AccessControlledV8, IProtocolShareReserve {
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+
+    /// @notice protocol income is categorized into two schemas.
+    /// The first schema is for spread income from prime markets in core protocol
+    /// The second schema is for all other sources and types of income
+    enum Schema {
+        DEFAULT,
+        SPREAD_PRIME_CORE
+    }
+
+    struct DistributionConfig {
+        Schema schema;
+        /// @dev percenatge is represented without any scale
+        uint256 percentage;
+        address destination;
+    }
+
+    /// @notice address of core pool comptroller contract
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+    address public immutable CORE_POOL_COMPTROLLER;
+
+    /// @notice address of WBNB contract
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+    address public immutable WBNB;
+
+    /// @notice address of vBNB contract
+    /// @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;
+
+    /// @notice comptroller => asset => schema => balance
+    mapping(address => mapping(address => mapping(Schema => uint256))) public assetsReserves;
+
+    /// @notice asset => balance
+    mapping(address => uint256) public totalAssetReserve;
+
+    /// @notice configuration for different income distribution targets
+    DistributionConfig[] public distributionTargets;
+
+    /// @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,
+        address indexed asset,
+        uint256 amount,
+        IncomeType incomeType,
+        Schema schema
+    );
+
+    /// @notice Event emitted after a income distribution target is configured
+    event DestinationConfigured(address indexed destination, uint percent, Schema schema);
+
+    /// @notice Event emitted when an asset is released to a target
+    event AssetReleased(
+        address indexed destination,
+        address indexed asset,
+        Schema schema,
+        uint256 percent,
+        uint256 amount
+    );
+
+    /// @notice Event emitted when asset reserves state is updated
+    event ReservesUpdated(
+        address indexed comptroller,
+        address indexed asset,
+        Schema schema,
+        uint256 oldBalance,
+        uint256 newBalance
+    );
+
+    /// @notice Event emitted when distribution configuration is updated
+    event DistributionConfigUpdated(
+        address indexed destination,
+        uint256 oldPercentage,
+        uint256 newPercentage,
+        Schema schema
+    );
+
+    /// @notice Event emitted when distribution configuration is added
+    event DistributionConfigAdded(address indexed destination, uint256 percentage, Schema schema);
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    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();
+
+        CORE_POOL_COMPTROLLER = _corePoolComptroller;
+        WBNB = _wbnb;
+        vBNB = _vbnb;
+
+        // Note that the contract is upgradeable. Use initialize() or reinitializers
+        // to set the state variables.
+        _disableInitializers();
+    }
+
+    /**
+     * @dev Initializes the deployer to owner.
+     * @param _accessControlManager The address of ACM contract
+     */
+    function initialize(address _accessControlManager) external initializer {
+        __AccessControlled_init(_accessControlManager);
+    }
+
+    /**
+     * @dev Pool registry setter.
+     * @param _poolRegistry Address of the pool registry
+     */
+    function setPoolRegistry(address _poolRegistry) external {
+        _checkAccessAllowed("setPoolRegistry(address)");
+        if (_poolRegistry == address(0)) revert InvalidAddress();
+        address oldPoolRegistry = poolRegistry;
+        poolRegistry = _poolRegistry;
+        emit PoolRegistryUpdated(oldPoolRegistry, poolRegistry);
+    }
+
+    /**
+     * @dev Prime contract address setter.
+     * @param _prime Address of the prime contract
+     */
+    function setPrime(address _prime) external {
+        _checkAccessAllowed("setPrime(address)");
+        if (_prime == address(0)) revert InvalidAddress();
+        address oldPrime = prime;
+        prime = _prime;
+        emit PrimeUpdated(oldPrime, prime);
+    }
+
+    /**
+     * @dev Add or update destination targets based on destination address
+     * @param configs configurations of the destinations.
+     */
+    function addOrUpdateDistributionConfigs(DistributionConfig[] memory configs) external {
+        _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 (uint i = 0; i < configs.length; ++i) {
+            DistributionConfig memory _config = configs[i];
+            require(_config.destination != address(0), "ProtocolShareReserve: Destination address invalid");
+
+            bool updated = false;
+            for (uint j = 0; j < distributionTargets.length; ++j) {
+                DistributionConfig storage config = distributionTargets[j];
+
+                if (_config.schema == config.schema && config.destination == _config.destination) {
+                    emit DistributionConfigUpdated(
+                        config.destination,
+                        config.percentage,
+                        _config.percentage,
+                        config.schema
+                    );
+                    config.percentage = _config.percentage;
+                    updated = true;
+                    break;
+                }
+            }
+
+            if (!updated) {
+                distributionTargets.push(_config);
+                emit DistributionConfigAdded(_config.destination, _config.percentage, _config.schema);
+            }
+        }
+
+        _ensurePercentages();
+    }
+
+    /**
+     * @dev Release funds
+     * @param assets assets to be released to distribution targets
+     */
+    function releaseFunds(address comptroller, address[] memory assets) external {
+        _accruePrimeInterest();
+
+        for (uint i = 0; i < assets.length; ++i) {
+            _releaseFund(comptroller, assets[i]);
+        }
+    }
+
+    /**
+     * @dev Used to find out the amount of funds that's going to be released when release funds is called.
+     * @param comptroller the comptroller address of the pool
+     * @param schema the schema of the distribution target
+     * @param destination the destination address of the distribution target
+     * @param asset the asset address which will be released
+     */
+    function getUnreleasedFunds(
+        address comptroller,
+        Schema schema,
+        address destination,
+        address asset
+    ) external view returns (uint256) {
+        for (uint i = 0; i < distributionTargets.length; ++i) {
+            DistributionConfig storage _config = distributionTargets[i];
+            if (_config.schema == schema && _config.destination == destination) {
+                uint256 total = assetsReserves[comptroller][asset][schema];
+                return (total * _config.percentage) / MAX_PERCENT;
+            }
+        }
+    }
+
+    /**
+     * @dev Returns the total number of distribution targets
+     */
+    function totalDistributions() external view returns (uint256) {
+        return distributionTargets.length;
+    }
+
+    /**
+     * @dev Update the reserve of the asset for the specific pool after transferring to the protocol share reserve.
+     * @param comptroller  Comptroller address(pool)
+     * @param asset Asset address.
+     */
+    function updateAssetsState(
+        address comptroller,
+        address asset,
+        IncomeType incomeType
+    ) public override(IProtocolShareReserve) {
+        if (!ComptrollerInterface(comptroller).isComptroller()) revert InvalidAddress();
+        if (asset == address(0)) revert InvalidAddress();
+        if (
+            comptroller != CORE_POOL_COMPTROLLER &&
+            PoolRegistryInterface(poolRegistry).getVTokenForAsset(comptroller, asset) == address(0)
+        ) revert InvalidAddress();
+
+        Schema schema = getSchema(comptroller, asset, incomeType);
+        uint256 currentBalance = IERC20Upgradeable(asset).balanceOf(address(this));
+        uint256 assetReserve = totalAssetReserve[asset];
+
+        if (currentBalance > assetReserve) {
+            uint256 balanceDifference;
+            unchecked {
+                balanceDifference = currentBalance - assetReserve;
+            }
+
+            assetsReserves[comptroller][asset][schema] += balanceDifference;
+            totalAssetReserve[asset] += balanceDifference;
+            emit AssetsReservesUpdated(comptroller, asset, balanceDifference, incomeType, schema);
+        }
+    }
+
+    /**
+     * @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).allMarkets();
+        for (uint i = 0; i < markets.length; ++i) {
+            address market = markets[i];
+            IPrime(prime).accrueInterest(market);
+            _releaseFund(CORE_POOL_COMPTROLLER, _getUnderlying(market));
+        }
+    }
+
+    /**
+     * @dev Fetches the list of prime markets and then accrues interest
+     * to prime for each market
+     */
+    function _accruePrimeInterest() internal {
+        address[] memory markets = IPrime(prime).allMarkets();
+        for (uint i = 0; i < markets.length; ++i) {
+            address market = markets[i];
+            IPrime(prime).accrueInterest(market);
+        }
+    }
+
+    function _releaseFund(address comptroller, address asset) internal {
+        uint256 totalSchemas = uint256(type(Schema).max) + 1;
+        uint[] memory schemaBalances = new uint[](totalSchemas);
+        uint256 totalBalance;
+
+        for (uint schemaValue; schemaValue < totalSchemas; ++schemaValue) {
+            schemaBalances[schemaValue] = assetsReserves[comptroller][asset][Schema(schemaValue)];
+            totalBalance += schemaBalances[schemaValue];
+        }
+
+        if (totalBalance == 0) {
+            return;
+        }
+
+        uint[] memory totalTransferAmounts = new uint[](totalSchemas);
+
+        for (uint i = 0; i < distributionTargets.length; ++i) {
+            DistributionConfig memory _config = distributionTargets[i];
+
+            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);
+
+            emit AssetReleased(_config.destination, asset, _config.schema, _config.percentage, transferAmount);
+        }
+
+        uint[] memory newSchemaBalances = new uint[](totalSchemas);
+        for (uint schemaValue = 0; schemaValue < totalSchemas; ++schemaValue) {
+            newSchemaBalances[schemaValue] = schemaBalances[schemaValue] - totalTransferAmounts[schemaValue];
+            assetsReserves[comptroller][asset][Schema(schemaValue)] = newSchemaBalances[schemaValue];
+            totalAssetReserve[asset] = totalAssetReserve[asset] - totalTransferAmounts[schemaValue];
+
+            emit ReservesUpdated(
+                comptroller,
+                asset,
+                Schema(schemaValue),
+                schemaBalances[schemaValue],
+                newSchemaBalances[schemaValue]
+            );
+        }
+    }
+
+    function getSchema(
+        address comptroller,
+        address asset,
+        IncomeType incomeType
+    ) internal view returns (Schema schema) {
+        schema = Schema.DEFAULT;
+        address vToken = IPrime(prime).vTokenForAsset(asset);
+
+        if (vToken != address(0) && comptroller == CORE_POOL_COMPTROLLER && incomeType == IncomeType.SPREAD) {
+            schema = Schema.SPREAD_PRIME_CORE;
+        }
+    }
+
+    function _ensurePercentages() internal view {
+        uint256 totalSchemas = uint256(type(Schema).max) + 1;
+        uint[] memory totalPercentages = new uint[](totalSchemas);
+
+        for (uint i = 0; i < distributionTargets.length; ++i) {
+            DistributionConfig memory config = distributionTargets[i];
+            totalPercentages[uint256(config.schema)] += config.percentage;
+        }
+
+        for (uint schemaValue = 0; schemaValue <= totalSchemas - 1; ++schemaValue) {
+            if (totalPercentages[schemaValue] != MAX_PERCENT && totalPercentages[schemaValue] != 0)
+                revert InvalidTotalPercentage();
+        }
+    }
+
+    function _getUnderlying(address vToken) internal view returns (address) {
+        if (vToken == vBNB) {
+            return WBNB;
+        } else {
+            return IVToken(vToken).underlying();
+        }
+    }
+}

package/contracts/Test/Mocks/MockToken.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol)
+
+pragma solidity ^0.8.0;
+
+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_) {
+        _decimals = decimals_;
+    }
+
+    function faucet(uint256 amount) external {
+        _mint(msg.sender, amount);
+    }
+
+    function decimals() public view virtual override returns (uint8) {
+        return _decimals;
+    }
+}

package/contracts/interfaces/ComptrollerInterface.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+interface ComptrollerInterface {
+    function isComptroller() external view returns (bool);
+}

package/contracts/interfaces/IProtocolShareReserve.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+interface IProtocolShareReserve {
+    /// @notice it represents the type of vToken income
+    enum IncomeType {
+        SPREAD,
+        LIQUIDATION
+    }
+
+    function updateAssetsState(address comptroller, address asset, IncomeType incomeType) external;
+}

package/contracts/interfaces/PoolRegistryInterface.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+interface PoolRegistryInterface {
+    /*** get VToken in the Pool for an Asset ***/
+    function getVTokenForAsset(address comptroller, address asset) external view returns (address);
+}

package/contracts/test/Mocks/MockToken.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol)
+
+pragma solidity ^0.8.0;
+
+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_) {
+        _decimals = decimals_;
+    }
+
+    function faucet(uint256 amount) external {
+        _mint(msg.sender, amount);
+    }
+
+    function decimals() public view virtual override returns (uint8) {
+        return _decimals;
+    }
+}

package/package.json

@@ -0,0 +1,116 @@
+{
+  "name": "@venusprotocol/protocol-reserve",
+  "description": "",
+  "version": "1.0.0-dev.1",
+  "author": "",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "artifacts",
+    "deploy",
+    "deployments",
+    "contracts"
+  ],
+  "keywords": [
+    "blockchain",
+    "ethers",
+    "ethereum",
+    "hardhat",
+    "smart-contracts",
+    "solidity",
+    "template",
+    "typescript",
+    "typechain"
+  ],
+  "exports": {
+    "deploy": "./dist/deploy",
+    "artifacts": "./artifacts",
+    "contracts": "./contracts",
+    "deployments": "./deployments"
+  },
+  "packageManager": "yarn@3.2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "compile": "hardhat compile",
+    "test": "hardhat test",
+    "build": "rm -rf dist && tsc --declaration && hardhat compile",
+    "publish:dist": "yarn build && cd dist && yarn publish --access public",
+    "lint": "yarn lint:ts && yarn lint:sol && yarn prettier:check",
+    "lint:ts": "eslint --ignore-path ./.eslintignore --ext .js,.ts .",
+    "lint:sol": "solhint \"contracts/**/*.sol\"",
+    "lint:sol:fix": "prettier --write \"contracts/**/*.sol\"",
+    "prettier": "prettier  --write \"**/*.{js,json,md,ts,yaml,yml,sol}\"",
+    "prettier:check": "prettier --check \"**/*.{js,json,md,ts,yaml,yml,sol}\"",
+    "docgen": "hardhat docgen"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^17.4.4",
+    "@commitlint/config-conventional": "^17.4.4",
+    "@defi-wonderland/smock": "^2.3.4",
+    "@ethersproject/abi": "^5.7.0",
+    "@ethersproject/abstract-signer": "^5.7.0",
+    "@ethersproject/bignumber": "^5.7.0",
+    "@ethersproject/bytes": "^5.7.0",
+    "@ethersproject/providers": "^5.7.2",
+    "@nomicfoundation/hardhat-chai-matchers": "^1.0.4",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.6",
+    "@nomicfoundation/hardhat-toolbox": "^2.0.0",
+    "@nomiclabs/hardhat-ethers": "^2.2.1",
+    "@nomiclabs/hardhat-etherscan": "^3.1.2",
+    "@openzeppelin/contracts": "^4.8.2",
+    "@openzeppelin/contracts-upgradeable": "^4.8.2",
+    "@openzeppelin/hardhat-upgrades": "^1.22.1",
+    "@semantic-release/changelog": "^6.0.2",
+    "@semantic-release/git": "^10.0.1",
+    "@trivago/prettier-plugin-sort-imports": "^4.0.0",
+    "@typechain/ethers-v5": "^10.1.1",
+    "@typechain/hardhat": "^6.1.4",
+    "@types/chai": "^4.3.4",
+    "@types/fs-extra": "^9.0.13",
+    "@types/mocha": "^10.0.0",
+    "@types/node": "^18.16.3",
+    "@typescript-eslint/eslint-plugin": "^5.44.0",
+    "@typescript-eslint/parser": "^5.44.0",
+    "@venusprotocol/oracle": "^1.6.11-dev.7",
+    "@venusprotocol/venus-protocol": "^0.7.0",
+    "bignumber.js": "^9.1.1",
+    "chai": "^4.3.7",
+    "commitizen": "^4.2.5",
+    "cross-env": "^7.0.3",
+    "cz-conventional-changelog": "^3.3.0",
+    "dotenv": "^16.0.3",
+    "eslint": "^8.28.0",
+    "eslint-config-prettier": "^8.5.0",
+    "ethers": "^5.7.2",
+    "fs-extra": "^10.1.0",
+    "hardhat": "^2.16.1",
+    "hardhat-dependency-compiler": "^1.1.3",
+    "hardhat-deploy": "^0.11.23",
+    "hardhat-docgen": "^1.3.0",
+    "hardhat-gas-reporter": "^1.0.9",
+    "husky": "^8.0.3",
+    "lint-staged": "^13.0.4",
+    "lodash": "^4.17.21",
+    "mocha": "^10.1.0",
+    "pinst": "^3.0.0",
+    "prettier": "^2.8.4",
+    "prettier-plugin-solidity": "^1.1.2",
+    "semantic-release": "^19.0.3",
+    "shx": "^0.3.4",
+    "solhint": "^3.4.0",
+    "solhint-plugin-prettier": "^0.0.5",
+    "solidity-coverage": "^0.8.4",
+    "solidity-docgen": "^0.6.0-beta.34",
+    "ts-generator": "^0.1.1",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.1.2",
+    "typechain": "^8.1.1",
+    "typescript": "^4.9.3"
+  },
+  "dependencies": {
+    "@venusprotocol/isolated-pools": "^0.1.0-develop.3"
+  }
+}