@pendle/core-v2 0.6.8 → 0.7.0

package/contracts/interfaces/IPActionCore.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 import "../libraries/math/MarketApproxLib.sol";
 
@@ -13,9 +13,9 @@ interface IPActionCore {
     )
         external
         returns (
-            uint256,
-            uint256,
-            uint256
+            uint256 netLpOut,
+            uint256 scyUsed,
+            uint256 ptUsed
         );
 
     function removeLiquidity(
@@ -24,81 +24,98 @@ interface IPActionCore {
         uint256 lpToRemove,
         uint256 scyOutMin,
         uint256 ptOutMin
-    ) external returns (uint256, uint256);
+    ) external returns (uint256 netScyOut, uint256 netPtOut);
 
     function swapExactPtForScy(
         address receiver,
         address market,
         uint256 exactPtIn,
         uint256 minScyOut
-    ) external returns (uint256);
+    ) external returns (uint256 netScyOut);
 
     function swapPtForExactScy(
         address receiver,
         address market,
         uint256 exactScyOut,
-        ApproxParams memory approx
-    ) external returns (uint256);
+        uint256 maxPtIn,
+        ApproxParams memory guessPtIn
+    ) external returns (uint256 netPtIn);
 
     function swapScyForExactPt(
         address receiver,
         address market,
         uint256 exactPtOut,
         uint256 maxScyIn
-    ) external returns (uint256);
+    ) external returns (uint256 netScyIn);
 
     function swapExactScyForPt(
         address receiver,
         address market,
         uint256 exactScyIn,
-        ApproxParams memory approx
-    ) external returns (uint256);
+        uint256 minPtOut,
+        ApproxParams memory guessPtOut
+    ) external returns (uint256 netPtOut);
 
     function mintScyFromRawToken(
-        uint256 netRawTokenIn,
+        address receiver,
         address SCY,
+        uint256 netRawTokenIn,
         uint256 minScyOut,
-        address receiver,
         address[] calldata path
-    ) external returns (uint256);
+    ) external returns (uint256 netScyOut);
 
     function redeemScyToRawToken(
+        address receiver,
         address SCY,
         uint256 netScyIn,
         uint256 minRawTokenOut,
-        address receiver,
         address[] memory path
-    ) external returns (uint256);
+    ) external returns (uint256 netRawTokenOut);
 
     function mintPyFromRawToken(
-        uint256 netRawTokenIn,
+        address receiver,
         address YT,
+        uint256 netRawTokenIn,
         uint256 minPyOut,
-        address receiver,
         address[] calldata path
-    ) external returns (uint256);
+    ) external returns (uint256 netPyOut);
 
     function redeemPyToRawToken(
+        address receiver,
         address YT,
         uint256 netPyIn,
         uint256 minRawTokenOut,
-        address receiver,
         address[] memory path
-    ) external returns (uint256);
+    ) external returns (uint256 netRawTokenOut);
 
     function swapExactRawTokenForPt(
-        uint256 exactRawTokenIn,
         address receiver,
-        address[] calldata path,
         address market,
-        ApproxParams memory approx
+        uint256 exactRawTokenIn,
+        uint256 minPtOut,
+        address[] calldata path,
+        ApproxParams memory guessPtOut
     ) external returns (uint256 netPtOut);
 
     function swapExactPtForRawToken(
-        uint256 exactPtIn,
         address receiver,
-        address[] calldata path,
         address market,
-        uint256 minRawTokenOut
+        uint256 exactPtIn,
+        uint256 minRawTokenOut,
+        address[] calldata path
     ) external returns (uint256 netRawTokenOut);
+
+    function redeemDueIncome(
+        address user,
+        address[] calldata scys,
+        address[] calldata yts,
+        address[] calldata markets
+    )
+        external
+        returns (
+            uint256[][] memory scyRewards,
+            uint256[] memory ytInterests,
+            uint256[][] memory ytRewards,
+            uint256[][] memory marketRewards
+        );
 }

package/contracts/interfaces/IPActionYT.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 import "../libraries/math/MarketApproxLib.sol";
 
