@pendle/core-v2 5.2.3-beta → 5.2.3

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);
+}

package/contracts/interfaces/Kyber/IKyberElasticRouter.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.8.0;
+
+/// @notice Functions for swapping tokens via KyberSwap v2
+/// - Support swap with exact input or exact output
+/// - 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;
+    }
+
+    /// @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;
+    }
+
+    /// @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;
+    }
+
+    /// @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;
+    }
+
+    /// @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

@@ -0,0 +1,209 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.8.0;
+
+interface IKyberLiquidityMining {
+    error Forbidden();
+    error EmergencyEnabled();
+
+    error InvalidRange();
+    error InvalidTime();
+    error InvalidReward();
+
+    error PositionNotEligible();
+    error FarmNotFound();
+    error InvalidFarm();
+    error NotOwner();
+    error StakeNotFound();
+    error RangeNotMatch();
+    error RangeNotFound();
+    error PhaseSettled();
+    error InvalidInput();
+    error LiquidityNotMatch();
+    error FailToAdd();
+    error FailToRemove();
+    error Expired();
+
+    event UpdateEmergency(bool enableOrDisable);
+    event UpdateTokenCode(bytes farmingTokenCode);
+    event WithdrawUnusedRewards(address token, uint256 amount, address receiver);
+
+    event AddFarm(
+        uint256 indexed fId,
+        address poolAddress,
+        RangeInput[] ranges,
+        PhaseInput phase,
+        address farmingToken
+    );
+    event AddPhase(uint256 indexed fId, PhaseInput phase);
+    event ForceClosePhase(uint256 indexed fId);
+    event AddRange(uint256 indexed fId, RangeInput range);
+    event RemoveRange(uint256 indexed fId, uint256 rangeId);
+    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 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);
+
+    struct RangeInput {
+        int24 tickLower;
+        int24 tickUpper;
+        uint32 weight;
+    }
+
+    struct RewardInput {
+        address rewardToken;
+        uint256 rewardAmount;
+    }
+
+    struct PhaseInput {
+        uint32 startTime;
+        uint32 endTime;
+        RewardInput[] rewards;
+    }
+
+    struct RemoveLiquidityInput {
+        uint256 nftId;
+        uint128 liquidity;
+    }
+
+    struct RangeInfo {
+        int24 tickLower;
+        int24 tickUpper;
+        uint32 weight;
+        bool isRemoved;
+    }
+
+    struct PhaseInfo {
+        uint32 startTime;
+        uint32 endTime;
+        bool isSettled;
+        RewardInput[] rewards;
+    }
+
+    struct FarmInfo {
+        address poolAddress;
+        RangeInfo[] ranges;
+        PhaseInfo phase;
+        uint256 liquidity;
+        address farmingToken;
+        uint256[] sumRewardPerLiquidity;
+        uint32 lastTouchedTime;
+    }
+
+    struct StakeInfo {
+        address owner;
+        uint256 fId;
+        uint256 rangeId;
+        uint256 liquidity;
+        uint256[] lastSumRewardPerLiquidity;
+        uint256[] rewardUnclaimed;
+    }
+
+    // ======== user ============
+    /// @dev deposit nfts to farm
+    /// @dev store curRewardPerLiq now to stake info, mint an amount of farmingToken (if needed) to msg.sender
+    /// @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;
+
+    /// @dev claim reward earned for nfts
+    /// @param fId farm's id
+    /// @param nftIds nfts to claim
+    function claimReward(uint256 fId, uint256[] memory nftIds) external;
+
+    /// @dev withdraw nfts from farm
+    /// @dev only can call by nfts's owner, also claim reward earned
+    /// @dev burn an amount of farmingToken (if needed) from msg.sender
+    /// @param fId farm's id
+    /// @param nftIds nfts to withdraw
+    function withdraw(uint256 fId, uint256[] memory nftIds) external;
+
+    /// @dev add liquidity of nfts when liquidity already added on Elastic Pool
+    /// @dev only can call by nfts's owner
+    /// @dev calculate reward earned, update stakeInfo, mint an amount of farmingToken to msg.sender
+    /// @param fId farm's id
+    /// @param rangeId rangeId of deposited nfts
+    /// @param nftIds nfts to add liquidity
+    function addLiquidity(uint256 fId, uint256 rangeId, uint256[] calldata nftIds) external;
+
+    /// @dev remove liquidity of nfts from Elastic Pool
+    /// @dev only can call by nfts's owner
+    /// @dev calculate reward earned, update stakeInfo, mint/burn an amount of farmingToken
+    /// @param nftId id of nft to remove liquidity
+    /// @param liquidity amount to remove from nft
+    /// @param amount0Min min amount of token0 should receive
+    /// @param amount1Min min amount of token1 should receive
+    /// @param deadline deadline of remove liquidity tx
+    /// @param isClaimFee is also burnRTokens or not
+    function removeLiquidity(
+        uint256 nftId,
+        uint128 liquidity,
+        uint256 amount0Min,
+        uint256 amount1Min,
+        uint256 deadline,
+        bool isClaimFee,
+        bool isReceiveNative
+    ) external;
+
+    /// @dev claim fee from Elastic Pool
+    /// @dev only can call by nfts's owner
+    /// @param fId farm's id
+    /// @param nftIds nfts to claim
+    /// @param amount0Min min amount of token0 should receive
+    /// @param amount1Min min amount of token1 should receive
+    /// @param deadline deadline of remove liquidity tx
+    function claimFee(
+        uint256 fId,
+        uint256[] calldata nftIds,
+        uint256 amount0Min,
+        uint256 amount1Min,
+        uint256 deadline,
+        bool isReceiveNative
+    ) external;
+
+    /// @dev withdraw nfts in case emergency
+    /// @dev only can call by nfts's owner
+    /// @dev in normal case, abandon all rewards, must return farmingToken
+    /// @dev incase emergencyEnabled, bypass all calculation
+    /// @param nftIds nfts to withdraw
+    function withdrawEmergency(uint256[] calldata nftIds) external;
+
+    function emergencyEnabled() external view returns (bool);
+
+    // ======== view ============
+
+    function getFarm(
+        uint256 fId
+    )
+        external
+        view
+        returns (
+            address poolAddress,
+            RangeInfo[] memory ranges,
+            PhaseInfo memory phase,
+            uint256 liquidity,
+            address farmingToken,
+            uint256[] memory sumRewardPerLiquidity,
+            uint32 lastTouchedTime
+        );
+
+    function getDepositedNFTs(address user) external view returns (uint256[] memory listNFTs);
+
+    function getStake(
+        uint256 nftId
+    )
+        external
+        view
+        returns (
+            address owner,
+            uint256 fId,
+            uint256 rangeId,
+            uint256 liquidity,
+            uint256[] memory lastSumRewardPerLiquidity,
+            uint256[] memory rewardUnclaimeds
+        );
+}

