@gearbox-protocol/periphery-v3 1.7.0-next.1 → 1.7.0-next.4

package/contracts/compressors/CreditAccountCompressor.sol

@@ -0,0 +1,443 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import {IContractsRegister} from "@gearbox-protocol/core-v3/contracts/interfaces/IContractsRegister.sol";
+import {ICreditAccountV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditAccountV3.sol";
+import {
+    CollateralCalcTask,
+    CollateralDebtData,
+    ICreditManagerV3
+} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditManagerV3.sol";
+import {IPoolQuotaKeeperV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPoolQuotaKeeperV3.sol";
+import {IVersion} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol";
+import {SanityCheckTrait} from "@gearbox-protocol/core-v3/contracts/traits/SanityCheckTrait.sol";
+
+import {IAddressProviderV3} from "@gearbox-protocol/governance/contracts/interfaces/IAddressProviderV3.sol";
+import {IMarketConfiguratorV3} from "@gearbox-protocol/governance/contracts/interfaces/IMarketConfiguratorV3.sol";
+
+import {CreditAccountData, CreditAccountFilter, CreditManagerFilter, TokenInfo} from "./Types.sol";
+
+/// @title  Credit account compressor
+/// @notice Allows to fetch data on all credit accounts matching certain criteria in an efficient manner
+/// @dev    The contract is not gas optimized and is thus not recommended for on-chain use
+/// @dev    The querying functions exist in two modes, with one of them trying to YOLO-load everything and the other
+///         one loading as many accounts as fit in the call gas limit to implement the tightest pagination possible
+contract CreditAccountCompressor is IVersion, SanityCheckTrait {
+    /// @notice Contract version
+    uint256 public constant override version = 3_10;
+
+    /// @notice Address provider contract address
+    address public immutable addressProvider;
+
+    /// @dev Maximum number of accounts to consider in a single step to avoid excessive memory expansion
+    uint256 internal constant STEP_SIZE = 1000;
+
+    /// @notice Thrown when address provider is not a contract or does not implement `marketConfigurators()`
+    error InvalidAddressProviderException();
+
+    /// @notice Constructor
+    /// @param  addressProvider_ Address provider contract address
+    constructor(address addressProvider_) nonZeroAddress(addressProvider_) {
+        if (addressProvider_.code.length == 0) revert InvalidAddressProviderException();
+        try IAddressProviderV3(addressProvider_).marketConfigurators() {}
+        catch {
+            revert InvalidAddressProviderException();
+        }
+        addressProvider = addressProvider_;
+    }
+
+    // -------- //
+    // QUERYING //
+    // -------- //
+
+    /// @notice Returns data for a particular `creditAccount`
+    function getCreditAccountData(address creditAccount) external view returns (CreditAccountData memory) {
+        address creditManager = ICreditAccountV3(creditAccount).creditManager();
+        return _getCreditAccountData(creditAccount, creditManager);
+    }
+
+    /// @notice Returns data for credit accounts that match `caFilter` in credit managers matching `cmFilter`
+    /// @dev    The `offset` parameter specifies the position to start scanning from in the list of all
+    ///         credit accounts opened in credit managers matching `cmFilter`
+    /// @dev    The `false` value of `finished` return variable indicates that gas supplied with a call
+    ///         was insufficient to process all the accounts and next iteration is needed which should
+    ///         start from `nextOffset` position
+    function getCreditAccounts(CreditManagerFilter memory cmFilter, CreditAccountFilter memory caFilter, uint256 offset)
+        external
+        view
+        returns (CreditAccountData[] memory data, bool finished, uint256 nextOffset)
+    {
+        uint256 num = countCreditAccounts(cmFilter, caFilter, offset);
+        nextOffset = offset;
+
+        // FIXME: If the number of accounts matching the filter is much larger than the number of accounts that
+        // can realistically be processed with most providers, pre-allocation burns unnecessarily large amount
+        // of gas due to quadratic memory expansion cost.
+        // An idea for the mitigation is to calculate the maximum memory pointer that can possibly be reached
+        // during calculations, and write resulting data after it, only expanding memory when actually needed.
+        data = new CreditAccountData[](num);
+        uint256 dataOffset;
+
+        // FIXME: This should be proven to be enough to properly return the data, and possibly made tighter
+        uint256 gasThreshold = gasleft() / 64;
+
+        address[] memory creditManagers = _getCreditManagers(cmFilter);
+        for (uint256 i; i < creditManagers.length; ++i) {
+            uint256 len = ICreditManagerV3(creditManagers[i]).creditAccountsLen();
+
+            // first, we need to get to the `offset` position
+            if (len <= offset) {
+                offset -= len;
+                continue;
+            }
+
+            while (offset < len) {
+                bool outOfGas;
+                uint256 processed;
+
+                // circumvent the "Stack too deep." error
+                uint256 offset_ = offset;
+
+                (dataOffset, outOfGas, processed) = _getCreditAccounts({
+                    creditManager: creditManagers[i],
+                    filter: caFilter,
+                    data: data,
+                    dataOffset: dataOffset,
+                    offset: offset_,
+                    limit: STEP_SIZE,
+                    gasThreshold: gasThreshold
+                });
+                offset += processed;
+                nextOffset += processed;
+
+                if (outOfGas) {
+                    // trim the array to its actual size
+                    assembly {
+                        mstore(data, dataOffset)
+                    }
+                    return (data, dataOffset == num, nextOffset);
+                }
+            }
+            offset = 0;
+        }
+        return (data, true, nextOffset);
+    }
+
+    /// @dev Same as above but with no gas limit control
+    function getCreditAccounts(CreditManagerFilter memory cmFilter, CreditAccountFilter memory caFilter)
+        external
+        view
+        returns (CreditAccountData[] memory data)
+    {
+        uint256 num = countCreditAccounts(cmFilter, caFilter, 0);
+        data = new CreditAccountData[](num);
+        uint256 dataOffset;
+
+        address[] memory creditManagers = _getCreditManagers(cmFilter);
+        for (uint256 i; i < creditManagers.length; ++i) {
+            uint256 len = ICreditManagerV3(creditManagers[i]).creditAccountsLen();
+            (dataOffset,,) = _getCreditAccounts({
+                creditManager: creditManagers[i],
+                filter: caFilter,
+                data: data,
+                dataOffset: dataOffset,
+                offset: 0,
+                limit: len,
+                gasThreshold: 0
+            });
+        }
+    }
+
+    /// @notice Returns data for credit accounts that match `caFilter` in a given `creditManager`
+    /// @dev    The `offset` parameter specifies the position to start scanning from in the list of all
+    ///         credit accounts opened in `creditManager`
+    /// @dev    The `false` value of `finished` return variable indicates that gas supplied with a call
+    ///         was insufficient to process all the accounts and next iteration is needed which should
+    ///         start from `nextOffset` position
+    function getCreditAccounts(address creditManager, CreditAccountFilter memory caFilter, uint256 offset)
+        external
+        view
+        returns (CreditAccountData[] memory data, bool finished, uint256 nextOffset)
+    {
+        uint256 num = countCreditAccounts(creditManager, caFilter, offset);
+        nextOffset = offset;
+
+        // FIXME: If the number of accounts matching the filter is much larger than the number of accounts that
+        // can realistically be processed with most providers, pre-allocation burns unnecessarily large amount
+        // of gas due to quadratic memory expansion cost.
+        // An idea for the mitigation is to calculate the maximum memory pointer that can possibly be reached
+        // during calculations, and write resulting data after it, only expanding memory when actually needed.
+        data = new CreditAccountData[](num);
+        uint256 dataOffset;
+
+        // FIXME: This should be proven to be enough to properly return the data, and possibly made tighter
+        uint256 gasThreshold = gasleft() / 64;
+
+        uint256 len = ICreditManagerV3(creditManager).creditAccountsLen();
+        while (offset < len) {
+            bool outOfGas;
+            uint256 processed;
+            (dataOffset, outOfGas, processed) = _getCreditAccounts({
+                creditManager: creditManager,
+                filter: caFilter,
+                data: data,
+                dataOffset: dataOffset,
+                offset: offset,
+                limit: STEP_SIZE,
+                gasThreshold: gasThreshold
+            });
+            offset += processed;
+            nextOffset += processed;
+
+            if (outOfGas) {
+                // trim the array to its actual size
+                assembly {
+                    mstore(data, dataOffset)
+                }
+                return (data, dataOffset == num, nextOffset);
+            }
+        }
+        return (data, true, nextOffset);
+    }
+
+    /// @dev Same as above but with no gas limit control
+    function getCreditAccounts(address creditManager, CreditAccountFilter memory caFilter)
+        external
+        view
+        returns (CreditAccountData[] memory data)
+    {
+        uint256 num = countCreditAccounts(creditManager, caFilter, 0);
+        data = new CreditAccountData[](num);
+
+        uint256 len = ICreditManagerV3(creditManager).creditAccountsLen();
+        _getCreditAccounts({
+            creditManager: creditManager,
+            filter: caFilter,
+            data: data,
+            dataOffset: 0,
+            offset: 0,
+            limit: len,
+            gasThreshold: 0
+        });
+    }
+
+    // -------- //
+    // COUNTING //
+    // -------- //
+
+    /// @notice Counts credit accounts that match `caFilter` in credit managers matching `cmFilter`
+    /// @dev    The `offset` parameter specifies the position to start scanning from in the list of all
+    ///         credit accounts opened in credit managers matching `cmFilter`
+    function countCreditAccounts(
+        CreditManagerFilter memory cmFilter,
+        CreditAccountFilter memory caFilter,
+        uint256 offset
+    ) public view returns (uint256 num) {
+        address[] memory creditManagers = _getCreditManagers(cmFilter);
+
+        for (uint256 i; i < creditManagers.length; ++i) {
+            uint256 len = ICreditManagerV3(creditManagers[i]).creditAccountsLen();
+
+            // first, we need to get to the `offset` position
+            if (len <= offset) {
+                offset -= len;
+                continue;
+            }
+
+            while (offset < len) {
+                num += _countCreditAccounts(creditManagers[i], caFilter, offset, STEP_SIZE);
+                offset += STEP_SIZE;
+            }
+            offset = 0;
+        }
+    }
+
+    /// @notice Counts credit accounts that match `caFilter` in a given `creditManager`
+    /// @dev    The `offset` parameter specifies the position to start scanning from in the list of all
+    ///         credit accounts opened in `creditManager`
+    function countCreditAccounts(address creditManager, CreditAccountFilter memory caFilter, uint256 offset)
+        public
+        view
+        returns (uint256 num)
+    {
+        uint256 len = ICreditManagerV3(creditManager).creditAccountsLen();
+        while (offset < len) {
+            num += _countCreditAccounts(creditManager, caFilter, offset, STEP_SIZE);
+            offset += STEP_SIZE;
+        }
+    }
+
+    // --------- //
+    // INTERNALS //
+    // --------- //
+
+    /// @dev Querying implementation
+    function _getCreditAccounts(
+        address creditManager,
+        CreditAccountFilter memory filter,
+        CreditAccountData[] memory data,
+        uint256 dataOffset,
+        uint256 offset,
+        uint256 limit,
+        uint256 gasThreshold
+    ) internal view returns (uint256, bool, uint256) {
+        address[] memory creditAccounts = ICreditManagerV3(creditManager).creditAccounts(offset, limit);
+        uint256 len = creditAccounts.length;
+        for (uint256 i; i < len; ++i) {
+            // early return if remaining gas is below given threshold
+            if (gasleft() < gasThreshold) return (dataOffset, true, i);
+            if (_checkFilterMatch(creditAccounts[i], creditManager, filter)) {
+                data[dataOffset++] = _getCreditAccountData(creditAccounts[i], creditManager);
+            }
+        }
+        return (dataOffset, false, len);
+    }
+
+    /// @dev Counting implementation
+    function _countCreditAccounts(
+        address creditManager,
+        CreditAccountFilter memory filter,
+        uint256 offset,
+        uint256 limit
+    ) internal view returns (uint256 num) {
+        address[] memory creditAccounts = ICreditManagerV3(creditManager).creditAccounts(offset, limit);
+        for (uint256 i; i < creditAccounts.length; ++i) {
+            if (_checkFilterMatch(creditAccounts[i], creditManager, filter)) {
+                ++num;
+            }
+        }
+    }
+
+    /// @dev Data loading implementation
+    function _getCreditAccountData(address creditAccount, address creditManager)
+        internal
+        view
+        returns (CreditAccountData memory data)
+    {
+        data.creditAccount = creditAccount;
+        data.creditManager = creditManager;
+        data.creditFacade = ICreditManagerV3(creditManager).creditFacade();
+        data.underlying = ICreditManagerV3(creditManager).underlying();
+        data.owner = ICreditManagerV3(creditManager).getBorrowerOrRevert(creditAccount);
+
+        CollateralDebtData memory cdd =
+            ICreditManagerV3(creditManager).calcDebtAndCollateral(creditAccount, CollateralCalcTask.DEBT_ONLY);
+        data.enabledTokensMask = cdd.enabledTokensMask;
+        data.debt = cdd.debt;
+        data.accruedInterest = cdd.accruedInterest;
+        data.accruedFees = cdd.accruedFees;
+
+        // collateral is computed separately since it might revert on `balanceOf` and `latestRoundData` calls
+        try ICreditManagerV3(creditManager).calcDebtAndCollateral(creditAccount, CollateralCalcTask.DEBT_COLLATERAL)
+        returns (CollateralDebtData memory cdd_) {
+            data.totalDebtUSD = cdd.totalDebtUSD;
+            data.totalValueUSD = cdd_.totalValueUSD;
+            data.twvUSD = cdd_.twvUSD;
+            data.totalValue = cdd.totalValue;
+            data.healthFactor = cdd.totalDebtUSD == 0 ? type(uint256).max : cdd.twvUSD * 1e18 / cdd.totalDebtUSD;
+            data.success = true;
+        } catch {}
+
+        uint256 numTokens = ICreditManagerV3(creditManager).collateralTokensCount();
+        data.tokens = new TokenInfo[](numTokens);
+        for (uint256 i; i < numTokens; ++i) {
+            address token = ICreditManagerV3(creditManager).getTokenByMask(1 << i);
+            data.tokens[i].token = token;
+
+            try IERC20(token).balanceOf(creditAccount) returns (uint256 balance) {
+                data.tokens[i].balance = balance;
+                data.tokens[i].success = true;
+            } catch {}
+
+            // down goes quotas logic which does not apply to underlying
+            if (i == 0) continue;
+
+            (data.tokens[i].quota,) =
+                IPoolQuotaKeeperV3(cdd._poolQuotaKeeper).getQuotaAndOutstandingInterest(creditAccount, token);
+        }
+    }
+
+    /// @dev Credit account filtering implementation
+    function _checkFilterMatch(address creditAccount, address creditManager, CreditAccountFilter memory filter)
+        internal
+        view
+        returns (bool)
+    {
+        if (filter.owner != address(0)) {
+            address owner = ICreditManagerV3(creditManager).getBorrowerOrRevert(creditAccount);
+            if (owner != filter.owner) return false;
+        }
+
+        if (!filter.includeZeroDebt) {
+            (uint256 debt,,,,,,,) = ICreditManagerV3(creditManager).creditAccountInfo(creditAccount);
+            if (debt == 0) return false;
+        }
+
+        if (filter.minHealthFactor != 0 || filter.maxHealthFactor != 0 || filter.reverting) {
+            try ICreditManagerV3(creditManager).calcDebtAndCollateral(creditAccount, CollateralCalcTask.DEBT_COLLATERAL)
+            returns (CollateralDebtData memory cdd) {
+                if (filter.reverting) return false;
+                uint256 healthFactor = cdd.totalDebtUSD == 0 ? type(uint256).max : cdd.twvUSD * 1e18 / cdd.totalDebtUSD;
+                if (filter.minHealthFactor != 0 && healthFactor < filter.minHealthFactor) return false;
+                if (filter.maxHealthFactor != 0 && healthFactor > filter.maxHealthFactor) return false;
+            } catch {
+                if (!filter.reverting) return false;
+            }
+        }
+
+        return true;
+    }
+
+    /// @dev Credit managers discovery
+    function _getCreditManagers(CreditManagerFilter memory filter)
+        internal
+        view
+        returns (address[] memory creditManagers)
+    {
+        address[] memory configurators = IAddressProviderV3(addressProvider).marketConfigurators();
+
+        // rough estimate of maximum number of credit managers
+        uint256 max;
+        for (uint256 i; i < configurators.length; ++i) {
+            address cr = IMarketConfiguratorV3(configurators[i]).contractsRegister();
+            max += IContractsRegister(cr).getCreditManagers().length;
+        }
+
+        // allocate the array with maximum potentially needed size (total number of credit managers
+        // can be assumed to be relatively small, so memary expansion cost is not an issue here)
+        creditManagers = new address[](max);
+        uint256 num;
+        for (uint256 i; i < configurators.length; ++i) {
+            if (filter.curator != address(0)) {
+                if (IMarketConfiguratorV3(configurators[i]).owner() != filter.curator) continue;
+            }
+
+            address cr = IMarketConfiguratorV3(configurators[i]).contractsRegister();
+            address[] memory managers = IContractsRegister(cr).getCreditManagers();
+            for (uint256 j; j < managers.length; ++j) {
+                // we're only concerned with v3 contracts
+                uint256 ver = IVersion(managers[i]).version();
+                if (ver < 3_00 || ver > 3_99) continue;
+
+                if (filter.pool != address(0)) {
+                    if (ICreditManagerV3(managers[i]).pool() != filter.pool) continue;
+                }
+
+                if (filter.underlying != address(0)) {
+                    if (ICreditManagerV3(managers[i]).underlying() != filter.underlying) continue;
+                }
+
+                creditManagers[num++] = managers[j];
+            }
+        }
+
+        // trim the array to its actual size
+        assembly {
+            mstore(creditManagers, num)
+        }
+    }
+}

package/contracts/compressors/PriceFeedCompressor.sol

@@ -0,0 +1,225 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+import {AddressIsNotContractException} from "@gearbox-protocol/core-v3/contracts/interfaces/IExceptions.sol";
+import {IPriceOracleV3, PriceFeedParams} from "@gearbox-protocol/core-v3/contracts/interfaces/IPriceOracleV3.sol";
+import {IPriceFeed, IUpdatablePriceFeed} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IPriceFeed.sol";
+import {IVersion} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol";
+import {PriceFeedType} from "@gearbox-protocol/sdk-gov/contracts/PriceFeedType.sol";
+
+import {IStateSerializer} from "../interfaces/IStateSerializer.sol";
+import {IStateSerializerTrait} from "../interfaces/IStateSerializerTrait.sol";
+import {NestedPriceFeeds} from "../libraries/NestedPriceFeeds.sol";
+import {BoundedPriceFeedSerializer} from "../serializers/oracles/BoundedPriceFeedSerializer.sol";
+import {BPTWeightedPriceFeedSerializer} from "../serializers/oracles/BPTWeightedPriceFeedSerializer.sol";
+import {LPPriceFeedSerializer} from "../serializers/oracles/LPPriceFeedSerializer.sol";
+import {PythPriceFeedSerializer} from "../serializers/oracles/PythPriceFeedSerializer.sol";
+import {RedstonePriceFeedSerializer} from "../serializers/oracles/RedstonePriceFeedSerializer.sol";
+import {PriceFeedAnswer, PriceFeedMapEntry, PriceFeedTreeNode} from "./Types.sol";
+
+interface ImplementsPriceFeedType {
+    /// @dev Annotates `priceFeedType` as `uint8` instead of `PriceFeedType` enum to support future types
+    function priceFeedType() external view returns (uint8);
+}
+
+/// @dev Price oracle with version below `3_10` has some important interface differences:
+///      - it does not implement `getTokens`
+///      - it only allows to fetch staleness period of a currently active price feed
+interface IPriceOracleV3Legacy {
+    /// @dev Older signature for fetching main and reserve feeds
+    function priceFeedsRaw(address token, bool reserve) external view returns (address);
+}
+
+/// @title  Price feed compressor
+/// @notice Allows to fetch all useful data from price oracle in a single call
+/// @dev    The contract is not gas optimized and is thus not recommended for on-chain use
+contract PriceFeedCompressor is IVersion, Ownable {
+    using NestedPriceFeeds for IPriceFeed;
+
+    /// @notice Contract version
+    uint256 public constant override version = 3_10;
+
+    /// @notice Map of state serializers for different price feed types
+    /// @dev    Serializers only apply to feeds that don't implement `IStateSerializerTrait` themselves
+    mapping(uint8 => address) public serializers;
+
+    /// @notice Emitted when new state serializer is set for a given price feed type
+    event SetSerializer(uint8 indexed priceFeedType, address indexed serializer);
+
+    /// @notice Constructor
+    /// @param  owner Contract owner
+    /// @dev    Sets serializers for existing price feed types.
+    ///         It is recommended to implement `IStateSerializerTrait` in new price feeds.
+    constructor(address owner) {
+        transferOwnership(owner);
+
+        address lpSerializer = address(new LPPriceFeedSerializer());
+        // these types can be serialized as generic LP price feeds
+        _setSerializer(uint8(PriceFeedType.BALANCER_STABLE_LP_ORACLE), lpSerializer);
+        _setSerializer(uint8(PriceFeedType.COMPOUND_V2_ORACLE), lpSerializer);
+        _setSerializer(uint8(PriceFeedType.CURVE_2LP_ORACLE), lpSerializer);
+        _setSerializer(uint8(PriceFeedType.CURVE_3LP_ORACLE), lpSerializer);
+        _setSerializer(uint8(PriceFeedType.CURVE_4LP_ORACLE), lpSerializer);
+        _setSerializer(uint8(PriceFeedType.CURVE_CRYPTO_ORACLE), lpSerializer);
+        _setSerializer(uint8(PriceFeedType.CURVE_USD_ORACLE), lpSerializer);
+        _setSerializer(uint8(PriceFeedType.ERC4626_VAULT_ORACLE), lpSerializer);
+        _setSerializer(uint8(PriceFeedType.WRAPPED_AAVE_V2_ORACLE), lpSerializer);
+        _setSerializer(uint8(PriceFeedType.WSTETH_ORACLE), lpSerializer);
+        _setSerializer(uint8(PriceFeedType.YEARN_ORACLE), lpSerializer);
+
+        // these types need special serialization
+        _setSerializer(uint8(PriceFeedType.BALANCER_WEIGHTED_LP_ORACLE), address(new BPTWeightedPriceFeedSerializer()));
+        _setSerializer(uint8(PriceFeedType.BOUNDED_ORACLE), address(new BoundedPriceFeedSerializer()));
+        _setSerializer(uint8(PriceFeedType.PYTH_ORACLE), address(new PythPriceFeedSerializer()));
+        _setSerializer(uint8(PriceFeedType.REDSTONE_ORACLE), address(new RedstonePriceFeedSerializer()));
+    }
+
+    /// @notice Sets state serializer for a given price feed type (unsets if `serializer` is `address(0)`)
+    function setSerializer(uint8 priceFeedType, address serializer) external onlyOwner {
+        if (serializer != address(0) && serializer.code.length == 0) revert AddressIsNotContractException(serializer);
+        _setSerializer(priceFeedType, serializer);
+    }
+
+    /// @notice Returns all potentially useful price feeds data for a given price oracle in the form of two arrays:
+    ///         - `priceFeedMap` is a set of entries in the map (token, reserve) => (priceFeed, stalenessPeirod).
+    ///         These are all the price feeds one can actually query via the price oracle.
+    ///         - `priceFeedTree` is a set of nodes in a tree-like structure that contains detailed info of both feeds
+    ///         from `priceFeedMap` and their underlying feeds, in case former are nested, which can help to determine
+    ///         what underlying feeds should be updated to query the nested one.
+    /// @dev    `priceFeedTree` can have duplicate entries since a price feed can both be in `priceFeedMap` for one or
+    ///         more (token, reserve) pairs, and serve as an underlying feed in one or more nested feeds.
+    ///         If there are two identical nodes in the tree, then subtrees of these nodes are also identical.
+    function getPriceFeeds(address priceOracle)
+        external
+        view
+        returns (PriceFeedMapEntry[] memory priceFeedMap, PriceFeedTreeNode[] memory priceFeedTree)
+    {
+        address[] memory tokens = IPriceOracleV3(priceOracle).getTokens();
+        return getPriceFeeds(priceOracle, tokens);
+    }
+
+    /// @dev Same as the above but takes the list of tokens as argument as legacy oracle doesn't implement `getTokens`
+    function getPriceFeeds(address priceOracle, address[] memory tokens)
+        public
+        view
+        returns (PriceFeedMapEntry[] memory priceFeedMap, PriceFeedTreeNode[] memory priceFeedTree)
+    {
+        uint256 numTokens = tokens.length;
+
+        priceFeedMap = new PriceFeedMapEntry[](2 * numTokens);
+        uint256 priceFeedMapSize;
+        uint256 priceFeedTreeSize;
+
+        for (uint256 i; i < 2 * numTokens; ++i) {
+            address token = tokens[i % numTokens];
+            bool reserve = i >= numTokens;
+
+            (address priceFeed, uint32 stalenessPeriod) = _getPriceFeed(priceOracle, token, reserve);
+            if (priceFeed == address(0)) continue;
+
+            priceFeedMap[priceFeedMapSize++] = PriceFeedMapEntry({
+                token: token,
+                reserve: reserve,
+                priceFeed: priceFeed,
+                stalenessPeriod: stalenessPeriod
+            });
+            priceFeedTreeSize += _getPriceFeedTreeSize(priceFeed);
+        }
+        assembly {
+            mstore(priceFeedMap, priceFeedMapSize)
+        }
+
+        priceFeedTree = new PriceFeedTreeNode[](priceFeedTreeSize);
+        uint256 offset;
+        for (uint256 i; i < priceFeedMapSize; ++i) {
+            offset = _loadPriceFeedTree(priceFeedMap[i].priceFeed, priceFeedTree, offset);
+        }
+    }
+
+    // --------- //
+    // INTERNALS //
+    // --------- //
+
+    /// @dev Sets `serializer` for `priceFeedType`
+    function _setSerializer(uint8 priceFeedType, address serializer) internal {
+        if (serializers[priceFeedType] != serializer) {
+            serializers[priceFeedType] = serializer;
+            emit SetSerializer(priceFeedType, serializer);
+        }
+    }
+
+    /// @dev Returns `token`'s price feed in the price oracle
+    function _getPriceFeed(address priceOracle, address token, bool reserve) internal view returns (address, uint32) {
+        if (IPriceOracleV3(priceOracle).version() < 3_10) {
+            address priceFeed = IPriceOracleV3Legacy(priceOracle).priceFeedsRaw(token, reserve);
+            // legacy oracle does not allow to fetch staleness period of a non-active feed
+            return (priceFeed, 0);
+        }
+        PriceFeedParams memory params = reserve
+            ? IPriceOracleV3(priceOracle).reservePriceFeedParams(token)
+            : IPriceOracleV3(priceOracle).priceFeedParams(token);
+        return (params.priceFeed, params.stalenessPeriod);
+    }
+
+    /// @dev Computes the size of the `priceFeed`'s subtree (recursively)
+    function _getPriceFeedTreeSize(address priceFeed) internal view returns (uint256 size) {
+        size = 1;
+        (address[] memory underlyingFeeds,) = IPriceFeed(priceFeed).getUnderlyingFeeds();
+        for (uint256 i; i < underlyingFeeds.length; ++i) {
+            size += _getPriceFeedTreeSize(underlyingFeeds[i]);
+        }
+    }
+
+    /// @dev Loads `priceFeed`'s subtree (recursively)
+    function _loadPriceFeedTree(address priceFeed, PriceFeedTreeNode[] memory priceFeedTree, uint256 offset)
+        internal
+        view
+        returns (uint256)
+    {
+        PriceFeedTreeNode memory node = _getPriceFeedTreeNode(priceFeed);
+        priceFeedTree[offset++] = node;
+        for (uint256 i; i < node.underlyingFeeds.length; ++i) {
+            offset = _loadPriceFeedTree(node.underlyingFeeds[i], priceFeedTree, offset);
+        }
+        return offset;
+    }
+
+    /// @dev Returns price feed tree node, see `PriceFeedTreeNode` for detailed description of struct fields
+    function _getPriceFeedTreeNode(address priceFeed) internal view returns (PriceFeedTreeNode memory data) {
+        data.priceFeed = priceFeed;
+        data.decimals = IPriceFeed(priceFeed).decimals();
+
+        try ImplementsPriceFeedType(priceFeed).priceFeedType() returns (uint8 priceFeedType) {
+            data.priceFeedType = priceFeedType;
+        } catch {
+            data.priceFeedType = uint8(PriceFeedType.CHAINLINK_ORACLE);
+        }
+
+        try IPriceFeed(priceFeed).skipPriceCheck() returns (bool skipCheck) {
+            data.skipCheck = skipCheck;
+        } catch {}
+
+        try IUpdatablePriceFeed(priceFeed).updatable() returns (bool updatable) {
+            data.updatable = updatable;
+        } catch {}
+
+        try IStateSerializerTrait(priceFeed).serialize() returns (bytes memory specificParams) {
+            data.specificParams = specificParams;
+        } catch {
+            address serializer = serializers[data.priceFeedType];
+            if (serializer != address(0)) {
+                data.specificParams = IStateSerializer(serializer).serialize(priceFeed);
+            }
+        }
+
+        (data.underlyingFeeds, data.underlyingStalenessPeriods) = IPriceFeed(priceFeed).getUnderlyingFeeds();
+
+        try IPriceFeed(priceFeed).latestRoundData() returns (uint80, int256 price, uint256, uint256 updatedAt, uint80) {
+            data.answer = PriceFeedAnswer({price: price, updatedAt: updatedAt, success: true});
+        } catch {}
+    }
+}

package/contracts/compressors/Types.sol

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+/// @notice Credit account data
+/// @param  creditAccount Credit account address
+/// @param  creditManager Credit manager account is opened in
+/// @param  creditFacade Facade connected to account's credit manager
+/// @param  underlying Credit manager's underlying token
+/// @param  owner Credit account owner
+/// @param  enabledTokensMask Bitmask of tokens enabled on credit account as collateral
+/// @param  debt Credit account's debt principal in underlying
+/// @param  accruedInterest Base and quota interest accrued on the credit account
+/// @param  accruedFees Fees accrued on the credit account
+/// @param  totalDebtUSD Account's total debt in USD
+/// @param  totalValueUSD Account's total value in USD
+/// @param  twvUSD Account's threshold-weighted value in USD
+/// @param  totalValue Account's total value in underlying
+/// @param  healthFactor Account's health factor, i.e. ratio of `twvUSD` to `totalDebtUSD` with 18 decimals precision
+/// @param  success Whether collateral calculation was successful
+/// @param  tokens Info on all collateral tokens in account's credit manager ordered by their mask, see `TokenInfo`
+/// @dev    Fields from `totalDebtUSD` through `healthFactor` are not filled if `success` is `false`
+/// @dev    `debt`, `accruedInterest` and `accruedFees` don't account for transfer fees
+struct CreditAccountData {
+    address creditAccount;
+    address creditManager;
+    address creditFacade;
+    address underlying;
+    address owner;
+    uint256 enabledTokensMask;
+    uint256 debt;
+    uint256 accruedInterest;
+    uint256 accruedFees;
+    uint256 totalDebtUSD;
+    uint256 totalValueUSD;
+    uint256 twvUSD;
+    uint256 totalValue;
+    uint256 healthFactor;
+    bool success;
+    TokenInfo[] tokens;
+}
+
+/// @notice Credit account filters
+/// @param  owner If set, match credit accounts owned by given address
+/// @param  includeZeroDebt If set, also match accounts with zero debt
+/// @param  minHealthFactor If set, only return accounts with health factor above this value
+/// @param  maxHealthFactor If set, only return accounts with health factor below this value
+/// @param  reverting If set, only match accounts with reverting collateral calculation
+struct CreditAccountFilter {
+    address owner;
+    bool includeZeroDebt;
+    uint256 minHealthFactor;
+    uint256 maxHealthFactor;
+    bool reverting;
+}
+
+/// @notice Credit manager filters
+/// @param  curator If set, match credit managers managed by given curator
+/// @param  pool If set, match credit managers connected to a given pool
+/// @param  underlying If set, match credit managers with given underlying
+struct CreditManagerFilter {
+    address curator;
+    address pool;
+    address underlying;
+}
+
+/// @notice Price feed answer packed in a struct
+struct PriceFeedAnswer {
+    int256 price;
+    uint256 updatedAt;
+    bool success;
+}
+
+/// @notice Represents an entry in the price feed map of a price oracle
+/// @dev    `stalenessPeriod` is always 0 if price oracle's version is below `3_10`
+struct PriceFeedMapEntry {
+    address token;
+    bool reserve;
+    address priceFeed;
+    uint32 stalenessPeriod;
+}
+
+/// @notice Represents a node in the price feed "tree"
+/// @param  priceFeed Price feed address
+/// @param  decimals Price feed's decimals (might not be equal to 8 for lower-level)
+/// @param  priceFeedType Price feed type (same as `PriceFeedType` but annotated as `uint8` to support future types),
+///         defaults to `PriceFeedType.CHAINLINK_ORACLE`
+/// @param  skipCheck Whether price feed implements its own staleness and sanity check, defaults to `false`
+/// @param  updatable Whether it is an on-demand updatable (aka pull) price feed, defaults to `false`
+/// @param  specificParams ABI-encoded params specific to this price feed type, filled if price feed implements
+///         `IStateSerializerTrait` or there is a state serializer set for this type
+/// @param  underlyingFeeds Array of underlying feeds, filled when `priceFeed` is nested
+/// @param  underlyingStalenessPeriods Staleness periods of underlying feeds, filled when `priceFeed` is nested
+/// @param  answer Price feed answer packed in a struct
+struct PriceFeedTreeNode {
+    address priceFeed;
+    uint8 decimals;
+    uint8 priceFeedType;
+    bool skipCheck;
+    bool updatable;
+    bytes specificParams;
+    address[] underlyingFeeds;
+    uint32[] underlyingStalenessPeriods;
+    PriceFeedAnswer answer;
+}
+
+/// @notice Info on credit account's holdings of a token
+/// @param  token Token address
+/// @param  balance Account's balance of token
+/// @param  quota Account's quota of token
+/// @param  success Whether balance call was successful
+struct TokenInfo {
+    address token;
+    uint256 balance;
+    uint256 quota;
+    bool success;
+}

package/contracts/interfaces/IStateSerializer.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+/// @title State serializer
+/// @notice Generic interface of a contract that is able to serialize state of other contracts
+interface IStateSerializer {
+    function serialize(address) external view returns (bytes memory);
+}

package/contracts/interfaces/IStateSerializerTrait.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+/// @title State serializer trait
+/// @notice Generic interface of a contract that is able to serialize its own state
+interface IStateSerializerTrait {
+    function serialize() external view returns (bytes memory);
+}

package/contracts/libraries/NestedPriceFeeds.sol

@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+import {IPriceFeed} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IPriceFeed.sol";
+
+uint256 constant MAX_UNDERLYING_PRICE_FEEDS = 8;
+
+interface NestedPriceFeedWithSingleUnderlying is IPriceFeed {
+    function priceFeed() external view returns (address);
+    function stalenessPeriod() external view returns (uint32);
+}
+
+interface NestedPriceFeedWithMultipleUnderlyings is IPriceFeed {
+    function priceFeed0() external view returns (address);
+    function priceFeed1() external view returns (address);
+    function priceFeed2() external view returns (address);
+    function priceFeed3() external view returns (address);
+    function priceFeed4() external view returns (address);
+    function priceFeed5() external view returns (address);
+    function priceFeed6() external view returns (address);
+    function priceFeed7() external view returns (address);
+
+    function stalenessPeriod0() external view returns (uint32);
+    function stalenessPeriod1() external view returns (uint32);
+    function stalenessPeriod2() external view returns (uint32);
+    function stalenessPeriod3() external view returns (uint32);
+    function stalenessPeriod4() external view returns (uint32);
+    function stalenessPeriod5() external view returns (uint32);
+    function stalenessPeriod6() external view returns (uint32);
+    function stalenessPeriod7() external view returns (uint32);
+}
+
+library NestedPriceFeeds {
+    enum NestingType {
+        NO_NESTING,
+        SINGLE_UNDERLYING,
+        MULTIPLE_UNDERLYING
+    }
+
+    function getUnderlyingFeeds(IPriceFeed priceFeed)
+        internal
+        view
+        returns (address[] memory feeds, uint32[] memory stalenessPeriods)
+    {
+        NestingType nestingType = getNestingType(priceFeed);
+        if (nestingType == NestingType.SINGLE_UNDERLYING) {
+            (feeds, stalenessPeriods) = getSingleUnderlyingFeed(NestedPriceFeedWithSingleUnderlying(address(priceFeed)));
+        } else if (nestingType == NestingType.MULTIPLE_UNDERLYING) {
+            (feeds, stalenessPeriods) =
+                getMultipleUnderlyingFeeds(NestedPriceFeedWithMultipleUnderlyings(address(priceFeed)));
+        }
+    }
+
+    function getNestingType(IPriceFeed priceFeed) internal view returns (NestingType) {
+        try NestedPriceFeedWithSingleUnderlying(address(priceFeed)).priceFeed() returns (address) {
+            return NestingType.SINGLE_UNDERLYING;
+        } catch {}
+
+        try NestedPriceFeedWithMultipleUnderlyings(address(priceFeed)).priceFeed0() returns (address) {
+            return NestingType.MULTIPLE_UNDERLYING;
+        } catch {}
+
+        return NestingType.NO_NESTING;
+    }
+
+    function getSingleUnderlyingFeed(NestedPriceFeedWithSingleUnderlying priceFeed)
+        internal
+        view
+        returns (address[] memory feeds, uint32[] memory stalenessPeriods)
+    {
+        feeds = new address[](1);
+        stalenessPeriods = new uint32[](1);
+        (feeds[0], stalenessPeriods[0]) = (priceFeed.priceFeed(), priceFeed.stalenessPeriod());
+    }
+
+    function getMultipleUnderlyingFeeds(NestedPriceFeedWithMultipleUnderlyings priceFeed)
+        internal
+        view
+        returns (address[] memory feeds, uint32[] memory stalenessPeriods)
+    {
+        feeds = new address[](MAX_UNDERLYING_PRICE_FEEDS);
+        stalenessPeriods = new uint32[](MAX_UNDERLYING_PRICE_FEEDS);
+        for (uint256 i; i < MAX_UNDERLYING_PRICE_FEEDS; ++i) {
+            feeds[i] = _getPriceFeedByIndex(priceFeed, i);
+            if (feeds[i] == address(0)) {
+                assembly {
+                    mstore(feeds, i)
+                    mstore(stalenessPeriods, i)
+                }
+                break;
+            }
+            stalenessPeriods[i] = _getStalenessPeriodByIndex(priceFeed, i);
+        }
+    }
+
+    function _getPriceFeedByIndex(NestedPriceFeedWithMultipleUnderlyings priceFeed, uint256 index)
+        private
+        view
+        returns (address)
+    {
+        bytes4 selector;
+        if (index == 0) {
+            selector = priceFeed.priceFeed0.selector;
+        } else if (index == 1) {
+            selector = priceFeed.priceFeed1.selector;
+        } else if (index == 2) {
+            selector = priceFeed.priceFeed2.selector;
+        } else if (index == 3) {
+            selector = priceFeed.priceFeed3.selector;
+        } else if (index == 4) {
+            selector = priceFeed.priceFeed4.selector;
+        } else if (index == 5) {
+            selector = priceFeed.priceFeed5.selector;
+        } else if (index == 6) {
+            selector = priceFeed.priceFeed6.selector;
+        } else if (index == 7) {
+            selector = priceFeed.priceFeed7.selector;
+        }
+        (bool success, bytes memory result) = address(priceFeed).staticcall(abi.encodePacked(selector));
+        if (!success || result.length == 0) return address(0);
+        return abi.decode(result, (address));
+    }
+
+    function _getStalenessPeriodByIndex(NestedPriceFeedWithMultipleUnderlyings priceFeed, uint256 index)
+        private
+        view
+        returns (uint32)
+    {
+        bytes4 selector;
+        if (index == 0) {
+            selector = priceFeed.stalenessPeriod0.selector;
+        } else if (index == 1) {
+            selector = priceFeed.stalenessPeriod1.selector;
+        } else if (index == 2) {
+            selector = priceFeed.stalenessPeriod2.selector;
+        } else if (index == 3) {
+            selector = priceFeed.stalenessPeriod3.selector;
+        } else if (index == 4) {
+            selector = priceFeed.stalenessPeriod4.selector;
+        } else if (index == 5) {
+            selector = priceFeed.stalenessPeriod5.selector;
+        } else if (index == 6) {
+            selector = priceFeed.stalenessPeriod6.selector;
+        } else if (index == 7) {
+            selector = priceFeed.stalenessPeriod7.selector;
+        }
+        (bool success, bytes memory result) = address(priceFeed).staticcall(abi.encodePacked(selector));
+        if (!success || result.length == 0) return 0;
+        return abi.decode(result, (uint32));
+    }
+}

package/contracts/serializers/oracles/BPTWeightedPriceFeedSerializer.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+import {BPTWeightedPriceFeed} from "@gearbox-protocol/oracles-v3/contracts/oracles/balancer/BPTWeightedPriceFeed.sol";
+import {LPPriceFeedSerializer} from "./LPPriceFeedSerializer.sol";
+
+contract BPTWeightedPriceFeedSerializer is LPPriceFeedSerializer {
+    function serialize(address priceFeed) public view override returns (bytes memory) {
+        BPTWeightedPriceFeed pf = BPTWeightedPriceFeed(priceFeed);
+
+        uint256[8] memory weights = [
+            pf.weight0(),
+            pf.weight1(),
+            pf.weight2(),
+            pf.weight3(),
+            pf.weight4(),
+            pf.weight5(),
+            pf.weight6(),
+            pf.weight7()
+        ];
+
+        return abi.encode(super.serialize(priceFeed), pf.vault(), pf.poolId(), weights);
+    }
+}

package/contracts/serializers/oracles/BoundedPriceFeedSerializer.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+import {BoundedPriceFeed} from "@gearbox-protocol/oracles-v3/contracts/oracles/BoundedPriceFeed.sol";
+import {IStateSerializer} from "../../interfaces/IStateSerializer.sol";
+
+contract BoundedPriceFeedSerializer is IStateSerializer {
+    function serialize(address priceFeed) external view override returns (bytes memory) {
+        BoundedPriceFeed pf = BoundedPriceFeed(priceFeed);
+
+        return abi.encode(pf.upperBound());
+    }
+}

package/contracts/serializers/oracles/LPPriceFeedSerializer.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+import {ILPPriceFeed} from "@gearbox-protocol/oracles-v3/contracts/interfaces/ILPPriceFeed.sol";
+import {IStateSerializer} from "../../interfaces/IStateSerializer.sol";
+
+contract LPPriceFeedSerializer is IStateSerializer {
+    struct PriceData {
+        uint256 exchangeRate;
+        int256 aggregatePrice;
+        uint256 scale;
+        bool exchageRateSuccess;
+        bool aggregatePriceSuccess;
+    }
+
+    function serialize(address priceFeed) public view virtual override returns (bytes memory) {
+        ILPPriceFeed pf = ILPPriceFeed(priceFeed);
+
+        return abi.encode(
+            pf.lpToken(),
+            pf.lpContract(),
+            pf.lowerBound(),
+            pf.upperBound(),
+            pf.updateBoundsAllowed(),
+            pf.lastBoundsUpdate(),
+            _getPriceData(pf)
+        );
+    }
+
+    function _getPriceData(ILPPriceFeed priceFeed) internal view returns (PriceData memory data) {
+        try priceFeed.getLPExchangeRate() returns (uint256 rate) {
+            data.exchangeRate = rate;
+            data.exchageRateSuccess = true;
+        } catch {}
+
+        try priceFeed.getAggregatePrice() returns (int256 price) {
+            data.aggregatePrice = price;
+            data.aggregatePriceSuccess = true;
+        } catch {}
+
+        // safe to assume that `getScale` is non-reverting
+        data.scale = priceFeed.getScale();
+    }
+}

package/contracts/serializers/oracles/PythPriceFeedSerializer.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+import {PythPriceFeed} from "@gearbox-protocol/oracles-v3/contracts/oracles/updatable/PythPriceFeed.sol";
+import {IStateSerializer} from "../../interfaces/IStateSerializer.sol";
+
+contract PythPriceFeedSerializer is IStateSerializer {
+    function serialize(address priceFeed) external view override returns (bytes memory) {
+        PythPriceFeed pf = PythPriceFeed(payable(priceFeed));
+
+        return abi.encode(pf.token(), pf.priceFeedId(), pf.pyth());
+    }
+}

package/contracts/serializers/oracles/RedstonePriceFeedSerializer.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+import {RedstonePriceFeed} from "@gearbox-protocol/oracles-v3/contracts/oracles/updatable/RedstonePriceFeed.sol";
+import {IStateSerializer} from "../../interfaces/IStateSerializer.sol";
+
+contract RedstonePriceFeedSerializer is IStateSerializer {
+    function serialize(address priceFeed) external view override returns (bytes memory) {
+        RedstonePriceFeed pf = RedstonePriceFeed(priceFeed);
+
+        address[10] memory signers = [
+            pf.signerAddress0(),
+            pf.signerAddress1(),
+            pf.signerAddress2(),
+            pf.signerAddress3(),
+            pf.signerAddress4(),
+            pf.signerAddress5(),
+            pf.signerAddress6(),
+            pf.signerAddress7(),
+            pf.signerAddress8(),
+            pf.signerAddress9()
+        ];
+
+        return abi.encode(
+            pf.token(),
+            pf.dataFeedId(),
+            signers,
+            pf.getUniqueSignersThreshold(),
+            pf.lastPrice(),
+            pf.lastPayloadTimestamp()
+        );
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/periphery-v3",
-  "version": "1.7.0-next.1",
+  "version": "1.7.0-next.4",
   "main": "index.js",
   "repository": "git@github.com:Gearbox-protocol/periphery-v3.git",
   "author": "Mikael <26343374+0xmikko@users.noreply.github.com>",
@@ -15,13 +15,16 @@
   },
   "devDependencies": {
     "@1inch/solidity-utils": "^2.2.27",
+    "@chainlink/contracts": "^0.4.0",
     "@commitlint/cli": "^17.6.3",
     "@commitlint/config-conventional": "17.6.0",
-    "@gearbox-protocol/core-v3": "^1.50.0-next.14",
+    "@gearbox-protocol/core-v3": "^1.50.0-next.15",
+    "@gearbox-protocol/governance": "^1.4.0-next.5",
     "@gearbox-protocol/integrations-v3": "^1.23.1",
-    "@gearbox-protocol/oracles-v3": "^1.11.0-next.2",
+    "@gearbox-protocol/oracles-v3": "^1.11.0-next.3",
     "@gearbox-protocol/sdk-gov": "^2.3.1",
     "@openzeppelin/contracts": "^4.9.3",
+    "@redstone-finance/evm-connector": "0.2.5",
     "ds-test": "dapphub/ds-test",
     "forge-std": "foundry-rs/forge-std"
   },