@pendle/core-v2 3.0.0 → 4.0.1

package/contracts/router/base/MarketApproxLib.sol

@@ -11,23 +11,23 @@ struct ApproxParams {
     uint256 maxIteration; // every iteration, the diff between guessMin and guessMax will be divided by 2
     uint256 eps; // the max eps between the returned result & the correct result, base 1e18. Normally this number will be set
     // to 1e15 (1e18/1000 = 0.1%)
-
-    /// Further explanation of the eps. Take swapExactSyForPt for example. To calc the corresponding amount of Pt to swap out,
-    /// it's necessary to run an approximation algorithm, because by default there only exists the Pt to Sy formula
-    /// To approx, the 5 values above will have to be provided, and the approx process will run as follows:
-    /// mid = (guessMin + guessMax) / 2 // mid here is the current guess of the amount of Pt out
-    /// netSyNeed = calcSwapSyForExactPt(mid)
-    /// if (netSyNeed > exactSyIn) guessMax = mid - 1 // since the maximum Sy in can't exceed the exactSyIn
-    /// else guessMin = mid (1)
-    /// For the (1), since netSyNeed <= exactSyIn, the result might be usable. If the netSyNeed is within eps of
-    /// exactSyIn (ex eps=0.1% => we have used 99.9% the amount of Sy specified), mid will be chosen as the final guess result
-
-    /// for guessOffchain, this is to provide a shortcut to guessing. The offchain SDK can precalculate the exact result
-    /// before the tx is sent. When the tx reaches the contract, the guessOffchain will be checked first, and if it satisfies the
-    /// approximation, it will be used (and save all the guessing). It's expected that this shortcut will be used in most cases
-    /// except in cases that there is a trade in the same market right before the tx
 }
 
