@pendle/core-v2 2.21.1 → 2.22.1

package/contracts/core/StandardizedYield/implementations/BalancerStable/PendleAuraWstethAnkreth.sol

@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./base/PendleAuraBalancerStableLPSYV2.sol";
+import "./base/ComposableStable/ComposableStablePreview.sol";
+import "../../StEthHelper.sol";
+
+contract PendleAuraWstethAnkreth is PendleAuraBalancerStableLPSYV2, StEthHelper {
+    uint256 internal constant AURA_PID = 125;
+    address internal constant LP = 0xdfE6e7e18f6Cc65FA13C8D8966013d4FdA74b6ba;
+    address internal constant ANKRETH = 0xE95A203B1a91a908F9B9CE46459d101078c2c3cb;
+
+    bool internal constant NO_TOKENS_EXEMPT = true;
+    bool internal constant ALL_TOKENS_EXEMPT = false;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        ComposableStablePreview _composablePreviewHelper
+    )
+        PendleAuraBalancerStableLPSYV2(_name, _symbol, LP, AURA_PID, _composablePreviewHelper)
+    //solhint-disable-next-line
+    {
+
+    }
+
+    function _deposit(address tokenIn, uint256 amount)
+        internal
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == NATIVE || tokenIn == STETH) {
+            uint256 amountWstETH = _depositWstETH(tokenIn, amount);
+            amountSharesOut = super._deposit(WSTETH, amountWstETH);
+        } else {
+            amountSharesOut = super._deposit(tokenIn, amount);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 amountTokenOut) {
+        if (tokenOut == STETH) {
+            uint256 amountWstETH = super._redeem(address(this), WSTETH, amountSharesToRedeem);
+            amountTokenOut = _redeemWstETH(receiver, amountWstETH);
+        } else {
+            amountTokenOut = super._redeem(receiver, tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256)
+    {
+        if (tokenIn == NATIVE || tokenIn == STETH) {
+            uint256 amountWstETH = _previewDepositWstETH(tokenIn, amountTokenToDeposit);
+            return super._previewDeposit(WSTETH, amountWstETH);
+        } else {
+            return super._previewDeposit(tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256)
+    {
+        if (tokenOut == STETH) {
+            uint256 amountWstETH = super._previewRedeem(WSTETH, amountSharesToRedeem);
+            return _previewRedeemWstETH(amountWstETH);
+        } else {
+            return super._previewRedeem(tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _getImmutablePoolData() internal pure override returns (bytes memory ret) {
+        ComposableStablePreview.ImmutableData memory res;
+        res.poolTokens = _getPoolTokenAddresses();
+        res.rateProviders = _getRateProviders();
+        res.rawScalingFactors = _getRawScalingFactors();
+        res.isExemptFromYieldProtocolFee = _getExemption();
+        res.LP = LP;
+        res.noTokensExempt = NO_TOKENS_EXEMPT;
+        res.allTokensExempt = ALL_TOKENS_EXEMPT;
+        res.bptIndex = _getBPTIndex();
+        res.totalTokens = res.poolTokens.length;
+
+        return abi.encode(res);
+    }
+
+    //  --------------------------------- POOL CONSTANTS ---------------------------------
+    function _getPoolTokenAddresses() internal pure override returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = WSTETH;
+        res[1] = LP;
+        res[2] = ANKRETH;
+    }
+
+    function _getBPTIndex() internal pure override returns (uint256) {
+        return 1;
+    }
+
+    function _getRateProviders() internal pure returns (address[] memory res) {
+        res = new address[](3);
+        res[0] = 0x72D07D7DcA67b8A406aD1Ec34ce969c90bFEE768;
+        res[1] = 0x0000000000000000000000000000000000000000;
+        res[2] = 0x00F8e64a8651E3479A0B20F46b1D462Fe29D6aBc;
+    }
+
+    function _getRawScalingFactors() internal pure returns (uint256[] memory res) {
+        res = new uint256[](3);
+        res[0] = res[1] = res[2] = 1e18;
+    }
+
+    function _getExemption() internal pure returns (bool[] memory res) {
+        res = new bool[](3);
+        res[0] = res[1] = res[2] = false;
+    }
+
+    function getTokensIn() public pure override returns (address[] memory res) {
+        res = new address[](5);
+        res[0] = NATIVE;
+        res[1] = STETH;
+        res[2] = WSTETH;
+        res[3] = ANKRETH;
+        res[4] = LP;
+    }
+
+    function getTokensOut() public pure override returns (address[] memory res) {
+        res = new address[](4);
+        res[0] = STETH;
+        res[1] = WSTETH;
+        res[2] = ANKRETH;
+        res[3] = LP;
+    }
+
+    function isValidTokenIn(address token) public pure override returns (bool) {
+        return (token == NATIVE ||
+            token == STETH ||
+            token == WSTETH ||
+            token == ANKRETH ||
+            token == LP);
+    }
+
+    function isValidTokenOut(address token) public pure override returns (bool) {
+        return (token == STETH || token == WSTETH || token == ANKRETH || token == LP);
+    }
+}

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

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "../../SYBase.sol";
+import "../../../../interfaces/ISwETH.sol";
+
+contract SwETHSY 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;
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(swETH, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    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);
+        }
+    }
+}