@pendle/core-v2 1.1.0-mainnet → 1.1.0-testnet

package/contracts/interfaces/IPActionSwapYT.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.17;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/kyberswap/KyberSwapHelper.sol";
+import "../router/base/ActionBaseMintRedeem.sol";
 
 interface IPActionSwapYT {
     event SwapYtAndSy(
@@ -22,12 +22,20 @@ interface IPActionSwapYT {
         int256 netTokenToAccount
     );
 
+    event SwapPtAndYt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        int256 netPtToAccount,
+        int256 netYtToAccount
+    );
+
     function swapExactSyForYt(
         address receiver,
         address market,
         uint256 exactSyIn,
         uint256 minYtOut,
-        ApproxParams memory guessYtOut
+        ApproxParams calldata guessYtOut
     ) external returns (uint256 netYtOut, uint256 netSyFee);
 
     function swapExactYtForSy(
@@ -49,14 +57,14 @@ interface IPActionSwapYT {
         address market,
         uint256 exactSyOut,
         uint256 maxYtIn,
-        ApproxParams memory guessYtIn
+        ApproxParams calldata guessYtIn
     ) external returns (uint256 netYtIn, uint256 netSyFee);
 
     function swapExactTokenForYt(
         address receiver,
         address market,
         uint256 minYtOut,
-        ApproxParams memory guessYtOut,
+        ApproxParams calldata guessYtOut,
         TokenInput calldata input
     ) external payable returns (uint256 netYtOut, uint256 netSyFee);
 
@@ -66,4 +74,20 @@ interface IPActionSwapYT {
         uint256 netYtIn,
         TokenOutput calldata output
     ) external returns (uint256 netTokenOut, uint256 netSyFee);
+
+    function swapExactPtForYt(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minYtOut,
+        ApproxParams calldata guessTotalPtToSwap
+    ) external returns (uint256 netYtOut, uint256 netSyFee);
+
+    function swapExactYtForPt(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessTotalPtSwapped
+    ) external returns (uint256 netPtOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPAllAction.sol

@@ -5,15 +5,17 @@ pragma solidity 0.8.17;
 import "./IPActionAddRemoveLiq.sol";
 import "./IPActionSwapPT.sol";
 import "./IPActionSwapYT.sol";
-import "./IPActionSwapPTYT.sol";
 import "./IPActionMintRedeem.sol";
 import "./IPActionMisc.sol";
+import "./IPMarketSwapCallback.sol";
+import "./IDiamondLoupe.sol";
 
 interface IPAllAction is
     IPActionAddRemoveLiq,
     IPActionSwapPT,
     IPActionSwapYT,
-    IPActionSwapPTYT,
     IPActionMintRedeem,
-    IPActionMisc
+    IPActionMisc,
+    IPMarketSwapCallback,
+    IDiamondLoupe
 {}

package/contracts/interfaces/IPFeeDistributor.sol

@@ -2,18 +2,20 @@
 pragma solidity 0.8.17;
 
 interface IPFeeDistributor {
-    event Fund(uint256 indexed epoch, uint256 incentive);
+    event UpdateFee(address indexed pool, uint256 indexed wTime, uint256 amount);
 
-    event ClaimReward(
-        address indexed user,
-        address indexed rewardToken,
-        uint256 lastEpochClaimed,
-        uint256 totalReward
-    );
+    event ClaimReward(address indexed pool, address indexed user, uint256 wTime, uint256 amount);
 
-    function fund(uint256[] calldata rewardsForEpoch) external;
+    event PoolAdded(address indexed pool, uint256 indexed startWeek);
 
-    function claimReward(address user) external returns (uint256 amountRewardOut);
+    struct UserInfo {
+        uint128 firstUnclaimedWeek;
+        uint128 iter;
+    }
 
-    function incentivesForEpoch(uint256 epoch) external returns (uint256);
+    function claimReward(address user, address[] calldata pools)
+        external
+        returns (uint256[] memory amountRewardOut);
+
+    function getAllPools() external view returns (address[] memory);
 }

package/contracts/interfaces/IPInterestManagerYTV2.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPInterestManagerYTV2 {
+    function userInterest(address user)
+        external
+        view
+        returns (
+            uint128 lastInterestIndex,
+            uint128 accruedInterest,
+            uint256 lastPYIndex
+        );
+}

package/contracts/interfaces/IPYieldTokenV2.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "./IRewardManager.sol";
+import "./IPInterestManagerYTV2.sol";
+
+interface IPYieldTokenV2 is IERC20Metadata, IRewardManager, IPInterestManagerYTV2 {
+    event Mint(
+        address indexed caller,
+        address indexed receiverPT,
+        address indexed receiverYT,
+        uint256 amountSyToMint,
+        uint256 amountPYOut
+    );
+
+    event Burn(
+        address indexed caller,
+        address indexed receiver,
+        uint256 amountPYToRedeem,
+        uint256 amountSyOut
+    );
+
+    event RedeemRewards(address indexed user, uint256[] amountRewardsOut);
+
+    event RedeemInterest(address indexed user, uint256 interestOut);
+
+    event WithdrawFeeToTreasury(uint256[] amountRewardsOut, uint256 syOut);
+
+    event CollectInterestFee(uint256 amountInterestFee);
+
+    event CollectRewardFee(address indexed rewardToken, uint256 amountRewardFee);
+
+    function mintPY(address receiverPT, address receiverYT) external returns (uint256 amountPYOut);
+
+    function redeemPY(address receiver) external returns (uint256 amountSyOut);
+
+    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
+        external
+        returns (uint256[] memory amountSyOuts);
+
+    function redeemDueInterestAndRewards(
+        address user,
+        bool redeemInterest,
+        bool redeemRewards
+    ) external returns (uint256 interestOut, uint256[] memory rewardsOut);
+
+    function rewardIndexesCurrent() external returns (uint256[] memory);
+
+    function pyIndexCurrent() external returns (uint256);
+
+    function pyIndexStored() external view returns (uint256);
+
+    function getRewardTokens() external view returns (address[] memory);
+
+    function SY() external view returns (address);
+
+    function PT() external view returns (address);
+
+    function factory() external view returns (address);
+
+    function expiry() external view returns (uint256);
+
+    function isExpired() external view returns (bool);
+
+    function doCacheIndexSameBlock() external view returns (bool);
+}

package/contracts/offchain-helpers/MarketMathStatic.sol

@@ -118,6 +118,21 @@ library MarketMathStatic {
         exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
     }
 
+    function addLiquiditySingleSyKeepYtStatic(address market, uint256 netSyIn)
+        public
+        returns (uint256 netLpOut, uint256 netYtOut)
+    {
+        MarketState memory state = IPMarket(market).readState(address(this));
+        PYIndex index = pyIndex(market);
+
+        uint256 netSyToPt = (netSyIn * state.totalPt.Uint()) /
+            (state.totalPt.Uint() + index.syToAsset(state.totalSy.Uint()));
+
+        netYtOut = index.syToAsset(netSyToPt);
+
+        (, netLpOut, , ) = state.addLiquidity(netSyIn - netSyToPt, netYtOut, block.timestamp);
+    }
+
     function removeLiquidityDualSyAndPtStatic(address market, uint256 netLpToRemove)
         external
         view

package/contracts/offchain-helpers/Multicall2.sol

@@ -0,0 +1,103 @@
+pragma solidity >=0.5.0;
+pragma experimental ABIEncoderV2;
+
+/// @title Multicall2 - Aggregate results from multiple read-only function calls
+/// @author Michael Elliot <mike@makerdao.com>
+/// @author Joshua Levine <joshua@makerdao.com>
+/// @author Nick Johnson <arachnid@notdot.net>
+
+contract Multicall2 {
+    struct Call {
+        address target;
+        bytes callData;
+    }
+    struct Result {
+        bool success;
+        bytes 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++) {
+            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
+            require(success, "Multicall aggregate: call failed");
+            returnData[i] = ret;
+        }
+    }
+
+    function blockAndAggregate(Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
+    }
+
+    function getBlockHash(uint256 blockNumber) public view returns (bytes32 blockHash) {
+        blockHash = blockhash(blockNumber);
+    }
+
+    function getBlockNumber() public view returns (uint256 blockNumber) {
+        blockNumber = block.number;
+    }
+
+    function getCurrentBlockCoinbase() public view returns (address coinbase) {
+        coinbase = block.coinbase;
+    }
+
+    function getCurrentBlockDifficulty() public view returns (uint256 difficulty) {
+        difficulty = block.difficulty;
+    }
+
+    function getCurrentBlockGasLimit() public view returns (uint256 gaslimit) {
+        gaslimit = block.gaslimit;
+    }
+
+    function getCurrentBlockTimestamp() public view returns (uint256 timestamp) {
+        timestamp = block.timestamp;
+    }
+
+    function getEthBalance(address addr) public view returns (uint256 balance) {
+        balance = addr.balance;
+    }
+
+    function getLastBlockHash() public view returns (bytes32 blockHash) {
+        blockHash = blockhash(block.number - 1);
+    }
+
+    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);
+
+            if (requireSuccess) {
+                require(success, "Multicall2 aggregate: call failed");
+            }
+
+            returnData[i] = Result(success, ret);
+        }
+    }
+
+    function tryBlockAndAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        blockNumber = block.number;
+        blockHash = blockhash(block.number);
+        returnData = tryAggregate(requireSuccess, calls);
+    }
+}

