@harvest-finance/harvest-strategy-arbitrum 0.0.1-security → 1.0.0

package/contracts/base/interface/ipor/FusesLib.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {FuseStorageLib} from "./FuseStorageLib.sol";
+import {PlasmaVaultStorageLib} from "./PlasmaVaultStorageLib.sol";
+
+/// @title Fuses Library responsible for managing fuses in the Plasma Vault
+library FusesLib {
+    using Address for address;
+
+    event FuseAdded(address fuse);
+    event FuseRemoved(address fuse);
+    event BalanceFuseAdded(uint256 marketId, address fuse);
+    event BalanceFuseRemoved(uint256 marketId, address fuse);
+
+    error FuseAlreadyExists();
+    error FuseDoesNotExist();
+    error FuseUnsupported(address fuse);
+    error BalanceFuseAlreadyExists(uint256 marketId, address fuse);
+    error BalanceFuseDoesNotExist(uint256 marketId, address fuse);
+    error BalanceFuseNotReadyToRemove(uint256 marketId, address fuse, uint256 currentBalance);
+
+    /// @notice Checks if the fuse is supported
+    /// @param fuse_ The address of the fuse
+    /// @return true if the fuse is supported
+    function isFuseSupported(address fuse_) internal view returns (bool) {
+        return FuseStorageLib.getFuses().value[fuse_] != 0;
+    }
+
+    /// @notice Checks if the balance fuse is supported
+    /// @param marketId_ The market id
+    /// @param fuse_ The address of the fuse
+    /// @return true if the balance fuse is supported
+    function isBalanceFuseSupported(uint256 marketId_, address fuse_) internal view returns (bool) {
+        return PlasmaVaultStorageLib.getBalanceFuses().value[marketId_] == fuse_;
+    }
+
+    /// @notice Gets the balance fuse for the market
+    /// @param marketId_ The market id
+    /// @return The address of the balance fuse
+    function getBalanceFuse(uint256 marketId_) internal view returns (address) {
+        return PlasmaVaultStorageLib.getBalanceFuses().value[marketId_];
+    }
+
+    /// @notice Gets the array of stored and supported Fuses
+    /// @return The array of Fuses
+    function getFusesArray() internal view returns (address[] memory) {
+        return FuseStorageLib.getFusesArray().value;
+    }
+
+    /// @notice Gets the index of the fuse in the fuses array
+    /// @param fuse_ The address of the fuse
+    /// @return The index of the fuse in the fuses array stored in Plasma Vault
+    function getFuseArrayIndex(address fuse_) internal view returns (uint256) {
+        return FuseStorageLib.getFuses().value[fuse_];
+    }
+
+    /// @notice Adds a fuse to supported fuses
+    /// @param fuse_ The address of the fuse
+    function addFuse(address fuse_) internal {
+        FuseStorageLib.Fuses storage fuses = FuseStorageLib.getFuses();
+
+        uint256 keyIndexValue = fuses.value[fuse_];
+
+        if (keyIndexValue != 0) {
+            revert FuseAlreadyExists();
+        }
+
+        uint256 newLastFuseId = FuseStorageLib.getFusesArray().value.length + 1;
+
+        /// @dev for balance fuses, value is a index + 1 in the fusesArray
+        fuses.value[fuse_] = newLastFuseId;
+
+        FuseStorageLib.getFusesArray().value.push(fuse_);
+
+        emit FuseAdded(fuse_);
+    }
+
+    /// @notice Removes a fuse from supported fuses
+    /// @param fuse_ The address of the fuse
+    function removeFuse(address fuse_) internal {
+        FuseStorageLib.Fuses storage fuses = FuseStorageLib.getFuses();
+
+        uint256 indexToRemove = fuses.value[fuse_];
+
+        if (indexToRemove == 0) {
+            revert FuseDoesNotExist();
+        }
+
+        address lastKeyInArray = FuseStorageLib.getFusesArray().value[FuseStorageLib.getFusesArray().value.length - 1];
+
+        fuses.value[lastKeyInArray] = indexToRemove;
+
+        fuses.value[fuse_] = 0;
+
+        /// @dev balanceFuses mapping contains values as index + 1
+        FuseStorageLib.getFusesArray().value[indexToRemove - 1] = lastKeyInArray;
+
+        FuseStorageLib.getFusesArray().value.pop();
+
+        emit FuseRemoved(fuse_);
+    }
+
+    /// @notice Adds a balance fuse to the market
+    /// @param marketId_ The market id
+    /// @param fuse_ The address of the fuse
+    /// @dev Every market can have one dedicated balance fuse
+    function addBalanceFuse(uint256 marketId_, address fuse_) internal {
+        address currentFuse = PlasmaVaultStorageLib.getBalanceFuses().value[marketId_];
+
+        if (currentFuse == fuse_) {
+            revert BalanceFuseAlreadyExists(marketId_, fuse_);
+        }
+
+        PlasmaVaultStorageLib.getBalanceFuses().value[marketId_] = fuse_;
+
+        emit BalanceFuseAdded(marketId_, fuse_);
+    }
+
+    /// @notice Removes a balance fuse from the market
+    /// @param marketId_ The market id
+    /// @param fuse_ The address of the fuse
+    /// @dev Every market can have one dedicated balance fuse
+    function removeBalanceFuse(uint256 marketId_, address fuse_) internal {
+        address currentBalanceFuse = PlasmaVaultStorageLib.getBalanceFuses().value[marketId_];
+
+        if (currentBalanceFuse != fuse_) {
+            revert BalanceFuseDoesNotExist(marketId_, fuse_);
+        }
+
+        uint256 wadBalanceAmountInUSD = abi.decode(
+            currentBalanceFuse.functionDelegateCall(abi.encodeWithSignature("balanceOf()")),
+            (uint256)
+        );
+
+        if (wadBalanceAmountInUSD > calculateAllowedDustInBalanceFuse()) {
+            revert BalanceFuseNotReadyToRemove(marketId_, fuse_, wadBalanceAmountInUSD);
+        }
+
+        PlasmaVaultStorageLib.getBalanceFuses().value[marketId_] = address(0);
+
+        emit BalanceFuseRemoved(marketId_, fuse_);
+    }
+
+    function calculateAllowedDustInBalanceFuse() private view returns (uint256) {
+        return 10 ** (PlasmaVaultStorageLib.getERC4626Storage().underlyingDecimals / 2);
+    }
+}

