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

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/Math.sol

@@ -60,10 +60,8 @@ library Math {
     }
 
     function rawDivUp(uint256 a, uint256 b) internal pure returns (uint256) {
-        if (a == 0) return 0;
-        else {
-            return (a + b - 1) / b;
-        }
+        require(b != 0, "divide by zero");
+        return (a + b - 1) / b;
     }
 
     function abs(int256 x) internal pure returns (uint256) {

package/contracts/offchain-helpers/RouterStatic.sol

@@ -7,11 +7,12 @@ import "../interfaces/IPRouterStatic.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IPYieldContractFactory.sol";
 import "../interfaces/IPMarketFactory.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
 /// EXCLUDED FROM ALL AUDITS, TO BE CALLED ONLY BY PENDLE's SDK
-contract RouterStatic is IPRouterStatic {
+contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, OwnableUpgradeable {
     using MarketMathCore for MarketState;
     using Math for uint256;
     using Math for int256;
@@ -20,17 +21,125 @@ contract RouterStatic is IPRouterStatic {
     IPYieldContractFactory public immutable yieldContractFactory;
     IPMarketFactory public immutable marketFactory;
 
-    constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory) {
+    constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory)
+        initializer
+    {
         yieldContractFactory = _yieldContractFactory;
         marketFactory = _marketFactory;
     }
 
+    function initialize() external initializer {
+        __UUPSUpgradeable_init();
+        __Ownable_init();
+    }
+
+    // ============= SYSTEM INFO =============
+
+    function getPYInfo(address py)
+        external
+        returns (
+            uint256 exchangeRate,
+            uint256 totalSupply,
+            RewardIndex[] memory rewardIndexes
+        )
+    {
+        (, address yt) = getPY(py);
+        IPYieldToken YT = IPYieldToken(yt);
+        exchangeRate = YT.scyIndexCurrent();
+        totalSupply = YT.totalSupply();
+        address[] memory rewardTokens = YT.getRewardTokens();
+        rewardIndexes = new RewardIndex[](rewardTokens.length);
+
+        uint256[] memory indexes = YT.rewardIndexesCurrent();
+        for (uint256 i = 0; i < rewardTokens.length; ++i) {
+            address rewardToken = rewardTokens[i];
+            rewardIndexes[i].rewardToken = rewardToken;
+            rewardIndexes[i].index = indexes[i];
+        }
+    }
+
+    function getPendleTokenType(address token)
+        external
+        view
+        returns (
+            bool isPT,
+            bool isYT,
+            bool isMarket
+        )
+    {
+        if (yieldContractFactory.isPT(token)) isPT = true;
+        else if (yieldContractFactory.isYT(token)) isYT = true;
+        else if (marketFactory.isValidMarket(token)) isMarket = true;
+    }
+
+    function getMarketInfo(address market)
+        external
+        view
+        returns (
+            address pt,
+            address scy,
+            MarketState memory state,
+            int256 impliedYield
+        )
+    {
+        IPMarket _market = IPMarket(market);
+        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+
+        pt = address(PT);
+        scy = address(SCY);
+        state = _market.readState(true);
+        impliedYield = getPtImpliedYield(market);
+    }
+
+    // ============= USER INFO =============
+
+    function getUserPYPositionsByPYs(address user, address[] calldata pys)
+        external
+        view
+        returns (UserPYInfo[] memory userPYPositions)
+    {
+        userPYPositions = new UserPYInfo[](pys.length);
+        for (uint256 i = 0; i < pys.length; ++i) {
+            userPYPositions[i] = getUserPYInfo(pys[i], user);
+        }
+    }
+
+    function getUserMarketPositions(address user, address[] calldata markets)
+        external
+        view
+        returns (UserMarketInfo[] memory userMarketPositions)
+    {
+        userMarketPositions = new UserMarketInfo[](markets.length);
+        for (uint256 i = 0; i < markets.length; ++i) {
+            userMarketPositions[i] = getUserMarketInfo(markets[i], user);
+        }
+    }
+
+    function getUserSCYInfo(address scy, address user)
+        external
+        view
+        returns (uint256 balance, TokenAmount[] memory rewards)
+    {
+        ISuperComposableYield SCY = ISuperComposableYield(scy);
+        balance = SCY.balanceOf(scy);
+        address[] memory rewardTokens = SCY.getRewardTokens();
+        rewards = new TokenAmount[](rewardTokens.length);
+        for (uint256 i = 0; i < rewardTokens.length; ++i) {
+            address rewardToken = rewardTokens[i];
+            rewards[i].token = rewardToken;
+            (, rewards[i].amount) = IRewardManager(scy).userReward(rewardToken, user);
+        }
+    }
+
+    // ============= MARKET ACTIONS =============
+
     function addLiquidityStatic(
         address market,
         uint256 scyDesired,
         uint256 ptDesired
     )
         external
+        view
         returns (
             uint256 netLpOut,
             uint256 scyUsed,
@@ -57,6 +166,7 @@ contract RouterStatic is IPRouterStatic {
 
     function swapPtForScyStatic(address market, uint256 exactPtIn)
         external
+        view
         returns (uint256 netScyOut, uint256 netScyFee)
     {
         MarketState memory state = IPMarket(market).readState(false);
@@ -69,6 +179,7 @@ contract RouterStatic is IPRouterStatic {
 
     function swapScyForPtStatic(address market, uint256 exactPtOut)
         external
+        view
         returns (uint256 netScyIn, uint256 netScyFee)
     {
         MarketState memory state = IPMarket(market).readState(false);
@@ -79,12 +190,24 @@ contract RouterStatic is IPRouterStatic {
         );
     }
 
+    // ============= OTHER HELPERS =============
+
     function scyIndex(address market) public view returns (SCYIndex index) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
         return SCYIndexLib.newIndex(SCY);
     }
 
+    function getPY(address py) public view returns (address pt, address yt) {
+        if (yieldContractFactory.isYT(py)) {
+            pt = IPYieldToken(py).PT();
+            yt = py;
+        } else {
+            pt = py;
+            yt = IPPrincipalToken(py).YT();
+        }
+    }
+
     function getPtImpliedYield(address market) public view returns (int256) {
         MarketState memory state = IPMarket(market).readState(false);
 
@@ -92,26 +215,12 @@ contract RouterStatic is IPRouterStatic {
         return lnImpliedRate.exp();
     }
 
-    function getPendleTokenType(address token)
-        external
-        view
-        returns (
-            bool isPT,
-            bool isYT,
-            bool isMarket
-        )
-    {
-        if (yieldContractFactory.isPT(token)) isPT = true;
-        else if (yieldContractFactory.isYT(token)) isYT = true;
-        else if (marketFactory.isValidMarket(token)) isMarket = true;
-    }
-
     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);
@@ -135,119 +244,39 @@ contract RouterStatic is IPRouterStatic {
         }
     }
 
-    function getPYInfo(address py)
-        external
-        returns (
-            uint256 exchangeRate,
-            uint256 totalSupply,
-            RewardIndex[] memory rewardIndexes
-        )
-    {
-        (address yt, ) = getPY(py);
-        IPYieldToken YT = IPYieldToken(yt);
-        exchangeRate = YT.scyIndexCurrent();
-        totalSupply = YT.totalSupply();
-        address[] memory rewardTokens = YT.getRewardTokens();
-        rewardIndexes = new RewardIndex[](rewardTokens.length);
-
-        uint256[] memory indexes = YT.rewardIndexesCurrent();
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address rewardToken = rewardTokens[i];
-            rewardIndexes[i].rewardToken = rewardToken;
-            rewardIndexes[i].index = indexes[i];
-        }
-    }
-
-    function getPY(address py) public view returns (address pt, address yt) {
-        if (yieldContractFactory.isYT(py)) {
-            yt = py;
-            pt = IPYieldToken(py).PT();
-        } else {
-            yt = IPPrincipalToken(py).YT();
-            pt = py;
-        }
-    }
-
-    function getMarketInfo(address market)
-        external
-        view
-        returns (
-            address pt,
-            address scy,
-            MarketState memory state,
-            int256 impliedYield,
-            uint256 exchangeRate
-        )
-    {
-        IPMarket _market = IPMarket(market);
-        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
-
-        pt = address(PT);
-        scy = address(SCY);
-        state = _market.readState(true);
-        impliedYield = getPtImpliedYield(market);
-        exchangeRate = 0; // TODO: get the actual exchange rate
-    }
-
     function getUserMarketInfo(address market, address user)
         public
         view
         returns (UserMarketInfo memory userMarketInfo)
     {
         IPMarket _market = IPMarket(market);
+        uint256 userLp = _market.balanceOf(user);
+
         userMarketInfo.market = market;
-        userMarketInfo.lpBalance = _market.balanceOf(user);
-        // TODO: Is there a way to convert LP to PT and SCY?
-        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        userMarketInfo.lpBalance = userLp;
 
-        userMarketInfo.ptBalance = TokenAmount(address(PT), 0);
-        userMarketInfo.scyBalance = TokenAmount(address(SCY), 0);
-        // TODO: Get this from SCY once it is in the interface
-        userMarketInfo.assetBalance = TokenAmount(address(0), 0);
-    }
+        MarketState memory state = _market.readState(true);
+        uint256 totalLp = uint256(state.totalLp);
+        uint256 userPt = (userLp * uint256(state.totalPt)) / totalLp;
+        uint256 userScy = (userLp * uint256(state.totalScy)) / totalLp;
 
-    function getUserPYPositionsByPYs(address user, address[] calldata pys)
-        external
-        view
-        returns (UserPYInfo[] memory userPYPositions)
-    {
-        userPYPositions = new UserPYInfo[](pys.length);
-        for (uint256 i = 0; i < pys.length; ++i) {
-            userPYPositions[i] = getUserPYInfo(pys[i], user);
-        }
+        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = _market.readTokens();
+        userMarketInfo.ptBalance = TokenAmount(address(PT), userPt);
+        userMarketInfo.scyBalance = TokenAmount(address(SCY), userScy);
+        (userMarketInfo.assetBalance.assetType, userMarketInfo.assetBalance.assetAddress, ) = SCY
+            .assetInfo();
+        userMarketInfo.assetBalance.amount = (userScy * SCY.exchangeRate()) / Math.ONE;
     }
 
-    function getUserMarketPositions(address user, address[] calldata markets)
-        external
-        view
-        returns (UserMarketInfo[] memory userMarketPositions)
-    {
-        userMarketPositions = new UserMarketInfo[](markets.length);
-        for (uint256 i = 0; i < markets.length; ++i) {
-            userMarketPositions[i] = getUserMarketInfo(markets[i], user);
-        }
-    }
-
-    function hasPYPosition(UserPYInfo memory userPYInfo) public pure returns (bool hasPosition) {
+    function hasPYPosition(UserPYInfo calldata userPYInfo) public pure returns (bool hasPosition) {
         hasPosition = (userPYInfo.ytBalance > 0 ||
             userPYInfo.ptBalance > 0 ||
             userPYInfo.unclaimedInterest.amount > 0 ||
             userPYInfo.unclaimedRewards.length > 0);
     }
 
-    function getUserSCYInfo(address scy, address user)
-        external
-        view
-        returns (uint256 balance, TokenAmount[] memory rewards)
-    {
-        ISuperComposableYield SCY = ISuperComposableYield(scy);
-        balance = SCY.balanceOf(scy);
-        address[] memory rewardTokens = SCY.getRewardTokens();
-        rewards = new TokenAmount[](rewardTokens.length);
-        for (uint256 i = 0; i < rewardTokens.length; ++i) {
-            address rewardToken = rewardTokens[i];
-            rewards[i].token = rewardToken;
-            (, rewards[i].amount) = IRewardManager(scy).userReward(rewardToken, user);
-        }
-    }
+    // ============= UPGRADES =============
+
+    // solhint-disable-next-line no-empty-blocks
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 }

package/deployments/43113-core.json

@@ -2,13 +2,15 @@
     "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
     "network": 43113,
     "celerBus": "0xE9533976C590200E32d95C53f06AE12d292cFc47",
-    "treasury": "0x8c73eEef8A74223717c129e6F18Df27508dbCb23",
-    "governanceManager": "0xe8d12F4e6933107C797E369Dd577bfca9f412758",
-    "PENDLE": "0xd6403Ff542290C38EE4fCFf48552FA85fbe8539B",
-    "yieldContractFactory": "0x0EA46a4C257071352b57E9F6d054fC137F6E14b9",
-    "marketFactory": "0x9e7be80205815111617B9578157e130ECd9757e4",
-    "startTime": 1656547200,
-    "vePendle": "0x5CA98fBE317f0165499E886286A2737FE5A913E7",
-    "votingController": "0xcb0d3d9147845C7F2B77DCFBE4dB8114d928DC93",
-    "gaugeController": "0x38F5320795CE3BeD55b87decca0A60e52f65c522"
+    "treasury": "0xeEb65778Aa8866163d28ea0fF6Dc68826C722aeD",
+    "governanceManager": "0x8C7e949dDFA8549ddBC418Bf66135367Ec33e230",
+    "PENDLE": "0x49a61480e7C8E08EF6e5c52411396310B9257b11",
+    "yieldContractFactory": "0xa611Ecc96c2E59406a58115F08AaCeD05b60bB6b",
+    "marketFactory": "0xbb1aD0bd2A7cC4d1eB08A563670d2aC819b39d83",
+    "router": "0xc443267dC61Fda10f523795f70dB505E624caC82",
+    "routerStatic": "0xEE3cE0bFC2b0175Dd9CCC788E39f4952463b8b7a",
+    "startTime": 1657756800,
+    "vePendle": "0x47797F05f96532070E6A3D0125b2242FA869F8a9",
+    "votingController": "0xF89b549dF09ee805FC59F80bD333D8145e14480a",
+    "gaugeController": "0x7F21fa9108Ef12CDd7bFF026f26a95D6e17C5dA8"
 }

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

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

package/deployments/80001-core.json

@@ -2,12 +2,14 @@
     "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
     "network": 80001,
     "celerBus": "0x7d43AABC515C356145049227CeE54B608342c0ad",
-    "treasury": "0x3865D8a1Bd6D281f6c77d4e233d26Cd56380EF45",
-    "governanceManager": "0xFC7eC014280A98850F4167aF47c0272f0E7490A5",
-    "PENDLE": "0x53F435CEC95c597d905f0903a13F4dAbEA8491dB",
-    "yieldContractFactory": "0x4e5De6339FC7Ef63c176f9A7e7a8B2aC21744B8D",
-    "marketFactory": "0xCAd502Bb55d1A3F79952F969BFF3f011CF30a94a",
-    "startTime": 1656547200,
-    "vePendle": "0x69A23F16974024A1b6A5362ac2A11BFeEEFd5827",
-    "gaugeController": "0x847da006F940833bB44709CBa241c99e3c531F38"
+    "treasury": "0x28FcFb63c8ab55E3710e51441d003318eE235FE8",
+    "governanceManager": "0x27FaF900007B4cBa7803000251ec96Bc69ff1BEa",
+    "PENDLE": "0x8553e57B13aECb9704Be27d7BF0067211dEaed00",
+    "yieldContractFactory": "0xE6DD1433d59B2eaf26E7B2107c574d3c3299023e",
+    "marketFactory": "0x191c677bc1d2BbcBfa99fd68b34ed4fb2E157eFD",
+    "router": "0xCd6fC1E4f430976fB5c20E747f861E6bd14454d4",
+    "routerStatic": "0xeb83006b0aADdD15AD8AFbebE2f4e0937f210673",
+    "startTime": 1657756800,
+    "vePendle": "0xd160cd8eeb79F976d6f08EaeAA3C93612D543c2c",
+    "gaugeController": "0x52dFCD0b5DCaa16E697de2cc4A1F404DDC41fC42"
 }