@pendle/core-v2 3.0.0-beta-11 → 3.0.0-beta-12

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "3.0.0-beta-11",
+  "version": "3.0.0-beta-12",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -25,15 +25,15 @@
   "devDependencies": {
     "@typechain/ethers-v5": "^9.0.0",
     "@typechain/hardhat": "^4.0.0",
-    "hardhat": "^2.19.0",
+    "hardhat": "^2.19.2",
     "hardhat-contract-sizer": "^2.10.0",
-    "prettier": "^3.1.0",
+    "prettier": "^3.1.1",
     "prettier-plugin-solidity": "^1.2.0",
     "solc": "^0.8.23-fixed",
     "solhint": "^4.0.0",
-    "ts-node": "^10.9.1",
+    "ts-node": "^10.9.2",
     "typechain": "^8.3.2",
-    "typescript": "^5.2.2"
+    "typescript": "^5.3.3"
   },
   "scripts": {
     "compile": "yarn hardhat compile",
@@ -44,8 +44,8 @@
   },
   "packageManager": "yarn@3.3.1",
   "dependencies": {
-    "@chainlink/contracts": "^0.6.1",
-    "@openzeppelin/contracts": "4.7.3",
-    "@openzeppelin/contracts-upgradeable": "4.7.3"
+    "@chainlink/contracts": "^0.8.0",
+    "@openzeppelin/contracts": "4.9.3",
+    "@openzeppelin/contracts-upgradeable": "4.9.3"
   }
 }

package/contracts/limit/helpers/ArgumentsDecoder.sol

@@ -1,47 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.0;
-
-/// @title Library with gas efficient alternatives to `abi.decode`
-library ArgumentsDecoder {
-    function decodeUint256(bytes memory data) internal pure returns (uint256) {
-        uint256 value;
-        assembly {
-            // solhint-disable-line no-inline-assembly
-            value := mload(add(data, 0x20))
-        }
-        return value;
-    }
-
-    function decodeBool(bytes memory data) internal pure returns (bool) {
-        bool value;
-        assembly {
-            // solhint-disable-line no-inline-assembly
-            value := eq(mload(add(data, 0x20)), 1)
-        }
-        return value;
-    }
-
-    function decodeTargetAndCalldata(bytes memory data) internal pure returns (address, bytes memory) {
-        address target;
-        bytes memory args;
-        assembly {
-            // solhint-disable-line no-inline-assembly
-            target := mload(add(data, 0x14))
-            args := add(data, 0x14)
-            mstore(args, sub(mload(data), 0x14))
-        }
-        return (target, args);
-    }
-
-    function decodeTargetAndData(bytes calldata data) internal pure returns (address, bytes calldata) {
-        address target;
-        bytes calldata args;
-        assembly {
-            // solhint-disable-line no-inline-assembly
-            target := shr(96, calldataload(data.offset))
-        }
-        args = data[20:];
-        return (target, args);
-    }
-}

package/contracts/limit/helpers/Permitable.sol

@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol";
-import "./RevertReasonParser.sol";
-import "../../interfaces/IDailLikePermit.sol";
-
-/// @title Base contract with common permit handling logics
-abstract contract Permitable {
-    function _permit(address token, bytes calldata permit) internal {
-        if (permit.length > 0) {
-            bool success;
-            bytes memory result;
-            if (permit.length == 32 * 7) {
-                // solhint-disable-next-line avoid-low-level-calls
-                (success, result) = token.call(abi.encodePacked(IERC20Permit.permit.selector, permit));
-            } else if (permit.length == 32 * 8) {
-                // solhint-disable-next-line avoid-low-level-calls
-                (success, result) = token.call(abi.encodePacked(IDaiLikePermit.permit.selector, permit));
-            } else {
-                revert("Wrong permit length");
-            }
-            if (!success) {
-                revert(RevertReasonParser.parse(result, "Permit failed: "));
-            }
-        }
-    }
-
-    function _permitMemory(address token, bytes memory permit) internal {
-        if (permit.length > 0) {
-            bool success;
-            bytes memory result;
-            if (permit.length == 32 * 7) {
-                // solhint-disable-next-line avoid-low-level-calls
-                (success, result) = token.call(abi.encodePacked(IERC20Permit.permit.selector, permit));
-            } else if (permit.length == 32 * 8) {
-                // solhint-disable-next-line avoid-low-level-calls
-                (success, result) = token.call(abi.encodePacked(IDaiLikePermit.permit.selector, permit));
-            } else {
-                revert("Wrong permit length");
-            }
-            if (!success) {
-                revert(RevertReasonParser.parse(result, "Permit failed: "));
-            }
-        }
-    }
-}

