@pendle/core-v2 2.29.1 → 3.0.0-beta-2

package/contracts/limit/helpers/RevertReasonParser.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+/// @title Library that allows to parse unsuccessful arbitrary calls revert reasons.
+/// See https://solidity.readthedocs.io/en/latest/control-structures.html#revert for details.
+/// Note that we assume revert reason being abi-encoded as Error(string) so it may fail to parse reason
+/// if structured reverts appear in the future.
+///
+/// All unsuccessful parsings get encoded as Unknown(data) string
+
+library RevertReasonParser {
+    bytes4 private constant _PANIC_SELECTOR = bytes4(keccak256("Panic(uint256)"));
+    bytes4 private constant _ERROR_SELECTOR = bytes4(keccak256("Error(string)"));
+
+    function parse(bytes memory data, string memory prefix) internal pure returns (string memory) {
+        if (data.length >= 4) {
+            bytes4 selector;
+
+            assembly {
+                // solhint-disable-line no-inline-assembly
+                selector := mload(add(data, 0x20))
+            }
+
+            // 68 = 4-byte selector + 32 bytes offset + 32 bytes length
+            if (selector == _ERROR_SELECTOR && data.length >= 68) {
+                uint256 offset;
+                bytes memory reason;
+                assembly {
+                    // solhint-disable-line no-inline-assembly
+                    // 36 = 32 bytes data length + 4-byte selector
+                    offset := mload(add(data, 36))
+                    reason := add(data, add(36, offset))
+                }
+                /*
+                    revert reason is padded up to 32 bytes with ABI encoder: Error(string)
+                    also sometimes there is extra 32 bytes of zeros padded in the end:
+                    https://github.com/ethereum/solidity/issues/10170
+                    because of that we can't check for equality and instead check
+                    that offset + string length + extra 36 bytes is less than overall data length
+                */
+                require(data.length >= 36 + offset + reason.length, "Invalid revert reason");
+                return string(abi.encodePacked(prefix, "Error(", reason, ")"));
+            }
+            // 36 = 4-byte selector + 32 bytes integer
+            else if (selector == _PANIC_SELECTOR && data.length == 36) {
+                uint256 code;
+                assembly {
+                    // solhint-disable-line no-inline-assembly
+                    // 36 = 32 bytes data length + 4-byte selector
+                    code := mload(add(data, 36))
+                }
+                return string(abi.encodePacked(prefix, "Panic(", _toHex(code), ")"));
+            }
+        }
+
+        return string(abi.encodePacked(prefix, "Unknown(", _toHex(data), ")"));
+    }
+
+    function _toHex(uint256 value) private pure returns (string memory) {
+        return _toHex(abi.encodePacked(value));
+    }
+
+    function _toHex(bytes memory data) private pure returns (string memory) {
+        bytes16 alphabet = 0x30313233343536373839616263646566;
+        bytes memory str = new bytes(2 + data.length * 2);
+        str[0] = "0";
+        str[1] = "x";
+        for (uint256 i = 0; i < data.length; i++) {
+            str[2 * i + 2] = alphabet[uint8(data[i] >> 4)];
+            str[2 * i + 3] = alphabet[uint8(data[i] & 0x0f)];
+        }
+        return string(str);
+    }
+}

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/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";
@@ -17,10 +17,7 @@ contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeable {
         __BoringOwnable_init();
     }
 