@@ -22,29 +22,32 @@ interface IPActionYT {
         address receiver,
         address market,
         uint256 exactScyIn,
-        ApproxParams memory approx
+        uint256 minYtOut,
+        ApproxParams memory guessYtOut
     ) external returns (uint256 netYtOut);
 
     function swapYtForExactScy(
         address receiver,
         address market,
         uint256 exactScyOut,
-        ApproxParams memory approx
+        uint256 maxYtIn,
+        ApproxParams memory guessYtIn
     ) external returns (uint256 netYtIn);
 
     function swapExactRawTokenForYt(
-        uint256 exactRawTokenIn,
         address receiver,
-        address[] calldata path,
         address market,
-        ApproxParams memory approx
+        uint256 exactRawTokenIn,
+        uint256 minYtOut,
+        address[] calldata path,
+        ApproxParams memory guessYtOut
     ) external returns (uint256 netYtOut);
 
     function swapExactYtForRawToken(
-        uint256 exactYtIn,
         address receiver,
-        address[] calldata path,
         address market,
-        uint256 minRawTokenOut
+        uint256 exactYtIn,
+        uint256 minRawTokenOut,
+        address[] calldata path
     ) external returns (uint256 netRawTokenOut);
 }

package/contracts/interfaces/IPAllAction.sol

@@ -1,9 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 import "./IPActionCore.sol";
 import "./IPActionYT.sol";
-import "./IPActionRedeem.sol";
 
-interface IPAllAction is IPActionCore, IPActionYT, IPActionRedeem {}
+interface IPAllAction is IPActionCore, IPActionYT {}

package/contracts/interfaces/IPGaugeController.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+interface IPGaugeController {
+    event MarketClaimReward(address indexed market, uint256 amount);
+
+    event ReceiveVotingResults(uint128 wTime, address[] markets, uint256[] pendleAmounts);
+
+    function pendle() external returns (address);
+
+    function claimMarketReward() external;
+
+    function rewardData(address pool)
+        external
+        view
+        returns (
+            uint128 pendlePerSec,
+            uint128,
+            uint128,
+            uint128
+        );
+}

package/contracts/interfaces/IPGaugeControllerMainchain.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+import "./IPGaugeController.sol";
+
+interface IPGaugeControllerMainchain is IPGaugeController {
+    function updateVotingResults(
+        uint128 wTime,
+        address[] calldata markets,
+        uint256[] calldata pendleSpeeds
+    ) external;
+}