package/contracts/limit/helpers/RevertReasonParser.sol

@@ -1,75 +0,0 @@
-// 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/ChainlinkRelayerGelato.sol

@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.17;
-
-import "./AutomateReady.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
-import "../core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol";
-
-contract ChainlinkRelayerGelato is AutomateReady, BoringOwnableUpgradeable {
-    PendleChainlinkRelayer public immutable relayer;
-
-    int256 public lastSentAnswer;
-
-    constructor(address _automate, address _taskCreator, PendleChainlinkRelayer _relayer)
-        initializer
-        AutomateReady(_automate, _taskCreator)
-    {
-        __BoringOwnable_init();
-        relayer = _relayer;
-    }
-
-    receive() external payable {}
-
-    function withdraw() external onlyOwner {
-        payable(owner).transfer(address(this).balance);
-    }
-
-    function run() external {
-        int256 latestAnswer = IChainlinkAggregator(relayer.chainlinkFeed()).latestAnswer();
-        require(lastSentAnswer != latestAnswer, "answer not new");
-
-        (uint256 fee, address feeToken) = _getFeeDetails();
-        _transfer(fee, feeToken);
-
-        relayer.run{value: address(this).balance}();
-        lastSentAnswer = latestAnswer;
-    }
-}

package/contracts/offchain-helpers/PtAndLpToAsset.sol

@@ -1,62 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-import "../interfaces/IPMarket.sol";
-import "../core/libraries/math/PMath.sol";
-import "../core/Market/MarketMathCore.sol";
-
-contract PtAndLpToAsset {
-    using PMath for int256;
-    using PMath for uint256;
-    using MarketMathCore for MarketState;
-
-    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
-        );
-
-        int256 totalHypotheticalAsset = comp.totalAsset +
-            state.totalPt.mulDown(int256(_getPtToAssetRate(market, state, pyIndexCurrent)));
-
-        lpToAssetRate = uint256(totalHypotheticalAsset.divDown(state.totalLp));
-    }
-
-    function getPtToAssetRate(IPMarket market) public view returns (uint256 ptToAssetRate) {
-        MarketState memory state = market.readState(address(0));
-        return _getPtToAssetRate(market, state, _getPYIndexCurrent(market));
-    }
-
-    function _getPtToAssetRate(
-        IPMarket market,
-        MarketState memory state,
-        uint256 pyIndexCurrent
-    ) internal view returns (uint256 ptToAssetRate) {
-        if (state.expiry <= block.timestamp) {
-            (IStandardizedYield SY, , ) = market.readTokens();
-            return (SY.exchangeRate().divDown(pyIndexCurrent));
-        }
-        uint256 timeToExpiry = state.expiry - block.timestamp;
-        int256 assetToPtRate = MarketMathCore._getExchangeRateFromImpliedRate(
-            state.lastLnImpliedRate,
-            timeToExpiry
-        );
-
-        ptToAssetRate = uint256(PMath.IONE.divDown(assetToPtRate));
-    }
-
-    function _getPYIndexCurrent(IPMarket market) private view returns (uint256) {
-        (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
-
-        uint256 syIndex = SY.exchangeRate();
-        uint256 pyIndexStored = YT.pyIndexStored();
-
-        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
-            return pyIndexStored;
-        } else {
-            return PMath.max(syIndex, pyIndexStored);
-        }
-    }
-}

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

@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "@openzeppelin/contracts/proxy/Proxy.sol";
-import "../../interfaces/IPRouterStatic.sol";
-import "./base/StorageLayout.sol";
-
-// solhint-disable no-empty-blocks
-contract PendleRouterStatic is Proxy, StorageLayout {
-    constructor(address actionStorage) {
-        owner = msg.sender;
-        selectorToFacet[IPMiniDiamond.setFacetForSelectors.selector] = actionStorage;
-    }
-
-    function _implementation() internal view override returns (address res) {
-        res = selectorToFacet[msg.sig];
-        require(res != address(0), "selector not found");
-    }
-}

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