+/// Further explanation of the eps. Take swapExactSyForPt for example. To calc the corresponding amount of Pt to swap out,
+/// it's necessary to run an approximation algorithm, because by default there only exists the Pt to Sy formula
+/// To approx, the 5 values above will have to be provided, and the approx process will run as follows:
+/// mid = (guessMin + guessMax) / 2 // mid here is the current guess of the amount of Pt out
+/// netSyNeed = calcSwapSyForExactPt(mid)
+/// if (netSyNeed > exactSyIn) guessMax = mid - 1 // since the maximum Sy in can't exceed the exactSyIn
+/// else guessMin = mid (1)
+/// For the (1), since netSyNeed <= exactSyIn, the result might be usable. If the netSyNeed is within eps of
+/// exactSyIn (ex eps=0.1% => we have used 99.9% the amount of Sy specified), mid will be chosen as the final guess result
+
+/// for guessOffchain, this is to provide a shortcut to guessing. The offchain SDK can precalculate the exact result
+/// before the tx is sent. When the tx reaches the contract, the guessOffchain will be checked first, and if it satisfies the
+/// approximation, it will be used (and save all the guessing). It's expected that this shortcut will be used in most cases
+/// except in cases that there is a trade in the same market right before the tx
+
 library MarketApproxPtInLib {
     using MarketMathCore for MarketState;
     using PYIndexLib for PYIndex;
@@ -37,10 +37,10 @@ library MarketApproxPtInLib {
 
     /**
      * @dev algorithm:
-        - Bin search the amount of PT to swap in
-        - Try swapping & get netSyOut
-        - Stop when netSyOut greater & approx minSyOut
-        - guess & approx is for netPtIn
+     *     - Bin search the amount of PT to swap in
+     *     - Try swapping & get netSyOut
+     *     - Stop when netSyOut greater & approx minSyOut
+     *     - guess & approx is for netPtIn
      */
     function approxSwapPtForExactSy(
         MarketState memory market,
@@ -48,7 +48,7 @@ library MarketApproxPtInLib {
         uint256 minSyOut,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256 /*netPtIn*/, uint256 /*netSyOut*/, uint256 /*netSyFee*/) {
+    ) internal pure returns (uint256, /*netPtIn*/ uint256, /*netSyOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -61,7 +61,9 @@ library MarketApproxPtInLib {
             (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             if (netSyOut >= minSyOut) {
-                if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps)) return (guess, netSyOut, netSyFee);
+                if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps)) {
+                    return (guess, netSyOut, netSyFee);
+                }
                 approx.guessMax = guess;
             } else {
                 approx.guessMin = guess;
@@ -72,12 +74,12 @@ library MarketApproxPtInLib {
 
     /**
      * @dev algorithm:
-        - Bin search the amount of PT to swap in
-        - Flashswap the corresponding amount of SY out
-        - Pair those amount with exactSyIn SY to tokenize into PT & YT
-        - PT to repay the flashswap, YT transferred to user
-        - Stop when the amount of SY to be pulled to tokenize PT to repay loan approx the exactSyIn
-        - guess & approx is for netYtOut (also netPtIn)
+     *     - Bin search the amount of PT to swap in
+     *     - Flashswap the corresponding amount of SY out
+     *     - Pair those amount with exactSyIn SY to tokenize into PT & YT
+     *     - PT to repay the flashswap, YT transferred to user
+     *     - Stop when the amount of SY to be pulled to tokenize PT to repay loan approx the exactSyIn
+     *     - guess & approx is for netYtOut (also netPtIn)
      */
     function approxSwapExactSyForYt(
         MarketState memory market,
@@ -85,7 +87,7 @@ library MarketApproxPtInLib {
         uint256 exactSyIn,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256 /*netYtOut*/, uint256 /*netSyFee*/) {
+    ) internal pure returns (uint256, /*netYtOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, index.syToAsset(exactSyIn));
@@ -106,7 +108,9 @@ library MarketApproxPtInLib {
             uint256 netSyToPull = netSyToTokenizePt - netSyOut;
 
             if (netSyToPull <= exactSyIn) {
-                if (PMath.isASmallerApproxB(netSyToPull, exactSyIn, approx.eps)) return (guess, netSyFee);
+                if (PMath.isASmallerApproxB(netSyToPull, exactSyIn, approx.eps)) {
+                    return (guess, netSyFee);
+                }
                 approx.guessMin = guess;
             } else {
                 approx.guessMax = guess - 1;
@@ -115,42 +119,56 @@ library MarketApproxPtInLib {
         revert Errors.ApproxFail();
     }
 
+    struct Args5 {
+        MarketState market;
+        PYIndex index;
+        uint256 totalPtIn;
+        uint256 netSyHolding;
+        uint256 blockTime;
+        ApproxParams approx;
+    }
+
     /**
      * @dev algorithm:
-        - Bin search the amount of PT to swap to SY
-        - Swap PT to SY
-        - Pair the remaining PT with the SY to add liquidity
-        - Stop when the ratio of PT / totalPt & SY / totalSy is approx
-        - guess & approx is for netPtSwap
+     *     - Bin search the amount of PT to swap to SY
+     *     - Swap PT to SY
+     *     - Pair the remaining PT with the SY to add liquidity
+     *     - Stop when the ratio of PT / totalPt & SY / totalSy is approx
+     *     - guess & approx is for netPtSwap
      */
     function approxSwapPtToAddLiquidity(
-        MarketState memory market,
-        PYIndex index,
-        uint256 totalPtIn,
-        uint256 blockTime,
+        MarketState memory _market,
+        PYIndex _index,
+        uint256 _totalPtIn,
+        uint256 _netSyHolding,
+        uint256 _blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256 /*netPtSwap*/, uint256 /*netSyFromSwap*/, uint256 /*netSyFee*/) {
-        MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
+    ) internal pure returns (uint256, /*netPtSwap*/ uint256, /*netSyFromSwap*/ uint256 /*netSyFee*/) {
+        Args5 memory a = Args5(_market, _index, _totalPtIn, _netSyHolding, _blockTime, approx);
+        MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
-            approx.guessMax = PMath.min(approx.guessMax, calcMaxPtIn(market, comp));
-            approx.guessMax = PMath.min(approx.guessMax, totalPtIn);
+            approx.guessMax = PMath.min(approx.guessMax, calcMaxPtIn(a.market, comp));
+            approx.guessMax = PMath.min(approx.guessMax, a.totalPtIn);
             validateApprox(approx);
-            require(market.totalLp != 0, "no existing lp");
+            require(a.market.totalLp != 0, "no existing lp");
         }
 
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
             (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee, ) = calcNumerators(
-                market,
-                index,
-                totalPtIn,
+                a.market,
+                a.index,
+                a.totalPtIn,
+                a.netSyHolding,
                 comp,
                 guess
             );
 
-            if (PMath.isAApproxB(syNumerator, ptNumerator, approx.eps)) return (guess, netSyOut, netSyFee);
+            if (PMath.isAApproxB(syNumerator, ptNumerator, approx.eps)) {
+                return (guess, netSyOut, netSyFee);
+            }
 
             if (syNumerator <= ptNumerator) {
                 // needs more SY --> swap more PT
@@ -167,6 +185,7 @@ library MarketApproxPtInLib {
         MarketState memory market,
         PYIndex index,
         uint256 totalPtIn,
+        uint256 netSyHolding,
         MarketPreCompute memory comp,
         uint256 guess
     )
@@ -180,29 +199,22 @@ library MarketApproxPtInLib {
         uint256 newTotalSy = (uint256(market.totalSy) - netSyOut - netSyToReserve);
 
         // it is desired that
-        // netSyOut / newTotalSy = netPtRemaining / newTotalPt
+        // (netSyOut + netSyHolding) / newTotalSy = netPtRemaining / newTotalPt
         // which is equivalent to
-        // netSyOut * newTotalPt = netPtRemaining * newTotalSy
+        // (netSyOut + netSyHolding) * newTotalPt = netPtRemaining * newTotalSy
 
-        syNumerator = netSyOut * newTotalPt;
+        syNumerator = (netSyOut + netSyHolding) * newTotalPt;
         ptNumerator = (totalPtIn - guess) * newTotalSy;
     }
 
-    struct Args7 {
-        MarketState market;
-        PYIndex index;
-        uint256 exactPtIn;
-        uint256 blockTime;
-    }
-
     /**
      * @dev algorithm:
-        - Bin search the amount of PT to swap to SY
-        - Flashswap the corresponding amount of SY out
-        - Tokenize all the SY into PT + YT
-        - PT to repay the flashswap, YT transferred to user
-        - Stop when the additional amount of PT to pull to repay the loan approx the exactPtIn
-        - guess & approx is for totalPtToSwap
+     *     - Bin search the amount of PT to swap to SY
+     *     - Flashswap the corresponding amount of SY out
+     *     - Tokenize all the SY into PT + YT
+     *     - PT to repay the flashswap, YT transferred to user
+     *     - Stop when the additional amount of PT to pull to repay the loan approx the exactPtIn
+     *     - guess & approx is for totalPtToSwap
      */
     function approxSwapExactPtForYt(
         MarketState memory market,
@@ -210,7 +222,7 @@ library MarketApproxPtInLib {
         uint256 exactPtIn,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256 /*netYtOut*/, uint256 /*totalPtToSwap*/, uint256 /*netSyFee*/) {
+    ) internal pure returns (uint256, /*netYtOut*/ uint256, /*totalPtToSwap*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, exactPtIn);
@@ -229,7 +241,9 @@ library MarketApproxPtInLib {
             uint256 netPtToPull = guess - netAssetOut;
 
             if (netPtToPull <= exactPtIn) {
-                if (PMath.isASmallerApproxB(netPtToPull, exactPtIn, approx.eps)) return (netAssetOut, guess, netSyFee);
+                if (PMath.isASmallerApproxB(netPtToPull, exactPtIn, approx.eps)) {
+                    return (netAssetOut, guess, netSyFee);
+                }
                 approx.guessMin = guess;
             } else {
                 approx.guessMax = guess - 1;
@@ -261,8 +275,9 @@ library MarketApproxPtInLib {
     /// INTENDED TO BE CALLED BY WHEN GUESS.OFFCHAIN == 0 ONLY ///
 
     function validateApprox(ApproxParams memory approx) internal pure {
-        if (approx.guessMin > approx.guessMax || approx.eps > PMath.ONE)
+        if (approx.guessMin > approx.guessMax || approx.eps > PMath.ONE) {
             revert Errors.ApproxParamsInvalid(approx.guessMin, approx.guessMax, approx.eps);
+        }
     }
 
     function calcMaxPtIn(MarketState memory market, MarketPreCompute memory comp) internal pure returns (uint256) {
@@ -301,10 +316,10 @@ library MarketApproxPtOutLib {
 
     /**
      * @dev algorithm:
-        - Bin search the amount of PT to swapExactOut
-        - Calculate the amount of SY needed
-        - Stop when the netSyIn is smaller approx exactSyIn
-        - guess & approx is for netSyIn
+     *     - Bin search the amount of PT to swapExactOut
+     *     - Calculate the amount of SY needed
+     *     - Stop when the netSyIn is smaller approx exactSyIn
+     *     - guess & approx is for netSyIn
      */
     function approxSwapExactSyForPt(
         MarketState memory market,
@@ -312,7 +327,7 @@ library MarketApproxPtOutLib {
         uint256 exactSyIn,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256 /*netPtOut*/, uint256 /*netSyFee*/) {
+    ) internal pure returns (uint256, /*netPtOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -326,7 +341,9 @@ library MarketApproxPtOutLib {
             (uint256 netSyIn, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             if (netSyIn <= exactSyIn) {
-                if (PMath.isASmallerApproxB(netSyIn, exactSyIn, approx.eps)) return (guess, netSyFee);
+                if (PMath.isASmallerApproxB(netSyIn, exactSyIn, approx.eps)) {
+                    return (guess, netSyFee);
+                }
                 approx.guessMin = guess;
             } else {
                 approx.guessMax = guess - 1;
@@ -338,11 +355,11 @@ library MarketApproxPtOutLib {
 
     /**
      * @dev algorithm:
-        - Bin search the amount of PT to swapExactOut
-        - Flashswap that amount of PT & pair with YT to redeem SY
-        - Use the SY to repay the flashswap debt and the remaining is transferred to user
-        - Stop when the netSyOut is greater approx the minSyOut
-        - guess & approx is for netSyOut
+     *     - Bin search the amount of PT to swapExactOut
+     *     - Flashswap that amount of PT & pair with YT to redeem SY
+     *     - Use the SY to repay the flashswap debt and the remaining is transferred to user
+     *     - Stop when the netSyOut is greater approx the minSyOut
+     *     - guess & approx is for netSyOut
      */
     function approxSwapYtForExactSy(
         MarketState memory market,
@@ -350,7 +367,7 @@ library MarketApproxPtOutLib {
         uint256 minSyOut,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256 /*netYtIn*/, uint256 /*netSyOut*/, uint256 /*netSyFee*/) {
+    ) internal pure returns (uint256, /*netYtIn*/ uint256, /*netSyOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -367,7 +384,9 @@ library MarketApproxPtOutLib {
             uint256 netSyOut = index.assetToSy(guess - netAssetToRepay);
 
             if (netSyOut >= minSyOut) {
-                if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps)) return (guess, netSyOut, netSyFee);
+                if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps)) {
+                    return (guess, netSyOut, netSyFee);
+                }
                 approx.guessMax = guess;
             } else {
                 approx.guessMin = guess + 1;
@@ -380,26 +399,28 @@ library MarketApproxPtOutLib {
         MarketState market;
         PYIndex index;
         uint256 totalSyIn;
+        uint256 netPtHolding;
         uint256 blockTime;
         ApproxParams approx;
     }
 
     /**
      * @dev algorithm:
-        - Bin search the amount of PT to swapExactOut
-        - Swap that amount of PT out
-        - Pair the remaining PT with the SY to add liquidity
-        - Stop when the ratio of PT / totalPt & SY / totalSy is approx
-        - guess & approx is for netPtFromSwap
+     *     - Bin search the amount of PT to swapExactOut
+     *     - Swap that amount of PT out
+     *     - Pair the remaining PT with the SY to add liquidity
+     *     - Stop when the ratio of PT / totalPt & SY / totalSy is approx
+     *     - guess & approx is for netPtFromSwap
      */
     function approxSwapSyToAddLiquidity(
         MarketState memory _market,
         PYIndex _index,
         uint256 _totalSyIn,
+        uint256 _netPtHolding,
         uint256 _blockTime,
         ApproxParams memory _approx
-    ) internal pure returns (uint256 /*netPtFromSwap*/, uint256 /*netSySwap*/, uint256 /*netSyFee*/) {
-        Args6 memory a = Args6(_market, _index, _totalSyIn, _blockTime, _approx);
+    ) internal pure returns (uint256, /*netPtFromSwap*/ uint256, /*netSySwap*/ uint256 /*netSyFee*/) {
+        Args6 memory a = Args6(_market, _index, _totalSyIn, _netPtHolding, _blockTime, _approx);
 
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
         if (a.approx.guessOffchain == 0) {
@@ -427,15 +448,17 @@ library MarketApproxPtOutLib {
                 uint256 netTotalSy = uint256(a.market.totalSy) + netSyIn - netSyToReserve;
 
                 // it is desired that
-                // netPtFromSwap / newTotalPt = netSyRemaining / netTotalSy
+                // (netPtFromSwap + netPtHolding) / newTotalPt = netSyRemaining / netTotalSy
                 // which is equivalent to
-                // netPtFromSwap * netTotalSy = netSyRemaining * newTotalPt
+                // (netPtFromSwap + netPtHolding) * netTotalSy = netSyRemaining * newTotalPt
 
-                ptNumerator = guess * netTotalSy;
+                ptNumerator = (guess + a.netPtHolding) * netTotalSy;
                 syNumerator = (a.totalSyIn - netSyIn) * newTotalPt;
             }
 
-            if (PMath.isAApproxB(ptNumerator, syNumerator, a.approx.eps)) return (guess, netSyIn, netSyFee);
+            if (PMath.isAApproxB(ptNumerator, syNumerator, a.approx.eps)) {
+                return (guess, netSyIn, netSyFee);
+            }
 
             if (ptNumerator <= syNumerator) {
                 // needs more PT
@@ -450,12 +473,12 @@ library MarketApproxPtOutLib {
 
     /**
      * @dev algorithm:
-        - Bin search the amount of PT to swapExactOut
-        - Flashswap that amount of PT out
-        - Pair all the PT with the YT to redeem SY
-        - Use the SY to repay the flashswap debt
-        - Stop when the amount of YT required to pair with PT is approx exactYtIn
-        - guess & approx is for netPtFromSwap
+     *     - Bin search the amount of PT to swapExactOut
+     *     - Flashswap that amount of PT out
+     *     - Pair all the PT with the YT to redeem SY
+     *     - Use the SY to repay the flashswap debt
+     *     - Stop when the amount of YT required to pair with PT is approx exactYtIn
+     *     - guess & approx is for netPtFromSwap
      */
     function approxSwapExactYtForPt(
         MarketState memory market,
@@ -463,7 +486,7 @@ library MarketApproxPtOutLib {
         uint256 exactYtIn,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256 /*netPtOut*/, uint256 /*totalPtSwapped*/, uint256 /*netSyFee*/) {
+    ) internal pure returns (uint256, /*netPtOut*/ uint256, /*totalPtSwapped*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, exactYtIn);
@@ -479,8 +502,9 @@ library MarketApproxPtOutLib {
             uint256 netYtToPull = index.syToAssetUp(netSyOwed);
 
             if (netYtToPull <= exactYtIn) {
-                if (PMath.isASmallerApproxB(netYtToPull, exactYtIn, approx.eps))
+                if (PMath.isASmallerApproxB(netYtToPull, exactYtIn, approx.eps)) {
                     return (guess - netYtToPull, guess, netSyFee);
+                }
                 approx.guessMin = guess;
             } else {
                 approx.guessMax = guess - 1;
@@ -521,7 +545,8 @@ library MarketApproxPtOutLib {
     }
 
     function validateApprox(ApproxParams memory approx) internal pure {
-        if (approx.guessMin > approx.guessMax || approx.eps > PMath.ONE)
+        if (approx.guessMin > approx.guessMax || approx.eps > PMath.ONE) {
             revert Errors.ApproxParamsInvalid(approx.guessMin, approx.guessMax, approx.eps);
+        }
     }
 }

package/deployments/1-core.json

@@ -4,6 +4,7 @@
         "chainId": 1,
         "treasury": "0x8270400d528c34e1596EF367eeDEc99080A1b592",
         "governance": "0x8119EC16F0573B7dAc7C0CB94EB504FB32456ee1",
+        "devMultisig": "0xE6F0489ED91dc27f40f9dbe8f81fccbFC16b9cb1",
         "pendle": "0x808507121b80c02388fad14726482e061b8da827",
         "lzEndpoint": "0x66A71Dcef29A0fFBDBE3c6a460a3B5BC225Cd675",
         "wrappedNative": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
@@ -21,11 +22,10 @@
     "marketFactory": "0x27b1dAcd74688aF24a64BD3C9C1B143118740784",
     "bulkSellerFactory": "0x4B1da107B50529d53e5C906a79eaEcDCbC0E1dE3",
     "bulkSellerOffchain": "0x9ACc60F915dFcd190D270fc92567aE71776bd320",
-    "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
+    "router": "0x00000000005BBB0EF59571E58418F9a4357b68A0",
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
     "pendleSwap": "0x324D838b26Eb73786bDBBc53bb0682F1EBB50603",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
-    "routerHelper2": "0x2ed3af0275a1fd0c53c39d70241a1c14e8ce37d3",
     "ptOracle": "0xbbd487268A295531d299c125F3e5f749884A3e30",
     "yieldContractFactoryV3": "0xdF3601014686674e53d1Fa52F7602525483F9122",
     "marketFactoryV3": "0x1A6fCc85557BC4fB7B534ed835a03EF056552D52",
@@ -35,5 +35,7 @@
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
     "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
     "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
-    "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9"
+    "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9",
+    "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
+    "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64"
 }

package/deployments/10-core.json

@@ -4,6 +4,7 @@
         "chainId": 10,
         "treasury": "0xE972D450ec5b11b99D97760422e0E054Afbc8042",
         "governance": "0xa06C863fcf17cA6f24AA81aeA75E23953193fF6A",
+        "devMultisig": "0x79d7a5e8b130eEf1e022b3EDEE4DAF226DC168CA",
         "pendle": "0xBC7B1Ff1c6989f006a1185318eD4E7b5796e66E1",
         "lzEndpoint": "0x3c2269811836af69497E5F486A85D7316753cf62",
         "wrappedNative": "0x4200000000000000000000000000000000000006",
@@ -18,11 +19,10 @@
     "PENDLE": "0xBC7B1Ff1c6989f006a1185318eD4E7b5796e66E1",
     "yieldContractFactory": "0xf5a7De2D276dbda3EEf1b62A9E718EFf4d29dDC8",
     "marketFactory": "0x17F100fB4bE2707675c6439468d38249DD993d58",
-    "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
+    "router": "0x00000000005BBB0EF59571E58418F9a4357b68A0",
     "routerStatic": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0",
     "pendleSwap": "0x85D0C209FC632e6908D78BE08646dE3e39A58453",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
-    "routerHelper2": "0x25e5e9E134ddAf1D378fcB0Ec8dbd3F148cb55FD",
     "ptOracle": "0x0b692f06CA82e3075dC537224450885Fd138e655",
     "externalRewardDistributor": "0x1fBaCedf510dAA79dfD9B41227A7ba192d5D548D",
     "yieldContractFactoryV3": "0xfa6B22FC4c3Ad88B68c16b3061a16b1714F6Bd57",
@@ -30,5 +30,7 @@
     "liquiditySeedingHelper": "0xFc7A495389cD3454f5cC0Ecaa55D30E343A1Fc16",
     "receiverEndpoint": "0xED18de5442297a4Ec1ce59C7c7d9427Adc2A012b",
     "vePendle": "0xd5C47D2383Fddc19596489280C0A33AC42b2bB18",
-    "gaugeController": "0x6875e4A945E498FE1B90BbB13CFbAF0b68658C9C"
+    "gaugeController": "0x6875e4A945E498FE1B90BbB13CFbAF0b68658C9C",
+    "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
+    "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64"
 }

package/deployments/42161-core.json

@@ -4,6 +4,7 @@
         "chainId": 42161,
         "treasury": "0xCbcb48e22622a3778b6F14C2f5d258Ba026b05e6",
         "governance": "0x7877AdFaDEd756f3248a0EBfe8Ac2E2eF87b75Ac",
+        "devMultisig": "0x3c0f8F070E6400C1C4eD10CfF85dE4c643b66bd3",
         "pendle": "0x0c880f6761F1af8d9Aa9C466984b80DAb9a8c9e8",
         "lzEndpoint": "0x3c2269811836af69497E5F486A85D7316753cf62",
         "wrappedNative": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
@@ -18,11 +19,10 @@
     "PENDLE": "0x0c880f6761F1af8d9Aa9C466984b80DAb9a8c9e8",
     "yieldContractFactory": "0x28dE02Ac3c3F5ef427e55c321F73fDc7F192e8E4",
     "marketFactory": "0xf5a7De2D276dbda3EEf1b62A9E718EFf4d29dDC8",
-    "router": "0x0000000001e4ef00d069e71d6ba041b0a16f7ea0",
+    "router": "0x00000000005BBB0EF59571E58418F9a4357b68A0",
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
     "pendleSwap": "0x8e09Aa43885d99701AB047dA2aC98aECC13807B0",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
-    "routerHelper2": "0x64e50365eb97a199d71b15e32761c4b9147cd0f0",
     "ptOracle": "0x7e16e4253CE4a1C96422a9567B23b4b5Ebc207F1",
     "yieldContractFactoryV3": "0xEb38531db128EcA928aea1B1CE9E5609B15ba146",
     "marketFactoryV3": "0x2FCb47B58350cD377f94d3821e7373Df60bD9Ced",
@@ -31,5 +31,8 @@
     "vePendle": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
     "gaugeController": "0x1e56299ebc8a1010cec26005d12e3e5c5cc2db00",
     "arbMerkleDistribution": "0x23a102e78D1FF1645a3666691495174764a5FCAF",
-    "linearDistributor": "0x83d85AEDD308261d847C3eb8d7146457bD8F38E8"
+    "linearDistributor": "0x83d85AEDD308261d847C3eb8d7146457bD8F38E8",
+    "limitBackendHelper": "0xa3b3442D8f9ceb45D87b5f32115d94e9b7FcB114",
+    "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
+    "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64"
 }

package/deployments/42161-markets/AAVE-USDC-JUNE2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY aUSDC",
+    "SY": "0x50288c30c37FA1Ec6167a31E575EA8632645dE20",
+    "YT": "0xA1c32EF8d3c4c30cB596bAb8647e11daF0FA5C94",
+    "PT": "0xb72b988CAF33f3d8A6d816974fE8cAA199E5E86c",
+    "market": "0x8621c587059357d6C669f72dA3Bfe1398fc0D0B5",
+    "expiry": 1719446400,
+    "scalarRoot": "112567687675000000000",
+    "initAnchor": "1029547938000000000",
+    "lnFeeRateRoot": "499875041000000"
+}

package/deployments/42161-markets/WSTETH-ARBITRUM-MARCH2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY wstETH",
+    "SY": "0x80c12D5b6Cc494632Bf11b03F09436c8B61Cc5Df",
+    "YT": "0xcA71E00e364BB033371a7F61f3F6B803b06e9fC4",
+    "PT": "0x5A4e68E1F82dD4eAFBda13e47E0EC3cc452ED521",
+    "market": "0x58F50De493B6bE3585558F95F208dE489C296E24",
+    "expiry": 1711584000,
+    "scalarRoot": "375475280800000000000",
+    "initAnchor": "1011384347000000000",
+    "lnFeeRateRoot": "299955008997942"
+}

package/deployments/42161-markets/WSTETHSILO-ETH-MARCH2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY sETH-wstEthSilo",
+    "SY": "0x22B9E6f6C462BB0B03f76d3A8246950d95f03692",
+    "YT": "0x0C9d0cAf36c14F26d29a18D84b19A4c2565F5739",
+    "PT": "0x9ADDde3a8819c2eED4E5113B7aA1cecf4096BEc3",
+    "market": "0x6acacf8dC9d489AA83dbD4390BBe1163D2585e70",
+    "expiry": 1711584000,
+    "scalarRoot": "151089382436000000000",
+    "initAnchor": "1013067323000000000",
+    "lnFeeRateRoot": "499875041000000"
+}

package/deployments/56-core.json

@@ -4,6 +4,7 @@
         "chainId": 56,
         "treasury": "0xd77E9062c6DF3F2d1CB5Bf45855fa1E7712A059e",
         "governance": "0xA06627d9884996BC27a7c20fDA94FC94C13aa9Ec",
+        "devMultisig": "0x2ad76D576D5910F32227B2F07efC21b3F559858C",
         "pendle": "0xb3Ed0A426155B79B898849803E3B36552f7ED507",
         "lzEndpoint": "0x3c2269811836af69497E5F486A85D7316753cf62",
         "wrappedNative": "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
@@ -18,16 +19,17 @@
     "PENDLE": "0xb3Ed0A426155B79B898849803E3B36552f7ED507",
     "yieldContractFactory": "0xa2530b4cfBF271e2B409A05C2CE520e4cB5fCc88",
     "marketFactory": "0x2bEa6BfD8fbFF45aA2a893EB3B6d85D10EFcC70E",
-    "router": "0x00000000025EFaDc0b8d17d3d87aB5056e3D2510",
+    "router": "0x00000000005BBB0EF59571E58418F9a4357b68A0",
     "routerStatic": "0x2700ADB035F82a11899ce1D3f1BF8451c296eABb",
     "pendleSwap": "0xD85d2F484DF4329746325e7398f3fC3E1915a173",
     "routerHelper": "0x09D65812dCD0f276e052583d41885cA5C7Dd0086",
-    "routerHelper2": "0x46aCbe071f580bfC09C6F48326f01148991DB107",
     "ptOracle": "0x70ee0A6DB4F5a2Dc4d9c0b57bE97B9987e75BAFD",
     "yieldContractFactoryV3": "0x40Ae6da2d92aa3DCb7f8d7a7209FD12BDfcb7C85",
     "marketFactoryV3": "0xC40fEbF5A33b8C92B187d9be0fD3fe0ac2E4B07c",
     "liquiditySeedingHelper": "0x203D3A2Fd52973A34bAb6fC50E3B69863bdb769C",
     "receiverEndpoint": "0x998CF52b2585e05494BF9F2bF502351a9C7FdA8f",
     "vePendle": "0x8A09574b0401A856d89d1b583eE22E8cb0C5530B",
-    "gaugeController": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0"
+    "gaugeController": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0",
+    "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
+    "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64"
 }