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

package/contracts/interfaces/IPVotingEscrow.sol

@@ -20,5 +20,5 @@ interface IPVotingEscrow {
         external
         returns (uint128);
 
-    function withdraw(address user) external returns (uint128);
+    function withdraw() external returns (uint128);
 }

package/contracts/interfaces/IPYieldContractFactory.sol

@@ -30,15 +30,19 @@ interface IPYieldContractFactory {
 
     event SetInterestFeeRate(uint256 newInterestFeeRate);
 
+    event SetRewardFeeRate(uint256 newInterestFeeRate);
+
     event SetTreasury(address indexed treasury);
 
     function getPT(address SCY, uint256 expiry) external view returns (address);
 
     function getYT(address SCY, uint256 expiry) external view returns (address);
 
-    function expiryDivisor() external view returns (uint256);
+    function expiryDivisor() external view returns (uint96);
+
+    function interestFeeRate() external view returns (uint128);
 
-    function interestFeeRate() external view returns (uint256);
+    function rewardFeeRate() external view returns (uint128);
 
     function treasury() external view returns (address);
 

package/contracts/interfaces/IPYieldToken.sol

@@ -5,15 +5,27 @@ import "./IRewardManager.sol";
 import "./IPInterestManagerYT.sol";
 
 interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
+    event NewInterestIndex(
+        uint256 indexed newIndex
+    );
+
     event Mint(
         address indexed caller,
         address indexed receiverPT,
         address indexed receiverYT,
-        uint256 amount
+        uint256 amountScyToMint,
+        uint256 amountPYOut
+    );
+
+    event Burn(
+        address indexed caller,
+        address indexed receiver,
+        uint256 amountPYToRedeem,
+        uint256 amountScyOut
     );
-    event Redeem(address indexed caller, address indexed receiver, uint256 amount);
 
     event RedeemRewards(address indexed user, uint256[] amountRewardsOut);
+
     event RedeemInterest(address indexed user, uint256 interestOut);
 
     event WithdrawFeeToTreasury(uint256[] amountRewardsOut, uint256 scyOut);
@@ -22,17 +34,15 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
 
     function redeemPY(address receiver) external returns (uint256 amountScyOut);
 
-    function redeemPY(address[] memory receivers, uint256[] memory maxAmountScyOuts)
-        external
-        returns (uint256 totalAmountScyOut);
-
-    function redeemDueInterestAndRewards(address user)
+    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
         external
-        returns (uint256 interestOut, uint256[] memory rewardsOut);
-
-    function redeemDueInterest(address user) external returns (uint256 interestOut);
+        returns (uint256[] memory amountScyOuts);
 
-    function redeemDueRewards(address user) external returns (uint256[] memory rewardsOut);
+    function redeemDueInterestAndRewards(
+        address user,
+        bool redeemInterest,
+        bool redeemRewards
+    ) external returns (uint256 interestOut, uint256[] memory rewardsOut);
 
     function rewardIndexesCurrent() external returns (uint256[] memory);
 

package/contracts/interfaces/ISuperComposableYield.sol

@@ -56,58 +56,42 @@ interface ISuperComposableYield is IERC20Metadata {
      * @notice mints an amount of shares by depositing a base token.
      * @param receiver shares recipient address
      * @param tokenIn address of the base tokens to mint shares
-     * @param amountTokenToPull amount of base tokens to be transferred from (`msg.sender`)
+     * @param amountTokenToDeposit amount of base tokens to be transferred from (`msg.sender`)
      * @param minSharesOut reverts if amount of shares minted is lower than this
      * @return amountSharesOut amount of shares minted
-     * @dev
-     *
-     * This contract receives base tokens using these two (possibly both) methods:
-     * - The tokens have been transferred directly to this contract prior to calling deposit().
-     * - Exactly `amountTokenToPull` are transferred to this contract using `transferFrom()` upon calling deposit().
-     *
-     * The amount of shares minted will be based on the combined amount of base tokens deposited
-     * using the given two methods.
-     *
-     * Emits a {Deposit} event
+     * @dev Emits a {Deposit} event
      *
      * Requirements:
      * - (`baseTokenIn`) must be a valid base token.
-     * - There must be an ongoing approval from (`msg.sender`) for this contract with
-     * at least `amountTokenToPull` base tokens.
      */
     function deposit(
         address receiver,
         address tokenIn,
-        uint256 amountTokenToPull,
+        uint256 amountTokenToDeposit,
         uint256 minSharesOut
     ) external payable returns (uint256 amountSharesOut);
 
     /**
      * @notice redeems an amount of base tokens by burning some shares
      * @param receiver recipient address
-     * @param amountSharesToPull amount of shares to be transferred from (`msg.sender`)
+     * @param amountSharesToRedeem amount of shares to be burned from (`msg.sender`)
      * @param tokenOut address of the base token to be redeemed
      * @param minTokenOut reverts if amount of base token redeemed is lower than this
      * @return amountTokenOut amount of base tokens redeemed
-     * @dev
-     *
-     * This contract receives shares using these two (possibly both) methods:
-     * - The shares have been transferred directly to this contract prior to calling redeem().
-     * - Exactly `amountSharesToPull` are transferred to this contract using `transferFrom()` upon calling redeem().
-     *
-     * The amount of base tokens redeemed based on the combined amount of shares deposited
-     * using the given two methods
-     *
-     * Emits a {Redeem} event
+     * @dev Emits a {Redeem} event
      *
      * Requirements:
      * - (`tokenOut`) must be a valid base token.
-     * - There must be an ongoing approval from (`msg.sender`) for this contract with
-     * at least `amountSharesToPull` shares.
      */
     function redeem(
         address receiver,
-        uint256 amountSharesToPull,
+        uint256 amountSharesToRedeem,
+        address tokenOut,
+        uint256 minTokenOut
+    ) external returns (uint256 amountTokenOut);
+
+    function redeemAfterTransfer(
+        address receiver,
         address tokenOut,
         uint256 minTokenOut
     ) external returns (uint256 amountTokenOut);
@@ -163,6 +147,16 @@ interface ISuperComposableYield is IERC20Metadata {
      */
     function isValidBaseToken(address token) external view returns (bool);
 
+    function previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        external
+        view
+        returns (uint256 amountSharesOut);
+
+    function previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        external
+        view
+        returns (uint256 amountTokenOut);
+
     /**
     * @notice This function contains information to interpret what the asset is
     * @notice decimals is the decimals to format asset balances

package/contracts/interfaces/IYearnVault.sol

@@ -26,9 +26,17 @@ pragma solidity 0.8.15;
 interface IYearnVault {
     function deposit(uint256 amount) external returns (uint256);
 
+    function deposit(uint256 amount, address recipient) external returns (uint256);
+
     function withdraw(uint256 maxShares) external returns (uint256);
 
     function pricePerShare() external view returns (uint256);
 
     function token() external view returns (address);
+
+    function depositLimit() external view returns (uint256);
+
+    function totalAssets() external view returns (uint256);
+
+    function decimals() external view returns (uint256);
 }

package/contracts/libraries/RewardManager.sol

@@ -35,21 +35,20 @@ abstract contract RewardManager is RewardManagerAbstract {
 
             uint256 totalShares = _rewardSharesTotal();
 
-            uint256[] memory preBalances = _selfBalances(tokens);
-
             _redeemExternalReward();
 
-            uint256[] memory accrued = _selfBalances(tokens).sub(preBalances);
-
             for (uint256 i = 0; i < tokens.length; ++i) {
                 address token = tokens[i];
+
+                // the entire token balance of the contract must be the rewards of the contract
+                uint256 accrued = _selfBalance(tokens[i]) - rewardState[token].lastBalance;
                 uint256 index = rewardState[token].index;
 
                 if (index == 0) index = INITIAL_REWARD_INDEX;
-                if (totalShares != 0) index += accrued[i].divDown(totalShares);
+                if (totalShares != 0) index += accrued.divDown(totalShares);
 
                 rewardState[token].index = index.Uint128();
-                rewardState[token].lastBalance += accrued[i].Uint128();
+                rewardState[token].lastBalance += accrued.Uint128();
             }
         }
 
@@ -75,4 +74,8 @@ abstract contract RewardManager is RewardManagerAbstract {
             }
         }
     }
+
+    function _getRewardTokens() internal view virtual returns (address[] memory);
+
+    function _rewardSharesTotal() internal view virtual returns (uint256);
 }

package/contracts/libraries/RewardManagerAbstract.sol

@@ -29,17 +29,19 @@ abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
         if (tokens.length == 0) return;
 
         if (user1 != address(0) && user1 != address(this))
-            _distributeRewards(user1, tokens, indexes);
+            _distributeRewardsPrivate(user1, tokens, indexes);
         if (user2 != address(0) && user2 != address(this))
-            _distributeRewards(user2, tokens, indexes);
+            _distributeRewardsPrivate(user2, tokens, indexes);
     }
 
-    /// @dev private function
-    function _distributeRewards(
+    // should only be callable from `_updateAndDistributeRewardsForTwo` to guarantee user != address(0) && user != address(this)
+    function _distributeRewardsPrivate(
         address user,
         address[] memory tokens,
         uint256[] memory indexes
     ) private {
+        assert(user != address(0) && user != address(this));
+
         uint256 userShares = _rewardSharesUser(user);
 
         for (uint256 i = 0; i < tokens.length; ++i) {
@@ -77,9 +79,5 @@ abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
         virtual
         returns (uint256[] memory rewardAmounts);
 
-    function _getRewardTokens() internal view virtual returns (address[] memory);
-
     function _rewardSharesUser(address user) internal view virtual returns (uint256);
-
-    function _rewardSharesTotal() internal view virtual returns (uint256);
 }

package/contracts/libraries/SCY/SCYIndex.sol

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

package/contracts/libraries/VeBalanceLib.sol

@@ -65,7 +65,6 @@ library VeBalanceLib {
         returns (VeBalance memory res)
     {
         res.slope = position.amount / MAX_LOCK_TIME;
-        require(res.slope > 0, "zero slope");
         res.bias = res.slope * position.expiry;
     }
 

package/contracts/libraries/helpers/ArrayLib.sol

@@ -19,6 +19,17 @@ library ArrayLib {
         return output;
     }
 
+    function sum(uint256[] memory input) internal pure returns (uint256) {
+        uint256 value = 0;
+        for (uint256 i = 0; i < input.length; ) {
+            value += input[i];
+            unchecked {
+                i++;
+            }
+        }
+        return value;
+    }
+
     function contains(address[] memory array, address element) internal pure returns (bool) {
         uint256 length = array.length;
         for (uint256 i = 0; i < length; ) {

package/contracts/libraries/helpers/TokenHelper.sol

@@ -50,19 +50,20 @@ abstract contract TokenHelper {
         uint256 totalAmount,
         address[] memory tos,
         uint256[] memory maxAmounts
-    ) internal {
+    ) internal returns (uint256 leftover) {
         uint256 numTos = tos.length;
         require(numTos == maxAmounts.length, "invalid length");
 
-        uint256 remaining = totalAmount;
+        leftover = totalAmount;
         for (uint256 i = 0; i < numTos; ) {
             uint256 maxAmount = maxAmounts[i];
-            if (maxAmount > remaining) {
-                maxAmount = remaining;
+            if (maxAmount > leftover) {
+                maxAmount = leftover;
             }
             _transferOut(token, tos[i], maxAmount);
             unchecked {
-                remaining -= maxAmount;
+                leftover -= maxAmount;
+                if (leftover == 0) break;
                 i++;
             }
         }

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

@@ -43,7 +43,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();
@@ -220,7 +220,7 @@ contract RouterStatic is IPRouterStatic, Initializable, UUPSUpgradeable, Ownable
         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);

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": "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"
+}