@pendle/core-v2 0.15.2-mainnet → 0.16.0-testnet

package/contracts/core/libraries/Errors.sol

@@ -4,20 +4,6 @@ pragma solidity 0.8.17;
 /// Adapted from UniswapV3's Oracle
 
 library Errors {
-    // BulkSeller
-    error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
-    error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
-    error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
-    error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
-    error BulkInsufficientTokenReceived(uint256 actualBalance, uint256 requiredBalance);
-    error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
-    error BulkNotMaintainer();
-    error BulkNotAdmin();
-    error BulkSellerAlreadyExisted(address token, address SY, address bulk);
-    error BulkSellerInvalidToken(address token, address SY);
-    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
-    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
-
     // APPROX
     error ApproxFail();
     error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
@@ -45,13 +31,8 @@ library Errors {
     error MarketFactoryInvalidPt();
     error MarketFactoryMarketExists();
 
-    error MarketFactoryLnFeeRateRootTooHigh(uint88 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
-    error MarketFactoryReserveFeePercentTooHigh(
-        uint8 reserveFeePercent,
-        uint8 maxReserveFeePercent
-    );
-    error MarketFactoryZeroTreasury();
-    error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
+    error MFactoryLnFeeRateRootTooHigh(uint88 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
+    error MFactoryReserveFeePercentTooHigh(uint8 reserveFeePercent, uint8 maxReserveFeePercent);
 
     // ROUTER
     error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
@@ -65,14 +46,11 @@ library Errors {
     error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
     error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
     error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
-    error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
 
     error RouterTimeRangeZero();
     error RouterCallbackNotPendleMarket(address caller);
     error RouterInvalidAction(bytes4 selector);
 
-    error RouterKyberSwapDataZero();
-
     // YIELD CONTRACT
     error YCExpired();
     error YCNotExpired();
@@ -84,10 +62,6 @@ library Errors {
     // YieldFactory
     error YCFactoryInvalidExpiry();
     error YCFactoryYieldContractExisted();
-    error YCFactoryZeroExpiryDivisor();
-    error YCFactoryZeroTreasury();
-    error YCFactoryInterestFeeRateTooHigh(uint256 interestFeeRate, uint256 maxInterestFeeRate);
-    error YCFactoryRewardFeeRateTooHigh(uint256 newRewardFeeRate, uint256 maxRewardFeeRate);
 
     // SY
     error SYInvalidTokenIn(address token);

package/contracts/core/libraries/TokenHelper.sol

@@ -17,15 +17,6 @@ abstract contract TokenHelper {
         else if (amount != 0) IERC20(token).safeTransferFrom(from, address(this), amount);
     }
 
-    function _transferFrom(
-        IERC20 token,
-        address from,
-        address to,
-        uint256 amount
-    ) internal {
-        if (amount != 0) token.safeTransferFrom(from, to, amount);
-    }
-
     function _transferOut(
         address token,
         address to,

package/contracts/interfaces/ConvexCurve/IBooster.sol

@@ -10,7 +10,7 @@ interface IBooster {
         external
         view
         returns (
-            address lpToken,
+            address,
             address,
             address,
             address,

package/contracts/interfaces/Curve/ICrvPool.sol

@@ -6,12 +6,6 @@ interface ICrvPool {
 
     function get_virtual_price() external view returns (uint256);
 
-    function lp_token() external view returns (address);
-
-    function fee() external view returns (uint256);
-
-    function admin_fee() external view returns (uint256);
-
     function get_dy(
         int128 i,
         int128 j,
@@ -22,31 +16,56 @@ interface ICrvPool {
         int128 i,
         int128 j,
         uint256 dx,
-        uint256 min_dy // The amount of i being exchanged.
+        uint256 min_dy, // The amount of i being exchanged.
+        address _receiver
+    ) external returns (uint256);
+
+    function add_liquidity(
+        uint256[] memory _deposit_amount,
+        uint256 _min_amount,
+        address _receiver
     ) external returns (uint256);
 
     function add_liquidity(
         uint256[2] memory _deposit_amount,
         uint256 _min_amount
-    ) external returns (uint256 lpOut);
+    ) external;
+
+    function add_liquidity(
+        uint256[3] memory _deposit_amount,
+        uint256 _min_amount
+    ) external;
+
+    function remove_liquidity(
+        uint256 _burn_amount,
+        uint256[] memory _min_amounts,
+        address _receiver
+    ) external returns (uint256[] memory);
 
     function remove_liquidity_one_coin(
         uint256 _burn_amount,
         int128 i,
         uint256 _min_amount
-    ) external returns (uint256 tokenOut);
+    ) external;
+
+    function calc_token_amount(uint256[] memory _amounts, bool _is_deposit)
+        external
+        view
+        returns (uint256);
 
     function calc_token_amount(uint256[2] memory _amounts, bool _is_deposit)
         external
         view
         returns (uint256);
 
-    function calc_withdraw_one_coin(uint256 _burn_amount, int128 i)
+    function calc_token_amount(uint256[3] memory _amounts, bool _is_deposit)
         external
         view
         returns (uint256);
 
-    function balances(uint256 i) external view returns (uint256);
 
-    function A_precise() external view returns (uint256);
+    function calc_withdraw_one_coin(uint256 _burn_amount, int128 i)
+        external
+        view
+        returns (uint256);
 }

package/contracts/interfaces/IPActionAddRemoveLiq.sol

@@ -19,7 +19,7 @@ interface IPActionAddRemoveLiq {
         address indexed market,
         address indexed receiver,
         address tokenIn,
-        uint256 netTokenUsed,
+        uint256 tokenUsed,
         uint256 netPtUsed,
         uint256 netLpOut
     );
@@ -110,7 +110,8 @@ interface IPActionAddRemoveLiq {
     function addLiquidityDualTokenAndPt(
         address receiver,
         address market,
-        TokenInput calldata input,
+        address tokenIn,
+        uint256 netTokenDesired,
         uint256 netPtDesired,
         uint256 minLpOut
     )
@@ -158,7 +159,8 @@ interface IPActionAddRemoveLiq {
         address receiver,
         address market,
         uint256 netLpToRemove,
-        TokenOutput calldata output,
+        address tokenOut,
+        uint256 minTokenOut,
         uint256 minPtOut
     ) external returns (uint256 netTokenOut, uint256 netPtOut);
 

package/contracts/interfaces/IPActionMintRedeem.sol

@@ -138,7 +138,6 @@ interface IPActionMintRedeem {
         // key-value pair
         address[] syAddrs;
         address[] tokenRedeemSys;
-        address[] bulks;
         //
     }
 
@@ -147,7 +146,6 @@ interface IPActionMintRedeem {
         address[] tokens;
         bytes[] kybercalls;
         //
-        address kyberRouter;
         address outputToken;
         uint256 minTokenOut;
     }

package/contracts/interfaces/IPMarketFactory.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.17;
 
 interface IPMarketFactory {
-    event NewMarketConfig(address indexed treasury, uint88 lnFeeRateRoot, uint8 reserveFeePercent);
+    event NewMarketConfig(address indexed treasury, uint96 lnFeeRateRoot, uint8 reserveFeePercent);
 
     event CreateNewMarket(
         address indexed market,

package/contracts/interfaces/IPYieldContractFactory.sol

@@ -30,7 +30,7 @@ interface IPYieldContractFactory {
 
     event SetInterestFeeRate(uint256 newInterestFeeRate);
 
-    event SetRewardFeeRate(uint256 newRewardFeeRate);
+    event SetRewardFeeRate(uint256 newInterestFeeRate);
 
     event SetTreasury(address indexed treasury);
 

package/contracts/interfaces/IStETH.sol

@@ -11,10 +11,4 @@ interface IStETH {
     function burnShares(address _account, uint256 _sharesAmount)
         external
         returns (uint256 newTotalShares);
-    
-    function sharesOf(address account) external view returns (uint256);
-
-    function getTotalShares() external view returns (uint256);
-
-    function getTotalPooledEther() external view returns (uint256);
 }

package/contracts/interfaces/IStandardizedYield.sol

@@ -43,7 +43,7 @@ interface IStandardizedYield is IERC20Metadata {
         uint256 amountTokenOut
     );
 
-    /// @dev check `assetInfo()` for more information
+    /// @dev check assetInfo for more information
     enum AssetType {
         TOKEN,
         LIQUIDITY
@@ -74,10 +74,9 @@ interface IStandardizedYield is IERC20Metadata {
     /**
      * @notice redeems an amount of base tokens by burning some shares
      * @param receiver recipient address
-     * @param amountSharesToRedeem amount of shares to be burned
+     * @param amountSharesToRedeem amount of shares to be burned from (`msg.sender`)
      * @param tokenOut address of the base token to be redeemed
      * @param minTokenOut reverts if amount of base token redeemed is lower than this
-     * @param burnFromInternalBalance if true, burns from balance of `address(this)`, otherwise burns from `msg.sender`
      * @return amountTokenOut amount of base tokens redeemed
      * @dev Emits a {Redeem} event
      *
@@ -106,7 +105,7 @@ interface IStandardizedYield is IERC20Metadata {
      * @param user the user receiving their rewards
      * @return rewardAmounts an array of reward amounts in the same order as `getRewardTokens`
      * @dev
-     * Emits a `ClaimRewards` event
+     * Emits a `ClaimRewardss` event
      * See {getRewardTokens} for list of reward tokens
      */
     function claimRewards(address user) external returns (uint256[] memory rewardAmounts);
@@ -132,14 +131,8 @@ interface IStandardizedYield is IERC20Metadata {
      */
     function yieldToken() external view returns (address);
 
-    /**
-     * @notice returns all tokens that can mint this SY
-     */
     function getTokensIn() external view returns (address[] memory res);
 
-    /**
-     * @notice returns all tokens that can be redeemed by this SY
-     */
     function getTokensOut() external view returns (address[] memory res);
 
     function isValidTokenIn(address token) external view returns (bool);
@@ -157,11 +150,13 @@ interface IStandardizedYield is IERC20Metadata {
         returns (uint256 amountTokenOut);
 
     /**
-     * @notice This function contains information to interpret what the asset is
-     * @return assetType the type of the asset (0 for ERC20 tokens, 1 for AMM liquidity tokens)
-     * @return assetAddress the address of the asset
-     * @return assetDecimals the decimals of the asset
-     */
+    * @notice This function contains information to interpret what the asset is
+    * @notice decimals is the decimals to format asset balances
+    * @notice if asset is an ERC20 token, assetType = 0, assetAddress is the address of the token
+    * @notice if asset is liquidity of an AMM (like sqrt(k) in UniswapV2 forks), assetType = 1,
+    assetAddress is the address of the LP token
+    * @notice assetDecimals is the decimals of the asset
+    */
     function assetInfo()
         external
         view

package/contracts/offchain-helpers/ImplicitSwapfeeContract.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../interfaces/IPMarket.sol";
+
+contract ImplicitSwapfeeContract {
+    using Math for int256;
+    using MarketMathCore for MarketState;
+
+    constructor() {}
+
+    function execute(
+        int256 K,
+        address market,
+        MarketState memory prevState,
+        int256 netPtToAccount
+    ) external view returns (int256 netScyToAccount) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        PYIndex index = PYIndex.wrap(YT.pyIndexStored());
+
+        for (int256 i = 0; i < K; ++i) {
+            (int256 scyToAccount, ) = prevState.executeTradeCore(
+                index,
+                netPtToAccount / K,
+                block.timestamp
+            );
+            netScyToAccount += scyToAccount;
+        }
+    }
+}

package/contracts/offchain-helpers/MarketMathStatic.sol

@@ -35,6 +35,35 @@ library MarketMathStatic {
         );
     }
 
+    function addLiquidityDualTokenAndPtStatic(
+        address market,
+        address tokenIn,
+        uint256 netTokenDesired,
+        uint256 netPtDesired
+    )
+        external
+        view
+        returns (
+            uint256 netLpOut,
+            uint256 netTokenUsed,
+            uint256 netPtUsed
+        )
+    {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+
+        uint256 syDesired = SY.previewDeposit(tokenIn, netTokenDesired);
+        uint256 syUsed;
+
+        MarketState memory state = IPMarket(market).readState();
+        (, netLpOut, syUsed, netPtUsed) = state.addLiquidity(
+            syDesired,
+            netPtDesired,
+            block.timestamp
+        );
+
+        netTokenUsed = (netTokenDesired * syUsed).rawDivUp(syDesired);
+    }
+
     /// @dev netPtToSwap is the parameter to approx
     function addLiquiditySinglePtStatic(
         address market,
@@ -111,6 +140,31 @@ library MarketMathStatic {
         priceImpact = calcPriceImpact(market, netPtFromSwap.Int());
     }
 
+    /// @dev netPtFromSwap is the parameter to approx
+    function addLiquiditySingleBaseTokenStatic(
+        address market,
+        address baseToken,
+        uint256 netBaseTokenIn,
+        ApproxParams memory approxParams
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netPtFromSwap,
+            uint256 netSyFee,
+            uint256 priceImpact
+        )
+    {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+
+        return
+            addLiquiditySingleSyStatic(
+                market,
+                SY.previewDeposit(baseToken, netBaseTokenIn),
+                approxParams
+            );
+    }
+
     function removeLiquidityDualSyAndPtStatic(address market, uint256 netLpToRemove)
         external
         view
@@ -120,6 +174,20 @@ library MarketMathStatic {
         (netSyOut, netPtOut) = state.removeLiquidity(netLpToRemove);
     }
 
+    function removeLiquidityDualTokenAndPtStatic(
+        address market,
+        uint256 metLpToRemove,
+        address tokenOut
+    ) external view returns (uint256 netTokenOut, uint256 netPtOut) {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+
+        uint256 netSyOut;
+        MarketState memory state = IPMarket(market).readState();
+        (netSyOut, netPtOut) = state.removeLiquidity(metLpToRemove);
+
+        netTokenOut = SY.previewRedeem(tokenOut, netSyOut);
+    }
+
     /// @dev netPtFromSwap is the parameter to approx
     function removeLiquiditySinglePtStatic(
         address market,
@@ -175,6 +243,25 @@ library MarketMathStatic {
         }
     }
 
+    function removeLiquiditySingleBaseTokenStatic(
+        address market,
+        uint256 netLpToRemove,
+        address baseToken
+    )
+        external
+        returns (
+            uint256 netBaseTokenOut,
+            uint256 netSyFee,
+            uint256 priceImpact
+        )
+    {
+        uint256 netSyOut;
+        (netSyOut, netSyFee, priceImpact) = removeLiquiditySingleSyStatic(market, netLpToRemove);
+
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+        netBaseTokenOut = SY.previewRedeem(baseToken, netSyOut);
+    }
+
     function swapExactPtForSyStatic(address market, uint256 exactPtIn)
         public
         returns (
@@ -248,6 +335,49 @@ library MarketMathStatic {
         priceImpact = calcPriceImpact(market, netPtIn.neg());
     }
 
+    /// @dev netPtOut is the parameter to approx
+    function swapExactBaseTokenForPtStatic(
+        address market,
+        address baseToken,
+        uint256 amountBaseToken,
+        ApproxParams memory approxParams
+    )
+        external
+        returns (
+            uint256 netPtOut,
+            uint256 netSyFee,
+            uint256 priceImpact
+        )
+    {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+
+        return
+            swapExactSyForPtStatic(
+                market,
+                SY.previewDeposit(baseToken, amountBaseToken),
+                approxParams
+            );
+    }
+
+    function swapExactPtForBaseTokenStatic(
+        address market,
+        uint256 exactPtIn,
+        address baseToken
+    )
+        external
+        returns (
+            uint256 netBaseTokenOut,
+            uint256 netSyFee,
+            uint256 priceImpact
+        )
+    {
+        uint256 netSyOut;
+        (netSyOut, netSyFee, priceImpact) = swapExactPtForSyStatic(market, exactPtIn);
+
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+        netBaseTokenOut = SY.previewRedeem(baseToken, netSyOut);
+    }
+
     function swapSyForExactYtStatic(address market, uint256 exactYtOut)
         external
         returns (
@@ -347,6 +477,49 @@ library MarketMathStatic {
         priceImpact = calcPriceImpact(market, netYtIn.Int());
     }
 
+    function swapExactYtForBaseTokenStatic(
+        address market,
+        uint256 exactYtIn,
+        address baseToken
+    )
+        external
+        returns (
+            uint256 netBaseTokenOut,
+            uint256 netSyFee,
+            uint256 priceImpact
+        )
+    {
+        uint256 netSyOut;
+        (netSyOut, netSyFee, priceImpact) = swapExactYtForSyStatic(market, exactYtIn);
+
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+        netBaseTokenOut = SY.previewRedeem(baseToken, netSyOut);
+    }
+
+    /// @dev netYtOut is the parameter to approx
+    function swapExactBaseTokenForYtStatic(
+        address market,
+        address baseToken,
+        uint256 amountBaseToken,
+        ApproxParams memory approxParams
+    )
+        external
+        returns (
+            uint256 netYtOut,
+            uint256 netSyFee,
+            uint256 priceImpact
+        )
+    {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+
+        return
+            swapExactSyForYtStatic(
+                market,
+                SY.previewDeposit(baseToken, amountBaseToken),
+                approxParams
+            );
+    }
+
     // totalPtToSwap is the param to approx
     function swapExactPtForYt(
         address market,