@pendle/core-v2 0.16.2-testnet → 0.16.3-testnet

package/contracts/router/ActionMintRedeem.sol

@@ -13,11 +13,10 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     using SafeERC20 for IERC20;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberSwapRouter)
-        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberScalingLib, address _bulkSellerDirectory)
+        ActionBaseMintRedeem(_kyberScalingLib, _bulkSellerDirectory) //solhint-disable-next-line no-empty-blocks
     {}
 
-    /// @dev refer to the internal function
     function mintSyFromToken(
         address receiver,
         address SY,
@@ -25,11 +24,9 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         TokenInput calldata input
     ) external payable returns (uint256 netSyOut) {
         netSyOut = _mintSyFromToken(receiver, SY, minSyOut, input);
-
         emit MintSyFromToken(msg.sender, receiver, SY, input.tokenIn, input.netTokenIn, netSyOut);
     }
 
-    /// @dev refer to the internal function
     function redeemSyToToken(
         address receiver,
         address SY,
@@ -40,25 +37,31 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         emit RedeemSyToToken(msg.sender, receiver, SY, netSyIn, output.tokenOut, netTokenOut);
     }
 
-    /// @dev refer to the internal function
     function mintPyFromToken(
         address receiver,
         address YT,
         uint256 minPyOut,
         TokenInput calldata input
     ) external payable returns (uint256 netPyOut) {
-        netPyOut = _mintPyFromToken(receiver, YT, minPyOut, input);
+        address SY = IPYieldToken(YT).SY();
+
+        uint256 netSyToMint = _mintSyFromToken(YT, SY, 0, input);
+        netPyOut = _mintPyFromSy(receiver, YT, minPyOut, netSyToMint, false);
+
         emit MintPyFromToken(msg.sender, receiver, YT, input.tokenIn, input.netTokenIn, netPyOut);
     }
 
-    /// @dev refer to the internal function
     function redeemPyToToken(
         address receiver,
         address YT,
         uint256 netPyIn,
         TokenOutput calldata output
     ) external returns (uint256 netTokenOut) {
-        netTokenOut = _redeemPyToToken(receiver, YT, netPyIn, output, true);
+        address SY = IPYieldToken(YT).SY();
+
+        uint256 netSyToRedeem = _redeemPyToSy(_syOrBulk(SY, output), YT, netPyIn, 1, true);
+        netTokenOut = _redeemSyToToken(receiver, SY, netSyToRedeem, output, false);
+
         emit RedeemPyToToken(msg.sender, receiver, YT, netPyIn, output.tokenOut, netTokenOut);
     }
 
@@ -187,7 +190,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
                 tokensOut.amounts[i]
             );
         }
-        _redeemAllSys(sysOut, dataYT.tokenRedeemSys, tokensOut);
+        _redeemAllSys(sysOut, dataYT.useBulks, dataYT.tokenRedeemSys, tokensOut);
 
         // now swap all to outputToken
         netTokenOut = _swapAllToOutputToken(tokensOut, dataSwap);
