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

package/contracts/compressors/CreditAccountCompressor.sol

@@ -0,0 +1,402 @@
+// 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 {Math} from "@openzeppelin/contracts/utils/math/Math.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 {PERCENTAGE_FACTOR} from "@gearbox-protocol/core-v3/contracts/libraries/Constants.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    Querying functions try to process as many accounts as possible and stop when they get close to gas limit
+contract CreditAccountCompressor is IVersion, SanityCheckTrait {
+    /// @notice Contract version
+    uint256 public constant override version = 3_10;
+
+    /// @notice Address provider contract address
+    address public immutable ADDRESS_PROVIDER;
+
+    /// @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();
+        }
+        ADDRESS_PROVIDER = 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 non-zero value of `nextOffset` return variable indicates that gas supplied with a call was
+    ///         insufficient to process all the accounts and next iteration starting from this value is needed
+    function getCreditAccounts(CreditManagerFilter memory cmFilter, CreditAccountFilter memory caFilter, uint256 offset)
+        external
+        view
+        returns (CreditAccountData[] memory data, uint256 nextOffset)
+    {
+        address[] memory creditManagers = _getCreditManagers(cmFilter);
+        return _getCreditAccounts(creditManagers, caFilter, offset, type(uint256).max);
+    }
+
+    /// @dev Same as above but with `limit` parameter that specifies the number of accounts to process
+    function getCreditAccounts(
+        CreditManagerFilter memory cmFilter,
+        CreditAccountFilter memory caFilter,
+        uint256 offset,
+        uint256 limit
+    ) public view returns (CreditAccountData[] memory data, uint256 nextOffset) {
+        address[] memory creditManagers = _getCreditManagers(cmFilter);
+        return _getCreditAccounts(creditManagers, caFilter, offset, limit);
+    }
+
+    /// @notice Returns data for credit accounts that match `caFilter` in a given `creditManager`
+    /// @dev    The non-zero value of `nextOffset` return variable indicates that gas supplied with a call was
+    ///         insufficient to process all the accounts and next iteration starting from this value is needed
+    function getCreditAccounts(address creditManager, CreditAccountFilter memory caFilter, uint256 offset)
+        external
+        view
+        returns (CreditAccountData[] memory data, uint256 nextOffset)
+    {
+        address[] memory creditManagers = new address[](1);
+        creditManagers[0] = creditManager;
+        return _getCreditAccounts(creditManagers, caFilter, offset, type(uint256).max);
+    }
+
+    /// @dev Same as above but with `limit` parameter that specifies the number of accounts to process
+    function getCreditAccounts(
+        address creditManager,
+        CreditAccountFilter memory caFilter,
+        uint256 offset,
+        uint256 limit
+    ) external view returns (CreditAccountData[] memory data, uint256 nextOffset) {
+        address[] memory creditManagers = new address[](1);
+        creditManagers[0] = creditManager;
+        return _getCreditAccounts(creditManagers, caFilter, offset, limit);
+    }
+
+    // -------- //
+    // COUNTING //
+    // -------- //
+
+    /// @notice Counts credit accounts that match `caFilter` in credit managers matching `cmFilter`
+    function countCreditAccounts(CreditManagerFilter memory cmFilter, CreditAccountFilter memory caFilter)
+        external
+        view
+        returns (uint256)
+    {
+        address[] memory creditManagers = _getCreditManagers(cmFilter);
+        return _countCreditAccounts(creditManagers, caFilter, 0, type(uint256).max);
+    }
+
+    /// @notice Counts credit accounts that match `caFilter` in a given `creditManager`
+    function countCreditAccounts(address creditManager, CreditAccountFilter memory caFilter)
+        external
+        view
+        returns (uint256)
+    {
+        address[] memory creditManagers = new address[](1);
+        creditManagers[0] = creditManager;
+        return _countCreditAccounts(creditManagers, caFilter, 0, type(uint256).max);
+    }
+
+    // --------- //
+    // INTERNALS //
+    // --------- //
+
+    /// @dev Querying implementation
+    function _getCreditAccounts(
+        address[] memory creditManagers,
+        CreditAccountFilter memory filter,
+        uint256 offset,
+        uint256 limit
+    ) internal view returns (CreditAccountData[] memory data, uint256 nextOffset) {
+        uint256 num = _countCreditAccounts(creditManagers, filter, offset, limit);
+        if (num == 0) return (data, 0);
+
+        // allocating the `CreditAccountData` array might consume most of the gas leaving no room for computations,
+        // so we instead allocate and gradually fill the array of pointers to structs which takes much less space
+        bytes32[] memory dataPointers = new bytes32[](num);
+        uint256 dataOffset;
+
+        // to adjust to RPC provider's call gas limit, the function stops when gas left gets below gas reserve, which
+        // starts at this number that should be enough to cover a single account processing, and increases with each
+        // new data struct to accommodate the cost of memory expansion that happens upon ABI-encoding returned data
+        uint256 gasReserve = 2e6;
+
+        nextOffset = offset;
+        for (uint256 i; i < creditManagers.length; ++i) {
+            address creditManager = creditManagers[i];
+            uint256 len = ICreditManagerV3(creditManager).creditAccountsLen();
+
+            // first, we need to get to the `offset` position
+            if (len <= offset) {
+                offset -= len;
+                continue;
+            }
+
+            uint256 count = Math.min(len - offset, limit);
+            address[] memory creditAccounts = ICreditManagerV3(creditManager).creditAccounts(offset, count);
+
+            // circumvent the "Stack too deep." error
+            CreditAccountFilter memory filter_ = filter;
+
+            for (uint256 j; j < creditAccounts.length; ++j) {
+                address creditAccount = creditAccounts[j];
+                if (_checkFilterMatch(creditAccount, creditManager, filter_)) {
+                    uint256 gasBefore = gasleft();
+
+                    CreditAccountData memory d = _getCreditAccountData(creditAccount, creditManager);
+                    ++dataOffset;
+                    assembly {
+                        // save the pointer to created struct
+                        mstore(add(dataPointers, mul(0x20, dataOffset)), d)
+                    }
+
+                    // rough approximation of gas that will be needed to accommodate additional memory expansion cost
+                    gasReserve += (gasBefore - gasleft()) / 2;
+                }
+                --count;
+
+                if (dataOffset == num || gasleft() < gasReserve) break;
+            }
+
+            nextOffset += creditAccounts.length - count;
+            if (dataOffset == num || count != 0) break;
+
+            limit -= creditAccounts.length;
+            if (limit == 0) break;
+            offset = 0;
+        }
+
+        assembly {
+            // cast array of pointers to structs to array of structs
+            data := dataPointers
+            // trim array to its actual size
+            mstore(data, dataOffset)
+        }
+
+        // set `nextOffset` to zero to indicate that scanning is finished
+        if (dataOffset == num) nextOffset = 0;
+    }
+
+    /// @dev Counting implementation
+    function _countCreditAccounts(
+        address[] memory creditManagers,
+        CreditAccountFilter memory filter,
+        uint256 offset,
+        uint256 limit
+    ) internal view returns (uint256 num) {
+        for (uint256 i; i < creditManagers.length; ++i) {
+            address creditManager = creditManagers[i];
+            uint256 len = ICreditManagerV3(creditManager).creditAccountsLen();
+
+            // first, we need to get to the `offset` position
+            if (len <= offset) {
+                offset -= len;
+                continue;
+            }
+
+            address[] memory creditAccounts =
+                ICreditManagerV3(creditManager).creditAccounts(offset, Math.min(len - offset, limit));
+            for (uint256 j; j < creditAccounts.length; ++j) {
+                if (_checkFilterMatch(creditAccounts[j], creditManager, filter)) {
+                    ++num;
+                }
+            }
+
+            limit -= creditAccounts.length;
+            if (limit == 0) break;
+            offset = 0;
+        }
+    }
+
+    /// @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_.twvUSD * PERCENTAGE_FACTOR >= type(uint16).max * cdd_.totalDebtUSD
+                ? type(uint16).max
+                : uint16(cdd_.twvUSD * PERCENTAGE_FACTOR / cdd_.totalDebtUSD);
+            data.success = true;
+        } catch {}
+
+        uint256 maxTokens = ICreditManagerV3(creditManager).collateralTokensCount();
+
+        // the function is called for every account, so allocating an array of size `maxTokens` and trimming it
+        // might cause issues with memory expansion and we must count the precise number of tokens in advance
+        uint256 numTokens;
+        uint256 returnedTokensMask;
+        for (uint256 k; k < maxTokens; ++k) {
+            uint256 mask = 1 << k;
+            if (cdd.enabledTokensMask & mask == 0) {
+                address token = ICreditManagerV3(creditManager).getTokenByMask(mask);
+                try IERC20(token).balanceOf(creditAccount) returns (uint256 balance) {
+                    if (balance <= 1) continue;
+                } catch {
+                    continue;
+                }
+            }
+            ++numTokens;
+            returnedTokensMask |= mask;
+        }
+
+        data.tokens = new TokenInfo[](numTokens);
+        uint256 i;
+        while (returnedTokensMask != 0) {
+            uint256 mask = returnedTokensMask & uint256(-int256(returnedTokensMask));
+            address token = ICreditManagerV3(creditManager).getTokenByMask(mask);
+            data.tokens[i].token = token;
+            data.tokens[i].mask = mask;
+
+            try IERC20(token).balanceOf(creditAccount) returns (uint256 balance) {
+                data.tokens[i].balance = balance;
+                data.tokens[i].success = true;
+            } catch {}
+
+            if (IPoolQuotaKeeperV3(cdd._poolQuotaKeeper).isQuotedToken(token)) {
+                (data.tokens[i].quota,) =
+                    IPoolQuotaKeeperV3(cdd._poolQuotaKeeper).getQuotaAndOutstandingInterest(creditAccount, token);
+            }
+
+            returnedTokensMask ^= mask;
+            ++i;
+        }
+    }
+
+    /// @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;
+                uint16 healthFactor = cdd.twvUSD * PERCENTAGE_FACTOR >= type(uint16).max * cdd.totalDebtUSD
+                    ? type(uint16).max
+                    : uint16(cdd.twvUSD * PERCENTAGE_FACTOR / 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(ADDRESS_PROVIDER).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 and the function is only called once, so memary expansion cost is not an issue)
+        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[j]).version();
+                if (ver < 3_00 || ver > 3_99) continue;
+
+                if (filter.pool != address(0)) {
+                    if (ICreditManagerV3(managers[j]).pool() != filter.pool) continue;
+                }
+
+                if (filter.underlying != address(0)) {
+                    if (ICreditManagerV3(managers[j]).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,224 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2024.
+pragma solidity ^0.8.17;
+
+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 {IStateSerializerLegacy} from "../interfaces/IStateSerializerLegacy.sol";
+import {IStateSerializer} from "../interfaces/IStateSerializer.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, reverts if price feed is not set
+    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 {
+    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 `IStateSerializer` 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
+    /// @dev    Sets serializers for existing price feed types.
+    ///         It is recommended to implement `IStateSerializer` in new price feeds.
+    constructor() {
+        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 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.
+    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);
+        }
+        // trim array to its actual size in case there were duplicates
+        assembly {
+            mstore(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) {
+            try IPriceOracleV3Legacy(priceOracle).priceFeedsRaw(token, reserve) returns (address priceFeed) {
+                // legacy oracle does not allow to fetch staleness period of a non-active feed
+                return (priceFeed, 0);
+            } catch {
+                return (address(0), 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)
+    {
+        // duplicates are possible since price feed can be in `priceFeedMap` for more than one (token, reserve) pair
+        // or serve as an underlying in more than one nested feed, and the whole subtree can be skipped in this case
+        for (uint256 i; i < offset; ++i) {
+            if (priceFeedTree[i].priceFeed == priceFeed) return offset;
+        }
+
+        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 IStateSerializer(priceFeed).serialize() returns (bytes memory specificParams) {
+            data.specificParams = specificParams;
+        } catch {
+            address serializer = serializers[data.priceFeedType];
+            if (serializer != address(0)) {
+                data.specificParams = IStateSerializerLegacy(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,120 @@
+// 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's 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`, in bps
+/// @param  success Whether collateral calculation was successful
+/// @param  tokens Info on credit account's enabled tokens and tokens with non-zero balance, 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;
+    uint16 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;
+    uint16 minHealthFactor;
+    uint16 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
+///         `IStateSerializer` 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  mask Token mask in the credit manager
+/// @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 mask;
+    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 trait
+/// @notice Generic interface of a contract that is able to serialize its own state
+interface IStateSerializer {
+    function serialize() external view returns (bytes memory);
+}

package/contracts/interfaces/IStateSerializerLegacy.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 IStateSerializerLegacy {
+    function serialize(address) 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 {IStateSerializerLegacy} from "../../interfaces/IStateSerializerLegacy.sol";
+
+contract BoundedPriceFeedSerializer is IStateSerializerLegacy {
+    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 {IStateSerializerLegacy} from "../../interfaces/IStateSerializerLegacy.sol";
+
+contract LPPriceFeedSerializer is IStateSerializerLegacy {
+    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 {IStateSerializerLegacy} from "../../interfaces/IStateSerializerLegacy.sol";
+
+contract PythPriceFeedSerializer is IStateSerializerLegacy {
+    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 {IStateSerializerLegacy} from "../../interfaces/IStateSerializerLegacy.sol";
+
+contract RedstonePriceFeedSerializer is IStateSerializerLegacy {
+    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.11",
   "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"
   },