package/contracts/offchain-helpers/PendleMulticall.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+/// @title PendleMulticall - A more gas-efficient version of Multicall3 (~700 gas saved for each call)
+/// @author UncleGrandpa925 <longvh@pendle.finance>
+contract PendleMulticall {
+    error MulticallFailed(uint256 index);
+
+    struct Call {
+        address target;
+        bytes callData;
+    }
+
+    function aggregate(Call[] calldata calls) external payable {
+        uint256 length = calls.length;
+        Call calldata call;
+        for (uint256 i = 0; i < length; ) {
+            call = calls[i];
+            (bool success, ) = call.target.call(call.callData);
+            if (!success) revert MulticallFailed(i);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+}

package/contracts/offchain-helpers/RouterStatic.sol

@@ -368,6 +368,28 @@ contract RouterStatic is Initializable, Proxy, BoringOwnableUpgradeable, UUPSUpg
         return MarketMathStatic.addLiquiditySingleSyStatic(market, netSyIn);
     }
 
+    function addLiquiditySingleSyKeepYtStatic(address market, uint256 netSyIn)
+        external
+        returns (uint256 netLpOut, uint256 netYtOut)
+    {
+        return MarketMathStatic.addLiquiditySingleSyKeepYtStatic(market, netSyIn);
+    }
+
+    function addLiquiditySingleTokenKeepYtStatic(
+        address market,
+        address baseToken,
+        uint256 netBaseTokenIn,
+        address bulk
+    ) external returns (uint256 netLpOut, uint256 netYtOut) {
+        uint256 netSyIn = previewDepositStatic(
+            getSyMarket(market),
+            baseToken,
+            netBaseTokenIn,
+            bulk
+        );
+        return MarketMathStatic.addLiquiditySingleSyKeepYtStatic(market, netSyIn);
+    }
+
     function removeLiquidityDualSyAndPtStatic(address market, uint256 netLpToRemove)
         external
         view

package/contracts/router/ActionAddRemoveLiq.sol

@@ -21,13 +21,9 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
     using PYIndexLib for IPYieldToken;
+    using PYIndexLib for PYIndex;
     using BulkSellerMathCore for BulkSellerState;
 
-    /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberScalingLib)
-        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
-    {}
-
     /**
      * @notice Adds liquidity to the SY/PT market, granting LP tokens in return
      * @dev Will mint as much LP as possible given no more than `netSyDesired` and `netPtDesired`,
@@ -258,6 +254,78 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         );
     }
 
+    /**
+     * @notice Mints partial SY to PT+YT, returns YT to user, then uses PT+SY to add liquidity
+     * @param netSyIn amount of SY to be transferred in from caller
+     * @return netLpOut actual LP output, will not be lower than `minLpOut`
+     * @return netYtOut actual YT output, will not be lower than `minYtOut`
+     * @dev Reverts if market is expired
+     */
+    function addLiquiditySingleSyKeepYt(
+        address receiver,
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) external returns (uint256 netLpOut, uint256 netYtOut) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        _transferIn(address(SY), msg.sender, netSyIn);
+
+        (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(
+            receiver,
+            market,
+            SY,
+            YT,
+            netSyIn,
+            minLpOut,
+            minYtOut
+        );
+
+        emit AddLiquiditySingleSyKeepYt(msg.sender, market, receiver, netSyIn, netLpOut, netYtOut);
+    }
+
+    /**
+     * @notice Adds liquidity and returns leftover YT using a single token input. The input token
+     * is first swapped through Kyberswap to a SY-mintable token, the rest is the same as
+     * `addLiquiditySingleSyKeepYt()`
+     * @param input data for input token, see {`./kyberswap/KyberSwapHelper.sol`}
+     * @return netLpOut actual LP output, will not be lower than `minLpOut`
+     * @return netYtOut actual YT output, will not be lower than `minYtOut`
+     * @dev Reverts if market is expired
+     */
+    function addLiquiditySingleTokenKeepYt(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input
+    ) external returns (uint256 netLpOut, uint256 netYtOut) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 netSyUsed = _mintSyFromToken(address(this), address(SY), 1, input);
+
+        (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(
+            receiver,
+            market,
+            SY,
+            YT,
+            netSyUsed,
+            minLpOut,
+            minYtOut
+        );
+
+        emit AddLiquiditySingleTokenKeepYt(
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            input.netTokenIn,
+            netLpOut,
+            netYtOut
+        );
+    }
+
     /**
      * @notice Burns LP token to remove SY/PT liquidity
      * @param netLpToRemove amount of LP to be burned from caller
@@ -473,6 +541,48 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
     }
 
+    /**
+     * @dev algorithm:
+        - Split SY into a SY and b SY (with a + b = netSyIn)
+        - Mint PY with a SY ---> gives (a * pyIndex / ONE) PT + YT
+        - Mint LP with (a * pyIndex / ONE) PT and b SY
+
+        -> We want (a * pyIndex / ONE) / totalPt = b / totalSy
+        -> a * (1 + pyIndex * totalSy / ONE / totalPt) = netSyIn
+        -> a = (netSyIn * totalPt) / (totalPt + (pyIndex * totalSy / ONE))
+        -> a = (netSyIn * totalPt) / (totalPt + totalAsset)
+     */
+    function _addLiquiditySingleSyKeepYt(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) internal returns (uint256 netLpOut, uint256 netYtOut) {
+        MarketState memory state = IPMarket(market).readState(address(this));
+
+        PYIndex pyIndex = YT.newIndex();
+
+        uint256 netSyToPt = (netSyIn * state.totalPt.Uint()) /
+            (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
+
+        // transfer SY to mint PY
+        _transferOut(address(SY), address(YT), netSyToPt);
+
+        // the rest of SY goes to market
+        _transferOut(address(SY), market, netSyIn - netSyToPt);
+
+        // PT goes to market, YT goes to receiver
+        netYtOut = YT.mintPY(market, receiver);
+
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyIn - netSyToPt, netYtOut);
+
+        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
+        if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
+    }
+
     /// @dev removes SY/PT liquidity, then converts PT to SY
     function _removeLiquiditySingleSy(
         address receiver,
@@ -497,7 +607,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) internal returns (uint256 netSyOut) {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
         (uint256 syFromBurn, ) = IPMarket(market).burn(receiver, address(YT), netLpToRemove);
-        netSyOut = syFromBurn + IPYieldToken(YT).redeemPY(receiver);
+        netSyOut = syFromBurn + YT.redeemPY(receiver);
     }
 
     /// @dev swaps PT to SY pre-expiry