@pendle/core-v2 2.13.3-mainnet → 2.14.0-mainnet

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

@@ -4,6 +4,7 @@ pragma solidity 0.8.17;
 
 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";
@@ -19,12 +20,14 @@ import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
  * 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 nitroPool;
     address public immutable GRAIL;
     address public immutable xGRAIL;
     uint256 public positionId = POSITION_UNINITIALIZED;
@@ -41,14 +44,18 @@ contract CamelotRewardHelper is TokenHelper, ICamelotNFTHandler {
         _;
     }
 
-    constructor(address _nitroPool, address _lp) {
-        nitroPool = _nitroPool;
-        nftPool = ICamelotNitroPool(nitroPool).nftPool();
-        GRAIL = ICamelotNitroPool(nitroPool).grailToken();
-        xGRAIL = ICamelotNitroPool(nitroPool).xGrailToken();
-        _safeApproveInf(_lp, nftPool);
+    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);
     }
 
@@ -104,7 +111,6 @@ contract CamelotRewardHelper is TokenHelper, ICamelotNFTHandler {
             positionId = ICamelotNFTPool(nftPool).lastTokenId() + 1;
             ICamelotNFTPool(nftPool).createPosition(amountLp, 0);
 
-            // deposit nft to nitro pool (first time)
             _depositToNitroPool();
 
             return amountLp - MINIMUM_LIQUIDITY;
@@ -121,12 +127,14 @@ contract CamelotRewardHelper is TokenHelper, ICamelotNFTHandler {
         _depositToNitroPool();
     }
 
-    function _depositToNitroPool() private {
+    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() private {
+    function _withdrawFromNitroPool() internal {
+        if (nitroPool == address(0) || positionId == POSITION_UNINITIALIZED) return;
         ICamelotNitroPool(nitroPool).withdraw(positionId);
     }
 

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

@@ -22,26 +22,18 @@ abstract contract CamelotV1VolatileLpHelper is TokenHelper, CamelotV1VolatileCom
     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
+        address _router
     ) {
         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);
@@ -137,7 +129,7 @@ abstract contract CamelotV1VolatileLpHelper is TokenHelper, CamelotV1VolatileCom
             0,
             path,
             address(this),
-            referrerForSwap,
+            address(0),
             block.timestamp
         );
 

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

@@ -19,19 +19,19 @@ contract PendleCamelotV1VolatileSY is
     CamelotV1VolatilePreview public immutable previewHelper;
     bool public isRewardDisabled;
 
+    /// @notice _nitroPoolIndex set to uint256(max) to indicate that this SY is not using Nitro Pool
     constructor(
         string memory _name,
         string memory _symbol,
         address _pair,
-        address _factory,
         address _router,
-        address _nitroPool,
-        address _referrer,
+        address _nftPool,
+        uint256 _nitroPoolIndex,
         CamelotV1VolatilePreview _previewHelper
     )
-        CamelotV1VolatileLpHelper(_pair, _factory, _router, _referrer)
+        CamelotV1VolatileLpHelper(_pair, _router)
         SYBaseWithRewards(_name, _symbol, _pair)
-        CamelotRewardHelper(_nitroPool, _pair)
+        CamelotRewardHelper(_nftPool, _nitroPoolIndex)
     {
         rewardTokens.push(GRAIL);
         updateRewardTokensList();
@@ -41,12 +41,10 @@ contract PendleCamelotV1VolatileSY is
     /**
      * @dev See {SYBase-_deposit}
      */
-    function _deposit(address tokenIn, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256)
-    {
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256) {
         uint256 amountLpDeposited;
         if (tokenIn == pair) {
             amountLpDeposited = amountDeposited;
@@ -103,11 +101,15 @@ contract PendleCamelotV1VolatileSY is
 
     /// @notice allows anyone to add new rewardTokens to this SY if a new rewardToken is added to the Nitro pool
     function updateRewardTokensList() public virtual {
+        if (nitroPool == address(0)) return; // if nitroPool is not set, we don't need to update rewardTokens list
+
         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);
+        if (token1 != address(0) && token1 != xGRAIL && !rewardTokens.contains(token1))
+            rewardTokens.push(token1);
+        if (token2 != address(0) && token2 != xGRAIL && !rewardTokens.contains(token2))
+            rewardTokens.push(token2);
     }
 
     function _redeemExternalReward() internal override {
@@ -115,7 +117,9 @@ contract PendleCamelotV1VolatileSY is
             return;
         }
 
-        ICamelotNitroPool(nitroPool).harvest();
+        if (nitroPool != address(0)) {
+            ICamelotNitroPool(nitroPool).harvest();
+        }
         ICamelotNFTPool(nftPool).harvestPosition(positionId);
         _allocateXGrail();
     }
@@ -124,12 +128,10 @@ contract PendleCamelotV1VolatileSY is
                     PREVIEW-RELATED
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256)
-    {
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256) {
         if (tokenIn == pair) {
             return amountTokenToDeposit;
         } else {
@@ -137,12 +139,10 @@ contract PendleCamelotV1VolatileSY is
         }
     }
 
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        override
-        returns (uint256)
-    {
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256) {
         if (tokenOut == pair) {
             return amountSharesToRedeem;
         } else {
@@ -186,11 +186,7 @@ contract PendleCamelotV1VolatileSY is
     function assetInfo()
         external
         view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
     {
         return (AssetType.LIQUIDITY, pair, IERC20Metadata(pair).decimals());
     }
@@ -204,7 +200,9 @@ contract PendleCamelotV1VolatileSY is
         if (doRewardIndexUpdate) _updateRewardIndex();
 
         if (positionId != POSITION_UNINITIALIZED) {
-            ICamelotNitroPool(nitroPool).emergencyWithdraw(positionId);
+            if (nitroPool != address(0)) {
+                ICamelotNitroPool(nitroPool).emergencyWithdraw(positionId);
+            }
             ICamelotNFTPool(nftPool).emergencyWithdraw(positionId);
             positionId = POSITION_UNINITIALIZED;
         }
@@ -212,8 +210,18 @@ contract PendleCamelotV1VolatileSY is
         isRewardDisabled = true;
     }
 
-    function setReferrerForSwap(address newReferrer) external onlyOwner {
-        referrerForSwap = newReferrer;
+    function setNewNitroPool(uint256 newPoolIndex) external onlyOwner {
+        assert(!isRewardDisabled);
+
+        _updateRewardIndex();
+        _withdrawFromNitroPool();
+
+        nitroPool = NITRO_POOL_FACTORY.getNitroPool(newPoolIndex);
+        require(ICamelotNitroPool(nitroPool).nftPool() == nftPool, "invalid nitro pool");
+
+        _depositToNitroPool();
+
+        updateRewardTokensList();
     }
 
     // XGRAIL related, to be used only when this SY is deprecated

package/contracts/interfaces/Camelot/ICamelotNFTPool.sol

@@ -16,4 +16,18 @@ interface ICamelotNFTPool is IERC721 {
     function yieldBooster() external view returns (address);
 
     function emergencyWithdraw(uint256 tokenId) external;
+
+    function getPoolInfo()
+        external
+        view
+        returns (
+            address lpToken,
+            address grailToken,
+            address xGrailToken,
+            uint256 lastRewardTime,
+            uint256 accRewardsPerShare,
+            uint256 lpSupply,
+            uint256 lpSupplyWithMultiplier,
+            uint256 allocPoint
+        );
 }

package/contracts/interfaces/Camelot/ICamelotNitroPoolFactory.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface ICamelotNitroPoolFactory {
+    event CreateNitroPool(address nitroAddress);
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    event PublishNitroPool(address nitroAddress);
+    event SetDefaultFee(uint256 fee);
+    event SetEmergencyRecoveryAddress(address emergencyRecoveryAddress);
+    event SetExemptedAddress(address exemptedAddress, bool isExempted);
+    event SetFeeAddress(address feeAddress);
+    event SetNitroPoolOwner(address previousOwner, address newOwner);
+
+    struct Settings {
+        uint256 startTime;
+        uint256 endTime;
+        uint256 harvestStartTime;
+        uint256 depositEndTime;
+        uint256 lockDurationReq;
+        uint256 lockEndReq;
+        uint256 depositAmountReq;
+        bool whitelist;
+        string description;
+    }
+
+    function MAX_DEFAULT_FEE() external view returns (uint256);
+
+    function createNitroPool(
+        address nftPoolAddress,
+        address rewardsToken1,
+        address rewardsToken2,
+        Settings memory settings
+    ) external returns (address nitroPool);
+
+    function defaultFee() external view returns (uint256);
+
+    function emergencyRecoveryAddress() external view returns (address);
+
+    function exemptedAddressesLength() external view returns (uint256);
+
+    function feeAddress() external view returns (address);
+
+    function getExemptedAddress(uint256 index) external view returns (address);
+
+    function getNftPoolPublishedNitroPool(address nftPoolAddress, uint256 index)
+        external
+        view
+        returns (address);
+
+    function getNitroPool(uint256 index) external view returns (address);
+
+    function getNitroPoolFee(address nitroPoolAddress, address ownerAddress)
+        external
+        view
+        returns (uint256);
+
+    function getOwnerNitroPool(address userAddress, uint256 index) external view returns (address);
+
+    function getPublishedNitroPool(uint256 index) external view returns (address);
+
+    function grailToken() external view returns (address);
+
+    function isExemptedAddress(address checkedAddress) external view returns (bool);
+
+    function nftPoolPublishedNitroPoolsLength(address nftPoolAddress)
+        external
+        view
+        returns (uint256);
+
+    function nitroPoolsLength() external view returns (uint256);
+
+    function owner() external view returns (address);
+
+    function ownerNitroPoolsLength(address userAddress) external view returns (uint256);
+
+    function publishNitroPool(address nftAddress) external;
+
+    function publishedNitroPoolsLength() external view returns (uint256);
+
+    function renounceOwnership() external;
+
+    function setDefaultFee(uint256 newFee) external;
+
+    function setEmergencyRecoveryAddress(address emergencyRecoveryAddress_) external;
+
+    function setExemptedAddress(address exemptedAddress, bool isExempted) external;
+
+    function setFeeAddress(address feeAddress_) external;
+
+    function setNitroPoolOwner(address previousOwner, address newOwner) external;
+
+    function transferOwnership(address newOwner) external;
+
+    function xGrailToken() external view returns (address);
+}

package/deployments/42161-markets/CAMELOT-ARBETH-27JUNE2024-ARBITRUM.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY ARB-ETH_Camelot",
+    "SY": "0x318EEC91f653cA72fAFB038f9AD792A6bC0d644C",
+    "YT": "0x69ddf9Ce5568EfA913f1eA601Ed298ccfeBfC811",
+    "PT": "0xa3BeDB2885Bf23E9b8f72e38Bbd9fdDD1b50E1d6",
+    "market": "0x9f003Fd08d5317Dfd988Bd1EE151B27836FE6C3D",
+    "expiry": 1719446400,
+    "scalarRoot": "7045105000000000000",
+    "initAnchor": "1461042000000000000"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "2.13.3-mainnet",
+  "version": "2.14.0-mainnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/CamelotV1LpHelper.ts

@@ -0,0 +1,203 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface CamelotV1LpHelperInterface extends utils.Interface {
+  contractName: "CamelotV1LpHelper";
+  functions: {
+    "factory()": FunctionFragment;
+    "isStable()": FunctionFragment;
+    "multiplier0()": FunctionFragment;
+    "multiplier1()": FunctionFragment;
+    "pair()": FunctionFragment;
+    "referrerForSwap()": FunctionFragment;
+    "router()": FunctionFragment;
+    "token0()": FunctionFragment;
+    "token1()": FunctionFragment;
+  };
+
+  encodeFunctionData(functionFragment: "factory", values?: undefined): string;
+  encodeFunctionData(functionFragment: "isStable", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "multiplier0",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "multiplier1",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "pair", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "referrerForSwap",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "router", values?: undefined): string;
+  encodeFunctionData(functionFragment: "token0", values?: undefined): string;
+  encodeFunctionData(functionFragment: "token1", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isStable", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "multiplier0",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "multiplier1",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pair", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "referrerForSwap",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "router", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "token0", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "token1", data: BytesLike): Result;
+
+  events: {};
+}
+
+export interface CamelotV1LpHelper extends BaseContract {
+  contractName: "CamelotV1LpHelper";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: CamelotV1LpHelperInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    factory(overrides?: CallOverrides): Promise<[string]>;
+
+    isStable(overrides?: CallOverrides): Promise<[boolean]>;
+
+    multiplier0(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    multiplier1(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    pair(overrides?: CallOverrides): Promise<[string]>;
+
+    referrerForSwap(overrides?: CallOverrides): Promise<[string]>;
+
+    router(overrides?: CallOverrides): Promise<[string]>;
+
+    token0(overrides?: CallOverrides): Promise<[string]>;
+
+    token1(overrides?: CallOverrides): Promise<[string]>;
+  };
+
+  factory(overrides?: CallOverrides): Promise<string>;
+
+  isStable(overrides?: CallOverrides): Promise<boolean>;
+
+  multiplier0(overrides?: CallOverrides): Promise<BigNumber>;
+
+  multiplier1(overrides?: CallOverrides): Promise<BigNumber>;
+
+  pair(overrides?: CallOverrides): Promise<string>;
+
+  referrerForSwap(overrides?: CallOverrides): Promise<string>;
+
+  router(overrides?: CallOverrides): Promise<string>;
+
+  token0(overrides?: CallOverrides): Promise<string>;
+
+  token1(overrides?: CallOverrides): Promise<string>;
+
+  callStatic: {
+    factory(overrides?: CallOverrides): Promise<string>;
+
+    isStable(overrides?: CallOverrides): Promise<boolean>;
+
+    multiplier0(overrides?: CallOverrides): Promise<BigNumber>;
+
+    multiplier1(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pair(overrides?: CallOverrides): Promise<string>;
+
+    referrerForSwap(overrides?: CallOverrides): Promise<string>;
+
+    router(overrides?: CallOverrides): Promise<string>;
+
+    token0(overrides?: CallOverrides): Promise<string>;
+
+    token1(overrides?: CallOverrides): Promise<string>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    factory(overrides?: CallOverrides): Promise<BigNumber>;
+
+    isStable(overrides?: CallOverrides): Promise<BigNumber>;
+
+    multiplier0(overrides?: CallOverrides): Promise<BigNumber>;
+
+    multiplier1(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pair(overrides?: CallOverrides): Promise<BigNumber>;
+
+    referrerForSwap(overrides?: CallOverrides): Promise<BigNumber>;
+
+    router(overrides?: CallOverrides): Promise<BigNumber>;
+
+    token0(overrides?: CallOverrides): Promise<BigNumber>;
+
+    token1(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    factory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    isStable(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    multiplier0(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    multiplier1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pair(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    referrerForSwap(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    router(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    token0(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    token1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}