@pendle/core-v2 2.29.4 → 2.30.1

package/contracts/interfaces/Kyber/IKyberElasticPool.sol

@@ -2,111 +2,100 @@
 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);
+    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);
 }

package/contracts/interfaces/Kyber/IKyberElasticRouter.sol

@@ -6,105 +6,93 @@ pragma solidity >=0.8.0;
 /// - Support swap with a price limit
 /// - Support swap within a single pool and between multiple pools
 interface IKyberElasticRouter {
-  /// @dev Params for swapping exact input amount
-  /// @param tokenIn the token to swap
-  /// @param tokenOut the token to receive
-  /// @param fee the pool's fee
-  /// @param recipient address to receive tokenOut
-  /// @param deadline time that the transaction will be expired
-  /// @param amountIn the tokenIn amount to swap
-  /// @param amountOutMinimum the minimum receive amount
-  /// @param limitSqrtP the price limit, if reached, stop swapping
-  struct ExactInputSingleParams {
-    address tokenIn;
-    address tokenOut;
-    uint24 fee;
-    address recipient;
-    uint256 deadline;
-    uint256 amountIn;
-    uint256 minAmountOut;
-    uint160 limitSqrtP;
-  }
+    /// @dev Params for swapping exact input amount
+    /// @param tokenIn the token to swap
+    /// @param tokenOut the token to receive
+    /// @param fee the pool's fee
+    /// @param recipient address to receive tokenOut
+    /// @param deadline time that the transaction will be expired
+    /// @param amountIn the tokenIn amount to swap
+    /// @param amountOutMinimum the minimum receive amount
+    /// @param limitSqrtP the price limit, if reached, stop swapping
+    struct ExactInputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint24 fee;
+        address recipient;
+        uint256 deadline;
+        uint256 amountIn;
+        uint256 minAmountOut;
+        uint160 limitSqrtP;
+    }
 
-  /// @notice Swaps `amountIn` of one token for as much as possible of another token
-  /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
-  /// @return amountOut The amount of the received token
-  function swapExactInputSingle(ExactInputSingleParams calldata params)
-    external
-    payable
-    returns (uint256 amountOut);
+    /// @notice Swaps `amountIn` of one token for as much as possible of another token
+    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
+    /// @return amountOut The amount of the received token
+    function swapExactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
 
-  /// @dev Params for swapping exact input using multiple pools
-  /// @param path the encoded path to swap from tokenIn to tokenOut
-  ///   If the swap is from token0 -> token1 -> token2, then path is encoded as [token0, fee01, token1, fee12, token2]
-  /// @param recipient address to receive tokenOut
-  /// @param deadline time that the transaction will be expired
-  /// @param amountIn the tokenIn amount to swap
-  /// @param amountOutMinimum the minimum receive amount
-  struct ExactInputParams {
-    bytes path;
-    address recipient;
-    uint256 deadline;
-    uint256 amountIn;
-    uint256 minAmountOut;
-  }
+    /// @dev Params for swapping exact input using multiple pools
+    /// @param path the encoded path to swap from tokenIn to tokenOut
+    ///   If the swap is from token0 -> token1 -> token2, then path is encoded as [token0, fee01, token1, fee12, token2]
+    /// @param recipient address to receive tokenOut
+    /// @param deadline time that the transaction will be expired
+    /// @param amountIn the tokenIn amount to swap
+    /// @param amountOutMinimum the minimum receive amount
+    struct ExactInputParams {
+        bytes path;
+        address recipient;
+        uint256 deadline;
+        uint256 amountIn;
+        uint256 minAmountOut;
+    }
 
-  /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
-  /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
-  /// @return amountOut The amount of the received token
-  function swapExactInput(ExactInputParams calldata params)
-    external
-    payable
-    returns (uint256 amountOut);
+    /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
+    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
+    /// @return amountOut The amount of the received token
+    function swapExactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);
 
