@pendle/core-v2 3.0.0-beta-10 → 3.0.0-beta-12

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

package/contracts/interfaces/Silo/ISilo.sol

@@ -0,0 +1,298 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+interface ISilo {
+    enum AssetStatus {
+        Undefined,
+        Active,
+        Removed
+    }
+
+    /// @dev Storage struct that holds all required data for a single token market
+    struct AssetStorage {
+        /// @dev Token that represents a share in totalDeposits of Silo
+        address collateralToken;
+        /// @dev Token that represents a share in collateralOnlyDeposits of Silo
+        address collateralOnlyToken;
+        /// @dev Token that represents a share in totalBorrowAmount of Silo
+        address debtToken;
+        /// @dev COLLATERAL: Amount of asset token that has been deposited to Silo with interest earned by depositors.
+        /// It also includes token amount that has been borrowed.
+        uint256 totalDeposits;
+        /// @dev COLLATERAL ONLY: Amount of asset token that has been deposited to Silo that can be ONLY used
+        /// as collateral. These deposits do NOT earn interest and CANNOT be borrowed.
+        uint256 collateralOnlyDeposits;
+        /// @dev DEBT: Amount of asset token that has been borrowed with accrued interest.
+        uint256 totalBorrowAmount;
+    }
+
+    /// @dev Storage struct that holds data related to fees and interest
+    struct AssetInterestData {
+        /// @dev Total amount of already harvested protocol fees
+        uint256 harvestedProtocolFees;
+        /// @dev Total amount (ever growing) of asset token that has been earned by the protocol from
+        /// generated interest.
+        uint256 protocolFees;
+        /// @dev Timestamp of the last time `interestRate` has been updated in storage.
+        uint64 interestRateTimestamp;
+        /// @dev True if asset was removed from the protocol. If so, deposit and borrow functions are disabled
+        /// for that asset
+        AssetStatus status;
+    }
+
+    /// @notice data that InterestModel needs for calculations
+    struct UtilizationData {
+        uint256 totalDeposits;
+        uint256 totalBorrowAmount;
+        /// @dev timestamp of last interest accrual
+        uint64 interestRateTimestamp;
+    }
+
+    /// @dev Shares names and symbols that are generated while asset initialization
+    struct AssetSharesMetadata {
+        /// @dev Name for the collateral shares token
+        string collateralName;
+        /// @dev Symbol for the collateral shares token
+        string collateralSymbol;
+        /// @dev Name for the collateral only (protected collateral) shares token
+        string protectedName;
+        /// @dev Symbol for the collateral only (protected collateral) shares token
+        string protectedSymbol;
+        /// @dev Name for the debt shares token
+        string debtName;
+        /// @dev Symbol for the debt shares token
+        string debtSymbol;
+    }
+
+    /// @notice Emitted when deposit is made
+    /// @param asset asset address that was deposited
+    /// @param depositor wallet address that deposited asset
+    /// @param amount amount of asset that was deposited
+    /// @param collateralOnly type of deposit, true if collateralOnly deposit was used
+    event Deposit(address indexed asset, address indexed depositor, uint256 amount, bool collateralOnly);
+
+    /// @notice Emitted when withdraw is made
+    /// @param asset asset address that was withdrawn
+    /// @param depositor wallet address that deposited asset
+    /// @param receiver wallet address that received asset
+    /// @param amount amount of asset that was withdrew
+    /// @param collateralOnly type of withdraw, true if collateralOnly deposit was used
+    event Withdraw(
+        address indexed asset,
+        address indexed depositor,
+        address indexed receiver,
+        uint256 amount,
+        bool collateralOnly
+    );
+
+    /// @notice Emitted on asset borrow
+    /// @param asset asset address that was borrowed
+    /// @param user wallet address that borrowed asset
+    /// @param amount amount of asset that was borrowed
+    event Borrow(address indexed asset, address indexed user, uint256 amount);
+
+    /// @notice Emitted on asset repay
+    /// @param asset asset address that was repaid
+    /// @param user wallet address that repaid asset
+    /// @param amount amount of asset that was repaid
+    event Repay(address indexed asset, address indexed user, uint256 amount);
+
+    /// @notice Emitted on user liquidation
+    /// @param asset asset address that was liquidated
+    /// @param user wallet address that was liquidated
+    /// @param shareAmountRepaid amount of collateral-share token that was repaid. This is collateral token representing
+    /// ownership of underlying deposit.
+    /// @param seizedCollateral amount of underlying token that was seized by liquidator
+    event Liquidate(address indexed asset, address indexed user, uint256 shareAmountRepaid, uint256 seizedCollateral);
+
+    /// @notice Emitted when the status for an asset is updated
+    /// @param asset asset address that was updated
+    /// @param status new asset status
+    event AssetStatusUpdate(address indexed asset, AssetStatus indexed status);
+
+    /// @return version of the silo contract
+    function VERSION() external returns (uint128); // solhint-disable-line func-name-mixedcase
+
+    /// @notice Synchronize current bridge assets with Silo
+    /// @dev This function needs to be called on Silo deployment to setup all assets for Silo. It needs to be
+    /// called every time a bridged asset is added or removed. When bridge asset is removed, depositing and borrowing
+    /// should be disabled during asset sync.
+    function syncBridgeAssets() external;
+
+    /// @notice Get Silo Repository contract address
+    /// @return Silo Repository contract address
+    function siloRepository() external view returns (address);
+
+    /// @notice Get asset storage data
+    /// @param _asset asset address
+    /// @return AssetStorage struct
+    function assetStorage(address _asset) external view returns (AssetStorage memory);
+
+    /// @notice Get asset interest data
+    /// @param _asset asset address
+    /// @return AssetInterestData struct
+    function interestData(address _asset) external view returns (AssetInterestData memory);
+
+    /// @dev helper method for InterestRateModel calculations
+    function utilizationData(address _asset) external view returns (UtilizationData memory data);
+
+    /// @notice Calculates solvency of an account
+    /// @param _user wallet address for which solvency is calculated
+    /// @return true if solvent, false otherwise
+    function isSolvent(address _user) external view returns (bool);
+
+    /// @notice Returns all initialized (synced) assets of Silo including current and removed bridge assets
+    /// @return assets array of initialized assets of Silo
+    function getAssets() external view returns (address[] memory assets);
+
+    /// @notice Returns all initialized (synced) assets of Silo including current and removed bridge assets
+    /// with corresponding state
+    /// @return assets array of initialized assets of Silo
+    /// @return assetsStorage array of assets state corresponding to `assets` array
+    function getAssetsWithState() external view returns (address[] memory assets, AssetStorage[] memory assetsStorage);
+
+    /// @notice Check if depositing an asset for given account is possible
+    /// @dev Depositing an asset that has been already borrowed (and vice versa) is disallowed
+    /// @param _asset asset we want to deposit
+    /// @param _depositor depositor address
+    /// @return true if asset can be deposited by depositor
+    function depositPossible(address _asset, address _depositor) external view returns (bool);
+
+    /// @notice Check if borrowing an asset for given account is possible
+    /// @dev Borrowing an asset that has been already deposited (and vice versa) is disallowed
+    /// @param _asset asset we want to deposit
+    /// @param _borrower borrower address
+    /// @return true if asset can be borrowed by borrower
+    function borrowPossible(address _asset, address _borrower) external view returns (bool);
+
+    /// @dev Amount of token that is available for borrowing
+    /// @param _asset asset to get liquidity for
+    /// @return Silo liquidity
+    function liquidity(address _asset) external view returns (uint256);
+
+    /// @notice Deposit `_amount` of `_asset` tokens from `msg.sender` to the Silo
+    /// @param _asset The address of the token to deposit
+    /// @param _amount The amount of the token to deposit
+    /// @param _collateralOnly True if depositing collateral only
+    /// @return collateralAmount deposited amount
+    /// @return collateralShare user collateral shares based on deposited amount
+    function deposit(
+        address _asset,
+        uint256 _amount,
+        bool _collateralOnly
+    ) external returns (uint256 collateralAmount, uint256 collateralShare);
+
+    /// @notice Router function to deposit `_amount` of `_asset` tokens to the Silo for the `_depositor`
+    /// @param _asset The address of the token to deposit
+    /// @param _depositor The address of the recipient of collateral tokens
+    /// @param _amount The amount of the token to deposit
+    /// @param _collateralOnly True if depositing collateral only
+    /// @return collateralAmount deposited amount
+    /// @return collateralShare `_depositor` collateral shares based on deposited amount
+    function depositFor(
+        address _asset,
+        address _depositor,
+        uint256 _amount,
+        bool _collateralOnly
+    ) external returns (uint256 collateralAmount, uint256 collateralShare);
+
+    /// @notice Withdraw `_amount` of `_asset` tokens from the Silo to `msg.sender`
+    /// @param _asset The address of the token to withdraw
+    /// @param _amount The amount of the token to withdraw
+    /// @param _collateralOnly True if withdrawing collateral only deposit
+    /// @return withdrawnAmount withdrawn amount that was transferred to user
+    /// @return withdrawnShare burned share based on `withdrawnAmount`
+    function withdraw(
+        address _asset,
+        uint256 _amount,
+        bool _collateralOnly
+    ) external returns (uint256 withdrawnAmount, uint256 withdrawnShare);
+
+    /// @notice Router function to withdraw `_amount` of `_asset` tokens from the Silo for the `_depositor`
+    /// @param _asset The address of the token to withdraw
+    /// @param _depositor The address that originally deposited the collateral tokens being withdrawn,
+    /// it should be the one initiating the withdrawal through the router
+    /// @param _receiver The address that will receive the withdrawn tokens
+    /// @param _amount The amount of the token to withdraw
+    /// @param _collateralOnly True if withdrawing collateral only deposit
+    /// @return withdrawnAmount withdrawn amount that was transferred to `_receiver`
+    /// @return withdrawnShare burned share based on `withdrawnAmount`
+    function withdrawFor(
+        address _asset,
+        address _depositor,
+        address _receiver,
+        uint256 _amount,
+        bool _collateralOnly
+    ) external returns (uint256 withdrawnAmount, uint256 withdrawnShare);
+
+    /// @notice Borrow `_amount` of `_asset` tokens from the Silo to `msg.sender`
+    /// @param _asset The address of the token to borrow
+    /// @param _amount The amount of the token to borrow
+    /// @return debtAmount borrowed amount
+    /// @return debtShare user debt share based on borrowed amount
+    function borrow(address _asset, uint256 _amount) external returns (uint256 debtAmount, uint256 debtShare);
+
+    /// @notice Router function to borrow `_amount` of `_asset` tokens from the Silo for the `_receiver`
+    /// @param _asset The address of the token to borrow
+    /// @param _borrower The address that will take the loan,
+    /// it should be the one initiating the borrowing through the router
+    /// @param _receiver The address of the asset receiver
+    /// @param _amount The amount of the token to borrow
+    /// @return debtAmount borrowed amount
+    /// @return debtShare `_receiver` debt share based on borrowed amount
+    function borrowFor(
+        address _asset,
+        address _borrower,
+        address _receiver,
+        uint256 _amount
+    ) external returns (uint256 debtAmount, uint256 debtShare);
+
+    /// @notice Repay `_amount` of `_asset` tokens from `msg.sender` to the Silo
+    /// @param _asset The address of the token to repay
+    /// @param _amount amount of asset to repay, includes interests
+    /// @return repaidAmount amount repaid
+    /// @return burnedShare burned debt share
+    function repay(address _asset, uint256 _amount) external returns (uint256 repaidAmount, uint256 burnedShare);
+
+    /// @notice Allows to repay in behalf of borrower to execute liquidation
+    /// @param _asset The address of the token to repay
+    /// @param _borrower The address of the user to have debt tokens burned
+    /// @param _amount amount of asset to repay, includes interests
+    /// @return repaidAmount amount repaid
+    /// @return burnedShare burned debt share
+    function repayFor(
+        address _asset,
+        address _borrower,
+        uint256 _amount
+    ) external returns (uint256 repaidAmount, uint256 burnedShare);
+
+    /// @dev harvest protocol fees from an array of assets
+    /// @return harvestedAmounts amount harvested during tx execution for each of silo asset
+    function harvestProtocolFees() external returns (uint256[] memory harvestedAmounts);
+
+    /// @notice Function to update interests for `_asset` token since the last saved state
+    /// @param _asset The address of the token to be updated
+    /// @return interest accrued interest
+    function accrueInterest(address _asset) external returns (uint256 interest);
+
+    /// @notice this methods does not requires to have tokens in order to liquidate user
+    /// @dev during liquidation process, msg.sender will be notified once all collateral will be send to him
+    /// msg.sender needs to be `IFlashLiquidationReceiver`
+    /// @param _users array of users to liquidate
+    /// @param _flashReceiverData this data will be forward to msg.sender on notification
+    /// @return assets array of all processed assets (collateral + debt, including removed)
+    /// @return receivedCollaterals receivedCollaterals[userId][assetId] => amount
+    /// amounts of collaterals send to `_flashReceiver`
+    /// @return shareAmountsToRepaid shareAmountsToRepaid[userId][assetId] => amount
+    /// required amounts of debt to be repaid
+    function flashLiquidate(
+        address[] memory _users,
+        bytes memory _flashReceiverData
+    )
+        external
+        returns (
+            address[] memory assets,
+            uint256[][] memory receivedCollaterals,
+            uint256[][] memory shareAmountsToRepaid
+        );
+}

