@pendle/core-v2 0.8.0-beta-12 → 0.8.1-gamma

package/contracts/libraries/math/MarketMathCore.sol

@@ -3,7 +3,7 @@ pragma solidity 0.8.15;
 
 import "./Math.sol";
 import "./LogExpMath.sol";
-import "../SCY/SCYIndex.sol";
+import "../helpers/PYIndex.sol";
 import "../helpers/MiniHelpers.sol";
 
 struct MarketState {
@@ -36,7 +36,7 @@ library MarketMathCore {
     using Math for uint256;
     using Math for int256;
     using LogExpMath for int256;
-    using SCYIndexLib for SCYIndex;
+    using PYIndexLib for PYIndex;
 
     int256 internal constant MINIMUM_LIQUIDITY = 10**3;
     int256 internal constant PERCENTAGE_DECIMALS = 100;
@@ -54,7 +54,7 @@ library MarketMathCore {
 
     function addLiquidity(
         MarketState memory market,
-        SCYIndex index,
+        PYIndex index,
         uint256 scyDesired,
         uint256 ptDesired,
         uint256 blockTime
@@ -97,7 +97,7 @@ library MarketMathCore {
 
     function swapExactPtForScy(
         MarketState memory market,
-        SCYIndex index,
+        PYIndex index,
         uint256 exactPtToMarket,
         uint256 blockTime
     ) internal pure returns (uint256 netScyToAccount, uint256 netScyToReserve) {
@@ -114,7 +114,7 @@ library MarketMathCore {
 
     function swapScyForExactPt(
         MarketState memory market,
-        SCYIndex index,
+        PYIndex index,
         uint256 exactPtToAccount,
         uint256 blockTime
     ) internal pure returns (uint256 netScyToMarket, uint256 netScyToReserve) {
@@ -135,7 +135,7 @@ library MarketMathCore {
 
     function addLiquidityCore(
         MarketState memory market,
-        SCYIndex index,
+        PYIndex index,
         int256 scyDesired,
         int256 ptDesired,
         uint256 blockTime
@@ -159,7 +159,9 @@ library MarketMathCore {
         /// MATH
         /// ------------------------------------------------------------
         if (market.totalLp == 0) {
-            lpToAccount = index.scyToAsset(scyDesired).subNoNeg(MINIMUM_LIQUIDITY);
+            lpToAccount =
+                Math.sqrt((index.scyToAsset(scyDesired) * ptDesired).Uint()).Int() -
+                MINIMUM_LIQUIDITY;
             lpToReserve = MINIMUM_LIQUIDITY;
             scyUsed = scyDesired;
             ptUsed = ptDesired;
@@ -214,7 +216,7 @@ library MarketMathCore {
 
     function executeTradeCore(
         MarketState memory market,
-        SCYIndex index,
+        PYIndex index,
         int256 netPtToAccount,
         uint256 blockTime
     ) internal pure returns (int256 netScyToAccount, int256 netScyToReserve) {
@@ -241,12 +243,20 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
-        _setNewMarketStateTrade(market, comp, index, netPtToAccount, netScyToAccount, blockTime);
+        _setNewMarketStateTrade(
+            market,
+            comp,
+            index,
+            netPtToAccount,
+            netScyToAccount,
+            netScyToReserve,
+            blockTime
+        );
     }
 
     function getMarketPreCompute(
         MarketState memory market,
-        SCYIndex index,
+        PYIndex index,
         uint256 blockTime
     ) internal pure returns (MarketPreCompute memory res) {
         require(!MiniHelpers.isExpired(market.expiry, blockTime), "market expired");
@@ -294,16 +304,15 @@ library MarketMathCore {
 
         netAssetToReserve = (fee * market.reserveFeePercent.Int()) / PERCENTAGE_DECIMALS;
         netAssetToAccount = preFeeAssetToAccount - fee;
-        // netAssetToMarket = (preFeeAssetToAccount - fee + netAssetToReserve)
-        //     .neg();
     }
 
     function _setNewMarketStateTrade(
         MarketState memory market,
         MarketPreCompute memory comp,
-        SCYIndex index,
+        PYIndex index,
         int256 netPtToAccount,
         int256 netScyToAccount,
+        int256 netScyToReserve,
         uint256 blockTime
     ) internal pure {
         uint256 timeToExpiry = market.expiry - blockTime;
@@ -311,7 +320,7 @@ library MarketMathCore {
         market.lastTradeTime = blockTime;
 
         market.totalPt = market.totalPt.subNoNeg(netPtToAccount);
-        market.totalScy = market.totalScy.subNoNeg(netScyToAccount);
+        market.totalScy = market.totalScy.subNoNeg(netScyToAccount + netScyToReserve);
 
         market.lastLnImpliedRate = _getLnImpliedRate(
             market.totalPt,
@@ -412,7 +421,7 @@ library MarketMathCore {
 
     function setInitialLnImpliedRate(
         MarketState memory market,
-        SCYIndex index,
+        PYIndex index,
         int256 initialAnchor,
         uint256 blockTime
     ) internal pure {

package/contracts/libraries/math/Math.sol

@@ -59,6 +59,20 @@ library Math {
         }
     }
 
+    // @author Uniswap
+    function sqrt(uint256 y) internal pure returns (uint256 z) {
+        if (y > 3) {
+            z = y;
+            uint256 x = y / 2 + 1;
+            while (x < z) {
+                z = x;
+                x = (y / x + x) / 2;
+            }
+        } else if (y != 0) {
+            z = 1;
+        }
+    }
+
     function abs(int256 x) internal pure returns (uint256) {
         return uint256(x > 0 ? x : -x);
     }

package/contracts/offchain-helpers/RouterStatic.sol

@@ -19,7 +19,8 @@ contract RouterStatic is IPRouterStatic {
     using Math for uint256;
     using Math for int256;
     using LogExpMath for int256;
-    using SCYIndexLib for SCYIndex;
+    using PYIndexLib for PYIndex;
+    using PYIndexLib for IPYieldToken;
 
     IPYieldContractFactory internal immutable yieldContractFactory;
     IPMarketFactory internal immutable marketFactory;
@@ -49,7 +50,7 @@ contract RouterStatic is IPRouterStatic {
     {
         (, address yt) = getPY(py);
         IPYieldToken YT = IPYieldToken(yt);
-        exchangeRate = YT.scyIndexCurrent();
+        exchangeRate = YT.pyIndexCurrent();
         totalSupply = YT.totalSupply();
         address[] memory rewardTokens = YT.getRewardTokens();
         rewardIndexes = new RewardIndex[](rewardTokens.length);
@@ -78,7 +79,6 @@ contract RouterStatic is IPRouterStatic {
 
     function getMarketInfo(address market)
         external
-        view
         returns (
             address pt,
             address scy,
@@ -145,7 +145,6 @@ contract RouterStatic is IPRouterStatic {
         uint256 ptDesired
     )
         external
-        view
         returns (
             uint256 netLpOut,
             uint256 scyUsed,
@@ -154,7 +153,7 @@ contract RouterStatic is IPRouterStatic {
     {
         MarketState memory state = IPMarket(market).readState(false);
         (, netLpOut, scyUsed, ptUsed) = state.addLiquidity(
-            scyIndex(market),
+            pyIndex(market),
             scyDesired,
             ptDesired,
             block.timestamp
@@ -163,23 +162,38 @@ contract RouterStatic is IPRouterStatic {
 
     function addLiquiditySinglePtStatic(address market, uint256 netPtIn)
         external
-        returns (uint256 netLpOut)
+        returns (
+            uint256 netLpOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         require(false, "NOT IMPLEMENTED");
     }
 
-    function addLiquiditySingleScy(address market, uint256 netScyIn)
+    function addLiquiditySingleScyStatic(address market, uint256 netScyIn)
         external
-        returns (uint256 netLpOut)
+        returns (
+            uint256 netLpOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         require(false, "NOT IMPLEMENTED");
     }
 
-    function addLiquiditySingleBaseToken(
+    function addLiquiditySingleBaseTokenStatic(
         address market,
         address baseToken,
         uint256 netBaseTokenIn
-    ) external returns (uint256 netLpOut) {
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
+    {
         require(false, "NOT IMPLEMENTED");
     }
 
@@ -194,86 +208,124 @@ contract RouterStatic is IPRouterStatic {
 
     function removeLiquiditySinglePtStatic(address market, uint256 lpToRemove)
         external
-        returns (uint256 netPtOut)
+        returns (
+            uint256 netPtOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         require(false, "NOT IMPLEMENTED");
     }
 
-    function removeLiquiditySingleScy(address market, uint256 lpToRemove)
+    function removeLiquiditySingleScyStatic(address market, uint256 lpToRemove)
         external
-        returns (uint256 netScyOut)
+        returns (
+            uint256 netScyOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         require(false, "NOT IMPLEMENTED");
     }
 
-    function removeLiquiditySingleBaseToken(
+    function removeLiquiditySingleBaseTokenStatic(
         address market,
         uint256 lpToRemove,
         address baseToken
-    ) external returns (uint256 netBaseTokenOut) {
+    )
+        external
+        returns (
+            uint256 netBaseTokenOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
+    {
         require(false, "NOT IMPLEMENTED");
     }
 
     function swapExactPtForScyStatic(address market, uint256 exactPtIn)
         public
-        view
-        returns (uint256 netScyOut, uint256 netScyFee)
+        returns (
+            uint256 netScyOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         MarketState memory state = IPMarket(market).readState(false);
         (netScyOut, netScyFee) = state.swapExactPtForScy(
-            scyIndex(market),
+            pyIndex(market),
             exactPtIn,
             block.timestamp
         );
+        priceImpact = calcPriceImpact(market, exactPtIn.neg());
     }
 
     function swapScyForExactPtStatic(address market, uint256 exactPtOut)
         external
-        view
-        returns (uint256 netScyIn, uint256 netScyFee)
+        returns (
+            uint256 netScyIn,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         MarketState memory state = IPMarket(market).readState(false);
         (netScyIn, netScyFee) = state.swapScyForExactPt(
-            scyIndex(market),
+            pyIndex(market),
             exactPtOut,
             block.timestamp
         );
+        priceImpact = calcPriceImpact(market, exactPtOut.Int());
     }
 
     function swapExactScyForPtStatic(address market, uint256 exactScyIn)
         public
-        view
-        returns (uint256 netPtOut, uint256 netScyFee)
+        returns (
+            uint256 netPtOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         MarketState memory state = IPMarket(market).readState(false);
         (netPtOut, , netScyFee) = state.approxSwapExactScyForPt(
-            scyIndex(market),
+            pyIndex(market),
             exactScyIn,
             block.timestamp,
             approxParams
         );
+        priceImpact = calcPriceImpact(market, netPtOut.Int());
     }
 
     function swapPtForExactScyStatic(address market, uint256 exactScyOut)
         public
-        view
-        returns (uint256 netPtIn, uint256 netScyFee)
+        returns (
+            uint256 netPtIn,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         MarketState memory state = IPMarket(market).readState(false);
 
         (netPtIn, , netScyFee) = state.approxSwapPtForExactScy(
-            scyIndex(market),
+            pyIndex(market),
             exactScyOut,
             block.timestamp,
             approxParams
         );
+        priceImpact = calcPriceImpact(market, netPtIn.neg());
     }
 
     function swapExactBaseTokenForPtStatic(
         address market,
         address baseToken,
         uint256 amountBaseToken
-    ) external view returns (uint256 netPtOut, uint256 netScyFee) {
+    )
+        external
+        returns (
+            uint256 netPtOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
+    {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
         return swapExactScyForPtStatic(market, SCY.previewDeposit(baseToken, amountBaseToken));
@@ -283,9 +335,16 @@ contract RouterStatic is IPRouterStatic {
         address market,
         uint256 exactYtIn,
         address baseToken
-    ) external view returns (uint256 netBaseTokenOut, uint256 netScyFee) {
+    )
+        external
+        returns (
+            uint256 netBaseTokenOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
+    {
         uint256 netScyOut;
-        (netScyOut, netScyFee) = swapExactPtForScyStatic(market, exactYtIn);
+        (netScyOut, netScyFee, priceImpact) = swapExactPtForScyStatic(market, exactYtIn);
 
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
         netBaseTokenOut = SCY.previewRedeem(baseToken, netScyOut);
@@ -293,31 +352,39 @@ contract RouterStatic is IPRouterStatic {
 
     function swapScyForExactYtStatic(address market, uint256 exactYtOut)
         external
-        view
-        returns (uint256 netScyIn, uint256 netScyFee)
+        returns (
+            uint256 netScyIn,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         MarketState memory state = IPMarket(market).readState(false);
 
-        SCYIndex index = scyIndex(market);
+        PYIndex index = pyIndex(market);
 
         uint256 scyReceived;
         (scyReceived, netScyFee) = state.swapExactPtForScy(
-            scyIndex(market),
+            pyIndex(market),
             exactYtOut,
             block.timestamp
         );
 
         uint256 totalScyNeed = index.assetToScyUp(exactYtOut);
         netScyIn = totalScyNeed.subMax0(scyReceived);
+
+        priceImpact = calcPriceImpact(market, exactYtOut.neg());
     }
 
     function swapExactScyForYtStatic(address market, uint256 exactScyIn)
         public
-        view
-        returns (uint256 netYtOut, uint256 netScyFee)
+        returns (
+            uint256 netYtOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         MarketState memory state = IPMarket(market).readState(false);
-        SCYIndex index = scyIndex(market);
+        PYIndex index = pyIndex(market);
 
         (netYtOut, , netScyFee) = state.approxSwapExactScyForYt(
             index,
@@ -325,16 +392,21 @@ contract RouterStatic is IPRouterStatic {
             block.timestamp,
             approxParams
         );
+
+        priceImpact = calcPriceImpact(market, netYtOut.neg());
     }
 
     function swapExactYtForScyStatic(address market, uint256 exactYtIn)
         public
-        view
-        returns (uint256 netScyOut, uint256 netScyFee)
+        returns (
+            uint256 netScyOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         MarketState memory state = IPMarket(market).readState(false);
 
-        SCYIndex index = scyIndex(market);
+        PYIndex index = pyIndex(market);
 
         uint256 scyOwed;
         (scyOwed, netScyFee) = state.swapScyForExactPt(index, exactYtIn, block.timestamp);
@@ -343,16 +415,20 @@ contract RouterStatic is IPRouterStatic {
         uint256 amountPYToRedeemScyOut = exactYtIn - amountPYToRepayScyOwed;
 
         netScyOut = index.assetToScy(amountPYToRedeemScyOut);
+        priceImpact = calcPriceImpact(market, exactYtIn.Int());
     }
 
     function swapYtForExactScyStatic(address market, uint256 exactScyOut)
         external
-        view
-        returns (uint256 netYtIn, uint256 netScyFee)
+        returns (
+            uint256 netYtIn,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
     {
         MarketState memory state = IPMarket(market).readState(false);
 
-        SCYIndex index = scyIndex(market);
+        PYIndex index = pyIndex(market);
 
         (netYtIn, , netScyFee) = state.approxSwapYtForExactScy(
             index,
@@ -360,15 +436,23 @@ contract RouterStatic is IPRouterStatic {
             block.timestamp,
             approxParams
         );
+        priceImpact = calcPriceImpact(market, netYtIn.Int());
     }
 
     function swapExactYtForBaseTokenStatic(
         address market,
         uint256 exactYtIn,
         address baseToken
-    ) external view returns (uint256 netBaseTokenOut, uint256 netScyFee) {
+    )
+        external
+        returns (
+            uint256 netBaseTokenOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
+    {
         uint256 netScyOut;
-        (netScyOut, netScyFee) = swapExactYtForScyStatic(market, exactYtIn);
+        (netScyOut, netScyFee, priceImpact) = swapExactYtForScyStatic(market, exactYtIn);
 
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
         netBaseTokenOut = SCY.previewRedeem(baseToken, netScyOut);
@@ -378,7 +462,14 @@ contract RouterStatic is IPRouterStatic {
         address market,
         address baseToken,
         uint256 amountBaseToken
-    ) external view returns (uint256 netPtOut, uint256 netScyFee) {
+    )
+        external
+        returns (
+            uint256 netPtOut,
+            uint256 netScyFee,
+            uint256 priceImpact
+        )
+    {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
         return swapExactScyForYtStatic(market, SCY.previewDeposit(baseToken, amountBaseToken));
@@ -392,7 +483,7 @@ contract RouterStatic is IPRouterStatic {
     {
         IPYieldToken _YT = IPYieldToken(YT);
         require(!_YT.isExpired(), "YT is expired");
-        return amountScyToMint.mulDown(_YT.scyIndexCurrent());
+        return amountScyToMint.mulDown(_YT.pyIndexCurrent());
     }
 
     function redeemPYToScyStatic(address YT, uint256 amountPYToRedeem)
@@ -400,7 +491,7 @@ contract RouterStatic is IPRouterStatic {
         returns (uint256 amountPY)
     {
         IPYieldToken _YT = IPYieldToken(YT);
-        return amountPYToRedeem.divDown(_YT.scyIndexCurrent());
+        return amountPYToRedeem.divDown(_YT.pyIndexCurrent());
     }
 
     function mintPYFromBaseStatic(
@@ -421,10 +512,10 @@ contract RouterStatic is IPRouterStatic {
         return SCY.previewRedeem(baseToken, redeemPYToScyStatic(YT, amountPYToRedeem));
     }
 
-    function scyIndex(address market) public view returns (SCYIndex index) {
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+    function pyIndex(address market) public returns (PYIndex index) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        return SCYIndexLib.newIndex(SCY);
+        return YT.newIndex();
     }
 
     function getPY(address py) public view returns (address pt, address yt) {
@@ -437,30 +528,50 @@ contract RouterStatic is IPRouterStatic {
         }
     }
 
-    function getPtImpliedYield(address market) public view returns (int256) {
+    function getPtImpliedYield(address market) public returns (int256) {
         MarketState memory state = IPMarket(market).readState(false);
 
         int256 lnImpliedRate = (state.lastLnImpliedRate).Int();
         return lnImpliedRate.exp();
     }
 
-    function getExchangeRate(address market) public view returns (uint256) {
+    function getExchangeRate(address market) public returns (uint256) {
+        return getTradeExchangeRateIncludeFee(market, 0);
+    }
+
+    function getTradeExchangeRateIncludeFee(address market, int256 netPtOut)
+        public
+        returns (uint256)
+    {
+        int256 netPtToAccount = netPtOut;
         MarketState memory state = IPMarket(market).readState(false);
-        MarketPreCompute memory comp = state.getMarketPreCompute(
-            scyIndex(market),
-            block.timestamp
+        MarketPreCompute memory comp = state.getMarketPreCompute(pyIndex(market), block.timestamp);
+
+        int256 preFeeExchangeRate = MarketMathCore._getExchangeRate(
+            state.totalPt,
+            comp.totalAsset,
+            comp.rateScalar,
+            comp.rateAnchor,
+            netPtToAccount
         );
 
-        return
-            MarketMathCore
-                ._getExchangeRate(
-                    state.totalPt,
-                    comp.totalAsset,
-                    comp.rateScalar,
-                    comp.rateAnchor,
-                    0
-                )
-                .Uint();
+        if (netPtToAccount > 0) {
+            int256 postFeeExchangeRate = preFeeExchangeRate.divDown(comp.feeRate);
+            require(postFeeExchangeRate >= Math.IONE, "exchange rate below 1");
+            return postFeeExchangeRate.Uint();
+        } else {
+            return preFeeExchangeRate.mulDown(comp.feeRate).Uint();
+        }
+    }
+
+    function calcPriceImpact(address market, int256 netPtOut)
+        public
+        returns (uint256 priceImpact)
+    {
+        uint256 preTradeRate = getExchangeRate(market);
+        uint256 tradedRate = getTradeExchangeRateIncludeFee(market, netPtOut);
+
+        priceImpact = (tradedRate.Int() - preTradeRate.Int()).abs().divDown(preTradeRate);
     }
 
     function getUserPYInfo(address py, address user)

package/deployments/43113-benqi.json

@@ -3,8 +3,8 @@
     "QI": "0x09Fe18C4C0cFE929a6CD40903129F9bA3C837866",
     "USD": "0x2018ecc38fbca2ce3A62f96f9F0D38F0DEE2f99D",
     "qiUSD": "0x884f8d66862b03434E11f4Bd5527A1119c115D83",
-    "scyQiUSD": "0x4c91cC2062ABE2000A0E8AdF6b9b3Ceea839EAF7",
+    "scyQiUSD": "0xc68Fe29C91a5611e332A57d4FC091eDe7fD5156d",
     "WAVAX": "0xD323E5337713D2e01fb341D960BC31e1FB42348d",
     "qiAVAX": "0xABD65178Aa35051277b062327A70644F10D3cB9d",
-    "scyQiAVAX": "0xe0c34CeF3980988a71aFC902FD7B12E0c51961E3"
+    "scyQiAVAX": "0x60e235D9836Ecf533966E2ef94795C83FcB5E7e3"
 }

package/deployments/43113-core.json

@@ -3,14 +3,14 @@
     "network": 43113,
     "celerBus": "0xE9533976C590200E32d95C53f06AE12d292cFc47",
     "treasury": "0xB4E292AD98Ba0D5531Ca573757f7b7d6c0C205d8",
-    "governanceManager": "0x96Ee4f9D53dFac1fDC10CD079F5D850cEb95b464",
+    "governanceManager": "0x8b6618109D33f84e1C83fFA50a1aAC3bEDc3d523",
     "PENDLE": "0x83B694f9Ef84D22BECe87257f0cd4513737A505e",
-    "yieldContractFactory": "0x2B233F133f3DA67698453F4A251BAF8BAc1E584d",
-    "marketFactory": "0xE3a730f28EAe40309A9868Fb5b66B5BaaF531204",
+    "yieldContractFactory": "0xf9397B3b93d118587c29bA2a166c0192251fc758",
+    "marketFactory": "0x2FfdD5E68ce0F668498029c1219Db39f79ebD5bd",
     "router": "0xFEdBED4682D136925d30FFb9B8977CC9b3a6c406",
-    "routerStatic": "0x1436Cb03C753bB9fAc7fcfE5627d08F143D6d8ed",
+    "routerStatic": "0x501E089e6BD6b78e6E435C15118E52c665931850",
     "startTime": 1657756800,
-    "vePendle": "0xD05B49500F35d879F3Bf220c81BE3ff9d73Ca205",
-    "votingController": "0x449f676be160C5C682E1E64934f29641D6096116",
-    "gaugeController": "0xc13B5c62e80bA35fEF620de4257e961AafFD5542"
+    "vePendle": "0xa94936409d9B0633dB6271Fc2789aBa9C74bD729",
+    "votingController": "0x676A97883D396b21f3a7554A73F30187752c7C45",
+    "gaugeController": "0x8490DDFBCf1F451dC25e7deaeB9ac6137E75b91b"
 }

package/deployments/43113-markets/benqi-market-599408.json

@@ -0,0 +1,7 @@
+{
+    "SCY": "0xc68Fe29C91a5611e332A57d4FC091eDe7fD5156d",
+    "expiry": 1688860800,
+    "PT": "0x43f637d5C1E6c4Ba6c557537ef59c56cCDeD9228",
+    "YT": "0xa6Fe544BbF21D0964452120eF4d1613227abE8E1",
+    "market": "0x4370105207dBdabCDE6f6B719Fd2E7f373599408"
+}

package/deployments/43113-markets/benqi-market-93bbf0.json

@@ -0,0 +1,7 @@
+{
+    "SCY": "0x60e235D9836Ecf533966E2ef94795C83FcB5E7e3",
+    "expiry": 1688860800,
+    "PT": "0x1c47Bc3d191E08Ae4d60c9a2dC5D1D04D31A89fA",
+    "YT": "0x2bf665477C0C7AE4c443a71b80Fbff2a87DE0776",
+    "market": "0xE327922Eadc6Fe151915906F548F555A4b93bbf0"
+}