package/contracts/base/interface/ipor/IFuseCommon.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+/// @title Interface for Fuses Common functions
+interface IFuseCommon {
+    /// @notice Market ID associated with the Fuse
+    //solhint-disable-next-line
+    function MARKET_ID() external view returns (uint256);
+}

package/contracts/base/interface/ipor/IFuseInstantWithdraw.sol

@@ -0,0 +1,14 @@
+
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+/// @title Interface for Fuses - instant withdraw from the market
+interface IFuseInstantWithdraw {
+    /// @notice Instant withdraw assets from the external market
+    /// @param params - array of parameters
+    /// @dev - Notice! Always first param is the asset value in underlying
+    /// @dev params[0] is asset value in underlying, next params are specific for the Fuse,
+    /// @dev params[1] - could be address of the asset, address of the external vault or address of the market or any other specific param for the Fuse
+    /// @dev params[n] - any other specific param for a given the Fuse
+    function instantWithdraw(bytes32[] calldata params) external;
+}

package/contracts/base/interface/ipor/IMarketBalanceFuse.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+/// @title Interface for Fuses responsible for providing the balance of the PlasmaVault address in the market in USD
+interface IMarketBalanceFuse {
+    /// @notice Get the balance of the Plasma Vault in the market in USD
+    /// @dev Notice! Every Balance Fuse have to implement this exact function signature, because it is used by Plasma Vault engine
+    /// @return balanceValue The balance of the Plasma Vault in the market in USD, represented in 18 decimals
+    function balanceOf() external returns (uint256 balanceValue);
+}

