@pendle/core-v2 2.21.0 → 2.22.0

package/contracts/core/StandardizedYield/implementations/Swell/PendleSwETH.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "../../SYBase.sol";
+import "../../../../interfaces/ISwETH.sol";
+
+contract PendleSwETH is SYBase {
+    using Math for uint256;
+
+    address public immutable swETH;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _swETH
+    ) SYBase(_name, _symbol, _swETH) {
+        swETH = _swETH;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            uint256 preBalance = _selfBalance(swETH);
+            ISwETH(swETH).deposit{ value: amountDeposited }();
+            return _selfBalance(swETH) - preBalance;
+        } else {
+            // sweth
+            return amountDeposited;
+        }
+    }
+
+    /**
+     * Withdrawal to sfrxETH and frxETH is done normally as other ERC4626.
+     * Withdrawal to ETH is on the other hand not possible
+     */
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(swETH, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of sfrxETH to frxETH
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return ISwETH(swETH).getRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == NATIVE) {
+            return amountTokenToDeposit.divDown(ISwETH(swETH).getRate());
+        } else {
+            return amountTokenToDeposit;
+        }
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = swETH;
+        res[1] = NATIVE;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = swETH;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == NATIVE || token == swETH;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == swETH;
+    }
+
+    function assetInfo()
+        external
+        pure
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, NATIVE, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Thena/PendleThenaSY.sol

