@gearbox-protocol/periphery-v3 1.7.0-next.6 → 1.7.0-next.60

package/contracts/compressors/AdapterCompressor.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: BUSL-1.1
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2024
+pragma solidity ^0.8.17;
+
+import {IVersion} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol";
+import {IStateSerializer} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IStateSerializer.sol";
+import {AdapterType} from "@gearbox-protocol/sdk-gov/contracts/AdapterType.sol";
+import {AdapterState} from "../types/CreditSuiteData.sol";
+import {IAdapterCompressor} from "../interfaces/IAdapterCompressor.sol";
+import {ICreditConfiguratorV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditConfiguratorV3.sol";
+import {ICreditManagerV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditManagerV3.sol";
+import {AP_ADAPTER_COMPRESSOR} from "../libraries/Literals.sol";
+
+interface ILegacyAdapter {
+    function _gearboxAdapterVersion() external view returns (uint16);
+    function _gearboxAdapterType() external view returns (uint8);
+}
+
+contract AdapterCompressor is IAdapterCompressor {
+    uint256 public constant override version = 3_10;
+    bytes32 public constant override contractType = AP_ADAPTER_COMPRESSOR;
+
+    mapping(uint8 => bytes32) public contractTypes;
+
+    constructor() {
+        contractTypes[uint8(AdapterType.BALANCER_VAULT)] = "ADAPTER::BALANCER_VAULT";
+        contractTypes[uint8(AdapterType.BALANCER_V3_ROUTER)] = "ADAPTER::BALANCER_V3_ROUTER";
+        contractTypes[uint8(AdapterType.CAMELOT_V3_ROUTER)] = "ADAPTER::CAMELOT_V3_ROUTER";
+        contractTypes[uint8(AdapterType.CONVEX_V1_BASE_REWARD_POOL)] = "ADAPTER::CVX_V1_BASE_REWARD_POOL";
+        contractTypes[uint8(AdapterType.CONVEX_V1_BOOSTER)] = "ADAPTER::CVX_V1_BOOSTER";
+        contractTypes[uint8(AdapterType.CURVE_V1_2ASSETS)] = "ADAPTER::CURVE_V1_2ASSETS";
+        contractTypes[uint8(AdapterType.CURVE_V1_3ASSETS)] = "ADAPTER::CURVE_V1_3ASSETS";
+        contractTypes[uint8(AdapterType.CURVE_V1_4ASSETS)] = "ADAPTER::CURVE_V1_4ASSETS";
+        contractTypes[uint8(AdapterType.CURVE_STABLE_NG)] = "ADAPTER::CURVE_STABLE_NG";
+        contractTypes[uint8(AdapterType.CURVE_V1_STECRV_POOL)] = "ADAPTER::CURVE_V1_STECRV_POOL";
+        contractTypes[uint8(AdapterType.CURVE_V1_WRAPPER)] = "ADAPTER::CURVE_V1_WRAPPER";
+        contractTypes[uint8(AdapterType.DAI_USDS_EXCHANGE)] = "ADAPTER::DAI_USDS_EXCHANGE";
+        contractTypes[uint8(AdapterType.EQUALIZER_ROUTER)] = "ADAPTER::EQUALIZER_ROUTER";
+        contractTypes[uint8(AdapterType.ERC4626_VAULT)] = "ADAPTER::ERC4626_VAULT";
+        contractTypes[uint8(AdapterType.LIDO_V1)] = "ADAPTER::LIDO_V1";
+        contractTypes[uint8(AdapterType.LIDO_WSTETH_V1)] = "ADAPTER::LIDO_WSTETH_V1";
+        contractTypes[uint8(AdapterType.MELLOW_ERC4626_VAULT)] = "ADAPTER::MELLOW_ERC4626_VAULT";
+        contractTypes[uint8(AdapterType.MELLOW_LRT_VAULT)] = "ADAPTER::MELLOW_LRT_VAULT";
+        contractTypes[uint8(AdapterType.PENDLE_ROUTER)] = "ADAPTER::PENDLE_ROUTER";
+        contractTypes[uint8(AdapterType.STAKING_REWARDS)] = "ADAPTER::STAKING_REWARDS";
+        contractTypes[uint8(AdapterType.UNISWAP_V2_ROUTER)] = "ADAPTER::UNISWAP_V2_ROUTER";
+        contractTypes[uint8(AdapterType.UNISWAP_V3_ROUTER)] = "ADAPTER::UNISWAP_V3_ROUTER";
+        contractTypes[uint8(AdapterType.VELODROME_V2_ROUTER)] = "ADAPTER::VELODROME_V2_ROUTER";
+        contractTypes[uint8(AdapterType.YEARN_V2)] = "ADAPTER::YEARN_V2";
+        contractTypes[uint8(AdapterType.ZIRCUIT_POOL)] = "ADAPTER::ZIRCUIT_POOL";
+    }
+
+    function getAdapters(address creditManager) external view returns (AdapterState[] memory adapters) {
+        ICreditConfiguratorV3 creditConfigurator =
+            ICreditConfiguratorV3(ICreditManagerV3(creditManager).creditConfigurator());
+
+        address[] memory allowedAdapters = creditConfigurator.allowedAdapters();
+        uint256 len = allowedAdapters.length;
+
+        adapters = new AdapterState[](len);
+        unchecked {
+            for (uint256 i = 0; i < len; ++i) {
+                address adapter = allowedAdapters[i];
+                adapters[i].baseParams.addr = adapter;
+                try IVersion(adapter).contractType() returns (bytes32 contractType_) {
+                    adapters[i].baseParams.contractType = contractType_;
+                } catch {
+                    adapters[i].baseParams.contractType = contractTypes[ILegacyAdapter(adapter)._gearboxAdapterType()];
+                }
+
+                try IVersion(adapter).version() returns (uint256 v) {
+                    adapters[i].baseParams.version = v;
+                } catch {
+                    adapters[i].baseParams.version = ILegacyAdapter(adapter)._gearboxAdapterVersion();
+                }
+
+                try IStateSerializer(adapter).serialize() returns (bytes memory serializedParams) {
+                    adapters[i].baseParams.serializedParams = serializedParams;
+                } catch {}
+
+                adapters[i].targetContract = ICreditManagerV3(creditManager).adapterToContract(adapter);
+            }
+        }
+    }
+}

package/contracts/compressors/CreditAccountCompressor.sol

@@ -3,55 +3,67 @@
 // (c) Gearbox Foundation, 2024.
 pragma solidity ^0.8.17;
 
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 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 {ICreditFacadeV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditFacadeV3.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 {ICreditAccountCompressor} from "../interfaces/ICreditAccountCompressor.sol";
 
-import {IAddressProviderV3} from "@gearbox-protocol/governance/contracts/interfaces/IAddressProviderV3.sol";
-import {IMarketConfiguratorV3} from "@gearbox-protocol/governance/contracts/interfaces/IMarketConfiguratorV3.sol";
+import {IContractsRegister} from "@gearbox-protocol/governance/contracts/interfaces/IContractsRegister.sol";
+import {IAddressProvider} from "@gearbox-protocol/governance/contracts/interfaces/IAddressProvider.sol";
+import {IMarketConfigurator} from "@gearbox-protocol/governance/contracts/interfaces/IMarketConfigurator.sol";
+import {IMarketConfiguratorFactory} from
+    "@gearbox-protocol/governance/contracts/interfaces/IMarketConfiguratorFactory.sol";
+import {
+    AP_MARKET_CONFIGURATOR_FACTORY,
+    NO_VERSION_CONTROL
+} from "@gearbox-protocol/governance/contracts/libraries/ContractLiterals.sol";
 
-import {CreditAccountData, CreditAccountFilter, CreditManagerFilter, Pagination, TokenInfo} from "./Types.sol";
+import {CreditAccountData, TokenInfo} from "../types/CreditAccountState.sol";
+import {CreditAccountFilter, MarketFilter} from "../types/Filters.sol";
 
+import {Contains} from "../libraries/Contains.sol";
+import {AP_CREDIT_ACCOUNT_COMPRESSOR} from "../libraries/Literals.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,
-///         but additional pagination options are available, see `Pagination`
-contract CreditAccountCompressor is IVersion, SanityCheckTrait {
+/// @dev    Querying functions try to process as many accounts as possible and stop when they get close to gas limit
+
+contract CreditAccountCompressor is ICreditAccountCompressor, SanityCheckTrait {
+    using Contains for address[];
+
     /// @notice Contract version
     uint256 public constant override version = 3_10;
+    bytes32 public constant override contractType = AP_CREDIT_ACCOUNT_COMPRESSOR;
 
     /// @notice Address provider contract address
-    address public immutable ADDRESS_PROVIDER;
+    address public immutable addressProvider;
 
-    /// @dev Amount of gas that covers filter matching and data preparation for a single account
-    /// @dev After processing a large number of accounts, gas costs might eventually exceed this number due to
-    ///      quadratic memory expansion cost and memory always growing in Solidity
-    uint256 internal constant GAS_THRESHOLD = 2e6;
+    address public immutable marketConfiguratorFactory;
 
-    /// @notice Thrown when address provider is not a contract or does not implement `marketConfigurators()`
+    /// @notice Thrown when address provider is not a contract
     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 {
+    /// @param  addressProvider_ Address provider contract address
+    constructor(address addressProvider_) nonZeroAddress(addressProvider_) {
+        if (addressProvider_.code.length == 0) {
             revert InvalidAddressProviderException();
         }
-        ADDRESS_PROVIDER = addressProvider;
+
+        addressProvider = addressProvider_;
+        marketConfiguratorFactory =
+            IAddressProvider(addressProvider_).getAddressOrRevert(AP_MARKET_CONFIGURATOR_FACTORY, NO_VERSION_CONTROL);
     }
 
     // -------- //
@@ -64,163 +76,77 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
         return _getCreditAccountData(creditAccount, creditManager);
     }
 
-    /// @notice Returns data for credit accounts that match `caFilter` in credit managers matching `cmFilter`
-    /// @dev    The `false` value of `finished` return variable indicates either that return limit was reached or
-    ///         that gas supplied with a call was insufficient to process all the accounts and next iteration is
-    ///         needed which should start from the `nextOffset` position
+    /// @notice Returns data for credit accounts that match `caFilter` in credit managers matching `marketFilter`
+    /// @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(MarketFilter memory marketFilter, CreditAccountFilter memory caFilter, uint256 offset)
+        external
+        view
+        returns (CreditAccountData[] memory data, uint256 nextOffset)
+    {
+        address[] memory creditManagers = _getCreditManagers(marketFilter);
+        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,
+        MarketFilter memory marketFilter,
         CreditAccountFilter memory caFilter,
-        Pagination memory pagination
-    ) external view returns (CreditAccountData[] memory data, bool finished, uint256 nextOffset) {
-        uint256 num = countCreditAccounts(cmFilter, caFilter, pagination);
-        if (num == 0) return (data, true, 0);
-
-        // create a second object to avoid modifying `pagination` which can have side-effects in the calling code
-        Pagination memory _p = Pagination({
-            offset: pagination.offset,
-            scanLimit: pagination.scanLimit == 0 ? type(uint256).max : pagination.scanLimit,
-            returnLimit: pagination.returnLimit == 0 ? type(uint256).max : pagination.returnLimit
-        });
-
-        data = new CreditAccountData[](Math.min(_p.returnLimit, num));
-        uint256 dataOffset;
-
-        nextOffset = _p.offset;
-        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 <= _p.offset) {
-                _p.offset -= len;
-                continue;
-            }
-
-            uint256 limit = Math.min(len - _p.offset, _p.scanLimit);
-
-            uint256 scanned;
-            (dataOffset, scanned) = _getCreditAccounts({
-                creditManager: creditManagers[i],
-                filter: caFilter,
-                data: data,
-                dataOffset: dataOffset,
-                offset: _p.offset,
-                limit: limit
-            });
-            nextOffset += scanned;
-
-            // either finished or reached one of return size or gas limits
-            if (dataOffset == data.length || scanned < limit) break;
-
-            _p.scanLimit -= limit;
-            if (_p.scanLimit == 0) break;
-            _p.offset = 0;
-        }
-
-        if (dataOffset < data.length) {
-            // trim the array to its actual size
-            assembly {
-                mstore(data, dataOffset)
-            }
-        }
-
-        return (data, dataOffset == num, nextOffset);
+        uint256 offset,
+        uint256 limit
+    ) public view returns (CreditAccountData[] memory data, uint256 nextOffset) {
+        address[] memory creditManagers = _getCreditManagers(marketFilter);
+        return _getCreditAccounts(creditManagers, caFilter, offset, limit);
     }
 
     /// @notice Returns data for credit accounts that match `caFilter` in a given `creditManager`
-    /// @dev    The `false` value of `finished` return variable indicates either that return limit was reached or
-    ///         that gas supplied with a call was insufficient to process all the accounts and next iteration is
-    ///         needed which should start from the `nextOffset` position
-    function getCreditAccounts(address creditManager, CreditAccountFilter memory caFilter, Pagination memory pagination)
+    /// @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, bool finished, uint256 nextOffset)
+        returns (CreditAccountData[] memory data, uint256 nextOffset)
     {
-        uint256 num = countCreditAccounts(creditManager, caFilter, pagination);
-        if (num == 0) return (data, true, 0);
-
-        // create a second object to avoid modifying `pagination` which can have side-effects in the calling code
-        Pagination memory _p = Pagination({
-            offset: pagination.offset,
-            scanLimit: pagination.scanLimit == 0 ? type(uint256).max : pagination.scanLimit,
-            returnLimit: pagination.returnLimit == 0 ? type(uint256).max : pagination.returnLimit
-        });
-
-        data = new CreditAccountData[](Math.min(_p.returnLimit, num));
-        uint256 dataOffset;
-
-        uint256 len = ICreditManagerV3(creditManager).creditAccountsLen();
-        // since `num != 0`, we can be sure that `len > offset`
-        uint256 limit = Math.min(_p.scanLimit, len - _p.offset);
-
-        uint256 scanned;
-        (dataOffset, scanned) = _getCreditAccounts({
-            creditManager: creditManager,
-            filter: caFilter,
-            data: data,
-            dataOffset: 0,
-            offset: _p.offset,
-            limit: limit
-        });
-        nextOffset = _p.offset + scanned;
-
-        if (dataOffset < data.length) {
-            // trim the array to its actual size
-            assembly {
-                mstore(data, dataOffset)
-            }
-        }
+        address[] memory creditManagers = new address[](1);
+        creditManagers[0] = creditManager;
+        return _getCreditAccounts(creditManagers, caFilter, offset, type(uint256).max);
+    }
 
-        return (data, dataOffset == num, nextOffset);
+    /// @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,
-        Pagination memory pagination
-    ) public view returns (uint256 num) {
-        uint256 offset = pagination.offset;
-        uint256 scanLimit = pagination.scanLimit == 0 ? type(uint256).max : pagination.scanLimit;
-
-        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;
-            }
-
-            uint256 limit = Math.min(len - offset, scanLimit);
-            num += _countCreditAccounts(creditManagers[i], caFilter, offset, limit);
-
-            scanLimit -= limit;
-            if (scanLimit == 0) break;
-            offset = 0;
-        }
+    /// @notice Counts credit accounts that match `caFilter` in credit managers matching `marketFilter`
+    function countCreditAccounts(MarketFilter memory marketFilter, CreditAccountFilter memory caFilter)
+        external
+        view
+        returns (uint256)
+    {
+        address[] memory creditManagers = _getCreditManagers(marketFilter);
+        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,
-        Pagination memory pagination
-    ) public view returns (uint256) {
-        uint256 offset = pagination.offset;
-        uint256 scanLimit = pagination.scanLimit == 0 ? type(uint256).max : pagination.scanLimit;
-
-        uint256 len = ICreditManagerV3(creditManager).creditAccountsLen();
-        if (len <= offset) return 0;
-        uint256 limit = Math.min(len - offset, scanLimit);
-
-        return _countCreditAccounts(creditManager, caFilter, offset, limit);
+    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);
     }
 
     // --------- //