package/contracts/base/interface/ipor/IPriceOracleMiddleware.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+/// @title Interface to an aggregator of price feeds for assets, responsible for providing the prices of assets in a given quote currency
+interface IPriceOracleMiddleware {
+    error EmptyArrayNotSupported();
+    error ArrayLengthMismatch();
+    error UnexpectedPriceResult();
+    error UnsupportedAsset();
+    error ZeroAddress(string variableName);
+    error WrongDecimals();
+    error WrongDecimalsInPriceFeed();
+
+    /// @notice Returns the price of the given asset in given decimals
+    /// @return assetPrice price in QUOTE_CURRENCY of the asset
+    /// @return decimals number of decimals of the asset price
+    function getAssetPrice(address asset) external view returns (uint256 assetPrice, uint256 decimals);
+
+    /// @notice Returns the prices of the given assets in given decimals
+    /// @return assetPrices prices in QUOTE_CURRENCY of the assets represented in given decimals
+    /// @return decimalsList number of decimals of the asset prices
+    function getAssetsPrices(
+        address[] calldata assets
+    ) external view returns (uint256[] memory assetPrices, uint256[] memory decimalsList);
+
+    /// @notice Returns address of source of the asset price - it could be IPOR Price Feed or Chainlink Aggregator or any other source of price for a given asset
+    /// @param asset address of the asset
+    /// @return address of the source of the asset price
+    function getSourceOfAssetPrice(address asset) external view returns (address);
+
+    /// @notice Sets the sources of the asset prices
+    /// @param assets array of addresses of the assets
+    function setAssetsPricesSources(address[] calldata assets, address[] calldata sources) external;
+
+    /// @notice Returns the address of the quote currency to which all the prices are relative, in IPOR Fusion it is the USD
+    //solhint-disable-next-line
+    function QUOTE_CURRENCY() external view returns (address);
+
+    /// @notice Returns the number of decimals of the quote currency, by default it is 8 for USD, but can be different for other types of Price Oracles Middlewares
+    //solhint-disable-next-line
+    function QUOTE_CURRENCY_DECIMALS() external view returns (uint256);
+}

