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

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

@@ -0,0 +1,293 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import {Errors} from "./Errors.sol";
+import {PlasmaVaultStorageLib} from "./PlasmaVaultStorageLib.sol";
+import {FusesLib} from "./FusesLib.sol";
+
+/// @notice Technical struct used to pass parameters in the `updateInstantWithdrawalFuses` function
+struct InstantWithdrawalFusesParamsStruct {
+    /// @notice The address of the fuse
+    address fuse;
+    /// @notice The parameters of the fuse, first element is an amount, second element is an address of the asset or a market id or other substrate specific for the fuse
+    /// @dev Notice! Always first param is the asset value in underlying, next params are specific for the Fuse
+    bytes32[] params;
+}
+
+/// @title Plasma Vault Library responsible for managing the Plasma Vault
+library PlasmaVaultLib {
+    using SafeCast for uint256;
+    using SafeCast for int256;
+
+    /// @dev Hard CAP for the performance fee in percentage - 50%
+    uint256 public constant PERFORMANCE_MAX_FEE_IN_PERCENTAGE = 5000;
+
+    /// @dev Hard CAP for the management fee in percentage - 5%
+    uint256 public constant MANAGEMENT_MAX_FEE_IN_PERCENTAGE = 500;
+
+    /// @dev The offset for the underlying asset decimals in the Plasma Vault
+    uint8 public constant DECIMALS_OFFSET = 2;
+
+    error InvalidPerformanceFee(uint256 feeInPercentage);
+    error InvalidManagementFee(uint256 feeInPercentage);
+
+    event InstantWithdrawalFusesConfigured(InstantWithdrawalFusesParamsStruct[] fuses);
+    event PriceOracleMiddlewareChanged(address newPriceOracleMiddleware);
+    event PerformanceFeeDataConfigured(address feeAccount, uint256 feeInPercentage);
+    event ManagementFeeDataConfigured(address feeAccount, uint256 feeInPercentage);
+    event RewardsClaimManagerAddressChanged(address newRewardsClaimManagerAddress);
+    event DependencyBalanceGraphChanged(uint256 marketId, uint256[] newDependenceGraph);
+    event WithdrawManagerChanged(address newWithdrawManager);
+
+    /// @notice Gets the total assets in the vault for all markets
+    /// @return The total assets in the vault for all markets, represented in decimals of the underlying asset
+    //solhint-disable-next-line
+    function getTotalAssetsInAllMarkets() internal view returns (uint256) {
+        return PlasmaVaultStorageLib.getTotalAssets().value;
+    }
+
+    /// @notice Gets the total assets in the vault for a specific market
+    /// @param marketId_ The market id
+    /// @return The total assets in the vault for the market, represented in decimals of the underlying asset
+    //solhint-disable-next-line
+    function getTotalAssetsInMarket(uint256 marketId_) internal view returns (uint256) {
+        return PlasmaVaultStorageLib.getMarketTotalAssets().value[marketId_];
+    }
+
+    /// @notice Gets the dependency balance graph for a specific market
+    /// @param marketId_ The market id
+    /// @return The dependency balance graph for the market
+    /// @dev The dependency balance graph is used to update appropriate balance markets when Plasma Vault interact with a given marketId_
+    function getDependencyBalanceGraph(uint256 marketId_) internal view returns (uint256[] memory) {
+        return PlasmaVaultStorageLib.getDependencyBalanceGraph().dependencyGraph[marketId_];
+    }
+
+    /// @notice Updates the dependency balance graph for a specific market
+    /// @param marketId_ The market id
+    /// @param newDependenceGraph_ The new dependency balance graph for the market
+    function updateDependencyBalanceGraph(uint256 marketId_, uint256[] memory newDependenceGraph_) internal {
+        PlasmaVaultStorageLib.getDependencyBalanceGraph().dependencyGraph[marketId_] = newDependenceGraph_;
+        emit DependencyBalanceGraphChanged(marketId_, newDependenceGraph_);
+    }
+
+    /// @notice Adds an amount to the total assets in the Plasma Vault for all markets
+    /// @param amount_ The amount to add, represented in decimals of the underlying asset
+    function addToTotalAssetsInAllMarkets(int256 amount_) internal {
+        if (amount_ < 0) {
+            PlasmaVaultStorageLib.getTotalAssets().value -= (-amount_).toUint256();
+        } else {
+            PlasmaVaultStorageLib.getTotalAssets().value += amount_.toUint256();
+        }
+    }
+
+    /// @notice Updates the total assets in the Plasma Vault for a specific market
+    /// @param marketId_ The market id
+    /// @param newTotalAssetsInUnderlying_ The new total assets in the vault for the market, represented in decimals of the underlying asset
+    /// @return deltaInUnderlying The difference between the old and the new total assets in the vault for the market
+    function updateTotalAssetsInMarket(
+        uint256 marketId_,
+        uint256 newTotalAssetsInUnderlying_
+    ) internal returns (int256 deltaInUnderlying) {
+        uint256 oldTotalAssetsInUnderlying = PlasmaVaultStorageLib.getMarketTotalAssets().value[marketId_];
+        PlasmaVaultStorageLib.getMarketTotalAssets().value[marketId_] = newTotalAssetsInUnderlying_;
+        deltaInUnderlying = newTotalAssetsInUnderlying_.toInt256() - oldTotalAssetsInUnderlying.toInt256();
+    }
+
+    /// @notice Gets the management fee data
+    /// @return managementFeeData The management fee data, like the fee manager and the fee in percentage
+    //solhint-disable-next-line
+    function getManagementFeeData()
+        internal
+        view
+        returns (PlasmaVaultStorageLib.ManagementFeeData memory managementFeeData)
+    {
+        return PlasmaVaultStorageLib.getManagementFeeData();
+    }
+
+    /// @notice Configures the management fee data like the fee manager and the fee in percentage
+    /// @param feeAccount_ The address of the fee manager responsible for managing the management fee
+    /// @param feeInPercentage_ The fee in percentage, represented in 2 decimals, example: 100% = 10000, 1% = 100, 0.01% = 1
+    function configureManagementFee(address feeAccount_, uint256 feeInPercentage_) internal {
+        if (feeAccount_ == address(0)) {
+            revert Errors.WrongAddress();
+        }
+        if (feeInPercentage_ > MANAGEMENT_MAX_FEE_IN_PERCENTAGE) {
+            revert InvalidManagementFee(feeInPercentage_);
+        }
+
+        PlasmaVaultStorageLib.ManagementFeeData storage managementFeeData = PlasmaVaultStorageLib
+            .getManagementFeeData();
+
+        managementFeeData.feeAccount = feeAccount_;
+        managementFeeData.feeInPercentage = feeInPercentage_.toUint16();
+
+        emit ManagementFeeDataConfigured(feeAccount_, feeInPercentage_);
+    }
+
+    /// @notice Gets the performance fee data
+    /// @return performanceFeeData The performance fee data, like the fee manager and the fee in percentage
+    //solhint-disable-next-line
+    function getPerformanceFeeData()
+        internal
+        view
+        returns (PlasmaVaultStorageLib.PerformanceFeeData memory performanceFeeData)
+    {
+        return PlasmaVaultStorageLib.getPerformanceFeeData();
+    }
+
+    /// @notice Configures the performance fee data like the fee manager and the fee in percentage
+    /// @param feeAccount_ The address of the fee manager responsible for managing the performance fee
+    /// @param feeInPercentage_ The fee in percentage, represented in 2 decimals, example: 100% = 10000, 1% = 100, 0.01% = 1
+    function configurePerformanceFee(address feeAccount_, uint256 feeInPercentage_) internal {
+        if (feeAccount_ == address(0)) {
+            revert Errors.WrongAddress();
+        }
+        if (feeInPercentage_ > PERFORMANCE_MAX_FEE_IN_PERCENTAGE) {
+            revert InvalidPerformanceFee(feeInPercentage_);
+        }
+
+        PlasmaVaultStorageLib.PerformanceFeeData storage performanceFeeData = PlasmaVaultStorageLib
+            .getPerformanceFeeData();
+
+        performanceFeeData.feeAccount = feeAccount_;
+        performanceFeeData.feeInPercentage = feeInPercentage_.toUint16();
+
+        emit PerformanceFeeDataConfigured(feeAccount_, feeInPercentage_);
+    }
+
+    /// @notice Updates the management fee data with the current timestamp
+    /// @dev lastUpdateTimestamp is used to calculate unrealized management fees
+    function updateManagementFeeData() internal {
+        PlasmaVaultStorageLib.ManagementFeeData storage feeData = PlasmaVaultStorageLib.getManagementFeeData();
+        feeData.lastUpdateTimestamp = block.timestamp.toUint32();
+    }
+
+    /// @notice Gets instant withdrawal fuses
+    /// @return The instant withdrawal fuses, the order of the fuses is important
+    function getInstantWithdrawalFuses() internal view returns (address[] memory) {
+        return PlasmaVaultStorageLib.getInstantWithdrawalFusesArray().value;
+    }
+
+    /// @notice Gets the instant withdrawal fuses parameters for a specific fuse
+    /// @param fuse_ The fuse address
+    /// @param index_ The index of the Fuse in the fuses array
+    /// @return The instant withdrawal fuses parameters
+    function getInstantWithdrawalFusesParams(address fuse_, uint256 index_) internal view returns (bytes32[] memory) {
+        return
+            PlasmaVaultStorageLib.getInstantWithdrawalFusesParams().value[keccak256(abi.encodePacked(fuse_, index_))];
+    }
+
+    /// @notice Configures order of the instant withdrawal fuses. Order of the fuse is important, as it will be used in the same order during the instant withdrawal process
+    /// @param fuses_ The fuses to configure
+    /// @dev Order of the fuses is important, the same fuse can be used multiple times with different parameters (for example different assets, markets or any other substrate specific for the fuse)
+    function configureInstantWithdrawalFuses(InstantWithdrawalFusesParamsStruct[] calldata fuses_) internal {
+        address[] memory fusesList = new address[](fuses_.length);
+
+        PlasmaVaultStorageLib.InstantWithdrawalFusesParams storage instantWithdrawalFusesParams = PlasmaVaultStorageLib
+            .getInstantWithdrawalFusesParams();
+
+        bytes32 key;
+
+        for (uint256 i; i < fuses_.length; ++i) {
+            if (!FusesLib.isFuseSupported(fuses_[i].fuse)) {
+                revert FusesLib.FuseUnsupported(fuses_[i].fuse);
+            }
+
+            fusesList[i] = fuses_[i].fuse;
+            key = keccak256(abi.encodePacked(fuses_[i].fuse, i));
+
+            delete instantWithdrawalFusesParams.value[key];
+
+            for (uint256 j; j < fuses_[i].params.length; ++j) {
+                instantWithdrawalFusesParams.value[key].push(fuses_[i].params[j]);
+            }
+        }
+
+        delete PlasmaVaultStorageLib.getInstantWithdrawalFusesArray().value;
+
+        PlasmaVaultStorageLib.getInstantWithdrawalFusesArray().value = fusesList;
+
+        emit InstantWithdrawalFusesConfigured(fuses_);
+    }
+
+    /// @notice Gets the Price Oracle Middleware address
+    /// @return The Price Oracle Middleware address
+    function getPriceOracleMiddleware() internal view returns (address) {
+        return PlasmaVaultStorageLib.getPriceOracleMiddleware().value;
+    }
+
+    /// @notice Sets the Price Oracle Middleware address
+    /// @param priceOracleMiddleware_ The Price Oracle Middleware address
+    function setPriceOracleMiddleware(address priceOracleMiddleware_) internal {
+        PlasmaVaultStorageLib.getPriceOracleMiddleware().value = priceOracleMiddleware_;
+        emit PriceOracleMiddlewareChanged(priceOracleMiddleware_);
+    }
+
+    /// @notice Gets the Rewards Claim Manager address
+    /// @return The Rewards Claim Manager address
+    function getRewardsClaimManagerAddress() internal view returns (address) {
+        return PlasmaVaultStorageLib.getRewardsClaimManagerAddress().value;
+    }
+
+    /// @notice Sets the Rewards Claim Manager address
+    /// @param rewardsClaimManagerAddress_ The rewards claim manager address
+    function setRewardsClaimManagerAddress(address rewardsClaimManagerAddress_) internal {
+        PlasmaVaultStorageLib.getRewardsClaimManagerAddress().value = rewardsClaimManagerAddress_;
+        emit RewardsClaimManagerAddressChanged(rewardsClaimManagerAddress_);
+    }
+
+    /// @notice Gets the total supply cap
+    /// @return The total supply cap, represented in decimals of the underlying asset
+    function getTotalSupplyCap() internal view returns (uint256) {
+        return PlasmaVaultStorageLib.getERC20CappedStorage().cap;
+    }
+
+    /// @notice Sets the total supply cap
+    /// @param cap_ The total supply cap, represented in decimals of the underlying asset
+    function setTotalSupplyCap(uint256 cap_) internal {
+        if (cap_ == 0) {
+            revert Errors.WrongValue();
+        }
+        PlasmaVaultStorageLib.getERC20CappedStorage().cap = cap_;
+    }
+
+    /// @notice Sets the total supply cap validation
+    /// @param flag_ The total supply cap validation flag
+    /// @dev 1 - no validation, 0 - validation, total supply validation cap is disabled when performance fee or management fee is minted.
+    /// By default, the total supply cap validation is enabled (flag_ = 0)
+    function setTotalSupplyCapValidation(uint256 flag_) internal {
+        PlasmaVaultStorageLib.getERC20CappedValidationFlag().value = flag_;
+    }
+
+    /// @notice Checks if the total supply cap validation is enabled
+    /// @return true if the total supply cap validation is enabled, false otherwise
+    function isTotalSupplyCapValidationEnabled() internal view returns (bool) {
+        return PlasmaVaultStorageLib.getERC20CappedValidationFlag().value == 0;
+    }
+
+    /// @notice Sets the execution state to started, used in the execute function called by Alpha
+    /// @dev Alpha can do interaction with the Plasma Vault using more than one FuseAction
+    function executeStarted() internal {
+        PlasmaVaultStorageLib.getExecutionState().value = 1;
+    }
+
+    /// @notice Sets the execution state to finished, used in the execute function called by Alpha
+    /// @dev Alpha can do interaction with the Plasma Vault using more than one FuseAction
+    function executeFinished() internal {
+        PlasmaVaultStorageLib.getExecutionState().value = 0;
+    }
+
+    /// @notice Checks if the execution is started
+    /// @return true if the execution is started
+    function isExecutionStarted() internal view returns (bool) {
+        return PlasmaVaultStorageLib.getExecutionState().value == 1;
+    }
+
+    /// @notice Updates the Withdraw Manager address. If the address is zero, it means that scheduled withdrawals are turned off.
+    function updateWithdrawManager(address newWithdrawManager_) internal {
+        PlasmaVaultStorageLib.getWithdrawManager().manager = newWithdrawManager_;
+
+        emit WithdrawManagerChanged(newWithdrawManager_);
+    }
+}

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

