@pendle/core-v2 0.8.0-beta → 0.8.0-beta-2

package/contracts/SuperComposableYield/SCY-implementations/PendleYearnVaultScy.sol

@@ -65,14 +65,18 @@ contract PendleYearnVaultSCY is SCYBase {
             amountTokenOut = amountSharesToRedeem;
         } else {
             // tokenOut == underlying
-            uint256 sharesRedeemed = IYearnVault(yvToken).withdraw(amountSharesToRedeem);
+            uint256 preBalanceYvToken = _selfBalance(yvToken);
+
+            amountTokenOut = IYearnVault(yvToken).withdraw(
+                amountSharesToRedeem,
+                address(this),
+                10000
+            );
 
             require(
-                sharesRedeemed == amountSharesToRedeem,
+                preBalanceYvToken - _selfBalance(yvToken) == amountSharesToRedeem,
                 "Yearn Vault SCY: Not allowed to redeem all shares"
             );
-
-            amountTokenOut = _selfBalance(underlying);
         }
     }
 

package/contracts/SuperComposableYield/base-implementations/SCYBase.sol

@@ -18,7 +18,7 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         string memory _name,
         string memory _symbol,
         address _yieldToken
-    ) PendleERC20(_name, _symbol, 18) {
+    ) PendleERC20(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) {
         yieldToken = _yieldToken;
     }
 

package/contracts/core/Market/PendleMarket.sol

@@ -103,7 +103,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
             index,
             scyDesired,
             ptDesired,
-            true
+            block.timestamp
         );
 
         // initializing the market
@@ -133,7 +133,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         uint256 lpToRemove = balanceOf(address(this));
         _burn(address(this), lpToRemove);
 
-        (scyToAccount, ptToAccount) = market.removeLiquidity(lpToRemove, true);
+        (scyToAccount, ptToAccount) = market.removeLiquidity(lpToRemove);
 
         IERC20(SCY).safeTransfer(receiverScy, scyToAccount);
         IERC20(PT).safeTransfer(receiverPt, ptToAccount);

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -197,6 +197,31 @@ contract PendleYieldToken is
         return MiniHelpers.isCurrentlyExpired(expiry);
     }
 
+    function getPostExpiryData()
+        external
+        view
+        returns (
+            uint256 firstScyIndex,
+            uint256 totalScyInterestForTreasury,
+            uint256[] memory firstRewardIndexes,
+            uint256[] memory userRewardOwed
+        )
+    {
+        require(postExpiry.firstScyIndex != 0, "PostExpiry data not set");
+
+        firstScyIndex = postExpiry.firstScyIndex;
+        totalScyInterestForTreasury = postExpiry.totalScyInterestForTreasury;
+
+        address[] memory tokens = getRewardTokens();
+        firstRewardIndexes = new uint256[](tokens.length);
+        userRewardOwed = new uint256[](tokens.length);
+
+        for (uint256 i = 0; i < tokens.length; ++i) {
+            firstRewardIndexes[i] = postExpiry.firstRewardIndex[tokens[i]];
+            userRewardOwed[i] = postExpiry.userRewardOwed[tokens[i]];
+        }
+    }
+
     function _redeemPY(address[] memory receivers, uint256[] memory amountPYToRedeems)
         internal
         returns (uint256[] memory amountScyOuts)
@@ -370,6 +395,7 @@ contract PendleYieldToken is
         address to,
         uint256
     ) internal override {
+        _setPostExpiryData();
         _updateAndDistributeRewardsForTwo(from, to);
         _distributeInterestForTwo(from, to);
     }

package/contracts/core/actions/ActionCallback.sol

@@ -92,9 +92,7 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         /// ------------------------------------------------------------
         SCYIndex scyIndex = SCY.newIndex();
         uint256 ptOwed = ptToAccount.abs();
-        uint256 totalScyNeed = scyIndex.assetToScy(ptOwed);
-        // to guard against precision issue of lacking a few units of SCY. rawDivUp is not Fixed-Point division
-        totalScyNeed += SCYIndex.unwrap(scyIndex).rawDivUp(SCYUtils.ONE);
+        uint256 totalScyNeed = scyIndex.assetToScyUp(ptOwed);
 
         /// ------------------------------------------------------------
         /// calc netScyToPull

package/contracts/core/actions/base/ActionSCYAndPTBase.sol