@@ -229,37 +155,108 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
 
     /// @dev Querying implementation
     function _getCreditAccounts(
-        address creditManager,
+        address[] memory creditManagers,
         CreditAccountFilter memory filter,
-        CreditAccountData[] memory data,
-        uint256 dataOffset,
         uint256 offset,
         uint256 limit
-    ) internal view returns (uint256 nextDataOffset, uint256 scanned) {
-        address[] memory creditAccounts = ICreditManagerV3(creditManager).creditAccounts(offset, limit);
-        for (uint256 i; i < creditAccounts.length; ++i) {
-            if (_checkFilterMatch(creditAccounts[i], creditManager, filter)) {
-                data[dataOffset++] = _getCreditAccountData(creditAccounts[i], creditManager);
+    ) 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;
             }
 
-            // either finished or reached one of return size or gas limits
-            if (dataOffset == data.length || gasleft() < GAS_THRESHOLD) return (dataOffset, i + 1);
+            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)
         }
-        return (dataOffset, creditAccounts.length);
+
+        // set `nextOffset` to zero to indicate that scanning is finished
+        if (dataOffset == num) nextOffset = 0;
     }
 
     /// @dev Counting implementation
     function _countCreditAccounts(
-        address creditManager,
+        address[] memory creditManagers,
         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;
+        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;
         }
     }
 
