@pendle/core-v2 0.11.10-testnet → 0.12.0-testnet

package/contracts/interfaces/IBoringOwnableUpgradeable.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.15;
+
+interface IBoringOwnableUpgradeable {
+    function transferOwnership(
+        address newOwner,
+        bool direct,
+        bool renounce
+    ) external;
+}

package/contracts/interfaces/IPActionAddRemoveLiq.sol

@@ -103,7 +103,7 @@ interface IPActionAddRemoveLiq {
         external
         returns (
             uint256 netLpOut,
-            uint256 scyUsed,
+            uint256 netScyUsed,
             uint256 netPtUsed
         );
 
@@ -129,7 +129,7 @@ interface IPActionAddRemoveLiq {
         uint256 netPtIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtSwapToScy
-    ) external returns (uint256 netLpOut);
+    ) external returns (uint256 netLpOut, uint256 netScyFee);
 
     function addLiquiditySingleScy(
         address receiver,
@@ -137,7 +137,7 @@ interface IPActionAddRemoveLiq {
         uint256 netScyIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromScy
-    ) external returns (uint256 netLpOut);
+    ) external returns (uint256 netLpOut, uint256 netScyFee);
 
     function addLiquiditySingleToken(
         address receiver,
@@ -145,7 +145,7 @@ interface IPActionAddRemoveLiq {
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromScy,
         TokenInput calldata input
-    ) external payable returns (uint256 netLpOut);
+    ) external payable returns (uint256 netLpOut, uint256 netScyFee);
 
     function removeLiquidityDualScyAndPt(
         address receiver,
@@ -170,19 +170,19 @@ interface IPActionAddRemoveLiq {
         uint256 netLpToRemove,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut
-    ) external returns (uint256 netPtOut);
+    ) external returns (uint256 netPtOut, uint256 netScyFee);
 
     function removeLiquiditySingleScy(
         address receiver,
         address market,
         uint256 netLpToRemove,
         uint256 minScyOut
-    ) external returns (uint256 netScyOut);
+    ) external returns (uint256 netScyOut, uint256 netScyFee);
 
     function removeLiquiditySingleToken(
         address receiver,
         address market,
         uint256 netLpToRemove,
         TokenOutput calldata output
-    ) external returns (uint256 netTokenOut);
+    ) external returns (uint256 netTokenOut, uint256 netScyFee);
 }

package/contracts/interfaces/IPActionMintRedeem.sol

@@ -147,6 +147,7 @@ interface IPActionMintRedeem {
         bytes[] kybercalls;
         //
         address outputToken;
+        uint256 minTokenOut;
     }
 
     function redeemDueInterestAndRewardsThenSwapAll(

package/contracts/interfaces/IPActionSwapPT.sol

@@ -27,7 +27,7 @@ interface IPActionSwapPT {
         address market,
         uint256 exactPtIn,
         uint256 minScyOut
-    ) external returns (uint256 netScyOut);
+    ) external returns (uint256 netScyOut, uint256 netScyFee);
 
     function swapPtForExactScy(
         address receiver,
@@ -35,14 +35,14 @@ interface IPActionSwapPT {
         uint256 exactScyOut,
         uint256 maxPtIn,
         ApproxParams calldata guessPtIn
-    ) external returns (uint256 netPtIn);
+    ) external returns (uint256 netPtIn, uint256 netScyFee);
 
     function swapScyForExactPt(
         address receiver,
         address market,
         uint256 exactPtOut,
         uint256 maxScyIn
-    ) external returns (uint256 netScyIn);
+    ) external returns (uint256 netScyIn, uint256 netScyFee);
 
     function swapExactScyForPt(
         address receiver,
@@ -50,7 +50,7 @@ interface IPActionSwapPT {
         uint256 exactScyIn,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut
-    ) external returns (uint256 netPtOut);
+    ) external returns (uint256 netPtOut, uint256 netScyFee);
 
     function swapExactTokenForPt(
         address receiver,
@@ -58,12 +58,12 @@ interface IPActionSwapPT {
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netPtOut);
+    ) external payable returns (uint256 netPtOut, uint256 netScyFee);
 
     function swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
         TokenOutput calldata output
-    ) external returns (uint256 netTokenOut);
+    ) external returns (uint256 netTokenOut, uint256 netScyFee);
 }

package/contracts/interfaces/IPActionSwapPTYT.sol