package/contracts/interfaces/IPGovernanceManager.sol

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 interface IPGovernanceManager {
     function governance() external view returns (address);

package/contracts/interfaces/IPInterestManagerYT.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+interface IPInterestManagerYT {
+    function userInterest(address user)
+        external
+        view
+        returns (uint128 lastScyIndex, uint128 accruedInterest);
+}

package/contracts/interfaces/IPMarket.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
-import "./IPBaseToken.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import "./IPPrincipalToken.sol";
 import "./IPYieldToken.sol";
 import "../libraries/math/MarketMathCore.sol";
 
-interface IPMarket is IPBaseToken {
+interface IPMarket is IERC20Metadata {
     event AddLiquidity(
         address indexed receiver,
         uint256 lpToAccount,
@@ -15,7 +15,8 @@ interface IPMarket is IPBaseToken {
     );
 
     event RemoveLiquidity(
-        address indexed receiver,
+        address indexed receiverScy,
+        address indexed receiverPt,
         uint256 lpRemoved,
         uint256 scyToAccount,
         uint256 ptToAccount
@@ -44,7 +45,8 @@ interface IPMarket is IPBaseToken {
         );
 
     function removeLiquidity(
-        address receiver,
+        address receiverScy,
+        address receiverPt,
         uint256 lpToRemove,
         bytes calldata data
     ) external returns (uint256 scyToAccount, uint256 ptToAccount);
@@ -52,24 +54,18 @@ interface IPMarket is IPBaseToken {
     function swapExactPtForScy(
         address receiver,
         uint256 exactPtIn,
-        uint256 minScyOut,
         bytes calldata data
     ) external returns (uint256 netScyOut, uint256 netScyToReserve);
 
     function swapScyForExactPt(
         address receiver,
         uint256 exactPtOut,
-        uint256 maxScyIn,
         bytes calldata data
     ) external returns (uint256 netScyIn, uint256 netScyToReserve);
 
-    function readState(bool updateRateOracle) external view returns (MarketState memory market);
-
-    function PT() external view returns (address);
+    function redeemRewards(address user) external returns (uint256[] memory);
 
-    function YT() external view returns (address);
-
-    function SCY() external view returns (address);
+    function readState(bool updateRateOracle) external view returns (MarketState memory market);
 
     function readTokens()
         external
@@ -79,4 +75,8 @@ interface IPMarket is IPBaseToken {
             IPPrincipalToken _PT,
             IPYieldToken _YT
         );
+
+    function getRewardTokens() external view returns (address[] memory);
+
+    function isExpired() external view returns (bool);
 }

package/contracts/interfaces/IPMarketAddRemoveCallback.sol

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 interface IPMarketAddRemoveCallback {
     function addLiquidityCallback(
         uint256 lpToAccount,
-        uint256 scyOwed,
-        uint256 ptOwed,
+        uint256 scyUsed,
+        uint256 ptUsed,
         bytes calldata data
     ) external;
 

package/contracts/interfaces/IPMarketFactory.sol

@@ -1,7 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 interface IPMarketFactory {
+    event NewMarketConfig(
+        address indexed treasury,
+        uint96 lnFeeRateRoot,
+        uint32 rateOracleTimeWindow,
+        uint8 reserveFeePercent
+    );
+
     event CreateNewMarket(address indexed PT, int256 scalarRoot, int256 initialAnchor);
 
     function isValidMarket(address market) external view returns (bool);

package/contracts/interfaces/IPMarketSwapCallback.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 interface IPMarketSwapCallback {
     function swapCallback(

package/contracts/interfaces/IPPermissionsV2Upg.sol

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 interface IPermissionsV2Upg {
     function governanceManager() external view returns (address);

package/contracts/interfaces/IPPrincipalToken.sol

@@ -1,10 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-import "./IPBaseToken.sol";
-
-interface IPPrincipalToken is IPBaseToken {
-    function initialize(address _YT) external;
+pragma solidity 0.8.13;
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
+interface IPPrincipalToken is IERC20Metadata {
     function burnByYT(address user, uint256 amount) external;
 
     function mintByYT(address user, uint256 amount) external;
@@ -12,4 +10,10 @@ interface IPPrincipalToken is IPBaseToken {
     function SCY() external view returns (address);
 
     function YT() external view returns (address);
+
+    function factory() external view returns (address);
+
+    function expiry() external view returns (uint256);
+
+    function isExpired() external view returns (bool);
 }

package/contracts/interfaces/IPRouterStatic.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 import "../libraries/math/MarketMathCore.sol";
 

package/contracts/interfaces/IPVeToken.sol

@@ -1,14 +1,19 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.9;
-pragma abicoder v2;
+pragma solidity 0.8.13;
 
-interface IVePToken {
+interface IPVeToken {
     // ============= USER INFO =============
 
-    function balanceOf(address user) external view returns (uint256);
+    function balanceOf(address user) external view returns (uint128);
+
+    function positionData(address user) external view returns (uint128 amount, uint128 expiry);
 
     // ============= META DATA =============
 
-    function totalSupply() external view returns (uint256);
+    function totalSupplyStored() external view returns (uint128);
+
+    function totalSupplyCurrent() external returns (uint128);
+
+    function isPositionExpired(address user) external view returns (bool);
 }

package/contracts/interfaces/IPVotingController.sol

@@ -0,0 +1,21 @@
+pragma solidity 0.8.13;
+
+import "../libraries/VeBalanceLib.sol";
+
+interface IPVotingController {
+    event AddPool(uint64 indexed chainId, address indexed pool);
+
+    event RemovePool(uint64 indexed chainId, address indexed pool);
+
+    event Unvote(address indexed user, address indexed pool, VeBalance vote);
+
+    event Vote(address indexed user, address indexed pool, uint64 weight, VeBalance vote);
+
+    event SetPendlePerSec(uint256 newPendlePerSec);
+
+    event BroadcastResults(
+        uint64 indexed chainId,
+        uint128 indexed wTime,
+        uint128 totalPendlePerSec
+    );
+}

package/contracts/interfaces/IPVotingEscrow.sol

@@ -1,32 +1,24 @@
-pragma solidity 0.8.9;
-pragma abicoder v2;
+// SPDX-License-Identifier: GPL-3.0-or-later
 
-import "./IVePToken.sol";
+pragma solidity 0.8.13;
 
-interface IVotingEscrowPendle is IVePToken {
-    // ============= ACTIONS =============
-
-    function lock(uint256 expiry) external returns (uint256);
+import "./IPVeToken.sol";
+import "../libraries/VeBalanceLib.sol";
 
-    function increaseLockAmount(address receiver) external returns (uint256);
+interface IPVotingEscrow {
+    event NewLockPosition(address indexed user, uint128 amount, uint128 expiry);
 
-    function increaseLockDuration(uint256 duration) external returns (uint256);
+    event Withdraw(address indexed user, uint128 amount);
 
-    function withdraw(address user) external returns (uint256);
+    event BroadcastTotalSupply(VeBalance newTotalSupply, uint256[] chainIds);
 
-    /**
-     * @return amount :amount of vePendle voted for pool
-     */
-    function vote(address gauge, uint256 weight) external returns (uint256 amount);
+    event BroadcastUserPosition(address indexed user, uint256[] chainIds);
 
-    // ============= USER INFO =============
+    // ============= ACTIONS =============
 
-    /**
-     * @return lockedAmount amount of PENDLE user locked
-     * @return expiry expiry of users' locked PENDLE
-     */
-    function readUserInfo(address user)
+    function increaseLockPosition(uint128 additionalAmountToLock, uint128 expiry)
         external
-        view
-        returns (uint256 lockedAmount, uint256 expiry);
+        returns (uint128);
+
+    function withdraw(address user) external returns (uint128);
 }

package/contracts/interfaces/IPYieldContractFactory.sol

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 interface IPYieldContractFactory {
     event CreateYieldContract(address indexed SCY, address PT, address YT, uint256 expiry);

package/contracts/interfaces/IPYieldToken.sol

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-import "./IPBaseToken.sol";
-import "../SuperComposableYield/implementations/IRewardManager.sol";
+pragma solidity 0.8.13;
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "./IRewardManager.sol";
+import "./IPInterestManagerYT.sol";
 
-interface IPYieldToken is IPBaseToken, IRewardManager {
-    event RedeemReward(address indexed user, uint256[] amountRewardsOut);
+interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
+    event RedeemRewards(address indexed user, uint256[] amountRewardsOut);
     event RedeemInterest(address indexed user, uint256 interestOut);
 
     event WithdrawFeeToTreasury(uint256[] amountRewardsOut, uint256 scyOut);
@@ -13,7 +14,9 @@ interface IPYieldToken is IPBaseToken, IRewardManager {
 
     function redeemPY(address receiver) external returns (uint256 amountScyOut);
 
-    // minimum of PT & YT balance
+    function redeemPY(address[] memory receivers, uint256[] memory amounts)
+        external
+        returns (uint256 amountScyOut);
 
     function redeemDueInterestAndRewards(address user)
         external
@@ -23,22 +26,19 @@ interface IPYieldToken is IPBaseToken, IRewardManager {
 
     function redeemDueRewards(address user) external returns (uint256[] memory rewardsOut);
 
-    function updateGlobalReward() external;
+    function rewardIndexesCurrent() external returns (uint256[] memory);
 
-    function updateUserReward(address user) external;
+    function getScyIndex() external view returns (uint256 currentIndex);
 
-    function updateUserInterest(address user) external;
+    function getRewardTokens() external view returns (address[] memory);
 
-    function getInterestData(address user)
-        external
-        view
-        returns (uint256 lastScyIndex, uint256 dueInterest);
+    function SCY() external view returns (address);
 
-    function getScyIndex() external returns (uint256 currentIndex, uint256 lastIndexBeforeExpiry);
+    function PT() external view returns (address);
 
-    function withdrawFeeToTreasury() external;
+    function factory() external view returns (address);
 
-    function SCY() external view returns (address);
+    function expiry() external view returns (uint256);
 
-    function PT() external view returns (address);
+    function isExpired() external view returns (bool);
 }

package/contracts/interfaces/IQiAvax.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+
+pragma solidity 0.8.13;
+import "./IQiToken.sol";
+
+interface IQiAvax is IQiToken {
+    function mint() external payable;
+
+    function redeem(uint256 redeemTokens) external returns (uint256);
+}

package/contracts/interfaces/IQiErc20.sol

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 import "./IQiToken.sol";
 
 interface IQiErc20 is IQiToken {

package/contracts/interfaces/IQiToken.sol

@@ -21,9 +21,30 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./IBenQiInterestRateModel.sol";
 
 interface IQiToken is IERC20 {
     function exchangeRateCurrent() external returns (uint256);
+
+    function exchangeRateStored() external view returns (uint256);
+
+    function comptroller() external view returns (address);
+
+    function accrualBlockTimestamp() external view returns (uint256);
+
+    function getCash() external view returns (uint256);
+
+    function totalBorrows() external view returns (uint256);
+
+    function totalReserves() external view returns (uint256);
+
+    function borrowIndex() external view returns (uint256);
+
+    function interestRateModel() external view returns (IBenQiInterestRateModel);
+
+    function totalSupply() external view returns (uint256);
+
+    function reserveFactorMantissa() external view returns (uint256);
 }

package/contracts/interfaces/IREDACTEDStaking.sol

@@ -20,7 +20,7 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 interface IREDACTEDStaking {
     function stake(uint256 _amount, address _receiver) external returns (bool);