@@ -274,6 +271,7 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
         data.creditFacade = ICreditManagerV3(creditManager).creditFacade();
         data.underlying = ICreditManagerV3(creditManager).underlying();
         data.owner = ICreditManagerV3(creditManager).getBorrowerOrRevert(creditAccount);
+        data.expirationDate = ICreditFacadeV3(data.creditFacade).expirationDate();
 
         CollateralDebtData memory cdd =
             ICreditManagerV3(creditManager).calcDebtAndCollateral(creditAccount, CollateralCalcTask.DEBT_ONLY);
@@ -285,21 +283,41 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
         // 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.totalDebtUSD = cdd_.totalDebtUSD;
             data.totalValueUSD = cdd_.totalValueUSD;
             data.twvUSD = cdd_.twvUSD;
-            data.totalValue = cdd.totalValue;
+            data.totalValue = cdd_.totalValue;
 
-            data.healthFactor = cdd.twvUSD * PERCENTAGE_FACTOR >= type(uint16).max * cdd.totalDebtUSD
+            data.healthFactor = cdd_.twvUSD * PERCENTAGE_FACTOR >= type(uint16).max * cdd_.totalDebtUSD
                 ? type(uint16).max
-                : uint16(cdd.twvUSD * PERCENTAGE_FACTOR / cdd.totalDebtUSD);
+                : uint16((cdd_.twvUSD * PERCENTAGE_FACTOR) / cdd_.totalDebtUSD);
             data.success = true;
         } catch {}
 
