@venusprotocol/protocol-reserve 1.0.0-dev.2 → 1.0.0-dev.4

package/contracts/ProtocolReserve/ProtocolShareReserve.sol

@@ -3,6 +3,8 @@ 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 { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import { MaxLoopsLimitHelper } from "@venusprotocol/isolated-pools/contracts/MaxLoopsLimitHelper.sol";
 
 import { IProtocolShareReserve } from "../Interfaces/IProtocolShareReserve.sol";
 import { ComptrollerInterface } from "../Interfaces/ComptrollerInterface.sol";
@@ -14,13 +16,19 @@ import { IIncomeDestination } from "../Interfaces/IIncomeDestination.sol";
 error InvalidAddress();
 error UnsupportedAsset();
 error InvalidTotalPercentage();
-
-contract ProtocolShareReserve is AccessControlledV8, IProtocolShareReserve {
+error InvalidMaxLoopsLimit();
+
+contract ProtocolShareReserve is
+    AccessControlledV8,
+    ReentrancyGuardUpgradeable,
+    MaxLoopsLimitHelper,
+    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
+    /// The first schema is the default one
+    /// The second schema is for spread income from prime markets in core protocol
     enum Schema {
         DEFAULT,
         SPREAD_PRIME_CORE
@@ -77,9 +85,6 @@ contract ProtocolShareReserve is AccessControlledV8, IProtocolShareReserve {
         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,
@@ -127,85 +132,98 @@ contract ProtocolShareReserve is AccessControlledV8, IProtocolShareReserve {
     /**
      * @dev Initializes the deployer to owner.
      * @param _accessControlManager The address of ACM contract
+     * @param _loopsLimit Limit for the loops in the contract to avoid DOS
      */
-    function initialize(address _accessControlManager) external initializer {
+    function initialize(address _accessControlManager, uint256 _loopsLimit) external initializer {
         __AccessControlled_init(_accessControlManager);
+        __ReentrancyGuard_init();
+        _setMaxLoopsLimit(_loopsLimit);
     }
 
     /**
      * @dev Pool registry setter.
      * @param _poolRegistry Address of the pool registry
      */
-    function setPoolRegistry(address _poolRegistry) external {
-        _checkAccessAllowed("setPoolRegistry(address)");
+    function setPoolRegistry(address _poolRegistry) external onlyOwner {
         if (_poolRegistry == address(0)) revert InvalidAddress();
-        address oldPoolRegistry = poolRegistry;
+        emit PoolRegistryUpdated(poolRegistry, _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)");
+    function setPrime(address _prime) external onlyOwner {
         if (_prime == address(0)) revert InvalidAddress();
-        address oldPrime = prime;
+        emit PrimeUpdated(prime, _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)");
+    function addOrUpdateDistributionConfigs(DistributionConfig[] memory 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 (uint i = 0; i < configs.length; ++i) {
+        for (uint256 i = 0; i < configs.length; ) {
             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) {
+            for (uint256 j = 0; j < distributionTargets.length; ) {
                 DistributionConfig storage config = distributionTargets[j];
 
                 if (_config.schema == config.schema && config.destination == _config.destination) {
                     emit DistributionConfigUpdated(
-                        config.destination,
+                        _config.destination,
                         config.percentage,
                         _config.percentage,
-                        config.schema
+                        _config.schema
                     );
                     config.percentage = _config.percentage;
                     updated = true;
                     break;
                 }
+
+                unchecked {
+                    ++j;
+                }
             }
 
             if (!updated) {
                 distributionTargets.push(_config);
                 emit DistributionConfigAdded(_config.destination, _config.percentage, _config.schema);
             }
+
+            unchecked {
+                ++i;
+            }
         }
 
         _ensurePercentages();
+        _ensureMaxLoops(distributionTargets.length);
     }
 
     /**
      * @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 {
+    function releaseFunds(address comptroller, address[] memory assets) external nonReentrant {
         _accruePrimeInterest();
 
-        for (uint i = 0; i < assets.length; ++i) {
+        for (uint256 i = 0; i < assets.length; ) {
             _releaseFund(comptroller, assets[i]);
+
+            unchecked {
+                ++i;
+            }
         }
     }
 
@@ -222,12 +240,16 @@ contract ProtocolShareReserve is AccessControlledV8, IProtocolShareReserve {
         address destination,
         address asset
     ) external view returns (uint256) {
-        for (uint i = 0; i < distributionTargets.length; ++i) {
+        for (uint256 i = 0; i < distributionTargets.length; ) {
             DistributionConfig storage _config = distributionTargets[i];
             if (_config.schema == schema && _config.destination == destination) {
                 uint256 total = assetsReserves[comptroller][asset][schema];
                 return (total * _config.percentage) / MAX_PERCENT;
             }
+
+            unchecked {
+                ++i;
+            }
         }
     }
 
@@ -242,12 +264,13 @@ contract ProtocolShareReserve is AccessControlledV8, IProtocolShareReserve {
      * @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.
+     * @param incomeType type of income
      */
     function updateAssetsState(
         address comptroller,
         address asset,
         IncomeType incomeType
-    ) public override(IProtocolShareReserve) {
+    ) public override(IProtocolShareReserve) nonReentrant {
         if (!ComptrollerInterface(comptroller).isComptroller()) revert InvalidAddress();
         if (asset == address(0)) revert InvalidAddress();
         if (
@@ -277,10 +300,14 @@ contract ProtocolShareReserve is AccessControlledV8, IProtocolShareReserve {
      */
     function _accrueAndReleaseFundsToPrime() internal {
         address[] memory markets = IPrime(prime).allMarkets();
-        for (uint i = 0; i < markets.length; ++i) {
+        for (uint256 i = 0; i < markets.length; ) {
             address market = markets[i];
             IPrime(prime).accrueInterest(market);
             _releaseFund(CORE_POOL_COMPTROLLER, _getUnderlying(market));
+
+            unchecked {
+                ++i;
+            }
         }
     }
 
@@ -290,29 +317,40 @@ contract ProtocolShareReserve is AccessControlledV8, IProtocolShareReserve {
      */
     function _accruePrimeInterest() internal {
         address[] memory markets = IPrime(prime).allMarkets();
-        for (uint i = 0; i < markets.length; ++i) {
+        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)
+     * @param asset Asset address.
+     */
     function _releaseFund(address comptroller, address asset) internal {
         uint256 totalSchemas = uint256(type(Schema).max) + 1;
-        uint[] memory schemaBalances = new uint[](totalSchemas);
+        uint256[] memory schemaBalances = new uint256[](totalSchemas);
         uint256 totalBalance;
-
-        for (uint schemaValue; schemaValue < totalSchemas; ++schemaValue) {
+        for (uint256 schemaValue; schemaValue < totalSchemas; ) {
             schemaBalances[schemaValue] = assetsReserves[comptroller][asset][Schema(schemaValue)];
             totalBalance += schemaBalances[schemaValue];
+
+            unchecked {
+                ++schemaValue;
+            }
         }
 
         if (totalBalance == 0) {
             return;
         }
 
-        uint[] memory totalTransferAmounts = new uint[](totalSchemas);
-
-        for (uint i = 0; i < distributionTargets.length; ++i) {
+        uint256[] memory totalTransferAmounts = new uint256[](totalSchemas);
+        for (uint256 i = 0; i < distributionTargets.length; ) {
             DistributionConfig memory _config = distributionTargets[i];
 
             uint256 transferAmount = (schemaBalances[uint256(_config.schema)] * _config.percentage) / MAX_PERCENT;
@@ -322,10 +360,14 @@ contract ProtocolShareReserve is AccessControlledV8, IProtocolShareReserve {
             IIncomeDestination(_config.destination).updateAssetsState(comptroller, asset);
 
             emit AssetReleased(_config.destination, asset, _config.schema, _config.percentage, transferAmount);
+
+            unchecked {
+                ++i;
+            }
         }
 
-        uint[] memory newSchemaBalances = new uint[](totalSchemas);
-        for (uint schemaValue = 0; schemaValue < totalSchemas; ++schemaValue) {
+        uint256[] memory newSchemaBalances = new uint256[](totalSchemas);
+        for (uint256 schemaValue = 0; schemaValue < totalSchemas; ) {
             newSchemaBalances[schemaValue] = schemaBalances[schemaValue] - totalTransferAmounts[schemaValue];
             assetsReserves[comptroller][asset][Schema(schemaValue)] = newSchemaBalances[schemaValue];
             totalAssetReserve[asset] = totalAssetReserve[asset] - totalTransferAmounts[schemaValue];
@@ -337,9 +379,20 @@ contract ProtocolShareReserve is AccessControlledV8, IProtocolShareReserve {
                 schemaBalances[schemaValue],
                 newSchemaBalances[schemaValue]
             );
+
+            unchecked {
+                ++schemaValue;
+            }
         }
     }
 
+    /**
+     * @dev Returns the schema based on comptroller, asset and income type
+     * @param comptroller  Comptroller address(pool)
+     * @param asset Asset address.
+     * @param incomeType type of income
+     * @return schema schema for distribution
+     */
     function getSchema(
         address comptroller,
         address asset,
@@ -355,19 +408,31 @@ contract ProtocolShareReserve is AccessControlledV8, IProtocolShareReserve {
 
     function _ensurePercentages() internal view {
         uint256 totalSchemas = uint256(type(Schema).max) + 1;
-        uint[] memory totalPercentages = new uint[](totalSchemas);
+        uint256[] memory totalPercentages = new uint256[](totalSchemas);
 
-        for (uint i = 0; i < distributionTargets.length; ++i) {
+        for (uint256 i = 0; i < distributionTargets.length; ) {
             DistributionConfig memory config = distributionTargets[i];
             totalPercentages[uint256(config.schema)] += config.percentage;
-        }
 
-        for (uint schemaValue = 0; schemaValue <= totalSchemas - 1; ++schemaValue) {
+            unchecked {
+                ++i;
+            }
+        }
+        for (uint256 schemaValue = 0; schemaValue < totalSchemas; ) {
             if (totalPercentages[schemaValue] != MAX_PERCENT && totalPercentages[schemaValue] != 0)
                 revert InvalidTotalPercentage();
+
+            unchecked {
+                ++schemaValue;
+            }
         }
     }
 
+    /**
+     * @dev Returns the underlying asset address for the vToken
+     * @param vToken vToken address
+     * @return asset address of asset
+     */
     function _getUnderlying(address vToken) internal view returns (address) {
         if (vToken == vBNB) {
             return WBNB;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@venusprotocol/protocol-reserve",
   "description": "",
-  "version": "1.0.0-dev.2",
+  "version": "1.0.0-dev.4",
   "author": "",
   "engines": {
     "node": ">=18.0.0"
@@ -109,5 +109,8 @@
     "tsconfig-paths": "^4.1.2",
     "typechain": "^8.1.1",
     "typescript": "^4.9.3"
+  },
+  "dependencies": {
+    "@venusprotocol/isolated-pools": "^1.3.0"
   }
 }

package/typechain/@openzeppelin/contracts-upgradeable/index.ts

@@ -5,6 +5,7 @@
 /* eslint-disable */
 import type * as access from "./access";
 import type * as proxy from "./proxy";
+import type * as security from "./security";
 import type * as token from "./token";
 import type * as utils from "./utils";
 
@@ -12,6 +13,8 @@ export type { access };
 
 export type { proxy };
 
+export type { security };
+
 export type { token };
 
 export type { utils };

package/typechain/@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.ts

@@ -0,0 +1,72 @@
+/* Autogenerated file. Do not edit manually. */
+
+/* tslint:disable */
+
+/* eslint-disable */
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+import type { EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { BaseContract, Signer, utils } from "ethers";
+
+export interface ReentrancyGuardUpgradeableInterface extends utils.Interface {
+  functions: {};
+
+  events: {
+    "Initialized(uint8)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+
+export interface InitializedEventObject {
+  version: number;
+}
+export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
+
+export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+
+export interface ReentrancyGuardUpgradeable extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ReentrancyGuardUpgradeableInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {};
+
+  callStatic: {};
+
+  filters: {
+    "Initialized(uint8)"(version?: null): InitializedEventFilter;
+    Initialized(version?: null): InitializedEventFilter;
+  };
+
+  estimateGas: {};
+
+  populateTransaction: {};
+}

package/typechain/@openzeppelin/contracts-upgradeable/security/index.ts

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { ReentrancyGuardUpgradeable } from "./ReentrancyGuardUpgradeable";

package/typechain/@venusprotocol/index.ts

@@ -4,5 +4,8 @@
 
 /* eslint-disable */
 import type * as governanceContracts from "./governance-contracts";
+import type * as isolatedPools from "./isolated-pools";
 
 export type { governanceContracts };
+
+export type { isolatedPools };

package/typechain/@venusprotocol/isolated-pools/contracts/MaxLoopsLimitHelper.ts

@@ -0,0 +1,119 @@
+/* Autogenerated file. Do not edit manually. */
+
+/* tslint:disable */
+
+/* eslint-disable */
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+  PromiseOrValue,
+} from "../../../common";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+
+export interface MaxLoopsLimitHelperInterface extends utils.Interface {
+  functions: {
+    "maxLoopsLimit()": FunctionFragment;
+  };
+
+  getFunction(nameOrSignatureOrTopic: "maxLoopsLimit"): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "maxLoopsLimit",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "maxLoopsLimit",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "MaxLoopsLimitUpdated(uint256,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "MaxLoopsLimitUpdated"): EventFragment;
+}
+
+export interface MaxLoopsLimitUpdatedEventObject {
+  oldMaxLoopsLimit: BigNumber;
+  newmaxLoopsLimit: BigNumber;
+}
+export type MaxLoopsLimitUpdatedEvent = TypedEvent<
+  [BigNumber, BigNumber],
+  MaxLoopsLimitUpdatedEventObject
+>;
+
+export type MaxLoopsLimitUpdatedEventFilter =
+  TypedEventFilter<MaxLoopsLimitUpdatedEvent>;
+
+export interface MaxLoopsLimitHelper extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: MaxLoopsLimitHelperInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    maxLoopsLimit(overrides?: CallOverrides): Promise<[BigNumber]>;
+  };
+
+  maxLoopsLimit(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    maxLoopsLimit(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {
+    "MaxLoopsLimitUpdated(uint256,uint256)"(
+      oldMaxLoopsLimit?: null,
+      newmaxLoopsLimit?: null
+    ): MaxLoopsLimitUpdatedEventFilter;
+    MaxLoopsLimitUpdated(
+      oldMaxLoopsLimit?: null,
+      newmaxLoopsLimit?: null
+    ): MaxLoopsLimitUpdatedEventFilter;
+  };
+
+  estimateGas: {
+    maxLoopsLimit(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    maxLoopsLimit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}

package/typechain/@venusprotocol/isolated-pools/contracts/index.ts

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { MaxLoopsLimitHelper } from "./MaxLoopsLimitHelper";

package/typechain/@venusprotocol/isolated-pools/index.ts

@@ -0,0 +1,8 @@
+/* Autogenerated file. Do not edit manually. */
+
+/* tslint:disable */
+
+/* eslint-disable */
+import type * as contracts from "./contracts";
+
+export type { contracts };