@pendle/core-v2 0.6.8 → 0.7.0

package/contracts/core/actions/base/ActionSCYAndYTBase.sol

@@ -1,43 +1,56 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 import "../../../interfaces/IPMarketFactory.sol";
 import "../../../interfaces/IPMarket.sol";
-import "../../../SuperComposableYield/SCYUtils.sol";
+import "../../../libraries/SCY/SCYUtils.sol";
 import "../../../libraries/math/MarketApproxLib.sol";
-import "../../../libraries/math/MarketMathAux.sol";
 import "./ActionSCYAndPYBase.sol";
-import "./ActionType.sol";
+import "./CallbackHelper.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, ActionType {
+abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
-    using MarketMathAux for MarketState;
     using MarketApproxLib for MarketState;
     using SafeERC20 for ISuperComposableYield;
     using SafeERC20 for IPYieldToken;
+    using SCYIndexLib for ISuperComposableYield;
 
-    event SwapYT(address indexed user, int256 ytToAccount, int256 scyToAccount);
+    event SwapYTAndSCY(address indexed user, int256 ytToAccount, int256 scyToAccount);
 
+    /**
+    * @notice swap exact SCY to YT with the help of flashswaps & YT tokenization / redemption
+    * @dev inner working of this function:
+     - `exactScyIn` SCY is transferred to YT contract
+     - `market.swapExactPtForScy` is called, which will transfer SCY directly to YT contract & callback is invoked.
+        Note that now we owe PT
+     - in callback, all SCY in YT contract is used to mint PT + YT, with PT used to pay back the loan, and YT
+        transferred to the receiver
+    * @dev this function works in conjunction with ActionCallback
+     */
     function _swapExactScyForYt(
         address receiver,
         address market,
         uint256 exactScyIn,
-        ApproxParams memory approx,
+        uint256 minYtOut,
+        ApproxParams memory guessYtOut,
         bool doPull
     ) internal returns (uint256 netYtOut) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
         MarketState memory state = IPMarket(market).readState(false);
 
         (netYtOut, ) = state.approxSwapExactScyForYt(
-            SCYIndexLib.newIndex(SCY),
+            SCY.newIndex(),
             exactScyIn,
             block.timestamp,
-            approx
+            guessYtOut
         );
 
+        // early-check
+        require(netYtOut >= minYtOut, "insufficient YT out");
+
         if (doPull) {
             SCY.safeTransferFrom(msg.sender, address(YT), exactScyIn);
         }
@@ -45,19 +58,21 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, ActionType {
         IPMarket(market).swapExactPtForScy(
             address(YT),
             netYtOut, // exactPtIn = netYtOut
-            1,
-            abi.encode(ACTION_TYPE.SwapExactScyForYt, receiver)
-        ); // ignore-return
+            _encodeSwapExactScyForYt(receiver, minYtOut)
+        );
 
