@pendle/core-v2 0.6.9 → 0.7.1-beta

package/contracts/SuperComposableYield/SCY-implementations/PendleERC4626SCY.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+import "../base-implementations/SCYBase.sol";
+import "../../interfaces/IERC4626.sol";
+import "../../libraries/math/Math.sol";
+
+contract PendleERC4626SCY is SCYBase {
+    using Math for uint256;
+    // if exchangeRate is >= 3e38, the contract will overflow & frozen.
+    // Therefore, a reasonable limit (1e30) is set here. It can be removed
+    // if the implementer is fully aware of the risk
+    uint256 private constant MAX_EXCHANGE_RATE = 1e30;
+
+    address public immutable underlying;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        IERC4626 _yieldToken
+    ) SCYBase(_name, _symbol, address(_yieldToken)) {
+        underlying = _yieldToken.asset();
+        _safeApprove(underlying, yieldToken, type(uint256).max);
+        _validateERC4626SCY();
+    }
+
+    function _validateERC4626SCY() internal view {
+        require(exchangeRate() <= 1e30, "too big exchangeRate");
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        // 1 4626 = 1 Share
+        if (tokenIn == yieldToken) {
+            amountSharesOut = amountDeposited;
+        } else {
+            // must be underlying
+            amountSharesOut = IERC4626(yieldToken).deposit(amountDeposited, address(this));
+        }
+    }
+
+    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == yieldToken) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            amountTokenOut = IERC4626(yieldToken).redeem(
+                amountSharesToRedeem,
+                address(this),
+                address(this)
+            );
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               SCY-INDEX
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IERC4626(yieldToken).convertToAssets(Math.ONE);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function getBaseTokens() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = yieldToken;
+    }
+
+    function isValidBaseToken(address token) public view virtual override returns (bool) {
+        return token == underlying || token == yieldToken;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
+    }
+}

package/contracts/SuperComposableYield/SCY-implementations/PendleJoeLpSCY.sol