@@ -0,0 +1,202 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "./ThenaLpHelper.sol";
+import "../../../../interfaces/IPendlePreviewHelper.sol";
+import "../../../../interfaces/Thena/IThenaGaugeV2.sol";
+import "../../../libraries/ArrayLib.sol";
+
+contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
+    event SetNewBinarySearchEps(uint256 newEps);
+    event AddExternalRewardToken(address indexed token);
+
+    using Math for uint256;
+    using ArrayLib for address[];
+
+    address[] public externalRewardTokens;
+    address public immutable gauge;
+    address public immutable THENA;
+    IPendlePreviewHelper public immutable previewHelper;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _pair,
+        address _factory,
+        address _router,
+        address _gauge,
+        address _THENA,
+        IPendlePreviewHelper _previewHelper
+    ) SYBaseWithRewards(_name, _symbol, _pair) ThenaLpHelper(_pair, _factory, _router) {
+        THENA = _THENA;
+        gauge = _gauge;
+        previewHelper = _previewHelper;
+        _safeApproveInf(_pair, _gauge);
+    }
+
+    /**
+     * @dev See {SYBase-_deposit}
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountLpDeposited)
+    {
+        _withdrawAllFromGauge();
+        if (tokenIn == pair) {
+            amountLpDeposited = amountDeposited;
+        } else {
+            amountLpDeposited = _zapIn(tokenIn, amountDeposited);
+        }
+        _depositToGaugeIfNotEmergency();
+    }
+
+    /**
+     * @dev See {SYBase-_redeem}
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        _withdrawAllFromGauge();
+        if (tokenOut == pair) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            amountTokenOut = _zapOut(tokenOut, amountSharesToRedeem);
+        }
+        _transferOut(tokenOut, receiver, amountTokenOut);
+        _depositToGaugeIfNotEmergency();
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return Math.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view virtual override returns (address[] memory res) {
+        res = new address[](1 + externalRewardTokens.length);
+        res[0] = THENA;
+        for(uint256 i = 1; i < res.length; ++i) {
+            res[i] = externalRewardTokens[i - 1];
+        }
+    }
+
+    function _redeemExternalReward() internal override {
+        IThenaGaugeV2(gauge).getReward();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    PREVIEW-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256)
+    {
+        if (tokenIn == pair) {
+            return amountTokenToDeposit;
+        } else {
+            return previewHelper.previewDeposit(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256)
+    {
+        if (tokenOut == pair) {
+            return amountSharesToRedeem;
+        } else {
+            return previewHelper.previewRedeem(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = token0;
+        res[1] = token1;
+        res[2] = pair;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = token0;
+        res[1] = token1;
+        res[2] = pair;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == token0 || token == token1 || token == pair;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == token0 || token == token1 || token == pair;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.LIQUIDITY, pair, IERC20Metadata(pair).decimals());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        REWARD RELATED FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function _withdrawAllFromGauge() internal {
+        if (IThenaGaugeV2(gauge).balanceOf(address(this)) == 0) {
+            return;
+        }
+
+        if (IThenaGaugeV2(gauge).emergency()) {
+            IThenaGaugeV2(gauge).emergencyWithdraw();
+        } else {
+            IThenaGaugeV2(gauge).withdrawAll();
+        }
+    }
+
+    function _depositToGaugeIfNotEmergency() internal {
+        if (!IThenaGaugeV2(gauge).emergency()) {
+            IThenaGaugeV2(gauge).depositAll();
+        }
+    }
+
+    function setBinarySearchEps(uint256 newEps) external onlyOwner {
+        require(newEps > 0 && newEps < 1e18, "invalid newEps");
+        binarySearchEps = newEps;
+
+        emit SetNewBinarySearchEps(newEps);
+    }
+
+    function addExternalRewardToken(address token) external onlyOwner {
+        // prevent adding THE as well
+        require(!_getRewardTokens().contains(token), "rewardToken existed");
+        externalRewardTokens.push(token);
+
+        emit AddExternalRewardToken(token);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Thena/ThenaLpHelper.sol

@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity >=0.8.0;
+
+import "../../../../interfaces/Thena/IThenaPair.sol";
+import "../../../../interfaces/Thena/IThenaRouter.sol";
+import "../../../../interfaces/Thena/IThenaFactory.sol";
+import "../../../libraries/TokenHelper.sol";
+import "../../../libraries/math/Math.sol";
+import "./ThenaMath.sol";
+
+abstract contract ThenaLpHelper is TokenHelper, ThenaMath {
+    address public immutable factory;
+    address public immutable pair;
+
+    bool public immutable isStable;
+    address public immutable token0;
+    address public immutable token1;
+    uint256 public immutable decimals0;
+    uint256 public immutable decimals1;
+    address public immutable router;
+
+    constructor(address _pair, address _factory, address _router) {
+        factory = _factory;
+        pair = _pair;
+        router = _router;
+
+        isStable = IThenaPair(pair).isStable();
+        token0 = IThenaPair(pair).token0();
+        token1 = IThenaPair(pair).token1();
+        decimals0 = 10 ** IERC20Metadata(token0).decimals();
+        decimals1 = 10 ** IERC20Metadata(token1).decimals();
+
+        _safeApproveInf(token0, router);
+        _safeApproveInf(token1, router);
+        _safeApproveInf(pair, router);
+    }
+
+    /**
+     * ==================================================================
+     *                      ZAP ACTION RELATED
+     * ==================================================================
+     */
+    function _zapIn(address tokenIn, uint256 amountIn) internal returns (uint256) {
+        (uint256 amount0ToAddLiq, uint256 amount1ToAddLiq) = _swapZapIn(tokenIn, amountIn);
+        return _addLiquidity(amount0ToAddLiq, amount1ToAddLiq);
+    }
+
+    function _zapOut(address tokenOut, uint256 amountLpIn) internal returns (uint256) {
+        (uint256 amount0, uint256 amount1) = _removeLiquidity(amountLpIn);
+        if (tokenOut == token0) {
+            return amount0 + _swap(token1, amount1);
+        } else {
+            return amount1 + _swap(token0, amount0);
+        }
+    }
+
+    function _swapZapIn(
+        address tokenIn,
+        uint256 amountIn
+    ) private returns (uint256 amount0ToAddLiq, uint256 amount1ToAddLiq) {
+        ThenaData memory data = _getNormalizedThenaData(tokenIn);
+        if (tokenIn == token0) {
+            uint256 amount0ToSwap = _getZapInSwapAmount(data, tokenIn, amountIn);
+            amount0ToAddLiq = amountIn - amount0ToSwap;
+            amount1ToAddLiq = _swap(token0, amount0ToSwap);
+        } else {
+            uint256 amount1ToSwap = _getZapInSwapAmount(data, tokenIn, amountIn);
+            amount0ToAddLiq = _swap(token1, amount1ToSwap);
+            amount1ToAddLiq = amountIn - amount1ToSwap;
+        }
+    }
+
+    /**
+     * ==================================================================
+     *                      CAMELOT ROUTER RELATED
+     * ==================================================================
+     */
+
+    function _addLiquidity(
+        uint256 amount0ToAddLiq,
+        uint256 amount1ToAddLiq
+    ) private returns (uint256 amountLpOut) {
+        (, , amountLpOut) = IThenaRouter(router).addLiquidity(
+            token0,
+            token1,
+            isStable,
+            amount0ToAddLiq,
+            amount1ToAddLiq,
+            0,
+            0,
+            address(this),
+            block.timestamp
+        );
+    }
+
+    function _removeLiquidity(
+        uint256 amountLpToRemove
+    ) private returns (uint256 amountTokenA, uint256 amountTokenB) {
+        return
+            IThenaRouter(router).removeLiquidity(
+                token0,
+                token1,
+                isStable,
+                amountLpToRemove,
+                0,
+                0,
+                address(this),
+                block.timestamp
+            );
+    }
+
+    function _swap(address tokenIn, uint256 amountTokenIn) private returns (uint256) {
+        address tokenOut = tokenIn == token0 ? token1 : token0;
+        uint256 preBalance = _selfBalance(tokenOut);
+
+        IThenaRouter(router).swapExactTokensForTokensSimple(
+            amountTokenIn,
+            0,
+            tokenIn,
+            tokenOut,
+            isStable,
+            address(this),
+            block.timestamp
+        );
+
+        return _selfBalance(tokenOut) - preBalance;
+    }
+
+    /**
+     * ==================================================================
+     *                      CAMELOT PAIR DATA READ
+     * ==================================================================
+     */
+
+    function _getNormalizedThenaData(
+        address tokenIn
+    ) internal view returns (ThenaData memory data) {
+        data.pair = pair;
+        data.isStable = isStable;
+        data.fee = IThenaFactory(factory).getFee(data.isStable);
+        (data.reserve0, data.reserve1, ) = IThenaPair(pair).getReserves();
+
+        if (data.isStable) {
+            // if not stable, skip reading these data
+            data.decimals0 = decimals0;
+            data.decimals1 = decimals1;
+        }
+
+        // Normalize token order
+        if (tokenIn == token1) {
+            (data.reserve0, data.reserve1) = (data.reserve1, data.reserve0);
+            (data.decimals0, data.decimals1) = (data.decimals1, data.decimals0);
+        }
+    }
+}

