@pendle/core-v2 3.0.0-beta-9 → 3.0.0

package/contracts/interfaces/IPActionMintRedeemStatic.sol

@@ -2,34 +2,51 @@
 pragma solidity ^0.8.0;
 
 interface IPActionMintRedeemStatic {
-    function getAmountTokenToMintSy(address SY, address tokenIn, uint256 netSyOut)
-        external
-        view
-        returns (uint256 netTokenIn);
+    function getAmountTokenToMintSy(
+        address SY,
+        address tokenIn,
+        address bulk,
+        uint256 netSyOut
+    ) external view returns (uint256 netTokenIn);
+
+    function getBulkSellerInfo(
+        address token,
+        address SY,
+        uint256 netTokenIn,
+        uint256 netSyIn
+    ) external view returns (address bulk, uint256 totalToken, uint256 totalSy);
 
     function mintPyFromSyStatic(address YT, uint256 netSyToMint) external view returns (uint256 netPYOut);
 
-    function mintPyFromTokenStatic(address YT, address tokenIn, uint256 netTokenIn)
-        external
-        view
-        returns (uint256 netPyOut);
+    function mintPyFromTokenStatic(
+        address YT,
+        address tokenIn,
+        uint256 netTokenIn,
+        address bulk
+    ) external view returns (uint256 netPyOut);
 
-    function mintSyFromTokenStatic(address SY, address tokenIn, uint256 netTokenIn)
-        external
-        view
-        returns (uint256 netSyOut);
+    function mintSyFromTokenStatic(
+        address SY,
+        address tokenIn,
+        uint256 netTokenIn,
+        address bulk
+    ) external view returns (uint256 netSyOut);
 
     function redeemPyToSyStatic(address YT, uint256 netPYToRedeem) external view returns (uint256 netSyOut);
 
-    function redeemPyToTokenStatic(address YT, uint256 netPYToRedeem, address tokenOut)
-        external
-        view
-        returns (uint256 netTokenOut);
-
-    function redeemSyToTokenStatic(address SY, address tokenOut, uint256 netSyIn)
-        external
-        view
-        returns (uint256 netTokenOut);
+    function redeemPyToTokenStatic(
+        address YT,
+        uint256 netPYToRedeem,
+        address tokenOut,
+        address bulk
+    ) external view returns (uint256 netTokenOut);
+
+    function redeemSyToTokenStatic(
+        address SY,
+        address tokenOut,
+        uint256 netSyIn,
+        address bulk
+    ) external view returns (uint256 netTokenOut);
 
     function pyIndexCurrentViewMarket(address market) external view returns (uint256);
 

package/contracts/interfaces/IPActionMisc.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPActionMisc {
+    struct MultiApproval {
+        address[] tokens;
+        address spender;
+    }
+
+    struct Call3 {
+        bool allowFailure;
+        bytes callData;
+    }
+
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    function approveInf(MultiApproval[] calldata) external;
+
+    function batchExec(Call3[] calldata calls) external returns (Result[] memory returnData);
+}

package/contracts/interfaces/IPActionStorageStatic.sol

@@ -1,6 +1,6 @@
 pragma solidity ^0.8.0;
 
-import "./IPAllActionV3.sol";
+import "./IPAllAction.sol";
 
 interface IPActionStorageStatic {
     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
@@ -9,6 +9,10 @@ interface IPActionStorageStatic {
 
     function getDefaultApproxParams() external view returns (ApproxParams memory);
 
+    function setBulkSellerFactory(address _bulkSellerFactory) external;
+
+    function getBulkSellerFactory() external view returns (address);
+
     function getOwnerAndPendingOwner() external view returns (address _owner, address _pendingOwner);
 
     function transferOwnership(address newOwner, bool direct, bool renounce) external;

package/contracts/interfaces/{IPActionSwapPTV3.sol → IPActionSwapPT.sol}

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "./IPAllActionTypeV3.sol";
+import "../router/base/ActionBaseMintRedeem.sol";
 
-interface IPActionSwapPTV3 {
+interface IPActionSwapPT {
     event SwapPtAndSy(
         address indexed caller,
         address indexed market,
@@ -19,41 +19,51 @@ interface IPActionSwapPTV3 {
         address indexed token,
         address receiver,
         int256 netPtToAccount,
-        int256 netTokenToAccount,
-        uint256 netSyInterm
+        int256 netTokenToAccount
     );
 
-    function swapExactTokenForPt(
+    function swapExactPtForSy(
         address receiver,
         address market,
-        uint256 minPtOut,
-        ApproxParams calldata guessPtOut,
-        TokenInput calldata input,
-        LimitOrderData calldata limit
-    ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm);
+        uint256 exactPtIn,
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
+
+    function swapPtForExactSy(
+        address receiver,
+        address market,
+        uint256 exactSyOut,
+        uint256 maxPtIn,
+        ApproxParams calldata guessPtIn
+    ) external returns (uint256 netPtIn, uint256 netSyFee);
+
+    function swapSyForExactPt(
+        address receiver,
+        address market,
+        uint256 exactPtOut,
+        uint256 maxSyIn
+    ) external returns (uint256 netSyIn, uint256 netSyFee);
 
     function swapExactSyForPt(
         address receiver,
         address market,
         uint256 exactSyIn,
         uint256 minPtOut,
-        ApproxParams calldata guessPtOut,
-        LimitOrderData calldata limit
+        ApproxParams calldata guessPtOut
     ) external returns (uint256 netPtOut, uint256 netSyFee);
 
-    function swapExactPtForToken(
+    function swapExactTokenForPt(
         address receiver,
         address market,
-        uint256 exactPtIn,
-        TokenOutput calldata output,
-        LimitOrderData calldata limit
-    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPtOut, uint256 netSyFee);
 
-    function swapExactPtForSy(
+    function swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
-        uint256 minSyOut,
-        LimitOrderData calldata limit
-    ) external returns (uint256 netSyOut, uint256 netSyFee);
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut, uint256 netSyFee);
 }

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

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "./IPAllActionTypeV3.sol";
+import "../router/base/ActionBaseMintRedeem.sol";
 
-interface IPActionSwapYTV3 {
+interface IPActionSwapYT {
     event SwapYtAndSy(
         address indexed caller,
         address indexed market,
@@ -19,8 +19,7 @@ interface IPActionSwapYTV3 {
         address indexed token,
         address receiver,
         int256 netYtToAccount,
-        int256 netTokenToAccount,
-        uint256 netSyInterm
+        int256 netTokenToAccount
     );
 
     event SwapPtAndYt(
@@ -31,39 +30,50 @@ interface IPActionSwapYTV3 {
         int256 netYtToAccount
     );
 
-    function swapExactTokenForYt(
-        address receiver,
-        address market,
-        uint256 minYtOut,
-        ApproxParams calldata guessYtOut,
-        TokenInput calldata input,
-        LimitOrderData calldata limit
-    ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm);
-
     function swapExactSyForYt(
         address receiver,
         address market,
         uint256 exactSyIn,
         uint256 minYtOut,
-        ApproxParams calldata guessYtOut,
-        LimitOrderData calldata limit
+        ApproxParams calldata guessYtOut
     ) external returns (uint256 netYtOut, uint256 netSyFee);
 
-    function swapExactYtForToken(
+    function swapExactYtForSy(
         address receiver,
         address market,
         uint256 exactYtIn,
-        TokenOutput calldata output,
-        LimitOrderData calldata limit
-    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 
-    function swapExactYtForSy(
+    function swapSyForExactYt(
         address receiver,
         address market,
-        uint256 exactYtIn,
-        uint256 minSyOut,
-        LimitOrderData calldata limit
-    ) external returns (uint256 netSyOut, uint256 netSyFee);
+        uint256 exactYtOut,
+        uint256 maxSyIn
+    ) external returns (uint256 netSyIn, uint256 netSyFee);
+
+    function swapYtForExactSy(
+        address receiver,
+        address market,
+        uint256 exactSyOut,
+        uint256 maxYtIn,
+        ApproxParams calldata guessYtIn
+    ) external returns (uint256 netYtIn, uint256 netSyFee);
+
+    function swapExactTokenForYt(
+        address receiver,
+        address market,
+        uint256 minYtOut,
+        ApproxParams calldata guessYtOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netYtOut, uint256 netSyFee);
+
+    function swapExactYtForToken(
+        address receiver,
+        address market,
+        uint256 netYtIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut, uint256 netSyFee);
 
     function swapExactPtForYt(
         address receiver,
@@ -78,6 +88,6 @@ interface IPActionSwapYTV3 {
         address market,
         uint256 exactYtIn,
         uint256 minPtOut,
-        ApproxParams calldata guessTotalPtFromSwap
+        ApproxParams calldata guessTotalPtSwapped
     ) external returns (uint256 netPtOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPAllAction.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import "./IPActionAddRemoveLiq.sol";
+import "./IPActionSwapPT.sol";
+import "./IPActionSwapYT.sol";
+import "./IPActionMintRedeem.sol";
+import "./IPActionMisc.sol";
+import "./IPMarketSwapCallback.sol";
+import "./IDiamondLoupe.sol";
+
+interface IPAllAction is
+    IPActionAddRemoveLiq,
+    IPActionSwapPT,
+    IPActionSwapYT,
+    IPActionMintRedeem,
+    IPActionMisc,
+    IPMarketSwapCallback,
+    IDiamondLoupe
+{}

package/contracts/interfaces/IPBulkSeller.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../core/BulkSeller/BulkSellerMathCore.sol";
+
+interface IPBulkSeller {
+    event SwapExactTokenForSy(address receiver, uint256 netTokenIn, uint256 netSyOut);
+    event SwapExactSyForToken(address receiver, uint256 netSyIn, uint256 netTokenOut);
+    event RateUpdated(
+        uint256 newRateTokenToSy,
+        uint256 newRateSyToToken,
+        uint256 oldRateTokenToSy,
+        uint256 oldRateSyToToken
+    );
+    event ReBalanceTokenToSy(
+        uint256 netTokenDeposit,
+        uint256 netSyFromToken,
+        uint256 newTokenProp,
+        uint256 oldTokenProp
+    );
+    event ReBalanceSyToToken(uint256 netSyRedeem, uint256 netTokenFromSy, uint256 newTokenProp, uint256 oldTokenProp);
+    event ReserveUpdated(uint256 totalToken, uint256 totalSy);
+    event FeeRateUpdated(uint256 newFeeRate, uint256 oldFeeRate);
+
+    function swapExactTokenForSy(
+        address receiver,
+        uint256 netTokenIn,
+        uint256 minSyOut
+    ) external payable returns (uint256 netSyOut);
+
+    function swapExactSyForToken(
+        address receiver,
+        uint256 exactSyIn,
+        uint256 minTokenOut,
+        bool swapFromInternalBalance
+    ) external returns (uint256 netTokenOut);
+
+    function SY() external view returns (address);
+
+    function token() external view returns (address);
+
+    function readState() external view returns (BulkSellerState memory);
+}

package/contracts/interfaces/IPBulkSellerFactory.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPBulkSellerFactory {
+    event BulkSellerCreated(address indexed token, address indexed sy, address indexed bulk);
+
+    event UpgradedBeacon(address indexed implementation);
+
+    function get(address token, address SY) external view returns (address);
+
+    function isMaintainer(address addr) external view returns (bool);
+}

package/contracts/interfaces/IPBulkSellerSYCallback.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPBulkSellerCallback {
+    function swapCallback(int256 ptToAccount, int256 syToAccount, bytes calldata data) external;
+}

package/contracts/interfaces/IPFeeDistributor.sol

@@ -13,9 +13,7 @@ interface IPFeeDistributor {
         uint128 iter;
     }
 
-    function claimReward(address user, address[] calldata pools)
-        external
-        returns (uint256[] memory amountRewardOut);
+    function claimReward(address user, address[] calldata pools) external returns (uint256[] memory amountRewardOut);
 
     function getAllPools() external view returns (address[] memory);
 }

package/contracts/interfaces/IPFeeDistributorV2.sol

@@ -29,18 +29,19 @@ interface IPFeeDistributorV2 {
      * @notice Protocols that require the use of this function & feeData should contact the Pendle team.
      * @notice Protocols should NOT EVER use claimRetail. Using it will make getProtocolFeeData unreliable.
      */
-    function claimProtocol(address receiver, address[] calldata pools)
-        external
-        returns (uint256 totalAmountOut, uint256[] memory amountsOut);
+    function claimProtocol(
+        address receiver,
+        address[] calldata pools
+    ) external returns (uint256 totalAmountOut, uint256[] memory amountsOut);
 
     /**
     * @notice returns the claimable fees per pool. Only available if the Pendle team has specifically
     set up the data
      */
-    function getProtocolClaimables(address user, address[] calldata pools)
-        external
-        view
-        returns (uint256[] memory claimables);
+    function getProtocolClaimables(
+        address user,
+        address[] calldata pools
+    ) external view returns (uint256[] memory claimables);
 
     function getProtocolTotalAccrued(address user) external view returns (uint256);
 }

package/contracts/interfaces/IPGaugeController.sol

@@ -6,11 +6,7 @@ interface IPGaugeController {
 
     event ReceiveVotingResults(uint128 indexed wTime, address[] markets, uint256[] pendleAmounts);
 
-    event UpdateMarketReward(
-        address indexed market,
-        uint256 pendlePerSec,
-        uint256 incentiveEndsAt
-    );
+    event UpdateMarketReward(address indexed market, uint256 pendlePerSec, uint256 incentiveEndsAt);
 
     function fundPendle(uint256 amount) external;
 
@@ -20,7 +16,5 @@ interface IPGaugeController {
 
     function redeemMarketReward() external;
 
-    function rewardData(
-        address pool
-    ) external view returns (uint128 pendlePerSec, uint128, uint128, uint128);
+    function rewardData(address pool) external view returns (uint128 pendlePerSec, uint128, uint128, uint128);
 }

package/contracts/interfaces/IPGaugeControllerMainchain.sol

@@ -4,9 +4,5 @@ pragma solidity ^0.8.0;
 import "./IPGaugeController.sol";
 
 interface IPGaugeControllerMainchain is IPGaugeController {
-    function updateVotingResults(
-        uint128 wTime,
-        address[] calldata markets,
-        uint256[] calldata pendleSpeeds
-    ) external;
+    function updateVotingResults(uint128 wTime, address[] calldata markets, uint256[] calldata pendleSpeeds) external;
 }

package/contracts/interfaces/IPInterestManagerYT.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 interface IPInterestManagerYT {
-    function userInterest(
-        address user
-    ) external view returns (uint128 lastPYIndex, uint128 accruedInterest);
+    event CollectInterestFee(uint256 amountInterestFee);
+
+    function userInterest(address user) external view returns (uint128 lastPYIndex, uint128 accruedInterest);
 }

package/contracts/interfaces/IPInterestManagerYTV2.sol

@@ -4,8 +4,5 @@ pragma solidity ^0.8.0;
 interface IPInterestManagerYTV2 {
     function userInterest(
         address user
-    )
-        external
-        view
-        returns (uint128 lastInterestIndex, uint128 accruedInterest, uint256 lastPYIndex);
+    ) external view returns (uint128 lastInterestIndex, uint128 accruedInterest, uint256 lastPYIndex);
 }

package/contracts/interfaces/IPLinearDistributor.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+interface IPLinearDistributor {
+    event VestQueued(address indexed token, address indexed addr, uint256 amount);
+    event Vested(address indexed token, address indexed addr, uint256 amount, uint256 duration);
+    event Claim(address indexed token, address indexed addr, uint256 amount);
+
+    struct DistributionData {
+        uint128 accruedReward;
+        uint128 unvestedReward;
+        // [irregular uint192] reward tokens might be up to 1e18 decimals, at 1e18 based, the reward per sec might be very close to 1e38 limit of uint128
+        uint192 rewardPerSec;
+        uint32 lastDistributedTime;
+        uint32 endTime;
+    }
+
+    function queueVestAndClaim(address token, uint256 amountToVest) external returns (uint256 amountOut);
+
+    function claim(address token) external returns (uint256 amountOut);
+}

package/contracts/interfaces/IPMarket.sol

@@ -9,12 +9,7 @@ import "./IPGauge.sol";
 import "../core/Market/MarketMathCore.sol";
 
 interface IPMarket is IERC20Metadata, IPGauge {
-    event Mint(
-        address indexed receiver,
-        uint256 netLpMinted,
-        uint256 netSyUsed,
-        uint256 netPtUsed
-    );
+    event Mint(address indexed receiver, uint256 netLpMinted, uint256 netSyUsed, uint256 netPtUsed);
 
     event Burn(
         address indexed receiverSy,
@@ -68,16 +63,11 @@ interface IPMarket is IERC20Metadata, IPGauge {
 
     function readState(address router) external view returns (MarketState memory market);
 
-    function observe(
-        uint32[] memory secondsAgos
-    ) external view returns (uint216[] memory lnImpliedRateCumulative);
+    function observe(uint32[] memory secondsAgos) external view returns (uint216[] memory lnImpliedRateCumulative);
 
     function increaseObservationsCardinalityNext(uint16 cardinalityNext) external;
 
-    function readTokens()
-        external
-        view
-        returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT);
+    function readTokens() external view returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT);
 
     function getRewardTokens() external view returns (address[] memory);
 
@@ -87,10 +77,7 @@ interface IPMarket is IERC20Metadata, IPGauge {
 
     function observations(
         uint256 index
-    )
-        external
-        view
-        returns (uint32 blockTimestamp, uint216 lnImpliedRateCumulative, bool initialized);
+    ) external view returns (uint32 blockTimestamp, uint216 lnImpliedRateCumulative, bool initialized);
 
     function _storage()
         external

package/contracts/interfaces/IPMarketFactory.sol

@@ -8,20 +8,11 @@ interface IPMarketFactory {
         bool active;
     }
 
-    event NewMarketConfig(
-        address indexed treasury,
-        uint80 defaultLnFeeRateRoot,
-        uint8 reserveFeePercent
-    );
+    event NewMarketConfig(address indexed treasury, uint80 defaultLnFeeRateRoot, uint8 reserveFeePercent);
     event SetOverriddenFee(address indexed router, uint80 lnFeeRateRoot, uint8 reserveFeePercent);
     event UnsetOverriddenFee(address indexed router);
 
-    event CreateNewMarket(
-        address indexed market,
-        address indexed PT,
-        int256 scalarRoot,
-        int256 initialAnchor
-    );
+    event CreateNewMarket(address indexed market, address indexed PT, int256 scalarRoot, int256 initialAnchor);
 
     function isValidMarket(address market) external view returns (bool);
 
@@ -29,6 +20,4 @@ interface IPMarketFactory {
     function getMarketConfig(
         address router
     ) external view returns (address treasury, uint80 lnFeeRateRoot, uint8 reserveFeePercent);
-
-
 }

package/contracts/interfaces/IPMarketFactoryV3.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPMarketFactoryV3 {
+    event SetOverriddenFee(address indexed router, address indexed market, uint80 lnFeeRateRoot);
+
+    event CreateNewMarket(
+        address indexed market,
+        address indexed PT,
+        int256 scalarRoot,
+        int256 initialAnchor,
+        uint256 lnFeeRateRoot
+    );
+
+    event NewTreasuryAndFeeReserve(address indexed treasury, uint8 reserveFeePercent);
+
+    function isValidMarket(address market) external view returns (bool);
+
+    // If this is changed, change the readState function in market as well
+    function getMarketConfig(
+        address market,
+        address router
+    ) external view returns (address treasury, uint80 overriddenFee, uint8 reserveFeePercent);
+}

package/contracts/interfaces/IPMarketV3.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./IPMarket.sol";
+
+interface IPMarketV3 is IPMarket {
+    function getNonOverrideLnFeeRateRoot() external view returns (uint80);
+}

package/contracts/interfaces/IPMerkleDistributor.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPMerkleDistributor {
+    event Claimed(address indexed user, address indexed receiver, uint256 amount);
+    event Verified(address indexed user, uint256 amountClaimable);
+    event SetMerkleRoot(bytes32 indexed merkleRoot);
+
+    error InvalidMerkleProof();
+
+    function claim(
+        address receiver,
+        uint256 totalAccrued,
+        bytes32[] calldata proof
+    ) external returns (uint256 amountOut);
+
+    function claimVerified(address receiver) external returns (uint256 amountOut);
+
+    function verify(
+        address user,
+        uint256 totalAccrued,
+        bytes32[] calldata proof
+    ) external returns (uint256 amountVerified);
+}

package/contracts/interfaces/IPOffchainStorage.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface IPOffchainStorage {
+    event SetStorage(bytes32 indexed key, bytes value);
+
+    function setStorageUint256(bytes32 key, uint256 value) external;
+
+    function getUint256(bytes32 key) external view returns (uint256);
+}

package/contracts/interfaces/IPPriceFeed.sol

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