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

package/contracts/libraries/math/MarketApproxLib.sol

@@ -39,6 +39,7 @@ library MarketApproxLib {
     struct VarsSwapPtForExactScy {
         uint256 netPtInGuess;
         int256 assetToAccount;
+        int256 assetToReserve;
         uint256 netAssetOut;
         uint256 minAssetOut;
         uint256 largestGoodSlope;
@@ -58,7 +59,8 @@ library MarketApproxLib {
         pure
         returns (
             uint256, /*netPtIn*/
-            uint256 /*netScyOut*/
+            uint256, /*netScyOut*/
+            uint256 /*netScyToReserve*/
         )
     {
         /*
@@ -81,9 +83,8 @@ library MarketApproxLib {
         VarsSwapPtForExactScy memory vars;
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
-        if (approx.guessMax == type(uint256).max) {
-            approx.guessMax = calcMaxPtIn(market.totalPt, comp.totalAsset);
-        }
+        if (approx.guessMax == type(uint256).max) approx.guessMax = calcMaxPtIn(comp.totalAsset);
+
         vars.minAssetOut = index.scyToAsset(minScyOut);
 
         for (uint256 iter = 0; iter < approx.maxIteration; ) {
@@ -100,7 +101,10 @@ library MarketApproxLib {
                 continue;
             }
 
-            (vars.assetToAccount, ) = market.calcTrade(comp, vars.netPtInGuess.neg());
+            (vars.assetToAccount, vars.assetToReserve) = market.calcTrade(
+                comp,
+                vars.netPtInGuess.neg()
+            );
             vars.netAssetOut = vars.assetToAccount.Uint();
 
             if (vars.netAssetOut >= vars.minAssetOut) {
@@ -111,7 +115,11 @@ library MarketApproxLib {
                     approx.eps
                 );
                 if (isAnswerAccepted)
-                    return (vars.netPtInGuess, index.assetToScy(vars.netAssetOut));
+                    return (
+                        vars.netPtInGuess,
+                        index.assetToScy(vars.netAssetOut),
+                        index.assetToScy(vars.assetToReserve.Uint())
+                    );
             } else {
                 approx.guessMin = vars.netPtInGuess;
             }
@@ -126,6 +134,7 @@ library MarketApproxLib {
     struct VarsSwapExactScyForYt {
         uint256 ptInGuess;
         int256 assetToAccount;
+        int256 assetToReserve;
         uint256 netAssetOut;
         uint256 amountAssetNeedMore;
         uint256 largestGoodSlope;
@@ -145,7 +154,8 @@ library MarketApproxLib {
         pure
         returns (
             uint256, /*netYtOut*/
-            uint256 /*netScyIn*/
+            uint256, /*netScyIn*/
+            uint256
         )
     {
         /*
@@ -174,9 +184,7 @@ library MarketApproxLib {
         VarsSwapExactScyForYt memory vars;
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
 
-        if (approx.guessMax == type(uint256).max) {
-            approx.guessMax = calcMaxPtIn(market.totalPt, comp.totalAsset);
-        }
+        if (approx.guessMax == type(uint256).max) approx.guessMax = calcMaxPtIn(comp.totalAsset);
 
         vars.maxAssetIn = index.scyToAsset(maxScyIn);
 
@@ -195,7 +203,10 @@ library MarketApproxLib {
                 continue;
             }
 
-            (vars.assetToAccount, ) = market.calcTrade(comp, vars.ptInGuess.neg());
+            (vars.assetToAccount, vars.assetToReserve) = market.calcTrade(
+                comp,
+                vars.ptInGuess.neg()
+            );
             vars.netAssetOut = vars.assetToAccount.Uint();
             vars.amountAssetNeedMore = vars.ptInGuess - vars.netAssetOut;
 
@@ -207,7 +218,11 @@ library MarketApproxLib {
                     approx.eps
                 );
                 if (isAnswerAccepted)
-                    return (vars.ptInGuess, index.assetToScy(vars.amountAssetNeedMore));
+                    return (
+                        vars.ptInGuess,
+                        index.assetToScy(vars.amountAssetNeedMore),
+                        index.assetToScy(vars.assetToReserve.Uint())
+                    );
             } else {
                 approx.guessMax = vars.ptInGuess - 1;
             }
@@ -219,6 +234,14 @@ library MarketApproxLib {
         revert("approx fail");
     }
 
+    struct VarsSwapExactScyForPt {
+        uint256 maxAssetIn;
+        uint256 ptOutGuess;
+        int256 assetToAccount;
+        int256 assetToReserve;
+        uint256 netAssetIn;
+    }
+
     function approxSwapExactScyForPt(
         MarketState memory market,
         SCYIndex index,
@@ -230,7 +253,8 @@ library MarketApproxLib {
         pure
         returns (
             uint256, /*netPtOut*/
-            uint256 /*netScyIn*/
+            uint256, /*netScyIn*/
+            uint256
         )
     {
         /*
@@ -251,24 +275,37 @@ library MarketApproxLib {
 
         require(isValidApproxParams(approx), "invalid approx approx");
 
+        VarsSwapExactScyForPt memory vars;
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessMax == type(uint256).max) {
             approx.guessMax = calcMaxPtOut(market.totalPt, comp);
         }
 
-        uint256 maxAssetIn = index.scyToAsset(maxScyIn);
+        vars.maxAssetIn = index.scyToAsset(maxScyIn);
 
         for (uint256 iter = 0; iter < approx.maxIteration; ) {
-            uint256 ptOutGuess = getCurrentGuess(iter, approx);
-            (int256 assetToAccount, ) = market.calcTrade(comp, ptOutGuess.Int());
-            uint256 netAssetIn = assetToAccount.abs();
-
-            if (netAssetIn <= maxAssetIn) {
-                approx.guessMin = ptOutGuess;
-                bool isAnswerAccepted = Math.isASmallerApproxB(netAssetIn, maxAssetIn, approx.eps);
-                if (isAnswerAccepted) return (ptOutGuess, index.assetToScy(netAssetIn));
+            vars.ptOutGuess = getCurrentGuess(iter, approx);
+            (vars.assetToAccount, vars.assetToReserve) = market.calcTrade(
+                comp,
+                vars.ptOutGuess.Int()
+            );
+            vars.netAssetIn = vars.assetToAccount.abs();
+
+            if (vars.netAssetIn <= vars.maxAssetIn) {
+                approx.guessMin = vars.ptOutGuess;
+                bool isAnswerAccepted = Math.isASmallerApproxB(
+                    vars.netAssetIn,
+                    vars.maxAssetIn,
+                    approx.eps
+                );
+                if (isAnswerAccepted)
+                    return (
+                        vars.ptOutGuess,
+                        index.assetToScy(vars.netAssetIn),
+                        index.assetToScy(vars.assetToReserve.Uint())
+                    );
             } else {
-                approx.guessMax = ptOutGuess;
+                approx.guessMax = vars.ptOutGuess;
             }
 
             unchecked {
@@ -278,6 +315,15 @@ library MarketApproxLib {
         revert("approx fail");
     }
 
+    struct VarsSwapYtForExactScy {
+        uint256 minAssetOut;
+        uint256 ptOutGuess;
+        int256 assetToAccount;
+        int256 assetToReserve;
+        uint256 netAssetOwed;
+        uint256 netAssetOut;
+    }
+
     function approxSwapYtForExactScy(
         MarketState memory market,
         SCYIndex index,
@@ -289,7 +335,8 @@ library MarketApproxLib {
         pure
         returns (
             uint256, /*netYtIn*/
-            uint256 /*netScyOut*/
+            uint256, /*netScyOut*/
+            uint256
         )
     {
         /*
@@ -315,32 +362,40 @@ library MarketApproxLib {
 
         require(isValidApproxParams(approx), "invalid approx approx");
 
+        VarsSwapYtForExactScy memory vars;
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessMax == type(uint256).max) {
             approx.guessMax = calcMaxPtOut(market.totalPt, comp);
         }
 
-        uint256 minAssetOut = index.scyToAsset(minScyOut);
+        vars.minAssetOut = index.scyToAsset(minScyOut);
 
         for (uint256 iter = 0; iter < approx.maxIteration; ) {
             // ytInGuess = ptOutGuess
-            uint256 ptOutGuess = getCurrentGuess(iter, approx);
+            vars.ptOutGuess = getCurrentGuess(iter, approx);
 
-            (int256 assetToAccount, ) = market.calcTrade(comp, ptOutGuess.Int());
-            uint256 netAssetOwed = assetToAccount.abs();
+            (vars.assetToAccount, vars.assetToReserve) = market.calcTrade(
+                comp,
+                vars.ptOutGuess.Int()
+            );
+            vars.netAssetOwed = vars.assetToAccount.abs();
 
             // since ptOutGuess is between guessMin & guessMax, it's guaranteed that
             // there are enough Yt to pair with ptOut
 
-            uint256 netAssetOut = ptOutGuess - netAssetOwed;
+            vars.netAssetOut = vars.ptOutGuess - vars.netAssetOwed;
 
-            if (netAssetOut >= minAssetOut) {
-                approx.guessMax = ptOutGuess;
-                if (Math.isAGreaterApproxB(netAssetOut, minAssetOut, approx.eps)) {
-                    return (ptOutGuess, index.assetToScy(netAssetOut));
+            if (vars.netAssetOut >= vars.minAssetOut) {
+                approx.guessMax = vars.ptOutGuess;
+                if (Math.isAGreaterApproxB(vars.netAssetOut, vars.minAssetOut, approx.eps)) {
+                    return (
+                        vars.ptOutGuess,
+                        index.assetToScy(vars.netAssetOut),
+                        index.assetToScy(vars.assetToReserve.Uint())
+                    );
                 }
             } else {
-                approx.guessMin = ptOutGuess + 1;
+                approx.guessMin = vars.ptOutGuess + 1;
             }
 
             unchecked {
@@ -403,8 +458,8 @@ library MarketApproxLib {
         return (maxPtOut.Uint() * 999) / 1000;
     }
 
-    function calcMaxPtIn(int256 totalPt, int256 totalAsset) internal pure returns (uint256) {
-        return Math.min(totalPt, totalAsset).Uint() - 1;
+    function calcMaxPtIn(int256 totalAsset) internal pure returns (uint256) {
+        return totalAsset.Uint() - 1;
     }
 
     function isValidApproxParams(ApproxParams memory approx) internal pure returns (bool) {

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,13 +59,6 @@ library Math {
         }
     }
 
-    function rawDivUp(uint256 a, uint256 b) internal pure returns (uint256) {
-        if (a == 0) return 0;
-        else {
-            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
@@ -43,7 +54,7 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
             RewardIndex[] memory rewardIndexes
         )
     {
-        (address yt, ) = getPY(py);
+        (, address yt) = getPY(py);
         IPYieldToken YT = IPYieldToken(yt);
         exchangeRate = YT.scyIndexCurrent();
         totalSupply = YT.totalSupply();
@@ -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,12 +328,31 @@ 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
         returns (UserPYInfo memory userPYInfo)
     {
-        (userPYInfo.yt, userPYInfo.pt) = getPY(py);
+        (userPYInfo.pt, userPYInfo.yt) = getPY(py);
         IPYieldToken YT = IPYieldToken(userPYInfo.yt);
         userPYInfo.ytBalance = YT.balanceOf(user);
         userPYInfo.ptBalance = IPPrincipalToken(userPYInfo.pt).balanceOf(user);
@@ -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": "0x8c73eEef8A74223717c129e6F18Df27508dbCb23",
-    "governanceManager": "0xe8d12F4e6933107C797E369Dd577bfca9f412758",
-    "PENDLE": "0xd6403Ff542290C38EE4fCFf48552FA85fbe8539B",
-    "yieldContractFactory": "0x0EA46a4C257071352b57E9F6d054fC137F6E14b9",
-    "marketFactory": "0x9e7be80205815111617B9578157e130ECd9757e4",
-    "router": "0xb359F0A97Ca269Ae5574dc75be48b0e81eFD1dA2",
-    "routerStatic": "0x860D23ADA1652CEEE1e3c77210CCE068bB4BD4e1",
-    "startTime": 1656547200,
-    "vePendle": "0x5CA98fBE317f0165499E886286A2737FE5A913E7",
-    "votingController": "0xcb0d3d9147845C7F2B77DCFBE4dB8114d928DC93",
-    "gaugeController": "0x38F5320795CE3BeD55b87decca0A60e52f65c522"
+    "treasury": "0xf176fB51F4eB826136a54FDc71C50fCd2202E272",
+    "governanceManager": "0x0A60B5D39b27E18F63aa937aD09Acc2B3d46d2a1",
+    "PENDLE": "0x519f3907379491c291Cf7b98425F35036a698080",
+    "yieldContractFactory": "0x2ff0de5593c85e0609675d07A6a33093A3838b17",
+    "marketFactory": "0x30340f337C27768e84CA5E957Fb22dcBF95857cD",
+    "router": "0xFEdBED4682D136925d30FFb9B8977CC9b3a6c406",
+    "routerStatic": "0xc49d8fdA920a46B21E1821780238f9E7A0de68df",
+    "startTime": 1657756800,
+    "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": "0x3865D8a1Bd6D281f6c77d4e233d26Cd56380EF45",
-    "governanceManager": "0xFC7eC014280A98850F4167aF47c0272f0E7490A5",
-    "PENDLE": "0x53F435CEC95c597d905f0903a13F4dAbEA8491dB",
-    "yieldContractFactory": "0x4e5De6339FC7Ef63c176f9A7e7a8B2aC21744B8D",
-    "marketFactory": "0xCAd502Bb55d1A3F79952F969BFF3f011CF30a94a",
-    "router": "0xA972fB7828f0bff8a22f7f8C63b17cfB971BFC0a",
-    "routerStatic": "0x9a8Ff151BDA518ece44Cb1125F368F4C893D63b7",
-    "startTime": 1656547200,
-    "vePendle": "0x69A23F16974024A1b6A5362ac2A11BFeEEFd5827",
-    "gaugeController": "0x847da006F940833bB44709CBa241c99e3c531F38"
+    "treasury": "0xFF4a4515888AEf82C9557A56E37A55a5dDe6EFF1",
+    "governanceManager": "0xE4a112A028D93e9E9b207eBedB1e1D6Cf5FdCEe9",
+    "PENDLE": "0x6D998d832b82f6307c5a2592d59A4cba7f15167f",
+    "yieldContractFactory": "0x058Ceec78EB7F854daBfdDd894e841423Ca344c3",
+    "marketFactory": "0xD33F62424acC95704D43E725B11b9e770505B425",
+    "router": "0x24d7CEaFBA7c7b32BE200aD6dA38C03797F0611f",
+    "routerStatic": "0x9902C57F6bc1e7737238777Fc52dA8A2161759f7",
+    "startTime": 1657756800,
+    "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"
+}