@pendle/core-v2 0.9.4-beta → 0.10.2-testnet

package/contracts/interfaces/IPActionAddRemoveLiq.sol

@@ -0,0 +1,188 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../libraries/math/MarketApproxLib.sol";
+import "../libraries/kyberswap/KyberSwapHelper.sol";
+
+interface IPActionAddRemoveLiq {
+    event AddLiquidityDualScyAndPt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netScyUsed,
+        uint256 netPtUsed,
+        uint256 netLpOut
+    );
+
+    event AddLiquidityDualTokenAndPt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        address tokenIn,
+        uint256 tokenUsed,
+        uint256 netPtUsed,
+        uint256 netLpOut
+    );
+
+    event AddLiquiditySinglePt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netPtIn,
+        uint256 netLpOut
+    );
+
+    event AddLiquiditySingleScy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netScyIn,
+        uint256 netLpOut
+    );
+
+    event AddLiquiditySingleToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netTokenIn,
+        uint256 netLpOut
+    );
+
+    event RemoveLiquidityDualScyAndPt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpToRemove,
+        uint256 netPtOut,
+        uint256 netScyOut
+    );
+
+    event RemoveLiquidityDualTokenAndPt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpToRemove,
+        uint256 netPtOut,
+        address tokenOut,
+        uint256 netTokenOut
+    );
+
+    event RemoveLiquiditySinglePt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpToRemove,
+        uint256 netPtOut
+    );
+
+    event RemoveLiquiditySingleScy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpToRemove,
+        uint256 netScyOut
+    );
+
+    event RemoveLiquiditySingleToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpToRemove,
+        uint256 netTokenOut
+    );
+
+    function addLiquidityDualScyAndPt(
+        address receiver,
+        address market,
+        uint256 netScyDesired,
+        uint256 netPtDesired,
+        uint256 minLpOut
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 scyUsed,
+            uint256 netPtUsed
+        );
+
+    function addLiquidityDualTokenAndPt(
+        address receiver,
+        address market,
+        address tokenIn,
+        uint256 netTokenDesired,
+        uint256 netPtDesired,
+        uint256 minLpOut
+    )
+        external
+        payable
+        returns (
+            uint256 netLpOut,
+            uint256 netTokenUsed,
+            uint256 netPtUsed
+        );
+
+    function addLiquiditySinglePt(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtSwapToScy
+    ) external returns (uint256 netLpOut);
+
+    function addLiquiditySingleScy(
+        address receiver,
+        address market,
+        uint256 netScyIn,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtReceivedFromScy
+    ) external returns (uint256 netLpOut);
+
+    function addLiquiditySingleToken(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtReceivedFromScy,
+        TokenInput calldata input
+    ) external payable returns (uint256 netLpOut);
+
+    function removeLiquidityDualScyAndPt(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        uint256 minScyOut,
+        uint256 minPtOut
+    ) external returns (uint256 netScyOut, uint256 netPtOut);
+
+    function removeLiquidityDualTokenAndPt(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        address tokenOut,
+        uint256 minTokenOut,
+        uint256 minPtOut
+    ) external returns (uint256 netTokenOut, uint256 netPtOut);
+
+    function removeLiquiditySinglePt(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut
+    ) external returns (uint256 netPtOut);
+
+    function removeLiquiditySingleScy(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        uint256 minScyOut
+    ) external returns (uint256 netScyOut);
+
+    function removeLiquiditySingleToken(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut);
+}