-  /// @dev Params for swapping exact output amount
-  /// @param tokenIn the token to swap
-  /// @param tokenOut the token to receive
-  /// @param fee the pool's fee
-  /// @param recipient address to receive tokenOut
-  /// @param deadline time that the transaction will be expired
-  /// @param amountOut the tokenOut amount of tokenOut
-  /// @param amountInMaximum the minimum input amount
-  /// @param limitSqrtP the price limit, if reached, stop swapping
-  struct ExactOutputSingleParams {
-    address tokenIn;
-    address tokenOut;
-    uint24 fee;
-    address recipient;
-    uint256 deadline;
-    uint256 amountOut;
-    uint256 maxAmountIn;
-    uint160 limitSqrtP;
-  }
+    /// @dev Params for swapping exact output amount
+    /// @param tokenIn the token to swap
+    /// @param tokenOut the token to receive
+    /// @param fee the pool's fee
+    /// @param recipient address to receive tokenOut
+    /// @param deadline time that the transaction will be expired
+    /// @param amountOut the tokenOut amount of tokenOut
+    /// @param amountInMaximum the minimum input amount
+    /// @param limitSqrtP the price limit, if reached, stop swapping
+    struct ExactOutputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint24 fee;
+        address recipient;
+        uint256 deadline;
+        uint256 amountOut;
+        uint256 maxAmountIn;
+        uint160 limitSqrtP;
+    }
 
-  /// @notice Swaps as little as possible of one token for `amountOut` of another token
-  /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
-  /// @return amountIn The amount of the input token
-  function swapExactOutputSingle(ExactOutputSingleParams calldata params)
-    external
-    payable
-    returns (uint256 amountIn);
+    /// @notice Swaps as little as possible of one token for `amountOut` of another token
+    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
+    /// @return amountIn The amount of the input token
+    function swapExactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
 
-  /// @dev Params for swapping exact output using multiple pools
-  /// @param path the encoded path to swap from tokenIn to tokenOut
-  ///   If the swap is from token0 -> token1 -> token2, then path is encoded as [token2, fee12, token1, fee01, token0]
-  /// @param recipient address to receive tokenOut
-  /// @param deadline time that the transaction will be expired
-  /// @param amountOut the tokenOut amount of tokenOut
-  /// @param amountInMaximum the minimum input amount
-  struct ExactOutputParams {
-    bytes path;
-    address recipient;
-    uint256 deadline;
-    uint256 amountOut;
-    uint256 maxAmountIn;
-  }
+    /// @dev Params for swapping exact output using multiple pools
+    /// @param path the encoded path to swap from tokenIn to tokenOut
+    ///   If the swap is from token0 -> token1 -> token2, then path is encoded as [token2, fee12, token1, fee01, token0]
+    /// @param recipient address to receive tokenOut
+    /// @param deadline time that the transaction will be expired
+    /// @param amountOut the tokenOut amount of tokenOut
+    /// @param amountInMaximum the minimum input amount
+    struct ExactOutputParams {
+        bytes path;
+        address recipient;
+        uint256 deadline;
+        uint256 amountOut;
+        uint256 maxAmountIn;
+    }
 
-  /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
-  /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
-  /// @return amountIn The amount of the input token
-  function swapExactOutput(ExactOutputParams calldata params)
-    external
-    payable
-    returns (uint256 amountIn);
+    /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
+    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
+    /// @return amountIn The amount of the input token
+    function swapExactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
 }

package/contracts/interfaces/Kyber/IKyberLiquidityMining.sol

