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

package/contracts/compressors/CreditAccountCompressor.sol

@@ -4,6 +4,7 @@
 pragma solidity ^0.8.17;
 
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 
 import {IContractsRegister} from "@gearbox-protocol/core-v3/contracts/interfaces/IContractsRegister.sol";
 import {ICreditAccountV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditAccountV3.sol";
@@ -14,40 +15,43 @@ import {
 } from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditManagerV3.sol";
 import {IPoolQuotaKeeperV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPoolQuotaKeeperV3.sol";
 import {IVersion} from "@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol";
+import {PERCENTAGE_FACTOR} from "@gearbox-protocol/core-v3/contracts/libraries/Constants.sol";
 import {SanityCheckTrait} from "@gearbox-protocol/core-v3/contracts/traits/SanityCheckTrait.sol";
 
 import {IAddressProviderV3} from "@gearbox-protocol/governance/contracts/interfaces/IAddressProviderV3.sol";
 import {IMarketConfiguratorV3} from "@gearbox-protocol/governance/contracts/interfaces/IMarketConfiguratorV3.sol";
 
-import {CreditAccountData, CreditAccountFilter, CreditManagerFilter, TokenInfo} from "./Types.sol";
+import {CreditAccountData, CreditAccountFilter, CreditManagerFilter, Pagination, TokenInfo} from "./Types.sol";
 
 /// @title  Credit account compressor
 /// @notice Allows to fetch data on all credit accounts matching certain criteria in an efficient manner
 /// @dev    The contract is not gas optimized and is thus not recommended for on-chain use
-/// @dev    The querying functions exist in two modes, with one of them trying to YOLO-load everything and the other
-///         one loading as many accounts as fit in the call gas limit to implement the tightest pagination possible
+/// @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 {
     /// @notice Contract version
     uint256 public constant override version = 3_10;
 
     /// @notice Address provider contract address
-    address public immutable addressProvider;
+    address public immutable ADDRESS_PROVIDER;
 
-    /// @dev Maximum number of accounts to consider in a single step to avoid excessive memory expansion
-    uint256 internal constant STEP_SIZE = 1000;
+    /// @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;
 
     /// @notice Thrown when address provider is not a contract or does not implement `marketConfigurators()`
     error InvalidAddressProviderException();
 
     /// @notice Constructor
-    /// @param  addressProvider_ Address provider contract address
-    constructor(address addressProvider_) nonZeroAddress(addressProvider_) {
-        if (addressProvider_.code.length == 0) revert InvalidAddressProviderException();
-        try IAddressProviderV3(addressProvider_).marketConfigurators() {}
+    /// @param  addressProvider Address provider contract address
+    constructor(address addressProvider) nonZeroAddress(addressProvider) {
+        if (addressProvider.code.length == 0) revert InvalidAddressProviderException();
+        try IAddressProviderV3(addressProvider).marketConfigurators() {}
         catch {
             revert InvalidAddressProviderException();
         }
-        addressProvider = addressProvider_;
+        ADDRESS_PROVIDER = addressProvider;
     }
 
     // -------- //
@@ -61,168 +65,114 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
     }
 
     /// @notice Returns data for credit accounts that match `caFilter` in credit managers matching `cmFilter`
-    /// @dev    The `offset` parameter specifies the position to start scanning from in the list of all
-    ///         credit accounts opened in credit managers matching `cmFilter`
-    /// @dev    The `false` value of `finished` return variable indicates that gas supplied with a call
-    ///         was insufficient to process all the accounts and next iteration is needed which should
-    ///         start from `nextOffset` position
-    function getCreditAccounts(CreditManagerFilter memory cmFilter, CreditAccountFilter memory caFilter, uint256 offset)
-        external
-        view
-        returns (CreditAccountData[] memory data, bool finished, uint256 nextOffset)
-    {
-        uint256 num = countCreditAccounts(cmFilter, caFilter, offset);
-        nextOffset = offset;
-
-        // FIXME: If the number of accounts matching the filter is much larger than the number of accounts that
-        // can realistically be processed with most providers, pre-allocation burns unnecessarily large amount
-        // of gas due to quadratic memory expansion cost.
-        // An idea for the mitigation is to calculate the maximum memory pointer that can possibly be reached
-        // during calculations, and write resulting data after it, only expanding memory when actually needed.
-        data = new CreditAccountData[](num);
-        uint256 dataOffset;
+    /// @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(
+        CreditManagerFilter memory cmFilter,
+        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
+        });
 
-        // FIXME: This should be proven to be enough to properly return the data, and possibly made tighter
-        uint256 gasThreshold = gasleft() / 64;
+        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 <= offset) {
-                offset -= len;
+            if (len <= _p.offset) {
+                _p.offset -= len;
                 continue;
             }
 
-            while (offset < len) {
-                bool outOfGas;
-                uint256 processed;
-
-                // circumvent the "Stack too deep." error
-                uint256 offset_ = offset;
-
-                (dataOffset, outOfGas, processed) = _getCreditAccounts({
-                    creditManager: creditManagers[i],
-                    filter: caFilter,
-                    data: data,
-                    dataOffset: dataOffset,
-                    offset: offset_,
-                    limit: STEP_SIZE,
-                    gasThreshold: gasThreshold
-                });
-                offset += processed;
-                nextOffset += processed;
-
-                if (outOfGas) {
-                    // trim the array to its actual size
-                    assembly {
-                        mstore(data, dataOffset)
-                    }
-                    return (data, dataOffset == num, nextOffset);
-                }
-            }
-            offset = 0;
-        }
-        return (data, true, nextOffset);
-    }
+            uint256 limit = Math.min(len - _p.offset, _p.scanLimit);
 