@@ -0,0 +1,352 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+/// @title Library responsible for managing access to the storage of the PlasmaVault contract using the ERC-7201 standard
+library PlasmaVaultStorageLib {
+    /// @dev value taken from ERC4626 contract, don't change it!
+    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC4626")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant ERC4626_STORAGE_LOCATION =
+        0x0773e532dfede91f04b12a73d3d2acd361424f41f76b4fb79f090161e36b4e00;
+
+    /// @dev value taken from ERC20CappedUpgradeable contract, don't change it!
+    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC20Capped")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant ERC20_CAPPED_STORAGE_LOCATION =
+        0x0f070392f17d5f958cc1ac31867dabecfc5c9758b4a419a200803226d7155d00;
+
+    /// @dev storage pointer location for a flag which indicates if the Total Supply Cap validation is enabled
+    // keccak256(abi.encode(uint256(keccak256("io.ipor.Erc20CappedValidationFlag")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant ERC20_CAPPED_VALIDATION_FLAG =
+        0xaef487a7a52e82ae7bbc470b42be72a1d3c066fb83773bf99cce7e6a7df2f900;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.PlasmaVaultTotalAssetsInAllMarkets")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant PLASMA_VAULT_TOTAL_ASSETS_IN_ALL_MARKETS =
+        0x24e02552e88772b8e8fd15f3e6699ba530635ffc6b52322da922b0b497a77300;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.PlasmaVaultTotalAssetsInMarket")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant PLASMA_VAULT_TOTAL_ASSETS_IN_MARKET =
+        0x656f5ca8c676f20b936e991a840e1130bdd664385322f33b6642ec86729ee600;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.CfgPlasmaVaultMarketSubstrates")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant CFG_PLASMA_VAULT_MARKET_SUBSTRATES =
+        0x78e40624004925a4ef6749756748b1deddc674477302d5b7fe18e5335cde3900;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.CfgPlasmaVaultBalanceFuses")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant CFG_PLASMA_VAULT_BALANCE_FUSES =
+        0x150144dd6af711bac4392499881ec6649090601bd196a5ece5174c1400b1f700;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.CfgPlasmaVaultInstantWithdrawalFusesArray")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant CFG_PLASMA_VAULT_INSTANT_WITHDRAWAL_FUSES_ARRAY =
+        0xd243afa3da07e6bdec20fdd573a17f99411aa8a62ae64ca2c426d3a86ae0ac00;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.PriceOracleMiddleware")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant PRICE_ORACLE_MIDDLEWARE =
+        0x0d761ae54d86fc3be4f1f2b44ade677efb1c84a85fc6bb1d087dc42f1e319a00;
+
+    /// @notice Every fuse has a list of parameters used for instant withdrawal
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.CfgPlasmaVaultInstantWithdrawalFusesParams")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant CFG_PLASMA_VAULT_INSTANT_WITHDRAWAL_FUSES_PARAMS =
+        0x45a704819a9dcb1bb5b8cff129eda642cf0e926a9ef104e27aa53f1d1fa47b00;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.CfgPlasmaVaultFeeConfig")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant CFG_PLASMA_VAULT_FEE_CONFIG =
+        0x78b5ce597bdb64d5aa30a201c7580beefe408ff13963b5d5f3dce2dc09e89c00;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.PlasmaVaultPerformanceFeeData")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant PLASMA_VAULT_PERFORMANCE_FEE_DATA =
+        0x9399757a27831a6cfb6cf4cd5c97a908a2f8f41e95a5952fbf83a04e05288400;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.PlasmaVaultManagementFeeData")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant PLASMA_VAULT_MANAGEMENT_FEE_DATA =
+        0x239dd7e43331d2af55e2a25a6908f3bcec2957025f1459db97dcdc37c0003f00;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.RewardsClaimManagerAddress")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant REWARDS_CLAIM_MANAGER_ADDRESS =
+        0x08c469289c3f85d9b575f3ae9be6831541ff770a06ea135aa343a4de7c962d00;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.MarketLimits")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant MARKET_LIMITS = 0xc2733c187287f795e2e6e84d35552a190e774125367241c3e99e955f4babf000;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.DependencyBalanceGraph")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant DEPENDENCY_BALANCE_GRAPH =
+        0x82411e549329f2815579116a6c5e60bff72686c93ab5dba4d06242cfaf968900;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.executeRunning")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant EXECUTE_RUNNING = 0x054644eb87255c1c6a2d10801735f52fa3b9d6e4477dbed74914d03844ab6600;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.callbackHandler")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant CALLBACK_HANDLER = 0xb37e8684757599da669b8aea811ee2b3693b2582d2c730fab3f4965fa2ec3e00;
+
+    /// @dev keccak256(abi.encode(uint256(keccak256("io.ipor.WithdrawManager")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 private constant WITHDRAW_MANAGER = 0xb37e8684757599da669b8aea811ee2b3693b2582d2c730fab3f4965fa2ec3e11;
+
+    /// @dev Value taken from ERC20VotesUpgradeable contract, don't change it!
+    /// @custom:storage-location erc7201:openzeppelin.storage.ERC4626
+    struct ERC4626Storage {
+        /// @dev underlying asset in Plasma Vault
+        address asset;
+        /// @dev underlying asset decimals in Plasma Vault
+        uint8 underlyingDecimals;
+    }
+
+    /// @dev Value taken from ERC20VotesUpgradeable contract, don't change it!
+    /// @custom:storage-location erc7201:openzeppelin.storage.ERC20Capped
+    struct ERC20CappedStorage {
+        uint256 cap;
+    }
+
+    /// @notice ERC20CappedValidationFlag is used to enable or disable the total supply cap validation during execution
+    /// Required for situation when performance fee or management fee is minted for fee managers
+    /// @custom:storage-location erc7201:io.ipor.Erc20CappedValidationFlag
+    struct ERC20CappedValidationFlag {
+        uint256 value;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.RewardsClaimManagerAddress
+    struct RewardsClaimManagerAddress {
+        /// @dev total assets in the Plasma Vault
+        address value;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.PlasmaVaultTotalAssetsInAllMarkets
+    struct TotalAssets {
+        /// @dev total assets in the Plasma Vault
+        uint256 value;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.PlasmaVaultTotalAssetsInMarket
+    struct MarketTotalAssets {
+        /// @dev marketId => total assets in the vault in the market
+        mapping(uint256 => uint256) value;
+    }
+
+    /// @notice Market Substrates configuration
+    /// @dev Substrate - abstract item in the market, could be asset or sub market in the external protocol, it could be any item required to calculate balance in the market
+    struct MarketSubstratesStruct {
+        /// @notice Define which substrates are allowed and supported in the market
+        /// @dev key can be specific asset or sub market in a specific external protocol (market), value - 1 - granted, otherwise - not granted
+        mapping(bytes32 => uint256) substrateAllowances;
+        /// @dev it could be list of assets or sub markets in a specific protocol or any other ids required to calculate balance in the market (external protocol)
+        bytes32[] substrates;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.CfgPlasmaVaultMarketSubstrates
+    struct MarketSubstrates {
+        /// @dev marketId => MarketSubstratesStruct
+        mapping(uint256 => MarketSubstratesStruct) value;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.CfgPlasmaVaultBalanceFuses
+    struct BalanceFuses {
+        /// @dev marketId => balance fuse address
+        mapping(uint256 => address) value;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.BalanceDependenceGraph
+    struct DependencyBalanceGraph {
+        mapping(uint256 marketId => uint256[] marketIds) dependencyGraph;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.callbackHandler
+    struct CallbackHandler {
+        /// @dev key: keccak256(abi.encodePacked(sender, sig)), value: handler address
+        mapping(bytes32 key => address handler) callbackHandler;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.CfgPlasmaVaultInstantWithdrawalFusesArray
+    struct InstantWithdrawalFuses {
+        /// @dev value is a Fuse address used for instant withdrawal
+        address[] value;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.CfgPlasmaVaultInstantWithdrawalFusesParams
+    struct InstantWithdrawalFusesParams {
+        /// @dev key: fuse address and index in InstantWithdrawalFuses array, value: list of parameters used for instant withdrawal
+        /// @dev first param always amount in underlying asset of PlasmaVault, second and next params are specific for the fuse and market
+        mapping(bytes32 => bytes32[]) value;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.PlasmaVaultPerformanceFeeData
+    struct PerformanceFeeData {
+        address feeAccount;
+        uint16 feeInPercentage;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.PlasmaVaultManagementFeeData
+    struct ManagementFeeData {
+        address feeAccount;
+        uint16 feeInPercentage;
+        uint32 lastUpdateTimestamp;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.PriceOracleMiddleware
+    struct PriceOracleMiddleware {
+        address value;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.executeRunning
+    struct ExecuteState {
+        uint256 value;
+    }
+
+    /// @custom:storage-location erc7201:io.ipor.WithdrawManager
+    struct WithdrawManager {
+        address manager;
+    }
+
+    /// @dev limit is percentage of total assets in the market in 18 decimals, 1e18 is 100%
+    /// @deb if limit for zero marketId is greater than 0, then limits are activated
+    /// @custom:storage-location erc7201:io.ipor.MarketLimits
+    struct MarketLimits {
+        mapping(uint256 marketId => uint256 limit) limitInPercentage;
+    }
+
+    function getERC4626Storage() internal pure returns (ERC4626Storage storage $) {
+        assembly {
+            $.slot := ERC4626_STORAGE_LOCATION
+        }
+    }
+
+    function getERC20CappedStorage() internal pure returns (ERC20CappedStorage storage $) {
+        assembly {
+            $.slot := ERC20_CAPPED_STORAGE_LOCATION
+        }
+    }
+
+    function getERC20CappedValidationFlag() internal pure returns (ERC20CappedValidationFlag storage $) {
+        assembly {
+            $.slot := ERC20_CAPPED_VALIDATION_FLAG
+        }
+    }
+
+    /// @notice Gets the total assets storage pointer
+    /// @return totalAssets storage pointer
+    function getTotalAssets() internal pure returns (TotalAssets storage totalAssets) {
+        assembly {
+            totalAssets.slot := PLASMA_VAULT_TOTAL_ASSETS_IN_ALL_MARKETS
+        }
+    }
+
+    /// @notice Gets execution state storage pointer
+    /// @return executeRunning storage pointer
+    function getExecutionState() internal pure returns (ExecuteState storage executeRunning) {
+        assembly {
+            executeRunning.slot := EXECUTE_RUNNING
+        }
+    }
+
+    /// @notice Gets the callback handler storage pointer
+    /// @return handler storage pointer
+    function getCallbackHandler() internal pure returns (CallbackHandler storage handler) {
+        assembly {
+            handler.slot := CALLBACK_HANDLER
+        }
+    }
+
+    /// @notice Gets the dependency balance graph storage pointer
+    /// @return dependencyBalanceGraph storage pointer
+    function getDependencyBalanceGraph() internal pure returns (DependencyBalanceGraph storage dependencyBalanceGraph) {
+        assembly {
+            dependencyBalanceGraph.slot := DEPENDENCY_BALANCE_GRAPH
+        }
+    }
+
+    /// @notice Gets the market total assets storage pointer
+    /// @return marketTotalAssets storage pointer
+    function getMarketTotalAssets() internal pure returns (MarketTotalAssets storage marketTotalAssets) {
+        assembly {
+            marketTotalAssets.slot := PLASMA_VAULT_TOTAL_ASSETS_IN_MARKET
+        }
+    }
+
+    /// @notice Gets the market substrates storage pointer
+    /// @return marketSubstrates storage pointer
+    function getMarketSubstrates() internal pure returns (MarketSubstrates storage marketSubstrates) {
+        assembly {
+            marketSubstrates.slot := CFG_PLASMA_VAULT_MARKET_SUBSTRATES
+        }
+    }
+
+    /// @notice Gets the balance fuses storage pointer
+    /// @return balanceFuses storage pointer
+    function getBalanceFuses() internal pure returns (BalanceFuses storage balanceFuses) {
+        assembly {
+            balanceFuses.slot := CFG_PLASMA_VAULT_BALANCE_FUSES
+        }
+    }
+
+    /// @notice Gets the instant withdrawal fuses storage pointer
+    /// @return instantWithdrawalFuses storage pointer
+    function getInstantWithdrawalFusesArray()
+        internal
+        pure
+        returns (InstantWithdrawalFuses storage instantWithdrawalFuses)
+    {
+        assembly {
+            instantWithdrawalFuses.slot := CFG_PLASMA_VAULT_INSTANT_WITHDRAWAL_FUSES_ARRAY
+        }
+    }
+
+    /// @notice Gets the instant withdrawal fuses params storage pointer
+    /// @return instantWithdrawalFusesParams storage pointer
+    function getInstantWithdrawalFusesParams()
+        internal
+        pure
+        returns (InstantWithdrawalFusesParams storage instantWithdrawalFusesParams)
+    {
+        assembly {
+            instantWithdrawalFusesParams.slot := CFG_PLASMA_VAULT_INSTANT_WITHDRAWAL_FUSES_PARAMS
+        }
+    }
+
+    /// @notice Gets the PriceOracleMiddleware storage pointer
+    /// @return oracle storage pointer
+    function getPriceOracleMiddleware() internal pure returns (PriceOracleMiddleware storage oracle) {
+        assembly {
+            oracle.slot := PRICE_ORACLE_MIDDLEWARE
+        }
+    }
+
+    /// @notice Gets performance fee config storage pointer
+    /// @return performanceFeeData storage pointer
+    function getPerformanceFeeData() internal pure returns (PerformanceFeeData storage performanceFeeData) {
+        assembly {
+            performanceFeeData.slot := PLASMA_VAULT_PERFORMANCE_FEE_DATA
+        }
+    }
+
+    /// @notice Gets management fee config storage pointer
+    /// @return managementFeeData storage pointer
+    function getManagementFeeData() internal pure returns (ManagementFeeData storage managementFeeData) {
+        assembly {
+            managementFeeData.slot := PLASMA_VAULT_MANAGEMENT_FEE_DATA
+        }
+    }
+
+    /// @notice Gets the Rewards Claim Manager address storage pointer
+    /// @return rewardsClaimManagerAddress storage pointer
+    function getRewardsClaimManagerAddress()
+        internal
+        pure
+        returns (RewardsClaimManagerAddress storage rewardsClaimManagerAddress)
+    {
+        assembly {
+            rewardsClaimManagerAddress.slot := REWARDS_CLAIM_MANAGER_ADDRESS
+        }
+    }
+
+    /// @notice Gets the MarketLimits storage pointer
+    /// @return marketLimits storage pointer
+    function getMarketsLimits() internal pure returns (MarketLimits storage marketLimits) {
+        assembly {
+            marketLimits.slot := MARKET_LIMITS
+        }
+    }
+
+    /// @notice Gets the WithdrawManager storage pointer
+    /// @return withdrawManager storage pointer
+    function getWithdrawManager() internal pure returns (WithdrawManager storage withdrawManager) {
+        assembly {
+            withdrawManager.slot := WITHDRAW_MANAGER
+        }
+    }
+}

package/contracts/base/interface/merkl/IDistributor.sol

@@ -0,0 +1,6 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.26;
+
+interface IDistributor {
+    function toggleOperator(address user, address operator) external;
+}