package/contracts/core/StandardizedYield/implementations/Thena/ThenaMath.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+import "../../../libraries/math/Math.sol";
+import "../../../../interfaces/Thena/IThenaPair.sol";
+
+abstract contract ThenaMath {
+    using Math for uint256;
+
+    struct ThenaData {
+        address pair;
+        bool isStable;
+        uint256 reserve0;
+        uint256 reserve1;
+        uint256 fee;
+        uint256 decimals0;
+        uint256 decimals1;
+    }
+
+    struct StableBinarySearchParams {
+        uint256 guessMin;
+        uint256 guessMax;
+        uint256 amountSwapIn;
+        uint256 newReserve0;
+        uint256 newReserve1;
+        uint256 amount0ToAddLiq;
+        uint256 amount1ToAddLiq;
+    }
+
+    uint256 internal constant FEE_DENOMINATOR = 10000;
+    uint256 internal constant ONE = 1 * FEE_DENOMINATOR;
+    uint256 internal constant TWO = 2 * FEE_DENOMINATOR;
+    uint256 internal constant FOUR = 4 * FEE_DENOMINATOR;
+    uint256 internal constant DEFAULT_BINARY_SEARCH_EPS = 1e14; // 0.01% accuracy
+
+    uint256 public binarySearchEps = DEFAULT_BINARY_SEARCH_EPS;
+
+    function _getZapInSwapAmount(
+        ThenaData memory data,
+        address tokenIn,
+        uint256 amountIn
+    ) internal view returns (uint256) {
+        return
+            data.isStable
+                ? _getStableZapAmount(data, tokenIn, amountIn)
+                : _getVolatileZapAmount(data, amountIn);
+    }
+
+    function _getVolatileZapAmount(
+        ThenaData memory data,
+        uint256 amountIn
+    ) private pure returns (uint256) {
+
+        uint256 numer0 = (TWO - FEE_DENOMINATOR) * data.reserve0 / FEE_DENOMINATOR;
+        uint256 numer1 = Math.square(numer0);
+        uint256 numer2 = 4 * Math.square(ONE - data.fee) * amountIn * data.reserve0;
+
+        uint256 numer = Math.sqrt(numer1 + numer2) - numer0;
+        uint256 denom = 2 * Math.square(ONE - data.fee);
+
+        return numer * FEE_DENOMINATOR / denom;
+    }
+
+    function _getStableZapAmount(
+        ThenaData memory data,
+        address tokenIn,
+        uint256 amountIn
+    ) private view returns (uint256) {
+        StableBinarySearchParams memory params = _prepareStableBinarySearchParams(amountIn, data);
+
+        while (!Math.isAApproxB(params.guessMin, params.guessMax, binarySearchEps)) {
+            params.amountSwapIn = (params.guessMax + params.guessMin) / 2;
+            params.amount1ToAddLiq = IThenaPair(data.pair).getAmountOut(
+                params.amountSwapIn,
+                tokenIn
+            );
+
+            params.newReserve0 = _getReserveAfterSwap(
+                params.amountSwapIn,
+                data.reserve0,
+                data.fee
+            );
+            params.newReserve1 = data.reserve1 - params.amount1ToAddLiq;
+            params.amount0ToAddLiq = amountIn - params.amountSwapIn;
+
+            if (
+                params.amount0ToAddLiq * params.newReserve1 <
+                params.amount1ToAddLiq * params.newReserve0
+            ) {
+                params.guessMax = params.amountSwapIn - 1; // need swap less
+            } else {
+                params.guessMin = params.amountSwapIn + 1; // swap more
+            }
+        }
+        return params.guessMin;
+    }
+
+    function _prepareStableBinarySearchParams(
+        uint256 amountIn,
+        ThenaData memory data
+    ) private pure returns (StableBinarySearchParams memory params) {
+        uint256 X = data.reserve0.divDown(data.decimals0);
+        uint256 Y = data.reserve1.divDown(data.decimals1);
+        amountIn = amountIn.divDown(data.decimals0);
+
+        uint256 t = Y.divDown(X + amountIn);
+        uint256 K = X.mulDown(Y).mulDown(X.mulDown(X) + Y.mulDown(Y));
+        uint256 denom = t.mulDown(t).mulDown(t) + t;
+
+        params.guessMin = (_fourthRoot(K.divDown(denom)) - X).mulDown(data.decimals0);
+        params.guessMax = (params.guessMin * FEE_DENOMINATOR) / (FEE_DENOMINATOR - data.fee);
+    }
+
+    function _getReserveAfterSwap(
+        uint256 amountIn,
+        uint256 reserve,
+        uint256 fee
+    ) internal pure returns (uint256) {
+        return reserve + amountIn - (amountIn * fee) / FEE_DENOMINATOR;
+    }
+
+    // this returns the fourthRoot of y in base 18
+    function _fourthRoot(uint256 y) private pure returns (uint256) {
+        uint256 root = Math.sqrt(y) * (10 ** 9);
+        return Math.sqrt(root) * (10 ** 9);
+    }
+}