@@ -0,0 +1,245 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../interfaces/IJoePair.sol";
+import "../../interfaces/IJoeRouter02.sol";
+import "../base-implementations/SCYBase.sol";
+import "../../libraries/math/LogExpMath.sol";
+
+contract PendleJoeLpSCY is SCYBase {
+    using Math for uint256;
+
+    address public immutable joeRouter;
+    address public immutable joePair;
+    address public immutable token0;
+    address public immutable token1;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _joeRouter,
+        address _joePair
+    ) SCYBase(_name, _symbol, _joePair) {
+        require(_joeRouter != address(0), "zero address");
+        joeRouter = _joeRouter;
+        joePair = _joePair;
+        token0 = IJoePair(joePair).token0();
+        token1 = IJoePair(joePair).token1();
+        _safeApprove(token0, joeRouter, type(uint256).max);
+        _safeApprove(token1, joeRouter, type(uint256).max);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == joePair) {
+            amountSharesOut = amount;
+        } else {
+            amountSharesOut = _performZapIn(tokenIn, amount);
+        }
+    }
+
+    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        override
+        returns (uint256 amountBaseOut)
+    {
+        if (tokenOut == joePair) {
+            amountBaseOut = amountSharesToRedeem;
+        } else {
+            amountBaseOut = _performZapOut(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        (uint256 reserve0, uint256 reserve1, ) = IJoePair(joePair).getReserves();
+
+        // K = sqrt(reserve0 * reserve1) = pow(reserve0*reserve1, 0.5)
+        uint256 currentK = LogExpMath.pow(reserve0 * reserve1, uint256(LogExpMath.ONE_18 / 2));
+        uint256 totalSupply = IJoePair(joePair).totalSupply();
+        return currentK.divDown(totalSupply);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function getBaseTokens() public view override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = token0;
+        res[1] = token1;
+        res[2] = joePair;
+    }
+
+    function isValidBaseToken(address token) public view override returns (bool res) {
+        res = (token == token0 || token == token1 || token == joePair);
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.LIQUIDITY, joePair, IERC20Metadata(joePair).decimals());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    ZAPPING IN/OUT USING ZAPPER'S ALGORITHMS
+    //////////////////////////////////////////////////////////////*/
+
+    function _performZapIn(address fromToken, uint256 amount) internal returns (uint256) {
+        require(fromToken == token0 || fromToken == token1, "Invalid fromToken");
+        // divide intermediate into appropriate amount to add liquidity
+        (uint256 token0Bought, uint256 token1Bought) = _swapIntermediate(fromToken, amount);
+
+        return _joeAddLiquidity(token0Bought, token1Bought, true);
+    }
+
+    function _performZapOut(address toToken, uint256 lpToRemove) internal returns (uint256) {
+        (uint256 token0Received, uint256 token1Received) = _joeRemoveLiquidity(lpToRemove);
+
+        if (toToken == token0) {
+            uint256 token0FromSwap = _token2Token(token1, token0, token1Received);
+            return token0Received + token0FromSwap;
+        } else {
+            uint256 token1FromSwap = _token2Token(token0, token1, token0Received);
+            return token1Received + token1FromSwap;
+        }
+    }
+
+    function _swapIntermediate(address fromToken, uint256 amount)
+        internal
+        returns (uint256 token0Bought, uint256 token1Bought)
+    {
+        (uint256 res0, uint256 res1, ) = IJoePair(joePair).getReserves();
+        if (fromToken == token0) {
+            uint256 amountToSwap = calculateSwapInAmount(res0, amount);
+            //if no reserve or a new pair is created
+            if (amountToSwap <= 0) amountToSwap = amount / 2;
+            token1Bought = _token2Token(fromToken, token1, amountToSwap);
+            token0Bought = amount - amountToSwap;
+        } else {
+            uint256 amountToSwap = calculateSwapInAmount(res1, amount);
+            //if no reserve or a new pair is created
+            if (amountToSwap <= 0) amountToSwap = amount / 2;
+            token0Bought = _token2Token(fromToken, token0, amountToSwap);
+            token1Bought = amount - amountToSwap;
+        }
+    }
+
+    function _joeAddLiquidity(
+        uint256 token0Bought,
+        uint256 token1Bought,
+        bool transferResidual
+    ) internal returns (uint256) {
+        (uint256 amountA, uint256 amountB, uint256 LP) = IJoeRouter02(joeRouter).addLiquidity(
+            token0,
+            token1,
+            token0Bought,
+            token1Bought,
+            1,
+            1,
+            address(this),
+            type(uint256).max
+        );
+
+        if (transferResidual) {
+            //Returning Residue in token0, if any.
+            if (token0Bought - amountA > 0) {
+                _transferOut(token0, msg.sender, token0Bought - amountA);
+            }
+
+            //Returning Residue in token1, if any
+            if (token1Bought - amountB > 0) {
+                _transferOut(token1, msg.sender, token1Bought - amountB);
+            }
+        }
+
+        return LP;
+    }
+
+    function _joeRemoveLiquidity(uint256 lpToRemove)
+        internal
+        returns (uint256 token0Received, uint256 token1Received)
+    {
+        (token0Received, token1Received) = IJoeRouter02(joeRouter).removeLiquidity(
+            token0,
+            token1,
+            lpToRemove,
+            1,
+            1,
+            address(this),
+            type(uint256).max
+        );
+    }
+
+    function calculateSwapInAmount(uint256 reserveIn, uint256 userIn)
+        internal
+        pure
+        returns (uint256)
+    {
+        return
+            (_babylonianSqrt(reserveIn * ((userIn * 3988000) + (reserveIn * 3988009))) -
+                (reserveIn * 1997)) / 1994;
+    }
+
+    function _babylonianSqrt(uint256 y) internal pure returns (uint256 z) {
+        if (y > 3) {
+            z = y;
+            uint256 x = y / 2 + 1;
+            while (x < z) {
+                z = x;
+                x = (y / x + x) / 2;
+            }
+        } else if (y != 0) {
+            z = 1;
+        }
+        // else z = 0
+    }
+
+    /**
+    @notice This function is used to swap ERC20 <> ERC20
+    @param fromToken The token address to swap from.
+    @param toToken The token address to swap to.
+    @param tokens2Trade The amount of tokens to swap
+    @return tokenBought The quantity of tokens bought
+    */
+    function _token2Token(
+        address fromToken,
+        address toToken,
+        uint256 tokens2Trade
+    ) internal returns (uint256 tokenBought) {
+        if (fromToken == toToken) {
+            return tokens2Trade;
+        }
+
+        require(joePair != address(0), "No Swap Available");
+        address[] memory path = new address[](2);
+        path[0] = fromToken;
+        path[1] = toToken;
+
+        tokenBought = IJoeRouter02(joeRouter).swapExactTokensForTokens(
+            tokens2Trade,
+            1,
+            path,
+            address(this),
+            type(uint256).max
+        )[path.length - 1];
+
+        require(tokenBought > 0, "Error Swapping Tokens 2");
+    }
+}

package/contracts/SuperComposableYield/SCY-implementations/PendleWstEthSCY.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+import "../base-implementations/SCYBase.sol";
+import "../../interfaces/IWstETH.sol";
+
+contract PendleWstEthSCY is SCYBase {
+    address public immutable stETH;
+    address public immutable wstETH;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _wstETH
+    ) SCYBase(_name, _symbol, _wstETH) {
+        wstETH = _wstETH;
+        stETH = IWstETH(wstETH).stETH();
+        _safeApprove(stETH, wstETH, type(uint256).max);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SCYBase-_deposit}
+     *
+     * The underlying yield token is wstETH. If the base token deposited is stETH, the function wraps
+     * it into wstETH first. Then the corresponding amount of shares is returned.
+     *
+     * The exchange rate of wstETH to shares is 1:1
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == wstETH) {
+            amountSharesOut = amountDeposited;
+        } else {
+            amountSharesOut = IWstETH(wstETH).wrap(amountDeposited); // .wrap returns amount of wstETH out
+        }
+    }
+
+    /**
+     * @dev See {SCYBase-_redeem}
+     *
+     * The shares are redeemed into the same amount of wstETH. If `tokenOut` is stETH, the function also
+     * unwraps said amount of wstETH into stETH for redemption.
+     */
+    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == wstETH) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            amountTokenOut = IWstETH(wstETH).unwrap(amountSharesToRedeem);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of wstETH to stETH
+     */
+    function exchangeRate() public view virtual override returns (uint256 currentRate) {
+        return IWstETH(wstETH).stEthPerToken();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {ISuperComposableYield-getBaseTokens}
+     */
+    function getBaseTokens() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = stETH;
+        res[1] = wstETH;
+    }
+
+    /**
+     * @dev See {ISuperComposableYield-isValidBaseToken}
+     */
+    function isValidBaseToken(address token) public view virtual override returns (bool) {
+        return token == stETH || token == wstETH;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, stETH, IERC20Metadata(stETH).decimals());
+    }
+}

