@pendle/core-v2 2.11.0-mainnet → 2.13.0-mainnet

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/CamelotV1VolatileCommon.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+import "../../../../interfaces/Camelot/ICamelotPair.sol";
+import "../../../../interfaces/Camelot/ICamelotRouter.sol";
+import "../../../../interfaces/Camelot/ICamelotFactory.sol";
+import "../../../libraries/TokenHelper.sol";
+import "../../../libraries/math/Math.sol";
+
+contract CamelotV1VolatileCommon {
+    struct CamelotPairData {
+        address token0;
+        address token1;
+        address pair;
+        uint256 reserve0;
+        uint256 reserve1;
+        uint256 fee0;
+        uint256 fee1;
+    }
+
+    uint256 internal constant FEE_DENOMINATOR = 100000;
+    uint256 internal constant ONE = 1 * FEE_DENOMINATOR;
+    uint256 internal constant TWO = 2 * FEE_DENOMINATOR;
+    uint256 internal constant FOUR = 4 * FEE_DENOMINATOR;
+
+    // reference: https://blog.alphaventuredao.io/onesideduniswap/
+    function _getZapInSwapAmount(
+        uint256 amountIn,
+        uint256 reserve,
+        uint256 fee
+    ) internal pure returns (uint256) {
+        return
+            (Math.sqrt(Math.square((TWO - fee) * reserve) + FOUR * (ONE - fee) * amountIn * reserve) -
+                (TWO - fee) *
+                reserve) / (2 * (ONE - fee));
+    }
+}

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/CamelotV1VolatileLpHelper.sol

