@pendle/core-v2 0.11.11-testnet → 0.12.0-testnet

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -11,9 +11,10 @@ import "../../libraries/math/Math.sol";
 import "../../libraries/helpers/ArrayLib.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
 import "../../libraries/SCY/SCYUtils.sol";
+import "../../libraries/Errors.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 import "../../libraries/RewardManagerAbstract.sol";
-import "../PendleERC20.sol";
+import "../PendleERC20Permit.sol";
 import "./InterestManagerYT.sol";
 
 /**
@@ -21,7 +22,12 @@ Invariance to maintain:
 - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
     guaranteed by address(0) & address(this) check in each updateForTwo function
 */
-contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, InterestManagerYT {
+contract PendleYieldToken is
+    IPYieldToken,
+    PendleERC20Permit,
+    RewardManagerAbstract,
+    InterestManagerYT
+{
     using Math for uint256;
     using SafeERC20 for IERC20;
     using ArrayLib for uint256[];
@@ -49,6 +55,11 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         _updateScyReserve();
     }
 
+    modifier notExpired() {
+        if (isExpired()) revert Errors.YCExpired();
+        _;
+    }
+
     constructor(
         address _SCY,
         address _PT,
@@ -56,7 +67,7 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
-    ) PendleERC20(_name, _symbol, __decimals) {
+    ) PendleERC20Permit(_name, _symbol, __decimals) {
         SCY = _SCY;
         PT = _PT;
         expiry = _expiry;
@@ -67,20 +78,41 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
     function mintPY(address receiverPT, address receiverYT)
         external
         nonReentrant
+        notExpired
         updateData
         returns (uint256 amountPYOut)
     {
-        require(!isExpired(), "yield contract expired");
-
-        uint256 amountScyToMint = _getFloatingScyAmount();
-
-        amountPYOut = _calcPYToMint(amountScyToMint);
-
-        _mint(receiverYT, amountPYOut);
-
-        IPPrincipalToken(PT).mintByYT(receiverPT, amountPYOut);
+        address[] memory receiverPTs = new address[](1);
+        address[] memory receiverYTs = new address[](1);
+        uint256[] memory amountScyToMints = new uint256[](1);
+
+        (receiverPTs[0], receiverYTs[0], amountScyToMints[0]) = (
+            receiverPT,
+            receiverYT,
+            _getFloatingScyAmount()
+        );
+
+        uint256[] memory amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountScyToMints);
+        amountPYOut = amountPYOuts[0];
+    }
 
-        emit Mint(msg.sender, receiverPT, receiverYT, amountScyToMint, amountPYOut);
+    /// @notice Tokenize SCY into PT + YT of equal qty. Every unit of underlying of SCY will create 1 PT + 1 YT
+    function mintPYMulti(
+        address[] calldata receiverPTs,
+        address[] calldata receiverYTs,
+        uint256[] calldata amountScyToMints
+    ) external nonReentrant notExpired updateData returns (uint256[] memory amountPYOuts) {
+        uint256 length = receiverPTs.length;
+
+        if (receiverYTs.length != length && amountScyToMints.length == length)
+            revert Errors.ArrayLengthMismatch();
+        if (length == 0) revert Errors.ArrayEmpty();
+
+        uint256 totalScyToMint = amountScyToMints.sum();
+        if (totalScyToMint > _getFloatingScyAmount())
+            revert Errors.YieldContractInsufficientScy(totalScyToMint, _getFloatingScyAmount());
+
+        amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountScyToMints);
     }
 
     /// @dev this function converts PY tokens into scy, but interests & rewards are not redeemed at the same time
@@ -109,8 +141,8 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         updateData
         returns (uint256[] memory amountScyOuts)
     {
-        require(receivers.length == amountPYToRedeems.length, "not same length");
-        require(receivers.length != 0, "empty array");
+        if (receivers.length != amountPYToRedeems.length) revert Errors.ArrayLengthMismatch();
+        if (receivers.length == 0) revert Errors.ArrayEmpty();
         amountScyOuts = _redeemPY(receivers, amountPYToRedeems);
     }
 