package/contracts/SuperComposableYield/SCY-implementations/PendleYearnVaultScy.sol

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../base-implementations/SCYBase.sol";
+import "../../interfaces/IYearnVault.sol";
+
+contract PendleYearnVaultSCY is SCYBase {
+    address public immutable underlying;
+    address public immutable yvToken;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _yvToken
+    ) SCYBase(_name, _symbol, _yvToken) {
+        require(_yvToken != address(0), "zero address");
+        yvToken = _yvToken;
+        underlying = IYearnVault(yvToken).token();
+        _safeApprove(underlying, yvToken, type(uint256).max);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SCYBase-_deposit}
+     *
+     * The underlying yield token is yvToken. If the base token deposited is underlying asset, the function
+     * first mints yvToken using those deposited. Then the corresponding amount of shares is returned.
+     *
+     * The exchange rate of yvToken to shares is 1:1
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == yvToken) {
+            amountSharesOut = amountDeposited;
+        } else {
+            // tokenIn == underlying
+            uint256 preBalance = _selfBalance(yvToken);
+            IYearnVault(yvToken).deposit(amountDeposited);
+            amountSharesOut = _selfBalance(yvToken) - preBalance; // 1 yvToken = 1 SCY
+        }
+    }
+
+    /**
+     * @dev See {SCYBase-_redeem}
+     *
+     * The shares are redeemed into the same amount of yvTokens. If `tokenOut` is the underlying asset,
+     * the function also withdraws said asset for redemption, using the corresponding amount of yvToken.
+     */
+    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        virtual
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == yvToken) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            // tokenOut == underlying
+            uint256 sharesRedeemed = IYearnVault(yvToken).withdraw(amountSharesToRedeem);
+
+            require(
+                sharesRedeemed != amountSharesToRedeem,
+                "Yearn Vault SCY: Not allowed to redeem all shares"
+            );
+
+            amountTokenOut = _selfBalance(underlying);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the price per share of the yvToken
+     */
+    function exchangeRate() public view override returns (uint256) {
+        return IYearnVault(yvToken).pricePerShare();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {ISuperComposableYield-getBaseTokens}
+     */
+    function getBaseTokens() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = underlying;
+        res[1] = yvToken;
+    }
+
+    /**
+     * @dev See {ISuperComposableYield-isValidBaseToken}
+     */
+    function isValidBaseToken(address token) public view virtual override returns (bool) {
+        return token == underlying || token == yvToken;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
+    }
+}