@pendle/core-v2 4.0.6 → 4.1.0

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

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../interfaces/IPRouterStatic.sol";
+import "./StorageLayout.sol";
+
+contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
+    using PMath for uint256;
+
+    function mintPyFromSyStatic(address YT, uint256 netSyToMint) public view returns (uint256 netPYOut) {
+        if (IPYieldToken(YT).isExpired()) revert Errors.YCExpired();
+        return netSyToMint.mulDown(pyIndexCurrentViewYt(YT));
+    }
+
+    function redeemPyToSyStatic(address YT, uint256 netPYToRedeem) public view returns (uint256 netSyOut) {
+        return netPYToRedeem.divDown(pyIndexCurrentViewYt(YT));
+    }
+
+    function mintPyFromTokenStatic(
+        address YT,
+        address tokenIn,
+        uint256 netTokenIn
+    ) external view returns (uint256 netPyOut) {
+        address SY = IPYieldToken(YT).SY();
+        uint256 netSyReceived = mintSyFromTokenStatic(SY, tokenIn, netTokenIn);
+        netPyOut = mintPyFromSyStatic(YT, netSyReceived);
+    }
+
+    function redeemPyToTokenStatic(
+        address YT,
+        uint256 netPYToRedeem,
+        address tokenOut
+    ) external view returns (uint256 netTokenOut) {
+        address SY = IPYieldToken(YT).SY();
+        uint256 netSyReceived = redeemPyToSyStatic(YT, netPYToRedeem);
+        netTokenOut = redeemSyToTokenStatic(SY, tokenOut, netSyReceived);
+    }
+
+    function mintSyFromTokenStatic(
+        address SY,
+        address tokenIn,
+        uint256 netTokenIn
+    ) public view returns (uint256 netSyOut) {
+        return IStandardizedYield(SY).previewDeposit(tokenIn, netTokenIn);
+    }
+
+    function redeemSyToTokenStatic(
+        address SY,
+        address tokenOut,
+        uint256 netSyIn
+    ) public view returns (uint256 netTokenOut) {
+        return IStandardizedYield(SY).previewRedeem(tokenOut, netSyIn);
+    }
+
+    function getAmountTokenToMintSy(
+        address SY,
+        address tokenIn,
+        uint256 netSyOut
+    ) external view returns (uint256 netTokenIn) {
+        uint256 pivotAmount;
+
+        if (tokenIn == address(0)) pivotAmount = 1e18;
+        else pivotAmount = 10 ** IStandardizedYield(SY).decimals();
+
+        uint256 low = pivotAmount;
+        {
+            while (true) {
+                uint256 lowSyOut = mintSyFromTokenStatic(SY, tokenIn, low);
+                if (lowSyOut >= netSyOut) low /= 10;
+                else break;
+            }
+        }
+
+        uint256 high = pivotAmount;
+        {
+            while (true) {
+                uint256 highSyOut = mintSyFromTokenStatic(SY, tokenIn, high);
+                if (highSyOut < netSyOut) high *= 10;
+                else break;
+            }
+        }
+
+        while (low <= high) {
+            uint256 mid = (low + high) / 2;
+            uint256 syOut = mintSyFromTokenStatic(SY, tokenIn, mid);
+
+            if (syOut >= netSyOut) {
+                netTokenIn = mid;
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        assert(netTokenIn > 0);
+    }
+
+    function pyIndexCurrentViewMarket(address market) public view returns (uint256) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        return pyIndexCurrentViewYt(address(YT));
+    }
+
+    function pyIndexCurrentViewYt(address yt) public view returns (uint256) {
+        IPYieldToken YT = IPYieldToken(yt);
+        IStandardizedYield SY = IStandardizedYield(YT.SY());
+
+        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/base/ActionStorageStatic.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./StorageLayout.sol";
+import "../../../interfaces/IPActionStorageStatic.sol";
+import "../../../interfaces/IPMiniDiamond.sol";
+
+contract ActionStorageStatic is StorageLayout, IPActionStorageStatic, IPMiniDiamond {
+    function setDefaultApproxParams(ApproxParams memory params) external onlyOwner {
+        defaultApproxParams = params;
+    }
+
+    function getDefaultApproxParams() external view returns (ApproxParams memory) {
+        return defaultApproxParams;
+    }
+
+    function getOwnerAndPendingOwner() external view returns (address _owner, address _pendingOwner) {
+        _owner = owner;
+        _pendingOwner = pendingOwner;
+    }
+
+    function setFacetForSelectors(SelectorsToFacet[] calldata arr) external onlyOwner {
+        for (uint256 i = 0; i < arr.length; ) {
+            SelectorsToFacet memory s = arr[i];
+            for (uint256 j = 0; j < s.selectors.length; ) {
+                selectorToFacet[s.selectors[j]] = s.facet;
+                unchecked {
+                    j++;
+                }
+            }
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function facetAddress(bytes4 selector) external view returns (address res) {
+        res = selectorToFacet[selector];
+        require(res != address(0), "selector not found");
+    }
+
+    // Ownable
+    function transferOwnership(address newOwner, bool direct, bool renounce) external onlyOwner {
+        if (direct) {
+            require(newOwner != address(0) || renounce, "Ownable: zero address");
+
+            emit OwnershipTransferred(owner, newOwner);
+            owner = newOwner;
+            pendingOwner = address(0);
+        } else {
+            pendingOwner = newOwner;
+        }
+    }
+
+    function claimOwnership() external {
+        address _pendingOwner = pendingOwner;
+
+        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
+
+        emit OwnershipTransferred(owner, _pendingOwner);
+        owner = _pendingOwner;
+        pendingOwner = address(0);
+    }
+}

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

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../core/libraries/MiniHelpers.sol";
+import "../../../interfaces/IPRouterStatic.sol";
+import "../../../interfaces/IPVotingEscrowMainchain.sol";
+import "../../../LiquidityMining/libraries/VeBalanceLib.sol";
+
+contract ActionVePendleStatic is IPActionVePendleStatic {
+    using VeBalanceLib for VeBalance;
+    using VeBalanceLib for LockedPosition;
+
+    uint128 private constant MAX_LOCK_TIME = 104 weeks;
+    uint128 private constant MIN_LOCK_TIME = 1 weeks;
+
+    IPVotingEscrowMainchain private immutable vePENDLE;
+
+    constructor(IPVotingEscrowMainchain _vePENDLE) {
+        vePENDLE = _vePENDLE;
+    }
+
+    function increaseLockPositionStatic(
+        address user,
+        uint128 additionalAmountToLock,
+        uint128 newExpiry
+    ) external view returns (uint128 newVeBalance) {
+        if (!WeekMath.isValidWTime(newExpiry)) revert Errors.InvalidWTime(newExpiry);
+        if (MiniHelpers.isTimeInThePast(newExpiry)) revert Errors.ExpiryInThePast(newExpiry);
+
+        if (newExpiry > block.timestamp + MAX_LOCK_TIME) revert Errors.VEExceededMaxLockTime();
+        if (newExpiry < block.timestamp + MIN_LOCK_TIME) revert Errors.VEInsufficientLockTime();
+
+        LockedPosition memory oldPosition;
+
+        {
+            (uint128 amount, uint128 expiry) = vePENDLE.positionData(user);
+            oldPosition = LockedPosition(amount, expiry);
+        }
+
+        if (newExpiry < oldPosition.expiry) revert Errors.VENotAllowedReduceExpiry();
+
+        uint128 newTotalAmountLocked = additionalAmountToLock + oldPosition.amount;
+        if (newTotalAmountLocked == 0) revert Errors.VEZeroAmountLocked();
+
+        uint128 additionalDurationToLock = newExpiry - oldPosition.expiry;
+
+        LockedPosition memory newPosition = LockedPosition(
+            oldPosition.amount + additionalAmountToLock,
+            oldPosition.expiry + additionalDurationToLock
+        );
+
+        VeBalance memory newBalance = newPosition.convertToVeBalance();
+        return newBalance.getCurrentValue();
+    }
+}

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

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../router/base/MarketApproxLib.sol";
+
+abstract contract StorageLayout {
+    address internal owner;
+    address internal pendingOwner;
+
+    mapping(bytes4 => address) internal selectorToFacet;
+
+    ApproxParams internal defaultApproxParams;
+
+    address internal _deprecated_bulkSellerFactory;
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Ownable: caller is not the owner");
+        _;
+    }
+}

package/contracts/oracles/PendleRedStoneRateOracle.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../core/libraries/math/PMath.sol";
+import "../interfaces/IPExchangeRateOracle.sol";
+import {AggregatorV3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+contract PendleRedStoneRateOracle is IPExchangeRateOracle {
+    using PMath for int256;
+
+    address public immutable oracle;
+    uint8 public immutable decimals;
+
+    constructor(address _redStoneOracle, uint8 _decimals) {
+        oracle = _redStoneOracle;
+        decimals = _decimals;
+    }
+
+    function getExchangeRate() external view returns (uint256) {
+        (, int256 answer, , , ) = IChainlinkAggregator(oracle).latestRoundData();
+        return (answer.Uint() * 10 ** decimals) / 10 ** IChainlinkAggregator(oracle).decimals();
+    }
+}

package/deployments/1-markets/EZETH-JUNE2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY ezETH",
+    "SY": "0x22E12A50e3ca49FB183074235cB1db84Fe4C716D",
+    "YT": "0x256Fb830945141f7927785c06b65dAbc3744213c",
+    "PT": "0xeEE8aED1957ca1545a0508AfB51b53cCA7e3c0d1",
+    "market": "0xDe715330043799D7a80249660d1e6b61eB3713B3",
+    "expiry": 1714003200,
+    "scalarRoot": "11664642502000000000",
+    "initAnchor": "1056877081000000000",
+    "lnFeeRateRoot": "999500333000000"
+}

package/deployments/1-markets/RSETH-KELP-JUNE2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY Kelp DAO rsETH",
+    "SY": "0x730A5E2AcEbccAA5e9095723B3CB862739DA793c",
+    "YT": "0x0ED3A1D45DfdCf85BCc6C7BAFDC0170A357B974C",
+    "PT": "0xB05cABCd99cf9a73b19805edefC5f67CA5d1895E",
+    "market": "0x4f43c77872Db6BA177c270986CD30c3381AF37Ee",
+    "expiry": 1719446400,
+    "scalarRoot": "11473762817000000000",
+    "initAnchor": "1090881589000000000",
+    "lnFeeRateRoot": "999500333000000"
+}

package/deployments/42161-markets/RSETH-APR2024-ARBITRUM.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY rsETH",
+    "SY": "0xf176fB51F4eB826136a54FDc71C50fCd2202E272",
+    "YT": "0x28DF0f193D8e45073BC1db6F2347812C031bA818",
+    "PT": "0x8D164E0C662C9E199baaC9E97b6A8664c75700EA",
+    "market": "0x6F02C88650837C8dfe89F66723c4743E9cF833cd",
+    "expiry": 1714003200,
+    "scalarRoot": "13486943734000000000",
+    "initAnchor": "1050863540000000000",
+    "lnFeeRateRoot": "999500333000000"
+}

package/deployments/42161-markets/WEETH-APR2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY weETH",
+    "SY": "0xa6C895EB332E91c5b3D00B7baeEAae478cc502DA",
+    "YT": "0xF28Db483773E3616DA91FDfa7b5D4090Ac40cC59",
+    "PT": "0x9bEcd6b4Fb076348A455518aea23d3799361FE95",
+    "market": "0xE11f9786B06438456b044B3E21712228ADcAA0D1",
+    "expiry": 1714003200,
+    "scalarRoot": "13422165649000000000",
+    "initAnchor": "1056001760000000000",
+    "lnFeeRateRoot": "999500333000000"
+}