-    /// @dev Same as above but with no gas limit control
-    function getCreditAccounts(CreditManagerFilter memory cmFilter, CreditAccountFilter memory caFilter)
-        external
-        view
-        returns (CreditAccountData[] memory data)
-    {
-        uint256 num = countCreditAccounts(cmFilter, caFilter, 0);
-        data = new CreditAccountData[](num);
-        uint256 dataOffset;
-
-        address[] memory creditManagers = _getCreditManagers(cmFilter);
-        for (uint256 i; i < creditManagers.length; ++i) {
-            uint256 len = ICreditManagerV3(creditManagers[i]).creditAccountsLen();
-            (dataOffset,,) = _getCreditAccounts({
+            uint256 scanned;
+            (dataOffset, scanned) = _getCreditAccounts({
                 creditManager: creditManagers[i],
                 filter: caFilter,
                 data: data,
                 dataOffset: dataOffset,
-                offset: 0,
-                limit: len,
-                gasThreshold: 0
+                offset: _p.offset,
+                limit: limit
             });
-        }
-    }
+            nextOffset += scanned;
 
-    /// @notice Returns data for credit accounts that match `caFilter` in a given `creditManager`
-    /// @dev    The `offset` parameter specifies the position to start scanning from in the list of all
-    ///         credit accounts opened in `creditManager`
-    /// @dev    The `false` value of `finished` return variable indicates that gas supplied with a call
-    ///         was insufficient to process all the accounts and next iteration is needed which should
-    ///         start from `nextOffset` position
-    function getCreditAccounts(address creditManager, CreditAccountFilter memory caFilter, uint256 offset)
-        external
-        view
-        returns (CreditAccountData[] memory data, bool finished, uint256 nextOffset)
-    {
-        uint256 num = countCreditAccounts(creditManager, caFilter, offset);
-        nextOffset = offset;
-
-        // FIXME: If the number of accounts matching the filter is much larger than the number of accounts that
-        // can realistically be processed with most providers, pre-allocation burns unnecessarily large amount
-        // of gas due to quadratic memory expansion cost.
-        // An idea for the mitigation is to calculate the maximum memory pointer that can possibly be reached
-        // during calculations, and write resulting data after it, only expanding memory when actually needed.
-        data = new CreditAccountData[](num);
-        uint256 dataOffset;
-
-        // FIXME: This should be proven to be enough to properly return the data, and possibly made tighter
-        uint256 gasThreshold = gasleft() / 64;
+            // either finished or reached one of return size or gas limits
+            if (dataOffset == data.length || scanned < limit) break;
 
-        uint256 len = ICreditManagerV3(creditManager).creditAccountsLen();
-        while (offset < len) {
-            bool outOfGas;
-            uint256 processed;
-            (dataOffset, outOfGas, processed) = _getCreditAccounts({
-                creditManager: creditManager,
-                filter: caFilter,
-                data: data,
-                dataOffset: dataOffset,
-                offset: offset,
-                limit: STEP_SIZE,
-                gasThreshold: gasThreshold
-            });
-            offset += processed;
-            nextOffset += processed;
+            _p.scanLimit -= limit;
+            if (_p.scanLimit == 0) break;
+            _p.offset = 0;
+        }
 
-            if (outOfGas) {
-                // trim the array to its actual size
-                assembly {
-                    mstore(data, dataOffset)
-                }
-                return (data, dataOffset == num, nextOffset);
+        if (dataOffset < data.length) {
+            // trim the array to its actual size
+            assembly {
+                mstore(data, dataOffset)
             }
         }
-        return (data, true, nextOffset);
+
+        return (data, dataOffset == num, nextOffset);
     }
 
-    /// @dev Same as above but with no gas limit control
-    function getCreditAccounts(address creditManager, CreditAccountFilter memory caFilter)
+    /// @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)
         external
         view
-        returns (CreditAccountData[] memory data)
+        returns (CreditAccountData[] memory data, bool finished, uint256 nextOffset)
     {
-        uint256 num = countCreditAccounts(creditManager, caFilter, 0);
-        data = new CreditAccountData[](num);
+        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();
-        _getCreditAccounts({
+        // 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: 0,
-            limit: len,
-            gasThreshold: 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)
+            }
+        }
+
+        return (data, dataOffset == num, nextOffset);
     }
 
     // -------- //
@@ -230,15 +180,15 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
     // -------- //
 
     /// @notice Counts credit accounts that match `caFilter` in credit managers matching `cmFilter`
-    /// @dev    The `offset` parameter specifies the position to start scanning from in the list of all
-    ///         credit accounts opened in credit managers matching `cmFilter`
     function countCreditAccounts(
         CreditManagerFilter memory cmFilter,
         CreditAccountFilter memory caFilter,
-        uint256 offset
+        Pagination memory pagination
     ) public view returns (uint256 num) {
-        address[] memory creditManagers = _getCreditManagers(cmFilter);
+        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();
 
@@ -248,27 +198,29 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
                 continue;
             }
 
-            while (offset < len) {
-                num += _countCreditAccounts(creditManagers[i], caFilter, offset, STEP_SIZE);
-                offset += STEP_SIZE;
-            }
+            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 a given `creditManager`
-    /// @dev    The `offset` parameter specifies the position to start scanning from in the list of all
-    ///         credit accounts opened in `creditManager`
-    function countCreditAccounts(address creditManager, CreditAccountFilter memory caFilter, uint256 offset)
-        public
-        view
-        returns (uint256 num)
-    {
+    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();
-        while (offset < len) {
-            num += _countCreditAccounts(creditManager, caFilter, offset, STEP_SIZE);
-            offset += STEP_SIZE;
-        }
+        if (len <= offset) return 0;
+        uint256 limit = Math.min(len - offset, scanLimit);
+
+        return _countCreditAccounts(creditManager, caFilter, offset, limit);
     }
 
     // --------- //
@@ -282,19 +234,18 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
         CreditAccountData[] memory data,
         uint256 dataOffset,
         uint256 offset,
-        uint256 limit,
-        uint256 gasThreshold
-    ) internal view returns (uint256, bool, uint256) {
+        uint256 limit
+    ) internal view returns (uint256 nextDataOffset, uint256 scanned) {
         address[] memory creditAccounts = ICreditManagerV3(creditManager).creditAccounts(offset, limit);
-        uint256 len = creditAccounts.length;
-        for (uint256 i; i < len; ++i) {
-            // early return if remaining gas is below given threshold
-            if (gasleft() < gasThreshold) return (dataOffset, true, i);
+        for (uint256 i; i < creditAccounts.length; ++i) {
             if (_checkFilterMatch(creditAccounts[i], creditManager, filter)) {
                 data[dataOffset++] = _getCreditAccountData(creditAccounts[i], creditManager);
             }
+
+            // either finished or reached one of return size or gas limits
+            if (dataOffset == data.length || gasleft() < GAS_THRESHOLD) return (dataOffset, i + 1);
         }
-        return (dataOffset, false, len);
+        return (dataOffset, creditAccounts.length);
     }
 
     /// @dev Counting implementation
@@ -338,26 +289,30 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
             data.totalValueUSD = cdd_.totalValueUSD;
             data.twvUSD = cdd_.twvUSD;
             data.totalValue = cdd.totalValue;
-            data.healthFactor = cdd.totalDebtUSD == 0 ? type(uint256).max : cdd.twvUSD * 1e18 / cdd.totalDebtUSD;
+
+            data.healthFactor = cdd.twvUSD * PERCENTAGE_FACTOR >= type(uint16).max * cdd.totalDebtUSD
+                ? type(uint16).max
+                : uint16(cdd.twvUSD * PERCENTAGE_FACTOR / cdd.totalDebtUSD);
             data.success = true;
         } catch {}
 
         uint256 numTokens = ICreditManagerV3(creditManager).collateralTokensCount();
         data.tokens = new TokenInfo[](numTokens);
         for (uint256 i; i < numTokens; ++i) {
-            address token = ICreditManagerV3(creditManager).getTokenByMask(1 << i);
+            uint256 mask = 1 << i;
+            address token = ICreditManagerV3(creditManager).getTokenByMask(mask);
             data.tokens[i].token = token;
+            data.tokens[i].mask = mask;
 
             try IERC20(token).balanceOf(creditAccount) returns (uint256 balance) {
                 data.tokens[i].balance = balance;
                 data.tokens[i].success = true;
             } catch {}
 
-            // down goes quotas logic which does not apply to underlying
-            if (i == 0) continue;
-
-            (data.tokens[i].quota,) =
-                IPoolQuotaKeeperV3(cdd._poolQuotaKeeper).getQuotaAndOutstandingInterest(creditAccount, token);
+            if (IPoolQuotaKeeperV3(cdd._poolQuotaKeeper).isQuotedToken(token)) {
+                (data.tokens[i].quota,) =
+                    IPoolQuotaKeeperV3(cdd._poolQuotaKeeper).getQuotaAndOutstandingInterest(creditAccount, token);
+            }
         }
     }
 