@@ -218,18 +221,19 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     /// @dev pull SYs from users & redeem them, then add to tokensOut
     function _redeemAllSys(
         RouterTokenAmounts memory sys,
+        bool[] calldata useBulks,
         address[] calldata tokenRedeemSys,
         RouterTokenAmounts memory tokensOut
     ) internal {
         for (uint256 i = 0; i < sys.tokens.length; ++i) {
             if (sys.amounts[i] == 0) continue;
 
-            IERC20(sys.tokens[i]).safeTransferFrom(msg.sender, sys.tokens[i], sys.amounts[i]);
-            uint256 amountOut = IStandardizedYield(sys.tokens[i]).redeem(
+            TokenOutput memory output = _wrapTokenOutput(tokenRedeemSys[i], 1, useBulks[i]);
+            uint256 amountOut = _redeemSyToToken(
                 address(this),
+                sys.tokens[i],
                 sys.amounts[i],
-                tokenRedeemSys[i],
-                1,
+                output,
                 true
             );
 
@@ -243,7 +247,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     ) internal returns (uint256 netTokenOut) {
         for (uint256 i = 0; i < tokens.tokens.length; ++i) {
             if (tokens.amounts[i] == 0) continue;
-            _kyberswap(tokens.tokens[i], tokens.amounts[i], dataSwap.kybercalls[i]);
+            _kyberswap(tokens.tokens[i], tokens.amounts[i], dataSwap.kyberRouter, dataSwap.kybercalls[i]);
         }
         netTokenOut = _selfBalance(dataSwap.outputToken);
         _transferOut(dataSwap.outputToken, msg.sender, netTokenOut);

package/contracts/router/ActionSwapPT.sol

@@ -16,8 +16,8 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     using PYIndexLib for IPYieldToken;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberSwapRouter)
-        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberScalingLib, address _bulkSellerDirectory)
+        ActionBaseMintRedeem(_kyberScalingLib, _bulkSellerDirectory) //solhint-disable-next-line no-empty-blocks
     {}
 
     function swapExactPtForSy(
@@ -168,7 +168,7 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         // all output SY is directly transferred to the SY contract
         uint256 netSyReceived;
         (netSyReceived, netSyFee) = IPMarket(market).swapExactPtForSy(
-            address(SY),
+            _syOrBulk(address(SY), output),
             exactPtIn,
             EMPTY_BYTES
         );

package/contracts/router/ActionSwapYT.sol

@@ -18,8 +18,8 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     using PYIndexLib for IPYieldToken;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberSwapRouter)
-        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberScalingLib, address _bulkSellerDirectory)
+        ActionBaseMintRedeem(_kyberScalingLib, _bulkSellerDirectory) //solhint-disable-next-line no-empty-blocks
     {}
 
     /**
@@ -192,7 +192,14 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
 
         uint256 netSyOut;
 
-        (netSyOut, netSyFee) = _swapExactYtForSy(address(SY), market, SY, YT, netYtIn, 1);
+        (netSyOut, netSyFee) = _swapExactYtForSy(
+            _syOrBulk(address(SY), output),
+            market,
+            SY,
+            YT,
+            netYtIn,
+            1
+        );
 
         netTokenOut = _redeemSyToToken(receiver, address(SY), netSyOut, output, false);
 
@@ -247,7 +254,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
             address(YT),
             exactYtIn, // exactPtOut = exactYtIn
             _encodeSwapYtForSy(receiver, minSyOut)
-        ); // ignore return
+        );
 
         netSyOut = SY.balanceOf(receiver) - preSyBalance;
     }

package/contracts/router/base/ActionBaseMintRedeem.sol

@@ -5,6 +5,8 @@ import "../kyberswap/KyberSwapHelper.sol";
 import "../../core/libraries/TokenHelper.sol";
 import "../../interfaces/IStandardizedYield.sol";
 import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPBulkSellerFactory.sol";
+import "../../interfaces/IPBulkSeller.sol";
 import "../../core/libraries/Errors.sol";
 
 // solhint-disable no-empty-blocks
@@ -12,13 +14,15 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
     using SafeERC20 for IERC20;
 
     bytes internal constant EMPTY_BYTES = abi.encode();
+    IPBulkSellerFactory public immutable bulkFactory;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberSwapRouter) KyberSwapHelper(_kyberSwapRouter) {}
+    constructor(address _kyberScalingLib, address _bulkSellerDirectory)
+        KyberSwapHelper(_kyberScalingLib)
+    {
+        bulkFactory = IPBulkSellerFactory(_bulkSellerDirectory);
+    }
 
-    /**
-     * @notice swap token to baseToken through Uniswap's forks & use it to mint SY
-     */
     function _mintSyFromToken(
         address receiver,
         address SY,
@@ -26,104 +30,83 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         TokenInput calldata input
     ) internal returns (uint256 netSyOut) {
         _transferIn(input.tokenIn, msg.sender, input.netTokenIn);
-        if (input.tokenIn != input.tokenMintSy) {
-            _kyberswap(input.tokenIn, input.netTokenIn, input.kybercall);
-        }
 
-        _safeApproveInf(input.tokenMintSy, SY);
+        bool requireSwap = input.tokenIn != input.tokenMintSy;
+        if (requireSwap) {
+            _kyberswap(input.tokenIn, input.netTokenIn, input.kyberRouter, input.kybercall);
+        }
 
         uint256 tokenMintSyBal = _selfBalance(input.tokenMintSy);
-        uint256 nativeAmountToAttach = input.tokenMintSy == NATIVE ? tokenMintSyBal : 0;
-
-        netSyOut = IStandardizedYield(SY).deposit{ value: nativeAmountToAttach }(
-            receiver,
-            input.tokenMintSy,
-            tokenMintSyBal,
-            minSyOut
-        );
+        if (input.useBulk) {
+            address bulk = bulkFactory.get(input.tokenMintSy, SY);
+
+            _transferOut(input.tokenMintSy, bulk, tokenMintSyBal);
+
+            netSyOut = IPBulkSeller(bulk).swapExactTokenForSy(receiver, tokenMintSyBal, minSyOut);
+        } else {
+            uint256 netNative = input.tokenMintSy == NATIVE ? tokenMintSyBal : 0;
+
+            _safeApproveInf(input.tokenMintSy, SY);
+
+            netSyOut = IStandardizedYield(SY).deposit{ value: netNative }(
+                receiver,
+                input.tokenMintSy,
+                tokenMintSyBal,
+                minSyOut
+            );
+        }
     }
 