package/contracts/base/interface/ipor/IporMath.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+/// @title Ipor Math library with math functions
+library IporMath {
+    uint256 private constant WAD_DECIMALS = 18;
+    uint256 public constant BASIS_OF_POWER = 10;
+
+    /// @dev The index of the most significant bit in a 256-bit signed integer
+    uint256 private constant MSB = 255;
+
+    function min(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a < b ? a : b;
+    }
+
+    /// @notice Converts the value to WAD decimals, WAD decimals are 18
+    /// @param value The value to convert
+    /// @param assetDecimals The decimals of the asset
+    /// @return The value in WAD decimals
+    function convertToWad(uint256 value, uint256 assetDecimals) internal pure returns (uint256) {
+        if (value > 0) {
+            if (assetDecimals == WAD_DECIMALS) {
+                return value;
+            } else if (assetDecimals > WAD_DECIMALS) {
+                return division(value, BASIS_OF_POWER ** (assetDecimals - WAD_DECIMALS));
+            } else {
+                return value * BASIS_OF_POWER ** (WAD_DECIMALS - assetDecimals);
+            }
+        } else {
+            return value;
+        }
+    }
+
+    /// @notice Converts the value to WAD decimals, WAD decimals are 18
+    /// @param value The value to convert
+    /// @param assetDecimals The decimals of the asset
+    /// @return The value in WAD decimals
+    function convertWadToAssetDecimals(uint256 value, uint256 assetDecimals) internal pure returns (uint256) {
+        if (assetDecimals == WAD_DECIMALS) {
+            return value;
+        } else if (assetDecimals > WAD_DECIMALS) {
+            return value * WAD_DECIMALS ** (assetDecimals - WAD_DECIMALS);
+        } else {
+            return division(value, BASIS_OF_POWER ** (WAD_DECIMALS - assetDecimals));
+        }
+    }
+
+    /// @notice Converts the int value to WAD decimals, WAD decimals are 18
+    /// @param value The int value to convert
+    /// @param assetDecimals The decimals of the asset
+    /// @return The value in WAD decimals, int
+    function convertToWadInt(int256 value, uint256 assetDecimals) internal pure returns (int256) {
+        if (value == 0) {
+            return 0;
+        }
+        if (assetDecimals == WAD_DECIMALS) {
+            return value;
+        } else if (assetDecimals > WAD_DECIMALS) {
+            return divisionInt(value, int256(BASIS_OF_POWER ** (assetDecimals - WAD_DECIMALS)));
+        } else {
+            return value * int256(BASIS_OF_POWER ** (WAD_DECIMALS - assetDecimals));
+        }
+    }
+
+    /// @notice Divides two int256 numbers and rounds the result to the nearest integer
+    /// @param x The numerator
+    /// @param y The denominator
+    /// @return z The result of the division
+    function divisionInt(int256 x, int256 y) internal pure returns (int256 z) {
+        uint256 absX = uint256(x < 0 ? -x : x);
+        uint256 absY = uint256(y < 0 ? -y : y);
+
+        // Use bitwise XOR to get the sign on MBS bit then shift to LSB
+        // sign == 0x0000...0000 ==  0 if the number is non-negative
+        // sign == 0xFFFF...FFFF == -1 if the number is negative
+        int256 sign = (x ^ y) >> MSB;
+
+        uint256 divAbs;
+        uint256 remainder;
+
+        unchecked {
+            divAbs = absX / absY;
+            remainder = absX % absY;
+        }
+        // Check if we need to round
+        if (sign < 0) {
+            // remainder << 1 left shift is equivalent to multiplying by 2
+            if (remainder << 1 > absY) {
+                ++divAbs;
+            }
+        } else {
+            if (remainder << 1 >= absY) {
+                ++divAbs;
+            }
+        }
+
+        // (sign | 1) is cheaper than (sign < 0) ? -1 : 1;
+        unchecked {
+            z = int256(divAbs) * (sign | 1);
+        }
+    }
+
+    /// @notice Divides two uint256 numbers and rounds the result to the nearest integer
+    /// @param x The numerator
+    /// @param y The denominator
+    /// @return z The result of the division
+    function division(uint256 x, uint256 y) internal pure returns (uint256 z) {
+        z = x / y;
+    }
+}

package/contracts/base/interface/ipor/PlasmaVaultConfigLib.sol