package/contracts/interfaces/IPActionMintRedeem.sol

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../libraries/math/MarketApproxLib.sol";
+import "../libraries/kyberswap/KyberSwapHelper.sol";
+
+interface IPActionMintRedeem {
+    event MintScyFromToken(
+        address indexed caller,
+        address indexed receiver,
+        address indexed SCY,
+        address tokenIn,
+        uint256 netTokenIn,
+        uint256 netScyOut
+    );
+
+    event RedeemScyToToken(
+        address indexed caller,
+        address indexed receiver,
+        address indexed SCY,
+        uint256 netScyIn,
+        address tokenOut,
+        uint256 netTokenOut
+    );
+
+    event MintPyFromScy(
+        address indexed caller,
+        address indexed receiver,
+        address indexed YT,
+        uint256 netScyIn,
+        uint256 netPyOut
+    );
+
+    event RedeemPyToScy(
+        address indexed caller,
+        address indexed receiver,
+        address indexed YT,
+        uint256 netPyIn,
+        uint256 netScyOut
+    );
+
+    event MintPyFromToken(
+        address indexed caller,
+        address indexed receiver,
+        address indexed YT,
+        address tokenIn,
+        uint256 netTokenIn,
+        uint256 netPyOut
+    );
+
+    event RedeemPyToToken(
+        address indexed caller,
+        address indexed receiver,
+        address indexed YT,
+        uint256 netPyIn,
+        address tokenOut,
+        uint256 netTokenOut
+    );
+
+    function mintScyFromToken(
+        address receiver,
+        address SCY,
+        uint256 minScyOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netScyOut);
+
+    function redeemScyToToken(
+        address receiver,
+        address SCY,
+        uint256 netScyIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut);
+
+    function mintPyFromToken(
+        address receiver,
+        address YT,
+        uint256 minPyOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPyOut);
+
+    function redeemPyToToken(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut);
+
+    function mintPyFromScy(
+        address receiver,
+        address YT,
+        uint256 netScyIn,
+        uint256 minPyOut
+    ) external returns (uint256 netPyOut);
+
+    function redeemPyToScy(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        uint256 minScyOut
+    ) external returns (uint256 netScyOut);
+
+    function redeemDueInterestAndRewards(
+        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/IPActionMisc.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface IPActionMisc {
+    function consult(address market, uint32 secondsAgo)
+        external
+        view
+        returns (uint96 lnImpliedRateMean);
+}

package/contracts/interfaces/IPActionSwapPT.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../libraries/math/MarketApproxLib.sol";
+import "../libraries/kyberswap/KyberSwapHelper.sol";
+
+interface IPActionSwapPT {
+    event SwapPtAndScy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        int256 netPtToAccount,
+        int256 netScyToAccount
+    );
+
+    event SwapPtAndToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        int256 netPtToAccount,
+        int256 netTokenToAccount
+    );
+
+    function swapExactPtForScy(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minScyOut
+    ) external returns (uint256 netScyOut);
+
+    function swapPtForExactScy(
+        address receiver,
+        address market,
+        uint256 exactScyOut,
+        uint256 maxPtIn,
+        ApproxParams calldata guessPtIn
+    ) external returns (uint256 netPtIn);
+
+    function swapScyForExactPt(
+        address receiver,
+        address market,
+        uint256 exactPtOut,
+        uint256 maxScyIn
+    ) external returns (uint256 netScyIn);
+
+    function swapExactScyForPt(
+        address receiver,
+        address market,
+        uint256 exactScyIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut
+    ) external returns (uint256 netPtOut);
+
+    function swapExactTokenForPt(
+        address receiver,
+        address market,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPtOut);
+
+    function swapExactPtForToken(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut);
+}

package/contracts/interfaces/{IPActionYT.sol → IPActionSwapYT.sol}

@@ -4,20 +4,22 @@ pragma solidity 0.8.15;
 import "../libraries/math/MarketApproxLib.sol";
 import "../libraries/kyberswap/KyberSwapHelper.sol";
 
