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

package/contracts/compressors/AdapterCompressor.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: BUSL-1.1
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2024
+pragma solidity ^0.8.17;
+
+import {IStateSerializer} from "../interfaces/IStateSerializer.sol";
+import {ContractAdapter} from "../types/CreditManagerState.sol";
+import {ICreditManagerV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditManagerV3.sol";
+import {ICreditConfiguratorV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditConfiguratorV3.sol";
+import {IAdapter} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IAdapter.sol";
+
+/// @title Adapter compressor 3.0.
+/// @notice Collects data from different adapter types
+contract AdaptgerCompressorV3 {
+    // Contract version
+    uint256 public constant version = 3_10;
+
+    function getContractAdapters(address creditManager) external view returns (ContractAdapter[] memory adapters) {
+        ICreditConfiguratorV3 creditConfigurator =
+            ICreditConfiguratorV3(ICreditManagerV3(creditManager).creditConfigurator());
+
+        address[] memory allowedAdapters = creditConfigurator.allowedAdapters();
+        uint256 len = allowedAdapters.length;
+
+        adapters = new ContractAdapter[](len);
+        bytes memory stateSerialised;
+
+        unchecked {
+            for (uint256 i = 0; i < len; ++i) {
+                address allowedAdapter = allowedAdapters[i];
+
+                /// add try{} catch for serialisation
+
+                adapters[i] = ContractAdapter({
+                    targetContract: ICreditManagerV3(creditManager).adapterToContract(allowedAdapter),
+                    adapter: allowedAdapter,
+                    adapterType: uint8(IAdapter(allowedAdapter)._gearboxAdapterType()),
+                    version: IAdapter(allowedAdapter)._gearboxAdapterVersion(),
+                    stateSerialised: stateSerialised
+                });
+            }
+        }
+    }
+}

package/contracts/compressors/PoolCompressor.sol

@@ -0,0 +1,175 @@
+// SPDX-License-Identifier: BUSL-1.1
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2023
+pragma solidity ^0.8.10;
+pragma experimental ABIEncoderV2;
+
+import {PoolV3} from "@gearbox-protocol/core-v3/contracts/pool/PoolV3.sol";
+import {IPoolQuotaKeeperV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPoolQuotaKeeperV3.sol";
+import {IGaugeV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IGaugeV3.sol";
+
+import {PoolState, CreditManagerDebtParams} from "../types/PoolState.sol";
+import {PoolQuotaKeeperState, QuotaTokenParams} from "../types/PoolQuotaKeeperState.sol";
+import {RateKeeperState, Rate} from "../types/RateKeeperState.sol";
+import {PERCENTAGE_FACTOR, RAY} from "@gearbox-protocol/core-v3/contracts/libraries/Constants.sol";
+import {IRateKeeper} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IRateKeeper.sol";
+
+import {RateKeeperType} from "../types/Enums.sol";
+// Serializers
+import {GaugeSerializer} from "../serializers/pool/GaugeSerializer.sol";
+
+/// @title Pool compressor
+/// @notice Collects data from pool related contracts
+/// Do not use for data from data compressor for state-changing functions
+contract PoolCompressorV3 {
+    // Contract version
+    uint256 public constant version = 3_10;
+
+    address public immutable gaugeSerializer;
+
+    constructor() {
+        gaugeSerializer = address(new GaugeSerializer());
+    }
+
+    function getPoolState(address pool) public view returns (PoolState memory result) {
+        PoolV3 _pool = PoolV3(pool);
+        //
+        // CONTRACT PARAMETERS
+        //
+        // address addr;
+        result.addr = pool;
+        // uint16 poolType;
+        // uint256 version;
+        result.version = _pool.version();
+
+        //
+        // ERC20 Properties
+        //
+        // string symbol;
+        result.symbol = _pool.symbol();
+        // string name;
+        result.name = _pool.name();
+        // uint8 decimals;
+        result.decimals = _pool.decimals();
+        // uint256 totalSupply;
+        result.totalSupply = _pool.totalSupply();
+
+        // // connected contracts
+
+        // address poolQuotaKeeper;
+        result.poolQuotaKeeper = _pool.poolQuotaKeeper();
+        // address interestRateModel;
+        result.interestRateModel = _pool.interestRateModel();
+        //
+        // address underlying;
+        result.underlying = _pool.underlyingToken();
+
+        // uint256 availableLiquidity;
+        result.availableLiquidity = _pool.availableLiquidity();
+        // uint256 expectedLiquidity;
+        result.expectedLiquidity = _pool.expectedLiquidity();
+        // //
+        // uint256 baseInterestIndex;
+        result.baseInterestIndex = _pool.baseInterestIndex();
+        // uint256 baseInterestRate;
+        result.baseInterestRate = _pool.baseInterestRate();
+        // uint256 dieselRate_RAY;
+        result.dieselRate_RAY = _pool.convertToAssets(RAY);
+        // uint256 totalBorrowed;
+        result.totalBorrowed = _pool.totalBorrowed();
+        // uint256 totalDebtLimit;
+        result.totalDebtLimit = _pool.totalDebtLimit();
+        // uint256 totalAssets;
+        result.totalAssets = _pool.totalAssets();
+
+        // uint256 supplyRate;
+        result.supplyRate = _pool.supplyRate();
+        // uint256 withdrawFee;
+        result.withdrawFee = _pool.withdrawFee();
+        // uint256 lastBaseInterestUpdate;
+        result.lastBaseInterestUpdate = _pool.lastBaseInterestUpdate();
+        // uint256 baseInterestIndexLU;
+        result.baseInterestIndexLU = _pool.baseInterestIndexLU();
+
+        // CreditManagerDebtParams[] creditManagerDebtParams;
+        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)
+                });
+            }
+        }
+        // bool isPaused;
+        result.isPaused = _pool.paused();
+    }
+
+    function getPoolQuotaKeeperState(address pqk) external view returns (PoolQuotaKeeperState memory result) {
+        IPoolQuotaKeeperV3 _pqk = IPoolQuotaKeeperV3(pqk);
+
+        result.addr = pqk;
+
+        // address version;
+        result.version = _pqk.version();
+        // address rateKeeper;
+        result.rateKeeper = _pqk.gauge();
+        // QuotaTokenParams[] quotas;
+        address[] memory quotaTokens = _pqk.quotedTokens();
+        uint256 len = quotaTokens.length;
+        result.quotas = new QuotaTokenParams[](len);
+        unchecked {
+            for (uint256 i; i < len; ++i) {
+                result.quotas[i].token = quotaTokens[i];
+                (
+                    result.quotas[i].rate,
+                    ,
+                    result.quotas[i].quotaIncreaseFee,
+                    result.quotas[i].totalQuoted,
+                    result.quotas[i].limit,
+                    result.quotas[i].isActive
+                ) = _pqk.getTokenQuotaParams(quotaTokens[i]);
+            }
+        }
+
+        // address[] creditManagers;
+
+        // uint40 lastQuotaRateUpdate;
+        result.lastQuotaRateUpdate = _pqk.lastQuotaRateUpdate();
+    }
+
+    function getRateKeeperState(address rateKeeper) external view returns (RateKeeperState memory result) {
+        IRateKeeper _rateKeeper = IRateKeeper(rateKeeper);
+
+        IPoolQuotaKeeperV3 _pqk;
+
+        result.addr = rateKeeper;
+
+        result.version = _rateKeeper.version();
+        if (result.version == 3_00) {
+            result.rateKeeperType = uint16(RateKeeperType.Gauge);
+            _pqk = IPoolQuotaKeeperV3(PoolV3(IGaugeV3(rateKeeper).pool()).poolQuotaKeeper());
+            result.serialisedData = GaugeSerializer(gaugeSerializer).serialize(rateKeeper);
+        } else {
+            // resuilt.rateKeeperType = uint16(_rateKeeper.rateKeeperType());
+            // _pqk = IPoolQuotaKeeperV3(IGaugeV3(rateKeeper).quotaKeeper());
+        }
+
+        address[] memory quotaTokens = _pqk.quotedTokens();
+        uint256 quotaTokensLen = quotaTokens.length;
+
+        uint16[] memory rawRates = _rateKeeper.getRates(quotaTokens);
+        result.rates = new Rate[](quotaTokensLen);
+
+        for (uint256 i; i < quotaTokensLen; ++i) {
+            result.rates[i].token = quotaTokens[i];
+            result.rates[i].rate = rawRates[i];
+        }
+    }
+}

