@gearbox-protocol/periphery-v3 1.0.2

package/README.md

@@ -0,0 +1,66 @@
+## Foundry
+
+**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
+
+Foundry consists of:
+
+-   **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
+-   **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
+-   **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
+-   **Chisel**: Fast, utilitarian, and verbose solidity REPL.
+
+## Documentation
+
+https://book.getfoundry.sh/
+
+## Usage
+
+### Build
+
+```shell
+$ forge build
+```
+
+### Test
+
+```shell
+$ forge test
+```
+
+### Format
+
+```shell
+$ forge fmt
+```
+
+### Gas Snapshots
+
+```shell
+$ forge snapshot
+```
+
+### Anvil
+
+```shell
+$ anvil
+```
+
+### Deploy
+
+```shell
+$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
+```
+
+### Cast
+
+```shell
+$ cast <subcommand>
+```
+
+### Help
+
+```shell
+$ forge --help
+$ anvil --help
+$ cast --help
+```

package/contracts/data/DataCompressor_2_1.sol

@@ -0,0 +1,318 @@
+// SPDX-License-Identifier: BUSL-1.1
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2022
+pragma solidity ^0.8.10;
+pragma experimental ABIEncoderV2;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
+
+import {PERCENTAGE_FACTOR} from "@gearbox-protocol/core-v2/contracts/libraries/PercentageMath.sol";
+
+import {ContractsRegisterTrait} from "@gearbox-protocol/core-v3/contracts/traits/ContractsRegisterTrait.sol";
+import {IContractsRegister} from "@gearbox-protocol/core-v2/contracts/interfaces/IContractsRegister.sol";
+
+import {ICreditManagerV2} from "@gearbox-protocol/core-v2/contracts/interfaces/ICreditManagerV2.sol";
+import {ICreditFacadeV2} from "@gearbox-protocol/core-v2/contracts/interfaces/ICreditFacadeV2.sol";
+import {ICreditConfiguratorV2} from "@gearbox-protocol/core-v2/contracts/interfaces/ICreditConfiguratorV2.sol";
+import {ICreditAccount} from "@gearbox-protocol/core-v2/contracts/interfaces/ICreditAccount.sol";
+import {IPoolService} from "@gearbox-protocol/core-v2/contracts/interfaces/IPoolService.sol";
+
+import {IVersion} from "@gearbox-protocol/core-v2/contracts/interfaces/IVersion.sol";
+
+import {IAddressProvider} from "@gearbox-protocol/core-v2/contracts/interfaces/IAddressProvider.sol";
+import {IDataCompressorV2_10} from "../interfaces/IDataCompressorV2_10.sol";
+
+import {CreditAccountData, CreditManagerData, PoolData, TokenBalance, ContractAdapter} from "./Types.sol";
+
+// EXCEPTIONS
+import {ZeroAddressException} from "@gearbox-protocol/core-v2/contracts/interfaces/IErrors.sol";
+
+/// @title Data compressor 2.1.
+/// @notice Collects data from various contracts for use in the dApp
+/// Do not use for data from data compressor for state-changing functions
+contract DataCompressorV2_10 is IDataCompressorV2_10, ContractsRegisterTrait {
+    // Contract version
+    uint256 public constant version = 2_10;
+
+    constructor(address _addressProvider) ContractsRegisterTrait(_addressProvider) {}
+
+    /// @dev Returns CreditAccountData for all opened accounts for particular borrower
+    /// @param borrower Borrower address
+    function getCreditAccountList(address borrower) external view returns (CreditAccountData[] memory result) {
+        // Counts how many opened accounts a borrower has
+        uint256 count;
+        uint256 creditManagersLength = IContractsRegister(contractsRegister).getCreditManagersCount();
+        unchecked {
+            for (uint256 i = 0; i < creditManagersLength; ++i) {
+                address creditManager = IContractsRegister(contractsRegister).creditManagers(i);
+                if (hasOpenedCreditAccount(creditManager, borrower)) {
+                    ++count;
+                }
+            }
+        }
+
+        result = new CreditAccountData[](count);
+
+        // Get data & fill the array
+        count = 0;
+        for (uint256 i = 0; i < creditManagersLength;) {
+            address creditManager = IContractsRegister(contractsRegister).creditManagers(i);
+            unchecked {
+                if (hasOpenedCreditAccount(creditManager, borrower)) {
+                    result[count] = getCreditAccountData(creditManager, borrower);
+
+                    count++;
+                }
+
+                ++i;
+            }
+        }
+    }
+
+    /// @dev Returns whether the borrower has an open credit account with the credit manager
+    /// @param _creditManager Credit manager to check
+    /// @param borrower Borrower to check
+    function hasOpenedCreditAccount(address _creditManager, address borrower)
+        public
+        view
+        registeredCreditManagerOnly(_creditManager)
+        returns (bool)
+    {
+        return _hasOpenedCreditAccount(_creditManager, borrower);
+    }
+
+    /// @dev Returns CreditAccountData for a particular Credit Account account, based on creditManager and borrower
+    /// @param _creditManager Credit manager address
+    /// @param borrower Borrower address
+    function getCreditAccountData(address _creditManager, address borrower)
+        public
+        view
+        returns (CreditAccountData memory result)
+    {
+        (uint256 ver, ICreditManagerV2 creditManagerV2, ICreditFacadeV2 creditFacade,) =
+            getCreditContracts(_creditManager);
+
+        result.cfVersion = ver;
+
+        address creditAccount = creditManagerV2.getCreditAccountOrRevert(borrower);
+
+        result.borrower = borrower;
+        result.creditManager = _creditManager;
+        result.addr = creditAccount;
+
+        result.underlying = creditManagerV2.underlying();
+        (result.totalValue,) = creditFacade.calcTotalValue(creditAccount);
+        result.healthFactor = creditFacade.calcCreditAccountHealthFactor(creditAccount);
+
+        {
+            (uint256 debt, uint256 borrowedAmountPlusInterest, uint256 borrowedAmountPlusInterestAndFees) =
+                creditManagerV2.calcCreditAccountAccruedInterest(creditAccount);
+
+            result.debt = debt;
+            result.accruedInterest = borrowedAmountPlusInterest - debt;
+            result.accruedFees = borrowedAmountPlusInterestAndFees - borrowedAmountPlusInterest;
+        }
+
+        address pool = creditManagerV2.pool();
+        result.baseBorrowRate = IPoolService(pool).borrowAPY_RAY();
+
+        uint256 collateralTokenCount = creditManagerV2.collateralTokensCount();
+
+        result.enabledTokensMask = creditManagerV2.enabledTokensMap(creditAccount);
+
+        result.balances = new TokenBalance[](collateralTokenCount);
+
+        unchecked {
+            for (uint256 i = 0; i < collateralTokenCount; ++i) {
+                TokenBalance memory balance;
+                uint256 tokenMask = 1 << i;
+
+                (balance.token,) = creditManagerV2.collateralTokens(i);
+                balance.balance = IERC20(balance.token).balanceOf(creditAccount);
+
+                balance.isForbidden = !creditFacade.isTokenAllowed(balance.token);
+                balance.isEnabled = tokenMask & result.enabledTokensMask == 0 ? false : true;
+
+                result.balances[i] = balance;
+            }
+        }
+
+        result.cumulativeIndexLastUpdate = ICreditAccount(creditAccount).cumulativeIndexAtOpen();
+
+        result.since = uint64(ICreditAccount(creditAccount).since());
+    }
+
+    /// @dev Returns CreditManagerData for all Credit Managers
+    function getCreditManagersList() external view returns (CreditManagerData[] memory result) {
+        uint256 creditManagersCount = IContractsRegister(contractsRegister).getCreditManagersCount();
+
+        result = new CreditManagerData[](creditManagersCount);
+
+        unchecked {
+            for (uint256 i = 0; i < creditManagersCount; ++i) {
+                address creditManager = IContractsRegister(contractsRegister).creditManagers(i);
+                result[i] = getCreditManagerData(creditManager);
+            }
+        }
+    }
+
+    /// @dev Returns CreditManagerData for a particular _creditManager
+    /// @param _creditManager CreditManager address
+    function getCreditManagerData(address _creditManager) public view returns (CreditManagerData memory result) {
+        (
+            uint256 ver,
+            ICreditManagerV2 creditManagerV2,
+            ICreditFacadeV2 creditFacade,
+            ICreditConfiguratorV2 creditConfigurator
+        ) = getCreditContracts(_creditManager);
+
+        result.addr = _creditManager;
+        result.cfVersion = ver;
+
+        result.underlying = creditManagerV2.underlying();
+
+        {
+            result.pool = creditManagerV2.pool();
+            IPoolService pool = IPoolService(result.pool);
+            // result.canBorrow =;
+            result.baseBorrowRate = pool.borrowAPY_RAY();
+            result.availableToBorrow = pool.creditManagersCanBorrow(_creditManager) ? pool.availableLiquidity() : 0;
+        }
+
+        (result.minDebt, result.maxDebt) = creditFacade.limits();
+
+        {
+            uint256 collateralTokenCount = creditManagerV2.collateralTokensCount();
+
+            result.collateralTokens = new address[](collateralTokenCount);
+            result.liquidationThresholds = new uint256[](collateralTokenCount);
+
+            unchecked {
+                for (uint256 i = 0; i < collateralTokenCount; ++i) {
+                    (result.collateralTokens[i], result.liquidationThresholds[i]) = creditManagerV2.collateralTokens(i);
+                }
+            }
+        }
+
+        address[] memory allowedContracts = creditConfigurator.allowedContracts();
+        uint256 len = allowedContracts.length;
+        result.adapters = new ContractAdapter[](len);
+
+        unchecked {
+            for (uint256 i = 0; i < len; ++i) {
+                address targetContract = allowedContracts[i];
+
+                result.adapters[i] = ContractAdapter({
+                    targetContract: targetContract,
+                    adapter: creditManagerV2.contractToAdapter(targetContract)
+                });
+            }
+        }
+
+        result.creditFacade = address(creditFacade);
+        result.creditConfigurator = creditManagerV2.creditConfigurator();
+        result.degenNFT = creditFacade.degenNFT();
+        {
+            bool isIncreaseDebtForbidden;
+            (, isIncreaseDebtForbidden,,) = creditFacade.params(); // V2 only: true if increasing debt is forbidden
+
+            (uint128 currentTotalDebt, uint128 totalDebtLimit) = creditFacade.totalDebt(); // V2 only: total debt and total debt limit
+
+            result.availableToBorrow = isIncreaseDebtForbidden ? 0 : totalDebtLimit - currentTotalDebt;
+        }
+
+        result.forbiddenTokenMask = creditManagerV2.forbiddenTokenMask(); // V2 only: mask which forbids some particular tokens
+        result.maxEnabledTokensLength = creditManagerV2.maxAllowedEnabledTokenLength(); // V2 only: a limit on enabled tokens imposed for security
+        {
+            (
+                result.feeInterest,
+                result.feeLiquidation,
+                result.liquidationDiscount,
+                result.feeLiquidationExpired,
+                result.liquidationDiscountExpired
+            ) = creditManagerV2.fees();
+        }
+
+        result.isPaused = Pausable(address(creditManagerV2)).paused();
+    }
+
+    /// @dev Returns PoolData for a particular pool
+    /// @param _pool Pool address
+    function getPoolData(address _pool) public view registeredPoolOnly(_pool) returns (PoolData memory result) {
+        IPoolService pool = IPoolService(_pool);
+
+        result.addr = _pool;
+        result.expectedLiquidity = pool.expectedLiquidity();
+        result.availableLiquidity = pool.availableLiquidity();
+        result.totalBorrowed = pool.totalBorrowed();
+        result.dieselRate_RAY = pool.getDieselRate_RAY();
+        result.linearCumulativeIndex = pool.calcLinearCumulative_RAY();
+        result.baseInterestRate = pool.borrowAPY_RAY();
+        result.underlying = pool.underlyingToken();
+        result.dieselToken = pool.dieselToken();
+        result.dieselRate_RAY = pool.getDieselRate_RAY();
+        result.withdrawFee = pool.withdrawFee();
+        result.baseInterestIndexLU = pool._timestampLU();
+        result.cumulativeIndex_RAY = pool._cumulativeIndex_RAY();
+
+        uint256 dieselSupply = IERC20(result.dieselToken).totalSupply();
+        uint256 totalLP = pool.fromDiesel(dieselSupply);
+        result.supplyRate = totalLP == 0
+            ? result.baseInterestRate
+            : (result.baseInterestRate * result.totalBorrowed) * (PERCENTAGE_FACTOR - result.withdrawFee) / totalLP
+                / PERCENTAGE_FACTOR;
+
+        result.version = uint8(pool.version());
+
+        return result;
+    }
+
+    /// @dev Returns PoolData for all registered pools
+    function getPoolsList() external view returns (PoolData[] memory result) {
+        uint256 poolsLength = IContractsRegister(contractsRegister).getPoolsCount();
+
+        result = new PoolData[](poolsLength);
+        unchecked {
+            for (uint256 i = 0; i < poolsLength; ++i) {
+                address pool = IContractsRegister(contractsRegister).pools(i);
+                result[i] = getPoolData(pool);
+            }
+        }
+    }
+
+    /// @dev Returns the adapter address for a particular creditManager and targetContract
+    function getAdapter(address _creditManager, address _allowedContract)
+        external
+        view
+        registeredCreditManagerOnly(_creditManager)
+        returns (address adapter)
+    {
+        (, ICreditManagerV2 creditManagerV2,,) = getCreditContracts(_creditManager);
+
+        adapter = creditManagerV2.contractToAdapter(_allowedContract);
+    }
+
+    /// @dev Internal implementation for hasOpenedCreditAccount
+    function _hasOpenedCreditAccount(address creditManager, address borrower) internal view returns (bool) {
+        return ICreditManagerV2(creditManager).creditAccounts(borrower) != address(0);
+    }
+
+    /// @dev Retrieves all relevant credit contracts for a particular Credit Manager
+    function getCreditContracts(address _creditManager)
+        internal
+        view
+        registeredCreditManagerOnly(_creditManager)
+        returns (
+            uint256 ver,
+            ICreditManagerV2 creditManagerV2,
+            ICreditFacadeV2 creditFacade,
+            ICreditConfiguratorV2 creditConfigurator
+        )
+    {
+        creditManagerV2 = ICreditManagerV2(_creditManager);
+        creditFacade = ICreditFacadeV2(creditManagerV2.creditFacade());
+        creditConfigurator = ICreditConfiguratorV2(creditManagerV2.creditConfigurator());
+        ver = ICreditFacadeV2(creditFacade).version();
+    }
+}