@@ -126,7 +158,7 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         bool redeemInterest,
         bool redeemRewards
     ) external nonReentrant updateData returns (uint256 interestOut, uint256[] memory rewardsOut) {
-        require(redeemInterest || redeemRewards, "nothing to redeem");
+        if (!redeemInterest && !redeemRewards) revert Errors.YCNothingToRedeem();
 
         // if redeemRewards == true, this line must be here for obvious reason
         // if redeemInterest == true, this line must be here because of the reason above
@@ -155,7 +187,7 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         updateData
         returns (uint256 interestOut, uint256[] memory rewardsOut)
     {
-        require(isExpired(), "not expired");
+        if (!isExpired()) revert Errors.YCNotExpired();
 
         address treasury = IPYieldContractFactory(factory).treasury();
 
@@ -175,23 +207,19 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         _transferOut(SCY, treasury, interestOut);
     }
 
-    function rewardIndexesCurrent() external override returns (uint256[] memory) {
+    function rewardIndexesCurrent() external override nonReentrant returns (uint256[] memory) {
         return ISuperComposableYield(SCY).rewardIndexesCurrent();
     }
 
     /// @dev maximize the current rate with the previous rate to guarantee non-decreasing rate
-    function pyIndexCurrent() public returns (uint256 currentIndex) {
-        currentIndex = Math.max(ISuperComposableYield(SCY).exchangeRate(), _pyIndexStored);
-        _pyIndexStored = currentIndex.Uint128();
-        emit NewInterestIndex(currentIndex);
-    }
-
-    function pyIndexStored() public view returns (uint256) {
-        return _pyIndexStored;
+    function pyIndexCurrent() public nonReentrant returns (uint256 currentIndex) {
+        currentIndex = _pyIndexCurrent();
     }
 
-    function isExpired() public view returns (bool) {
-        return MiniHelpers.isCurrentlyExpired(expiry);
+    function setPostExpiryData() external nonReentrant {
+        if (isExpired()) {
+            _setPostExpiryData();
+        }
     }
 
     function getPostExpiryData()
@@ -204,7 +232,7 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
             uint256[] memory userRewardOwed
         )
     {
-        require(postExpiry.firstPYIndex != 0, "PostExpiry data not set");
+        if (postExpiry.firstPYIndex == 0) revert Errors.YCPostExpiryDataNotSet();
 
         firstPYIndex = postExpiry.firstPYIndex;
         totalScyInterestForTreasury = postExpiry.totalScyInterestForTreasury;
@@ -219,6 +247,39 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         }
     }
 
+    function _mintPY(
+        address[] memory receiverPTs,
+        address[] memory receiverYTs,
+        uint256[] memory amountScyToMints
+    ) internal returns (uint256[] memory amountPYOuts) {
+        amountPYOuts = new uint256[](amountScyToMints.length);
+
+        uint256 index = _pyIndexCurrent();
+
+        for (uint256 i = 0; i < amountScyToMints.length; i++) {
+            amountPYOuts[i] = _calcPYToMint(amountScyToMints[i], index);
+
+            _mint(receiverYTs[i], amountPYOuts[i]);
+            IPPrincipalToken(PT).mintByYT(receiverPTs[i], amountPYOuts[i]);
+
+            emit Mint(
+                msg.sender,
+                receiverPTs[i],
+                receiverYTs[i],
+                amountScyToMints[i],
+                amountPYOuts[i]
+            );
+        }
+    }
+
+    function pyIndexStored() public view returns (uint256) {
+        return _pyIndexStored;
+    }
+
+    function isExpired() public view returns (bool) {
+        return MiniHelpers.isCurrentlyExpired(expiry);
+    }
+
     function _redeemPY(address[] memory receivers, uint256[] memory amountPYToRedeems)
         internal
         returns (uint256[] memory amountScyOuts)
@@ -227,7 +288,7 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         IPPrincipalToken(PT).burnByYT(address(this), totalAmountPYToRedeem);
         if (!isExpired()) _burn(address(this), totalAmountPYToRedeem);
 
-        uint256 index = pyIndexCurrent();
+        uint256 index = _pyIndexCurrent();
         uint256 totalScyInterestPostExpiry;
         amountScyOuts = new uint256[](receivers.length);
 
@@ -247,9 +308,13 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         }
     }
 