-    function deploy(
-        string memory name,
-        bytes calldata creationCode
-    )
+    function deploy(string memory name, bytes calldata creationCode)
         external
         onlyOwner
         returns (
@@ -30,18 +27,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/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";
@@ -28,10 +28,10 @@ contract Broadcaster is Initializable, BoringOwnableUpgradeable, UUPSUpgradeable
         lastBroadcastedWeek = currentWeek;
 
         votingController.finalizeEpoch();
-        for (uint256 i = 0; i < chainIds.length; ) {
+        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/ChainlinkRelayerAutomation.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../core/libraries/BoringOwnableUpgradeable.sol";
 import "../core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol";
@@ -22,26 +22,19 @@ contract ChainlinkRelayerAutomation is AutomationCompatible, BoringOwnableUpgrad
         payable(owner).transfer(address(this).balance);
     }
 
-    function checkUpkeep(
-        bytes calldata /*checkData*/
-    )
+    function checkUpkeep(bytes calldata /*checkData*/ )
         public
         view
-        returns (
-            bool upkeepNeeded,
-            bytes memory /*performData*/
-        )
+        returns (bool upkeepNeeded, bytes memory /*performData*/ )
     {
-        (upkeepNeeded, ) = _checkUpkeep();
+        (upkeepNeeded,) = _checkUpkeep();
     }
 
-    function performUpkeep(
-        bytes calldata /*performData*/
-    ) public {
+    function performUpkeep(bytes calldata /*performData*/ ) public {
         (bool upkeepNeeded, int256 latestAnswer) = _checkUpkeep();
         require(upkeepNeeded, "no upkeep needed");
 
-        relayer.run{ value: address(this).balance }();
+        relayer.run{value: address(this).balance}();
         answerLastSent = latestAnswer;
     }
 

package/contracts/offchain-helpers/ChainlinkRelayerGelato.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./AutomateReady.sol";
 import "../core/libraries/BoringOwnableUpgradeable.sol";
@@ -10,8 +10,10 @@ contract ChainlinkRelayerGelato is AutomateReady, BoringOwnableUpgradeable {
 
     int256 public lastSentAnswer;
 
-    constructor(address _automate, address _taskCreator, PendleChainlinkRelayer _relayer) initializer
-    AutomateReady(_automate, _taskCreator) {
+    constructor(address _automate, address _taskCreator, PendleChainlinkRelayer _relayer)
+        initializer
+        AutomateReady(_automate, _taskCreator)
+    {
         __BoringOwnable_init();
         relayer = _relayer;
     }
@@ -33,4 +35,3 @@ contract ChainlinkRelayerGelato is AutomateReady, BoringOwnableUpgradeable {
         lastSentAnswer = latestAnswer;
     }
 }
-

package/contracts/offchain-helpers/EmptyUUPS.sol

@@ -1,6 +1,7 @@
 // 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/PendleMulticallV1.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 contract PendleMulticallV1 {
     struct Call {
@@ -15,7 +15,7 @@ contract PendleMulticallV1 {
     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);
@@ -31,20 +31,18 @@ contract PendleMulticallV1 {
         }
     }
 
-    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
-            );
+            (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);

package/contracts/offchain-helpers/errors/SDKErrorsDirectory.sol

@@ -1,24 +1,10 @@
 pragma solidity ^0.8.0;
 
 library SDKErrorsDirectory {
-    error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
-    error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
-    error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
-    error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
-    error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
-    error BulkNotMaintainer();
-    error BulkNotAdmin();
-    error BulkSellerAlreadyExisted(address token, address SY, address bulk);
-    error BulkSellerInvalidToken(address token, address SY);
-    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
-    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
     error ApproxFail();
     error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
     error ApproxBinarySearchInputInvalid(
-        uint256 approxGuessMin,
-        uint256 approxGuessMax,
-        uint256 minGuessMin,
-        uint256 maxGuessMax
+        uint256 approxGuessMin, uint256 approxGuessMax, uint256 minGuessMin, uint256 maxGuessMax
     );
     error MarketExpired();
     error MarketZeroAmountsInput();
@@ -40,10 +26,7 @@ library SDKErrorsDirectory {
     error MarketFactoryInvalidPt();
     error MarketFactoryMarketExists();
     error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
-    error MarketFactoryReserveFeePercentTooHigh(
-        uint8 reserveFeePercent,
-        uint8 maxReserveFeePercent
-    );
+    error MarketFactoryReserveFeePercentTooHigh(uint8 reserveFeePercent, uint8 maxReserveFeePercent);
     error MarketFactoryZeroTreasury();
     error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
     error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);

package/contracts/offchain-helpers/router-static/PendleRouterStatic.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/proxy/Proxy.sol";
 import "../../interfaces/IPRouterStatic.sol";

package/contracts/offchain-helpers/router-static/base/ActionInfoStatic.sol

@@ -1,12 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../../interfaces/IPMarket.sol";
 import "../../../interfaces/IPRouterStatic.sol";
 import "../../../interfaces/IPYieldContractFactory.sol";
 import "../../../interfaces/IPMarketFactory.sol";
-import "../../../interfaces/IPBulkSellerFactory.sol";
-import "../../../interfaces/IPBulkSeller.sol";
 
 // solhint-disable no-empty-blocks
 contract ActionInfoStatic is IPActionInfoStatic {
@@ -34,11 +32,7 @@ contract ActionInfoStatic is IPActionInfoStatic {
             return (IStandardizedYield(SY).getTokensIn(), IStandardizedYield(SY).getTokensOut());
         } catch {}
 
-        try IPMarket(token).readTokens() returns (
-            IStandardizedYield SY,
-            IPPrincipalToken,
-            IPYieldToken
-        ) {
+        try IPMarket(token).readTokens() returns (IStandardizedYield SY, IPPrincipalToken, IPYieldToken) {
             return (SY.getTokensIn(), SY.getTokensOut());
         } catch {}
 
@@ -67,11 +61,7 @@ contract ActionInfoStatic is IPActionInfoStatic {
         res.ptBalance = TokenAmount(_PT, _balanceOf(_PT, user));
 
         // interest
-        (uint256 interestOut, uint256[] memory rewardsOut) = YT.redeemDueInterestAndRewards(
-            user,
-            true,
-            true
-        );
+        (uint256 interestOut, uint256[] memory rewardsOut) = YT.redeemDueInterestAndRewards(user, true, true);
 
         res.unclaimedInterest = TokenAmount(YT.SY(), interestOut);
 
@@ -80,17 +70,14 @@ contract ActionInfoStatic is IPActionInfoStatic {
         res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
     }
 
-    function getUserMarketInfo(address market, address user)
-        external
-        returns (UserMarketInfo memory res)
-    {
+    function getUserMarketInfo(address market, address user) external returns (UserMarketInfo memory res) {
         IPMarket _market = IPMarket(market);
         MarketState memory state = _market.readState(address(this));
 
         if (uint256(state.totalLp) == 0) return res; // market not initialized
 
         // LP PT SY
-        (IStandardizedYield SY, IPPrincipalToken PT, ) = _market.readTokens();
+        (IStandardizedYield SY, IPPrincipalToken PT,) = _market.readTokens();
 
         uint256 userLp = _balanceOf(market, user);
         uint256 userPt = (userLp * uint256(state.totalPt)) / uint256(state.totalLp);

package/contracts/offchain-helpers/router-static/base/ActionLimitOrdersStatic.sol

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../interfaces/IPMarket.sol";
+import "../../../interfaces/IPRouterStatic.sol";
+import "./StorageLayout.sol";
+import {LimitMathCore as LimitMath} from "../../../limit/LimitMathCore.sol";
+
+// contract ActionLimitOrdersStatic is StorageLayout, IPOrderMixinType {
+//     using PMath for uint256;
+//     using PMath for int256;
+
+//     using LogExpMath for int256;
+//     using PYIndexLib for PYIndex;
+//     using PYIndexLib for IPYieldToken;
+//     using MarketApproxPtInLib for MarketState;
+//     using MarketApproxPtOutLib for MarketState;
+//     using MarketMathCore for MarketState;
+
+//     uint256 internal constant _ORDER_DOES_NOT_EXIST = 0;
+//     uint256 internal constant _ORDER_FILLED = 1;
+
+//     IPLimitRouter public limitRouter;
+
+//     // TODO: opt for bytecode
+
+//     function normalFillStatic(FillOrderParams[] memory params)
+//         external
+//         returns (
+//             uint256 actualMaking,
+//             uint256 actualTaking,
+//             uint256 totalFee,
+//             NormalResults memory out,
+//             FillOrderParams[] memory postConvertedOrders
+//         )
+//     {
+//         OrderType Type = params[0].order.Type;
+//         bool tokenFromMaker = (Type == OrderType.SY_FOR_PT || Type == OrderType.SY_FOR_YT);
+
+//         OnchainParams memory onchain = preProcess(params, tokenFromMaker);
+//         out = LimitMath.calcNormalBatch(params, onchain);
+//         postConvertedOrders = params;
+
+//         if (tokenFromMaker) {
+//             (actualMaking, actualTaking, totalFee) = (out.totalMaking, out.totalTaking, out.totalFee);
+//         } else {
+//             (actualMaking, actualTaking, totalFee) = (out.totalMaking, out.totalTaking + out.totalFee, out.totalFee);
+//         }
+//     }
+
+//     function flashFillStatic(FillOrderParams[] memory params)
+//         external
+//         returns (
+//             uint256 actualInputFromTaker,
+//             uint256 actualOutputToTaker,
+//             uint256 totalFee,
+//             NormalResults memory out,
+//             FillOrderParams[] memory postConvertedOrders
+//         )
+//     {
+//         OrderType Type = params[0].order.Type;
+//         bool tokenFromMaker = (Type == OrderType.SY_FOR_PT || Type == OrderType.SY_FOR_YT);
+
+//         OnchainParams memory onchain = preProcess(params, tokenFromMaker);
+//         (out, actualInputFromTaker, actualOutputToTaker) = LimitMath.calcFlashBatch(params, onchain);
+//         totalFee = out.totalFee;
+//         postConvertedOrders = params;
+//     }
+
+//     function preProcess(FillOrderParams[] memory params, bool tokenToSy)
+//         internal
+//         returns (OnchainParams memory onchain)
+//     {
+//         _verifyAndUpdateMakings(params);
+
+//         address YT = params[0].order.YT;
+//         address SY = IPYieldToken(YT).SY();
+//         uint256 expiry = IPYieldToken(YT).expiry();
+//         require(block.timestamp < expiry, "PY expired");
+
+//         if (tokenToSy) {
+//             _mintSyStatic(params, IStandardizedYield(SY));
+//         }
+
+//         onchain = OnchainParams({
+//             timeToExpiry: expiry - block.timestamp,
+//             index: IPYieldToken(YT).newIndex(),
+//             feeRecipient: IPOrderMixin(limitRouter).feeRecipient(),
+//             feeRate: IPOrderMixin(limitRouter).feeRate()
+//         });
+//     }
+
+//     function _verifyAndUpdateMakings(FillOrderParams[] memory params) internal view {
+//         uint256 len = params.length;
+//         for (uint256 i = 0; i < len; i++) {
+//             FillOrderParams memory param = params[i];
+
+//             (, uint256 remainingMakerAmount) = _verifyOrder(param.order);
+//             uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
+
+//             param.makingAmount = netMaking;
+//         }
+//     }
+
+//     function _verifyOrder(Order memory order)
+//         internal
+//         view
+//         returns (bytes32, /*orderHash*/ uint256 /*remainingMakerAmount*/ )
+//     {
+//         bytes32 orderHash = limitRouter.hashOrder(order);
+//         uint256 remainingMakerAmount = limitRouter.remainingRaw(orderHash);
+
+//         if (remainingMakerAmount == _ORDER_FILLED) return (orderHash, 0);
+
+//         if (remainingMakerAmount == _ORDER_DOES_NOT_EXIST) {
+//             remainingMakerAmount = order.makingAmount;
+//         } else {
+//             unchecked {
+//                 remainingMakerAmount -= 1;
+//             }
+//         }
+
+//         // Check if order is valid predicate wise
+//         if (order.predicate.length > 0) {
+//             bool isValidPredicate = limitRouter.checkPredicate(order);
+//             require(isValidPredicate, "LOP: predicate returned false");
+//         }
+
+//         return (orderHash, remainingMakerAmount);
+//     }
+
+//     function _mintSyStatic(FillOrderParams[] memory params, IStandardizedYield SY) internal view {
+//         uint256 len = params.length;
+//         for (uint256 i = 0; i < len; i++) {
+//             FillOrderParams memory param = params[i];
+//             if (param.makingAmount == 0) continue;
+
+//             Order memory order = param.order;
+
+//             if (order.token != address(SY)) {
+//                 param.makingAmount = SY.previewDeposit(order.token, param.makingAmount);
+//             }
+//         }
+//     }
+// }