@pendle/core-v2 3.0.0-beta-9 → 3.0.0

package/contracts/interfaces/IPPtOracle.sol

@@ -4,10 +4,7 @@ pragma solidity ^0.8.0;
 interface IPPtOracle {
     event SetBlockCycleNumerator(uint16 newBlockCycleNumerator);
 
-    function getPtToAssetRate(
-        address market,
-        uint32 duration
-    ) external view returns (uint256 ptToAssetRate);
+    function getPtToAssetRate(address market, uint32 duration) external view returns (uint256 ptToAssetRate);
 
     function getOracleState(
         address market,
@@ -15,9 +12,5 @@ interface IPPtOracle {
     )
         external
         view
-        returns (
-            bool increaseCardinalityRequired,
-            uint16 cardinalityRequired,
-            bool oldestObservationSatisfied
-        );
+        returns (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied);
 }

package/contracts/interfaces/IPRouterHelper.sol

@@ -2,13 +2,13 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../interfaces/IPAllActionTypeV3.sol";
+import "../router/base/ActionBaseMintRedeem.sol";
 
 interface IPRouterHelper {
     /**
      * @param output This output struct should be filled the same way as the normal removeLiquiditySingleToken
-     *  operation (This means PendleSwap still works the same way). Note that the
-     *  output.tokenOut will also be used as the input token for the addLiquidity
+     operation (This means all BulkSeller, PendleSwap still works the same way). Note that the
+     output.tokenOut will also be used as the input token for the addLiquidity
      */
     struct RemoveLiquiditySingleTokenStruct {
         address market;
@@ -19,10 +19,10 @@ interface IPRouterHelper {
 
     /**
      * @param guessNetTokenIn the predicted amount of tokenIn that will be used to add liquidity. This
-     *  should be the same amount that was used to generate guessPtReceivedFromSy (if any).
+     should be the same amount that was used to generate guessPtReceivedFromSy (if any).
      * @param guessPtReceivedFromSy the same guess struct in the normal addLiquiditySingleToken operation.
-     *  Again, note that this struct, if not empty (i.e. if guessOffchain == 0), should be generated
-     *  using `guessNetTokenIn` amount of tokenIn
+     Again, note that this struct, if not empty (i.e. if guessOffchain == 0), should be generated
+     using `guessNetTokenIn` amount of tokenIn
      * @dev tokenIn is the output.tokenOut of the removeLiquiditySingleTokenStruct
      */
     struct AddLiquiditySingleTokenStruct {
@@ -30,6 +30,7 @@ interface IPRouterHelper {
         uint256 minLpOut;
         uint256 guessNetTokenIn;
         ApproxParams guessPtReceivedFromSy;
+        address bulk;
     }
 
     /**
@@ -39,6 +40,7 @@ interface IPRouterHelper {
         address market;
         uint256 minLpOut;
         uint256 minYtOut;
+        address bulk;
     }
 
     struct RemoveLiquiditySingleSyStruct {
@@ -90,7 +92,11 @@ interface IPRouterHelper {
     );
 
     event AddLiquiditySingleSy(
-        address indexed caller, address indexed market, address indexed receiver, uint256 netSyIn, uint256 netLpOut
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netSyIn,
+        uint256 netLpOut
     );
 
     event AddLiquiditySingleTokenKeepYt(
@@ -132,11 +138,11 @@ interface IPRouterHelper {
         AddLiquiditySingleSyKeepYtStruct calldata toMarket
     ) external returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyZapIn, uint256 netSyFeeOfRemove);
 
-    function removeLiquiditySingleToken(RemoveLiquiditySingleTokenStruct calldata fromMarket)
-        external
-        returns (uint256 netTokenOut, uint256 netSyFee);
+    function removeLiquiditySingleToken(
+        RemoveLiquiditySingleTokenStruct calldata fromMarket
+    ) external returns (uint256 netTokenOut, uint256 netSyFee);
 
-    function removeLiquiditySingleSy(RemoveLiquiditySingleSyStruct calldata fromMarket)
-        external
-        returns (uint256 netSyOut, uint256 netSyFee);
+    function removeLiquiditySingleSy(
+        RemoveLiquiditySingleSyStruct calldata fromMarket
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPRouterStatic.sol

@@ -18,6 +18,4 @@ interface IPRouterStatic is
     IPActionVePendleStatic,
     IPMiniDiamond,
     IPActionStorageStatic
-{
-
-}
+{}

package/contracts/interfaces/IPVotingController.sol

@@ -14,11 +14,7 @@ interface IPVotingController {
 
     event SetPendlePerSec(uint256 newPendlePerSec);
 
-    event BroadcastResults(
-        uint64 indexed chainId,
-        uint128 indexed wTime,
-        uint128 totalPendlePerSec
-    );
+    event BroadcastResults(uint64 indexed chainId, uint128 indexed wTime, uint128 totalPendlePerSec);
 
     function applyPoolSlopeChanges(address pool) external;
 
@@ -26,20 +22,12 @@ interface IPVotingController {
     function getUserPoolHistoryLength(address user, address pool) external view returns (uint256);
 
     /// @notice deprecated, only kept for compatibility reasons
-    function getUserPoolHistoryAt(
-        address user,
-        address pool,
-        uint256 index
-    ) external view returns (Checkpoint memory);
-
-    function getWeekData(uint128 wTime, address[] calldata pools)
-        external
-        view
-        returns (
-            bool isEpochFinalized,
-            uint128 totalVotes,
-            uint128[] memory poolVotes
-        );
+    function getUserPoolHistoryAt(address user, address pool, uint256 index) external view returns (Checkpoint memory);
+
+    function getWeekData(
+        uint128 wTime,
+        address[] calldata pools
+    ) external view returns (bool isEpochFinalized, uint128 totalVotes, uint128[] memory poolVotes);
 
     function getPoolTotalVoteAt(address pool, uint128 wTime) external view returns (uint128);
 

package/contracts/interfaces/IPVotingEscrowMainchain.sol

@@ -17,10 +17,7 @@ interface IPVotingEscrowMainchain is IPVeToken {
 
     // ============= ACTIONS =============
 
-    function increaseLockPosition(
-        uint128 additionalAmountToLock,
-        uint128 expiry
-    ) external returns (uint128);
+    function increaseLockPosition(uint128 additionalAmountToLock, uint128 expiry) external returns (uint128);
 
     function withdraw() external returns (uint128);
 
@@ -28,8 +25,5 @@ interface IPVotingEscrowMainchain is IPVeToken {
 
     function getUserHistoryLength(address user) external view returns (uint256);
 
-    function getUserHistoryAt(
-        address user,
-        uint256 index
-    ) external view returns (Checkpoint memory);
+    function getUserHistoryAt(address user, uint256 index) external view returns (Checkpoint memory);
 }

package/contracts/interfaces/IPYieldToken.sol

@@ -15,18 +15,13 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
         uint256 amountPYOut
     );
 
-    event Burn(
-        address indexed caller,
-        address indexed receiver,
-        uint256 amountPYToRedeem,
-        uint256 amountSyOut
-    );
+    event Burn(address indexed caller, address indexed receiver, uint256 amountPYToRedeem, uint256 amountSyOut);
 
     event RedeemRewards(address indexed user, uint256[] amountRewardsOut);
 
     event RedeemInterest(address indexed user, uint256 interestOut);
 
-    event WithdrawFeeToTreasury(uint256[] amountRewardsOut, uint256 syOut);
+    event CollectRewardFee(address indexed rewardToken, uint256 amountRewardFee);
 
     function mintPY(address receiverPT, address receiverYT) external returns (uint256 amountPYOut);
 
@@ -64,5 +59,4 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
     function doCacheIndexSameBlock() external view returns (bool);
 
     function pyIndexLastUpdatedBlock() external view returns (uint128);
-
 }

package/contracts/interfaces/IPYieldTokenV2.sol

@@ -13,12 +13,7 @@ interface IPYieldTokenV2 is IERC20Metadata, IRewardManager, IPInterestManagerYTV
         uint256 amountPYOut
     );
 
-    event Burn(
-        address indexed caller,
-        address indexed receiver,
-        uint256 amountPYToRedeem,
-        uint256 amountSyOut
-    );
+    event Burn(address indexed caller, address indexed receiver, uint256 amountPYToRedeem, uint256 amountSyOut);
 
     event RedeemRewards(address indexed user, uint256[] amountRewardsOut);
 

package/contracts/interfaces/IPendlePreviewHelper.sol

@@ -2,13 +2,7 @@
 pragma solidity ^0.8.0;
 
 interface IPendlePreviewHelper {
-    function previewDeposit(
-        address tokenIn,
-        uint256 amountTokenIn
-    ) external view returns (uint256 amountSharesOut);
+    function previewDeposit(address tokenIn, uint256 amountTokenIn) external view returns (uint256 amountSharesOut);
 
-    function previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToBurn
-    ) external view returns (uint256 amountTokenOut);
+    function previewRedeem(address tokenOut, uint256 amountSharesToBurn) external view returns (uint256 amountTokenOut);
 }

package/contracts/interfaces/IRewardManager.sol

@@ -2,8 +2,5 @@
 pragma solidity ^0.8.0;
 
 interface IRewardManager {
-    function userReward(
-        address token,
-        address user
-    ) external view returns (uint128 index, uint128 accrued);
+    function userReward(address token, address user) external view returns (uint128 index, uint128 accrued);
 }

package/contracts/interfaces/IStETH.sol

@@ -8,10 +8,7 @@ interface IStETH {
 
     function submit(address referral) external payable returns (uint256 amount);
 
-    function burnShares(
-        address _account,
-        uint256 _sharesAmount
-    ) external returns (uint256 newTotalShares);
+    function burnShares(address _account, uint256 _sharesAmount) external returns (uint256 newTotalShares);
 
     function sharesOf(address account) external view returns (uint256);
 

package/contracts/interfaces/IStandardizedYield.sol

@@ -146,15 +146,15 @@ interface IStandardizedYield is IERC20Metadata {
 
     function isValidTokenOut(address token) external view returns (bool);
 
-    function previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        external
-        view
-        returns (uint256 amountSharesOut);
+    function previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) external view returns (uint256 amountSharesOut);
 
-    function previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        external
-        view
-        returns (uint256 amountTokenOut);
+    function previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) external view returns (uint256 amountTokenOut);
 
     /**
      * @notice This function contains information to interpret what the asset is
@@ -163,12 +163,5 @@ interface IStandardizedYield is IERC20Metadata {
      * @return assetAddress the address of the asset
      * @return assetDecimals the decimals of the asset
      */
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        );
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals);
 }

package/contracts/interfaces/IStargateLP.sol

@@ -23,8 +23,6 @@
 pragma solidity ^0.8.0;
 
 interface IStargateLP {
-
-
     struct SwapObj {
         uint256 amount;
         uint256 eqFee;
@@ -58,5 +56,4 @@ interface IStargateLP {
     function convertRate() external view returns (uint256);
 
     function deltaCredit() external view returns (uint256);
-
 }

package/contracts/interfaces/IStargateRouter.sol

@@ -25,9 +25,5 @@ pragma solidity ^0.8.0;
 interface IStargateRouter {
     function addLiquidity(uint256 _poolId, uint256 _amountLD, address _to) external;
 
-    function instantRedeemLocal(
-        uint16 _srcPoolId,
-        uint256 _amountLP,
-        address _to
-    ) external returns (uint256 amountSD);
+    function instantRedeemLocal(uint16 _srcPoolId, uint256 _amountLP, address _to) external returns (uint256 amountSD);
 }

package/contracts/interfaces/Kyber/IKyberElasticFactory.sol

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/// @title KyberSwap v2 factory
+/// @notice Deploys KyberSwap v2 pools and manages control over government fees
+interface IKyberElasticFactory {
+    /// @notice Emitted when a pool is created
+    /// @param token0 First pool token by address sort order
+    /// @param token1 Second pool token by address sort order
+    /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @param tickDistance Minimum number of ticks between initialized ticks
+    /// @param pool The address of the created pool
+    event PoolCreated(
+        address indexed token0,
+        address indexed token1,
+        uint24 indexed swapFeeUnits,
+        int24 tickDistance,
+        address pool
+    );
+
+    /// @notice Emitted when a new fee is enabled for pool creation via the factory
+    /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @param tickDistance Minimum number of ticks between initialized ticks for pools created with the given fee
+    event SwapFeeEnabled(uint24 indexed swapFeeUnits, int24 indexed tickDistance);
+
+    /// @notice Emitted when vesting period changes
+    /// @param vestingPeriod The maximum time duration for which LP fees
+    /// are proportionally burnt upon LP removals
+    event VestingPeriodUpdated(uint32 vestingPeriod);
+
+    /// @notice Emitted when configMaster changes
+    /// @param oldConfigMaster configMaster before the update
+    /// @param newConfigMaster configMaster after the update
+    event ConfigMasterUpdated(address oldConfigMaster, address newConfigMaster);
+
+    /// @notice Emitted when fee configuration changes
+    /// @param feeTo Recipient of government fees
+    /// @param governmentFeeUnits Fee amount, in fee units,
+    /// to be collected out of the fee charged for a pool swap
+    event FeeConfigurationUpdated(address feeTo, uint24 governmentFeeUnits);
+
+    /// @notice Emitted when whitelist feature is enabled
+    event WhitelistEnabled();
+
+    /// @notice Emitted when whitelist feature is disabled
+    event WhitelistDisabled();
+
+    /// @notice Returns the maximum time duration for which LP fees
+    /// are proportionally burnt upon LP removals
+    function vestingPeriod() external view returns (uint32);
+
+    /// @notice Returns the tick distance for a specified fee.
+    /// @dev Once added, cannot be updated or removed.
+    /// @param swapFeeUnits Swap fee, in fee units.
+    /// @return The tick distance. Returns 0 if fee has not been added.
+    function feeAmountTickDistance(uint24 swapFeeUnits) external view returns (int24);
+
+    /// @notice Returns the address which can update the fee configuration
+    function configMaster() external view returns (address);
+
+    /// @notice Returns the keccak256 hash of the Pool creation code
+    /// This is used for pre-computation of pool addresses
+    function poolInitHash() external view returns (bytes32);
+
+    /// @notice Returns the pool oracle contract for twap
+    function poolOracle() external view returns (address);
+
+    /// @notice Fetches the recipient of government fees
+    /// and current government fee charged in fee units
+    function feeConfiguration() external view returns (address _feeTo, uint24 _governmentFeeUnits);
+
+    /// @notice Returns the status of whitelisting feature of NFT managers
+    /// If true, anyone can mint liquidity tokens
+    /// Otherwise, only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+    function whitelistDisabled() external view returns (bool);
+
+    //// @notice Returns all whitelisted NFT managers
+    /// If the whitelisting feature is turned on,
+    /// only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+    function getWhitelistedNFTManagers() external view returns (address[] memory);
+
+    /// @notice Checks if sender is a whitelisted NFT manager
+    /// If the whitelisting feature is turned on,
+    /// only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+    /// @param sender address to be checked
+    /// @return true if sender is a whistelisted NFT manager, false otherwise
+    function isWhitelistedNFTManager(address sender) external view returns (bool);
+
+    /// @notice Returns the pool address for a given pair of tokens and a swap fee
+    /// @dev Token order does not matter
+    /// @param tokenA Contract address of either token0 or token1
+    /// @param tokenB Contract address of the other token
+    /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @return pool The pool address. Returns null address if it does not exist
+    function getPool(address tokenA, address tokenB, uint24 swapFeeUnits) external view returns (address pool);
+
+    /// @notice Fetch parameters to be used for pool creation
+    /// @dev Called by the pool constructor to fetch the parameters of the pool
+    /// @return factory The factory address
+    /// @return poolOracle The pool oracle for twap
+    /// @return token0 First pool token by address sort order
+    /// @return token1 Second pool token by address sort order
+    /// @return swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @return tickDistance Minimum number of ticks between initialized ticks
+    function parameters()
+        external
+        view
+        returns (
+            address factory,
+            address poolOracle,
+            address token0,
+            address token1,
+            uint24 swapFeeUnits,
+            int24 tickDistance
+        );
+
+    /// @notice Creates a pool for the given two tokens and fee
+    /// @param tokenA One of the two tokens in the desired pool
+    /// @param tokenB The other of the two tokens in the desired pool
+    /// @param swapFeeUnits Desired swap fee for the pool, in fee units
+    /// @dev Token order does not matter. tickDistance is determined from the fee.
+    /// Call will revert under any of these conditions:
+    ///     1) pool already exists
+    ///     2) invalid swap fee
+    ///     3) invalid token arguments
+    /// @return pool The address of the newly created pool
+    function createPool(address tokenA, address tokenB, uint24 swapFeeUnits) external returns (address pool);
+
+    /// @notice Enables a fee amount with the given tickDistance
+    /// @dev Fee amounts may never be removed once enabled
+    /// @param swapFeeUnits The fee amount to enable, in fee units
+    /// @param tickDistance The distance between ticks to be enforced for all pools created with the given fee amount
+    function enableSwapFee(uint24 swapFeeUnits, int24 tickDistance) external;
+
+    /// @notice Updates the address which can update the fee configuration
+    /// @dev Must be called by the current configMaster
+    function updateConfigMaster(address) external;
+
+    /// @notice Updates the vesting period
+    /// @dev Must be called by the current configMaster
+    function updateVestingPeriod(uint32) external;
+
+    /// @notice Updates the address receiving government fees and fee quantity
+    /// @dev Only configMaster is able to perform the update
+    /// @param feeTo Address to receive government fees collected from pools
+    /// @param governmentFeeUnits Fee amount, in fee units,
+    /// to be collected out of the fee charged for a pool swap
+    function updateFeeConfiguration(address feeTo, uint24 governmentFeeUnits) external;
+
+    /// @notice Enables the whitelisting feature
+    /// @dev Only configMaster is able to perform the update
+    function enableWhitelist() external;
+
+    /// @notice Disables the whitelisting feature
+    /// @dev Only configMaster is able to perform the update
+    function disableWhitelist() external;
+}

package/contracts/interfaces/Kyber/IKyberElasticPool.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+interface IKyberElasticPool {
+    function factory() external view returns (address);
+
+    /// @notice The first of the two tokens of the pool, sorted by address
+    /// @return The token contract address
+    function token0() external view returns (address);
+
+    /// @notice The second of the two tokens of the pool, sorted by address
+    /// @return The token contract address
+    function token1() external view returns (address);
+
+    /// @notice The fee to be charged for a swap in basis points
+    /// @return The swap fee in basis points
+    function swapFeeUnits() external view returns (uint24);
+
+    function totalSupply() external view returns (uint256);
+
+    /// @notice The pool tick distance
+    /// @dev Ticks can only be initialized and used at multiples of this value
+    /// It remains an int24 to avoid casting even though it is >= 1.
+    /// e.g: a tickDistance of 5 means ticks can be initialized every 5th tick, i.e., ..., -10, -5, 0, 5, 10, ...
+    /// @return The tick distance
+    function tickDistance() external view returns (int24);
+
+    /// @notice Maximum gross liquidity that an initialized tick can have
+    /// @dev This is to prevent overflow the pool's active base liquidity (uint128)
+    /// also prevents out-of-range liquidity from being used to prevent adding in-range liquidity to a pool
+    /// @return The max amount of liquidity per tick
+    function maxTickLiquidity() external view returns (uint128);
+
+    /// @notice Look up information about a specific tick in the pool
+    /// @param tick The tick to look up
+    /// @return liquidityGross total liquidity amount from positions that uses this tick as a lower or upper tick
+    /// liquidityNet how much liquidity changes when the pool tick crosses above the tick
+    /// feeGrowthOutside the fee growth on the other side of the tick relative to the current tick
+    /// secondsPerLiquidityOutside the seconds per unit of liquidity  spent on the other side of the tick relative to the current tick
+    function ticks(
+        int24 tick
+    )
+        external
+        view
+        returns (
+            uint128 liquidityGross,
+            int128 liquidityNet,
+            uint256 feeGrowthOutside,
+            uint128 secondsPerLiquidityOutside
+        );
+
+    /// @notice Returns the previous and next initialized ticks of a specific tick
+    /// @dev If specified tick is uninitialized, the returned values are zero.
+    /// @param tick The tick to look up
+    function initializedTicks(int24 tick) external view returns (int24 previous, int24 next);
+
+    /// @notice Returns the information about a position by the position's key
+    /// @return liquidity the liquidity quantity of the position
+    /// @return feeGrowthInsideLast fee growth inside the tick range as of the last mint / burn action performed
+    function getPositions(
+        address owner,
+        int24 tickLower,
+        int24 tickUpper
+    ) external view returns (uint128 liquidity, uint256 feeGrowthInsideLast);
+
+    /// @notice Fetches the pool's prices, ticks and lock status
+    /// @return sqrtP sqrt of current price: sqrt(token1/token0)
+    /// @return currentTick pool's current tick
+    /// @return nearestCurrentTick pool's nearest initialized tick that is <= currentTick
+    /// @return locked true if pool is locked, false otherwise
+    function getPoolState()
+        external
+        view
+        returns (uint160 sqrtP, int24 currentTick, int24 nearestCurrentTick, bool locked);
+
+    /// @notice Fetches the pool's liquidity values
+    /// @return baseL pool's base liquidity without reinvest liqudity
+    /// @return reinvestL the liquidity is reinvested into the pool
+    /// @return reinvestLLast last cached value of reinvestL, used for calculating reinvestment token qty
+    function getLiquidityState() external view returns (uint128 baseL, uint128 reinvestL, uint128 reinvestLLast);
+
+    /// @return feeGrowthGlobal All-time fee growth per unit of liquidity of the pool
+    function getFeeGrowthGlobal() external view returns (uint256);
+
+    /// @return secondsPerLiquidityGlobal All-time seconds per unit of liquidity of the pool
+    /// @return lastUpdateTime The timestamp in which secondsPerLiquidityGlobal was last updated
+    function getSecondsPerLiquidityData()
+        external
+        view
+        returns (uint128 secondsPerLiquidityGlobal, uint32 lastUpdateTime);
+
+    /// @notice Calculates and returns the active time per unit of liquidity until current block.timestamp
+    /// @param tickLower The lower tick (of a position)
+    /// @param tickUpper The upper tick (of a position)
+    /// @return secondsPerLiquidityInside active time (multiplied by 2^96)
+    /// between the 2 ticks, per unit of liquidity.
+    function getSecondsPerLiquidityInside(
+        int24 tickLower,
+        int24 tickUpper
+    ) external view returns (uint128 secondsPerLiquidityInside);
+}