@@ -19,7 +19,7 @@ interface IPActionSwapPTYT {
         uint256 exactPtIn,
         uint256 minYtOut,
         ApproxParams calldata guessTotalPtToSwap
-    ) external returns (uint256 netYtOut);
+    ) external returns (uint256 netYtOut, uint256 netScyFee);
 
     function swapExactYtForPt(
         address receiver,
@@ -27,5 +27,5 @@ interface IPActionSwapPTYT {
         uint256 exactYtIn,
         uint256 minPtOut,
         ApproxParams calldata guessTotalPtSwapped
-    ) external returns (uint256 netPtOut);
+    ) external returns (uint256 netPtOut, uint256 netScyFee);
 }

package/contracts/interfaces/IPActionSwapYT.sol

@@ -22,27 +22,27 @@ interface IPActionSwapYT {
         int256 netTokenToAccount
     );
 
+    function swapExactScyForYt(
+        address receiver,
+        address market,
+        uint256 exactScyIn,
+        uint256 minYtOut,
+        ApproxParams memory guessYtOut
+    ) external returns (uint256 netYtOut, uint256 netScyFee);
+
     function swapExactYtForScy(
         address receiver,
         address market,
         uint256 exactYtIn,
         uint256 minScyOut
-    ) external returns (uint256 netScyOut);
+    ) external returns (uint256 netScyOut, uint256 netScyFee);
 
     function swapScyForExactYt(
         address receiver,
         address market,
         uint256 exactYtOut,
         uint256 maxScyIn
-    ) external returns (uint256 netScyIn);
-
-    function swapExactScyForYt(
-        address receiver,
-        address market,
-        uint256 exactScyIn,
-        uint256 minYtOut,
-        ApproxParams memory guessYtOut
-    ) external returns (uint256 netYtOut);
+    ) external returns (uint256 netScyIn, uint256 netScyFee);
 
     function swapYtForExactScy(
         address receiver,
@@ -50,7 +50,7 @@ interface IPActionSwapYT {
         uint256 exactScyOut,
         uint256 maxYtIn,
         ApproxParams memory guessYtIn
-    ) external returns (uint256 netYtIn);
+    ) external returns (uint256 netYtIn, uint256 netScyFee);
 
     function swapExactTokenForYt(
         address receiver,
@@ -58,12 +58,12 @@ interface IPActionSwapYT {
         uint256 minYtOut,
         ApproxParams memory guessYtOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netYtOut);
+    ) external payable returns (uint256 netYtOut, uint256 netScyFee);
 
     function swapExactYtForToken(
         address receiver,
         address market,
         uint256 netYtIn,
         TokenOutput calldata output
-    ) external returns (uint256 netTokenOut);
+    ) external returns (uint256 netTokenOut, uint256 netScyFee);
 }

package/contracts/interfaces/IPFeeDistributor.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface IPFeeDistributor {
+    event Fund(uint256 indexed epoch, uint256 incentive);
+
+    event ClaimReward(
+        address indexed user,
+        address indexed rewardToken,
+        uint256 lastEpochClaimed,
+        uint256 totalReward
+    );
+
+    function fund(uint256[] calldata rewardsForEpoch) external;
+
+    function claimReward(address user) external returns (uint256 amountRewardOut);
+
+    function incentivesForEpoch(uint256 epoch) external returns (uint256);
+}

package/contracts/interfaces/IPFeeDistributorFactory.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface IPFeeDistributorFactory {
+    function lastFinishedEpoch() external returns (uint256);
+
+    function updateUserShare(address user, address pool) external;
+
+    function getUserAndTotalSharesAt(
+        address user,
+        address pool,
+        uint256 epoch
+    ) external view returns (uint256 userShare, uint256 totalShare);
+}

package/contracts/interfaces/IPMarket.sol

@@ -91,4 +91,6 @@ interface IPMarket is IERC20Metadata, IPGauge {
     function getRewardTokens() external view returns (address[] memory);
 
     function isExpired() external view returns (bool);
+
+    function expiry() external view returns (uint256);
 }

package/contracts/interfaces/IPMsgReceiverApp.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity >=0.8.0;
+
+interface IPMsgReceiverApp {
+    function executeMessage(bytes calldata message) external payable;
+}

package/contracts/interfaces/IPMsgSendEndpoint.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity >=0.8.0;
+
+interface IPMsgSendEndpoint {
+    function calcFee(
+        address dstAddress,
+        uint256 dstChainId,
+        bytes calldata message
+    ) external view returns (uint256);
+
+    function sendMessage(
+        address dstAddress,
+        uint256 dstChainId,
+        bytes calldata message
+    ) external payable;
+}