-    function _calcPYToMint(uint256 amountScy) internal returns (uint256 amountPY) {
+    function _calcPYToMint(uint256 amountScy, uint256 indexCurrent)
+        internal
+        pure
+        returns (uint256 amountPY)
+    {
         // doesn't matter before or after expiry, since mintPY is only allowed before expiry
-        return SCYUtils.scyToAsset(pyIndexCurrent(), amountScy);
+        return SCYUtils.scyToAsset(indexCurrent, amountScy);
     }
 
     function _calcScyRedeemableFromPY(uint256 amountPY, uint256 indexCurrent)
@@ -275,7 +340,7 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
 
     function _getFloatingScyAmount() internal view returns (uint256 amount) {
         amount = _selfBalance(SCY) - scyReserve;
-        require(amount > 0, "RECEIVE_ZERO");
+        if (amount == 0) revert Errors.YCNoFloatingScy();
     }
 
     function _setPostExpiryData() internal {
@@ -284,7 +349,7 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
 
         _redeemExternalReward(); // do a final redeem. All the future reward income will belong to the treasury
 
-        local.firstPYIndex = pyIndexCurrent().Uint128();
+        local.firstPYIndex = _pyIndexCurrent().Uint128();
         address[] memory rewardTokens = ISuperComposableYield(SCY).getRewardTokens();
         uint256[] memory rewardIndexes = ISuperComposableYield(SCY).rewardIndexesCurrent();
         for (uint256 i = 0; i < rewardTokens.length; i++) {
@@ -299,7 +364,13 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
 
     function _getInterestIndex() internal virtual override returns (uint256 index) {
         if (isExpired()) index = postExpiry.firstPYIndex;
-        else index = pyIndexCurrent();
+        else index = _pyIndexCurrent();
+    }
+
+    function _pyIndexCurrent() internal returns (uint256 currentIndex) {
+        currentIndex = Math.max(ISuperComposableYield(SCY).exchangeRate(), _pyIndexStored);
+        _pyIndexStored = currentIndex.Uint128();
+        emit NewInterestIndex(currentIndex);
     }
 
     function _YTbalance(address user) internal view override returns (uint256) {

package/contracts/core/actions/ActionAddRemoveLiq.sol

@@ -4,6 +4,7 @@ pragma solidity 0.8.15;
 import "./base/ActionBaseMintRedeem.sol";
 import "../../interfaces/IPActionAddRemoveLiq.sol";
 import "../../interfaces/IPMarket.sol";
+import "../../libraries/Errors.sol";
 
 contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     using Math for uint256;
@@ -33,19 +34,17 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             uint256 netPtUsed
         )
     {
-        (ISuperComposableYield SCY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
-            .readTokens();
+        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         MarketState memory state = IPMarket(market).readState();
         (, netLpOut, netScyUsed, netPtUsed) = state.addLiquidity(
-            YT.newIndex(),
             netScyDesired,
             netPtDesired,
             block.timestamp
         );
 
         // early-check
-        require(netLpOut >= minLpOut, "insufficient lp out");
+        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
 
         IERC20(SCY).safeTransferFrom(msg.sender, market, netScyUsed);
         IERC20(PT).safeTransferFrom(msg.sender, market, netPtUsed);
@@ -53,7 +52,8 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         (netLpOut, , ) = IPMarket(market).mint(receiver, netScyUsed, netPtUsed);
 
         // fail-safe
-        require(netLpOut >= minLpOut, "FS insufficient lp out");
+        if (netLpOut < minLpOut) assert(false);
+
         emit AddLiquidityDualScyAndPt(
             msg.sender,
             market,
@@ -80,8 +80,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             uint256 netPtUsed
         )
     {
-        (ISuperComposableYield SCY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
-            .readTokens();
+        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         uint256 netScyDesired = SCY.previewDeposit(tokenIn, netTokenDesired);
         uint256 netScyUsed;
@@ -89,15 +88,13 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         {
             MarketState memory state = IPMarket(market).readState();
             (, netLpOut, netScyUsed, netPtUsed) = state.addLiquidity(
-                YT.newIndex(),
                 netScyDesired,
                 netPtDesired,
                 block.timestamp
             );
         }
 
-        // early-check
-        require(netLpOut >= minLpOut, "insufficient lp out");
+        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
 
         IERC20(PT).safeTransferFrom(msg.sender, market, netPtUsed);
 
@@ -115,8 +112,8 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         }
 
         (netLpOut, , ) = IPMarket(market).mint(receiver, netScyUsed, netPtUsed);
-        // fail-safe
-        require(netLpOut >= minLpOut, "FS insufficient lp out");
+
+        if (netLpOut < minLpOut) assert(false);
 
         emit AddLiquidityDualTokenAndPt(
             msg.sender,
@@ -135,7 +132,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 netPtIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtSwapToScy
-    ) external returns (uint256 netLpOut) {
+    ) external returns (uint256 netLpOut, uint256 netScyFee) {
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
         MarketState memory state = IPMarket(market).readState();
@@ -149,14 +146,16 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
 
         IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
 
-        (uint256 netScyReceived, ) = IPMarket(market).swapExactPtForScy(
+        uint256 netScyReceived;
+        (netScyReceived, netScyFee) = IPMarket(market).swapExactPtForScy(
             market,
             netPtSwap,
             EMPTY_BYTES
         ); // ignore return, receiver = market
+
         (netLpOut, , ) = IPMarket(market).mint(receiver, netScyReceived, netPtIn - netPtSwap);
 
-        require(netLpOut >= minLpOut, "insufficient lp out");
+        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
 
         emit AddLiquiditySinglePt(msg.sender, market, receiver, netPtIn, netLpOut);
     }
@@ -167,11 +166,11 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 netScyIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromScy
-    ) external returns (uint256 netLpOut) {
+    ) external returns (uint256 netLpOut, uint256 netScyFee) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
         IERC20(SCY).safeTransferFrom(msg.sender, market, netScyIn);
 
-        netLpOut = _addLiquiditySingleScy(
+        (netLpOut, netScyFee) = _addLiquiditySingleScy(
             receiver,
             market,
             YT,
@@ -189,13 +188,13 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromScy,
         TokenInput calldata input
-    ) external payable returns (uint256 netLpOut) {
+    ) external payable returns (uint256 netLpOut, uint256 netScyFee) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         // all output SCY is transferred directly to the market
         uint256 netScyUsed = _mintScyFromToken(address(market), address(SCY), 1, input);
 
-        netLpOut = _addLiquiditySingleScy(
+        (netLpOut, netScyFee) = _addLiquiditySingleScy(
             receiver,
             market,
             YT,
@@ -225,8 +224,8 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
 
         (netScyOut, netPtOut) = IPMarket(market).burn(receiver, receiver, netLpToRemove);
 
-        require(netScyOut >= minScyOut, "insufficient SCY out");
-        require(netPtOut >= minPtOut, "insufficient PT out");
+        if (netScyOut < minScyOut) revert Errors.RouterInsufficientScyOut(netScyOut, minScyOut);
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
         emit RemoveLiquidityDualScyAndPt(
             msg.sender,
@@ -250,11 +249,12 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
 
         IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
 
-        (, netPtOut) = IPMarket(market).burn(address(SCY), receiver, netLpToRemove);
+        uint256 netScyOut;
+        (netScyOut, netPtOut) = IPMarket(market).burn(address(SCY), receiver, netLpToRemove);
 
-        netTokenOut = SCY.redeemAfterTransfer(receiver, tokenOut, minTokenOut);
+        netTokenOut = SCY.redeem(receiver, netScyOut, tokenOut, minTokenOut, true);
 
-        require(netPtOut >= minPtOut, "insufficient PT out");
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
         emit RemoveLiquidityDualTokenAndPt(
             msg.sender,
@@ -273,7 +273,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 netLpToRemove,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut
-    ) external returns (uint256 netPtOut) {
+    ) external returns (uint256 netPtOut, uint256 netScyFee) {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
@@ -287,14 +287,15 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             guessPtOut
         );
 
-        // early-check
-        require(ptFromBurn + ptFromSwap >= minPtOut, "insufficient lp out");
+        if (ptFromBurn + ptFromSwap < minPtOut)
+            revert Errors.RouterInsufficientPtOut(ptFromBurn + ptFromSwap, minPtOut);
 
         (, ptFromBurn) = IPMarket(market).burn(market, receiver, netLpToRemove);
-        IPMarket(market).swapScyForExactPt(receiver, ptFromSwap, EMPTY_BYTES); // ignore return
+        (, netScyFee) = IPMarket(market).swapScyForExactPt(receiver, ptFromSwap, EMPTY_BYTES);
 
         // fail-safe
-        require(ptFromBurn + ptFromSwap >= minPtOut, "FS insufficient lp out");
+        if (ptFromBurn + ptFromSwap < minPtOut) assert(false);
+
         netPtOut = ptFromBurn + ptFromSwap;
 
         emit RemoveLiquiditySinglePt(msg.sender, market, receiver, netLpToRemove, netPtOut);
@@ -305,9 +306,14 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         address market,
         uint256 netLpToRemove,
         uint256 minScyOut
-    ) external returns (uint256 netScyOut) {
+    ) external returns (uint256 netScyOut, uint256 netScyFee) {
         IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
-        netScyOut = _removeLiquiditySingleScy(receiver, market, netLpToRemove, minScyOut);
+        (netScyOut, netScyFee) = _removeLiquiditySingleScy(
+            receiver,
+            market,
+            netLpToRemove,
+            minScyOut
+        );
         emit RemoveLiquiditySingleScy(msg.sender, market, receiver, netLpToRemove, netScyOut);
     }
 
@@ -316,13 +322,20 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         address market,
         uint256 netLpToRemove,
         TokenOutput calldata output
-    ) external returns (uint256 netTokenOut) {
+    ) external returns (uint256 netTokenOut, uint256 netScyFee) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
         IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
 
         // all output SCY is directly transferred to the SCY contract
-        uint256 netScyReceived = _removeLiquiditySingleScy(address(SCY), market, netLpToRemove, 1);
+        uint256 netScyReceived;
+
+        (netScyReceived, netScyFee) = _removeLiquiditySingleScy(
+            address(SCY),
+            market,
+            netLpToRemove,
+            1
+        );
 
         // since all SCY is already at the SCY contract, doPull = false
         netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyReceived, output, false);
@@ -344,7 +357,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 netScyIn,
         uint256 minLpOut,
         ApproxParams calldata guessPtReceivedFromScy
-    ) internal returns (uint256 netLpOut) {
+    ) internal returns (uint256 netLpOut, uint256 netScyFee) {
         MarketState memory state = IPMarket(market).readState();
 
         (uint256 netPtReceived, , ) = state.approxSwapScyToAddLiquidity(
@@ -354,14 +367,15 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             guessPtReceivedFromScy
         );
 
-        (uint256 netScySwapped, ) = IPMarket(market).swapScyForExactPt(
+        uint256 netScySwapped;
+        (netScySwapped, netScyFee) = IPMarket(market).swapScyForExactPt(
             market,
             netPtReceived,
             EMPTY_BYTES
         ); // ignore return, receiver = market
         (netLpOut, , ) = IPMarket(market).mint(receiver, netScyIn - netScySwapped, netPtReceived);
 
-        require(netLpOut >= minLpOut, "insufficient lp out");
+        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
     }
 
     function _removeLiquiditySingleScy(
@@ -369,13 +383,14 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         address market,
         uint256 netLpToRemove,
         uint256 minScyOut
-    ) internal returns (uint256 netScyOut) {
+    ) internal returns (uint256 netScyOut, uint256 netScyFee) {
         if (IPMarket(market).isExpired()) {
             netScyOut = __removeLpToScyAfterExpiry(receiver, market, netLpToRemove);
         } else {
-            netScyOut = __removeLpToScyBeforeExpiry(receiver, market, netLpToRemove);
+            (netScyOut, netScyFee) = __removeLpToScyBeforeExpiry(receiver, market, netLpToRemove);
         }
-        require(netScyOut >= minScyOut, "insufficient lp out");
+
+        if (netScyOut < minScyOut) revert Errors.RouterInsufficientScyOut(netScyOut, minScyOut);
     }
 
     function __removeLpToScyAfterExpiry(
@@ -392,13 +407,15 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         address receiver,
         address market,
         uint256 netLpToRemove
-    ) internal returns (uint256 netScyOut) {
+    ) internal returns (uint256 netScyOut, uint256 netScyFee) {
         (uint256 scyFromBurn, uint256 ptFromBurn) = IPMarket(market).burn(
             receiver,
             market,
             netLpToRemove
         );
-        (uint256 scyFromSwap, ) = IPMarket(market).swapExactPtForScy(
+
+        uint256 scyFromSwap;
+        (scyFromSwap, netScyFee) = IPMarket(market).swapExactPtForScy(
             receiver,
             ptFromBurn,
             EMPTY_BYTES

package/contracts/core/actions/ActionCallback.sol

@@ -6,6 +6,8 @@ import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPMarketSwapCallback.sol";
 import "../../libraries/SCY/SCYUtils.sol";
 import "../../libraries/math/MarketApproxLib.sol";
+import "../../libraries/Errors.sol";
+
 import "./base/ActionBaseMintRedeem.sol";
 import "./base/CallbackHelper.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
@@ -22,14 +24,14 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
 
     address public immutable marketFactory;
 
-    modifier onlyPendleMarket(address market) {
-        require(IPMarketFactory(marketFactory).isValidMarket(market), "INVALID_MARKET");
+    modifier onlyPendleMarket(address caller) {
+        if (!IPMarketFactory(marketFactory).isValidMarket(caller))
+            revert Errors.RouterCallbackNotPendleMarket(caller);
         _;
     }
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
     constructor(address _marketFactory) {
-        require(_marketFactory != address(0), "zero address");
         marketFactory = _marketFactory;
     }
 
@@ -54,7 +56,7 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         } else if (swapType == ActionType.SwapExactPtForYt) {
             _callbackSwapExactPtForYt(market, ptToAccount, scyToAccount, data);
         } else {
-            require(false, "unknown swapType");
+            assert(false);
         }
     }
 
@@ -71,8 +73,8 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         uint256 ptOwed = ptToAccount.abs();
         uint256 netPyOut = YT.mintPY(market, receiver);
 
-        require(netPyOut >= ptOwed, "insufficient PT to pay");
-        require(netPyOut >= minYtOut, "insufficient YT out");
+        if (netPyOut < ptOwed) revert Errors.RouterInsufficientPtRepay(netPyOut, ptOwed);
+        if (netPyOut < minYtOut) revert Errors.RouterInsufficientYtOut(netPyOut, minYtOut);
     }
 
     struct VarsSwapScyForExactYt {
@@ -104,7 +106,9 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         /// ------------------------------------------------------------
         uint256 scyReceived = scyToAccount.Uint();
         uint256 netScyToPull = totalScyNeed.subMax0(scyReceived);
-        require(netScyToPull <= vars.maxScyToPull, "exceed SCY in limit");
+
+        if (netScyToPull > vars.maxScyToPull)
+            revert Errors.RouterExceededLimitScyIn(netScyToPull, vars.maxScyToPull);
 
         /// ------------------------------------------------------------
         /// mint & transfer
@@ -114,7 +118,7 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         }
 
         uint256 netPyOut = YT.mintPY(market, vars.receiver);
-        require(netPyOut >= ptOwed, "insufficient pt to pay");
+        if (netPyOut < ptOwed) revert Errors.RouterInsufficientPtRepay(netPyOut, ptOwed);
     }
 
     /// @dev refer to _swapExactYtForScy or _swapYtForExactScy
@@ -140,7 +144,8 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         );
 
         uint256[] memory amountScyOuts = YT.redeemPYMulti(receivers, amountPYToRedeems);
-        require(amountScyOuts[1] >= minScyOut, "insufficient SCY out");
+        if (amountScyOuts[1] < minScyOut)
+            revert Errors.RouterInsufficientScyOut(amountScyOuts[1], minScyOut);
     }
 
     function _callbackSwapExactPtForYt(
@@ -154,8 +159,9 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 netPyOut = YT.mintPY(market, receiver);
-        require(netPyOut >= minYtOut, "insufficient YT out");
-        require(exactPtIn + netPyOut >= netPtOwed, "insufficient PT to pay");
+        if (netPyOut < minYtOut) revert Errors.RouterInsufficientYtOut(netPyOut, minYtOut);
+        if (exactPtIn + netPyOut < netPtOwed)
+            revert Errors.RouterInsufficientPtRepay(exactPtIn + netPyOut, netPtOwed);
     }
 
     function _callbackSwapExactYtForPt(
@@ -172,8 +178,12 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         PT.safeTransfer(address(YT), exactYtIn);
         uint256 netScyToMarket = YT.redeemPY(market);
 
-        require(netScyToMarket >= netScyOwed, "insufficient SCY to pay");
-        require(ptToAccount.Uint() - exactYtIn >= minPtOut, "insufficient PT out");
-        PT.safeTransfer(receiver, ptToAccount.Uint() - exactYtIn);
+        if (netScyToMarket < netScyOwed)
+            revert Errors.RouterInsufficientScyRepay(netScyToMarket, netScyOwed);
+
+        uint256 netPtOut = ptToAccount.Uint() - exactYtIn;
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+
+        PT.safeTransfer(receiver, netPtOut);
     }
 }