@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity >=0.8.0;
+
+import "../../../../interfaces/Camelot/ICamelotPair.sol";
+import "../../../../interfaces/Camelot/ICamelotRouter.sol";
+import "../../../../interfaces/Camelot/ICamelotFactory.sol";
+import "../../../libraries/TokenHelper.sol";
+import "../../../libraries/math/Math.sol";
+import "./CamelotV1VolatileCommon.sol";
+
+/**
+ * @notice This contract is intended to be launched on Arbitrum
+ *         Thus, some obvious gas optimization might be ignored
+ *
+ * @notice Since Camelot LP may offer the pool token as a reward token (for example PENDLE/ETH
+ * has PENDLE rewards),
+ * this contract should not take into account any floating balance
+ * for swap/add liquidity
+ */
+abstract contract CamelotV1VolatileLpHelper is TokenHelper, CamelotV1VolatileCommon {
+    address public immutable token0;
+    address public immutable token1;
+    address public immutable pair;
+    address public immutable factory;
+    address public immutable router;
+
+    address public referrerForSwap;
+
+    constructor(
+        address _pair,
+        address _factory,
+        address _router,
+        address _referrerForSwap
+    ) {
+        assert(ICamelotPair(_pair).stableSwap() == false);
+
+        pair = _pair;
+        factory = _factory;
+        router = _router;
+        token0 = ICamelotPair(pair).token0();
+        token1 = ICamelotPair(pair).token1();
+        referrerForSwap = _referrerForSwap;
+
+        _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)
+    {
+        (uint256 reserve0, uint256 reserve1, uint256 fee0, uint256 fee1) = ICamelotPair(pair)
+            .getReserves();
+
+        if (tokenIn == token0) {
+            uint256 amount0ToSwap = _getZapInSwapAmount(amountIn, reserve0, fee0);
+            amount0ToAddLiq = amountIn - amount0ToSwap;
+            amount1ToAddLiq = _swap(token0, amount0ToSwap);
+        } else {
+            uint256 amount1ToSwap = _getZapInSwapAmount(amountIn, reserve1, fee1);
+            amount0ToAddLiq = _swap(token1, amount1ToSwap);
+            amount1ToAddLiq = amountIn - amount1ToSwap;
+        }
+    }
+
+    /**
+     * ==================================================================
+     *                      CAMELOT ROUTER RELATED
+     * ==================================================================
+     */
+
+    function _addLiquidity(uint256 amount0ToAddLiq, uint256 amount1ToAddLiq)
+        private
+        returns (uint256 amountLpOut)
+    {
+        (, , amountLpOut) = ICamelotRouter(router).addLiquidity(
+            token0,
+            token1,
+            amount0ToAddLiq,
+            amount1ToAddLiq,
+            0,
+            0,
+            address(this),
+            block.timestamp
+        );
+    }
+
+    function _removeLiquidity(uint256 amountLpToRemove)
+        private
+        returns (uint256 amountTokenA, uint256 amountTokenB)
+    {
+        return
+            ICamelotRouter(router).removeLiquidity(
+                token0,
+                token1,
+                amountLpToRemove,
+                0,
+                0,
+                address(this),
+                block.timestamp
+            );
+    }
+
+    function _swap(address tokenIn, uint256 amountTokenIn) private returns (uint256) {
+        address[] memory path = new address[](2);
+
+        address tokenOut = tokenIn == token0 ? token1 : token0;
+
+        path[0] = tokenIn;
+        path[1] = tokenOut;
+
+        uint256 preBalance = _selfBalance(tokenOut);
+
+        ICamelotRouter(router).swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            amountTokenIn,
+            0,
+            path,
+            address(this),
+            referrerForSwap,
+            block.timestamp
+        );
+
+        return _selfBalance(tokenOut) - preBalance;
+    }
+}

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/CamelotV1VolatilePreview.sol

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+import "./CamelotV1VolatileCommon.sol";
+
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+
+contract CamelotV1VolatilePreview is
+    CamelotV1VolatileCommon,
+    BoringOwnableUpgradeable,
+    UUPSUpgradeable
+{
+    address internal immutable factory;
+
+    constructor(address _factory) initializer {
+        factory = _factory;
+    }
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    // solhint-disable-next-line
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+    /**
+     * @notice The Camelot.swap() function takes reserve() as the previously recorded at the start
+     * and take into account ALL floating balances after.
+     */
+    function previewZapIn(
+        CamelotPairData memory data,
+        address tokenIn,
+        uint256 amountTokenIn
+    ) external view returns (uint256 amountLpOut) {
+        bool isToken0 = tokenIn == data.token0;
+
+        uint256 amountToSwap = isToken0
+            ? _getZapInSwapAmount(amountTokenIn, data.reserve0, data.fee0)
+            : _getZapInSwapAmount(amountTokenIn, data.reserve1, data.fee1);
+
+        uint256 amountSwapOut = _getSwapAmountOut(
+            data,
+            amountToSwap,
+            tokenIn,
+            tokenIn == data.token0 ? data.fee0 : data.fee1
+        );
+
+        uint256 amount0ToAddLiq;
+        uint256 amount1ToAddLiq;
+
+        if (isToken0) {
+            data.reserve0 = _getPairBalance0(data) + amountToSwap;
+            data.reserve1 = _getPairBalance1(data) - amountSwapOut;
+
+            amount0ToAddLiq = amountTokenIn - amountToSwap;
+            amount1ToAddLiq = amountSwapOut;
+        } else {
+            data.reserve0 = _getPairBalance0(data) - amountSwapOut;
+            data.reserve1 = _getPairBalance1(data) + amountToSwap;
+
+            amount0ToAddLiq = amountSwapOut;
+            amount1ToAddLiq = amountTokenIn - amountToSwap;
+        }
+
+        return _calcAmountLpOut(data, amount0ToAddLiq, amount1ToAddLiq);
+    }
+
+    function previewZapOut(
+        CamelotPairData memory data,
+        address tokenOut,
+        uint256 amountLpIn
+    ) external view returns (uint256) {
+        uint256 totalSupply = _getTotalSupplyAfterMintFee(data);
+
+        data.reserve0 = _getPairBalance0(data);
+        data.reserve1 = _getPairBalance1(data);
+
+        uint256 amount0Removed = (data.reserve0 * amountLpIn) / totalSupply;
+        uint256 amount1Removed = (data.reserve1 * amountLpIn) / totalSupply;
+
+        data.reserve0 -= amount0Removed;
+        data.reserve1 -= amount1Removed;
+
+        if (tokenOut == data.token0) {
+            return
+                amount0Removed + _getSwapAmountOut(data, amount1Removed, data.token1, data.fee1);
+        } else {
+            return
+                amount1Removed + _getSwapAmountOut(data, amount0Removed, data.token0, data.fee0);
+        }
+    }
+
+    function _getPairBalance0(CamelotPairData memory data) private view returns (uint256) {
+        return IERC20(data.token0).balanceOf(data.pair);
+    }
+
+    function _getPairBalance1(CamelotPairData memory data) private view returns (uint256) {
+        return IERC20(data.token1).balanceOf(data.pair);
+    }
+
+    // @reference: Camelot
+    function _getSwapAmountOut(
+        CamelotPairData memory data,
+        uint256 amountIn,
+        address tokenIn,
+        uint256 feePercent
+    ) internal pure returns (uint256) {
+        (uint256 reserve0, uint256 reserve1) = tokenIn == data.token0
+            ? (data.reserve0, data.reserve1)
+            : (data.reserve1, data.reserve0);
+        amountIn = amountIn * (FEE_DENOMINATOR - feePercent);
+        return (amountIn * reserve1) / (reserve0 * FEE_DENOMINATOR + amountIn);
+    }
+
+    /**
+     * @notice This function simulates Camelot router so any precision issues from their calculation
+     * is preserved in preview functions...
+     */
+    function _calcAmountLpOut(
+        CamelotPairData memory data,
+        uint256 amount0ToAddLiq,
+        uint256 amount1ToAddLiq
+    ) private view returns (uint256 amountLpOut) {
+        uint256 amount1Optimal = _quote(amount0ToAddLiq, data.reserve0, data.reserve1);
+        if (amount1Optimal <= amount1ToAddLiq) {
+            amount1ToAddLiq = amount1Optimal;
+        } else {
+            amount0ToAddLiq = _quote(amount1ToAddLiq, data.reserve1, data.reserve0);
+        }
+
+        uint256 supply = _getTotalSupplyAfterMintFee(data);
+        return
+            Math.min(
+                (amount0ToAddLiq * supply) / data.reserve0,
+                (amount1ToAddLiq * supply) / data.reserve1
+            );
+    }
+
+    function _quote(
+        uint256 amountA,
+        uint256 reserveA,
+        uint256 reserveB
+    ) private pure returns (uint256 amountB) {
+        amountB = (amountA * reserveB) / reserveA;
+    }
+
+    function _getTotalSupplyAfterMintFee(CamelotPairData memory data)
+        private
+        view
+        returns (uint256)
+    {
+        (uint256 ownerFeeShare, address feeTo) = ICamelotFactory(factory).feeInfo();
+        bool feeOn = feeTo != address(0);
+        uint256 _kLast = ICamelotPair(data.pair).kLast();
+
+        uint256 totalSupply = ICamelotPair(data.pair).totalSupply();
+        // gas savings
+        if (feeOn) {
+            if (_kLast != 0) {
+                uint256 rootK = Math.sqrt(data.reserve0 * data.reserve1);
+                uint256 rootKLast = Math.sqrt(_kLast);
+                if (rootK > rootKLast) {
+                    uint256 d = (FEE_DENOMINATOR * 100) / ownerFeeShare - 100;
+                    uint256 numerator = totalSupply * (rootK - rootKLast) * 100;
+                    uint256 denominator = rootK * d + rootKLast * 100;
+                    uint256 liquidity = numerator / denominator;
+                    if (liquidity > 0) {
+                        totalSupply += liquidity;
+                    }
+                }
+            }
+        }
+        return totalSupply;
+    }
+}

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/PendleCamelotV1VolatileSY.sol

