@pendle/core-v2 0.12.1-testnet → 0.13.0-testnet

package/contracts/{libraries/math → router/base}/MarketApproxLib.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.15;
+pragma solidity 0.8.17;
 
-import "./Math.sol";
-import "./MarketMathCore.sol";
+import "../../core/libraries/math/Math.sol";
+import "../../core/Market/MarketMathCore.sol";
 
 struct ApproxParams {
     uint256 guessMin;
@@ -63,7 +63,7 @@ library MarketApproxPtInLib {
         returns (
             uint256, /*netPtIn*/
             uint256, /*netScyOut*/
-            uint256 /*netScyToReserve*/
+            uint256 /*netScyFee*/
         )
     {
         /*
@@ -72,54 +72,43 @@ library MarketApproxPtInLib {
         2. if netScyOut is greater & approx minScyOut => answer found
         */
 
-        Args1 memory arg = Args1(_market, _index, _minScyOut, _blockTime);
-        MarketPreCompute memory comp = arg.market.getMarketPreCompute(arg.index, arg.blockTime);
-        ApproxParamsPtIn memory p = newApproxParamsPtIn(_approx, comp.totalAsset);
-
-        uint256 minAssetOut = arg.index.scyToAssetUp(arg.minScyOut);
+        Args1 memory a = Args1(_market, _index, _minScyOut, _blockTime);
+        MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
+        ApproxParamsPtIn memory p = newApproxParamsPtIn(_approx, 0, calcMaxPtIn(comp.totalAsset));
 
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
-            (bool isGoodSlope, uint256 guess) = nextGuess(p, comp, arg.market.totalPt, iter);
-
+            (bool isGoodSlope, uint256 guess) = nextGuess(p, comp, a.market.totalPt, iter);
             if (!isGoodSlope) {
                 p.guessMax = guess;
                 continue;
             }
 
-            (uint256 netAssetOut, uint256 netAssetToReserve) = calcAssetOut(
-                arg.market,
-                comp,
-                guess
-            );
+            (uint256 netScyOut, uint256 netScyFee) = calcScyOut(a.market, comp, a.index, guess);
 
-            if (netAssetOut >= minAssetOut) {
+            if (netScyOut >= a.minScyOut) {
                 p.guessMax = guess;
-                bool isAnswerAccepted = Math.isAGreaterApproxB(netAssetOut, minAssetOut, p.eps);
+                bool isAnswerAccepted = Math.isAGreaterApproxB(netScyOut, a.minScyOut, p.eps);
                 if (isAnswerAccepted) {
-                    return (
-                        guess,
-                        arg.index.assetToScy(netAssetOut),
-                        arg.index.assetToScy(netAssetToReserve)
-                    );
+                    return (guess, netScyOut, netScyFee);
                 }
             } else {
                 p.guessMin = guess;
             }
         }
-        revert("approx fail");
+        revert Errors.ApproxFail();
     }
 
     struct Args2 {
         MarketState market;
         PYIndex index;
-        uint256 maxScyIn;
+        uint256 exactScyIn;
         uint256 blockTime;
     }
 
     function approxSwapExactScyForYt(
         MarketState memory _market,
         PYIndex _index,
-        uint256 _maxScyIn,
+        uint256 _exactScyIn,
         uint256 _blockTime,
         ApproxParams memory _approx
     )
@@ -127,59 +116,40 @@ library MarketApproxPtInLib {
         pure
         returns (
             uint256, /*netYtOut*/
-            uint256, /*netScyIn*/
-            uint256 /*netScyToReserve*/
+            uint256 /*netScyFee*/
         )
     {
-        /*
-        the algorithm is essentially to:
-        1. Binary search netPtIn (therefore netScyOut)
-        2. flashswap some netScyOut (now we owe netPtIn)
-        3. Use netScyOut + additional SCY from user => convert to PT + YT
-        4. Pay back PT & give user YT.
-        5. If the PT loan can be successfully & amount of additional SCY is smallerApprox maxScyIn
-        => answer found
-        */
-
-        Args2 memory arg = Args2(_market, _index, _maxScyIn, _blockTime);
-        MarketPreCompute memory comp = arg.market.getMarketPreCompute(arg.index, arg.blockTime);
-        ApproxParamsPtIn memory p = newApproxParamsPtIn(_approx, comp.totalAsset);
-
-        uint256 maxAssetIn = arg.index.scyToAsset(arg.maxScyIn);
-
-        // at minimum we will flashswap maxAssetIn since we have enough SCY to payback the PT loan
-        if (p.guessMin == 0) p.guessMin = maxAssetIn;
+        Args2 memory a = Args2(_market, _index, _exactScyIn, _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
+        ApproxParamsPtIn memory p = newApproxParamsPtIn(
+            _approx,
+            a.index.scyToAsset(a.exactScyIn),
+            calcMaxPtIn(comp.totalAsset)
+        );
 
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             // ytOutGuess = ptInGuess
-            (bool isGoodSlope, uint256 guess) = nextGuess(p, comp, arg.market.totalPt, iter);
+            (bool isGoodSlope, uint256 guess) = nextGuess(p, comp, a.market.totalPt, iter);
             if (!isGoodSlope) {
                 p.guessMax = guess;
                 continue;
             }
 
-            (uint256 netAssetOut, uint256 netAssetToReserve) = calcAssetOut(
-                arg.market,
-                comp,
-                guess
-            );
+            (uint256 netScyOut, uint256 netScyFee) = calcScyOut(a.market, comp, a.index, guess);
 
-            uint256 netAssetToPull = guess - netAssetOut;
+            uint256 maxPtPayable = a.index.scyToAsset(netScyOut + a.exactScyIn);
 
-            if (netAssetToPull <= maxAssetIn) {
+            if (guess <= maxPtPayable) {
                 p.guessMin = guess;
-                bool isAnswerAccepted = Math.isASmallerApproxB(netAssetToPull, maxAssetIn, p.eps);
-                if (isAnswerAccepted)
-                    return (
-                        guess,
-                        arg.index.assetToScy(netAssetToPull),
-                        arg.index.assetToScy(netAssetToReserve)
-                    );
+                bool isAnswerAccepted = Math.isASmallerApproxB(guess, maxPtPayable, p.eps);
+                if (isAnswerAccepted) return (guess, netScyFee);
             } else {
                 p.guessMax = guess;
             }
         }
-        revert("approx fail");
+        revert Errors.ApproxFail();
     }
 
     struct Args6 {
@@ -201,7 +171,7 @@ library MarketApproxPtInLib {
         returns (
             uint256, /*netPtSwap*/
             uint256, /*netScyFromSwap*/
-            uint256 /*netScyToReserve*/
+            uint256 /*netScyFee*/
         )
     {
         /*
@@ -215,53 +185,49 @@ library MarketApproxPtInLib {
         Note that market maintains PT/SCY ratio, but here PT/asset is used instead
         */
 
-        Args6 memory arg = Args6(_market, _index, _totalPtIn, _blockTime);
-        require(arg.market.totalLp != 0, "no existing lp");
+        Args6 memory a = Args6(_market, _index, _totalPtIn, _blockTime);
+        require(a.market.totalLp != 0, "no existing lp");
 
-        MarketPreCompute memory comp = arg.market.getMarketPreCompute(arg.index, arg.blockTime);
-        ApproxParamsPtIn memory p = newApproxParamsPtIn(_approx, comp.totalAsset);
+        MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
+        ApproxParamsPtIn memory p = newApproxParamsPtIn(
+            _approx,
+            0,
+            Math.min(a.totalPtIn, calcMaxPtIn(comp.totalAsset))
+        );
 
-        p.guessMax = Math.min(p.guessMax, arg.totalPtIn);
+        p.guessMax = Math.min(p.guessMax, a.totalPtIn);
 
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
-            (bool isGoodSlope, uint256 guess) = nextGuess(p, comp, arg.market.totalPt, iter);
+            (bool isGoodSlope, uint256 guess) = nextGuess(p, comp, a.market.totalPt, iter);
 
             if (!isGoodSlope) {
                 p.guessMax = guess;
                 continue;
             }
 
-            (uint256 netAssetOut, uint256 netAssetToReserve) = calcAssetOut(
-                arg.market,
-                comp,
-                guess
-            );
+            (uint256 netScyOut, uint256 netScyFee) = calcScyOut(a.market, comp, a.index, guess);
 
-            uint256 assetNumerator;
+            uint256 scyNumerator;
             uint256 ptNumerator;
             {
-                uint256 newTotalPt = arg.market.totalPt.Uint() + guess;
-                uint256 netPtRemaining = arg.totalPtIn - guess;
-                uint256 newTotalAsset = (comp.totalAsset.Uint() - netAssetOut - netAssetToReserve);
+                uint256 newTotalPt = a.market.totalPt.Uint() + guess;
+                uint256 netPtRemaining = a.totalPtIn - guess;
+                uint256 newTotalScy = (a.market.totalScy.Uint() - netScyOut - netScyFee);
 
                 // it is desired that
-                // netAssetOut / newTotalAsset = netPtRemaining / newTotalPt
+                // netAssetOut / newTotalScy = netPtRemaining / newTotalPt
                 // which is equivalent to
-                // netAssetOut * newTotalPt = netPtRemaining * newTotalAsset
+                // netAssetOut * newTotalPt = netPtRemaining * newTotalScy
 
-                assetNumerator = netAssetOut * newTotalPt;
-                ptNumerator = netPtRemaining * newTotalAsset;
+                scyNumerator = netScyOut * newTotalPt;
+                ptNumerator = netPtRemaining * newTotalScy;
             }
 
-            if (Math.isAApproxB(assetNumerator, ptNumerator, p.eps)) {
-                return (
-                    guess,
-                    arg.index.assetToScy(netAssetOut),
-                    arg.index.assetToScy(netAssetToReserve)
-                );
+            if (Math.isAApproxB(scyNumerator, ptNumerator, p.eps)) {
+                return (guess, netScyOut, netScyFee);
             }
 
-            if (assetNumerator <= ptNumerator) {
+            if (scyNumerator <= ptNumerator) {
                 // needs more asset --> swap more PT
                 p.guessMin = guess + 1;
             } else {
@@ -269,20 +235,20 @@ library MarketApproxPtInLib {
                 p.guessMax = guess - 1;
             }
         }
-        revert("approx fail");
+        revert Errors.ApproxFail();
     }
 
     struct Args7 {
         MarketState market;
         PYIndex index;
-        uint256 maxPtIn;
+        uint256 exactPtIn;
         uint256 blockTime;
     }
 
     function approxSwapExactPtForYt(
         MarketState memory _market,
         PYIndex _index,
-        uint256 _maxPtIn,
+        uint256 _exactPtIn,
         uint256 _blockTime,
         ApproxParams memory _approx // approx for totalPtToSwap
     )
@@ -290,71 +256,71 @@ library MarketApproxPtInLib {
         pure
         returns (
             uint256, /*netYtOut*/
-            uint256, /*netPtIn*/
             uint256, /*totalPtToSwap*/
-            uint256 /*netScyToReserve*/
+            uint256 /*netScyFee*/
         )
     {
-        Args7 memory arg = Args7(_market, _index, _maxPtIn, _blockTime);
+        Args7 memory a = Args7(_market, _index, _exactPtIn, _blockTime);
 
-        MarketPreCompute memory comp = arg.market.getMarketPreCompute(arg.index, arg.blockTime);
-        ApproxParamsPtIn memory p = newApproxParamsPtIn(_approx, comp.totalAsset);
-
-        p.guessMin = Math.max(p.guessMin, arg.maxPtIn);
+        MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
+        ApproxParamsPtIn memory p = newApproxParamsPtIn(
+            _approx,
+            a.exactPtIn,
+            calcMaxPtIn(comp.totalAsset)
+        );
 
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
-            (bool isGoodSlope, uint256 guess) = nextGuess(p, comp, arg.market.totalPt, iter);
+            (bool isGoodSlope, uint256 guess) = nextGuess(p, comp, a.market.totalPt, iter);
 
             if (!isGoodSlope) {
                 p.guessMax = guess;
                 continue;
             }
 
-            (uint256 netAssetOut, uint256 netAssetToReserve) = calcAssetOut(
-                arg.market,
-                comp,
-                guess
-            );
+            (uint256 netScyOut, uint256 netScyFee) = calcScyOut(a.market, comp, a.index, guess);
 
-            uint256 netPtPayable = netAssetOut + arg.maxPtIn;
-            if (guess <= netPtPayable) {
+            uint256 netAssetOut = a.index.scyToAsset(netScyOut);
+
+            uint256 maxPtPayable = netAssetOut + a.exactPtIn;
+            if (guess <= maxPtPayable) {
                 p.guessMin = guess;
-                uint256 netPtIn = guess - netAssetOut; // guess >= netAssetOut (market invariant)
-                if (Math.isASmallerApproxB(netPtIn, arg.maxPtIn, p.eps)) {
-                    return (netAssetOut, netPtIn, guess, arg.index.assetToScy(netAssetToReserve));
+                if (Math.isASmallerApproxB(guess, maxPtPayable, p.eps)) {
+                    return (netAssetOut, guess, netScyFee);
                 }
             } else {
                 p.guessMax = guess - 1;
             }
         }
-        revert("approx fail");
+        revert Errors.ApproxFail();
     }
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcAssetOut(
+    function calcScyOut(
         MarketState memory market,
         MarketPreCompute memory comp,
+        PYIndex index,
         uint256 netPtIn
-    ) internal pure returns (uint256 netAssetOut, uint256 netAssetToReserve) {
-        (int256 assetToAccount, int256 assetToReserve) = market.calcTrade(comp, netPtIn.neg());
-
-        netAssetOut = assetToAccount.Uint();
-        netAssetToReserve = assetToReserve.Uint();
+    ) internal pure returns (uint256 netScyOut, uint256 netScyFee) {
+        (int256 _netScyOut, int256 _netScyFee) = market.calcTrade(comp, index, netPtIn.neg());
+        netScyOut = _netScyOut.Uint();
+        netScyFee = _netScyFee.Uint();
     }
 
-    function newApproxParamsPtIn(ApproxParams memory _approx, int256 totalAsset)
-        internal
-        pure
-        returns (ApproxParamsPtIn memory res)
-    {
-        res.guessMin = _approx.guessMin;
-        res.guessMax = Math.min(_approx.guessMax, calcMaxPtIn(totalAsset));
+    function newApproxParamsPtIn(
+        ApproxParams memory _approx,
+        uint256 minGuessMin,
+        uint256 maxGuessMax
+    ) internal pure returns (ApproxParamsPtIn memory res) {
+        res.guessMin = Math.max(_approx.guessMin, minGuessMin);
+        res.guessMax = Math.min(_approx.guessMax, maxGuessMax);
+
+        if (res.guessMin > res.guessMax || _approx.eps > Math.ONE)
+            revert Errors.ApproxParamsInvalid(_approx.guessMin, _approx.guessMax, _approx.eps);
+
         res.guessOffchain = _approx.guessOffchain;
         res.maxIteration = _approx.maxIteration;
         res.eps = _approx.eps;
-
-        require(res.guessMin <= res.guessMax && res.eps <= Math.ONE, "invalid approx params");
     }
 
     function calcMaxPtIn(int256 totalAsset) internal pure returns (uint256) {
@@ -377,14 +343,18 @@ library MarketApproxPtInLib {
         return (true, guess);
     }
 
+    /**
+     * @dev it is safe to assume that p.guessMin <= p.guessMax from the initialization of p
+     * So once guessMin becomes larger, it should always be the case of ApproxFail
+     */
     function _nextGuessPrivate(ApproxParamsPtIn memory p, uint256 iter)
         private
         pure
         returns (uint256)
     {
         if (iter == 0 && p.guessOffchain != 0) return p.guessOffchain;
-        else if (p.guessMin > p.guessMax) return p.guessMax;
-        else return (p.guessMin + p.guessMax) / 2;
+        if (p.guessMin <= p.guessMax) return (p.guessMin + p.guessMax) / 2;
+        revert Errors.ApproxFail();
     }
 
     function calcSlope(
@@ -426,14 +396,14 @@ library MarketApproxPtOutLib {
     struct Args4 {
         MarketState market;
         PYIndex index;
-        uint256 maxScyIn;
+        uint256 exactScyIn;
         uint256 blockTime;
     }
 
     function approxSwapExactScyForPt(
         MarketState memory _market,
         PYIndex _index,
-        uint256 _maxScyIn,
+        uint256 _exactScyIn,
         uint256 _blockTime,
         ApproxParams memory _approx
     )
@@ -441,41 +411,38 @@ library MarketApproxPtOutLib {
         pure
         returns (
             uint256, /*netPtOut*/
-            uint256, /*netScyIn*/
-            uint256 /*netScyToReserve*/
+            uint256 /*netScyFee*/
         )
     {
         /*
         1. Binary search netPtOut
         2. Calc netScyIn to swap to receive netPtOut
-        2. If netScyIn < maxScyIn && netScyIn ~ maxScyIn => answer found
+        2. If netScyIn < exactScyIn && netScyIn ~ exactScyIn => answer found
         */
 
-        Args4 memory arg = Args4(_market, _index, _maxScyIn, _blockTime);
-        MarketPreCompute memory comp = arg.market.getMarketPreCompute(arg.index, arg.blockTime);
-        ApproxParamsPtOut memory p = newApproxParamsPtOut(_approx, comp, arg.market.totalPt);
-
-        uint256 maxAssetIn = arg.index.scyToAsset(arg.maxScyIn);
+        Args4 memory a = Args4(_market, _index, _exactScyIn, _blockTime);
+        MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
+        ApproxParamsPtOut memory p = newApproxParamsPtOut(
+            _approx,
+            0,
+            calcMaxPtOut(comp, a.market.totalPt)
+        );
 
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netAssetIn, uint256 netAssetToReserve) = calcAssetIn(arg.market, comp, guess);
+            (uint256 netScyIn, uint256 netScyFee) = calcScyIn(a.market, comp, a.index, guess);
 
-            if (netAssetIn <= maxAssetIn) {
+            if (netScyIn <= a.exactScyIn) {
                 p.guessMin = guess;
-                bool isAnswerAccepted = Math.isASmallerApproxB(netAssetIn, maxAssetIn, p.eps);
-                if (isAnswerAccepted)
-                    return (
-                        guess,
-                        arg.index.assetToScy(netAssetIn),
-                        arg.index.assetToScy(netAssetToReserve)
-                    );
+                bool isAnswerAccepted = Math.isASmallerApproxB(netScyIn, a.exactScyIn, p.eps);
+                if (isAnswerAccepted) return (guess, netScyFee);
             } else {
                 p.guessMax = guess - 1;
             }
         }
-        revert("approx fail");
+
+        revert Errors.ApproxFail();
     }
 
     struct Args5 {
@@ -497,7 +464,7 @@ library MarketApproxPtOutLib {
         returns (
             uint256, /*netYtIn*/
             uint256, /*netScyOut*/
-            uint256 /*netScyToReserve*/
+            uint256 /*netScyFee*/
         )
     {
         /*
@@ -508,37 +475,32 @@ library MarketApproxPtOutLib {
         5. If netScyOut > minScyOut && netScyOut ~ minScyOut => answer found
         */
 
-        Args5 memory arg = Args5(_market, _index, _minScyOut, _blockTime);
-        MarketPreCompute memory comp = arg.market.getMarketPreCompute(arg.index, arg.blockTime);
-        ApproxParamsPtOut memory p = newApproxParamsPtOut(_approx, comp, arg.market.totalPt);
-
-        uint256 minAssetOut = arg.index.scyToAssetUp(arg.minScyOut);
+        Args5 memory a = Args5(_market, _index, _minScyOut, _blockTime);
+        MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
+        ApproxParamsPtOut memory p = newApproxParamsPtOut(
+            _approx,
+            0,
+            calcMaxPtOut(comp, a.market.totalPt)
+        );
 
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netAssetOwed, uint256 netAssetToReserve) = calcAssetIn(
-                arg.market,
-                comp,
-                guess
-            );
+            (uint256 netScyOwed, uint256 netScyFee) = calcScyIn(a.market, comp, a.index, guess);
 
-            uint256 netAssetOut = guess - netAssetOwed;
+            uint256 netAssetToRepay = a.index.scyToAssetUp(netScyOwed);
+            uint256 netScyOut = a.index.assetToScy(guess - netAssetToRepay);
 
-            if (netAssetOut >= minAssetOut) {
+            if (netScyOut >= a.minScyOut) {
                 p.guessMax = guess;
-                if (Math.isAGreaterApproxB(netAssetOut, minAssetOut, p.eps)) {
-                    return (
-                        guess,
-                        arg.index.assetToScy(netAssetOut),
-                        arg.index.assetToScy(netAssetToReserve)
-                    );
+                if (Math.isAGreaterApproxB(netScyOut, a.minScyOut, p.eps)) {
+                    return (guess, netScyOut, netScyFee);
                 }
             } else {
                 p.guessMin = guess + 1;
             }
         }
-        revert("approx fail");
+        revert Errors.ApproxFail();
     }
 
     struct Args6 {
@@ -560,7 +522,7 @@ library MarketApproxPtOutLib {
         returns (
             uint256, /*netPtFromSwap*/
             uint256, /*netScySwap*/
-            uint256 /*netScyToReserve*/
+            uint256 /*netScyFee*/
         )
     {
         /*
@@ -573,50 +535,48 @@ library MarketApproxPtOutLib {
         Note that market maintains PT/SCY ratio, but here PT/asset is used instead
         */
 
-        Args6 memory arg = Args6(_market, _index, _totalScyIn, _blockTime);
-        require(arg.market.totalLp != 0, "no existing lp");
+        Args6 memory a = Args6(_market, _index, _totalScyIn, _blockTime);
+        require(a.market.totalLp != 0, "no existing lp");
 
-        MarketPreCompute memory comp = arg.market.getMarketPreCompute(arg.index, arg.blockTime);
-        ApproxParamsPtOut memory p = newApproxParamsPtOut(_approx, comp, arg.market.totalPt);
-
-        uint256 totalAssetIn = arg.index.scyToAsset(arg.totalScyIn);
+        MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
+        ApproxParamsPtOut memory p = newApproxParamsPtOut(
+            _approx,
+            0,
+            calcMaxPtOut(comp, a.market.totalPt)
+        );
 
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netAssetIn, uint256 netAssetToReserve) = calcAssetIn(arg.market, comp, guess);
+            (uint256 netScyIn, uint256 netScyFee) = calcScyIn(a.market, comp, a.index, guess);
 
-            if (netAssetIn > totalAssetIn) {
+            if (netScyIn > a.totalScyIn) {
                 p.guessMax = guess - 1;
                 continue;
             }
 
+            uint256 scyNumerator;
             uint256 ptNumerator;
-            uint256 assetNumerator;
 
             {
-                uint256 netAssetRemaining = totalAssetIn - netAssetIn;
-                uint256 newTotalPt = arg.market.totalPt.Uint() - guess;
-                uint256 newTotalAsset = comp.totalAsset.Uint() + netAssetIn - netAssetToReserve;
+                uint256 netScyRemaining = a.totalScyIn - netScyIn;
+                uint256 newTotalPt = a.market.totalPt.Uint() - guess;
+                uint256 netTotalScy = comp.totalAsset.Uint() + netScyIn - netScyFee;
 
                 // it is desired that
-                // guess / newTotalPt = netAssetRemaining / newTotalAsset
+                // guess / newTotalPt = netScyRemaining / netTotalScy
                 // which is equivalent to
-                // guess * newTotalAsset = netAssetRemaining * newTotalPt
+                // guess * netTotalScy = netScyRemaining * newTotalPt
 
-                ptNumerator = guess * newTotalAsset;
-                assetNumerator = netAssetRemaining * newTotalPt;
+                ptNumerator = guess * netTotalScy;
+                scyNumerator = netScyRemaining * newTotalPt;
             }
 
-            if (Math.isAApproxB(ptNumerator, assetNumerator, p.eps)) {
-                return (
-                    guess,
-                    arg.index.assetToScy(netAssetIn),
-                    arg.index.assetToScy(netAssetToReserve)
-                );
+            if (Math.isAApproxB(ptNumerator, scyNumerator, p.eps)) {
+                return (guess, netScyIn, netScyFee);
             }
 
-            if (ptNumerator <= assetNumerator) {
+            if (ptNumerator <= scyNumerator) {
                 // needs more PT
                 p.guessMin = guess + 1;
             } else {
@@ -624,21 +584,21 @@ library MarketApproxPtOutLib {
                 p.guessMax = guess - 1;
             }
         }
-        revert("approx fail");
+        revert Errors.ApproxFail();
     }
 
     struct Args8 {
         MarketState market;
         PYIndex index;
-        uint256 maxYtIn;
+        uint256 exactYtIn;
         uint256 blockTime;
-        uint256 maxScyRedeemableFromPY;
+        uint256 maxScyPayable;
     }
 
     function approxSwapExactYtForPt(
         MarketState memory _market,
         PYIndex _index,
-        uint256 _maxYtIn,
+        uint256 _exactYtIn,
         uint256 _blockTime,
         ApproxParams memory _approx
     )
@@ -646,71 +606,69 @@ library MarketApproxPtOutLib {
         pure
         returns (
             uint256, /*netPtOut*/
-            uint256, /*netYtIn*/
             uint256, /*totalPtSwapped*/
-            uint256 /*netScyToReserve*/
+            uint256 /*netScyFee*/
         )
     {
-        Args8 memory arg = Args8(
+        Args8 memory a = Args8(
             _market,
             _index,
-            _maxYtIn,
+            _exactYtIn,
             _blockTime,
-            _index.assetToScy(_maxYtIn)
+            _index.assetToScy(_exactYtIn)
+        );
+        MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
+        ApproxParamsPtOut memory p = newApproxParamsPtOut(
+            _approx,
+            a.exactYtIn,
+            calcMaxPtOut(comp, a.market.totalPt)
         );
-        MarketPreCompute memory comp = arg.market.getMarketPreCompute(arg.index, arg.blockTime);
-        ApproxParamsPtOut memory p = newApproxParamsPtOut(_approx, comp, arg.market.totalPt);
-
-        p.guessMin = Math.max(p.guessMin, arg.maxYtIn);
 
         for (uint256 iter = 0; iter < p.maxIteration; ++iter) {
             uint256 guess = nextGuess(p, iter);
 
-            (uint256 netAssetIn, uint256 netAssetToReserve) = calcAssetIn(arg.market, comp, guess);
-            uint256 netScyIn = arg.index.assetToScyUp(netAssetIn);
+            (uint256 netScyOwed, uint256 netScyFee) = calcScyIn(a.market, comp, a.index, guess);
 
-            if (netScyIn <= arg.maxScyRedeemableFromPY) {
+            if (netScyOwed <= a.maxScyPayable) {
                 p.guessMin = guess;
-                if (Math.isASmallerApproxB(netAssetIn, arg.maxYtIn, p.eps)) {
-                    return (
-                        guess - arg.maxYtIn,
-                        arg.maxYtIn,
-                        guess,
-                        arg.index.assetToScy(netAssetToReserve)
-                    );
+                if (Math.isASmallerApproxB(netScyOwed, a.maxScyPayable, p.eps)) {
+                    return (guess - a.exactYtIn, guess, netScyFee);
                 }
             } else {
                 p.guessMax = guess - 1;
             }
         }
-        revert("approx fail");
+        revert Errors.ApproxFail();
     }
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcAssetIn(
+    function calcScyIn(
         MarketState memory market,
         MarketPreCompute memory comp,
+        PYIndex index,
         uint256 netPtOut
-    ) internal pure returns (uint256 netAssetIn, uint256 netAssetToReserve) {
-        (int256 assetToAccount, int256 assetToReserve) = market.calcTrade(comp, netPtOut.Int());
+    ) internal pure returns (uint256 netScyIn, uint256 netScyFee) {
+        (int256 _netScyIn, int256 _netScyFee) = market.calcTrade(comp, index, netPtOut.Int());
 
-        netAssetIn = assetToAccount.abs();
-        netAssetToReserve = assetToReserve.Uint();
+        netScyIn = _netScyIn.abs();
+        netScyFee = _netScyFee.Uint();
     }
 
     function newApproxParamsPtOut(
         ApproxParams memory _approx,
-        MarketPreCompute memory comp,
-        int256 totalPt
+        uint256 minGuessMin,
+        uint256 maxGuessMax
     ) internal pure returns (ApproxParamsPtOut memory res) {
-        res.guessMin = _approx.guessMin;
-        res.guessMax = Math.min(_approx.guessMax, calcMaxPtOut(comp, totalPt));
+        res.guessMin = Math.max(_approx.guessMin, minGuessMin);
+        res.guessMax = Math.min(_approx.guessMax, maxGuessMax);
+
+        if (res.guessMin > res.guessMax || _approx.eps > Math.ONE)
+            revert Errors.ApproxParamsInvalid(_approx.guessMin, _approx.guessMax, _approx.eps);
+
         res.guessOffchain = _approx.guessOffchain;
         res.maxIteration = _approx.maxIteration;
         res.eps = _approx.eps;
-
-        require(res.guessMin <= res.guessMax && res.eps <= Math.ONE, "invalid approx params");
     }
 
     function calcMaxPtOut(MarketPreCompute memory comp, int256 totalPt)
@@ -726,9 +684,13 @@ library MarketApproxPtOutLib {
         return (maxPtOut.Uint() * 999) / 1000;
     }
 
+    /**
+     * @dev it is safe to assume that p.guessMin <= p.guessMax from the initialization of p
+     * So once guessMin becomes larger, it should always be the case of ApproxFail
+     */
     function nextGuess(ApproxParamsPtOut memory p, uint256 iter) private pure returns (uint256) {
         if (iter == 0 && p.guessOffchain != 0) return p.guessOffchain;
-        else if (p.guessMin > p.guessMax) return p.guessMax;
-        else return (p.guessMin + p.guessMax) / 2;
+        if (p.guessMin <= p.guessMax) return (p.guessMin + p.guessMax) / 2;
+        revert Errors.ApproxFail();
     }
 }