@@ -0,0 +1,106 @@
+
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+import {PlasmaVaultStorageLib} from "./PlasmaVaultStorageLib.sol";
+
+/// @title Plasma Vault Configuration Library responsible for managing the configuration of the Plasma Vault
+library PlasmaVaultConfigLib {
+    event MarketSubstratesGranted(uint256 marketId, bytes32[] substrates);
+
+    /// @notice Checks if the substrate treated as an asset is granted for the market
+    /// @param marketId_ The market id
+    /// @param substrateAsAsset The address of the substrate treated as an asset
+    /// @return true if the substrate is granted for the market
+    /// @dev Substrates are stored as bytes32
+    function isSubstrateAsAssetGranted(uint256 marketId_, address substrateAsAsset) internal view returns (bool) {
+        PlasmaVaultStorageLib.MarketSubstratesStruct storage marketSubstrates = _getMarketSubstrates(marketId_);
+        return marketSubstrates.substrateAllowances[addressToBytes32(substrateAsAsset)] == 1;
+    }
+
+    /// @notice Checks if the substrate is granted for the market
+    /// @param marketId_ The market id
+    /// @param substrate_ The bytes32 of the substrate
+    /// @return true if the substrate is granted for the market
+    /// @dev Substrates can be asset, vault, or any other params
+    function isMarketSubstrateGranted(uint256 marketId_, bytes32 substrate_) internal view returns (bool) {
+        PlasmaVaultStorageLib.MarketSubstratesStruct storage marketSubstrates = _getMarketSubstrates(marketId_);
+        return marketSubstrates.substrateAllowances[substrate_] == 1;
+    }
+
+    /// @notice Gets the market substrates for the market
+    /// @param marketId_ The market id
+    /// @return The array of substrates
+    function getMarketSubstrates(uint256 marketId_) internal view returns (bytes32[] memory) {
+        return _getMarketSubstrates(marketId_).substrates;
+    }
+
+    /// @notice Grants the substrates for the market
+    /// @param marketId_ The market id
+    /// @param substrates_ The array of substrates
+    /// @dev Substrates can be asset, vault, or any other params, only granted substrates can be used by Fuses in interaction with a given market and external protocols.
+    function grantMarketSubstrates(uint256 marketId_, bytes32[] memory substrates_) internal {
+        PlasmaVaultStorageLib.MarketSubstratesStruct storage marketSubstrates = _getMarketSubstrates(marketId_);
+
+        _revokeMarketSubstrates(marketSubstrates);
+
+        bytes32[] memory list = new bytes32[](substrates_.length);
+        for (uint256 i; i < substrates_.length; ++i) {
+            marketSubstrates.substrateAllowances[substrates_[i]] = 1;
+            list[i] = substrates_[i];
+        }
+
+        marketSubstrates.substrates = list;
+
+        emit MarketSubstratesGranted(marketId_, substrates_);
+    }
+
+    /// @notice Grants the substrates treated as assets for the market
+    /// @param marketId_ The market id
+    /// @param substratesAsAssets_ The array of substrates treated as assets
+    /// @dev Substrates are stored as bytes32, only granted substrates can be used by Fuses in interaction with a given market and external protocols.
+    function grantSubstratesAsAssetsToMarket(uint256 marketId_, address[] calldata substratesAsAssets_) internal {
+        PlasmaVaultStorageLib.MarketSubstratesStruct storage marketSubstrates = _getMarketSubstrates(marketId_);
+
+        _revokeMarketSubstrates(marketSubstrates);
+
+        bytes32[] memory list = new bytes32[](substratesAsAssets_.length);
+
+        for (uint256 i; i < substratesAsAssets_.length; ++i) {
+            marketSubstrates.substrateAllowances[addressToBytes32(substratesAsAssets_[i])] = 1;
+            list[i] = addressToBytes32(substratesAsAssets_[i]);
+        }
+
+        marketSubstrates.substrates = list;
+
+        emit MarketSubstratesGranted(marketId_, list);
+    }
+
+    function _revokeMarketSubstrates(PlasmaVaultStorageLib.MarketSubstratesStruct storage marketSubstrates) private {
+        uint256 length = marketSubstrates.substrates.length;
+        for (uint256 i; i < length; ++i) {
+            marketSubstrates.substrateAllowances[marketSubstrates.substrates[i]] = 0;
+        }
+    }
+
+    /// @notice Converts the substrate as bytes32 to value address
+    /// @param substrate_ The bytes32 of the substrate
+    /// @return The address of the substrate
+    function bytes32ToAddress(bytes32 substrate_) internal pure returns (address) {
+        return address(uint160(uint256(substrate_)));
+    }
+
+    /// @notice Converts the address to bytes32
+    /// @param address_ The address of the substrate
+    /// @return The bytes32 of the substrate
+    function addressToBytes32(address address_) internal pure returns (bytes32) {
+        return bytes32(uint256(uint160(address_)));
+    }
+
+    /// @notice Gets the market substrates configuration for a specific market
+    function _getMarketSubstrates(
+        uint256 marketId_
+    ) private view returns (PlasmaVaultStorageLib.MarketSubstratesStruct storage) {
+        return PlasmaVaultStorageLib.getMarketSubstrates().value[marketId_];
+    }
+}