@pendle/core-v2 5.2.2 → 5.2.3-beta

package/contracts/interfaces/Kyber/IKyberElasticPool.sol

@@ -1,101 +0,0 @@
-// 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

@@ -1,98 +0,0 @@
-// 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

@@ -1,209 +0,0 @@
-// 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

@@ -1,28 +0,0 @@
-// 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

@@ -1,179 +0,0 @@
-// 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

@@ -1,12 +0,0 @@
-// 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

@@ -1,13 +0,0 @@
-// 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);
-}