@pendle/core-v2 0.13.1-testnet → 0.14.0-testnet

package/contracts/router/base/MarketApproxLib.sol

@@ -12,15 +12,15 @@ struct ApproxParams {
     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 swapExactScyForPt 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 Scy formula
+    /// 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
-    /// netScyNeed = calcSwapScyForExactPt(mid)
-    /// if (netScyNeed > exactScyIn) guessMax = mid - 1 // since the maximum Scy in can't exceed the exactScyIn
+    /// 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 netScyNeed <= exactScyIn, the result might be usable. If the netScyNeed is within eps of
-    /// exactScyIn (ex eps=0.1% => we have used 99.9% the amount of Scy specified), mid will be chosen as the final guess result
+    /// 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
@@ -47,14 +47,21 @@ library MarketApproxPtInLib {
     struct Args1 {
         MarketState market;
         PYIndex index;
-        uint256 minScyOut;
+        uint256 minSyOut;
         uint256 blockTime;
     }
 
-    function approxSwapPtForExactScy(
+    /**
+     * @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
+     */
+    function approxSwapPtForExactSy(
         MarketState memory _market,
         PYIndex _index,
-        uint256 _minScyOut,
+        uint256 _minSyOut,
         uint256 _blockTime,
         ApproxParams memory _approx
     )
@@ -62,17 +69,11 @@ library MarketApproxPtInLib {
         pure
         returns (
             uint256, /*netPtIn*/
-            uint256, /*netScyOut*/
-            uint256 /*netScyFee*/
+            uint256, /*netSyOut*/
+            uint256 /*netSyFee*/
         )
     {
-        /*
-        the algorithm is essentially to:
-        1. binary search netPtIn
-        2. if netScyOut is greater & approx minScyOut => answer found
-        */
-
-        Args1 memory a = Args1(_market, _index, _minScyOut, _blockTime);
+        Args1 memory a = Args1(_market, _index, _minSyOut, _blockTime);
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
         ApproxParamsPtIn memory p = newApproxParamsPtIn(_approx, 0, calcMaxPtIn(comp.totalAsset));
 
@@ -83,13 +84,13 @@ library MarketApproxPtInLib {
                 continue;
             }
 
-            (uint256 netScyOut, uint256 netScyFee) = calcScyOut(a.market, comp, a.index, guess);
+            (uint256 netSyOut, uint256 netSyFee) = calcSyOut(a.market, comp, a.index, guess);
 
-            if (netScyOut >= a.minScyOut) {
+            if (netSyOut >= a.minSyOut) {
                 p.guessMax = guess;
-                bool isAnswerAccepted = Math.isAGreaterApproxB(netScyOut, a.minScyOut, p.eps);
+                bool isAnswerAccepted = Math.isAGreaterApproxB(netSyOut, a.minSyOut, p.eps);
                 if (isAnswerAccepted) {
-                    return (guess, netScyOut, netScyFee);
+                    return (guess, netSyOut, netSyFee);
                 }
             } else {
                 p.guessMin = guess;
@@ -101,14 +102,23 @@ library MarketApproxPtInLib {
     struct Args2 {
         MarketState market;
         PYIndex index;
-        uint256 exactScyIn;
+        uint256 exactSyIn;
         uint256 blockTime;
     }
 
-    function approxSwapExactScyForYt(
+    /**
+     * @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 PT to repay the flashswap greater approx the amount of PT owed
+        - guess & approx is for netYtOut (also netPtIn)
+     */
+    function approxSwapExactSyForYt(
         MarketState memory _market,
         PYIndex _index,
-        uint256 _exactScyIn,
+        uint256 _exactSyIn,
         uint256 _blockTime,
         ApproxParams memory _approx
     )
@@ -116,35 +126,34 @@ library MarketApproxPtInLib {
         pure
         returns (
             uint256, /*netYtOut*/
-            uint256 /*netScyFee*/
+            uint256 /*netSyFee*/
         )
     {
-        Args2 memory a = Args2(_market, _index, _exactScyIn, _blockTime);
+        Args2 memory a = Args2(_market, _index, _exactSyIn, _blockTime);
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
 
-        // at minimum we will flashswap exactScyIn since we have enough SCY to payback the PT loan
+        // at minimum we will flashswap exactSyIn since we have enough SY to payback the PT loan
         ApproxParamsPtIn memory p = newApproxParamsPtIn(
             _approx,
-            a.index.scyToAsset(a.exactScyIn),
+            a.index.syToAsset(a.exactSyIn),
             calcMaxPtIn(comp.totalAsset)
         );
 
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
-            // ytOutGuess = ptInGuess
             (bool isGoodSlope, uint256 guess) = nextGuess(p, comp, a.market.totalPt, iter);
             if (!isGoodSlope) {
                 p.guessMax = guess;
                 continue;
             }
 
-            (uint256 netScyOut, uint256 netScyFee) = calcScyOut(a.market, comp, a.index, guess);
+            (uint256 netSyOut, uint256 netSyFee) = calcSyOut(a.market, comp, a.index, guess);
 
-            uint256 maxPtPayable = a.index.scyToAsset(netScyOut + a.exactScyIn);
+            uint256 maxPtPayable = a.index.syToAsset(netSyOut + a.exactSyIn);
 
             if (guess <= maxPtPayable) {
                 p.guessMin = guess;
                 bool isAnswerAccepted = Math.isASmallerApproxB(guess, maxPtPayable, p.eps);
-                if (isAnswerAccepted) return (guess, netScyFee);
+                if (isAnswerAccepted) return (guess, netSyFee);
             } else {
                 p.guessMax = guess;
             }
@@ -159,6 +168,14 @@ library MarketApproxPtInLib {
         uint256 blockTime;
     }
 
+    /**
+     * @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
+     */
     function approxSwapPtToAddLiquidity(
         MarketState memory _market,
         PYIndex _index,
@@ -170,21 +187,10 @@ library MarketApproxPtInLib {
         pure
         returns (
             uint256, /*netPtSwap*/
-            uint256, /*netScyFromSwap*/
-            uint256 /*netScyFee*/
+            uint256, /*netSyFromSwap*/
+            uint256 /*netSyFee*/
         )
     {
-        /*
-        The algorithm is essentially to:
-        1. Binary search netPtIn (therefore netScyOut)
-        2. Swap netPtIn for netScyOut
-        3. Use (totalPtIn - netPtIn) and netScyOut to mint LP
-        4. If (totalPtIn - netPtIn) / netScyOut ratio is close enough to the market's PT/SCY ratio
-        => answer found
-
-        Note that market maintains PT/SCY ratio, but here PT/asset is used instead
-        */
-
         Args6 memory a = Args6(_market, _index, _totalPtIn, _blockTime);
         require(a.market.totalLp != 0, "no existing lp");
 
@@ -205,33 +211,33 @@ library MarketApproxPtInLib {
                 continue;
             }
 
-            (uint256 netScyOut, uint256 netScyFee) = calcScyOut(a.market, comp, a.index, guess);
+            (uint256 netSyOut, uint256 netSyFee) = calcSyOut(a.market, comp, a.index, guess);
 
-            uint256 scyNumerator;
+            uint256 syNumerator;
             uint256 ptNumerator;
             {
                 uint256 newTotalPt = a.market.totalPt.Uint() + guess;
                 uint256 netPtRemaining = a.totalPtIn - guess;
-                uint256 newTotalScy = (a.market.totalScy.Uint() - netScyOut - netScyFee);
+                uint256 newTotalSy = (a.market.totalSy.Uint() - netSyOut - netSyFee);
 
                 // it is desired that
-                // netAssetOut / newTotalScy = netPtRemaining / newTotalPt
+                // netSyOut / newTotalSy = netPtRemaining / newTotalPt
                 // which is equivalent to
-                // netAssetOut * newTotalPt = netPtRemaining * newTotalScy
+                // netSyOut * newTotalPt = netPtRemaining * newTotalSy
 
-                scyNumerator = netScyOut * newTotalPt;
-                ptNumerator = netPtRemaining * newTotalScy;
+                syNumerator = netSyOut * newTotalPt;
+                ptNumerator = netPtRemaining * newTotalSy;
             }
 
-            if (Math.isAApproxB(scyNumerator, ptNumerator, p.eps)) {
-                return (guess, netScyOut, netScyFee);
+            if (Math.isAApproxB(syNumerator, ptNumerator, p.eps)) {
+                return (guess, netSyOut, netSyFee);
             }
 
-            if (scyNumerator <= ptNumerator) {
-                // needs more asset --> swap more PT
+            if (syNumerator <= ptNumerator) {
+                // needs more SY --> swap more PT
                 p.guessMin = guess + 1;
             } else {
-                // needs less asset --> swap less PT
+                // needs less SY --> swap less PT
                 p.guessMax = guess - 1;
             }
         }
@@ -245,19 +251,28 @@ library MarketApproxPtInLib {
         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 amount of PT owed is smaller approx the amount of PT to repay the flashswap
+        - guess & approx is for totalPtToSwap
+     */
     function approxSwapExactPtForYt(
         MarketState memory _market,
         PYIndex _index,
         uint256 _exactPtIn,
         uint256 _blockTime,
-        ApproxParams memory _approx // approx for totalPtToSwap
+        ApproxParams memory _approx
     )
         internal
         pure
         returns (
             uint256, /*netYtOut*/
             uint256, /*totalPtToSwap*/
-            uint256 /*netScyFee*/
+            uint256 /*netSyFee*/
         )
     {
         Args7 memory a = Args7(_market, _index, _exactPtIn, _blockTime);
@@ -277,15 +292,15 @@ library MarketApproxPtInLib {
                 continue;
             }
 
-            (uint256 netScyOut, uint256 netScyFee) = calcScyOut(a.market, comp, a.index, guess);
+            (uint256 netSyOut, uint256 netSyFee) = calcSyOut(a.market, comp, a.index, guess);
 
-            uint256 netAssetOut = a.index.scyToAsset(netScyOut);
+            uint256 netAssetOut = a.index.syToAsset(netSyOut);
 
             uint256 maxPtPayable = netAssetOut + a.exactPtIn;
             if (guess <= maxPtPayable) {
                 p.guessMin = guess;
                 if (Math.isASmallerApproxB(guess, maxPtPayable, p.eps)) {
-                    return (netAssetOut, guess, netScyFee);
+                    return (netAssetOut, guess, netSyFee);
                 }
             } else {
                 p.guessMax = guess - 1;
@@ -296,15 +311,15 @@ library MarketApproxPtInLib {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcScyOut(
+    function calcSyOut(
         MarketState memory market,
         MarketPreCompute memory comp,
         PYIndex index,
         uint256 netPtIn
-    ) internal pure returns (uint256 netScyOut, uint256 netScyFee) {
-        (int256 _netScyOut, int256 _netScyFee) = market.calcTrade(comp, index, netPtIn.neg());
-        netScyOut = _netScyOut.Uint();
-        netScyFee = _netScyFee.Uint();
+    ) internal pure returns (uint256 netSyOut, uint256 netSyFee) {
+        (int256 _netSyOut, int256 _netSyFee) = market.calcTrade(comp, index, netPtIn.neg());
+        netSyOut = _netSyOut.Uint();
+        netSyFee = _netSyFee.Uint();
     }
 
     function newApproxParamsPtIn(
@@ -396,14 +411,21 @@ library MarketApproxPtOutLib {
     struct Args4 {
         MarketState market;
         PYIndex index;
-        uint256 exactScyIn;
+        uint256 exactSyIn;
         uint256 blockTime;
     }
 
-    function approxSwapExactScyForPt(
+    /**
+     * @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
+     */
+    function approxSwapExactSyForPt(
         MarketState memory _market,
         PYIndex _index,
-        uint256 _exactScyIn,
+        uint256 _exactSyIn,
         uint256 _blockTime,
         ApproxParams memory _approx
     )
@@ -411,16 +433,10 @@ library MarketApproxPtOutLib {
         pure
         returns (
             uint256, /*netPtOut*/
-            uint256 /*netScyFee*/
+            uint256 /*netSyFee*/
         )
     {
-        /*
-        1. Binary search netPtOut
-        2. Calc netScyIn to swap to receive netPtOut
-        2. If netScyIn < exactScyIn && netScyIn ~ exactScyIn => answer found
-        */
-
-        Args4 memory a = Args4(_market, _index, _exactScyIn, _blockTime);
+        Args4 memory a = Args4(_market, _index, _exactSyIn, _blockTime);
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
         ApproxParamsPtOut memory p = newApproxParamsPtOut(
             _approx,
@@ -431,12 +447,12 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netScyIn, uint256 netScyFee) = calcScyIn(a.market, comp, a.index, guess);
+            (uint256 netSyIn, uint256 netSyFee) = calcSyIn(a.market, comp, a.index, guess);
 
-            if (netScyIn <= a.exactScyIn) {
+            if (netSyIn <= a.exactSyIn) {
                 p.guessMin = guess;
-                bool isAnswerAccepted = Math.isASmallerApproxB(netScyIn, a.exactScyIn, p.eps);
-                if (isAnswerAccepted) return (guess, netScyFee);
+                bool isAnswerAccepted = Math.isASmallerApproxB(netSyIn, a.exactSyIn, p.eps);
+                if (isAnswerAccepted) return (guess, netSyFee);
             } else {
                 p.guessMax = guess - 1;
             }
@@ -448,14 +464,22 @@ library MarketApproxPtOutLib {
     struct Args5 {
         MarketState market;
         PYIndex index;
-        uint256 minScyOut;
+        uint256 minSyOut;
         uint256 blockTime;
     }
 
-    function approxSwapYtForExactScy(
+    /**
+     * @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
+     */
+    function approxSwapYtForExactSy(
         MarketState memory _market,
         PYIndex _index,
-        uint256 _minScyOut,
+        uint256 _minSyOut,
         uint256 _blockTime,
         ApproxParams memory _approx
     )
@@ -463,19 +487,11 @@ library MarketApproxPtOutLib {
         pure
         returns (
             uint256, /*netYtIn*/
-            uint256, /*netScyOut*/
-            uint256 /*netScyFee*/
+            uint256, /*netSyOut*/
+            uint256 /*netSyFee*/
         )
     {
-        /*
-        1. Binary search netPtOut (therefore netScyIn)
-        2. Flashswap netPtOut (now we owe netScyIn)
-        3. Pair netPtOut with netYtIn Yt => get SCY (netPtOut == netYtIn)
-        4. Pay back SCY & the exceed amount of SCY (netScyOut) is transferred out to user
-        5. If netScyOut > minScyOut && netScyOut ~ minScyOut => answer found
-        */
-
-        Args5 memory a = Args5(_market, _index, _minScyOut, _blockTime);
+        Args5 memory a = Args5(_market, _index, _minSyOut, _blockTime);
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
         ApproxParamsPtOut memory p = newApproxParamsPtOut(
             _approx,
@@ -486,15 +502,15 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netScyOwed, uint256 netScyFee) = calcScyIn(a.market, comp, a.index, guess);
+            (uint256 netSyOwed, uint256 netSyFee) = calcSyIn(a.market, comp, a.index, guess);
 
-            uint256 netAssetToRepay = a.index.scyToAssetUp(netScyOwed);
-            uint256 netScyOut = a.index.assetToScy(guess - netAssetToRepay);
+            uint256 netAssetToRepay = a.index.syToAssetUp(netSyOwed);
+            uint256 netSyOut = a.index.assetToSy(guess - netAssetToRepay);
 
-            if (netScyOut >= a.minScyOut) {
+            if (netSyOut >= a.minSyOut) {
                 p.guessMax = guess;
-                if (Math.isAGreaterApproxB(netScyOut, a.minScyOut, p.eps)) {
-                    return (guess, netScyOut, netScyFee);
+                if (Math.isAGreaterApproxB(netSyOut, a.minSyOut, p.eps)) {
+                    return (guess, netSyOut, netSyFee);
                 }
             } else {
                 p.guessMin = guess + 1;
@@ -506,14 +522,22 @@ library MarketApproxPtOutLib {
     struct Args6 {
         MarketState market;
         PYIndex index;
-        uint256 totalScyIn;
+        uint256 totalSyIn;
         uint256 blockTime;
     }
 
-    function approxSwapScyToAddLiquidity(
+    /**
+     * @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
+     */
+    function approxSwapSyToAddLiquidity(
         MarketState memory _market,
         PYIndex _index,
-        uint256 _totalScyIn,
+        uint256 _totalSyIn,
         uint256 _blockTime,
         ApproxParams memory _approx
     )
@@ -521,21 +545,11 @@ library MarketApproxPtOutLib {
         pure
         returns (
             uint256, /*netPtFromSwap*/
-            uint256, /*netScySwap*/
-            uint256 /*netScyFee*/
+            uint256, /*netSySwap*/
+            uint256 /*netSyFee*/
         )
     {
-        /*
-        1. Binary search netPtOut (therefore netScyIn)
-        2. Swap netScyIn for netPtOut
-        3. Use netPtOut and (totalScyIn - netScyIn) to mint LP
-        4. If netPtOut / (totalScyIn - netScyIn) ratio is close enough to the market's PT/SCY ratio
-        => answer found
-
-        Note that market maintains PT/SCY ratio, but here PT/asset is used instead
-        */
-
-        Args6 memory a = Args6(_market, _index, _totalScyIn, _blockTime);
+        Args6 memory a = Args6(_market, _index, _totalSyIn, _blockTime);
         require(a.market.totalLp != 0, "no existing lp");
 
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
@@ -548,35 +562,35 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netScyIn, uint256 netScyFee) = calcScyIn(a.market, comp, a.index, guess);
+            (uint256 netSyIn, uint256 netSyFee) = calcSyIn(a.market, comp, a.index, guess);
 
-            if (netScyIn > a.totalScyIn) {
+            if (netSyIn > a.totalSyIn) {
                 p.guessMax = guess - 1;
                 continue;
             }
 
-            uint256 scyNumerator;
+            uint256 syNumerator;
             uint256 ptNumerator;
 
             {
-                uint256 netScyRemaining = a.totalScyIn - netScyIn;
+                uint256 netSyRemaining = a.totalSyIn - netSyIn;
                 uint256 newTotalPt = a.market.totalPt.Uint() - guess;
-                uint256 netTotalScy = comp.totalAsset.Uint() + netScyIn - netScyFee;
+                uint256 netTotalSy = comp.totalAsset.Uint() + netSyIn - netSyFee;
 
                 // it is desired that
-                // guess / newTotalPt = netScyRemaining / netTotalScy
+                // netPtFromSwap / newTotalPt = netSyRemaining / netTotalSy
                 // which is equivalent to
-                // guess * netTotalScy = netScyRemaining * newTotalPt
+                // netPtFromSwap * netTotalSy = netSyRemaining * newTotalPt
 
-                ptNumerator = guess * netTotalScy;
-                scyNumerator = netScyRemaining * newTotalPt;
+                ptNumerator = guess * netTotalSy;
+                syNumerator = netSyRemaining * newTotalPt;
             }
 
-            if (Math.isAApproxB(ptNumerator, scyNumerator, p.eps)) {
-                return (guess, netScyIn, netScyFee);
+            if (Math.isAApproxB(ptNumerator, syNumerator, p.eps)) {
+                return (guess, netSyIn, netSyFee);
             }
 
-            if (ptNumerator <= scyNumerator) {
+            if (ptNumerator <= syNumerator) {
                 // needs more PT
                 p.guessMin = guess + 1;
             } else {
@@ -592,9 +606,18 @@ library MarketApproxPtOutLib {
         PYIndex index;
         uint256 exactYtIn;
         uint256 blockTime;
-        uint256 maxScyPayable;
+        uint256 maxSyPayable;
     }
 
+    /**
+     * @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 SY owed is smaller approx the amount of SY to repay the flashswap
+        - guess & approx is for netPtFromSwap
+     */
     function approxSwapExactYtForPt(
         MarketState memory _market,
         PYIndex _index,
@@ -607,7 +630,7 @@ library MarketApproxPtOutLib {
         returns (
             uint256, /*netPtOut*/
             uint256, /*totalPtSwapped*/
-            uint256 /*netScyFee*/
+            uint256 /*netSyFee*/
         )
     {
         Args8 memory a = Args8(
@@ -615,7 +638,7 @@ library MarketApproxPtOutLib {
             _index,
             _exactYtIn,
             _blockTime,
-            _index.assetToScy(_exactYtIn)
+            _index.assetToSy(_exactYtIn)
         );
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
         ApproxParamsPtOut memory p = newApproxParamsPtOut(
@@ -627,12 +650,12 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netScyOwed, uint256 netScyFee) = calcScyIn(a.market, comp, a.index, guess);
+            (uint256 netSyOwed, uint256 netSyFee) = calcSyIn(a.market, comp, a.index, guess);
 
-            if (netScyOwed <= a.maxScyPayable) {
+            if (netSyOwed <= a.maxSyPayable) {
                 p.guessMin = guess;
-                if (Math.isASmallerApproxB(netScyOwed, a.maxScyPayable, p.eps)) {
-                    return (guess - a.exactYtIn, guess, netScyFee);
+                if (Math.isASmallerApproxB(netSyOwed, a.maxSyPayable, p.eps)) {
+                    return (guess - a.exactYtIn, guess, netSyFee);
                 }
             } else {
                 p.guessMax = guess - 1;
@@ -643,16 +666,16 @@ library MarketApproxPtOutLib {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcScyIn(
+    function calcSyIn(
         MarketState memory market,
         MarketPreCompute memory comp,
         PYIndex index,
         uint256 netPtOut
-    ) internal pure returns (uint256 netScyIn, uint256 netScyFee) {
-        (int256 _netScyIn, int256 _netScyFee) = market.calcTrade(comp, index, netPtOut.Int());
+    ) internal pure returns (uint256 netSyIn, uint256 netSyFee) {
+        (int256 _netSyIn, int256 _netSyFee) = market.calcTrade(comp, index, netPtOut.Int());
 
-        netScyIn = _netScyIn.abs();
-        netScyFee = _netScyFee.Uint();
+        netSyIn = _netSyIn.abs();
+        netSyFee = _netSyFee.Uint();
     }
 
     function newApproxParamsPtOut(

package/contracts/router/kyberswap/KyberSwapHelper.sol

@@ -30,14 +30,14 @@ import "./AggregationRouterHelper.sol";
 struct TokenInput {
     address tokenIn;
     uint256 netTokenIn;
-    address tokenMintScy;
+    address tokenMintSy;
     bytes kybercall;
 }
 
 struct TokenOutput {
     address tokenOut;
     uint256 minTokenOut;
-    address tokenRedeemScy;
+    address tokenRedeemSy;
     bytes kybercall;
 }
 

package/deployments/43113-core.json

@@ -0,0 +1,16 @@
+{
+    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "network": 43113,
+    "splitter": "0x93217b443F75aDCc96cF888d934E42421896b261",
+    "lzEndpoint": "0x93f54D755A063cE7bB9e6Ac47Eccc8e33411d706",
+    "treasury": "0xa123528ad71ef5c5bc36D4A78083b2452Ec1F233",
+    "PENDLE": "0xf1857a9F1df68159F710aA9198B6e2A373d28151",
+    "yieldContractFactory": "0xAe8bc036451af7c8F96Fd90642e163392d21D33b",
+    "marketFactory": "0x540Ec7BEd6aCE1726234DC0B8DBE7D44f6b37843",
+    "router": "0x7097112fbEc6BB001352fC98A3470d1951464F5B",
+    "routerStatic": "0xf3E9DeDdd01aa9bD0E18087c4729e82Bc66f366d",
+    "vePendle": "0x138C04c3602e58E1176168a58BE2c10eFd8c1b7e",
+    "senderEndpoint": "0x1B7Ec861Ad05843F0Fb34716B4fc94409655e1A3",
+    "votingController": "0xA2a12e2e0F31C4e92aEf08803fBA4e0DcD2bD726",
+    "gaugeController": "0xecBe97316Ee3F77E511D815cA432Ca2914fBa347"
+}

package/deployments/43113-markets/benqi-market-QI-USDC-FEB-2ND.json

@@ -0,0 +1,8 @@
+{
+    "symbol": "SY-qiUSDC",
+    "SY": "0xf1ce104816e7578EaBcc9c148C58B1b287ccd387",
+    "expiry": 1675382400,
+    "PT": "0xAaBbDd4E38E4669d37810B4B1A4747f94beeF73A",
+    "YT": "0x37613Fb19988c395E6a2e7C062fDa7823ce4bE1a",
+    "market": "0xEf74AfeB451F3662Bc8600d4468FB7eF13b36a97"
+}

package/deployments/43113-markets/benqi-market-QI-WETH-DEC-1ST.json

@@ -0,0 +1,8 @@
+{
+    "symbol": "SY-qiWETH",
+    "SY": "0x4C63A4B1F031D2aF9dcd4E070b30566D563c87fc",
+    "expiry": 1669852800,
+    "PT": "0x208B0a9F18346A532a60cdAf364b18775bA9c087",
+    "YT": "0x1814Baf30a36247f7005a07914cd269bEe0A4a85",
+    "market": "0x4d26b9742722e1D0F81dF3b2ee053995f83d4831"
+}