@@ -41,23 +41,11 @@ interface IKyberLiquidityMining {
     event ActivateRange(uint256 indexed fId, uint256 rangeId);
     event ExpandEndTimeAndRewards(uint256 indexed fId, uint256 duration, uint256[] rewardAmounts);
 
-    event Deposit(
-        uint256 indexed fId,
-        uint256 rangeId,
-        uint256[] nftIds,
-        address indexed depositer,
-        address receiver
-    );
+    event Deposit(uint256 indexed fId, uint256 rangeId, uint256[] nftIds, address indexed depositer, address receiver);
     event UpdateLiquidity(uint256 indexed fId, uint256 nftId, uint256 liquidity);
     event Withdraw(uint256[] nftIds, address receiver);
     event WithdrawEmergency(uint256 nftId, address receiver);
-    event ClaimReward(
-        uint256 fId,
-        uint256[] nftIds,
-        address token,
-        uint256 amount,
-        address receiver
-    );
+    event ClaimReward(uint256 fId, uint256[] nftIds, address token, uint256 amount, address receiver);
 
     struct RangeInput {
         int24 tickLower;
@@ -120,12 +108,7 @@ interface IKyberLiquidityMining {
     /// @param fId farm's id
     /// @param rangeId rangeId to add, should use quoter to get best APR rangeId
     /// @param nftIds nfts to deposit
-    function deposit(
-        uint256 fId,
-        uint256 rangeId,
-        uint256[] memory nftIds,
-        address receiver
-    ) external;
+    function deposit(uint256 fId, uint256 rangeId, uint256[] memory nftIds, address receiver) external;
 
     /// @dev claim reward earned for nfts
     /// @param fId farm's id
@@ -191,7 +174,6 @@ interface IKyberLiquidityMining {
 
     function emergencyEnabled() external view returns (bool);
 
-
     // ======== view ============
 
     function getFarm(

package/contracts/interfaces/Kyber/IKyberPositionManager.sol

@@ -133,22 +133,11 @@ interface IKyberPositionManager {
 
     function mint(
         MintParams calldata params
-    )
-        external
-        payable
-        returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
+    ) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
 
     function addLiquidity(
         IncreaseLiquidityParams calldata params
-    )
-        external
-        payable
-        returns (
-            uint128 liquidity,
-            uint256 amount0,
-            uint256 amount1,
-            uint256 additionalRTokenOwed
-        );
+    ) external payable returns (uint128 liquidity, uint256 amount0, uint256 amount1, uint256 additionalRTokenOwed);
 
     function removeLiquidity(
         RemoveLiquidityParams calldata params
@@ -166,9 +155,7 @@ interface IKyberPositionManager {
 
     function syncFeeGrowth(uint256 tokenId) external returns (uint256 additionalRTokenOwed);
 
-    function positions(
-        uint256 tokenId
-    ) external view returns (Position memory pos, PoolInfo memory info);
+    function positions(uint256 tokenId) external view returns (Position memory pos, PoolInfo memory info);
 
     function addressToPoolId(address pool) external view returns (uint80);
 
@@ -188,9 +175,5 @@ interface IKyberPositionManager {
      */
     function supportsInterface(bytes4 interfaceId) external view returns (bool);
 
-    function transferAllTokens(
-        address token,
-        uint256 minAmount,
-        address recipient
-    ) external payable;
+    function transferAllTokens(address token, uint256 minAmount, address recipient) external payable;
 }

package/contracts/interfaces/Lybra/IEUSD.sol

@@ -10,4 +10,4 @@ interface IEUSD {
     function getMintedEUSDByShares(uint256 _sharesAmount) external view returns (uint256);
 
     function sharesOf(address _account) external view returns (uint256);
-}
+}

package/contracts/interfaces/MUX/IMUXRewardRouter.sol

@@ -0,0 +1,139 @@
+pragma solidity ^0.8.0;
+
+interface IMUXRewardRouter {
+    function vault() external view returns (address);
+
+    function weth() external view returns (address);
+
+    function mlp() external view returns (address);
+
+    function mcb() external view returns (address);
+
+    function mux() external view returns (address);
+
+    function votingEscrow() external view returns (address);
+
+    function mlpFeeTracker() external view returns (address);
+
+    function mlpMuxTracker() external view returns (address);
+
+    function veFeeTracker() external view returns (address);
+
+    function veMuxTracker() external view returns (address);
+
+    function mlpVester() external view returns (address);
+
+    function muxVester() external view returns (address);
+
+    function protocolLiquidityOwner() external view returns (address);
+
+    function mlpDistributor() external view returns (address);
+
+    function muxDistributor() external view returns (address);
+
+    function setProtocolLiquidityOwner(address _protocolLiquidityOwner) external;
+
+    function withdrawToken(address _token, address _account, uint256 _amount) external;
+
+    // ========================== aggregated staking interfaces ==========================
+    function claimableRewards(
+        address account
+    )
+        external
+        returns (
+            uint256 mlpFeeAmount,
+            uint256 mlpMuxAmount,
+            uint256 veFeeAmount,
+            uint256 veMuxAmount,
+            uint256 mcbAmount
+        );
+
+    function claimAll() external;
+
+    // ========================== mux & mcb staking interfaces ==========================
+    function batchStakeMuxForAccount(
+        address[] memory _accounts,
+        uint256[] memory _amounts,
+        uint256[] memory _unlockTime
+    ) external;
+
+    function stakeMcbForAccount(address _account, uint256 _amount) external;
+
+    function stakeMcb(uint256 _amount, uint256 lockPeriod) external;
+
+    function stakeMux(uint256 _amount, uint256 lockPeriod) external;
+
+    function increaseStakeUnlockTime(uint256 lockPeriod) external;
+
+    function unstakeMcbAndMux() external;
+
+    function stakeMlp(uint256 _amount) external returns (uint256);
+
+    function unstakeMlp(uint256 _amount) external returns (uint256);
+
+    // ========================== mlp staking interfaces ==========================
+
+    function maxVestableTokenFromMlp(address account) external view returns (uint256);
+
+    function totalVestedTokenFromMlp(address account) external view returns (uint256);
+
+    function claimedVestedTokenFromMlp(address account) external view returns (uint256);
+
+    function claimableVestedTokenFromMlp(address account) external view returns (uint256);
+
+    function depositToMlpVester(uint256 amount) external;
+
+    function withdrawFromMlpVester() external;
+
+    function claimFromMlp() external;
+
+    function claimVestedTokenFromMlp(address account) external returns (uint256);
+
+    // ========================== ve staking interfaces ==========================
+
+    function maxVestableTokenFromVe(address account) external view returns (uint256);
+
+    function totalVestedTokenFromVe(address account) external view returns (uint256);
+
+    function claimedVestedTokenFromVe(address account) external view returns (uint256);
+
+    function claimableVestedTokenFromVe(address account) external view returns (uint256);
+
+    function claimVestedTokenFromVe(address account) external returns (uint256);
+
+    function claimFromVe() external;
+
+    function depositToVeVester(uint256 amount) external;
+
+    function withdrawFromVeVester() external;
+
+    // ========================== staking status interfaces ==========================
+
+    function averageStakePeriod() external view returns (uint256);
+
+    function unlockTime(address account) external view returns (uint256);
+
+    function stakedMlpAmount(address account) external view returns (uint256);
+
+    function votingEscrowedAmounts(address account) external view returns (uint256, uint256);
+
+    function feeRewardRate() external view returns (uint256);
+
+    function muxRewardRate() external view returns (uint256);
+
+    function reservedMlpAmount(address account) external view returns (uint256);
+
+    function mlpLockAmount(address account, uint256 amount) external view returns (uint256);
+
+    function poolOwnedRate() external view returns (uint256);
+
+    function votingEscrowedRate() external view returns (uint256);
+
+    // ========================== reserved interfaces ==========================
+
+    function compound() external;
+
+    function compoundForAccount(address _account) external;
+
+    function batchCompoundForAccounts(address[] memory _accounts) external;
+}