@pendle/core-v2 0.16.5-testnet → 0.17.0-daily

package/contracts/router/ActionSwapPTYT.sol

@@ -5,6 +5,7 @@ import "../interfaces/IPActionSwapPTYT.sol";
 import "../interfaces/IPMarket.sol";
 import "./base/CallbackHelper.sol";
 
+/// @dev All swap actions will revert if market is expired
 contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper, TokenHelper {
     using MarketMathCore for MarketState;
     using MarketApproxPtInLib for MarketState;
@@ -19,6 +20,18 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper, TokenHelper {
 
     }
 
+    /**
+     * @notice swap exact PT to YT with the help of flashswaps & YT tokenization / redemption
+     * @dev inner working of this function:
+     - `exactPtIn` PT is transferred to market contract
+     - `market.swapExactPtForSy` is called, which will transfer SY directly to YT contract & callback is invoked.
+        Note that we will owe PT, the amount before is not sufficient
+     - in callback, all SY in YT contract is used to mint PT + YT, with PT used to pay the rest of the loan, and YT
+        transferred to the receiver
+     * @param exactPtIn will always consume this amount of PT for as much YT as possible
+     * @param guessTotalPtToSwap approximation data for PT used for the PT-to-SY flashswap
+     * @dev this function works in conjunction with ActionCallback
+     */
     function swapExactPtForYt(
         address receiver,
         address market,
@@ -27,7 +40,7 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper, TokenHelper {
         ApproxParams calldata guessTotalPtToSwap
     ) external returns (uint256 netYtOut, uint256 netSyFee) {
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
-        MarketState memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(address(this));
 
         _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
 
@@ -50,31 +63,43 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper, TokenHelper {
         emit SwapPtAndYt(msg.sender, market, receiver, exactPtIn.neg(), netYtOut.Int());
     }
 
+    /**
+     * @notice swap exact YT to PT with the help of flashswaps & YT tokenization / redemption
+     * @dev inner working of this function:
+     - `exactYtIn` YT is transferred to yield contract
+     - `market.swapSyForExactPt` is called, which will transfer PT directly to this contract & callback is invoked.
+        Note that we now owe SY
+     - in callback, a portion of PT + YT is used to redeem SY, which is then used to payback the loan. The rest of 
+       of the PT is transferred to `receiver`
+     * @param exactYtIn will always consume this amount of YT for as much PT as possible
+     * @param guessTotalPtFromSwap approximation data for PT output of the SY-to-PT flashswap
+     * @dev this function works in conjunction with ActionCallback
+     */
     function swapExactYtForPt(
         address receiver,
         address market,
         uint256 exactYtIn,
         uint256 minPtOut,
-        ApproxParams calldata guessTotalPtSwapped
+        ApproxParams calldata guessTotalPtFromSwap
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
-        MarketState memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(address(this));
 
         _transferFrom(IERC20(YT), msg.sender, address(YT), exactYtIn);
 
-        uint256 totalPtSwapped;
-        (netPtOut, totalPtSwapped, netSyFee) = state.approxSwapExactYtForPt(
+        uint256 totalPtFromSwap;
+        (netPtOut, totalPtFromSwap, netSyFee) = state.approxSwapExactYtForPt(
             YT.newIndex(),
             exactYtIn,
             block.timestamp,
-            guessTotalPtSwapped
+            guessTotalPtFromSwap
         );
 
         if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
         IPMarket(market).swapSyForExactPt(
             address(this),
-            totalPtSwapped,
+            totalPtFromSwap,
             _encodeSwapExactYtForPt(receiver, exactYtIn, minPtOut)
         );
 

package/contracts/router/ActionSwapYT.sol

@@ -7,6 +7,7 @@ import "../interfaces/IPActionSwapYT.sol";
 import "../interfaces/IPMarket.sol";
 import "../core/libraries/Errors.sol";
 
+/// @dev All swap actions will revert if market is expired
 contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     using Math for uint256;
     using Math for int256;
@@ -21,14 +22,16 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     {}
 
     /**
-    * @notice swap exact SY to YT with the help of flashswaps & YT tokenization / redemption
-    * @dev inner working of this function:
+     * @notice swap exact SY to YT with the help of flashswaps & YT tokenization / redemption
+     * @dev inner working of this function:
      - `exactSyIn` SY is transferred to YT contract
-     - `market.swapExactPtForSy` is called, which will transfer SY directly to YT contract & callback is invoked.
-        Note that now we owe PT
-     - in callback, all SY in YT contract is used to mint PT + YT, with PT used to pay back the loan, and YT
-        transferred to the receiver
-    * @dev this function works in conjunction with ActionCallback
+     - `market.swapExactPtForSy` is called, which will transfer more SY directly to YT contract & 
+       callback is invoked. Note that now we owe PT
+     - in callback, all SY in YT contract is used to mint PT + YT, with all PT used to pay back the 
+       loan, and all YT transferred to the receiver
+     * @param exactSyIn will always consume this amount of SY for as much YT as possible
+     * @param guessYtOut approximation data for total YT output
+     * @dev this function works in conjunction with ActionCallback
      */
     function swapExactSyForYt(
         address receiver,
@@ -54,14 +57,15 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     }
 
     /**
-    * @notice swap exact YT to SY with the help of flashswaps & YT tokenization / redemption
-    * @dev inner working of this function:
+     * @notice swap exact YT to SY with the help of flashswaps & YT tokenization / redemption
+     * @dev inner working of this function:
      - `exactYtIn` YT is transferred to YT contract
-     - `market.swapSyForExactPt` is called, which will transfer PT directly to YT contract & callback is invoked.
-        Note that now we owe SY
-     - in callback, all PT + YT in YT contract is used to redeem SY. A portion of SY is used to payback the loan,
-        the rest is transferred to the `receiver`
-    * @dev this function works in conjunction with ActionCallback
+     - `market.swapSyForExactPt` is called, which will transfer PT directly to YT contract & 
+       callback is invoked. Note that now we owe SY.
+     - In callback, all PT + YT in YT contract is used to redeem SY. A portion of SY is used to 
+       payback the loan, the rest is transferred to the `receiver`
+     * @param exactYtIn will consume exactly this much YT for as much SY as possible
+     * @dev this function works in conjunction with ActionCallback
      */
     function swapExactYtForSy(
         address receiver,
@@ -79,13 +83,14 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     }
 
     /**
-    * @notice swap SY to exact YT with the help of flashswaps & YT tokenization / redemption
-    * @dev inner working of this function:
-     - `market.swapExactPtForSy` is called, which will transfer SY directly to YT contract & callback is invoked.
-        Note that now we owe PT
-     - in callback, we will pull in more SY as needed & mint all SY to PT + YT. PT is then used to payback the loan
-        while YT is transferred to the user
-    * @dev this function works in conjunction with ActionCallback
+     * @notice swap SY to exact YT with the help of flashswaps & YT tokenization / redemption
+     * @dev inner working of this function:
+     - `market.swapExactPtForSy` is called, which will transfer SY directly to YT contract & 
+       callback is invoked. Note that now we owe PT
+     - In callback, we will pull in more SY as needed from caller & mint all SY to PT + YT. PT is 
+       then used to payback the loan, while YT is transferred to `receiver`
+     * @param exactYtOut will output exactly this amount of YT, no approximation is used
+     * @dev this function works in conjunction with ActionCallback
      */
     function swapSyForExactYt(
         address receiver,
@@ -109,14 +114,15 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     }
 
     /**
-    * @notice swap YT to exact SY with the help of flashswaps & YT tokenization / redemption
-    * @dev inner working of this function:
-     - transfer netYtIn (received from approx function) to YT contract
-     - `market.swapSyForExactPt` is called, which will transfer PT directly to YT contract & callback is invoked.
-        Note that now we owe SY
-     - in callback, we will redeem all PT + YT to get SY. A portion of it is used to payback the loan. The rest is
-        transferred to `receiver`
-    * @dev this function works in conjunction with ActionCallback
+     * @notice swap YT to exact SY with the help of flashswaps & YT tokenization / redemption
+     * @dev inner working of this function:
+     - Approximates `netYtIn` using the data from `guessYtIn`
+     - Pulls `netYtIn` amount of YT from caller
+     - `market.swapSyForExactPt` is called, which will transfer PT directly to YT contract & 
+       callback is invoked. Note that now we owe SY
+     - In callback, we will redeem all PT + YT to get SY. A portion of it is used to payback the 
+       loan. The rest is transferred to `receiver`
+     * @dev this function works in conjunction with ActionCallback
      */
     function swapYtForExactSy(
         address receiver,
@@ -125,7 +131,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         uint256 maxYtIn,
         ApproxParams memory guessYtIn
     ) external returns (uint256 netYtIn, uint256 netSyFee) {
-        MarketState memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(address(this));
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         (netYtIn, , ) = state.approxSwapYtForExactSy(
@@ -148,6 +154,11 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         emit SwapYtAndSy(msg.sender, market, receiver, netYtIn.neg(), exactSyOut.Int());
     }
 
+    /**
+     * @notice swaps any token to YT
+     * @dev this function swaps token for SY-mintable token first through Kyberswap, then mints SY
+     * from such, finally swaps SY to YT (see `swapSyForExactYt()`)
+     */
     function swapExactTokenForYt(
         address receiver,
         address market,
@@ -171,13 +182,18 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         emit SwapYtAndToken(
             msg.sender,
             market,
-            receiver,
             input.tokenIn,
+            receiver,
             netYtOut.Int(),
             input.netTokenIn.neg()
         );
     }
 
+    /**
+     * @notice swaps YT to a given token
+     * @dev the function first swaps YT to SY (see `swapExactYtForSy()`), then redeems SY,
+     * finally swaps resulting tokens to desired output token using Kyberswap
+     */
     function swapExactYtForToken(
         address receiver,
         address market,
@@ -204,8 +220,8 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         emit SwapYtAndToken(
             msg.sender,
             market,
-            receiver,
             output.tokenOut,
+            receiver,
             netYtIn.neg(),
             netTokenOut.Int()
         );
@@ -219,7 +235,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         uint256 minYtOut,
         ApproxParams memory guessYtOut
     ) internal returns (uint256 netYtOut, uint256 netSyFee) {
-        MarketState memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(address(this));
 
         (netYtOut, ) = state.approxSwapExactSyForYt(
             YT.newIndex(),

package/contracts/router/PendleRouter.sol

@@ -5,7 +5,6 @@ import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/Proxy.sol";
 import "../interfaces/IPAllAction.sol";
 import "../interfaces/IPMarketSwapCallback.sol";
-import "../core/libraries/BoringOwnableUpgradeable.sol";
 import "../core/libraries/Errors.sol";
 
 /// @dev this contract will be deployed behind an ERC1967 proxy
@@ -13,7 +12,7 @@ import "../core/libraries/Errors.sol";
 /// corresponding implementation contracts
 
 // solhint-disable no-empty-blocks
-contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpgradeable {
+contract PendleRouter is Proxy {
     address public immutable ACTION_MINT_REDEEM;
     address public immutable ACTION_ADD_REMOVE_LIQ;
     address public immutable ACTION_SWAP_PT;
@@ -30,7 +29,7 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
         address _ACTION_SWAP_PTYT,
         address _ACTION_CALLBACK,
         address _ACTION_MISC
-    ) initializer {
+    ) {
         ACTION_MINT_REDEEM = _ACTION_MINT_REDEEM;
         ACTION_ADD_REMOVE_LIQ = _ACTION_ADD_REMOVE_LIQ;
         ACTION_SWAP_PT = _ACTION_SWAP_PT;
@@ -40,12 +39,7 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
         ACTION_MISC = _ACTION_MISC;
     }
 
-    receive() external payable virtual override {
-    }
-
-    function initialize() external initializer {
-        __BoringOwnable_init();
-    }
+    receive() external payable virtual override {}
 
     function getRouterImplementation(bytes4 sig) public view returns (address) {
         if (
@@ -103,8 +97,6 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
         revert Errors.RouterInvalidAction(sig);
     }
 
-    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
-
     function _implementation() internal view override returns (address) {
         return getRouterImplementation(msg.sig);
     }

package/contracts/router/base/MarketApproxLib.sol

@@ -24,7 +24,8 @@ struct ApproxParams {
 
     /// for guessOffchain, this is to provide a shortcut to guessing. The offchain SDK can precalculate the exact result
     /// before the tx is sent. When the tx reaches the contract, the guessOffchain will be checked first, and if it satisfies the
-    /// approximation, it will be used (and save all the guessing).
+    /// approximation, it will be used (and save all the guessing). It's expected that this shortcut will be used in most cases
+    /// except in cases that there is a trade in the same market right before the tx
 }
 
 library MarketApproxPtInLib {
@@ -84,7 +85,7 @@ library MarketApproxPtInLib {
                 continue;
             }
 
-            (uint256 netSyOut, uint256 netSyFee) = calcSyOut(a.market, comp, a.index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(a.market, comp, a.index, guess);
 
             if (netSyOut >= a.minSyOut) {
                 p.guessMax = guess;
@@ -146,7 +147,7 @@ library MarketApproxPtInLib {
                 continue;
             }
 
-            (uint256 netSyOut, uint256 netSyFee) = calcSyOut(a.market, comp, a.index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(a.market, comp, a.index, guess);
 
             uint256 maxPtPayable = a.index.syToAsset(netSyOut + a.exactSyIn);
 
@@ -155,7 +156,7 @@ library MarketApproxPtInLib {
                 bool isAnswerAccepted = Math.isASmallerApproxB(guess, maxPtPayable, p.eps);
                 if (isAnswerAccepted) return (guess, netSyFee);
             } else {
-                p.guessMax = guess;
+                p.guessMax = guess - 1;
             }
         }
         revert Errors.ApproxFail();
@@ -211,14 +212,18 @@ library MarketApproxPtInLib {
                 continue;
             }
 
-            (uint256 netSyOut, uint256 netSyFee) = calcSyOut(a.market, comp, a.index, guess);
+            (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve) = calcSyOut(
+                a.market,
+                comp,
+                a.index,
+                guess
+            );
 
             uint256 syNumerator;
             uint256 ptNumerator;
             {
                 uint256 newTotalPt = a.market.totalPt.Uint() + guess;
-                uint256 netPtRemaining = a.totalPtIn - guess;
-                uint256 newTotalSy = (a.market.totalSy.Uint() - netSyOut - netSyFee);
+                uint256 newTotalSy = (a.market.totalSy.Uint() - netSyOut - netSyToReserve);
 
                 // it is desired that
                 // netSyOut / newTotalSy = netPtRemaining / newTotalPt
@@ -226,7 +231,7 @@ library MarketApproxPtInLib {
                 // netSyOut * newTotalPt = netPtRemaining * newTotalSy
 
                 syNumerator = netSyOut * newTotalPt;
-                ptNumerator = netPtRemaining * newTotalSy;
+                ptNumerator = (a.totalPtIn - guess) * newTotalSy;
             }
 
             if (Math.isAApproxB(syNumerator, ptNumerator, p.eps)) {
@@ -292,7 +297,7 @@ library MarketApproxPtInLib {
                 continue;
             }
 
-            (uint256 netSyOut, uint256 netSyFee) = calcSyOut(a.market, comp, a.index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(a.market, comp, a.index, guess);
 
             uint256 netAssetOut = a.index.syToAsset(netSyOut);
 
@@ -316,10 +321,23 @@ library MarketApproxPtInLib {
         MarketPreCompute memory comp,
         PYIndex index,
         uint256 netPtIn
-    ) internal pure returns (uint256 netSyOut, uint256 netSyFee) {
-        (int256 _netSyOut, int256 _netSyFee) = market.calcTrade(comp, index, netPtIn.neg());
+    )
+        internal
+        pure
+        returns (
+            uint256 netSyOut,
+            uint256 netSyFee,
+            uint256 netSyToReserve
+        )
+    {
+        (int256 _netSyOut, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(
+            comp,
+            index,
+            netPtIn.neg()
+        );
         netSyOut = _netSyOut.Uint();
         netSyFee = _netSyFee.Uint();
+        netSyToReserve = _netSyToReserve.Uint();
     }
 
     function newApproxParamsPtIn(
@@ -447,7 +465,7 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netSyIn, uint256 netSyFee) = calcSyIn(a.market, comp, a.index, guess);
+            (uint256 netSyIn, uint256 netSyFee, ) = calcSyIn(a.market, comp, a.index, guess);
 
             if (netSyIn <= a.exactSyIn) {
                 p.guessMin = guess;
@@ -502,7 +520,7 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netSyOwed, uint256 netSyFee) = calcSyIn(a.market, comp, a.index, guess);
+            (uint256 netSyOwed, uint256 netSyFee, ) = calcSyIn(a.market, comp, a.index, guess);
 
             uint256 netAssetToRepay = a.index.syToAssetUp(netSyOwed);
             uint256 netSyOut = a.index.assetToSy(guess - netAssetToRepay);
@@ -562,7 +580,12 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netSyIn, uint256 netSyFee) = calcSyIn(a.market, comp, a.index, guess);
+            (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve) = calcSyIn(
+                a.market,
+                comp,
+                a.index,
+                guess
+            );
 
             if (netSyIn > a.totalSyIn) {
                 p.guessMax = guess - 1;
@@ -573,9 +596,8 @@ library MarketApproxPtOutLib {
             uint256 ptNumerator;
 
             {
-                uint256 netSyRemaining = a.totalSyIn - netSyIn;
                 uint256 newTotalPt = a.market.totalPt.Uint() - guess;
-                uint256 netTotalSy = a.market.totalSy.Uint() + netSyIn - netSyFee;
+                uint256 netTotalSy = a.market.totalSy.Uint() + netSyIn - netSyToReserve;
 
                 // it is desired that
                 // netPtFromSwap / newTotalPt = netSyRemaining / netTotalSy
@@ -583,7 +605,7 @@ library MarketApproxPtOutLib {
                 // netPtFromSwap * netTotalSy = netSyRemaining * newTotalPt
 
                 ptNumerator = guess * netTotalSy;
-                syNumerator = netSyRemaining * newTotalPt;
+                syNumerator = (a.totalSyIn - netSyIn) * newTotalPt;
             }
 
             if (Math.isAApproxB(ptNumerator, syNumerator, p.eps)) {
@@ -650,7 +672,7 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netSyOwed, uint256 netSyFee) = calcSyIn(a.market, comp, a.index, guess);
+            (uint256 netSyOwed, uint256 netSyFee, ) = calcSyIn(a.market, comp, a.index, guess);
 
             if (netSyOwed <= a.maxSyPayable) {
                 p.guessMin = guess;
@@ -671,11 +693,24 @@ library MarketApproxPtOutLib {
         MarketPreCompute memory comp,
         PYIndex index,
         uint256 netPtOut
-    ) internal pure returns (uint256 netSyIn, uint256 netSyFee) {
-        (int256 _netSyIn, int256 _netSyFee) = market.calcTrade(comp, index, netPtOut.Int());
+    )
+        internal
+        pure
+        returns (
+            uint256 netSyIn,
+            uint256 netSyFee,
+            uint256 netSyToReserve
+        )
+    {
+        (int256 _netSyIn, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(
+            comp,
+            index,
+            netPtOut.Int()
+        );
 
         netSyIn = _netSyIn.abs();
         netSyFee = _netSyFee.Uint();
+        netSyToReserve = _netSyToReserve.Uint();
     }
 
     function newApproxParamsPtOut(
@@ -683,11 +718,19 @@ library MarketApproxPtOutLib {
         uint256 minGuessMin,
         uint256 maxGuessMax
     ) internal pure returns (ApproxParamsPtOut memory res) {
+        if (_approx.guessMin > _approx.guessMax || _approx.eps > Math.ONE)
+            revert Errors.ApproxParamsInvalid(_approx.guessMin, _approx.guessMax, _approx.eps);
+
         res.guessMin = Math.max(_approx.guessMin, minGuessMin);
         res.guessMax = Math.min(_approx.guessMax, maxGuessMax);
 
-        if (res.guessMin > res.guessMax || _approx.eps > Math.ONE)
-            revert Errors.ApproxParamsInvalid(_approx.guessMin, _approx.guessMax, _approx.eps);
+        if (res.guessMin > res.guessMax)
+            revert Errors.ApproxBinarySearchInputInvalid(
+                _approx.guessMin,
+                _approx.guessMax,
+                minGuessMin,
+                maxGuessMax
+            );
 
         res.guessOffchain = _approx.guessOffchain;
         res.maxIteration = _approx.maxIteration;

package/deployments/43113-core.json

@@ -1,17 +1,22 @@
 {
     "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
-    "network": 43113,
-    "splitter": "0x81357A3D4F023745a518E4F07b8714e141f84E0a",
-    "lzEndpoint": "0x93f54D755A063cE7bB9e6Ac47Eccc8e33411d706",
-    "treasury": "0x243b7CFD29AcAF9cDe98C1958902FAA3B1F095D5",
-    "PENDLE": "0xB7609dec1C926204c3B67345cbCd54bc4aa7a940",
-    "yieldContractFactory": "0xC39Efc7bb273B75B75471167Cb0EB4D3D41398a8",
-    "marketFactory": "0xa28B2445C8e1751733e75e6794971AEEA4806F45",
-    "bulkSellerFactory": "0x9f45D5A34CC9Bcb3AB4ee464bE768E30B5e627f8",
-    "router": "0x129be7922B733b0F06cb4f0f47B6b4a12710a312",
-    "routerStatic": "0x699665c3fA37FF59cACd913EAaB56CEFA66C339E",
-    "vePendle": "0x74E578b27aD53f23387b9Dcb7902F7Def6D4dB7c",
-    "senderEndpoint": "0xa87c479d77040d1c5433b9cD3b88b2B562A7cb10",
-    "votingController": "0x0b24c845feF83f8403EEF3922F3B53a05182512A",
-    "gaugeController": "0xf0cFb8781F17d51523922Ace5eB69a4b42e35a15"
+    "network": {
+        "chainId": 43113,
+        "treasury": "0x243b7CFD29AcAF9cDe98C1958902FAA3B1F095D5",
+        "governance": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+        "pendle": "0x808507121b80c02388fad14726482e061b8da827",
+        "lzEndpoint": "0x93f54D755A063cE7bB9e6Ac47Eccc8e33411d706",
+        "wrappedNative": "0xe43a7aD7C09d8fAE3ADe7361f0b847b23adD5094"
+    },
+    "splitter": "0x4B3B9f8f65E1c3fde4073874c2C93a1760F11035",
+    "PENDLE": "0x808507121b80c02388fad14726482e061b8da827",
+    "yieldContractFactory": "0xD3DC187247539380C3AAbFdb2D09c341910fFE83",
+    "marketFactory": "0x74D8b7eC36C0ff4157bD359B6D3Ab82a5d741B8E",
+    "bulkSellerFactory": "0x640bDc3daF9cFDb33CC67e46180A4E6c0495D0f4",
+    "router": "0x5334471de92CDBeB4245d3a3B1aF93b4DfDa8cC9",
+    "routerStatic": "0xd1dCaC6f75361A7C734863BC17B126EcB873192C",
+    "vePendle": "0x2d7e1Ab594E218eBd473bBE3aF57fAD5541F10f9",
+    "senderEndpoint": "0x33D7a94070A697E5CAe134A409ef42cfDba4F3b1",
+    "votingController": "0xdc8D6a5Db65287af491199244459e5C57d62f3f8",
+    "gaugeController": "0xd7D67E0b7DcF4665222809868512cAf6ac99C736"
 }

package/deployments/43113-markets/WETH-FEB-2ND.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY Benqi WETH",
+    "SY": "0x5C90c945C0f7Ad4D8C3d1746185262bB9499eCF0",
+    "YT": "0xe85DFab309ED388d75E4C3665a77C73C6C0BA630",
+    "PT": "0x27DaeA7A12A9499F8065631756FEE5A9ACbd105a",
+    "market": "0x096206b71CA3610724F780B9af6c2D47938A345C",
+    "expiry": 1675382400,
+    "scalarRoot": "62000000000000000000",
+    "initAnchor": "1012600000000000000"
+}

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.5-testnet",
+  "version": "0.17.0-daily",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -25,16 +25,16 @@
   "devDependencies": {
     "@typechain/ethers-v5": "^9.0.0",
     "@typechain/hardhat": "^4.0.0",
-    "hardhat": "^2.12.0",
+    "hardhat": "^2.12.2",
     "hardhat-contract-sizer": "^2.6.1",
     "hardhat-storage-layout-diff": "^0.0.4",
     "prettier": "^2.7.1",
-    "prettier-plugin-solidity": "^1.0.0-beta.24",
+    "prettier-plugin-solidity": "^1.0.0-rc.1",
     "solc": "^0.8.17",
     "solhint": "^3.3.7",
     "ts-node": "^10.9.1",
-    "typechain": "^8.1.0",
-    "typescript": "^4.8.4"
+    "typechain": "^8.1.1",
+    "typescript": "^4.9.3"
   },
   "scripts": {
     "compile": "yarn hardhat compile",
@@ -44,7 +44,7 @@
   },
   "packageManager": "yarn@3.2.2",
   "dependencies": {
-    "@openzeppelin/contracts": "^4.7.3",
-    "@openzeppelin/contracts-upgradeable": "^4.7.3"
+    "@openzeppelin/contracts": "4.7.3",
+    "@openzeppelin/contracts-upgradeable": "4.7.3"
   }
 }