package/contracts/interfaces/Silo/ISiloIncentiveController.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity ^0.8.0;
+
+interface ISiloIncentiveController {
+    /**
+     * @dev Claims reward for msg.sender, on all the assets of the lending pool, accumulating the pending rewards
+     * @param amount Amount of rewards to claim
+     * @return Rewards claimed
+     */
+    function claimRewardsToSelf(address[] calldata assets, uint256 amount) external returns (uint256);
+
+    /**
+     * @dev for backward compatibility with previous implementation of the Incentives controller
+     */
+    function REWARD_TOKEN() external view returns (address); // solhint-disable-line func-name-mixedcase
+}

package/contracts/interfaces/Silo/ISiloLens.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity ^0.8.0;
+
+interface ISiloLens {
+    function totalDepositsWithInterest(address _silo, address _asset) external view returns (uint256 _totalDeposits);
+}

package/contracts/interfaces/Stader/IStaderStakeManager.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 interface IStaderStakeManager {
     // Errors
@@ -54,4 +54,4 @@ interface IStaderStakeManager {
     function depositETHOverTargetWeight() external;
 
     function isVaultHealthy() external view returns (bool);
-}
+}

package/contracts/interfaces/Thena/IThenaFactory.sol

@@ -13,11 +13,7 @@ interface IThenaFactory {
 
     function getPair(address tokenA, address token, bool stable) external view returns (address);
 
-    function createPair(
-        address tokenA,
-        address tokenB,
-        bool stable
-    ) external returns (address pair);
+    function createPair(address tokenA, address tokenB, bool stable) external returns (address pair);
 
     function getFee(bool _stable) external view returns (uint256);
 }