@pendle/core-v2 0.9.4-beta → 0.10.2-testnet

package/contracts/core/PendleRouter.sol

@@ -4,87 +4,95 @@ pragma solidity 0.8.15;
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/Proxy.sol";
-import "../interfaces/IPActionCore.sol";
-import "../interfaces/IPActionYT.sol";
-import "../interfaces/IPRouterStatic.sol";
+import "../interfaces/IPAllAction.sol";
 import "../interfaces/IPMarketSwapCallback.sol";
-import "../periphery/PermissionsV2Upg.sol";
+import "../periphery/BoringOwnableUpgradeable.sol";
 
 /// @dev this contract will be deployed behind an ERC1967 proxy
 /// calls to the ERC1967 proxy will be resolved at this contract, and proxied again to the
 /// corresponding implementation contracts
 
 // solhint-disable no-empty-blocks
-contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, PermissionsV2Upg {
-    address public immutable ACTION_CORE;
-    address public immutable ACTION_YT;
+contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpgradeable {
+    address public immutable ACTION_MINT_REDEEM;
+    address public immutable ACTION_ADD_REMOVE_LIQ;
+    address public immutable ACTION_SWAP_PT;
+    address public immutable ACTION_SWAP_YT;
     address public immutable ACTION_CALLBACK;
+    address public immutable ACTION_MISC;
 
     constructor(
-        address _ACTION_CORE,
-        address _ACTION_YT,
+        address _ACTION_MINT_REDEEM,
+        address _ACTION_ADD_REMOVE_LIQ,
+        address _ACTION_SWAP_PT,
+        address _ACTION_SWAP_YT,
         address _ACTION_CALLBACK,
-        address _governanceManager
-    ) PermissionsV2Upg(_governanceManager) initializer {
-        require(
-            _ACTION_CORE != address(0) &&
-                _ACTION_YT != address(0) &&
-                _ACTION_CALLBACK != address(0),
-            "zero address"
-        );
-        ACTION_CORE = _ACTION_CORE;
-        ACTION_YT = _ACTION_YT;
+        address _ACTION_MISC
+    ) initializer {
+        ACTION_MINT_REDEEM = _ACTION_MINT_REDEEM;
+        ACTION_ADD_REMOVE_LIQ = _ACTION_ADD_REMOVE_LIQ;
+        ACTION_SWAP_PT = _ACTION_SWAP_PT;
+        ACTION_SWAP_YT = _ACTION_SWAP_YT;
         ACTION_CALLBACK = _ACTION_CALLBACK;
+        ACTION_MISC = _ACTION_MISC;
     }
 
     function initialize() external initializer {
         __UUPSUpgradeable_init();
-        // no need to initialize PermissionsV2Upg
+        __BoringOwnable_init();
     }
 
     function getRouterImplementation(bytes4 sig) public view returns (address) {
         if (
-            sig == IPActionCore.mintScyFromToken.selector ||
-            sig == IPActionCore.redeemScyToToken.selector ||
-            sig == IPActionCore.mintPyFromToken.selector ||
-            sig == IPActionCore.redeemPyToToken.selector ||
-            sig == IPActionCore.mintPyFromScy.selector ||
-            sig == IPActionCore.redeemPyToScy.selector ||
-            sig == IPActionCore.addLiquidityDualScyAndPt.selector ||
-            sig == IPActionCore.addLiquidityDualTokenAndPt.selector ||
-            sig == IPActionCore.addLiquiditySinglePt.selector ||
-            sig == IPActionCore.addLiquiditySingleScy.selector ||
-            sig == IPActionCore.addLiquiditySingleToken.selector ||
-            sig == IPActionCore.removeLiquidityDualScyAndPt.selector ||
-            sig == IPActionCore.removeLiquidityDualTokenAndPt.selector ||
-            sig == IPActionCore.removeLiquiditySinglePt.selector ||
-            sig == IPActionCore.removeLiquiditySingleScy.selector ||
-            sig == IPActionCore.removeLiquiditySingleToken.selector ||
-            sig == IPActionCore.swapExactPtForScy.selector ||
-            sig == IPActionCore.swapPtForExactScy.selector ||
-            sig == IPActionCore.swapScyForExactPt.selector ||
-            sig == IPActionCore.swapExactScyForPt.selector ||
-            sig == IPActionCore.swapExactTokenForPt.selector ||
-            sig == IPActionCore.swapExactPtForToken.selector ||
-            sig == IPActionCore.redeemDueInterestAndRewards.selector
+            sig == IPActionMintRedeem.mintScyFromToken.selector ||
+            sig == IPActionMintRedeem.redeemScyToToken.selector ||
+            sig == IPActionMintRedeem.mintPyFromToken.selector ||
+            sig == IPActionMintRedeem.redeemPyToToken.selector ||
+            sig == IPActionMintRedeem.mintPyFromScy.selector ||
+            sig == IPActionMintRedeem.redeemPyToScy.selector ||
+            sig == IPActionMintRedeem.redeemDueInterestAndRewards.selector
         ) {
-            return ACTION_CORE;
+            return ACTION_MINT_REDEEM;
         } else if (
-            sig == IPActionYT.swapExactYtForScy.selector ||
-            sig == IPActionYT.swapScyForExactYt.selector ||
-            sig == IPActionYT.swapExactScyForYt.selector ||
-            sig == IPActionYT.swapExactTokenForYt.selector ||
-            sig == IPActionYT.swapExactYtForToken.selector ||
-            sig == IPActionYT.swapYtForExactScy.selector
+            sig == IPActionAddRemoveLiq.addLiquidityDualScyAndPt.selector ||
+            sig == IPActionAddRemoveLiq.addLiquidityDualTokenAndPt.selector ||
+            sig == IPActionAddRemoveLiq.addLiquiditySinglePt.selector ||
+            sig == IPActionAddRemoveLiq.addLiquiditySingleScy.selector ||
+            sig == IPActionAddRemoveLiq.addLiquiditySingleToken.selector ||
+            sig == IPActionAddRemoveLiq.removeLiquidityDualScyAndPt.selector ||
+            sig == IPActionAddRemoveLiq.removeLiquidityDualTokenAndPt.selector ||
+            sig == IPActionAddRemoveLiq.removeLiquiditySinglePt.selector ||
+            sig == IPActionAddRemoveLiq.removeLiquiditySingleScy.selector ||
+            sig == IPActionAddRemoveLiq.removeLiquiditySingleToken.selector
         ) {
-            return ACTION_YT;
+            return ACTION_ADD_REMOVE_LIQ;
+        } else if (
+            sig == IPActionSwapPT.swapExactPtForScy.selector ||
+            sig == IPActionSwapPT.swapPtForExactScy.selector ||
+            sig == IPActionSwapPT.swapScyForExactPt.selector ||
+            sig == IPActionSwapPT.swapExactScyForPt.selector ||
+            sig == IPActionSwapPT.swapExactTokenForPt.selector ||
+            sig == IPActionSwapPT.swapExactPtForToken.selector
+        ) {
+            return ACTION_SWAP_PT;
+        } else if (
+            sig == IPActionSwapYT.swapExactYtForScy.selector ||
+            sig == IPActionSwapYT.swapScyForExactYt.selector ||
+            sig == IPActionSwapYT.swapExactScyForYt.selector ||
+            sig == IPActionSwapYT.swapExactTokenForYt.selector ||
+            sig == IPActionSwapYT.swapExactYtForToken.selector ||
+            sig == IPActionSwapYT.swapYtForExactScy.selector
+        ) {
+            return ACTION_SWAP_YT;
         } else if (sig == IPMarketSwapCallback.swapCallback.selector) {
             return ACTION_CALLBACK;
+        } else if (sig == IPActionMisc.consult.selector) {
+            return ACTION_MISC;
         }
         require(false, "invalid market sig");
     }
 
-    function _authorizeUpgrade(address newImplementation) internal override onlyGovernance {}
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 
     function _implementation() internal view override returns (address) {
         return getRouterImplementation(msg.sig);

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -32,13 +32,13 @@ import "../../libraries/helpers/ExpiryUtilsLib.sol";
 import "../../libraries/helpers/SSTORE2Deployer.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 
-import "../../periphery/PermissionsV2Upg.sol";
+import "../../periphery/BoringOwnableUpgradeable.sol";
 
 import "./PendlePrincipalToken.sol";
 import "./PendleYieldToken.sol";
 
 /// @dev If this contract is ever made upgradeable, please pay attention to the numContractDeployed variable
-contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldContractFactory {
+contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContractFactory {
     using ExpiryUtils for string;
 
     string private constant PT_PREFIX = "PT";
@@ -60,20 +60,20 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
     mapping(address => bool) public isPT;
     mapping(address => bool) public isYT;
 
-    constructor(
+    constructor() {}
+
+    function initialize(
         uint96 _expiryDivisor,
         uint128 _interestFeeRate,
         uint128 _rewardFeeRate,
         address _treasury,
-        address _governanceManager
-    ) PermissionsV2Upg(_governanceManager) {
+        bytes memory _pendleYtCreationCode
+    ) external initializer {
+        __BoringOwnable_init();
         setExpiryDivisor(_expiryDivisor);
         setInterestFeeRate(_interestFeeRate);
         setRewardFeeRate(_rewardFeeRate);
         setTreasury(_treasury);
-    }
-
-    function initialize(bytes memory _pendleYtCreationCode) external initializer {
         pendleYtCreationCodePointer = SSTORE2Deployer.setCreationCode(_pendleYtCreationCode);
     }
 
@@ -131,23 +131,23 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
         emit CreateYieldContract(SCY, PT, YT, expiry);
     }
 
-    function setExpiryDivisor(uint96 newExpiryDivisor) public onlyGovernance {
+    function setExpiryDivisor(uint96 newExpiryDivisor) public onlyOwner {
         require(newExpiryDivisor != 0, "zero value");
         expiryDivisor = newExpiryDivisor;
         emit SetExpiryDivisor(newExpiryDivisor);
     }
 
-    function setInterestFeeRate(uint128 newInterestFeeRate) public onlyGovernance {
+    function setInterestFeeRate(uint128 newInterestFeeRate) public onlyOwner {
         interestFeeRate = newInterestFeeRate;
         emit SetInterestFeeRate(newInterestFeeRate);
     }
 
-    function setRewardFeeRate(uint128 newInterestFeeRate) public onlyGovernance {
+    function setRewardFeeRate(uint128 newInterestFeeRate) public onlyOwner {
         rewardFeeRate = newInterestFeeRate;
         emit SetInterestFeeRate(newInterestFeeRate);
     }
 
-    function setTreasury(address newTreasury) public onlyGovernance {
+    function setTreasury(address newTreasury) public onlyOwner {
         require(newTreasury != address(0), "zero address");
         treasury = newTreasury;
         emit SetTreasury(newTreasury);

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -17,7 +17,7 @@ import "../PendleERC20.sol";
 import "./InterestManagerYT.sol";
 
 /**
-Invariances to maintain:
+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
 */

package/contracts/core/actions/ActionAddRemoveLiq.sol

@@ -0,0 +1,366 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "./base/ActionBaseMintRedeem.sol";
+import "../../interfaces/IPActionAddRemoveLiq.sol";
+import "../../interfaces/IPMarket.sol";
+
+contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
+    using Math for uint256;
+    using Math for int256;
+    using MarketMathCore for MarketState;
+    using MarketApproxLib for MarketState;
+    using SafeERC20 for IERC20;
+    using PYIndexLib for IPYieldToken;
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor(address _kyberSwapRouter)
+        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    {}
+
+    function addLiquidityDualScyAndPt(
+        address receiver,
+        address market,
+        uint256 netScyDesired,
+        uint256 netPtDesired,
+        uint256 minLpOut
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 scyUsed,
+            uint256 netPtUsed
+        )
+    {
+        (ISuperComposableYield SCY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
+            .readTokens();
+
+        MarketState memory state = IPMarket(market).readState();
+        (, netLpOut, scyUsed, netPtUsed) = state.addLiquidity(
+            YT.newIndex(),
+            netScyDesired,
+            netPtDesired,
+            block.timestamp
+        );
+
+        // early-check
+        require(netLpOut >= minLpOut, "insufficient lp out");
+
+        IERC20(SCY).safeTransferFrom(msg.sender, market, scyUsed);
+        IERC20(PT).safeTransferFrom(msg.sender, market, netPtUsed);
+
+        netLpOut = IPMarket(market).mint(receiver);
+
+        // fail-safe
+        require(netLpOut >= minLpOut, "FS insufficient lp out");
+        emit AddLiquidityDualScyAndPt(msg.sender, market, receiver, scyUsed, netPtUsed, netLpOut);
+    }
+
+    function addLiquidityDualTokenAndPt(
+        address receiver,
+        address market,
+        address tokenIn,
+        uint256 netTokenDesired,
+        uint256 netPtDesired,
+        uint256 minLpOut
+    )
+        external
+        payable
+        returns (
+            uint256 netLpOut,
+            uint256 netTokenUsed,
+            uint256 netPtUsed
+        )
+    {
+        (ISuperComposableYield SCY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
+            .readTokens();
+
+        uint256 netScyDesired = SCY.previewDeposit(tokenIn, netTokenDesired);
+        uint256 scyUsed;
+
+        {
+            MarketState memory state = IPMarket(market).readState();
+            (, netLpOut, scyUsed, netPtUsed) = state.addLiquidity(
+                YT.newIndex(),
+                netScyDesired,
+                netPtDesired,
+                block.timestamp
+            );
+        }
+
+        // early-check
+        require(netLpOut >= minLpOut, "insufficient lp out");
+
+        IERC20(PT).safeTransferFrom(msg.sender, market, netPtUsed);
+
+        // convert tokenIn to SCY to deposit
+        netTokenUsed = (netTokenDesired * scyUsed).rawDivUp(netScyDesired);
+
+        if (tokenIn == NATIVE) {
+            _transferIn(tokenIn, msg.sender, netTokenDesired);
+            SCY.deposit{ value: netTokenUsed }(market, tokenIn, netTokenUsed, scyUsed);
+            _transferOut(tokenIn, msg.sender, netTokenDesired - netTokenUsed);
+        } else {
+            _transferIn(tokenIn, msg.sender, netTokenUsed);
+            _safeApproveInf(tokenIn, address(SCY));
+            SCY.deposit(market, tokenIn, netTokenUsed, scyUsed);
+        }
+
+        netLpOut = IPMarket(market).mint(receiver);
+        // fail-safe
+        require(netLpOut >= minLpOut, "FS insufficient lp out");
+
+        emit AddLiquidityDualTokenAndPt(
+            msg.sender,
+            market,
+            receiver,
+            tokenIn,
+            netTokenDesired,
+            netPtUsed,
+            netLpOut
+        );
+    }
+
+    function addLiquiditySinglePt(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtSwapToScy
+    ) external returns (uint256 netLpOut) {
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+
+        MarketState memory state = IPMarket(market).readState();
+
+        (uint256 netPtSwap, , ) = state.approxSwapPtToAddLiquidity(
+            YT.newIndex(),
+            netPtIn,
+            block.timestamp,
+            guessPtSwapToScy
+        );
+
+        IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
+
+        IPMarket(market).swapExactPtForScy(market, netPtSwap, EMPTY_BYTES); // ignore return, receiver = market
+        netLpOut = IPMarket(market).mint(receiver);
+
+        require(netLpOut >= minLpOut, "insufficient lp out");
+
+        emit AddLiquiditySinglePt(msg.sender, market, receiver, netPtIn, netLpOut);
+    }
+
+    function addLiquiditySingleScy(
+        address receiver,
+        address market,
+        uint256 netScyIn,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtReceivedFromScy
+    ) external returns (uint256 netLpOut) {
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        IERC20(SCY).safeTransferFrom(msg.sender, market, netScyIn);
+
+        netLpOut = _addLiquiditySingleScy(
+            receiver,
+            market,
+            YT,
+            netScyIn,
+            minLpOut,
+            guessPtReceivedFromScy
+        );
+
+        emit AddLiquiditySingleScy(msg.sender, market, receiver, netScyIn, netLpOut);
+    }
+
+    function addLiquiditySingleToken(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtReceivedFromScy,
+        TokenInput calldata input
+    ) external payable returns (uint256 netLpOut) {
+        (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(
+            receiver,
+            market,
+            YT,
+            netScyUsed,
+            minLpOut,
+            guessPtReceivedFromScy
+        );
+
+        emit AddLiquiditySingleToken(
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            input.netTokenIn,
+            netLpOut
+        );
+    }
+
+    function removeLiquidityDualScyAndPt(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        uint256 minScyOut,
+        uint256 minPtOut
+    ) external returns (uint256 netScyOut, uint256 netPtOut) {
+        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
+
+        (netScyOut, netPtOut) = IPMarket(market).burn(receiver, receiver);
+
+        require(netScyOut >= minScyOut, "insufficient SCY out");
+        require(netPtOut >= minPtOut, "insufficient PT out");
+
+        emit RemoveLiquidityDualScyAndPt(
+            msg.sender,
+            market,
+            receiver,
+            netLpToRemove,
+            netPtOut,
+            netScyOut
+        );
+    }
+
+    function removeLiquidityDualTokenAndPt(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        address tokenOut,
+        uint256 minTokenOut,
+        uint256 minPtOut
+    ) external returns (uint256 netTokenOut, uint256 netPtOut) {
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+
+        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
+
+        (, netPtOut) = IPMarket(market).burn(address(SCY), receiver);
+
+        netTokenOut = SCY.redeemAfterTransfer(receiver, tokenOut, minTokenOut);
+
+        require(netPtOut >= minPtOut, "insufficient PT out");
+
+        emit RemoveLiquidityDualTokenAndPt(
+            msg.sender,
+            market,
+            receiver,
+            netLpToRemove,
+            netPtOut,
+            tokenOut,
+            netTokenOut
+        );
+    }
+
+    function removeLiquiditySinglePt(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut
+    ) external returns (uint256 netPtOut) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
+
+        MarketState memory state = IPMarket(market).readState();
+        (uint256 scyFromBurn, uint256 ptFromBurn) = state.removeLiquidity(netLpToRemove);
+        (uint256 ptFromSwap, , ) = state.approxSwapExactScyForPt(
+            YT.newIndex(),
+            scyFromBurn,
+            block.timestamp,
+            guessPtOut
+        );
+
+        // early-check
+        require(ptFromBurn + ptFromSwap >= minPtOut, "insufficient lp out");
+
+        (, ptFromBurn) = IPMarket(market).burn(market, receiver);
+        IPMarket(market).swapScyForExactPt(receiver, ptFromSwap, EMPTY_BYTES); // ignore return
+
+        // fail-safe
+        require(ptFromBurn + ptFromSwap >= minPtOut, "FS insufficient lp out");
+        netPtOut = ptFromBurn + ptFromSwap;
+
+        emit RemoveLiquiditySinglePt(msg.sender, market, receiver, netLpToRemove, netPtOut);
+    }
+
+    function removeLiquiditySingleScy(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        uint256 minScyOut
+    ) external returns (uint256 netScyOut) {
+        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
+        netScyOut = _removeLiquiditySingleScy(receiver, market, minScyOut);
+        emit RemoveLiquiditySingleScy(msg.sender, market, receiver, netLpToRemove, netScyOut);
+    }
+
+    function removeLiquiditySingleToken(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        (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, 1);
+
+        // since all SCY is already at the SCY contract, doPull = false
+        netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyReceived, output, false);
+
+        emit RemoveLiquiditySingleToken(
+            msg.sender,
+            market,
+            output.tokenOut,
+            receiver,
+            netLpToRemove,
+            netTokenOut
+        );
+    }
+
+    function _addLiquiditySingleScy(
+        address receiver,
+        address market,
+        IPYieldToken YT,
+        uint256 netScyIn,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtReceivedFromScy
+    ) internal returns (uint256 netLpOut) {
+        MarketState memory state = IPMarket(market).readState();
+
+        (uint256 netPtReceived, , ) = state.approxSwapScyToAddLiquidity(
+            YT.newIndex(),
+            netScyIn,
+            block.timestamp,
+            guessPtReceivedFromScy
+        );
+
+        IPMarket(market).swapScyForExactPt(market, netPtReceived, EMPTY_BYTES); // ignore return, receiver = market
+        netLpOut = IPMarket(market).mint(receiver);
+
+        require(netLpOut >= minLpOut, "insufficient lp out");
+    }
+
+    function _removeLiquiditySingleScy(
+        address receiver,
+        address market,
+        uint256 minScyOut
+    ) internal returns (uint256 netScyOut) {
+        (uint256 scyFromBurn, uint256 ptFromBurn) = IPMarket(market).burn(receiver, market);
+        (uint256 scyFromSwap, ) = IPMarket(market).swapExactPtForScy(
+            receiver,
+            ptFromBurn,
+            EMPTY_BYTES
+        );
+
+        require(scyFromBurn + scyFromSwap >= minScyOut, "insufficient lp out");
+        netScyOut = scyFromBurn + scyFromSwap;
+    }
+}

package/contracts/core/actions/ActionCallback.sol

@@ -6,7 +6,7 @@ import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPMarketSwapCallback.sol";
 import "../../libraries/SCY/SCYUtils.sol";
 import "../../libraries/math/MarketApproxLib.sol";
-import "./base/ActionSCYAndPYBase.sol";
+import "./base/ActionBaseMintRedeem.sol";
 import "./base/CallbackHelper.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
@@ -64,10 +64,10 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         (address receiver, uint256 minYtOut) = _decodeSwapExactScyForYt(data);
 
         uint256 ptOwed = ptToAccount.abs();
-        uint256 amountPYout = YT.mintPY(market, receiver);
+        uint256 netPyOut = YT.mintPY(market, receiver);
 
-        require(amountPYout >= ptOwed, "insufficient PT to pay");
-        require(amountPYout >= minYtOut, "insufficient YT out");
+        require(netPyOut >= ptOwed, "insufficient PT to pay");
+        require(netPyOut >= minYtOut, "insufficient YT out");
     }
 
     struct VarsSwapScyForExactYt {
@@ -108,8 +108,8 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
             SCY.safeTransferFrom(vars.payer, address(YT), netScyToPull);
         }
 
-        uint256 amountPYout = YT.mintPY(market, vars.receiver);
-        require(amountPYout >= ptOwed, "insufficient pt to pay");
+        uint256 netPyOut = YT.mintPY(market, vars.receiver);
+        require(netPyOut >= ptOwed, "insufficient pt to pay");
     }
 
     /// @dev refer to _swapExactYtForScy or _swapYtForExactScy