-    /**
-     * @notice redeem SY to baseToken -> swap baseToken to token through Uniswap's forks
-     */
     function _redeemSyToToken(
         address receiver,
         address SY,
         uint256 netSyIn,
-        TokenOutput calldata output,
+        TokenOutput memory output,
         bool doPull
     ) internal returns (uint256 netTokenOut) {
         if (doPull) {
-            IERC20(SY).safeTransferFrom(msg.sender, SY, netSyIn);
+            IERC20(SY).safeTransferFrom(msg.sender, _syOrBulk(SY, output), netSyIn);
         }
 
-        if (output.tokenRedeemSy == output.tokenOut) {
-            netTokenOut = IStandardizedYield(SY).redeem(
-                receiver,
+        bool requireSwap = output.tokenRedeemSy != output.tokenOut;
+        address receiverRedeemSy = requireSwap ? address(this) : receiver;
+        uint256 netTokenRedeemed;
+
+        if (output.useBulk) {
+            address bulk = bulkFactory.get(output.tokenRedeemSy, SY);
+            netTokenRedeemed = IPBulkSeller(bulk).swapExactSyForToken(
+                receiverRedeemSy,
                 netSyIn,
-                output.tokenRedeemSy,
-                output.minTokenOut,
-                true
+                0
             );
         } else {
-            uint256 netTokenRedeemed = IStandardizedYield(SY).redeem(
-                address(this),
+            netTokenRedeemed = IStandardizedYield(SY).redeem(
+                receiverRedeemSy,
                 netSyIn,
                 output.tokenRedeemSy,
-                1,
+                0,
                 true
             );
-            _kyberswap(output.tokenRedeemSy, netTokenRedeemed, output.kybercall);
+        }
 
-            netTokenOut = _selfBalance(output.tokenOut);
+        if (requireSwap) {
+            _kyberswap(
+                output.tokenRedeemSy,
+                netTokenRedeemed,
+                output.kyberRouter,
+                output.kybercall
+            );
 
-            if (netTokenOut < output.minTokenOut)
-                revert Errors.RouterInsufficientTokenOut(netTokenOut, output.minTokenOut);
+            netTokenOut = _selfBalance(output.tokenOut);
 
             _transferOut(output.tokenOut, receiver, netTokenOut);
+        } else {
+            netTokenOut = netTokenRedeemed;
         }
-    }
-
-    /**
-     * @notice swap token to baseToken through Uniswap's forks -> convert to SY -> convert to PT + YT
-     */
-    function _mintPyFromToken(
-        address receiver,
-        address YT,
-        uint256 minPyOut,
-        TokenInput calldata input
-    ) internal returns (uint256 netPyOut) {
-        address SY = IPYieldToken(YT).SY();
-
-        _mintSyFromToken(YT, SY, 1, input);
-
-        netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
-        if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
-    }
-
-    /**
-     * @notice redeem PT + YT to SY -> redeem SY to baseToken -> swap baseToken to token through Uniswap's forks.
-        If the YT hasn't expired, both PT & YT will be needed to redeem. Else, only PT is needed
-     */
-    function _redeemPyToToken(
-        address receiver,
-        address YT,
-        uint256 netPyIn,
-        TokenOutput calldata output,
-        bool doPull
-    ) internal returns (uint256 netTokenOut) {
-        address PT = IPYieldToken(YT).PT();
-        address SY = IPYieldToken(YT).SY();
 
-        if (doPull) {
-            bool needToBurnYt = (!IPYieldToken(YT).isExpired());
-            IERC20(PT).safeTransferFrom(msg.sender, YT, netPyIn);
-            if (needToBurnYt) IERC20(YT).safeTransferFrom(msg.sender, YT, netPyIn);
+        if (netTokenOut < output.minTokenOut) {
+            revert Errors.RouterInsufficientTokenOut(netTokenOut, output.minTokenOut);
         }
-
-        uint256 amountSyOut = IPYieldToken(YT).redeemPY(SY); // ignore return
-
-        netTokenOut = _redeemSyToToken(receiver, SY, amountSyOut, output, false);
     }
 
     function _mintPyFromSy(
@@ -161,4 +144,20 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         netSyOut = IPYieldToken(YT).redeemPY(receiver);
         if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
     }
+
+    function _syOrBulk(address SY, TokenOutput memory output)
+        internal
+        view
+        returns (address addr)
+    {
+        return (output.useBulk ? bulkFactory.get(output.tokenRedeemSy, SY) : SY);
+    }
+
+    function _wrapTokenOutput(
+        address tokenOut,
+        uint256 minTokenOut,
+        bool useBulk
+    ) internal pure returns (TokenOutput memory) {
+        return TokenOutput(tokenOut, minTokenOut, tokenOut, address(0), EMPTY_BYTES, useBulk);
+    }
 }

package/contracts/router/kyberswap/AggregationRouterHelper.sol

@@ -3,8 +3,16 @@
 pragma solidity 0.8.17;
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "./IMultihopRouter.sol";
+import "./IAggregatorRouterHelper.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../../core/libraries/BoringOwnableUpgradeable.sol";
 
-library AggregationRouterHelper {
+contract AggregationRouterHelper is
+    IAggregationRouterHelper,
+    Initializable,
+    UUPSUpgradeable,
+    BoringOwnableUpgradeable
+{
     uint256 private constant _PARTIAL_FILL = 0x01;
     uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
     uint256 private constant _SHOULD_CLAIM = 0x04;
@@ -14,6 +22,14 @@ library AggregationRouterHelper {
 
     uint256 private constant SLIPPAGE_RANGE = 10; // over 100
 
+    constructor() initializer {}
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
     enum DexType {
         UNI,
         STABLESWAP,

package/contracts/router/kyberswap/IAggregatorRouterHelper.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+
+interface IAggregationRouterHelper {
+    function getScaledInputData(bytes calldata kybercall, uint256 newAmount)
+        external
+        pure
+        returns (bytes memory);
+}

package/contracts/router/kyberswap/KyberSwapHelper.sol

@@ -25,42 +25,51 @@ pragma solidity 0.8.17;
 
 import "@openzeppelin/contracts/utils/Address.sol";
 import "../../core/libraries/TokenHelper.sol";
-import "./AggregationRouterHelper.sol";
+import "./IAggregatorRouterHelper.sol";
+import "../../core/libraries/Errors.sol";
 
 struct TokenInput {
     address tokenIn;
     uint256 netTokenIn;
     address tokenMintSy;
+    address kyberRouter;
     bytes kybercall;
+    bool useBulk;
 }
 
 struct TokenOutput {
     address tokenOut;
     uint256 minTokenOut;
     address tokenRedeemSy;
+    address kyberRouter;
     bytes kybercall;
+    bool useBulk;
 }
 
 abstract contract KyberSwapHelper is TokenHelper {
     using Address for address;
-    address public immutable kyberSwapRouter;
 
-    /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberSwapRouter) {
-        kyberSwapRouter = _kyberSwapRouter;
+    address public immutable kyberScalingLib;
+
+    constructor(address _kyberScalingLib) {
+        kyberScalingLib = _kyberScalingLib;
     }
 
     function _kyberswap(
         address tokenIn,
         uint256 amountIn,
+        address kyberRouter,
         bytes memory rawKybercall
     ) internal {
-        _safeApproveInf(tokenIn, kyberSwapRouter);
+        if (kyberRouter == address(0) || rawKybercall.length == 0) {
+            revert Errors.RouterKyberSwapDataZero();
+        }
+        _safeApproveInf(tokenIn, kyberRouter);
 
-        bytes memory kybercall = AggregationRouterHelper.getScaledInputData(
+        bytes memory kybercall = IAggregationRouterHelper(kyberScalingLib).getScaledInputData(
             rawKybercall,
             amountIn
         );
-        kyberSwapRouter.functionCallWithValue(kybercall, tokenIn == NATIVE ? amountIn : 0);
+        kyberRouter.functionCallWithValue(kybercall, tokenIn == NATIVE ? amountIn : 0);
     }
 }

package/deployments/43113-core.json

@@ -7,8 +7,9 @@
     "PENDLE": "0xB7609dec1C926204c3B67345cbCd54bc4aa7a940",
     "yieldContractFactory": "0xC39Efc7bb273B75B75471167Cb0EB4D3D41398a8",
     "marketFactory": "0xa28B2445C8e1751733e75e6794971AEEA4806F45",
-    "router": "0x37e0018919832abC3EDfbfE700df5bb15ed0682D",
-    "routerStatic": "0xFE1129fFa39A2660f5A99eF96343F06D472f781B",
+    "bulkSellerFactory": "0x9f45D5A34CC9Bcb3AB4ee464bE768E30B5e627f8",
+    "router": "0x129be7922B733b0F06cb4f0f47B6b4a12710a312",
+    "routerStatic": "0x699665c3fA37FF59cACd913EAaB56CEFA66C339E",
     "vePendle": "0x74E578b27aD53f23387b9Dcb7902F7Def6D4dB7c",
     "senderEndpoint": "0xa87c479d77040d1c5433b9cD3b88b2B562A7cb10",
     "votingController": "0x0b24c845feF83f8403EEF3922F3B53a05182512A",

package/deployments/43113-markets/benqi-market-QI-AVAX-FEB-2ND.json

@@ -0,0 +1,9 @@
+{
+    "symbol": "SY-qiAVAX",
+    "SY": "0x7bd149FFD976F366af864B2F9585016FD0386A3F",
+    "expiry": 1675382400,
+    "PT": "0x9156bf2494F7DaaBAE2Ec919513217Dc9a2535aD",
+    "YT": "0x12CBF941d14823160e606BdaA7eA4f351251A9cF",
+    "market": "0x94f1997DA3ea57875ab97747d2bF744c6895A0AD",
+    "bulkSeller": "0xc64c1A2DCbA6bB38DA23a4C2b9Ca76005508719A"
+}

package/deployments/80001-core.json

@@ -7,8 +7,9 @@
     "PENDLE": "0x5FDA5b3b05B2884F9f028550069B9D321E84814A",
     "yieldContractFactory": "0x8B3C5BD39E6B82272eCf0d6828D458536dc44dea",
     "marketFactory": "0xf963474FAe462B06B026DE500f605B3578B66c66",
-    "router": "0x7cD7cc0990A0F61532410fE11f884f2caD7e59D3",
-    "routerStatic": "0xc9132D222e681c86A522120B41585B87992D61b9",
+    "bulkSellerFactory": "0xcdFfe971e3dE61f94450C56e140E3b2E0d7597CF",
+    "router": "0x60e5F58005b326ecA0cf9c96528781567973d7B0",
+    "routerStatic": "0xf159EC6647659eD86a67eb0B1131595c2EE086c2",
     "receiverEndpoint": "0x57D55237374b0D1AFdac5E25F16A4EE5C57A627c",
     "vePendle": "0x89Cec94a14FAB1cb27C1A5cd32af05ef448d9829",
     "gaugeController": "0x8a6c59A80aA3Bbf32E7b3F0C359Eb528Cf6f7288"

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.16.2-testnet",
+  "version": "0.16.3-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -44,6 +44,7 @@
   },
   "packageManager": "yarn@3.2.2",
   "dependencies": {
-    "@openzeppelin/contracts": "^4.7.3"
+    "@openzeppelin/contracts": "^4.7.3",
+    "@openzeppelin/contracts-upgradeable": "^4.7.3"
   }
 }