@@ -381,7 +336,9 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
             try ICreditManagerV3(creditManager).calcDebtAndCollateral(creditAccount, CollateralCalcTask.DEBT_COLLATERAL)
             returns (CollateralDebtData memory cdd) {
                 if (filter.reverting) return false;
-                uint256 healthFactor = cdd.totalDebtUSD == 0 ? type(uint256).max : cdd.twvUSD * 1e18 / cdd.totalDebtUSD;
+                uint16 healthFactor = cdd.twvUSD * PERCENTAGE_FACTOR >= type(uint16).max * cdd.totalDebtUSD
+                    ? type(uint16).max
+                    : uint16(cdd.twvUSD * PERCENTAGE_FACTOR / cdd.totalDebtUSD);
                 if (filter.minHealthFactor != 0 && healthFactor < filter.minHealthFactor) return false;
                 if (filter.maxHealthFactor != 0 && healthFactor > filter.maxHealthFactor) return false;
             } catch {
@@ -398,7 +355,7 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
         view
         returns (address[] memory creditManagers)
     {
-        address[] memory configurators = IAddressProviderV3(addressProvider).marketConfigurators();
+        address[] memory configurators = IAddressProviderV3(ADDRESS_PROVIDER).marketConfigurators();
 
         // rough estimate of maximum number of credit managers
         uint256 max;
@@ -420,15 +377,15 @@ contract CreditAccountCompressor is IVersion, SanityCheckTrait {
             address[] memory managers = IContractsRegister(cr).getCreditManagers();
             for (uint256 j; j < managers.length; ++j) {
                 // we're only concerned with v3 contracts
-                uint256 ver = IVersion(managers[i]).version();
+                uint256 ver = IVersion(managers[j]).version();
                 if (ver < 3_00 || ver > 3_99) continue;
 
                 if (filter.pool != address(0)) {
-                    if (ICreditManagerV3(managers[i]).pool() != filter.pool) continue;
+                    if (ICreditManagerV3(managers[j]).pool() != filter.pool) continue;
                 }
 
                 if (filter.underlying != address(0)) {
-                    if (ICreditManagerV3(managers[i]).underlying() != filter.underlying) continue;
+                    if (ICreditManagerV3(managers[j]).underlying() != filter.underlying) continue;
                 }
 
                 creditManagers[num++] = managers[j];

package/contracts/compressors/Types.sol

@@ -17,7 +17,7 @@ pragma solidity ^0.8.17;
 /// @param  totalValueUSD Account's total value in USD
 /// @param  twvUSD Account's threshold-weighted value in USD
 /// @param  totalValue Account's total value in underlying
-/// @param  healthFactor Account's health factor, i.e. ratio of `twvUSD` to `totalDebtUSD` with 18 decimals precision
+/// @param  healthFactor Account's health factor, i.e. ratio of `twvUSD` to `totalDebtUSD`, in bps
 /// @param  success Whether collateral calculation was successful
 /// @param  tokens Info on all collateral tokens in account's credit manager ordered by their mask, see `TokenInfo`
 /// @dev    Fields from `totalDebtUSD` through `healthFactor` are not filled if `success` is `false`
@@ -36,7 +36,7 @@ struct CreditAccountData {
     uint256 totalValueUSD;
     uint256 twvUSD;
     uint256 totalValue;
-    uint256 healthFactor;
+    uint16 healthFactor;
     bool success;
     TokenInfo[] tokens;
 }
@@ -50,8 +50,8 @@ struct CreditAccountData {
 struct CreditAccountFilter {
     address owner;
     bool includeZeroDebt;
-    uint256 minHealthFactor;
-    uint256 maxHealthFactor;
+    uint16 minHealthFactor;
+    uint16 maxHealthFactor;
     bool reverting;
 }
 
@@ -65,6 +65,18 @@ struct CreditManagerFilter {
     address underlying;
 }
 
+/// @notice Pagination options
+/// @param  offset Position to start scanning from in the list of all credit accounts open in given credit managers
+/// @param  scanLimit If set, specifies maximum number of accounts to scan, which can be helpful to parallelize querying
+/// @param  returnLimit If set, specifies maximum number of accounts to return, which can be helpful to optimize querying
+///         as at some point allocating memory for returned data leaves almost no room for actual data preparation
+/// @dev    `offset` and `scanLimit` apply to both querying and counting, while `returnLimit` only applies to querying
+struct Pagination {
+    uint256 offset;
+    uint256 scanLimit;
+    uint256 returnLimit;
+}
+
 /// @notice Price feed answer packed in a struct
 struct PriceFeedAnswer {
     int256 price;
@@ -107,11 +119,13 @@ struct PriceFeedTreeNode {
 
 /// @notice Info on credit account's holdings of a token
 /// @param  token Token address
+/// @param  mask Token mask in the credit manager
 /// @param  balance Account's balance of token
 /// @param  quota Account's quota of token
 /// @param  success Whether balance call was successful
 struct TokenInfo {
     address token;
+    uint256 mask;
     uint256 balance;
     uint256 quota;
     bool success;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/periphery-v3",
-  "version": "1.7.0-next.5",
+  "version": "1.7.0-next.6",
   "main": "index.js",
   "repository": "git@github.com:Gearbox-protocol/periphery-v3.git",
   "author": "Mikael <26343374+0xmikko@users.noreply.github.com>",