@pendle/core-v2 2.29.4 → 2.30.1

package/contracts/interfaces/Silo/ISilo.sol

@@ -69,12 +69,7 @@ interface ISilo {
     /// @param depositor wallet address that deposited asset
     /// @param amount amount of asset that was deposited
     /// @param collateralOnly type of deposit, true if collateralOnly deposit was used
-    event Deposit(
-        address indexed asset,
-        address indexed depositor,
-        uint256 amount,
-        bool collateralOnly
-    );
+    event Deposit(address indexed asset, address indexed depositor, uint256 amount, bool collateralOnly);
 
     /// @notice Emitted when withdraw is made
     /// @param asset asset address that was withdrawn
@@ -108,12 +103,7 @@ interface ISilo {
     /// @param shareAmountRepaid amount of collateral-share token that was repaid. This is collateral token representing
     /// ownership of underlying deposit.
     /// @param seizedCollateral amount of underlying token that was seized by liquidator
-    event Liquidate(
-        address indexed asset,
-        address indexed user,
-        uint256 shareAmountRepaid,
-        uint256 seizedCollateral
-    );
+    event Liquidate(address indexed asset, address indexed user, uint256 shareAmountRepaid, uint256 seizedCollateral);
 
     /// @notice Emitted when the status for an asset is updated
     /// @param asset asset address that was updated
@@ -159,10 +149,7 @@ interface ISilo {
     /// with corresponding state
     /// @return assets array of initialized assets of Silo
     /// @return assetsStorage array of assets state corresponding to `assets` array
-    function getAssetsWithState()
-        external
-        view
-        returns (address[] memory assets, AssetStorage[] memory assetsStorage);
+    function getAssetsWithState() external view returns (address[] memory assets, AssetStorage[] memory assetsStorage);
 
     /// @notice Check if depositing an asset for given account is possible
     /// @dev Depositing an asset that has been already borrowed (and vice versa) is disallowed
@@ -243,10 +230,7 @@ interface ISilo {
     /// @param _amount The amount of the token to borrow
     /// @return debtAmount borrowed amount
     /// @return debtShare user debt share based on borrowed amount
-    function borrow(
-        address _asset,
-        uint256 _amount
-    ) external returns (uint256 debtAmount, uint256 debtShare);
+    function borrow(address _asset, uint256 _amount) external returns (uint256 debtAmount, uint256 debtShare);
 
     /// @notice Router function to borrow `_amount` of `_asset` tokens from the Silo for the `_receiver`
     /// @param _asset The address of the token to borrow
@@ -268,10 +252,7 @@ interface ISilo {
     /// @param _amount amount of asset to repay, includes interests
     /// @return repaidAmount amount repaid
     /// @return burnedShare burned debt share
-    function repay(
-        address _asset,
-        uint256 _amount
-    ) external returns (uint256 repaidAmount, uint256 burnedShare);
+    function repay(address _asset, uint256 _amount) external returns (uint256 repaidAmount, uint256 burnedShare);
 
     /// @notice Allows to repay in behalf of borrower to execute liquidation
     /// @param _asset The address of the token to repay

package/contracts/interfaces/Silo/ISiloIncentiveController.sol

@@ -7,10 +7,7 @@ interface ISiloIncentiveController {
      * @param amount Amount of rewards to claim
      * @return Rewards claimed
      */
-    function claimRewardsToSelf(
-        address[] calldata assets,
-        uint256 amount
-    ) external returns (uint256);
+    function claimRewardsToSelf(address[] calldata assets, uint256 amount) external returns (uint256);
 
     /**
      * @dev for backward compatibility with previous implementation of the Incentives controller

package/contracts/interfaces/Silo/ISiloLens.sol

@@ -2,8 +2,5 @@
 pragma solidity ^0.8.0;
 
 interface ISiloLens {
-    function totalDepositsWithInterest(
-        address _silo,
-        address _asset
-    ) external view returns (uint256 _totalDeposits);
+    function totalDepositsWithInterest(address _silo, address _asset) external view returns (uint256 _totalDeposits);
 }

package/contracts/interfaces/Stader/IStaderStakeManager.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 interface IStaderStakeManager {
     // Errors
@@ -54,4 +54,4 @@ interface IStaderStakeManager {
     function depositETHOverTargetWeight() external;
 
     function isVaultHealthy() external view returns (bool);
-}
+}

package/contracts/interfaces/Thena/IThenaFactory.sol

@@ -13,11 +13,7 @@ interface IThenaFactory {
 
     function getPair(address tokenA, address token, bool stable) external view returns (address);
 
-    function createPair(
-        address tokenA,
-        address tokenB,
-        bool stable
-    ) external returns (address pair);
+    function createPair(address tokenA, address tokenB, bool stable) external returns (address pair);
 
     function getFee(bool _stable) external view returns (uint256);
 }

package/contracts/interfaces/Thena/IThenaGaugeV2.sol

@@ -2,7 +2,6 @@
 
 pragma solidity ^0.8.0;
 
-
 interface IThenaGaugeV2 {
     function emergency() external returns (bool);
 
@@ -15,4 +14,4 @@ interface IThenaGaugeV2 {
     function getReward() external;
 
     function balanceOf(address account) external view returns (uint256);
-}
+}

package/contracts/interfaces/Thena/IThenaPair.sol

@@ -16,15 +16,13 @@ interface IThenaPair {
     function getReserves() external view returns (uint _reserve0, uint _reserve1, uint _blockTimestampLast);
     function getAmountOut(uint, address) external view returns (uint);
 
-    function name() external view returns(string memory);
-    function symbol() external view returns(string memory);
+    function name() external view returns (string memory);
+    function symbol() external view returns (string memory);
     function totalSupply() external view returns (uint);
     function decimals() external view returns (uint8);
 
     function claimable0(address _user) external view returns (uint);
     function claimable1(address _user) external view returns (uint);
 
-    function isStable() external view returns(bool);
-
-
+    function isStable() external view returns (bool);
 }

package/contracts/offchain-helpers/AddressProvider.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../interfaces/IAddressProvider.sol";
 import "../core/libraries/BoringOwnableUpgradeable.sol";

package/contracts/offchain-helpers/AutomateReady.sol

@@ -3,17 +3,17 @@ pragma solidity ^0.8.14;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-    enum Module {
-        RESOLVER,
-        TIME,
-        PROXY,
-        SINGLE_EXEC
-    }
+enum Module {
+    RESOLVER,
+    TIME,
+    PROXY,
+    SINGLE_EXEC
+}
 
-    struct ModuleData {
-        Module[] modules;
-        bytes[] args;
-    }
+struct ModuleData {
+    Module[] modules;
+    bytes[] args;
+}
 
 interface IAutomate {
     function createTask(
@@ -33,17 +33,9 @@ interface IAutomate {
 }
 
 interface ITaskTreasuryUpgradable {
-    function depositFunds(
-        address receiver,
-        address token,
-        uint256 amount
-    ) external payable;
-
-    function withdrawFunds(
-        address payable receiver,
-        address token,
-        uint256 amount
-    ) external;
+    function depositFunds(address receiver, address token, uint256 amount) external payable;
+
+    function withdrawFunds(address payable receiver, address token, uint256 amount) external;
 }
 
 interface IOpsProxyFactory {
@@ -61,8 +53,7 @@ abstract contract AutomateReady {
     address public immutable dedicatedMsgSender;
     address private immutable _gelato;
     address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
-    address private constant OPS_PROXY_FACTORY =
-    0xC815dB16D4be6ddf2685C201937905aBf338F5D7;
+    address private constant OPS_PROXY_FACTORY = 0xC815dB16D4be6ddf2685C201937905aBf338F5D7;
 
     /**
      * @dev
@@ -81,9 +72,7 @@ abstract contract AutomateReady {
     constructor(address _automate, address _taskCreator) {
         automate = IAutomate(_automate);
         _gelato = IAutomate(_automate).gelato();
-        (dedicatedMsgSender,) = IOpsProxyFactory(OPS_PROXY_FACTORY).getProxyOf(
-            _taskCreator
-        );
+        (dedicatedMsgSender, ) = IOpsProxyFactory(OPS_PROXY_FACTORY).getProxyOf(_taskCreator);
     }
 
     /**
@@ -94,18 +83,14 @@ abstract contract AutomateReady {
      */
     function _transfer(uint256 _fee, address _feeToken) internal {
         if (_feeToken == ETH) {
-            (bool success,) = _gelato.call{value: _fee}("");
+            (bool success, ) = _gelato.call{value: _fee}("");
             require(success, "_transfer: ETH transfer failed");
         } else {
             SafeERC20.safeTransfer(IERC20(_feeToken), _gelato, _fee);
         }
     }
 
-    function _getFeeDetails()
-    internal
-    view
-    returns (uint256 fee, address feeToken)
-    {
+    function _getFeeDetails() internal view returns (uint256 fee, address feeToken) {
         (fee, feeToken) = automate.getFeeDetails();
     }
 }

package/contracts/offchain-helpers/BaseSplitCodeFactoryContract.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../core/libraries/BoringOwnableUpgradeable.sol";
 import "../core/libraries/BaseSplitCodeFactory.sol";
@@ -30,18 +30,8 @@ contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeable {
             uint256 creationCodeSizeB
         )
     {
-        (
-            creationCodeContractA,
-            creationCodeSizeA,
-            creationCodeContractB,
-            creationCodeSizeB
-        ) = BaseSplitCodeFactory.setCreationCode(creationCode);
-        emit Deployed(
-            name,
-            creationCodeContractA,
-            creationCodeSizeA,
-            creationCodeContractB,
-            creationCodeSizeB
-        );
+        (creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB) = BaseSplitCodeFactory
+            .setCreationCode(creationCode);
+        emit Deployed(name, creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB);
     }
 }

package/contracts/offchain-helpers/BoringLpSeller.sol

@@ -12,13 +12,8 @@ abstract contract BoringLpSeller {
     /// @param netLpIn amount of Lp to sell
     /// @param tokenOut should be included in SY.getTokensOut()
     /// @return netTokenOut amount of token out
-    function _sellLpForToken(
-        address market,
-        uint256 netLpIn,
-        address tokenOut
-    ) internal returns (uint256 netTokenOut) {
-        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
-            .readTokens();
+    function _sellLpForToken(address market, uint256 netLpIn, address tokenOut) internal returns (uint256 netTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
         IPMarket(market).transfer(market, netLpIn);
 
@@ -29,16 +24,8 @@ abstract contract BoringLpSeller {
             uint256 netSyFromPt = YT.redeemPY(address(SY));
             netSyToRedeem = netSyRemoved + netSyFromPt;
         } else {
-            (uint256 netSyRemoved, uint256 netPtRemoved) = IPMarket(market).burn(
-                address(SY),
-                market,
-                netLpIn
-            );
-            (uint256 netSySwappedOut, ) = IPMarket(market).swapExactPtForSy(
-                address(SY),
-                netPtRemoved,
-                EMPTY_BYTES
-            );
+            (uint256 netSyRemoved, uint256 netPtRemoved) = IPMarket(market).burn(address(SY), market, netLpIn);
+            (uint256 netSySwappedOut, ) = IPMarket(market).swapExactPtForSy(address(SY), netPtRemoved, EMPTY_BYTES);
             netSyToRedeem = netSyRemoved + netSySwappedOut;
         }
 

package/contracts/offchain-helpers/BoringPtSeller.sol

@@ -12,13 +12,8 @@ abstract contract BoringPtSeller {
     /// @param netPtIn amount of Pt to sell
     /// @param tokenOut should be included in SY.getTokensOut()
     /// @return netTokenOut amount of token out
-    function _sellPtForToken(
-        address market,
-        uint256 netPtIn,
-        address tokenOut
-    ) internal returns (uint256 netTokenOut) {
-        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
-            .readTokens();
+    function _sellPtForToken(address market, uint256 netPtIn, address tokenOut) internal returns (uint256 netTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 netSyOut;
         if (PT.isExpired()) {

package/contracts/offchain-helpers/Broadcaster.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../interfaces/IPVotingController.sol";
 import "../LiquidityMining/libraries/WeekMath.sol";
@@ -31,7 +31,7 @@ contract Broadcaster is Initializable, BoringOwnableUpgradeable, UUPSUpgradeable
         for (uint256 i = 0; i < chainIds.length; ) {
             uint64 chainId = chainIds[i];
             uint256 fee = votingController.getBroadcastResultFee(chainId);
-            votingController.broadcastResults{ value: fee }(chainId);
+            votingController.broadcastResults{value: fee}(chainId);
             unchecked {
                 i++;
             }

package/contracts/offchain-helpers/BulkSellerOffchain.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../core/BulkSeller/BulkSellerMathCore.sol";
 import "../core/BulkSeller/BulkSeller.sol";
@@ -8,11 +8,7 @@ contract BulkSellerOffchain {
     using BulkSellerMathCore for BulkSellerState;
     using PMath for uint256;
 
-    function calcCurrentRates(IPBulkSeller bulk)
-        external
-        view
-        returns (uint256 rateTokenToSy, uint256 rateSyToToken)
-    {
+    function calcCurrentRates(IPBulkSeller bulk) external view returns (uint256 rateTokenToSy, uint256 rateSyToToken) {
         BulkSellerState memory state = bulk.readState();
         address SY = bulk.SY();
         address token = bulk.token();
@@ -31,21 +27,13 @@ contract BulkSellerOffchain {
         }
     }
 
-    function getCurrentState(IPBulkSeller bulk)
-        external
-        view
-        returns (
-            BulkSellerState memory state,
-            uint256 tokenProp,
-            uint256 hypoTokenBal
-        )
-    {
+    function getCurrentState(
+        IPBulkSeller bulk
+    ) external view returns (BulkSellerState memory state, uint256 tokenProp, uint256 hypoTokenBal) {
         state = bulk.readState();
 
         tokenProp = state.getTokenProp();
-        hypoTokenBal =
-            state.totalToken +
-            IStandardizedYield(bulk.SY()).previewRedeem(bulk.token(), state.totalSy);
+        hypoTokenBal = state.totalToken + IStandardizedYield(bulk.SY()).previewRedeem(bulk.token(), state.totalSy);
     }
 
     function calcCurrentRatesWithAmount(

package/contracts/offchain-helpers/EmptyUUPS.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../core/libraries/BoringOwnableUpgradeable.sol";

package/contracts/offchain-helpers/LegacyNFTHelper.sol

@@ -26,23 +26,14 @@ interface StarNFTV1 {
         uint256[] ids,
         uint256[] values
     );
-    event TransferSingle(
-        address indexed operator,
-        address indexed from,
-        address indexed to,
-        uint256 id,
-        uint256 value
-    );
+    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
     event URI(string value, uint256 indexed id);
 
     function addMinter(address minter) external;
 
     function balanceOf(address account, uint256 id) external view returns (uint256);
 
-    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
-        external
-        view
-        returns (uint256[] memory);
+    function balanceOfBatch(address[] memory accounts, uint256[] memory ids) external view returns (uint256[] memory);
 
     function baseURI() external view returns (string memory);
 
@@ -56,11 +47,7 @@ interface StarNFTV1 {
 
     function mint(address account, uint256 powah) external returns (uint256);
 
-    function mintBatch(
-        address account,
-        uint256 amount,
-        uint256[] memory powahArr
-    ) external returns (uint256[] memory);
+    function mintBatch(address account, uint256 amount, uint256[] memory powahArr) external returns (uint256[] memory);
 
     function minters(address) external view returns (bool);
 
@@ -78,13 +65,7 @@ interface StarNFTV1 {
         bytes memory data
     ) external;
 
-    function safeTransferFrom(
-        address from,
-        address to,
-        uint256 id,
-        uint256 amount,
-        bytes memory data
-    ) external;
+    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) external;
 
     function setApprovalForAll(address operator, bool approved) external;
 

package/contracts/offchain-helpers/MarketExchangeRateLib.sol

@@ -11,21 +11,10 @@ library MarketExchangeRateLib {
 
     function getMarketExchangeRate(address market) internal view returns (uint256) {
         MarketState memory state = IPMarket(market).readState(address(0));
-        MarketPreCompute memory comp = state.getMarketPreCompute(
-            _getPYIndexCurrent(market),
-            block.timestamp
-        );
+        MarketPreCompute memory comp = state.getMarketPreCompute(_getPYIndexCurrent(market), block.timestamp);
 
         return
-            MarketMathCore
-                ._getExchangeRate(
-                    state.totalPt,
-                    comp.totalAsset,
-                    comp.rateScalar,
-                    comp.rateAnchor,
-                    0
-                )
-                .Uint();
+            MarketMathCore._getExchangeRate(state.totalPt, comp.totalAsset, comp.rateScalar, comp.rateAnchor, 0).Uint();
     }
 
     function _getPYIndexCurrent(address market) private view returns (PYIndex) {

package/contracts/offchain-helpers/Multicall2.sol

@@ -16,9 +16,7 @@ contract Multicall2 {
         bytes returnData;
     }
 
-    function aggregate(
-        Call[] memory calls
-    ) public returns (uint256 blockNumber, bytes[] memory returnData) {
+    function aggregate(Call[] memory calls) public returns (uint256 blockNumber, bytes[] memory returnData) {
         blockNumber = block.number;
         returnData = new bytes[](calls.length);
         for (uint256 i = 0; i < calls.length; i++) {
@@ -66,10 +64,7 @@ contract Multicall2 {
         blockHash = blockhash(block.number - 1);
     }
 
-    function tryAggregate(
-        bool requireSuccess,
-        Call[] memory calls
-    ) public returns (Result[] memory returnData) {
+    function tryAggregate(bool requireSuccess, Call[] memory calls) public returns (Result[] memory returnData) {
         returnData = new Result[](calls.length);
         for (uint256 i = 0; i < calls.length; i++) {
             (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);

package/contracts/offchain-helpers/PendleMulticallV1.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 contract PendleMulticallV1 {
     struct Call {
@@ -42,9 +42,7 @@ contract PendleMulticallV1 {
         for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
-            (bool success, bytes memory resp) = call.target.call{ gas: gasLimit }(
-                calls[i].callData
-            );
+            (bool success, bytes memory resp) = call.target.call{gas: gasLimit}(calls[i].callData);
             if (!success && requireSuccess) {
                 assembly {
                     revert(add(32, resp), mload(resp))

package/contracts/offchain-helpers/PendleMulticallV2.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 contract PendleMulticallV2 {
     error CallThenRevertError(bool success, bytes res);
@@ -17,7 +17,7 @@ contract PendleMulticallV2 {
     function aggregate(Call[] calldata calls) public payable virtual {
         uint256 length = calls.length;
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call(call.callData);
@@ -33,15 +33,15 @@ contract PendleMulticallV2 {
         }
     }
 
-    function tryAggregate(bool requireSuccess, uint256 gasLimit, Call[] calldata calls)
-        public
-        payable
-        returns (Result[] memory returnData)
-    {
+    function tryAggregate(
+        bool requireSuccess,
+        uint256 gasLimit,
+        Call[] calldata calls
+    ) public payable returns (Result[] memory returnData) {
         uint256 length = calls.length;
         returnData = new Result[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call{gas: gasLimit}(calls[i].callData);
@@ -59,15 +59,14 @@ contract PendleMulticallV2 {
         }
     }
 
-    function tryAggregateRevert(uint256 gasLimit, Call[] calldata calls)
-        public
-        payable
-        returns (bytes[] memory returnData)
-    {
+    function tryAggregateRevert(
+        uint256 gasLimit,
+        Call[] calldata calls
+    ) public payable returns (bytes[] memory returnData) {
         uint256 length = calls.length;
         returnData = new bytes[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (, returnData[i]) = address(this).delegatecall{gas: gasLimit}(

package/contracts/offchain-helpers/PendleOffchainStorage.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../interfaces/IPOffchainStorage.sol";
+
+contract PendleOffchainStorage is IPOffchainStorage, UUPSUpgradeable, AccessControlUpgradeable {
+    bytes32 public constant MAINTAINER = keccak256("MAINTAINER");
+
+    constructor() initializer {}
+
+    modifier onlyMaintainer() {
+        require(isMaintainer(msg.sender), "not maintainer");
+        _;
+    }
+
+    function isMaintainer(address addr) public view returns (bool) {
+        return (hasRole(DEFAULT_ADMIN_ROLE, addr) || hasRole(MAINTAINER, addr));
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                                CORE
+    //////////////////////////////////////////////////////////////*/
+
+    mapping(bytes32 => bytes) internal _storage;
+
+    function setStorageUint256(bytes32 key, uint256 value) external onlyMaintainer {
+        _setStorage(key, abi.encode(value));
+    }
+
+    function setStorage(bytes32 key, bytes memory value) external onlyMaintainer {
+        _setStorage(key, value);
+    }
+
+    function getUint256(bytes32 key) external view returns (uint256) {
+        return abi.decode(_storage[key], (uint256));
+    }
+
+    function _setStorage(bytes32 key, bytes memory value) internal {
+        _storage[key] = value;
+        emit SetStorage(key, value);
+    }
+
+    // TODO: update more getSomething functions later when theres a need
+
+    /*///////////////////////////////////////////////////////////////
+                            UPGRADABLE RELATED
+    //////////////////////////////////////////////////////////////*/
+    function initialize() external initializer {
+        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
+    }
+
+    function _authorizeUpgrade(address) internal view override {
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not admin");
+    }
+
+    uint256[49] private __gap;
+}

package/contracts/offchain-helpers/PtAndLpToAsset.sol

@@ -13,10 +13,7 @@ contract PtAndLpToAsset {
     function getLpToAssetRate(IPMarket market) public view returns (uint256 lpToAssetRate) {
         MarketState memory state = market.readState(address(0));
         uint256 pyIndexCurrent = _getPYIndexCurrent(market);
-        MarketPreCompute memory comp = state.getMarketPreCompute(
-            PYIndex.wrap(pyIndexCurrent),
-            block.timestamp
-        );
+        MarketPreCompute memory comp = state.getMarketPreCompute(PYIndex.wrap(pyIndexCurrent), block.timestamp);
 
         int256 totalHypotheticalAsset = comp.totalAsset +
             state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
@@ -39,10 +36,7 @@ contract PtAndLpToAsset {
             return (SY.exchangeRate().divDown(pyIndexCurrent));
         }
         uint256 timeToExpiry = state.expiry - block.timestamp;
-        int256 assetToPtRate = MarketMathCore._getExchangeRateFromImpliedRate(
-            state.lastLnImpliedRate,
-            timeToExpiry
-        );
+        int256 assetToPtRate = MarketMathCore._getExchangeRateFromImpliedRate(state.lastLnImpliedRate, timeToExpiry);
 
         ptToAssetRate = uint256(PMath.IONE.divDown(assetToPtRate));
     }