-        emit SwapYT(receiver, netYtOut.Int(), exactScyIn.neg());
+        emit SwapYTAndSCY(receiver, netYtOut.Int(), exactScyIn.neg());
     }
 
     /**
+    * @notice swap exact YT to SCY with the help of flashswaps & YT tokenization / redemption
     * @dev inner working of this function:
-     - YT is transferred to the YT contract
-     - market.swap is called, which will transfer PT directly to the YT contract, and callback is invoked
-     - callback will call YT's redeemPY, which will redeem the outcome SCY to this router, then
-        all SCY owed to the market will be paid, the rest is transferred to the receiver
+     - `exactYtIn` YT is transferred to YT contract
+     - `market.swapScyForExactPt` is called, which will transfer PT directly to YT contract & callback is invoked.
+        Note that now we owe SCY
+     - in callback, all PT + YT in YT contract is used to redeem SCY. A portion of SCY is used to payback the loan,
+        the rest is transferred to the `receiver`
+    * @dev this function works in conjunction with ActionCallback
      */
     function _swapExactYtForScy(
         address receiver,
@@ -68,29 +83,31 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, ActionType {
     ) internal returns (uint256 netScyOut) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 preBalanceScy = SCY.balanceOf(receiver);
-
         if (doPull) {
             YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
         }
 
+        uint256 preScyBalance = SCY.balanceOf(receiver);
+
         IPMarket(market).swapScyForExactPt(
             address(YT),
             exactYtIn, // exactPtOut = exactYtIn
-            type(uint256).max,
-            abi.encode(ACTION_TYPE.SwapExactYtForScy, receiver)
+            _encodeSwapYtForScy(receiver, minScyOut)
         ); // ignore return
 
-        netScyOut = SCY.balanceOf(receiver) - preBalanceScy;
-        require(netScyOut >= minScyOut, "INSUFFICIENT_SCY_OUT");
+        netScyOut = SCY.balanceOf(receiver) - preScyBalance;
 
-        emit SwapYT(receiver, exactYtIn.neg(), netScyOut.Int());
+        emit SwapYTAndSCY(receiver, exactYtIn.neg(), netScyOut.Int());
     }
 
     /**
-     * @dev inner working of this function:
-     - market.swap is called, which will transfer SCY directly to the YT contract, and callback is invoked
-     - callback will pull more SCY if necessary, do call YT's mintPY, which will mint PT to the market & YT to the receiver
+    * @notice swap SCY to exact YT with the help of flashswaps & YT tokenization / redemption
+    * @dev inner working of this function:
+     - `market.swapExactPtForScy` is called, which will transfer SCY directly to YT contract & callback is invoked.
+        Note that now we owe PT
+     - in callback, we will pull in more SCY as needed & mint all SCY to PT + YT. PT is then used to payback the loan
+        while YT is transferred to the user
+    * @dev this function works in conjunction with ActionCallback
      */
     function _swapScyForExactYt(
         address receiver,
@@ -98,41 +115,47 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, ActionType {
         uint256 exactYtOut,
         uint256 maxScyIn
     ) internal returns (uint256 netScyIn) {
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
-
-        uint256 preBalanceScy = SCY.balanceOf(receiver);
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         IPMarket(market).swapExactPtForScy(
             address(YT),
             exactYtOut, // exactPtIn = exactYtOut
-            1,
-            abi.encode(ACTION_TYPE.SwapSCYForExactYt, msg.sender, receiver)
-        ); // ignore return
-
-        netScyIn = preBalanceScy - SCY.balanceOf(receiver);
-
-        require(netScyIn <= maxScyIn, "exceed out limit");
+            _encodeSwapScyForExactYt(msg.sender, receiver, maxScyIn)
+        );
 
-        emit SwapYT(receiver, exactYtOut.Int(), netScyIn.neg());
+        emit SwapYTAndSCY(receiver, exactYtOut.Int(), netScyIn.neg());
     }
 
+    /**
+    * @notice swap YT to exact SCY with the help of flashswaps & YT tokenization / redemption
+    * @dev inner working of this function:
+     - transfer netYtIn (received from approx function) to YT contract
+     - `market.swapScyForExactPt` is called, which will transfer PT directly to YT contract & callback is invoked.
+        Note that now we owe SCY
+     - in callback, we will redeem all PT + YT to get SCY. A portion of it is used to payback the loan. The rest is
+        transferred to `receiver`
+    * @dev this function works in conjunction with ActionCallback
+     */
     function _swapYtForExactScy(
         address receiver,
         address market,
         uint256 exactScyOut,
-        ApproxParams memory approx,
+        uint256 maxYtIn,
+        ApproxParams memory guessYtIn,
         bool doPull
     ) internal returns (uint256 netYtIn) {
         MarketState memory state = IPMarket(market).readState(false);
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         (netYtIn, ) = state.approxSwapYtForExactScy(
-            SCYIndexLib.newIndex(SCY),
+            SCY.newIndex(),
             exactScyOut,
             block.timestamp,
-            approx
+            guessYtIn
         );
 
+        require(netYtIn <= maxYtIn, "exceed YT in limit");
+
         if (doPull) {
             YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
         }
@@ -140,10 +163,69 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, ActionType {
         IPMarket(market).swapScyForExactPt(
             address(YT),
             netYtIn, // exactPtOut = netYtIn
-            type(uint256).max,
-            abi.encode(ACTION_TYPE.SwapYtForExactScy, receiver)
+            _encodeSwapYtForScy(receiver, exactScyOut)
         ); // ignore return
 
-        emit SwapYT(receiver, netYtIn.neg(), exactScyOut.Int());
+        emit SwapYTAndSCY(receiver, netYtIn.neg(), exactScyOut.Int());
+    }
+
+    /**
+     * @notice swap any ERC20 tokens, through Uniswap's forks, to baseToken of the corresponding SCY of YT. These SCY is then
+        used to swap to YT. Please refer to swapExactScyForYt for more details.
+     */
+    function _swapExactRawTokenForYt(
+        address receiver,
+        address market,
+        uint256 exactRawTokenIn,
+        uint256 minYtOut,
+        address[] calldata path,
+        ApproxParams memory guessYtOut,
+        bool doPull
+    ) internal returns (uint256 netYtOut) {
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 netScyUsedToBuyYT = _mintScyFromRawToken(
+            address(YT),
+            address(SCY),
+            exactRawTokenIn,
+            1,
+            path,
+            doPull
+        );
+
+        netYtOut = _swapExactScyForYt(
+            receiver,
+            market,
+            netScyUsedToBuyYT,
+            minYtOut,
+            guessYtOut,
+            false
+        );
+    }
+
+    /**
+     * @notice swap YT to SCY (using `swapExactYtForScy` logic), then redeem SCY to baseToken & swap baseToken to rawToken
+        through Uniswap's forks
+     */
+    function _swapExactYtForRawToken(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minRawTokenOut,
+        address[] calldata path,
+        bool doPull
+    ) internal returns (uint256 netRawTokenOut) {
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+
+        uint256 netScyOut = _swapExactYtForScy(address(SCY), market, exactYtIn, 1, doPull);
+
+        netRawTokenOut = _redeemScyToRawToken(
+            receiver,
+            address(SCY),
+            netScyOut,
+            minRawTokenOut,
+            path,
+            false
+        );
     }
 }