@@ -1,112 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../../interfaces/IPMarket.sol";
-import "../../../interfaces/IPRouterStatic.sol";
-import "../../../interfaces/IPYieldContractFactory.sol";
-import "../../../interfaces/IPMarketFactory.sol";
-
-// solhint-disable no-empty-blocks
-contract ActionInfoStatic is IPActionInfoStatic {
-    function getPY(address py) public view returns (address pt, address yt) {
-        try IPYieldToken(py).PT() returns (address _pt) {
-            pt = _pt;
-            yt = py;
-        } catch {
-            pt = py;
-            yt = IPPrincipalToken(py).YT();
-        }
-    }
-
-    /// can be SY, PY or Market
-    function getTokensInOut(address token)
-        external
-        view
-        returns (address[] memory tokensIn, address[] memory tokensOut)
-    {
-        try IStandardizedYield(token).getTokensIn() returns (address[] memory res) {
-            return (res, IStandardizedYield(token).getTokensOut());
-        } catch {}
-
-        try IPYieldToken(token).SY() returns (address SY) {
-            return (IStandardizedYield(SY).getTokensIn(), IStandardizedYield(SY).getTokensOut());
-        } catch {}
-
-        try IPMarket(token).readTokens() returns (IStandardizedYield SY, IPPrincipalToken, IPYieldToken) {
-            return (SY.getTokensIn(), SY.getTokensOut());
-        } catch {}
-
-        revert("invalid token");
-    }
-
-    function getUserSYInfo(address sy, address user) external returns (UserSYInfo memory res) {
-        IStandardizedYield SY = IStandardizedYield(sy);
-
-        // SY
-        res.syBalance = TokenAmount(sy, _balanceOf(sy, user));
-
-        // Rewards
-        uint256[] memory rewardsOut = SY.claimRewards(user);
-        address[] memory rewardTokens = SY.getRewardTokens();
-
-        res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
-    }
-
-    function getUserPYInfo(address py, address user) external returns (UserPYInfo memory res) {
-        (address _PT, address _YT) = getPY(py);
-        IPYieldToken YT = IPYieldToken(_YT);
-
-        // PT / YT
-        res.ytBalance = TokenAmount(_YT, _balanceOf(_YT, user));
-        res.ptBalance = TokenAmount(_PT, _balanceOf(_PT, user));
-
-        // interest
-        (uint256 interestOut, uint256[] memory rewardsOut) = YT.redeemDueInterestAndRewards(user, true, true);
-
-        res.unclaimedInterest = TokenAmount(YT.SY(), interestOut);
-
-        // Rewards
-        address[] memory rewardTokens = YT.getRewardTokens();
-        res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
-    }
-
-    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();
-
-        uint256 userLp = _balanceOf(market, user);
-        uint256 userPt = (userLp * uint256(state.totalPt)) / uint256(state.totalLp);
-        uint256 userSy = (userLp * uint256(state.totalSy)) / uint256(state.totalLp);
-
-        res.lpBalance = TokenAmount(market, userLp);
-        res.ptBalance = TokenAmount(address(PT), userPt);
-        res.syBalance = TokenAmount(address(SY), userSy);
-
-        // Rewards
-        uint256[] memory rewardsOut = _market.redeemRewards(user);
-        address[] memory rewardTokens = _market.getRewardTokens();
-
-        res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
-    }
-
-    function _zipTokenAmounts(address[] memory tokens, uint256[] memory amounts)
-        internal
-        pure
-        returns (TokenAmount[] memory res)
-    {
-        res = new TokenAmount[](tokens.length);
-
-        for (uint256 i = 0; i < tokens.length; i++) {
-            res[i] = TokenAmount(tokens[i], amounts[i]);
-        }
-    }
-
-    function _balanceOf(address token, address user) internal view returns (uint256) {
-        return IERC20(token).balanceOf(user);
-    }
-}

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

@@ -1,145 +0,0 @@
-// 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);
-//             }
-//         }
-//     }
-// }