package/contracts/data/DataCompressor_3_0.sol

@@ -0,0 +1,625 @@
+// SPDX-License-Identifier: BUSL-1.1
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2022
+pragma solidity ^0.8.10;
+pragma experimental ABIEncoderV2;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {PERCENTAGE_FACTOR, RAY} from "@gearbox-protocol/core-v2/contracts/libraries/Constants.sol";
+
+import {ContractsRegisterTrait} from "@gearbox-protocol/core-v3/contracts/traits/ContractsRegisterTrait.sol";
+import {IContractsRegister} from "@gearbox-protocol/core-v2/contracts/interfaces/IContractsRegister.sol";
+import {CreditFacadeV3} from "@gearbox-protocol/core-v3/contracts/credit/CreditFacadeV3.sol";
+
+import {
+    ICreditManagerV3,
+    CollateralDebtData,
+    CollateralCalcTask
+} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditManagerV3.sol";
+import {ICreditFacadeV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditFacadeV3.sol";
+import {ICreditConfiguratorV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditConfiguratorV3.sol";
+import {IPriceOracleV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPriceOracleV3.sol";
+import {ICreditAccountV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditAccountV3.sol";
+import {IPoolQuotaKeeperV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPoolQuotaKeeperV3.sol";
+import {IPoolV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPoolV3.sol";
+
+import {CreditManagerV3} from "@gearbox-protocol/core-v3/contracts/credit/CreditManagerV3.sol";
+
+import {CreditFacadeV3} from "@gearbox-protocol/core-v3/contracts/credit/CreditFacadeV3.sol";
+import {IBotListV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IBotListV3.sol";
+import {IWithdrawalManagerV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IWithdrawalManagerV3.sol";
+import {IGaugeV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IGaugeV3.sol";
+
+import {IPriceFeed} from "@gearbox-protocol/core-v2/contracts/interfaces/IPriceFeed.sol";
+import {IUpdatablePriceFeed} from "@gearbox-protocol/core-v2/contracts/interfaces/IPriceFeed.sol";
+
+import {IVersion} from "@gearbox-protocol/core-v2/contracts/interfaces/IVersion.sol";
+
+import {AddressProvider} from "@gearbox-protocol/core-v2/contracts/core/AddressProvider.sol";
+import {IDataCompressorV3_00, PriceOnDemand} from "../interfaces/IDataCompressorV3_00.sol";
+
+import {
+    CreditAccountData,
+    CreditManagerData,
+    PoolData,
+    TokenBalance,
+    ContractAdapter,
+    QuotaInfo,
+    GaugeInfo,
+    GaugeQuotaParams,
+    CreditManagerDebtParams,
+    GaugeVote
+} from "./Types.sol";
+
+// EXCEPTIONS
+import "@gearbox-protocol/core-v3/contracts/interfaces/IExceptions.sol";
+
+uint256 constant COUNT = 0;
+uint256 constant QUERY = 1;
+
+/// @title Data compressor 3.0.
+/// @notice Collects data from various contracts for use in the dApp
+/// Do not use for data from data compressor for state-changing functions
+contract DataCompressorV3_00 is IDataCompressorV3_00, ContractsRegisterTrait {
+    // Contract version
+    uint256 public constant version = 3_00;
+
+    error CreditManagerIsNotV3Exception();
+
+    constructor(address _addressProvider) ContractsRegisterTrait(_addressProvider) {}
+
+    /// @dev Returns CreditAccountData for all opened accounts for particular borrower
+    /// @param borrower Borrower address
+    /// @param priceUpdates Price updates for priceFeedsOnDemand
+    function getCreditAccountsByBorrower(address borrower, PriceOnDemand[] memory priceUpdates)
+        external
+        override
+        returns (CreditAccountData[] memory result)
+    {
+        return _queryCreditAccounts(_listCreditManagersV3(), borrower, false, priceUpdates);
+    }
+
+    function getCreditAccountsByCreditManager(address creditManager, PriceOnDemand[] memory priceUpdates)
+        external
+        registeredCreditManagerOnly(creditManager)
+        returns (CreditAccountData[] memory result)
+    {
+        if (!_isContractV3(creditManager)) revert CreditManagerIsNotV3Exception();
+
+        address[] memory creditManagers = new address[](1);
+        creditManagers[0] = creditManager;
+        return _queryCreditAccounts(creditManagers, address(0), false, priceUpdates);
+    }
+
+    function getLiquidatableCreditAccounts(PriceOnDemand[] memory priceUpdates)
+        external
+        returns (CreditAccountData[] memory result)
+    {
+        return _queryCreditAccounts(_listCreditManagersV3(), address(0), true, priceUpdates);
+    }
+
+    /// @notice Query credit accounts data by parameters
+    /// @param borrower Borrower address, all borrowers if address(0)
+    /// @param liquidatableOnly If true, returns only liquidatable accounts
+    /// @param priceUpdates Price updates for priceFeedsOnDemand
+    function _queryCreditAccounts(
+        address[] memory creditManagers,
+        address borrower,
+        bool liquidatableOnly,
+        PriceOnDemand[] memory priceUpdates
+    ) internal returns (CreditAccountData[] memory result) {
+        uint256 index;
+        uint256 len = creditManagers.length;
+        unchecked {
+            for (uint256 op = COUNT; op <= QUERY; ++op) {
+                if (op == QUERY && index == 0) {
+                    break;
+                } else {
+                    result = new CreditAccountData[](index);
+                    index = 0;
+                }
+
+                for (uint256 i = 0; i < len; ++i) {
+                    address _pool = creditManagers[i];
+
+                    _updatePrices(_pool, priceUpdates);
+                    address[] memory creditAccounts = ICreditManagerV3(_pool).creditAccounts();
+                    uint256 caLen = creditAccounts.length;
+                    for (uint256 j; j < caLen; ++j) {
+                        if (
+                            (
+                                borrower == address(0)
+                                    || ICreditManagerV3(_pool).getBorrowerOrRevert(creditAccounts[i]) == borrower
+                            )
+                                && (
+                                    !liquidatableOnly
+                                        || ICreditManagerV3(_pool).isLiquidatable(creditAccounts[i], PERCENTAGE_FACTOR)
+                                )
+                        ) {
+                            if (op == QUERY) {
+                                result[index] = _getCreditAccountData(_pool, creditAccounts[j]);
+                            }
+                            ++index;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// @dev Returns CreditAccountData for a particular Credit Account account, based on creditManager and borrower
+    /// @param _creditAccount Credit account address
+    /// @param priceUpdates Price updates for priceFeedsOnDemand
+    function getCreditAccountData(address _creditAccount, PriceOnDemand[] memory priceUpdates)
+        public
+        returns (CreditAccountData memory result)
+    {
+        ICreditAccountV3 creditAccount = ICreditAccountV3(_creditAccount);
+
+        address _pool = creditAccount.creditManager();
+        _ensureRegisteredCreditManager(_pool);
+
+        if (!_isContractV3(_pool)) revert CreditManagerIsNotV3Exception();
+
+        _updatePrices(_pool, priceUpdates);
+
+        return _getCreditAccountData(_pool, _creditAccount);
+    }
+
+    function _getCreditAccountData(address _pool, address _creditAccount)
+        internal
+        view
+        returns (CreditAccountData memory result)
+    {
+        ICreditManagerV3 creditManager = ICreditManagerV3(_pool);
+        ICreditFacadeV3 creditFacade = ICreditFacadeV3(creditManager.creditFacade());
+        // ICreditConfiguratorV3 creditConfigurator = ICreditConfiguratorV3(creditManager.creditConfigurator());
+
+        result.cfVersion = creditFacade.version();
+
+        address borrower = creditManager.getBorrowerOrRevert(_creditAccount);
+
+        result.borrower = borrower;
+        result.creditManager = _pool;
+        result.addr = _creditAccount;
+
+        result.underlying = creditManager.underlying();
+
+        address pool = creditManager.pool();
+        result.baseBorrowRate = IPoolV3(pool).baseInterestRate();
+
+        uint256 collateralTokenCount = creditManager.collateralTokensCount();
+
+        result.enabledTokensMask = creditManager.enabledTokensMaskOf(_creditAccount);
+
+        result.balances = new TokenBalance[](collateralTokenCount);
+        {
+            uint256 forbiddenTokenMask = creditFacade.forbiddenTokenMask();
+            uint256 quotedTokensMask = creditManager.quotedTokensMask();
+            IPoolQuotaKeeperV3 pqk = IPoolQuotaKeeperV3(creditManager.poolQuotaKeeper());
+
+            unchecked {
+                for (uint256 i = 0; i < collateralTokenCount; ++i) {
+                    TokenBalance memory balance;
+                    uint256 tokenMask = 1 << i;
+
+                    (balance.token,) = creditManager.collateralTokenByMask(tokenMask);
+                    balance.balance = IERC20(balance.token).balanceOf(_creditAccount);
+
+                    balance.isForbidden = tokenMask & forbiddenTokenMask == 0 ? false : true;
+                    balance.isEnabled = tokenMask & result.enabledTokensMask == 0 ? false : true;
+
+                    balance.isQuoted = tokenMask & quotedTokensMask == 0 ? false : true;
+
+                    if (balance.isQuoted) {
+                        (balance.quota,) = pqk.getQuota(_creditAccount, balance.token);
+                        balance.quotaRate = pqk.getQuotaRate(balance.token);
+                    }
+
+                    result.balances[i] = balance;
+                }
+            }
+        }
+
+        // uint256 debt;
+        // uint256 cumulativeIndexNow;
+        // uint256 cumulativeIndexLastUpdate;
+        // uint128 cumulativeQuotaInterest;
+        // uint256 accruedInterest;
+        // uint256 accruedFees;
+        // uint256 totalDebtUSD;
+        // uint256 totalValue;
+        // uint256 totalValueUSD;
+        // uint256 twvUSD;
+        // uint256 enabledTokensMask;
+        // uint256 quotedTokensMask;
+        // address[] quotedTokens;
+
+        try creditManager.calcDebtAndCollateral(_creditAccount, CollateralCalcTask.DEBT_COLLATERAL_WITHOUT_WITHDRAWALS)
+        returns (CollateralDebtData memory collateralDebtData) {
+            result.accruedInterest = collateralDebtData.accruedInterest;
+            result.accruedFees = collateralDebtData.accruedFees;
+            result.healthFactor = collateralDebtData.twvUSD * PERCENTAGE_FACTOR / collateralDebtData.debt;
+            result.totalValue = collateralDebtData.totalValue;
+            result.isSuccessful = true;
+        } catch {
+            _getPriceFeedFailedList(_pool, result.balances);
+            result.isSuccessful = false;
+        }
+
+        // (result.totalValue,) = creditFacade.calcTotalValue(creditAccount);
+        //  = ICreditAccountV3(creditAccount).cumulativeIndexAtOpen();
+
+        // uint256 debt;
+        // uint256 cumulativeIndexLastUpdate;
+        // uint128 cumulativeQuotaInterest;
+        // uint128 quotaFees;
+        // uint256 enabledTokensMask;
+        // uint16 flags;
+        // uint64 since;
+        // address borrower;
+
+        (result.debt, result.cumulativeIndexLastUpdate, result.cumulativeQuotaInterest,,,, result.since,) =
+            CreditManagerV3(_pool).creditAccountInfo(_creditAccount);
+
+        result.expirationDate = creditFacade.expirationDate();
+        result.maxApprovedBots = CreditFacadeV3(address(creditFacade)).maxApprovedBots();
+
+        result.activeBots =
+            IBotListV3(CreditFacadeV3(address(creditFacade)).botList()).getActiveBots(_pool, _creditAccount);
+
+        // QuotaInfo[] quotas;
+        result.schedultedWithdrawals = IWithdrawalManagerV3(CreditFacadeV3(address(creditFacade)).withdrawalManager())
+            .scheduledWithdrawals(_creditAccount);
+    }
+
+    function _listCreditManagersV3() internal view returns (address[] memory result) {
+        uint256 len = IContractsRegister(contractsRegister).getCreditManagersCount();
+
+        uint256 index;
+        unchecked {
+            for (uint256 op = COUNT; op <= QUERY; ++op) {
+                if (op == QUERY && index == 0) {
+                    break;
+                } else {
+                    result = new address[](index);
+                    index = 0;
+                }
+
+                for (uint256 i = 0; i < len; ++i) {
+                    address _pool = IContractsRegister(contractsRegister).creditManagers(i);
+
+                    if (_isContractV3(_pool)) {
+                        if (op == QUERY) result[index] = _pool;
+                        ++index;
+                    }
+                }
+            }
+        }
+    }
+
+    function _isContractV3(address _pool) internal view returns (bool) {
+        uint256 cmVersion = IVersion(_pool).version();
+        return cmVersion >= 3_00 && cmVersion < 3_99;
+    }
+
+    /// @dev Returns CreditManagerData for all Credit Managers
+    function getCreditManagersV3List() external view returns (CreditManagerData[] memory result) {
+        address[] memory creditManagers = _listCreditManagersV3();
+        uint256 len = creditManagers.length;
+
+        result = new CreditManagerData[](len);
+
+        unchecked {
+            for (uint256 i = 0; i < len; ++i) {
+                result[i] = getCreditManagerData(creditManagers[i]);
+            }
+        }
+    }
+
+    /// @dev Returns CreditManagerData for a particular _pool
+    /// @param _pool CreditManager address
+    function getCreditManagerData(address _pool) public view returns (CreditManagerData memory result) {
+        ICreditManagerV3 creditManager = ICreditManagerV3(_pool);
+        ICreditConfiguratorV3 creditConfigurator = ICreditConfiguratorV3(creditManager.creditConfigurator());
+        ICreditFacadeV3 creditFacade = ICreditFacadeV3(creditManager.creditFacade());
+
+        result.addr = _pool;
+        result.cfVersion = creditFacade.version();
+
+        result.underlying = creditManager.underlying();
+
+        {
+            result.pool = creditManager.pool();
+            IPoolV3 pool = IPoolV3(result.pool);
+            result.baseBorrowRate = pool.baseInterestRate();
+            result.availableToBorrow = pool.creditManagerBorrowable(_pool);
+        }
+
+        (result.minDebt, result.maxDebt) = creditFacade.debtLimits();
+
+        {
+            uint256 collateralTokenCount = creditManager.collateralTokensCount();
+
+            result.collateralTokens = new address[](collateralTokenCount);
+            result.liquidationThresholds = new uint256[](collateralTokenCount);
+
+            unchecked {
+                for (uint256 i = 0; i < collateralTokenCount; ++i) {
+                    (result.collateralTokens[i], result.liquidationThresholds[i]) =
+                        creditManager.collateralTokenByMask(1 << i);
+                }
+            }
+        }
+
+        address[] memory allowedAdapters = creditConfigurator.allowedAdapters();
+        uint256 len = allowedAdapters.length;
+        result.adapters = new ContractAdapter[](len);
+
+        unchecked {
+            for (uint256 i = 0; i < len; ++i) {
+                address allowedAdapter = allowedAdapters[i];
+
+                result.adapters[i] = ContractAdapter({
+                    targetContract: creditManager.adapterToContract(allowedAdapter),
+                    adapter: allowedAdapter
+                });
+            }
+        }
+
+        result.creditFacade = address(creditFacade);
+        result.creditConfigurator = address(creditConfigurator);
+        result.degenNFT = creditFacade.degenNFT();
+        // (, result.isIncreaseDebtForbidden,,) = creditFacade.params(); // V2 only: true if increasing debt is forbidden
+        result.forbiddenTokenMask = creditFacade.forbiddenTokenMask(); // V2 only: mask which forbids some particular tokens
+        result.maxEnabledTokensLength = creditManager.maxEnabledTokens(); // V2 only: a limit on enabled tokens imposed for security
+        {
+            (
+                result.feeInterest,
+                result.feeLiquidation,
+                result.liquidationDiscount,
+                result.feeLiquidationExpired,
+                result.liquidationDiscountExpired
+            ) = creditManager.fees();
+        }
+
+        result.quotas = _getQuotas(result.pool);
+
+        result.isPaused = CreditFacadeV3(address(creditFacade)).paused();
+    }
+
+    /// @dev Returns PoolData for a particular pool
+    /// @param _pool Pool address
+    function getPoolData(address _pool) public view registeredPoolOnly(_pool) returns (PoolData memory result) {
+        IPoolV3 pool = IPoolV3(_pool);
+
+        result.addr = _pool;
+        result.expectedLiquidity = pool.expectedLiquidity();
+        result.availableLiquidity = pool.availableLiquidity();
+
+        result.dieselRate_RAY = pool.convertToAssets(RAY);
+        result.linearCumulativeIndex = pool.calcLinearCumulative_RAY();
+        result.baseInterestRate = pool.baseInterestRate();
+        result.underlying = pool.underlyingToken();
+        result.dieselToken = address(pool);
+
+        result.dieselRate_RAY = pool.convertToAssets(RAY);
+        result.withdrawFee = pool.withdrawFee();
+        result.baseInterestIndexLU = pool.baseInterestIndexLU();
+        // result.cumulativeIndex_RAY = pool.calcLinearCumulative_RAY();
+
+        // Borrowing limits
+        result.totalBorrowed = pool.totalBorrowed();
+        result.totalDebtLimit = pool.totalDebtLimit();
+
+        address[] memory creditManagers = pool.creditManagers();
+        uint256 len = creditManagers.length;
+        result.creditManagerDebtParams = new CreditManagerDebtParams[](len);
+
+        unchecked {
+            for (uint256 i; i < len; ++i) {
+                address creditManager = creditManagers[i];
+                result.creditManagerDebtParams[i] = CreditManagerDebtParams({
+                    creditManager: creditManager,
+                    borrowed: pool.creditManagerBorrowed(creditManager),
+                    limit: pool.creditManagerDebtLimit(creditManager),
+                    availableToBorrow: pool.creditManagerBorrowable(creditManager)
+                });
+            }
+        }
+
+        result.totalSupply = pool.totalSupply();
+        result.totalAssets = pool.totalAssets();
+
+        result.supplyRate = pool.supplyRate();
+
+        result.version = uint8(pool.version());
+
+        result.quotas = _getQuotas(_pool);
+
+        return result;
+    }
+
+    /// @dev Returns PoolData for all registered pools
+    function getPoolsV3List() external view returns (PoolData[] memory result) {
+        address[] memory poolsV3 = _listPoolsV3();
+        uint256 len = poolsV3.length;
+        result = new PoolData[](len);
+
+        unchecked {
+            for (uint256 i = 0; i < len; ++i) {
+                result[i] = getPoolData(poolsV3[i]);
+            }
+        }
+    }
+
+    function _listPoolsV3() internal view returns (address[] memory result) {
+        uint256 len = IContractsRegister(contractsRegister).getPoolsCount();
+
+        uint256 index;
+        unchecked {
+            for (uint256 op = COUNT; op <= QUERY; ++op) {
+                if (op == QUERY && index == 0) {
+                    break;
+                } else {
+                    result = new address[](index);
+                    index = 0;
+                }
+
+                for (uint256 i = 0; i < len; ++i) {
+                    address _pool = IContractsRegister(contractsRegister).pools(i);
+
+                    if (_isContractV3(_pool)) {
+                        if (op == QUERY) result[index] = _pool;
+                        ++index;
+                    }
+                }
+            }
+        }
+    }
+
+    function _updatePrices(address creditManager, PriceOnDemand[] memory priceUpdates) internal {
+        uint256 len = priceUpdates.length;
+        unchecked {
+            for (uint256 i; i < len; ++i) {
+                address priceFeed =
+                    IPriceOracleV3(ICreditManagerV3(creditManager).priceOracle()).priceFeeds(priceUpdates[i].token);
+                if (priceFeed == address(0)) revert PriceFeedDoesNotExistException();
+
+                IUpdatablePriceFeed(priceFeed).updatePrice(priceUpdates[i].callData);
+            }
+        }
+    }
+
+    function _getPriceFeedFailedList(address _pool, TokenBalance[] memory balances)
+        internal
+        view
+        returns (address[] memory priceFeedFailed)
+    {
+        uint256 len = balances.length;
+
+        IPriceOracleV3 priceOracle = IPriceOracleV3(ICreditManagerV3(_pool).priceOracle());
+
+        uint256 index;
+
+        /// It counts on the first iteration how many price feeds failed and then fill the array on the second iteration
+        for (uint256 op = COUNT; op <= QUERY; ++op) {
+            if (op == QUERY && index == 0) {
+                break;
+            } else {
+                priceFeedFailed = new address[](index);
+                index = 0;
+            }
+            unchecked {
+                for (uint256 i = 0; i < len; ++i) {
+                    TokenBalance memory balance = balances[i];
+
+                    if (balance.balance > 1 && balance.isEnabled) {
+                        try IPriceFeed(priceOracle.priceFeeds(balance.token)).latestRoundData() returns (
+                            uint80, int256, uint256, uint256, uint80
+                        ) {} catch {
+                            if (op == QUERY) priceFeedFailed[index] = balance.token;
+                            ++index;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    function _getQuotas(address _pool) internal view returns (QuotaInfo[] memory quotas) {
+        IPoolQuotaKeeperV3 pqk = IPoolQuotaKeeperV3(IPoolV3(_pool).poolQuotaKeeper());
+
+        address[] memory quotaTokens = pqk.quotedTokens();
+        uint256 len = quotaTokens.length;
+        quotas = new QuotaInfo[](len);
+        unchecked {
+            for (uint256 i; i < len; ++i) {
+                quotas[i].token = quotaTokens[i];
+                (quotas[i].rate,, quotas[i].quotaIncreaseFee, quotas[i].totalQuoted, quotas[i].limit) =
+                    pqk.getTokenQuotaParams(quotaTokens[i]);
+            }
+        }
+    }
+
+    function getGaugesV3Data() external view returns (GaugeInfo[] memory result) {
+        address[] memory poolsV3 = _listPoolsV3();
+        uint256 len = poolsV3.length;
+        result = new GaugeInfo[](len);
+
+        unchecked {
+            for (uint256 i; i < len; ++i) {
+                GaugeInfo memory gaugeInfo = result[i];
+                IPoolQuotaKeeperV3 pqk = IPoolQuotaKeeperV3(IPoolV3(poolsV3[i]).poolQuotaKeeper());
+                address gauge = pqk.gauge();
+                gaugeInfo.addr = gauge;
+
+                address[] memory quotaTokens = pqk.quotedTokens();
+                uint256 quotaTokensLen = quotaTokens.length;
+                gaugeInfo.quotaParams = new GaugeQuotaParams[](quotaTokensLen);
+
+                for (uint256 j; j < quotaTokensLen; ++j) {
+                    GaugeQuotaParams memory quotaParams = gaugeInfo.quotaParams[j];
+                    address token = quotaTokens[j];
+                    quotaParams.token = token;
+
+                    (quotaParams.rate,, quotaParams.quotaIncreaseFee, quotaParams.totalQuoted, quotaParams.limit) =
+                        pqk.getTokenQuotaParams(token);
+
+                    (
+                        quotaParams.minRate,
+                        quotaParams.maxRate,
+                        quotaParams.totalVotesLpSide,
+                        quotaParams.totalVotesCaSide
+                    ) = IGaugeV3(gauge).quotaRateParams(token);
+                }
+            }
+        }
+    }
+
+    function getGaugeVotes(address staker) external view returns (GaugeVote[] memory gaugeVotes) {
+        address[] memory poolsV3 = _listPoolsV3();
+        uint256 len = poolsV3.length;
+        uint256 index;
+
+        unchecked {
+            for (uint256 op = COUNT; op <= QUERY; ++op) {
+                if (op == QUERY && index == 0) {
+                    break;
+                } else {
+                    gaugeVotes = new GaugeVote[](index);
+                    index = 0;
+                }
+                for (uint256 i; i < len; ++i) {
+                    address[] memory quotaTokens;
+                    address gauge;
+                    {
+                        IPoolQuotaKeeperV3 pqk = IPoolQuotaKeeperV3(IPoolV3(poolsV3[i]).poolQuotaKeeper());
+                        gauge = pqk.gauge();
+
+                        quotaTokens = pqk.quotedTokens();
+                    }
+                    uint256 quotaTokensLen = quotaTokens.length;
+
+                    for (uint256 j; j < quotaTokensLen; ++j) {
+                        address token = quotaTokens[j];
+
+                        (uint96 votesLpSide, uint96 votesCaSide) = IGaugeV3(gauge).userTokenVotes(staker, token);
+
+                        if (votesLpSide > 0 || votesCaSide > 0) {
+                            if (op == QUERY) {
+                                gaugeVotes[index] = GaugeVote({
+                                    gauge: gauge,
+                                    token: token,
+                                    totalVotesLpSide: votesLpSide,
+                                    totalVotesCaSide: votesCaSide
+                                });
+                            }
+                            ++index;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/contracts/data/Types.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2023
+pragma solidity ^0.8.17;
+
+import {ScheduledWithdrawal} from "@gearbox-protocol/core-v3/contracts/interfaces/IWithdrawalManagerV3.sol";
+
+struct TokenBalance {
+    address token;
+    uint256 balance;
+    bool isForbidden;
+    bool isEnabled;
+    bool isQuoted;
+    uint256 quota;
+    uint16 quotaRate;
+}
+
+struct QuotaInfo {
+    address token;
+    uint16 rate;
+    uint16 quotaIncreaseFee;
+    uint96 totalQuoted;
+    uint96 limit;
+}
+
+struct ContractAdapter {
+    address targetContract;
+    address adapter;
+}
+
+struct CreditAccountData {
+    // if not successful, priceFeedsNeeded are filled with the data
+    bool isSuccessful;
+    address[] priceFeedsNeeded;
+    address addr;
+    address borrower;
+    address creditManager;
+    address creditFacade;
+    address underlying;
+    uint256 debt;
+    uint256 cumulativeIndexNow;
+    uint256 cumulativeIndexLastUpdate;
+    uint128 cumulativeQuotaInterest;
+    uint256 accruedInterest;
+    uint256 accruedFees;
+    uint256 totalDebtUSD;
+    uint256 totalValue;
+    uint256 totalValueUSD;
+    uint256 twvUSD;
+    uint256 enabledTokensMask;
+    ///
+    uint256 healthFactor;
+    uint256 baseBorrowRate;
+    uint256 aggregatedBorrowRate;
+    TokenBalance[] balances;
+    uint64 since;
+    uint256 cfVersion;
+    // V3 features
+    uint40 expirationDate;
+    address[] activeBots;
+    uint256 maxApprovedBots;
+    ScheduledWithdrawal[2] schedultedWithdrawals;
+}
+
+struct CreditManagerData {
+    address addr;
+    uint256 cfVersion;
+    address creditFacade; // V2 only: address of creditFacade
+    address creditConfigurator; // V2 only: address of creditConfigurator
+    address underlying;
+    address pool;
+    uint256 totalDebt;
+    uint256 totalDebtLimit;
+    uint256 baseBorrowRate;
+    uint256 minDebt;
+    uint256 maxDebt;
+    uint256 availableToBorrow;
+    address[] collateralTokens;
+    ContractAdapter[] adapters;
+    uint256[] liquidationThresholds;
+    bool isDegenMode; // V2 only: true if contract is in Degen mode
+    address degenNFT; // V2 only: degenNFT, address(0) if not in degen mode
+    uint256 forbiddenTokenMask; // V2 only: mask which forbids some particular tokens
+    uint8 maxEnabledTokensLength; // V2 only: in V1 as many tokens as the CM can support (256)
+    uint16 feeInterest; // Interest fee protocol charges: fee = interest accrues * feeInterest
+    uint16 feeLiquidation; // Liquidation fee protocol charges: fee = totalValue * feeLiquidation
+    uint16 liquidationDiscount; // Miltiplier to get amount which liquidator should pay: amount = totalValue * liquidationDiscount
+    uint16 feeLiquidationExpired; // Liquidation fee protocol charges on expired accounts
+    uint16 liquidationDiscountExpired; // Multiplier for the amount the liquidator has to pay when closing an expired account
+    // V3 Fileds
+    QuotaInfo[] quotas;
+    bool isPaused;
+}
+
+struct CreditManagerDebtParams {
+    address creditManager;
+    uint256 borrowed;
+    uint256 limit;
+    uint256 availableToBorrow;
+}
+
+struct PoolData {
+    address addr;
+    address underlying;
+    address dieselToken;
+    ///
+    uint256 linearCumulativeIndex;
+    uint256 availableLiquidity;
+    uint256 expectedLiquidity;
+    //
+    uint256 totalBorrowed;
+    uint256 totalDebtLimit;
+    CreditManagerDebtParams[] creditManagerDebtParams;
+    uint256 totalAssets;
+    uint256 totalSupply;
+    uint256 supplyRate;
+    uint256 baseInterestRate;
+    uint256 dieselRate_RAY;
+    uint256 withdrawFee;
+    uint256 cumulativeIndex_RAY;
+    uint256 baseInterestIndexLU;
+    uint256 version;
+    QuotaInfo[] quotas;
+}
+
+struct GaugeQuotaParams {
+    address token;
+    uint16 minRate;
+    uint16 maxRate;
+    uint96 totalVotesLpSide;
+    uint96 totalVotesCaSide;
+    uint16 rate;
+    uint16 quotaIncreaseFee;
+    uint96 totalQuoted;
+    uint96 limit;
+}
+
+struct GaugeInfo {
+    address addr;
+    GaugeQuotaParams[] quotaParams;
+}
+
+struct GaugeVote {
+    address gauge;
+    address token;
+    uint96 totalVotesLpSide;
+    uint96 totalVotesCaSide;
+}

package/contracts/interfaces/IDataCompressorV2_10.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2022
+pragma solidity ^0.8.10;
+
+import {CreditAccountData, CreditManagerData, PoolData} from "../data/Types.sol";
+import {IVersion} from "@gearbox-protocol/core-v2/contracts/interfaces/IVersion.sol";
+
+interface IDataCompressorV2_10 is IVersion {
+    /// @dev Returns CreditAccountData for all opened accounts for particular borrower
+    /// @param borrower Borrower address
+    function getCreditAccountList(address borrower) external view returns (CreditAccountData[] memory);
+
+    /// @dev Returns whether the borrower has an open credit account with the credit manager
+    /// @param creditManager Credit manager to check
+    /// @param borrower Borrower to check
+    function hasOpenedCreditAccount(address creditManager, address borrower) external view returns (bool);
+
+    /// @dev Returns CreditAccountData for a particular Credit Account account, based on creditManager and borrower
+    /// @param _creditManager Credit manager address
+    /// @param borrower Borrower address
+    function getCreditAccountData(address _creditManager, address borrower)
+        external
+        view
+        returns (CreditAccountData memory);
+
+    /// @dev Returns CreditManagerData for all Credit Managers
+    function getCreditManagersList() external view returns (CreditManagerData[] memory);
+
+    /// @dev Returns CreditManagerData for a particular _creditManager
+    /// @param _creditManager CreditManager address
+    function getCreditManagerData(address _creditManager) external view returns (CreditManagerData memory);
+
+    /// @dev Returns PoolData for a particular pool
+    /// @param _pool Pool address
+    function getPoolData(address _pool) external view returns (PoolData memory);
+
+    /// @dev Returns PoolData for all registered pools
+    function getPoolsList() external view returns (PoolData[] memory);
+
+    /// @dev Returns the adapter address for a particular creditManager and targetContract
+    function getAdapter(address _creditManager, address _allowedContract) external view returns (address adapter);
+}

package/contracts/interfaces/IDataCompressorV3_00.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2022
+pragma solidity ^0.8.10;
+
+import {CreditAccountData, CreditManagerData, PoolData} from "../data/Types.sol";
+import {IVersion} from "@gearbox-protocol/core-v2/contracts/interfaces/IVersion.sol";
+
+struct PriceOnDemand {
+    address token;
+    bytes callData;
+}
+
+interface IDataCompressorV3_00 is IVersion {
+    /// @dev Returns CreditAccountData for all opened accounts for particular borrower
+    /// @param borrower Borrower address
+    /// @param priceUpdates Price updates for price on demand oracles
+    function getCreditAccountsByBorrower(address borrower, PriceOnDemand[] memory priceUpdates)
+        external
+        returns (CreditAccountData[] memory);
+
+    /// @dev Returns CreditAccountData for all opened accounts for particular borrower
+    /// @param creditManager Address
+    /// @param priceUpdates Price updates for price on demand oracles
+    function getCreditAccountsByCreditManager(address creditManager, PriceOnDemand[] memory priceUpdates)
+        external
+        returns (CreditAccountData[] memory);
+
+    /// @dev Returns CreditAccountData for a particular Credit Account account, based on creditManager and borrower
+    /// @param creditAccount Address of credit account
+    /// @param priceUpdates Price updates for price on demand oracles
+    function getCreditAccountData(address creditAccount, PriceOnDemand[] memory priceUpdates)
+        external
+        returns (CreditAccountData memory);
+
+    /// @dev Returns CreditManagerData for all Credit Managers
+    function getCreditManagersV3List() external view returns (CreditManagerData[] memory);
+
+    /// @dev Returns CreditManagerData for a particular _creditManager
+    /// @param creditManager CreditManager address
+    function getCreditManagerData(address creditManager) external view returns (CreditManagerData memory);
+
+    /// @dev Returns PoolData for a particular pool
+    /// @param _pool Pool address
+    function getPoolData(address _pool) external view returns (PoolData memory);
+
+    /// @dev Returns PoolData for all registered pools
+    function getPoolsV3List() external view returns (PoolData[] memory);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@gearbox-protocol/periphery-v3",
+  "version": "1.0.2",
+  "main": "index.js",
+  "repository": "git@github.com:Gearbox-protocol/periphery-v3.git",
+  "author": "Mikael <26343374+0xmikko@users.noreply.github.com>",
+  "license": "MIT",
+  "files": [
+    "contracts"
+  ],
+  "scripts": {
+    "prepare": "husky install",
+    "prettier": "forge fmt",
+    "prettier:ci": "forge fmt"
+  },
+  "devDependencies": {
+    "@1inch/solidity-utils": "^2.2.27",
+    "@commitlint/cli": "^17.6.3",
+    "@commitlint/config-conventional": "17.6.0",
+    "@gearbox-protocol/core-v2": "1.19.0-base.14",
+    "@gearbox-protocol/core-v3": "^1.36.5",
+    "@gearbox-protocol/oracles-v3": "^1.7.2",
+    "@gearbox-protocol/sdk-gov": "^1.5.10",
+    "@openzeppelin/contracts": "4.8.3",
+    "husky": "^8.0.3",
+    "lint-staged": "^13.0.3",
+    "prettier": "^3.0.3"
+  },
+  "prettier": "@gearbox-protocol/prettier-config",
+  "lint-staged": {
+    "*.sol": "forge fmt",
+    "*.{json,md}": "prettier --write"
+  }
+}