package/contracts/core/actions/base/CallbackHelper.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+abstract contract CallbackHelper {
+    enum ActionType {
+        SwapScyForExactYt,
+        SwapExactScyForYt,
+        SwapYtForScy
+    }
+
+    /// ------------------------------------------------------------
+    /// SwapExactScyForYt
+    /// ------------------------------------------------------------
+
+    function _encodeSwapExactScyForYt(address receiver, uint256 minYtOut)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encode(ActionType.SwapExactScyForYt, receiver, minYtOut);
+    }
+
+    function _decodeSwapExactScyForYt(bytes memory data)
+        internal
+        pure
+        returns (address receiver, uint256 minYtOut)
+    {
+        (, receiver, minYtOut) = abi.decode(data, (ActionType, address, uint256));
+    }
+
+    /// ------------------------------------------------------------
+    /// SwapScyForExactYt
+    /// ------------------------------------------------------------
+
+    function _encodeSwapScyForExactYt(
+        address payer,
+        address receiver,
+        uint256 maxScyIn
+    ) internal pure returns (bytes memory) {
+        return abi.encode(ActionType.SwapScyForExactYt, payer, receiver, maxScyIn);
+    }
+
+    function _decodeSwapScyForExactYt(bytes memory data)
+        internal
+        pure
+        returns (
+            address payer,
+            address receiver,
+            uint256 maxScyIn
+        )
+    {
+        (, payer, receiver, maxScyIn) = abi.decode(data, (ActionType, address, address, uint256));
+    }
+
+    /// ------------------------------------------------------------
+    /// SwapYtForScy (common encode & decode)
+    /// ------------------------------------------------------------
+
+    function _encodeSwapYtForScy(address receiver, uint256 minScyOut)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encode(ActionType.SwapYtForScy, receiver, minScyOut);
+    }
+
+    function _decodeSwapYtForScy(bytes memory data)
+        internal
+        pure
+        returns (address receiver, uint256 minScyOut)
+    {
+        (, receiver, minScyOut) = abi.decode(data, (ActionType, address, uint256));
+    }
+
+    /// ------------------------------------------------------------
+    /// Misc functions
+    /// ------------------------------------------------------------
+    function _getActionType(bytes memory data) internal pure returns (ActionType actionType) {
+        (actionType, ) = abi.decode(data, (ActionType, address));
+    }
+}

package/contracts/interfaces/IAToken.sol