package/contracts/interfaces/IPVotingController.sol

@@ -1,6 +1,7 @@
 pragma solidity 0.8.15;
 
 import "../libraries/VeBalanceLib.sol";
+import "../libraries/VeHistoryLib.sol";
 
 interface IPVotingController {
     event AddPool(uint64 indexed chainId, address indexed pool);
@@ -16,4 +17,25 @@ interface IPVotingController {
         uint128 indexed wTime,
         uint128 totalPendlePerSec
     );
+
+    function applyPoolSlopeChanges(address pool) external;
+
+    function getUserPoolHistoryLength(address user, address pool) external view returns (uint256);
+
+    function getUserPoolHistoryAt(
+        address user,
+        address pool,
+        uint256 index
+    ) external view returns (Checkpoint memory);
+
+    function getWeekData(uint128 wTime, address[] calldata pools)
+        external
+        view
+        returns (
+            bool isEpochFinalized,
+            uint128 totalVotes,
+            uint128[] memory poolVotes
+        );
+
+    function getPoolTotalVoteAt(address pool, uint128 wTime) external view returns (uint128);
 }

package/contracts/interfaces/{IPVotingEscrow.sol → IPVotingEscrowMainchain.sol}

@@ -4,8 +4,9 @@ pragma solidity 0.8.15;
 
 import "./IPVeToken.sol";
 import "../libraries/VeBalanceLib.sol";
+import "../libraries/VeHistoryLib.sol";
 