package/contracts/interfaces/Kyber/IKyberMathHelper.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+interface IKyberMathHelper {
+    function getSingleSidedSwapAmount(
+        address kyberPool,
+        uint256 startAmount,
+        bool isToken0,
+        int24 tickLower,
+        int24 tickUpper
+    ) external view returns (uint256 amountToSwap);
+
+    function previewDeposit(
+        address kyberPool,
+        int24 tickLower,
+        int24 tickUpper,
+        bool isToken0,
+        uint256 amountIn
+    ) external view returns (uint256);
+
+    function previewRedeem(
+        address kyberPool,
+        int24 tickLower,
+        int24 tickUpper,
+        bool isToken0,
+        uint256 amountShares
+    ) external view returns (uint256);
+}

package/contracts/interfaces/Kyber/IKyberPositionManager.sol

@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.8.0;
+
+interface IKyberPositionManager {
+    event MintPosition(
+        uint256 indexed tokenId,
+        uint80 indexed poolId,
+        uint128 liquidity,
+        uint256 amount0,
+        uint256 amount1
+    );
+
+    event RemoveLiquidity(
+        uint256 indexed tokenId,
+        uint128 liquidity,
+        uint256 amount0,
+        uint256 amount1,
+        uint256 additionalRTokenOwed
+    );
+
+    struct Position {
+        // the nonce for permits
+        uint96 nonce;
+        // the address that is approved for spending this token
+        address operator;
+        // the ID of the pool with which this token is connected
+        uint80 poolId;
+        // the tick range of the position
+        int24 tickLower;
+        int24 tickUpper;
+        // the liquidity of the position
+        uint128 liquidity;
+        // the current rToken that the position owed
+        uint256 rTokenOwed;
+        // fee growth per unit of liquidity as of the last update to liquidity
+        uint256 feeGrowthInsideLast;
+    }
+
+    struct PoolInfo {
+        address token0;
+        uint24 fee;
+        address token1;
+    }
+
+    /// @notice Params for the first time adding liquidity, mint new nft to sender
+    /// @param token0 the token0 of the pool
+    /// @param token1 the token1 of the pool
+    ///   - must make sure that token0 < token1
+    /// @param fee the pool's fee in fee units
+    /// @param tickLower the position's lower tick
+    /// @param tickUpper the position's upper tick
+    ///   - must make sure tickLower < tickUpper, and both are in tick distance
+    /// @param ticksPrevious the nearest tick that has been initialized and lower than or equal to
+    ///   the tickLower and tickUpper, use to help insert the tickLower and tickUpper if haven't initialized
+    /// @param amount0Desired the desired amount for token0
+    /// @param amount1Desired the desired amount for token1
+    /// @param amount0Min min amount of token 0 to add
+    /// @param amount1Min min amount of token 1 to add
+    /// @param recipient the owner of the position
+    /// @param deadline time that the transaction will be expired
+    struct MintParams {
+        address token0;
+        address token1;
+        uint24 fee;
+        int24 tickLower;
+        int24 tickUpper;
+        int24[2] ticksPrevious;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        address recipient;
+        uint256 deadline;
+    }
+
+    /// @notice Params for adding liquidity to the existing position
+    /// @param tokenId id of the position to increase its liquidity
+    /// @param ticksPrevious the nearest tick that has been initialized and lower than or equal to
+    ///   the tickLower and tickUpper, use to help insert the tickLower and tickUpper if haven't initialized
+    ///   only needed if the position has been closed and the owner wants to add more liquidity
+    /// @param amount0Desired the desired amount for token0
+    /// @param amount1Desired the desired amount for token1
+    /// @param amount0Min min amount of token 0 to add
+    /// @param amount1Min min amount of token 1 to add
+    /// @param deadline time that the transaction will be expired
+    struct IncreaseLiquidityParams {
+        uint256 tokenId;
+        int24[2] ticksPrevious;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    /// @notice Params for remove liquidity from the existing position
+    /// @param tokenId id of the position to remove its liquidity
+    /// @param amount0Min min amount of token 0 to receive
+    /// @param amount1Min min amount of token 1 to receive
+    /// @param deadline time that the transaction will be expired
+    struct RemoveLiquidityParams {
+        uint256 tokenId;
+        uint128 liquidity;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    /// @notice Burn the rTokens to get back token0 + token1 as fees
+    /// @param tokenId id of the position to burn r token
+    /// @param amount0Min min amount of token 0 to receive
+    /// @param amount1Min min amount of token 1 to receive
+    /// @param deadline time that the transaction will be expired
+    struct BurnRTokenParams {
+        uint256 tokenId;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    /// @notice Creates a new pool if it does not exist, then unlocks if it has not been unlocked
+    /// @param token0 the token0 of the pool
+    /// @param token1 the token1 of the pool
+    /// @param fee the fee for the pool
+    /// @param currentSqrtP the initia'l price of the pool
+    /// @return pool returns the pool address
+    function createAndUnlockPoolIfNecessary(
+        address token0,
+        address token1,
+        uint24 fee,
+        uint160 currentSqrtP
+    ) external payable returns (address pool);
+
+    function mint(
+        MintParams calldata params
+    ) 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);
+
+    function removeLiquidity(
+        RemoveLiquidityParams calldata params
+    ) external returns (uint256 amount0, uint256 amount1, uint256 additionalRTokenOwed);
+
+    function burnRTokens(
+        BurnRTokenParams calldata params
+    ) external returns (uint256 rTokenQty, uint256 amount0, uint256 amount1);
+
+    /**
+     * @dev Burn the token by its owner
+     * @notice All liquidity should be removed before burning
+     */
+    function burn(uint256 tokenId) external payable;
+
+    function syncFeeGrowth(uint256 tokenId) external returns (uint256 additionalRTokenOwed);
+
+    function positions(uint256 tokenId) external view returns (Position memory pos, PoolInfo memory info);
+
+    function addressToPoolId(address pool) external view returns (uint80);
+
+    function isRToken(address token) external view returns (bool);
+
+    function nextPoolId() external view returns (uint80);
+
+    function nextTokenId() external view returns (uint256);
+
+    /**
+     * @dev Returns true if this contract implements the interface defined by
+     * `interfaceId`. See the corresponding
+     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
+     * to learn more about how these ids are created.
+     *
+     * This function call must use less than 30 000 gas.
+     */
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+
+    function transferAllTokens(address token, uint256 minAmount, address recipient) external payable;
+}

package/contracts/interfaces/Lombard/ILBTCMinterBase.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+interface ILBTCMinterBase {
+    function swapCBBTCToLBTC(uint256 amount) external;
+
+    function relativeFee() external view returns (uint16);
+
+    function remainingStake() external view returns (uint256);
+
+    function stakeLimit() external view returns (uint256);
+}

package/contracts/interfaces/Lybra/IEUSD.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface IEUSD {
+    function transferShares(address _recipient, uint256 _sharesAmount) external returns (uint256);
+
+    function getSharesByMintedEUSD(uint256 _EUSDAmount) external view returns (uint256);
+
+    function getMintedEUSDByShares(uint256 _sharesAmount) external view returns (uint256);
+
+    function sharesOf(address _account) external view returns (uint256);
+}