@@ -20,7 +20,7 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 interface IAToken is IERC20 {
@@ -31,4 +31,14 @@ interface IAToken is IERC20 {
      * @return The scaled balance of the user
      **/
     function scaledBalanceOf(address user) external view returns (uint256);
+
+    /**
+     * @notice Returns the address of the underlying asset of this aToken (E.g. WETH for aWETH)
+     * @return The address of the underlying asset
+     **/
+    function UNDERLYING_ASSET_ADDRESS() external view returns (address);
+
+    function getIncentivesController() external view returns (address);
+
+    function POOL() external view returns (address);
 }

package/contracts/interfaces/IAavePool.sol

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 interface IAavePool {
     function supply(

package/contracts/interfaces/IAaveRewardsController.sol

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 interface IAaveRewardsController {
     function claimAllRewards(address[] calldata assets, address to)

package/contracts/interfaces/IBenQiComptroller.sol

@@ -20,7 +20,7 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 interface IBenQiComptroller {
     function claimReward(
@@ -30,4 +30,6 @@ interface IBenQiComptroller {
         bool borrowers,
         bool suppliers
     ) external;
+
+    function qiAddress() external view returns (address);
 }

package/contracts/interfaces/IBenQiInterestRateModel.sol

@@ -0,0 +1,16 @@
+pragma solidity 0.8.13;
+
+interface IBenQiInterestRateModel {
+    function getBorrowRate(
+        uint256 cash,
+        uint256 borrows,
+        uint256 reserves
+    ) external view returns (uint256);
+
+    function getSupplyRate(
+        uint256 cash,
+        uint256 borrows,
+        uint256 reserves,
+        uint256 reserveFactorMantissa
+    ) external view returns (uint256);
+}

package/contracts/interfaces/ICelerMessageBus.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity >=0.8.0;
+
+interface ICelerMessageBus {
+    /**
+     * @notice Calculates the required fee for the message.
+     * @param _message Arbitrary message bytes to be decoded by the destination app contract.
+     @ @return The required fee.
+     */
+    function calcFee(bytes calldata _message) external view returns (uint256);
+
+    /**
+     * @notice Sends a message to a contract on another chain.
+     * Sender needs to make sure the uniqueness of the message Id, which is computed as
+     * hash(type.MessageOnly, sender, receiver, srcChainId, srcTxHash, dstChainId, message).
+     * If messages with the same Id are sent, only one of them will succeed at dst chain..
+     * A fee is charged in the native gas token.
+     * @param _receiver The address of the destination app contract.
+     * @param _dstChainId The destination chain ID.
+     * @param _message Arbitrary message bytes to be decoded by the destination app contract.
+     */
+    function sendMessage(
+        address _receiver,
+        uint256 _dstChainId,
+        bytes calldata _message
+    ) external payable;
+}

package/contracts/interfaces/ICelerMessageReceiverApp.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity >=0.8.0;
+
+interface ICelerMessageReceiverApp {
+    enum ExecutionStatus {
+        Fail, // execution failed, finalized
+        Success, // execution succeeded, finalized
+        Retry // execution rejected, can retry later
+    }
+
+    /**
+     * @notice Called by MessageBus (MessageBusReceiver)
+     * @param _sender The address of the source app contract
+     * @param _srcChainId The source chain ID where the transfer is originated from
+     * @param _message Arbitrary message bytes originated from and encoded by the source app contract
+     * @param _executor Address who called the MessageBus execution function
+     */
+    function executeMessage(
+        address _sender,
+        uint64 _srcChainId,
+        bytes calldata _message,
+        address _executor
+    ) external payable returns (ExecutionStatus);
+}

package/contracts/interfaces/IERC4626.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+
+pragma solidity 0.8.13;
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+interface IERC4626 is IERC20Metadata {
+    function asset() external view returns (address);
+
+    function deposit(uint256 assets, address receiver) external returns (uint256);
+
+    function redeem(
+        uint256 assets,
+        address receiver,
+        address owner
+    ) external returns (uint256);
+
+    function convertToAssets(uint256 shares) external view returns (uint256);
+}

package/contracts/interfaces/IJoeRouter01.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 interface IJoeRouter01 {
     function addLiquidity(

package/contracts/interfaces/IJoeRouter02.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.13;
+
+import "./IJoeRouter01.sol";
+
+interface IJoeRouter02 is IJoeRouter01 {
+    function removeLiquidityAVAXSupportingFeeOnTransferTokens(
+        address token,
+        uint256 liquidity,
+        uint256 amountTokenMin,
+        uint256 amountAVAXMin,
+        address to,
+        uint256 deadline
+    ) external returns (uint256 amountAVAX);
+
+    function removeLiquidityAVAXWithPermitSupportingFeeOnTransferTokens(
+        address token,
+        uint256 liquidity,
+        uint256 amountTokenMin,
+        uint256 amountAVAXMin,
+        address to,
+        uint256 deadline,
+        bool approveMax,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external returns (uint256 amountAVAX);
+
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external;
+
+    function swapExactAVAXForTokensSupportingFeeOnTransferTokens(
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external payable;
+
+    function swapExactTokensForAVAXSupportingFeeOnTransferTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external;
+}