package/contracts/compressors/PriceFeedCompressor.sol

@@ -6,7 +6,7 @@ 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 {IPriceFeedCompressor} from "../interfaces/IPriceFeedCompressor.sol";
 import {PriceFeedType} from "@gearbox-protocol/sdk-gov/contracts/PriceFeedType.sol";
 
 import {IStateSerializerLegacy} from "../interfaces/IStateSerializerLegacy.sol";
@@ -17,7 +17,7 @@ import {BPTWeightedPriceFeedSerializer} from "../serializers/oracles/BPTWeighted
 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";
+import {PriceFeedAnswer, PriceFeedMapEntry, PriceFeedTreeNode} from "../types/PriceOracleState.sol";
 
 interface ImplementsPriceFeedType {
     /// @dev Annotates `priceFeedType` as `uint8` instead of `PriceFeedType` enum to support future types
@@ -35,7 +35,7 @@ interface IPriceOracleV3Legacy {
 /// @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 {
+contract PriceFeedCompressor is IPriceFeedCompressor {
     using NestedPriceFeeds for IPriceFeed;
 
     /// @notice Contract version
@@ -45,9 +45,6 @@ contract PriceFeedCompressor is IVersion {
     /// @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.
@@ -82,6 +79,7 @@ contract PriceFeedCompressor is IVersion {
     function getPriceFeeds(address priceOracle)
         external
         view
+        override
         returns (PriceFeedMapEntry[] memory priceFeedMap, PriceFeedTreeNode[] memory priceFeedTree)
     {
         address[] memory tokens = IPriceOracleV3(priceOracle).getTokens();
@@ -92,6 +90,7 @@ contract PriceFeedCompressor is IVersion {
     function getPriceFeeds(address priceOracle, address[] memory tokens)
         public
         view
+        override
         returns (PriceFeedMapEntry[] memory priceFeedMap, PriceFeedTreeNode[] memory priceFeedTree)
     {
         uint256 numTokens = tokens.length;
@@ -130,6 +129,30 @@ contract PriceFeedCompressor is IVersion {
         }
     }
 
+    function loadPriceFeedTree(address[] memory priceFeeds)
+        external
+        view
+        override
+        returns (PriceFeedTreeNode[] memory priceFeedTree)
+    {
+        uint256 len = priceFeeds.length;
+        uint256 priceFeedTreeSize;
+
+        for (uint256 i; i < len; ++i) {
+            priceFeedTreeSize += _getPriceFeedTreeSize(priceFeeds[i]);
+        }
+
+        priceFeedTree = new PriceFeedTreeNode[](priceFeedTreeSize);
+        uint256 offset;
+        for (uint256 i; i < len; ++i) {
+            offset = _loadPriceFeedTree(priceFeeds[i], priceFeedTree, offset);
+        }
+        // trim array to its actual size in case there were duplicates
+        assembly {
+            mstore(priceFeedTree, offset)
+        }
+    }
+
     // --------- //
     // INTERNALS //
     // --------- //
@@ -191,6 +214,7 @@ contract PriceFeedCompressor is IVersion {
     function _getPriceFeedTreeNode(address priceFeed) internal view returns (PriceFeedTreeNode memory data) {
         data.priceFeed = priceFeed;
         data.decimals = IPriceFeed(priceFeed).decimals();
+        data.version = IPriceFeed(priceFeed).version();
 
         try ImplementsPriceFeedType(priceFeed).priceFeedType() returns (uint8 priceFeedType) {
             data.priceFeedType = priceFeedType;

package/contracts/compressors/Types.sol

@@ -55,7 +55,7 @@ struct CreditAccountFilter {
     bool reverting;
 }
 
-/// @notice Credit manager filters
+// @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
@@ -65,46 +65,6 @@ struct CreditManagerFilter {
     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

package/contracts/data/DataCompressorV3.sol

@@ -55,13 +55,13 @@ import {
 
 // EXCEPTIONS
 import "@gearbox-protocol/core-v3/contracts/interfaces/IExceptions.sol";
-import {LinearInterestModelHelper} from "./LinearInterestModelHelper.sol";
+
 import {IZapperRegister} from "../interfaces/IZapperRegister.sol";
 
 /// @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 is IDataCompressorV3, ContractsRegisterTrait, LinearInterestModelHelper {
+contract DataCompressorV3 is IDataCompressorV3, ContractsRegisterTrait {
     // Contract version
     uint256 public constant version = 3_00;
 
@@ -328,7 +328,7 @@ contract DataCompressorV3 is IDataCompressorV3, ContractsRegisterTrait, LinearIn
 
             result.baseBorrowRate = _getBaseInterestRate(address(pool));
             result.availableToBorrow = pool.creditManagerBorrowable(_cm);
-            result.lirm = _getInterestRateModel(address(pool));
+            // result.lirm = _getInterestRateModel(address(pool));
         }
 
         (result.minDebt, result.maxDebt) = creditFacade.debtLimits();
@@ -431,7 +431,7 @@ contract DataCompressorV3 is IDataCompressorV3, ContractsRegisterTrait, LinearIn
         result.version = _getVersion(address(pool));
 
         result.quotas = _getQuotas(_pool);
-        result.lirm = _getInterestRateModel(_pool);
+        // result.lirm = _getInterestRateModel(_pool);
         result.isPaused = _getPaused(_pool);
 
         // Adding zappers
@@ -559,9 +559,9 @@ contract DataCompressorV3 is IDataCompressorV3, ContractsRegisterTrait, LinearIn
         name = _getName(token);
     }
 
-    function _getInterestRateModel(address pool) internal view returns (LinearModel memory) {
-        return getLIRMData(IPoolV3(pool).interestRateModel());
-    }
+    // function _getInterestRateModel(address pool) internal view returns (LinearModel memory) {
+    //     return address(0); //getLIRMData(IPoolV3(pool).interestRateModel());
+    // }
 
     function _getQuotedTokens(IPoolQuotaKeeperV3 pqk) internal view returns (address[] memory result) {
         result = pqk.quotedTokens();

package/contracts/interfaces/IPriceFeedCompressor.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: BUSL-1.1
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2023
+pragma solidity ^0.8.10;
+
+import {PriceFeedAnswer, PriceFeedMapEntry, PriceFeedTreeNode} from "../types/PriceOracleState.sol";
+
+import {IVersion} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol";
+
+interface IPriceFeedCompressor is IVersion {
+    /// @notice Emitted when new state serializer is set for a given price feed type
+    event SetSerializer(uint8 indexed priceFeedType, address indexed serializer);
+
+    function getPriceFeeds(address priceOracle)
+        external
+        view
+        returns (PriceFeedMapEntry[] memory priceFeedMap, PriceFeedTreeNode[] memory priceFeedTree);
+
+    function getPriceFeeds(address priceOracle, address[] memory tokens)
+        external
+        view
+        returns (PriceFeedMapEntry[] memory priceFeedMap, PriceFeedTreeNode[] memory priceFeedTree);
+
+    function loadPriceFeedTree(address[] memory priceFeeds)
+        external
+        view
+        returns (PriceFeedTreeNode[] memory priceFeedTree);
+}