-interface IPVotingEscrow is IPVeToken {
+interface IPVotingEscrowMainchain is IPVeToken {
     event NewLockPosition(address indexed user, uint128 amount, uint128 expiry);
 
     event Withdraw(address indexed user, uint128 amount);
@@ -21,4 +22,13 @@ interface IPVotingEscrow is IPVeToken {
         returns (uint128);
 
     function withdraw() external returns (uint128);
+
+    function totalSupplyAt(uint128 timestamp) external view returns (uint128);
+
+    function getUserHistoryLength(address user) external view returns (uint256);
+
+    function getUserHistoryAt(address user, uint256 index)
+        external
+        view
+        returns (Checkpoint memory);
 }

package/contracts/interfaces/ISuperComposableYield.sol

@@ -87,13 +87,8 @@ interface ISuperComposableYield is IERC20Metadata {
         address receiver,
         uint256 amountSharesToRedeem,
         address tokenOut,
-        uint256 minTokenOut
-    ) external returns (uint256 amountTokenOut);
-
-    function redeemAfterTransfer(
-        address receiver,
-        address tokenOut,
-        uint256 minTokenOut
+        uint256 minTokenOut,
+        bool burnFromInternalBalance
     ) external returns (uint256 amountTokenOut);
 
     /**

package/contracts/libraries/Errors.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+/// Adapted from UniswapV3's Oracle
+
+library Errors {
+    // MARKET + MARKET MATH CORE
+    error MarketExpired();
+    error MarketZeroAmountsInput();
+    error MarketZeroAmountsOutput();
+    error MarketZeroLnImpliedRate();
+    error MarketInsufficientPtForTrade(int256 currentAmount, int256 requiredAmount);
+    error MarketInsufficientPtReceived(uint256 actualBalance, uint256 requiredBalance);
+    error MarketInsufficientScyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error MarketZeroTotalPtOrTotalAsset(int256 totalPt, int256 totalAsset);
+    error MarketExchangeRateBelowOne(int256 exchangeRate);
+    error MarketProportionMustNotEqualOne();
+    error MarketRateScalarBelowZero(int256 rateScalar);
+    error MarketScalarRootBelowZero(int256 scalarRoot);
+    error MarketProportionTooHigh(int256 proportion, int256 maxProportion);
+
+    error OracleUninitialized();
+    error OracleTargetTooOld(uint32 target, uint32 oldest);
+    error OracleZeroCardinality();
+
+    error MarketFactoryExpiredPt();
+    error MarketFactoryInvalidPt();
+    error MarketFactoryMarketExists();
+
+    error MFactoryLnFeeRateRootTooHigh(uint88 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
+    error MFactoryReserveFeePercentTooHigh(uint8 reserveFeePercent, uint8 maxReserveFeePercent);
+
+    // ROUTER
+    error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
+    error RouterInsufficientScyOut(uint256 actualScyOut, uint256 requiredScyOut);
+    error RouterInsufficientPtOut(uint256 actualPtOut, uint256 requiredPtOut);
+    error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
+    error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
+    error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error RouterExceededLimitScyIn(uint256 actualScyIn, uint256 limitScyIn);
+    error RouterExceededLimitPtIn(uint256 actualPtIn, uint256 limitPtIn);
+    error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
+    error RouterInsufficientScyRepay(uint256 actualScyRepay, uint256 requiredScyRepay);
+    error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
+
+    error RouterTimeRangeZero();
+    error RouterCallbackNotPendleMarket(address caller);
+    error RouterInvalidAction(bytes4 selector);
+
+    // YIELD CONTRACT
+    error YCExpired();
+    error YCNotExpired();
+    error YieldContractInsufficientScy(uint256 actualScy, uint256 requiredScy);
+    error YCNothingToRedeem();
+    error YCPostExpiryDataNotSet();
+    error YCNoFloatingScy();
+
+    // YieldFactory
+    error YCFactoryInvalidExpiry();
+    error YCFactoryYieldContractExisted();
+
+    // SCY
+    error SCYInvalidTokenIn(address token);
+    error SCYInvalidTokenOut(address token);
+    error SCYZeroDeposit();
+    error SCYZeroRedeem();
+    error SCYInsufficientSharesOut(uint256 actualSharesOut, uint256 requiredSharesOut);
+    error SCYInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+
+    // SCY-specific
+    error SCYQiTokenMintFailed(uint256 errCode);
+    error SCYQiTokenRedeemFailed(uint256 errCode);
+    error SCYQiTokenRedeemRewardsFailed(uint256 rewardAccuredType0, uint256 rewardAccuredType1);
+    error SCYQiTokenBorrowRateTooHigh(uint256 borrowRate, uint256 borrowRateMax);
+
+    error SCYCurveInvalidPid();
+    error SCYCurve3crvPoolNotFound();
+
+    // Liquidity Mining
+    error VCInactivePool(address pool);
+    error VCPoolAlreadyActive(address pool);
+    error VCZeroVePendle(address user);
+    error VCExceededMaxWeight(uint256 totalWeight, uint256 maxWeight);
+    error VCEpochNotFinalized(uint256 wTime);
+    error VCPoolAlreadyAddAndRemoved(address pool);
+
+    error VEInvalidNewExpiry(uint256 newExpiry);
+    error VEExceededMaxLockTime();
+    error VEInsufficientLockTime();
+    error VENotAllowedReduceExpiry();
+    error VEZeroAmountLocked();
+    error VEPositionNotExpired();
+    error VEZeroPosition();
+    error VEZeroSlope(uint128 bias, uint128 slope);
+
+    error GCNotPendleMarket(address caller);
+    error GCNotVotingController(address caller);
+
+    error InvalidWTime(uint256 wTime);
+    error ExpiryInThePast(uint256 expiry);
+    error ChainNotSupported(uint256 chainId);
+
+    error FDCantFundFutureEpoch();
+    error FDFactoryDistributorAlreadyExisted(address pool, address distributor);
+
+    // Cross-Chain
+    error MsgNotFromSendEndpoint(address sender);
+    error MsgNotFromReceiveEndpoint(address sender);
+    error InsufficientFeeToSendMsg(uint256 currentFee, uint256 requiredFee);
+
+    // GENERIC MSG
+    error ArrayLengthMismatch();
+    error ArrayEmpty();
+    error ArrayOutOfBounds();
+    error ZeroAddress();
+
+    error OnlyCelerBus();
+    error OnlyYT();
+    error OnlyYCFactory();
+    error OnlyWhitelisted();
+}

package/contracts/libraries/OracleLib.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
+import "./Errors.sol";
+
 /// Adapted from UniswapV3's Oracle
 
 library OracleLib {
@@ -67,7 +69,7 @@ library OracleLib {
         uint16 current,
         uint16 next
     ) public returns (uint16) {
-        require(current != 0, "uninitialized");
+        if (current == 0) revert Errors.OracleUninitialized();
         // no-op if the passed next value isn't greater than the current next value
         if (next <= current) return current;
         // store in each slot to prevent fresh SSTOREs in swaps
@@ -139,7 +141,8 @@ library OracleLib {
         if (!beforeOrAt.initialized) beforeOrAt = self[0];
 
         // ensure that the target is chronologically at or after the oldest observation
-        require(beforeOrAt.blockTimestamp <= target, "target too old for observation");
+        if (target < beforeOrAt.blockTimestamp)
+            revert Errors.OracleTargetTooOld(target, beforeOrAt.blockTimestamp);
 
         // if we've reached this point, we have to binary search
         return binarySearch(self, target, index, cardinality);
@@ -197,7 +200,7 @@ library OracleLib {
         uint16 index,
         uint16 cardinality
     ) public view returns (uint216[] memory lnImpliedRateCumulative) {
-        require(cardinality != 0, "cardinality must be positive");
+        if (cardinality == 0) revert Errors.OracleZeroCardinality();
 
         lnImpliedRateCumulative = new uint216[](secondsAgos.length);
         for (uint256 i = 0; i < lnImpliedRateCumulative.length; ++i) {

package/contracts/libraries/VeBalanceLib.sol

@@ -2,6 +2,7 @@
 pragma solidity 0.8.15;
 
 import "./math/Math.sol";
+import "./Errors.sol";
 
 struct VeBalance {
     uint128 bias;
@@ -55,11 +56,14 @@ library VeBalanceLib {
     }
 
     function getValueAt(VeBalance memory a, uint128 t) internal pure returns (uint128) {
+        if (a.slope * t > a.bias) {
+            return 0;
+        }
         return a.bias - a.slope * t;
     }
 
     function getExpiry(VeBalance memory a) internal pure returns (uint128) {
-        require(a.slope != 0, "zero slope");
+        if (a.slope == 0) revert Errors.VEZeroSlope(a.bias, a.slope);
         return a.bias / a.slope;
     }
 

package/contracts/libraries/VeHistoryLib.sol

@@ -4,42 +4,31 @@ pragma solidity ^0.8.0;
 
 import "./math/Math.sol";
 import "./VeBalanceLib.sol";
+import "./math/WeekMath.sol";
 
-library Checkpoints {
-    struct Checkpoint {
-        uint32 _timestamp;
-        VeBalance _value;
+struct Checkpoint {
+    uint128 timestamp;
+    VeBalance value;
+}
+
+library CheckpointHelper {
+    function assignWith(Checkpoint memory a, Checkpoint memory b) internal pure {
+        a.timestamp = b.timestamp;
+        a.value = b.value;
     }
+}
 
+library Checkpoints {
     struct History {
         Checkpoint[] _checkpoints;
     }
 
-    /**
-     * @dev Returns the value at a given block number. If a checkpoint is not available at that block, the closest one
-     * before it is returned, or zero otherwise.
-     */
-    function getAtTimestamp(History storage self, uint256 timestamp)
-        internal
-        view
-        returns (uint128)
-    {
-        require(timestamp < block.timestamp, "Checkpoints: block not yet mined");
+    function length(History storage self) internal view returns (uint256) {
+        return self._checkpoints.length;
+    }
 
-        uint256 high = self._checkpoints.length;
-        uint256 low = 0;
-        while (low < high) {
-            uint256 mid = (low + high) / 2;
-            if (self._checkpoints[mid]._timestamp > timestamp) {
-                high = mid;
-            } else {
-                low = mid + 1;
-            }
-        }
-        return
-            high == 0
-                ? 0
-                : VeBalanceLib.getValueAt(self._checkpoints[high - 1]._value, uint128(timestamp));
+    function get(History storage self, uint256 index) internal view returns (Checkpoint memory) {
+        return self._checkpoints[index];
     }
 
     /**
@@ -49,11 +38,11 @@ library Checkpoints {
      */
     function push(History storage self, VeBalance memory value) internal {
         uint256 pos = self._checkpoints.length;
-        if (pos > 0 && self._checkpoints[pos - 1]._timestamp == block.timestamp) {
-            self._checkpoints[pos - 1]._value = value;
+        if (pos > 0 && self._checkpoints[pos - 1].timestamp == WeekMath.getCurrentWeekStart()) {
+            self._checkpoints[pos - 1].value = value;
         } else {
             self._checkpoints.push(
-                Checkpoint({ _timestamp: uint32(block.timestamp), _value: value })
+                Checkpoint({ timestamp: WeekMath.getCurrentWeekStart(), value: value })
             );
         }
     }

package/contracts/libraries/helpers/ArrayLib.sol

@@ -39,21 +39,4 @@ library ArrayLib {
         }
         out[length] = element;
     }
-
-    function sub(uint256[] memory a, uint256[] memory b)
-        internal
-        pure
-        returns (uint256[] memory res)
-    {
-        uint256 length = a.length;
-        require(length == b.length, "length mismatch");
-        res = new uint256[](length);
-
-        for (uint256 i = 0; i < length; ) {
-            res[i] = a[i] - b[i];
-            unchecked {
-                i++;
-            }
-        }
-    }
 }