@pendle/core-v2 0.1.0

package/contracts/core/router/PendleRouterProxy.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "../misc/BoringOwnableUpg.sol";
+import "@openzeppelin/contracts/proxy/Proxy.sol";
+import "../../interfaces/IPRouterCore.sol";
+import "../../interfaces/IPRouterYT.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
+contract PendleRouterProxy is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg {
+    address public immutable PENDLE_ROUTER_CORE;
+    address public immutable PENDLE_ROUTER_YT;
+
+    constructor(address _PENDLE_ROUTER_CORE, address _PENDLE_ROUTER_YT) {
+        PENDLE_ROUTER_CORE = _PENDLE_ROUTER_CORE;
+        PENDLE_ROUTER_YT = _PENDLE_ROUTER_YT;
+    }
+
+    function initialize() external initializer {
+        __UUPSUpgradeable_init();
+        __BoringOwnable_init();
+    }
+
+    function getRouterImplementation(bytes4 sig) public view returns (address) {
+        if (
+            sig == IPRouterCore.mintScyFromRawToken.selector ||
+            sig == IPRouterCore.redeemScyToRawToken.selector ||
+            sig == IPRouterCore.mintYoFromRawToken.selector ||
+            sig == IPRouterCore.redeemYoToRawToken.selector ||
+            sig == IPRouterCore.addLiquidity.selector ||
+            sig == IPRouterCore.removeLiquidity.selector ||
+            sig == IPRouterCore.swapExactOtForScy.selector ||
+            sig == IPRouterCore.swapOtForExactScy.selector ||
+            sig == IPRouterCore.swapScyForExactOt.selector ||
+            sig == IPRouterCore.swapExactScyForOt.selector ||
+            sig == IPRouterCore.swapExactRawTokenForOt.selector ||
+            sig == IPRouterCore.swapExactOtForRawToken.selector
+        ) {
+            return PENDLE_ROUTER_CORE;
+        } else if (
+            sig == IPRouterYT.swapExactYtForScy.selector ||
+            sig == IPRouterYT.swapScyForExactYt.selector ||
+            sig == IPRouterYT.swapExactScyForYt.selector ||
+            sig == IPRouterYT.swapExactRawTokenForYt.selector ||
+            sig == IPRouterYT.swapExactYtForRawToken.selector
+        ) {
+            return PENDLE_ROUTER_YT;
+        } else if (sig == IPMarketSwapCallback.swapCallback.selector) {
+            // only ROUTER_YT is doing callback
+            return PENDLE_ROUTER_YT;
+        }
+        require(false, "invalid market sig");
+    }
+
+    function _implementation() internal view override returns (address) {
+        return getRouterImplementation(msg.sig);
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}

package/contracts/core/router/PendleRouterYTUpg.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "./base/PendleRouterSCYAndForgeBaseUpg.sol";
+import "./base/PendleRouterYTBaseUpg.sol";
+import "../../interfaces/IPOwnershipToken.sol";
+import "../../interfaces/IPYieldToken.sol";
+
+contract PendleRouterYTUpg is PendleRouterSCYAndForgeBaseUpg, PendleRouterYTBaseUpg {
+    using MarketMathLib for MarketParameters;
+    using FixedPoint for uint256;
+    using FixedPoint for int256;
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor(
+        address _joeRouter,
+        address _joeFactory,
+        address _marketFactory
+    )
+        PendleRouterSCYAndForgeBaseUpg(_joeRouter, _joeFactory)
+        PendleRouterYTBaseUpg(_marketFactory)
+    //solhint-disable-next-line no-empty-blocks
+    {
+
+    }
+
+    function swapExactYtForScy(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minScyOut
+    ) external returns (uint256) {
+        return _swapExactYtForScy(receiver, market, exactYtIn, minScyOut, true);
+    }
+
+    function swapScyForExactYt(
+        address receiver,
+        address market,
+        uint256 exactYtOut,
+        uint256 maxScyIn
+    ) external returns (uint256) {
+        return _swapScyForExactYt(receiver, market, exactYtOut, maxScyIn);
+    }
+
+    function swapExactScyForYt(
+        address receiver,
+        address market,
+        uint256 exactScyIn,
+        uint256 minYtOut,
+        uint256 netYtOutGuessMin,
+        uint256 netYtOutGuessMax
+    ) external returns (uint256) {
+        return
+            _swapExactScyForYt(
+                receiver,
+                market,
+                exactScyIn,
+                minYtOut,
+                netYtOutGuessMin,
+                netYtOutGuessMax,
+                true
+            );
+    }
+
+    /**
+     * @dev netYtOutGuessMin & Max can be used in the same way as RawTokenOT
+     * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
+     * @dev inner working of this function:
+     - mintScyFromRawToken is invoked, except the YT contract will receive all the outcome SCY
+     - market.swap is called, which will transfer SCY to the YT contract, and callback is invoked
+     - callback will do call YT's mintYO, which will mint OT to the market & YT to the receiver
+     */
+    function swapExactRawTokenForYt(
+        uint256 exactRawTokenIn,
+        address receiver,
+        address[] calldata path,
+        address market,
+        uint256 minYtOut,
+        uint256 netYtOutGuessMin,
+        uint256 netYtOutGuessMax
+    ) external returns (uint256 netYtOut) {
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 netScyUsedToBuyYT = _mintScyFromRawToken(
+            exactRawTokenIn,
+            address(SCY),
+            1,
+            address(YT),
+            path,
+            true
+        );
+
+        netYtOut = _swapExactScyForYt(
+            receiver,
+            market,
+            netScyUsedToBuyYT,
+            minYtOut,
+            netYtOutGuessMin,
+            netYtOutGuessMax,
+            false
+        );
+    }
+
+    /**
+     * @notice swap YT -> SCY -> baseToken -> rawToken
+     * @notice the algorithm to swap will guarantee to swap all the YT available
+     * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
+     * @dev inner working of this function:
+     - YT is transferred to the YT contract
+     - market.swap is called, which will transfer OT directly to the YT contract, and callback is invoked
+     - callback will do call YT's redeemYO, which will redeem the outcome SCY to this router, then
+        all SCY owed to the market will be paid, the rest is used to feed redeemScyToRawToken
+     */
+    function swapExactYtForRawToken(
+        uint256 exactYtIn,
+        address receiver,
+        address[] calldata path,
+        address market,
+        uint256 minRawTokenOut
+    ) external returns (uint256 netRawTokenOut) {
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+
+        uint256 netScyOut = _swapExactYtForScy(address(SCY), market, exactYtIn, 1, true);
+
+        netRawTokenOut = _redeemScyToRawToken(
+            address(SCY),
+            netScyOut,
+            minRawTokenOut,
+            receiver,
+            path,
+            false
+        );
+    }
+}

package/contracts/core/router/base/PendleRouterOTBaseUpg.sol

@@ -0,0 +1,218 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "../../../interfaces/IPMarketFactory.sol";
+import "../../../interfaces/IPMarket.sol";
+import "../../../interfaces/IPMarketAddRemoveCallback.sol";
+import "../../../interfaces/IPMarketSwapCallback.sol";
+import "../../../libraries/math/MarketApproxLib.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
+
+abstract contract PendleRouterOTBaseUpg {
+    using FixedPoint for uint256;
+    using FixedPoint for int256;
+    using MarketMathLib for MarketParameters;
+    using MarketApproxLib for MarketParameters;
+    using SafeERC20 for IERC20;
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor() //solhint-disable-next-line no-empty-blocks
+    {
+
+    }
+
+    /**
+     * @notice addLiquidity to the market, using both SCY & OT, the receiver will receive LP before
+     msg.sender is required to pay SCY & OT
+     * @dev inner working of this function:
+     - market.addLiquidity is called
+     - LP is minted to the receiver, and this router's addLiquidityCallback is invoked
+     - the router will transfer the necessary scy & ot from msg.sender to the market, and finish the callback
+     */
+    function _addLiquidity(
+        address receiver,
+        address market,
+        uint256 scyDesired,
+        uint256 otDesired,
+        uint256 minLpOut,
+        bool doPull
+    )
+        internal
+        returns (
+            uint256 netLpOut,
+            uint256 scyUsed,
+            uint256 otUsed
+        )
+    {
+        (ISuperComposableYield SCY, IPOwnershipToken OT, ) = IPMarket(market).readTokens();
+
+        MarketParameters memory state = IPMarket(market).readState();
+        (, netLpOut, scyUsed, otUsed) = state.addLiquidity(
+            SCYIndexLib.newIndex(SCY),
+            scyDesired,
+            otDesired
+        );
+
+        require(netLpOut >= minLpOut, "insufficient lp out");
+
+        if (doPull) {
+            IERC20(SCY).safeTransferFrom(msg.sender, market, scyUsed);
+            IERC20(OT).safeTransferFrom(msg.sender, market, otUsed);
+        }
+
+        IPMarket(market).addLiquidity(receiver, otDesired, scyDesired, abi.encode());
+    }
+
+    /**
+     * @notice removeLiquidity from the market to receive both SCY & OT. The receiver will receive
+     SCY & OT before msg.sender is required to transfer in the necessary LP
+     * @dev inner working of this function:
+     - market.removeLiquidity is called
+     - SCY & OT is transferred to the receiver, and the router's callback is invoked
+     - the router will transfer the necessary LP from msg.sender to the market, and finish the callback
+     */
+    function _removeLiquidity(
+        address receiver,
+        address market,
+        uint256 lpToRemove,
+        uint256 scyOutMin,
+        uint256 otOutMin,
+        bool doPull
+    ) internal returns (uint256 netScyOut, uint256 netOtOut) {
+        MarketParameters memory state = IPMarket(market).readState();
+
+        (netScyOut, netOtOut) = state.removeLiquidity(lpToRemove);
+        require(netScyOut >= scyOutMin, "insufficient scy out");
+        require(netOtOut >= otOutMin, "insufficient ot out");
+
+        if (doPull) {
+            IERC20(market).safeTransferFrom(msg.sender, market, lpToRemove);
+        }
+
+        IPMarket(market).removeLiquidity(receiver, lpToRemove, abi.encode());
+    }
+
+    /**
+     * @notice swap exact OT for SCY, with receiver receiving SCY before msg.sender is required to
+     transfer the owed OT
+     * @dev inner working of this function:
+     - market.swap is called
+     - SCY is transferred to the receiver, and the router's callback is invoked
+     - the router will transfer the necessary OT from msg.sender to the market, and finish the callback
+     */
+    function _swapExactOtForScy(
+        address receiver,
+        address market,
+        uint256 exactOtIn,
+        uint256 minScyOut,
+        bool doPull
+    ) internal returns (uint256 netScyOut) {
+        if (doPull) {
+            address OT = IPMarket(market).OT();
+            IERC20(OT).safeTransferFrom(msg.sender, market, exactOtIn);
+        }
+
+        (netScyOut, ) = IPMarket(market).swapExactOtForScy(
+            receiver,
+            exactOtIn,
+            minScyOut,
+            abi.encode()
+        );
+
+        require(netScyOut >= minScyOut, "insufficient scy out");
+    }
+
+    function _swapOtForExactScy(
+        address receiver,
+        address market,
+        uint256 maxOtIn,
+        uint256 exactScyOut,
+        uint256 netOtInGuessMin,
+        uint256 netOtInGuessMax,
+        bool doPull
+    ) internal returns (uint256 netOtIn) {
+        MarketParameters memory state = IPMarket(market).readState();
+        (ISuperComposableYield SCY, IPOwnershipToken OT, ) = IPMarket(market).readTokens();
+
+        netOtIn = state.approxSwapOtForExactScy(
+            SCYIndexLib.newIndex(SCY),
+            exactScyOut,
+            block.timestamp,
+            netOtInGuessMin,
+            netOtInGuessMax
+        );
+
+        require(netOtIn <= maxOtIn, "ot in exceed limit");
+
+        if (doPull) {
+            IERC20(OT).safeTransferFrom(msg.sender, market, netOtIn);
+        }
+
+        IPMarket(market).swapExactOtForScy(receiver, netOtIn, exactScyOut, abi.encode());
+    }
+
+    /**
+     * @notice swap SCY for exact OT, with receiver receiving OT before msg.sender is required to
+     transfer the owed SCY
+     * @dev inner working of this function:
+     - market.swap is called
+     - OT is transferred to the receiver, and the router's callback is invoked
+     - the router will transfer the necessary SCY from msg.sender to the market, and finish the callback
+     */
+    function _swapScyForExactOt(
+        address receiver,
+        address market,
+        uint256 exactOtOut,
+        uint256 maxScyIn,
+        bool doPull
+    ) internal returns (uint256 netScyIn) {
+        MarketParameters memory state = IPMarket(market).readState();
+        address SCY = IPMarket(market).SCY();
+
+        (netScyIn, ) = state.swapScyForExactOt(
+            SCYIndexLib.newIndex(SCY),
+            exactOtOut,
+            block.timestamp
+        );
+        require(netScyIn <= maxScyIn, "exceed limit scy in");
+
+        if (doPull) {
+            IERC20(SCY).safeTransferFrom(msg.sender, market, netScyIn);
+        }
+
+        IPMarket(market).swapScyForExactOt(receiver, exactOtOut, maxScyIn, abi.encode());
+    }
+
+    function _swapExactScyForOt(
+        address receiver,
+        address market,
+        uint256 exactScyIn,
+        uint256 minOtOut,
+        uint256 netOtOutGuessMin,
+        uint256 netOtOutGuessMax,
+        bool doPull
+    ) internal returns (uint256 netOtOut) {
+        MarketParameters memory state = IPMarket(market).readState();
+        address SCY = IPMarket(market).SCY();
+
+        if (netOtOutGuessMax == type(uint256).max) {
+            netOtOutGuessMax = state.totalOt.Uint();
+        }
+
+        netOtOut = state.approxSwapExactScyForOt(
+            SCYIndexLib.newIndex(SCY),
+            exactScyIn,
+            block.timestamp,
+            netOtOutGuessMin,
+            netOtOutGuessMax
+        );
+
+        require(netOtOut >= minOtOut, "insufficient out");
+
+        if (doPull) {
+            IERC20(SCY).safeTransferFrom(msg.sender, market, exactScyIn);
+        }
+
+        IPMarket(market).swapScyForExactOt(receiver, netOtOut, exactScyIn, abi.encode());
+    }
+}

package/contracts/core/router/base/PendleRouterSCYAndForgeBaseUpg.sol

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
+import "../../misc/PendleJoeSwapHelperUpg.sol";
+import "../../../SuperComposableYield/ISuperComposableYield.sol";
+import "../../../interfaces/IPYieldToken.sol";
+
+abstract contract PendleRouterSCYAndForgeBaseUpg is PendleJoeSwapHelperUpg {
+    using SafeERC20 for IERC20;
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor(address _joeRouter, address _joeFactory)
+        PendleJoeSwapHelperUpg(_joeRouter, _joeFactory)
+    // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
+
+    /**
+     * @notice swap rawToken to baseToken -> baseToken to mint SCY
+     * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
+     * @dev inner working of this function:
+     - if [rawToken == baseToken], rawToken is transferred to SCY contract
+       else, it is transferred to the first pair of path, swap is called, and the output token is transferred
+            to SCY contract
+     - SCY.mint is called, minting SCY directly to receiver
+     */
+    function _mintScyFromRawToken(
+        uint256 netRawTokenIn,
+        address SCY,
+        uint256 minScyOut,
+        address receiver,
+        address[] calldata path,
+        bool doPull
+    ) internal returns (uint256 netScyOut) {
+        if (doPull) {
+            if (path.length == 1) {
+                IERC20(path[0]).safeTransferFrom(msg.sender, SCY, netRawTokenIn);
+            } else {
+                IERC20(path[0]).safeTransferFrom(msg.sender, _getFirstPair(path), netRawTokenIn);
+                _swapExactIn(path, netRawTokenIn, SCY);
+            }
+        }
+
+        address baseToken = path[path.length - 1];
+        netScyOut = ISuperComposableYield(SCY).mint(receiver, baseToken, minScyOut);
+    }
+
+    /**
+    * @notice redeem SCY to baseToken -> swap baseToken to rawToken
+    * @dev path[0] will be the baseToken that SCY is redeemed to, and path[path.length-1] is the
+    final rawToken output
+    * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
+    * @dev inner working of this function:
+     - SCY is transferred to SCY contract
+     - if [rawToken == baseToken], SCY.redeem is called & directly redeem tokens to the receiver
+       else, SCY.redeem is called with receiver = first pair in the path,
+        and swap is called, and the output token is transferred to receiver
+     */
+    function _redeemScyToRawToken(
+        address SCY,
+        uint256 netScyIn,
+        uint256 minRawTokenOut,
+        address receiver,
+        address[] memory path,
+        bool doPull
+    ) internal returns (uint256 netRawTokenOut) {
+        if (doPull) {
+            IERC20(SCY).safeTransferFrom(msg.sender, SCY, netScyIn);
+        }
+
+        address baseToken = path[0];
+        if (path.length == 1) {
+            netRawTokenOut = ISuperComposableYield(SCY).redeem(
+                receiver,
+                baseToken,
+                minRawTokenOut
+            );
+        } else {
+            uint256 netBaseTokenOut = ISuperComposableYield(SCY).redeem(
+                _getFirstPair(path),
+                baseToken,
+                1
+            );
+            netRawTokenOut = _swapExactIn(path, netBaseTokenOut, receiver);
+            require(netRawTokenOut >= minRawTokenOut, "insufficient out");
+        }
+    }
+
+    /**
+     * @notice swap rawToken to baseToken -> convert to SCY -> convert to OT + YT
+     * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
+     * @dev inner working of this function:
+     - same as mintScyFromRawToken, except the receiver of SCY will be the YT contract, then mintYO
+     will be called, minting OT + YT directly to receiver
+     */
+    function _mintYoFromRawToken(
+        uint256 netRawTokenIn,
+        address YT,
+        uint256 minYoOut,
+        address receiver,
+        address[] calldata path,
+        bool doPull
+    ) internal returns (uint256 netYoOut) {
+        address SCY = IPYieldToken(YT).SCY();
+        _mintScyFromRawToken(netRawTokenIn, SCY, 1, YT, path, doPull);
+        netYoOut = IPYieldToken(YT).mintYO(receiver, receiver);
+        require(netYoOut >= minYoOut, "insufficient YO out");
+    }
+
+    /**
+     * @notice redeem OT + YT to SCY -> redeem SCY to baseToken -> swap baseToken to rawToken
+     * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
+     * @dev inner working of this function:
+     - OT (+ YT if not expired) is transferred to the YT contract
+     - redeemYO is called, redeem all outcome SCY to the SCY contract
+     - The rest is the same as redeemScyToRawToken (except the first SCY transfer is skipped)
+     */
+    function _redeemYoToRawToken(
+        address YT,
+        uint256 netYoIn,
+        uint256 minRawTokenOut,
+        address receiver,
+        address[] memory path,
+        bool doPull
+    ) internal returns (uint256 netRawTokenOut) {
+        address OT = IPYieldToken(YT).OT();
+        address SCY = IPYieldToken(YT).SCY();
+
+        if (doPull) {
+            bool isNeedToBurnYt = (IPBaseToken(YT).isExpired() == false);
+            IERC20(OT).safeTransferFrom(msg.sender, YT, netYoIn);
+            if (isNeedToBurnYt) IERC20(YT).safeTransferFrom(msg.sender, YT, netYoIn);
+        }
+
+        IPYieldToken(YT).redeemYO(SCY);
+
+        netRawTokenOut = _redeemScyToRawToken(SCY, 0, minRawTokenOut, receiver, path, false);
+    }
+}