-        uint256 numTokens = ICreditManagerV3(creditManager).collateralTokensCount();
+        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);
-        for (uint256 i; i < numTokens; ++i) {
-            uint256 mask = 1 << i;
+        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;
@@ -313,6 +331,9 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
                 (data.tokens[i].quota,) =
                     IPoolQuotaKeeperV3(cdd._poolQuotaKeeper).getQuotaAndOutstandingInterest(creditAccount, token);
             }
+
+            returnedTokensMask ^= mask;
+            ++i;
         }
     }
 
@@ -338,7 +359,7 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
                 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);
+                    : 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 {
@@ -350,45 +371,34 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
     }
 
     /// @dev Credit managers discovery
-    function _getCreditManagers(CreditManagerFilter memory filter)
-        internal
-        view
-        returns (address[] memory creditManagers)
-    {
-        address[] memory configurators = IAddressProviderV3(ADDRESS_PROVIDER).marketConfigurators();
+    function _getCreditManagers(MarketFilter memory filter) internal view returns (address[] memory creditManagers) {
+        address[] memory configurators = filter.configurators.length != 0
+            ? filter.configurators
+            : IMarketConfiguratorFactory(marketConfiguratorFactory).getMarketConfigurators();
 
         // rough estimate of maximum number of credit managers
         uint256 max;
         for (uint256 i; i < configurators.length; ++i) {
-            address cr = IMarketConfiguratorV3(configurators[i]).contractsRegister();
+            address cr = IMarketConfigurator(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)
+        // 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 memory 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 cr = IMarketConfigurator(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;
+                address manager = managers[j];
+                // FIXME: there's room for optimization that allows to avoid scanning over all configurators
+                if (filter.pools.length != 0 && !filter.pools.contains(ICreditManagerV3(manager).pool())) continue;
+                if (filter.underlying != address(0) && ICreditManagerV3(manager).underlying() != filter.underlying) {
+                    continue;
                 }
 
-                creditManagers[num++] = managers[j];
+                creditManagers[num++] = manager;
             }
         }