@@ -0,0 +1,251 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.17;
+
+import "./CamelotRewardHelper.sol";
+import "../../SYBaseWithRewards.sol";
+import "./CamelotV1VolatilePreview.sol";
+import "./CamelotV1VolatileLpHelper.sol";
+
+contract PendleCamelotV1VolatileSY is
+    SYBaseWithRewards,
+    CamelotRewardHelper,
+    CamelotV1VolatileLpHelper
+{
+    using Math for uint256;
+    using ArrayLib for address[];
+
+    address[] public rewardTokens;
+    CamelotV1VolatilePreview public immutable previewHelper;
+    bool public isRewardDisabled;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _pair,
+        address _factory,
+        address _router,
+        address _nitroPool,
+        address _referrer,
+        CamelotV1VolatilePreview _previewHelper
+    )
+        CamelotV1VolatileLpHelper(_pair, _factory, _router, _referrer)
+        SYBaseWithRewards(_name, _symbol, _pair)
+        CamelotRewardHelper(_nitroPool, _pair)
+    {
+        rewardTokens.push(GRAIL);
+        updateRewardTokensList();
+        previewHelper = _previewHelper;
+    }
+
+    /**
+     * @dev See {SYBase-_deposit}
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256)
+    {
+        uint256 amountLpDeposited;
+        if (tokenIn == pair) {
+            amountLpDeposited = amountDeposited;
+        } else {
+            amountLpDeposited = _zapIn(tokenIn, amountDeposited);
+        }
+
+        if (isRewardDisabled) {
+            return amountLpDeposited;
+        } else {
+            return _increaseNftPoolPosition(amountLpDeposited);
+        }
+    }
+
+    /**
+     * @dev See {SYBase-_redeem}
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        // solhint-disable-next-line
+        if (isRewardDisabled) {
+            // if isRewardDisabled is activated, the LP has been withdrawn from the pool
+        } else {
+            _decreaseNftPoolPosition(amountSharesToRedeem);
+        }
+
+        if (tokenOut == pair) {
+            amountTokenOut = amountSharesToRedeem;
+        } else {
+            amountTokenOut = _zapOut(tokenOut, amountSharesToRedeem);
+        }
+        _transferOut(tokenOut, receiver, amountTokenOut);
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        (uint256 reserve0, uint256 reserve1, , ) = ICamelotPair(pair).getReserves();
+        uint256 supply = ICamelotPair(pair).totalSupply();
+        return Math.sqrt(reserve0 * reserve1).divDown(supply);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view virtual override returns (address[] memory res) {
+        uint256 extraRewardsLen = rewardTokens.length;
+        res = new address[](1 + extraRewardsLen);
+        res[0] = GRAIL;
+        for (uint256 i = 0; i < extraRewardsLen; i++) {
+            res[1 + i] = rewardTokens[i];
+        }
+    }
+
+    /// @notice allows anyone to add new rewardTokens to this SY if a new rewardToken is added to the Nitro pool
+    function updateRewardTokensList() public virtual {
+        address token1 = ICamelotNitroPool(nitroPool).rewardsToken1().token;
+        address token2 = ICamelotNitroPool(nitroPool).rewardsToken2().token;
+
+
+        if (token1 != address(0) && !rewardTokens.contains(token1)) rewardTokens.push(token1);
+        if (token2 != address(0) && !rewardTokens.contains(token2)) rewardTokens.push(token2);
+    }
+
+    function _redeemExternalReward() internal override {
+        if (isRewardDisabled) {
+            return;
+        }
+
+        ICamelotNitroPool(nitroPool).harvest();
+        ICamelotNFTPool(nftPool).harvestPosition(positionId);
+        _allocateXGrail();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    PREVIEW-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256)
+    {
+        if (tokenIn == pair) {
+            return amountTokenToDeposit;
+        } else {
+            return previewHelper.previewZapIn(_getPairData(), tokenIn, amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256)
+    {
+        if (tokenOut == pair) {
+            return amountSharesToRedeem;
+        } else {
+            return previewHelper.previewZapOut(_getPairData(), tokenOut, amountSharesToRedeem);
+        }
+    }
+
+    function _getPairData() internal view returns (CamelotPairData memory data) {
+        data.token0 = token0;
+        data.token1 = token1;
+        data.pair = pair;
+        (data.reserve0, data.reserve1, data.fee0, data.fee1) = ICamelotPair(pair).getReserves();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                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());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        OWNER ONLY FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function prepareForReallocation() external onlyOwner {
+        _prepareForReallocation();
+    }
+
+    function finalizeReallocation() external onlyOwner {
+        _finalizeReallocation();
+    }
+
+    /// @dev Use emergencyWithdraw to ensure LP withdrawal is always successful
+    function setRewardDisabled(bool doRewardIndexUpdate) external onlyOwner {
+        if (doRewardIndexUpdate) _updateRewardIndex();
+
+        if (positionId != POSITION_UNINITIALIZED) {
+            ICamelotNitroPool(nitroPool).emergencyWithdraw(positionId);
+            ICamelotNFTPool(nftPool).emergencyWithdraw(positionId);
+            positionId = POSITION_UNINITIALIZED;
+        }
+
+        isRewardDisabled = true;
+    }
+
+    function setReferrerForSwap(address newReferrer) external onlyOwner {
+        referrerForSwap = newReferrer;
+    }
+
+    // XGRAIL related, to be used only when this SY is deprecated
+
+    function redeemXGrailOwner(uint256 xGrailAmount, uint256 duration) external onlyOwner {
+        IXGrail(xGRAIL).redeem(xGrailAmount, duration);
+    }
+
+    function finalizeRedeem(uint256 redeemIndex) external onlyOwner {
+        uint256 preBalance = _selfBalance(GRAIL);
+
+        IXGrail(xGRAIL).finalizeRedeem(redeemIndex);
+
+        uint256 amount = _selfBalance(GRAIL) - preBalance;
+        _transferOut(GRAIL, msg.sender, amount);
+    }
+
+    function cancelRedeem(uint256 redeemIndex) external onlyOwner {
+        IXGrail(xGRAIL).cancelRedeem(redeemIndex);
+    }
+}

package/contracts/core/libraries/math/Math.sol

@@ -77,6 +77,10 @@ library Math {
         }
     }
 
+    function square(uint256 x) internal pure returns (uint256) {
+        return x * x;
+    }
+
     function abs(int256 x) internal pure returns (uint256) {
         return uint256(x > 0 ? x : -x);
     }
@@ -152,15 +156,27 @@ library Math {
         return uint128(x);
     }
 
-    function isAApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
+    function isAApproxB(
+        uint256 a,
+        uint256 b,
+        uint256 eps
+    ) internal pure returns (bool) {
         return mulDown(b, ONE - eps) <= a && a <= mulDown(b, ONE + eps);
     }
 
-    function isAGreaterApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
+    function isAGreaterApproxB(
+        uint256 a,
+        uint256 b,
+        uint256 eps
+    ) internal pure returns (bool) {
         return a >= b && a <= mulDown(b, ONE + eps);
     }
 
-    function isASmallerApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
+    function isASmallerApproxB(
+        uint256 a,
+        uint256 b,
+        uint256 eps
+    ) internal pure returns (bool) {
         return a <= b && a >= mulDown(b, ONE - eps);
     }
 }

package/contracts/interfaces/Camelot/ICamelotFactory.sol

@@ -0,0 +1,22 @@
+pragma solidity >=0.8.0;
+
+interface ICamelotFactory {
+    event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
+
+    function owner() external view returns (address);
+    function feePercentOwner() external view returns (address);
+    function setStableOwner() external view returns (address);
+    function feeTo() external view returns (address);
+
+    function ownerFeeShare() external view returns (uint256);
+    function referrersFeeShare(address) external view returns (uint256);
+
+    function getPair(address tokenA, address tokenB) external view returns (address pair);
+    function allPairs(uint256) external view returns (address pair);
+    function allPairsLength() external view returns (uint256);
+
+    function createPair(address tokenA, address tokenB) external returns (address pair);
+
+    function setFeeTo(address) external;
+    function feeInfo() external view returns (uint _ownerFeeShare, address _feeTo);
+}

package/contracts/interfaces/Camelot/ICamelotNFTFactory.sol

@@ -0,0 +1,11 @@
+
+pragma solidity >=0.8.0;
+
+interface ICamelotNFTFactory {
+    function getPool(address lp) external view returns (address nftPool);
+
+    function grailToken() external view returns (address);
+
+    function xGrailToken() external view returns (address);
+
+}