@@ -45,7 +45,7 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
             SCY.newIndex(),
             scyDesired,
             ptDesired,
-            false
+            block.timestamp
         );
 
         // early-check
@@ -72,7 +72,7 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
     ) internal returns (uint256 netScyOut, uint256 netPtOut) {
         MarketState memory state = IPMarket(market).readState(false);
 
-        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove, false);
+        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove);
 
         // early-check
         require(netScyOut >= scyOutMin, "insufficient SCY out");

package/contracts/core/actions/base/ActionSCYAndYTBase.sol

@@ -109,13 +109,16 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         uint256 exactYtOut,
         uint256 maxScyIn
     ) internal returns (uint256 netScyIn) {
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 preScyBalance = SCY.balanceOf(msg.sender);
 
         IPMarket(market).swapExactPtForScy(
             address(YT),
             exactYtOut, // exactPtIn = exactYtOut
             _encodeSwapScyForExactYt(msg.sender, receiver, maxScyIn)
         );
+        netScyIn = preScyBalance - SCY.balanceOf(msg.sender);
     }
 
     /**

package/contracts/interfaces/IPRouterStatic.sol

@@ -104,16 +104,21 @@ interface IPRouterStatic {
         view
         returns (uint256 netScyOut, uint256 netPtOut);
 
-    function swapPtForScyStatic(address market, uint256 exactPtIn)
+    function swapExactPtForScyStatic(address market, uint256 exactPtIn)
         external
         view
         returns (uint256 netScyOut, uint256 netScyFee);
 
-    function swapScyForPtStatic(address market, uint256 exactPtOut)
+    function swapScyForExactPtStatic(address market, uint256 exactPtOut)
         external
         view
         returns (uint256 netScyIn, uint256 netScyFee);
 
+    function swapExactScyForPtStatic(address market, uint256 exactScyIn)
+        external
+        view
+        returns (uint256 netPtOut, uint256 netScyFee);
+
     // ============= OTHER HELPERS =============
 
     function scyIndex(address market) external view returns (SCYIndex index);

package/contracts/interfaces/IYearnVault.sol

@@ -28,7 +28,11 @@ interface IYearnVault {
 
     function deposit(uint256 amount, address recipient) external returns (uint256);
 
-    function withdraw(uint256 maxShares) external returns (uint256);
+    function withdraw(
+        uint256 maxShares,
+        address recipient,
+        uint256 maxLoss
+    ) external returns (uint256 amountTokenRedeemed);
 
     function pricePerShare() external view returns (uint256);
 

package/contracts/libraries/SCY/SCYIndex.sol

@@ -34,6 +34,13 @@ library SCYIndexLib {
         return SCYUtils.assetToScy(SCYIndex.unwrap(index), assetAmount);
     }
 
+    function assetToScyUp(SCYIndex index, uint256 assetAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return SCYUtils.assetToScyUp(SCYIndex.unwrap(index), assetAmount);
+    }
 
     function scyToAssetUp(SCYIndex index, uint256 scyAmount)
         internal
@@ -41,7 +48,7 @@ library SCYIndexLib {
         returns (uint256)
     {
         uint256 _index = SCYIndex.unwrap(index);
-        return SCYUtils.scyToAsset(_index, scyAmount)+  _index.rawDivUp(SCYUtils.ONE);
+        return SCYUtils.scyToAssetUp(_index, scyAmount);
     }
 
     function scyToAsset(SCYIndex index, int256 scyAmount)

package/contracts/libraries/SCY/SCYUtils.sol

@@ -8,6 +8,14 @@ library SCYUtils {
         return (scyAmount * exchangeRate) / ONE;
     }
 
+    function scyToAssetUp(uint256 exchangeRate, uint256 scyAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return (scyAmount * exchangeRate + ONE - 1) / ONE;
+    }
+
     function assetToScy(uint256 exchangeRate, uint256 assetAmount)
         internal
         pure
@@ -15,4 +23,12 @@ library SCYUtils {
     {
         return (assetAmount * ONE) / exchangeRate;
     }
+
+    function assetToScyUp(uint256 exchangeRate, uint256 assetAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return (assetAmount * ONE + exchangeRate - 1) / exchangeRate;
+    }
 }

package/contracts/libraries/math/MarketMathCore.sol

@@ -57,7 +57,7 @@ library MarketMathCore {
         SCYIndex index,
         uint256 scyDesired,
         uint256 ptDesired,
-        bool updateState
+        uint256 blockTime
     )
         internal
         pure
@@ -73,7 +73,7 @@ library MarketMathCore {
             int256 _lpToAccount,
             int256 _scyUsed,
             int256 _otUsed
-        ) = addLiquidityCore(market, index, scyDesired.Int(), ptDesired.Int(), updateState);
+        ) = addLiquidityCore(market, index, scyDesired.Int(), ptDesired.Int(), blockTime);
 
         lpToReserve = _lpToReserve.Uint();
         lpToAccount = _lpToAccount.Uint();
@@ -81,15 +81,14 @@ library MarketMathCore {
         ptUsed = _otUsed.Uint();
     }
 
-    function removeLiquidity(
-        MarketState memory market,
-        uint256 lpToRemove,
-        bool updateState
-    ) internal pure returns (uint256 scyToAccount, uint256 netPtToAccount) {
+    function removeLiquidity(MarketState memory market, uint256 lpToRemove)
+        internal
+        pure
+        returns (uint256 scyToAccount, uint256 netPtToAccount)
+    {
         (int256 _scyToAccount, int256 _ptToAccount) = removeLiquidityCore(
             market,
-            lpToRemove.Int(),
-            updateState
+            lpToRemove.Int()
         );
 
         scyToAccount = _scyToAccount.Uint();
@@ -139,7 +138,7 @@ library MarketMathCore {
         SCYIndex index,
         int256 scyDesired,
         int256 ptDesired,
-        bool updateState
+        uint256 blockTime
     )
         internal
         pure
@@ -154,6 +153,7 @@ library MarketMathCore {
         /// CHECKS
         /// ------------------------------------------------------------
         require(scyDesired > 0 && ptDesired > 0, "ZERO_AMOUNTS");
+        require(!MiniHelpers.isExpired(market.expiry, blockTime), "market expired");
 
         /// ------------------------------------------------------------
         /// MATH
@@ -182,18 +182,16 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
-        if (updateState) {
-            market.totalScy += scyUsed;
-            market.totalPt += ptUsed;
-            market.totalLp += lpToAccount + lpToReserve;
-        }
+        market.totalScy += scyUsed;
+        market.totalPt += ptUsed;
+        market.totalLp += lpToAccount + lpToReserve;
     }
 
-    function removeLiquidityCore(
-        MarketState memory market,
-        int256 lpToRemove,
-        bool updateState
-    ) internal pure returns (int256 netScyToAccount, int256 netPtToAccount) {
+    function removeLiquidityCore(MarketState memory market, int256 lpToRemove)
+        internal
+        pure
+        returns (int256 netScyToAccount, int256 netPtToAccount)
+    {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
@@ -209,11 +207,9 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
-        if (updateState) {
-            market.totalLp = market.totalLp.subNoNeg(lpToRemove);
-            market.totalPt = market.totalPt.subNoNeg(netPtToAccount);
-            market.totalScy = market.totalScy.subNoNeg(netScyToAccount);
-        }
+        market.totalLp = market.totalLp.subNoNeg(lpToRemove);
+        market.totalPt = market.totalPt.subNoNeg(netPtToAccount);
+        market.totalScy = market.totalScy.subNoNeg(netScyToAccount);
     }
 
     function executeTradeCore(

package/contracts/libraries/math/Math.sol

@@ -59,11 +59,6 @@ library Math {
         }
     }
 
-    function rawDivUp(uint256 a, uint256 b) internal pure returns (uint256) {
-        require(b != 0, "divide by zero");
-        return (a + b - 1) / b;
-    }
-
     function abs(int256 x) internal pure returns (uint256) {
         return uint256(x > 0 ? x : -x);
     }

package/contracts/offchain-helpers/RouterStatic.sol

@@ -7,6 +7,7 @@ import "../interfaces/IPRouterStatic.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IPYieldContractFactory.sol";
 import "../interfaces/IPMarketFactory.sol";
+import "../libraries/math/MarketApproxLib.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
@@ -14,12 +15,22 @@ import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 /// EXCLUDED FROM ALL AUDITS, TO BE CALLED ONLY BY PENDLE's SDK
 contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, OwnableUpgradeable {
     using MarketMathCore for MarketState;
+    using MarketApproxLib for MarketState;
     using Math for uint256;
     using Math for int256;
     using LogExpMath for int256;
+    using SCYIndexLib for SCYIndex;
 
     IPYieldContractFactory public immutable yieldContractFactory;
     IPMarketFactory public immutable marketFactory;
+    ApproxParams public approxParams =
+        ApproxParams({
+            guessMin: 0,
+            guessMax: type(uint256).max,
+            guessOffchain: 0,
+            maxIteration: 256,
+            eps: 1e15
+        });
 
     constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory)
         initializer
@@ -151,7 +162,7 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
             scyIndex(market),
             scyDesired,
             ptDesired,
-            false
+            block.timestamp
         );
     }
 
@@ -161,10 +172,10 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
         returns (uint256 netScyOut, uint256 netPtOut)
     {
         MarketState memory state = IPMarket(market).readState(false);
-        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove, false);
+        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove);
     }
 
-    function swapPtForScyStatic(address market, uint256 exactPtIn)
+    function swapExactPtForScyStatic(address market, uint256 exactPtIn)
         external
         view
         returns (uint256 netScyOut, uint256 netScyFee)
@@ -177,7 +188,7 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
         );
     }
 
-    function swapScyForPtStatic(address market, uint256 exactPtOut)
+    function swapScyForExactPtStatic(address market, uint256 exactPtOut)
         external
         view
         returns (uint256 netScyIn, uint256 netScyFee)
@@ -190,8 +201,110 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
         );
     }
 
+    function swapExactScyForPtStatic(address market, uint256 exactScyIn)
+        external
+        view
+        returns (uint256 netPtOut, uint256 netScyFee)
+    {
+        MarketState memory state = IPMarket(market).readState(false);
+        (netPtOut, , netScyFee) = state.approxSwapExactScyForPt(
+            scyIndex(market),
+            exactScyIn,
+            block.timestamp,
+            approxParams
+        );
+    }
+
+    function swapScyForExactYtStatic(address market, uint256 exactYtOut)
+        external
+        view
+        returns (uint256 netScyIn, uint256 netScyFee)
+    {
+        MarketState memory state = IPMarket(market).readState(false);
+
+        SCYIndex index = scyIndex(market);
+
+        uint256 scyReceived;
+        (scyReceived, netScyFee) = state.swapExactPtForScy(
+            scyIndex(market),
+            exactYtOut,
+            block.timestamp
+        );
+
+        uint256 totalScyNeed = index.assetToScyUp(exactYtOut);
+        netScyIn = totalScyNeed.subMax0(scyReceived);
+    }
+
+    function swapExactScyForYtStatic(address market, uint256 exactScyIn)
+        external
+        view
+        returns (uint256 netYtOut, uint256 netScyFee)
+    {
+        MarketState memory state = IPMarket(market).readState(false);
+        SCYIndex index = scyIndex(market);
+
+        (netYtOut, , netScyFee) = state.approxSwapExactScyForYt(
+            index,
+            exactScyIn,
+            block.timestamp,
+            approxParams
+        );
+    }
+
+    function swapExactYtForScyStatic(address market, uint256 exactYtIn)
+        external
+        view
+        returns (uint256 netScyOut, uint256 netScyFee)
+    {
+        MarketState memory state = IPMarket(market).readState(false);
+
+        SCYIndex index = scyIndex(market);
+
+        uint256 scyOwed;
+        (scyOwed, netScyFee) = state.swapScyForExactPt(index, exactYtIn, block.timestamp);
+
+        uint256 amountPYToRepayScyOwed = index.scyToAssetUp(scyOwed);
+        uint256 amountPYToRedeemScyOut = exactYtIn - amountPYToRepayScyOwed;
+
+        netScyOut = index.assetToScy(amountPYToRedeemScyOut);
+    }
+
+    function swapYtForExactScyStatic(address market, uint256 exactScyOut)
+        external
+        view
+        returns (uint256 netYtIn, uint256 netScyFee)
+    {
+        MarketState memory state = IPMarket(market).readState(false);
+
+        SCYIndex index = scyIndex(market);
+
+        (netYtIn, , netScyFee) = state.approxSwapYtForExactScy(
+            index,
+            exactScyOut,
+            block.timestamp,
+            approxParams
+        );
+    }
+
     // ============= OTHER HELPERS =============
 
+    function previewMintPY(address YT, uint256 amountScyToMint)
+        external
+        returns (uint256 amountPY)
+    {
+        IPYieldToken _YT = IPYieldToken(YT);
+        require(!_YT.isExpired(), "YT is expired");
+        return amountScyToMint.mulDown(_YT.scyIndexCurrent());
+    }
+
+    function previewRedeemPY(address YT, uint256 amountPYToRedeem)
+        external
+        returns (uint256 amountPY)
+    {
+        IPYieldToken _YT = IPYieldToken(YT);
+        return amountPYToRedeem.divDown(_YT.scyIndexCurrent());
+    }
+
     function scyIndex(address market) public view returns (SCYIndex index) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
@@ -215,6 +328,25 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
         return lnImpliedRate.exp();
     }
 
+    function getExchangeRate(address market) public view returns (uint256) {
+        MarketState memory state = IPMarket(market).readState(false);
+        MarketPreCompute memory comp = state.getMarketPreCompute(
+            scyIndex(market),
+            block.timestamp
+        );
+
+        return
+            MarketMathCore
+                ._getExchangeRate(
+                    state.totalPt,
+                    comp.totalAsset,
+                    comp.rateScalar,
+                    comp.rateAnchor,
+                    0
+                )
+                .Uint();
+    }
+
     function getUserPYInfo(address py, address user)
         public
         view
@@ -255,7 +387,7 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
         userMarketInfo.market = market;
         userMarketInfo.lpBalance = userLp;
 
-        MarketState memory state = _market.readState(true);
+        MarketState memory state = _market.readState(false);
         uint256 totalLp = uint256(state.totalLp);
         uint256 userPt = (userLp * uint256(state.totalPt)) / totalLp;
         uint256 userScy = (userLp * uint256(state.totalScy)) / totalLp;

package/deployments/43113-core.json

@@ -2,15 +2,15 @@
     "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
     "network": 43113,
     "celerBus": "0xE9533976C590200E32d95C53f06AE12d292cFc47",
-    "treasury": "0xeEb65778Aa8866163d28ea0fF6Dc68826C722aeD",
-    "governanceManager": "0x8C7e949dDFA8549ddBC418Bf66135367Ec33e230",
-    "PENDLE": "0x49a61480e7C8E08EF6e5c52411396310B9257b11",
-    "yieldContractFactory": "0xa611Ecc96c2E59406a58115F08AaCeD05b60bB6b",
-    "marketFactory": "0xbb1aD0bd2A7cC4d1eB08A563670d2aC819b39d83",
-    "router": "0xc443267dC61Fda10f523795f70dB505E624caC82",
-    "routerStatic": "0xEE3cE0bFC2b0175Dd9CCC788E39f4952463b8b7a",
+    "treasury": "0xf176fB51F4eB826136a54FDc71C50fCd2202E272",
+    "governanceManager": "0x0A60B5D39b27E18F63aa937aD09Acc2B3d46d2a1",
+    "PENDLE": "0x519f3907379491c291Cf7b98425F35036a698080",
+    "yieldContractFactory": "0x2ff0de5593c85e0609675d07A6a33093A3838b17",
+    "marketFactory": "0x30340f337C27768e84CA5E957Fb22dcBF95857cD",
+    "router": "0xFEdBED4682D136925d30FFb9B8977CC9b3a6c406",
+    "routerStatic": "0xc49d8fdA920a46B21E1821780238f9E7A0de68df",
     "startTime": 1657756800,
-    "vePendle": "0x47797F05f96532070E6A3D0125b2242FA869F8a9",
-    "votingController": "0xF89b549dF09ee805FC59F80bD333D8145e14480a",
-    "gaugeController": "0x7F21fa9108Ef12CDd7bFF026f26a95D6e17C5dA8"
+    "vePendle": "0x7786729eEe8b9d30fE7d91fDFf23A0f1D0C615D9",
+    "votingController": "0x1001940C59e87AdfdB9f3b50aec5232c59d40Bc4",
+    "gaugeController": "0x3d47dBfB525cf8869B8c266a4c42E2c128F5639C"
 }

package/deployments/43113-markets/benqi-market-0x9f080Af83E84099ED92b1b9b4B4BbE4400f2A3CB.json

@@ -0,0 +1,7 @@
+{
+    "SCY": "0x0acd905cCecd83505455701Eca4Efd92F232D007",
+    "expiry": 1673308800,
+    "PT": "0x132dc1190DFa55895d6F75C0720Da800AF424b81",
+    "YT": "0xC1ea94221d74c45695Fbc7867640F10DaE4E7e7d",
+    "market": "0x9f080Af83E84099ED92b1b9b4B4BbE4400f2A3CB"
+}

package/deployments/80001-core.json

@@ -2,14 +2,14 @@
     "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
     "network": 80001,
     "celerBus": "0x7d43AABC515C356145049227CeE54B608342c0ad",
-    "treasury": "0x28FcFb63c8ab55E3710e51441d003318eE235FE8",
-    "governanceManager": "0x27FaF900007B4cBa7803000251ec96Bc69ff1BEa",
-    "PENDLE": "0x8553e57B13aECb9704Be27d7BF0067211dEaed00",
-    "yieldContractFactory": "0xE6DD1433d59B2eaf26E7B2107c574d3c3299023e",
-    "marketFactory": "0x191c677bc1d2BbcBfa99fd68b34ed4fb2E157eFD",
-    "router": "0xCd6fC1E4f430976fB5c20E747f861E6bd14454d4",
-    "routerStatic": "0xeb83006b0aADdD15AD8AFbebE2f4e0937f210673",
+    "treasury": "0xFF4a4515888AEf82C9557A56E37A55a5dDe6EFF1",
+    "governanceManager": "0xE4a112A028D93e9E9b207eBedB1e1D6Cf5FdCEe9",
+    "PENDLE": "0x6D998d832b82f6307c5a2592d59A4cba7f15167f",
+    "yieldContractFactory": "0x058Ceec78EB7F854daBfdDd894e841423Ca344c3",
+    "marketFactory": "0xD33F62424acC95704D43E725B11b9e770505B425",
+    "router": "0x24d7CEaFBA7c7b32BE200aD6dA38C03797F0611f",
+    "routerStatic": "0x9902C57F6bc1e7737238777Fc52dA8A2161759f7",
     "startTime": 1657756800,
-    "vePendle": "0xd160cd8eeb79F976d6f08EaeAA3C93612D543c2c",
-    "gaugeController": "0x52dFCD0b5DCaa16E697de2cc4A1F404DDC41fC42"
+    "vePendle": "0x1b615005157B9B0DDc7c0Af817f4A570cE3b591e",
+    "gaugeController": "0x3663E54bf1334B60FC97d3781460Bcf73d008116"
 }

package/deployments/80001-markets/benqi-market-0x78699fa58C484e9867B8047A12E959ccB8BaD90E.json

@@ -0,0 +1,7 @@
+{
+    "SCY": "0x9Bdb1dfD15D9051D127c3cD6882e194cA1c89e56",
+    "expiry": 1673308800,
+    "PT": "0x36b83a38f5073Ef53EaaC74F2C6F29cC346f3a61",
+    "YT": "0x376F7aEE5e3C2Ba02CB53122e0c7D9E4FEd65801",
+    "market": "0x78699fa58C484e9867B8047A12E959ccB8BaD90E"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.8.0-beta",
+  "version": "0.8.0-beta-2",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/deployments/43113-markets/benqi-market-0xF3150c14F776c50C9D397054d38979c7B77FC41D.json

@@ -1,7 +0,0 @@
-{
-    "SCY": "0x9a337ff76905e00167D8d15008C3537a89a278B7",
-    "expiry": 1673308800,
-    "PT": "0x697cB12b2e7545568bBF7aea138A2D44073F4E80",
-    "YT": "0x35f41D2adEc7E478F3559Da69E64f8ab47637ecd",
-    "market": "0xF3150c14F776c50C9D397054d38979c7B77FC41D"
-}

package/deployments/80001-markets/benqi-market-0x150b6eb90Bf636eC0c4328d13d1e1d4adDBAF904.json

@@ -1,7 +0,0 @@
-{
-    "SCY": "0x0F23e2c274a97E39813080a09D9F3E87d4d83116",
-    "expiry": 1673308800,
-    "PT": "0x3B5df4C6E9deC89350389a48ad0354422D1Ef2a1",
-    "YT": "0xFcd43fE1E9E48681B222d9a0861da82ea41fAA8A",
-    "market": "0x150b6eb90Bf636eC0c4328d13d1e1d4adDBAF904"
-}