@pendle/core-v2 2.29.0 → 3.0.0-beta-1

package/contracts/router/ActionMisc.sol

@@ -1,14 +1,108 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity 0.8.21;
 
+import "./base/ActionBase.sol";
 import "../interfaces/IPActionMisc.sol";
-import "../core/libraries/TokenHelper.sol";
 
-contract ActionMisc is IPActionMisc, TokenHelper {
+contract ActionMisc is IPActionMisc, ActionBase {
+    function mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata input)
+        external
+        payable
+        returns (uint256 netSyOut)
+    {
+        netSyOut = _mintSyFromToken(receiver, SY, minSyOut, input);
+        emit MintSyFromToken(msg.sender, input.tokenIn, SY, receiver, input.netTokenIn, netSyOut);
+    }
+
+    function redeemSyToToken(address receiver, address SY, uint256 netSyIn, TokenOutput calldata output)
+        external
+        returns (uint256 netTokenOut)
+    {
+        netTokenOut = _redeemSyToToken(receiver, SY, netSyIn, output, true);
+        emit RedeemSyToToken(msg.sender, output.tokenOut, SY, receiver, netSyIn, netTokenOut);
+    }
+
+    function mintPyFromToken(address receiver, address YT, uint256 minPyOut, TokenInput calldata input)
+        external
+        payable
+        returns (uint256 netPyOut)
+    {
+        address SY = IPYieldToken(YT).SY();
+
+        uint256 netSyToMint = _mintSyFromToken(YT, SY, 0, input);
+        netPyOut = _mintPyFromSy(receiver, SY, YT, netSyToMint, minPyOut, false);
+
+        emit MintPyFromToken(msg.sender, input.tokenIn, YT, receiver, input.netTokenIn, netPyOut);
+    }
+
+    function redeemPyToToken(address receiver, address YT, uint256 netPyIn, TokenOutput calldata output)
+        external
+        returns (uint256 netTokenOut)
+    {
+        address SY = IPYieldToken(YT).SY();
+
+        uint256 netSyToRedeem = _redeemPyToSy(SY, YT, netPyIn, 1);
+        netTokenOut = _redeemSyToToken(receiver, SY, netSyToRedeem, output, false);
+
+        emit RedeemPyToToken(msg.sender, output.tokenOut, YT, receiver, netPyIn, netTokenOut);
+    }
+
+    function mintPyFromSy(address receiver, address YT, uint256 netSyIn, uint256 minPyOut)
+        external
+        returns (uint256 netPyOut)
+    {
+        netPyOut = _mintPyFromSy(receiver, IPYieldToken(YT).SY(), YT, netSyIn, minPyOut, true);
+        emit MintPyFromSy(msg.sender, receiver, YT, netSyIn, netPyOut);
+    }
+
+    function redeemPyToSy(address receiver, address YT, uint256 netPyIn, uint256 minSyOut)
+        external
+        returns (uint256 netSyOut)
+    {
+        netSyOut = _redeemPyToSy(receiver, YT, netPyIn, minSyOut);
+        emit RedeemPyToSy(msg.sender, receiver, YT, netPyIn, netSyOut);
+    }
+
+    function redeemDueInterestAndRewards(
+        address user,
+        address[] calldata sys,
+        address[] calldata yts,
+        address[] calldata markets
+    ) external {
+        unchecked {
+            for (uint256 i = 0; i < sys.length; ++i) {
+                IStandardizedYield(sys[i]).claimRewards(user);
+            }
+
+            for (uint256 i = 0; i < yts.length; ++i) {
+                IPYieldToken(yts[i]).redeemDueInterestAndRewards(user, true, true);
+            }
+
+            for (uint256 i = 0; i < markets.length; ++i) {
+                IPMarket(markets[i]).redeemRewards(user);
+            }
+        }
+    }
+
+    function swapTokenToToken(address receiver, uint256 minTokenOut, TokenInput calldata inp)
+        external
+        payable
+        returns (uint256 netTokenOut)
+    {
+        _swapTokenInput(inp);
+
+        netTokenOut = _selfBalance(inp.tokenMintSy);
+        if (netTokenOut < minTokenOut) revert Errors.RouterInsufficientTokenOut(netTokenOut, minTokenOut);
+
+        _transferOut(receiver, receiver, netTokenOut);
+    }
+
+    // ----------------- MISC FUNCTIONS -----------------
+
     function approveInf(MultiApproval[] calldata arr) external {
-        for (uint256 i = 0; i < arr.length; ) {
+        for (uint256 i = 0; i < arr.length;) {
             MultiApproval calldata ele = arr[i];
-            for (uint256 j = 0; j < ele.tokens.length; ) {
+            for (uint256 j = 0; j < ele.tokens.length;) {
                 _safeApproveInf(ele.tokens[j], ele.spender);
                 unchecked {
                     j++;
@@ -20,20 +114,17 @@ contract ActionMisc is IPActionMisc, TokenHelper {
         }
     }
 
-    function batchExec(Call3[] calldata calls) external returns (Result[] memory res) {
+    function multicall(Call3[] calldata calls) external payable returns (Result[] memory res) {
         uint256 length = calls.length;
-
         res = new Result[](length);
-
-        Call3 calldata calli;
-
-        for (uint256 i = 0; i < length; ) {
-            calli = calls[i];
+        Call3 calldata call;
+        for (uint256 i = 0; i < length;) {
+            call = calls[i];
 
             // delegatecall to itself, it turns allowing invoking functions from other actions
-            (bool success, bytes memory result) = address(this).delegatecall(calli.callData);
+            (bool success, bytes memory result) = address(this).delegatecall(call.callData);
 
-            if (!success && !calli.allowFailure) {
+            if (!success && !call.allowFailure) {
                 assembly {
                     // We use Yul's revert() to bubble up errors from the target contract.
                     revert(add(32, result), mload(result))
@@ -48,4 +139,33 @@ contract ActionMisc is IPActionMisc, TokenHelper {
             }
         }
     }
+
+    function multicallRevert(uint256 gasLimit, Call3[] calldata calls)
+        public
+        payable
+        returns (bytes[] memory res, uint256[] memory gasUsed)
+    {
+        uint256 length = calls.length;
+        res = new bytes[](length);
+        gasUsed = new uint256[](length);
+        Call3 calldata call;
+        for (uint256 i = 0; i < length;) {
+            call = calls[i];
+
+            uint256 gasBefore = gasleft();
+            (, res[i]) = address(this).delegatecall{gas: gasLimit}(
+                abi.encodeWithSignature("callThenRevert(address,bytes)", address(this), call.callData)
+            );
+            gasUsed[i] = gasBefore - gasleft();
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function callThenRevert(address target, bytes memory callData) public payable {
+        (bool success, bytes memory resp) = target.delegatecall(callData);
+        revert Errors.CallThenRevertError(success, resp);
+    }
 }

package/contracts/router/ActionSwapPT.sol

@@ -1,235 +1,75 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity 0.8.21;
 
-import "./base/ActionBaseMintRedeem.sol";
+import "./base/ActionBase.sol";
 import "../interfaces/IPActionSwapPT.sol";
-import "../interfaces/IPMarket.sol";
-import "../core/libraries/Errors.sol";
 
-/// @dev All swap actions will revert if market is expired
-contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
-    using MarketMathCore for MarketState;
-    using MarketApproxPtInLib for MarketState;
-    using MarketApproxPtOutLib for MarketState;
+contract ActionSwapPT is IPActionSwapPT, ActionBase {
     using PMath for uint256;
-    using PMath for int256;
-    using PYIndexLib for IPYieldToken;
 
-    /**
-     * @notice swaps exact amount of PT for SY
-     * @param exactPtIn will always consume this exact amount of PT for as much SY as possible
-     * @return netSyOut amount SY output, will not be less than `minSyOut`
-     * @return netSyFee amount SY fee incurred
-     */
-    function swapExactPtForSy(
-        address receiver,
-        address market,
-        uint256 exactPtIn,
-        uint256 minSyOut
-    ) external returns (uint256 netSyOut, uint256 netSyFee) {
-        (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
-        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
-
-        (netSyOut, netSyFee) = IPMarket(market).swapExactPtForSy(receiver, exactPtIn, EMPTY_BYTES);
-
-        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
-
-        emit SwapPtAndSy(msg.sender, market, receiver, exactPtIn.neg(), netSyOut.Int());
-    }
-
-    /**
-     * @notice swaps some amount of PT for the desired SY amount
-     * @param guessPtIn approximation data for input PT amount
-     * @param exactSyOut will consume as little PT as possible for this much SY amount
-     * @return netPtIn amount of PT used, will not be more than `maxPtIn`
-     * @return netSyFee amount SY fee incurred
-     * @dev the SY output might be slightly more than `exactSyOut` since an approximation is used.
-     * It is guaranteed that exactSyOut <= actualSyOut <= exactSyOut*(100% + guessPtIn.eps)
-     */
-    function swapPtForExactSy(
-        address receiver,
-        address market,
-        uint256 exactSyOut,
-        uint256 maxPtIn,
-        ApproxParams calldata guessPtIn
-    ) external returns (uint256 netPtIn, uint256 netSyFee) {
-        MarketState memory state = IPMarket(market).readState(address(this));
-        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
-
-        (netPtIn, , ) = state.approxSwapPtForExactSy(
-            YT.newIndex(),
-            exactSyOut,
-            block.timestamp,
-            guessPtIn
-        );
-
-        if (netPtIn > maxPtIn) revert Errors.RouterExceededLimitPtIn(netPtIn, maxPtIn);
-
-        _transferFrom(IERC20(PT), msg.sender, market, netPtIn);
-
-        uint256 netSyOut;
-        (netSyOut, netSyFee) = IPMarket(market).swapExactPtForSy(receiver, netPtIn, EMPTY_BYTES);
-
-        // fail-safe
-        if (netSyOut < exactSyOut) assert(false);
-
-        emit SwapPtAndSy(msg.sender, market, receiver, netPtIn.neg(), exactSyOut.Int());
-    }
-
-    /**
-     * @notice swaps SY for exact amount of PT
-     * @param exactPtOut will always consume as little SY as possible for this much amount of PT
-     * @return netSyIn amount SY used, will not be more than `maxSyIn`
-     * @return netSyFee amount SY fee incurred
-     * @dev the output amount of PT here is exact, no approximation is used
-     */
-    function swapSyForExactPt(
+    // ------------------ SWAP TOKEN FOR PT ------------------
+    function swapExactTokenForPt(
         address receiver,
         address market,
-        uint256 exactPtOut,
-        uint256 maxSyIn
-    ) external returns (uint256 netSyIn, uint256 netSyFee) {
-        MarketState memory state = IPMarket(market).readState(address(this));
-        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
-
-        (netSyIn, , ) = state.swapSyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
-
-        if (netSyIn > maxSyIn) revert Errors.RouterExceededLimitSyIn(netSyIn, maxSyIn);
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut,
+        TokenInput calldata input,
+        LimitOrderData calldata limit
+    ) external payable returns (uint256 netPtOut, uint256 netSyFee) {
+        (IStandardizedYield SY,,) = IPMarket(market).readTokens();
 
-        _transferFrom(IERC20(SY), msg.sender, market, netSyIn);
+        uint256 netSyUseToBuyPt = _mintSyFromToken(_entry_swapExactSyForPt(market, limit), address(SY), 1, input);
 
-        (, netSyFee) = IPMarket(market).swapSyForExactPt(receiver, exactPtOut, EMPTY_BYTES); // ignore return
+        (netPtOut, netSyFee) = _swapExactSyForPt(receiver, market, netSyUseToBuyPt, minPtOut, guessPtOut, limit);
 
-        // no fail-safe since exactly netSyIn will go into the market
-        emit SwapPtAndSy(msg.sender, market, receiver, exactPtOut.Int(), netSyIn.neg());
+        emit SwapPtAndToken(msg.sender, market, input.tokenIn, receiver, netPtOut.Int(), input.netTokenIn.neg());
     }
 
-    /**
-     * @notice swaps exact amount of SY for as much PT as possible
-     * @param exactSyIn will always consume this much amount of SY
-     * @param guessPtOut approximation data for output PT amount
-     * @return netPtOut amount of PT output, will not be less than `minPtOut`
-     * @return netSyFee amount SY fee incurred
-     */
     function swapExactSyForPt(
         address receiver,
         address market,
         uint256 exactSyIn,
         uint256 minPtOut,
-        ApproxParams calldata guessPtOut
+        ApproxParams calldata guessPtOut,
+        LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
-        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
-
-        _transferFrom(IERC20(SY), msg.sender, market, exactSyIn);
-
-        (netPtOut, netSyFee) = _swapExactSyForPt(
-            receiver,
-            market,
-            YT,
-            exactSyIn,
-            minPtOut,
-            guessPtOut
-        );
+        (IStandardizedYield SY,,) = IPMarket(market).readTokens();
+        _transferFrom(SY, msg.sender, _entry_swapExactSyForPt(market, limit), exactSyIn);
 
+        (netPtOut, netSyFee) = _swapExactSyForPt(receiver, market, exactSyIn, minPtOut, guessPtOut, limit);
         emit SwapPtAndSy(msg.sender, market, receiver, netPtOut.Int(), exactSyIn.neg());
     }
 
-    /**
-     * @notice swap (through Kyberswap) from any input token for SY-mintable tokens, then mints SY
-     * and swaps said SY for PT
-     * @param input data for input token, see {`./kyberswap/KyberSwapHelper.sol`}
-     * @dev is a combination of `_mintSyFromToken()` and `_swapExactSyForPt()`
-     */
-    function swapExactTokenForPt(
-        address receiver,
-        address market,
-        uint256 minPtOut,
-        ApproxParams calldata guessPtOut,
-        TokenInput calldata input
-    ) external payable returns (uint256 netPtOut, uint256 netSyFee) {
-        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
-
-        // all output SY is transferred directly to the market
-        uint256 netSyUseToBuyPt = _mintSyFromToken(address(market), address(SY), 1, input);
-
-        // SY is already in the market, hence doPull = false
-        (netPtOut, netSyFee) = _swapExactSyForPt(
-            receiver,
-            market,
-            YT,
-            netSyUseToBuyPt,
-            minPtOut,
-            guessPtOut
-        );
-
-        emit SwapPtAndToken(
-            msg.sender,
-            market,
-            input.tokenIn,
-            receiver,
-            netPtOut.Int(),
-            input.netTokenIn.neg()
-        );
-    }
-
-    /**
-     * @notice swap from exact amount of PT to SY, then redeem SY for assets, finally swaps
-     * resulting assets through Kyberswap to get desired output token
-     * @param exactPtIn will always consume this much PT for as much SY as possible
-     * @param output data for desired output token, see {`./kyberswap/KyberSwapHelper.sol`}
-     * @dev is a combination of `_swapExactPtForSy()` and `_redeemSyToToken()`
-     */
+    // ------------------ SWAP PT FOR TOKEN ------------------
     function swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
-        TokenOutput calldata output
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee) {
-        (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        (IStandardizedYield SY, IPPrincipalToken PT,) = IPMarket(market).readTokens();
+        _transferFrom(PT, msg.sender, _entry_swapExactPtForSy(market, limit), exactPtIn);
 
-        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
-
-        // all output SY is directly transferred to the SY contract
         uint256 netSyReceived;
-        (netSyReceived, netSyFee) = IPMarket(market).swapExactPtForSy(
-            _syOrBulk(address(SY), output),
-            exactPtIn,
-            EMPTY_BYTES
-        );
+        (netSyReceived, netSyFee) = _swapExactPtForSy(address(SY), market, exactPtIn, 0, limit);
 
-        // since all SY is already at the SY contract, doPull = false
         netTokenOut = _redeemSyToToken(receiver, address(SY), netSyReceived, output, false);
 
-        emit SwapPtAndToken(
-            msg.sender,
-            market,
-            output.tokenOut,
-            receiver,
-            exactPtIn.neg(),
-            netTokenOut.Int()
-        );
+        emit SwapPtAndToken(msg.sender, market, output.tokenOut, receiver, exactPtIn.neg(), netTokenOut.Int());
     }
 
-    function _swapExactSyForPt(
+    function swapExactPtForSy(
         address receiver,
         address market,
-        IPYieldToken YT,
-        uint256 exactSyIn,
-        uint256 minPtOut,
-        ApproxParams calldata guessPtOut
-    ) internal returns (uint256 netPtOut, uint256 netSyFee) {
-        MarketState memory state = IPMarket(market).readState(address(this));
-
-        (netPtOut, ) = state.approxSwapExactSyForPt(
-            YT.newIndex(),
-            exactSyIn,
-            block.timestamp,
-            guessPtOut
-        );
-
-        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+        uint256 exactPtIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netSyOut, uint256 netSyFee) {
+        (, IPPrincipalToken PT,) = IPMarket(market).readTokens();
+        _transferFrom(PT, msg.sender, _entry_swapExactPtForSy(market, limit), exactPtIn);
 
-        (, netSyFee) = IPMarket(market).swapSyForExactPt(receiver, netPtOut, EMPTY_BYTES);
-        // no fail-safe since exactly netPtOut >= minPtOut will be out
+        (netSyOut, netSyFee) = _swapExactPtForSy(receiver, market, exactPtIn, minSyOut, limit);
+        emit SwapPtAndSy(msg.sender, market, receiver, exactPtIn.neg(), netSyOut.Int());
     }
 }