@pendle/core-v2 5.2.4 → 5.3.0

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

@@ -1,179 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-pragma solidity ^0.8.0;
-
-import "../../../libraries/TokenHelper.sol";
-import "../../../../interfaces/Camelot/ICamelotNFTFactory.sol";
-import "../../../../interfaces/Camelot/ICamelotNitroPoolFactory.sol";
-import "../../../../interfaces/Camelot/ICamelotNFTPool.sol";
-import "../../../../interfaces/Camelot/ICamelotNitroPool.sol";
-import "../../../../interfaces/Camelot/ICamelotNFTHandler.sol";
-import "../../../../interfaces/Camelot/ICamelotYieldBooster.sol";
-import "../../../../interfaces/Camelot/IXGrail.sol";
-import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
-
-/**
- * @dev This contract should leave at least MINIMUM_LIQUIDITY in NftPool position
- * to protect the position from being destroyed
- *
- * The reason for this is that once the position is destroyed, the de-allocation of xGrail
- * will be forced to occur and take away fees from our xGRAIL boosting
- */
-contract CamelotRewardHelper is TokenHelper, ICamelotNFTHandler {
-    ICamelotNitroPoolFactory internal constant NITRO_POOL_FACTORY =
-        ICamelotNitroPoolFactory(0xe0a6b372Ac6AF4B37c7F3a989Fe5d5b194c24569);
-    uint256 internal constant POSITION_UNINITIALIZED = type(uint256).max;
-    uint256 internal constant MINIMUM_LIQUIDITY = 10 ** 3;
-    bytes4 internal constant _ERC721_RECEIVED = 0x150b7a02;
-
-    address public nitroPool;
-    address public immutable nftPool;
-    address public immutable GRAIL;
-    address public immutable xGRAIL;
-    uint256 public positionId = POSITION_UNINITIALIZED;
-
-    address public yieldBooster;
-
-    error InvalidTokenId(uint256 tokenId, uint256 positionId);
-
-    modifier ensureValidTokenId(uint256 tokenId) {
-        // Not allow receiving NFT from unwanted sources
-        if (tokenId != positionId) {
-            revert InvalidTokenId(tokenId, positionId);
-        }
-        _;
-    }
-
-    constructor(address _nftPool, uint256 _nitroPoolIndex) {
-        nftPool = _nftPool;
-        if (_nitroPoolIndex != type(uint256).max) {
-            nitroPool = NITRO_POOL_FACTORY.getNitroPool(_nitroPoolIndex);
-            require(ICamelotNitroPool(nitroPool).nftPool() == nftPool);
-        }
-
-        address lp;
-        (lp, GRAIL, xGRAIL, , , , , ) = ICamelotNFTPool(nftPool).getPoolInfo();
-        yieldBooster = ICamelotNFTPool(nftPool).yieldBooster();
-
-        _safeApproveInf(lp, nftPool);
-        IXGrail(xGRAIL).approveUsage(yieldBooster, type(uint256).max);
-    }
-
-    /**
-     * @dev Though xGRAIL can be vested into GRAIL through vesting, it's not possible
-     * to distribute this reward fairly on-chain.
-     *
-     * We decided to go with the second option (keep allocating xGRAIL to boost APR)
-     */
-    function _allocateXGrail() internal {
-        if (_ensureYieldBoosterMatched()) return;
-
-        uint256 amount = _selfBalance(xGRAIL);
-        if (amount == 0) return;
-
-        // there should be no reward without minimum liquidity minted
-        assert(positionId != POSITION_UNINITIALIZED);
-
-        IXGrail(xGRAIL).allocate(yieldBooster, amount, _getAllocationData());
-    }
-
-    function _ensureYieldBoosterMatched() private returns (bool yieldBoosterUpdated) {
-        address oldYieldBooster = yieldBooster;
-        address newYieldBooster = ICamelotNFTPool(nftPool).yieldBooster();
-
-        if (oldYieldBooster == newYieldBooster) return false;
-
-        // Avoid reverts from camelot's check for amount > 0
-        uint256 amountAllocated = IXGrail(xGRAIL).usageAllocations(address(this), oldYieldBooster);
-        if (amountAllocated > 0) {
-            ICamelotYieldBooster(oldYieldBooster).forceDeallocate();
-        }
-
-        // Revoke approvals and revnew
-        IXGrail(xGRAIL).approveUsage(oldYieldBooster, 0);
-        IXGrail(xGRAIL).approveUsage(newYieldBooster, type(uint256).max);
-
-        // reallocate
-        uint256 amountToReallocate = _selfBalance(xGRAIL);
-        if (amountToReallocate > 0) {
-            IXGrail(xGRAIL).allocate(newYieldBooster, amountToReallocate, _getAllocationData());
-        }
-
-        yieldBooster = newYieldBooster;
-        return true;
-    }
-
-    function _increaseNftPoolPosition(uint256 amountLp) internal returns (uint256 amountLpAccountedForUser) {
-        // first time minting from this contract
-        if (positionId == POSITION_UNINITIALIZED) {
-            positionId = ICamelotNFTPool(nftPool).lastTokenId() + 1;
-            ICamelotNFTPool(nftPool).createPosition(amountLp, 0);
-
-            _depositToNitroPool();
-
-            return amountLp - MINIMUM_LIQUIDITY;
-        } else {
-            // nftPool allows adding to position even if the position is in NitroPool
-            ICamelotNFTPool(nftPool).addToPosition(positionId, amountLp);
-            return amountLp;
-        }
-    }
-
-    function _decreaseNftPoolPosition(uint256 amountLp) internal {
-        _withdrawFromNitroPool();
-        ICamelotNFTPool(nftPool).withdrawFromPosition(positionId, amountLp);
-        _depositToNitroPool();
-    }
-
-    function _depositToNitroPool() internal {
-        // Nitro pool's on receive callback will execute the accounting logic
-        if (nitroPool == address(0) || positionId == POSITION_UNINITIALIZED) return;
-        IERC721(nftPool).safeTransferFrom(address(this), nitroPool, positionId);
-    }
-
-    function _withdrawFromNitroPool() internal {
-        if (nitroPool == address(0) || positionId == POSITION_UNINITIALIZED) return;
-        ICamelotNitroPool(nitroPool).withdraw(positionId);
-    }
-
-    function _getAllocationData() private view returns (bytes memory) {
-        return abi.encode(nftPool, positionId);
-    }
-
-    /**
-     * ==================================================================
-     *                      CAMELOT NFT RELATED
-     * ==================================================================
-     */
-
-    function onERC721Received(
-        address,
-        address,
-        uint256 tokenId,
-        bytes calldata
-    ) external view ensureValidTokenId(tokenId) returns (bytes4) {
-        return _ERC721_RECEIVED;
-    }
-
-    function onNFTHarvest(
-        address,
-        address,
-        uint256 tokenId,
-        uint256,
-        uint256
-    ) external view ensureValidTokenId(tokenId) returns (bool) {
-        return true;
-    }
-
-    function onNFTAddToPosition(
-        address,
-        uint256 tokenId,
-        uint256
-    ) external view ensureValidTokenId(tokenId) returns (bool) {
-        return true;
-    }
-
-    function onNFTWithdraw(address, uint256 tokenId, uint256) external view ensureValidTokenId(tokenId) returns (bool) {
-        return true;
-    }
-}

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

@@ -1,34 +0,0 @@
-// 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/PMath.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
-            (PMath.sqrt(PMath.square((TWO - fee) * reserve) + FOUR * (ONE - fee) * amountIn * reserve) -
-                (TWO - fee) *
-                reserve) / (2 * (ONE - fee));
-    }
-}

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

@@ -1,127 +0,0 @@
-// 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/PMath.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 router;
-
-    constructor(address _pair, address _router) {
-        assert(ICamelotPair(_pair).stableSwap() == false);
-        pair = _pair;
-        router = _router;
-        token0 = ICamelotPair(pair).token0();
-        token1 = ICamelotPair(pair).token1();
-        _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),
-            address(0),
-            block.timestamp
-        );
-
-        return _selfBalance(tokenOut) - preBalance;
-    }
-}

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

@@ -1,159 +0,0 @@
-// 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 PMath.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 = PMath.sqrt(data.reserve0 * data.reserve1);
-                uint256 rootKLast = PMath.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;
-    }
-}