-interface IPActionYT {
-    event SwapYTAndSCY(
-        address indexed user,
+interface IPActionSwapYT {
+    event SwapYtAndScy(
+        address indexed caller,
         address indexed market,
-        int256 ytToAccount,
-        int256 scyToAccount
+        address indexed receiver,
+        int256 netYtToAccount,
+        int256 netScyToAccount
     );
 
-    event SwapYTAndToken(
-        address indexed user,
+    event SwapYtAndToken(
+        address indexed caller,
         address indexed market,
         address indexed token,
-        int256 ytToAccount,
-        int256 tokenToAccount
+        address receiver,
+        int256 netYtToAccount,
+        int256 netTokenToAccount
     );
 
     function swapExactYtForScy(
@@ -56,7 +58,7 @@ interface IPActionYT {
         uint256 minYtOut,
         ApproxParams memory guessYtOut,
         TokenInput calldata input
-    ) external returns (uint256 netYtOut);
+    ) external payable returns (uint256 netYtOut);
 
     function swapExactYtForToken(
         address receiver,

package/contracts/interfaces/IPAllAction.sol

@@ -2,7 +2,16 @@
 
 pragma solidity 0.8.15;
 
-import "./IPActionCore.sol";
-import "./IPActionYT.sol";
+import "./IPActionAddRemoveLiq.sol";
+import "./IPActionSwapPT.sol";
+import "./IPActionSwapYT.sol";
+import "./IPActionMintRedeem.sol";
+import "./IPActionMisc.sol";
 
-interface IPAllAction is IPActionCore, IPActionYT {}
+interface IPAllAction is
+    IPActionAddRemoveLiq,
+    IPActionSwapPT,
+    IPActionSwapYT,
+    IPActionMintRedeem,
+    IPActionMisc
+{}

package/contracts/interfaces/IPGauge.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface IPGauge {
+    function totalActiveSupply() external view returns (uint256);
+}

package/contracts/interfaces/IPGaugeController.sol

@@ -23,6 +23,4 @@ interface IPGaugeController {
             uint128,
             uint128
         );
-
-
 }

package/contracts/interfaces/IPMarket.sol

@@ -6,32 +6,43 @@ import "./IPPrincipalToken.sol";
 import "./IPYieldToken.sol";
 import "./ISuperComposableYield.sol";
 import "../libraries/math/MarketMathCore.sol";
+import "./IPGauge.sol";
 
-interface IPMarket is IERC20Metadata {
-    event Mint(address indexed receiver, uint256 lpMinted, uint256 scyUsed, uint256 ptUsed);
+interface IPMarket is IERC20Metadata, IPGauge {
+    event Mint(
+        address indexed receiver,
+        uint256 netLpMinted,
+        uint256 netScyUsed,
+        uint256 netPtUsed
+    );
 
     event Burn(
         address indexed receiverScy,
         address indexed receiverPt,
-        uint256 lpBurned,
-        uint256 scyToAccount,
-        uint256 ptToAccount
+        uint256 netLpBurned,
+        uint256 netScyOut,
+        uint256 netPtOut
     );
 
     event Swap(
         address indexed receiver,
-        int256 ptToAccount,
-        int256 scyToAccount,
+        int256 netPtOut,
+        int256 netScyOut,
         uint256 netScyToReserve
     );
 
     event UpdateImpliedRate(uint256 indexed timestamp, uint256 lnLastImpliedRate);
 
-    function mint(address receiver) external returns (uint256);
+    event IncreaseObservationCardinalityNext(
+        uint16 observationCardinalityNextOld,
+        uint16 observationCardinalityNextNew
+    );
+
+    function mint(address receiver) external returns (uint256 netLpOut);
 
     function burn(address receiverScy, address receiverPt)
         external
-        returns (uint256 scyToAccount, uint256 ptToAccount);
+        returns (uint256 netScyOut, uint256 netPtOut);
 
     function swapExactPtForScy(
         address receiver,
@@ -47,7 +58,14 @@ interface IPMarket is IERC20Metadata {
 
     function redeemRewards(address user) external returns (uint256[] memory);
 
-    function readState(bool updateRateOracle) external view returns (MarketState memory market);
+    function readState() external view returns (MarketState memory market);
+
+    function observe(uint32[] memory secondsAgos)
+        external
+        view
+        returns (uint216[] memory lnImpliedRateCumulative);
+
+    function increaseObservationsCardinalityNext(uint16 cardinalityNext) external;
 
     function readTokens()
         external

package/contracts/interfaces/IPMarketFactory.sol

@@ -2,12 +2,7 @@
 pragma solidity 0.8.15;
 
 interface IPMarketFactory {
-    event NewMarketConfig(
-        address indexed treasury,
-        uint96 lnFeeRateRoot,
-        uint32 rateOracleTimeWindow,
-        uint8 reserveFeePercent
-    );
+    event NewMarketConfig(address indexed treasury, uint96 lnFeeRateRoot, uint8 reserveFeePercent);
 
     event CreateNewMarket(
         address indexed market,
@@ -27,7 +22,6 @@ interface IPMarketFactory {
         returns (
             address treasury,
             uint96 lnFeeRateRoot,
-            uint32 rateOracleTimeWindow,
             uint8 reserveFeePercent
         );
 }

package/contracts/interfaces/IPVeToken.sol

@@ -15,5 +15,5 @@ interface IPVeToken {
 
     function totalSupplyCurrent() external returns (uint128);
 
-    function totalSupplyAndBlanaceCurrent(address user) external returns (uint128, uint128);
+    function totalSupplyAndBalanceCurrent(address user) external returns (uint128, uint128);
 }

package/contracts/interfaces/IPVotingController.sol

@@ -7,8 +7,6 @@ interface IPVotingController {
 
     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);

package/contracts/interfaces/IRewardManager.sol

@@ -5,5 +5,5 @@ interface IRewardManager {
     function userReward(address token, address user)
         external
         view
-        returns (uint128 index, uint128 accured);
+        returns (uint128 index, uint128 accrued);
 }