@pendle/core-v2 5.2.3-beta-2 → 5.2.4

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/Sky/ISkyConverter.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+interface ISkyConverter {
+    function daiToUsds(address usr, uint256 wad) external;
+
+    function usdsToDai(address usr, uint256 wad) external;
+}

package/contracts/interfaces/Sky/ISkyStaking.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+interface ISkyStaking {
+    function stake(uint256 amount) external;
+
+    function withdraw(uint256 amount) external;
+
+    function getReward() external;
+}

package/contracts/interfaces/Solv/ISolvERC3525.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISolvERC3525 {
+    /**
+     * @notice Get the number of decimals the token uses for value - e.g. 6, means the user
+     *  representation of the value of a token can be calculated by dividing it by 1,000,000.
+     *  Considering the compatibility with third-party wallets, this function is defined as
+     *  `valueDecimals()` instead of `decimals()` to avoid conflict with ERC20 tokens.
+     * @return The number of decimals for value
+     */
+    function valueDecimals() external view returns (uint8);
+}

package/contracts/interfaces/Solv/ISolvOpenFundMarket.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISolvOpenFundMarket {
+    struct SFTInfo {
+        address manager;
+        bool isValid;
+    }
+    struct SubscribeLimitInfo {
+        uint256 hardCap;
+        uint256 subscribeMin;
+        uint256 subscribeMax;
+        uint64 fundraisingStartTime;
+        uint64 fundraisingEndTime;
+    }
+    struct PoolSFTInfo {
+        address openFundShare;
+        address openFundRedemption;
+        uint256 openFundShareSlot;
+        uint256 latestRedeemSlot;
+    }
+    struct PoolFeeInfo {
+        uint16 carryRate;
+        address carryCollector;
+        uint64 latestProtocolFeeSettleTime;
+    }
+    struct ManagerInfo {
+        address poolManager;
+        address subscribeNavManager;
+        address redeemNavManager;
+    }
+    struct PoolInfo {
+        PoolSFTInfo poolSFTInfo;
+        PoolFeeInfo poolFeeInfo;
+        ManagerInfo managerInfo;
+        SubscribeLimitInfo subscribeLimitInfo;
+        address vault;
+        address currency;
+        address navOracle;
+        uint64 valueDate;
+        bool permissionless;
+        uint256 fundraisingAmount;
+    }
+
+    function poolInfos(bytes32) external view returns (PoolInfo memory);
+}

package/contracts/interfaces/Solv/ISolvOracle.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface ISolvOracle {
+    function setSubscribeNavOnlyMarket(bytes32 poolId_, uint256 time_, uint256 nav_) external;
+    function updateAllTimeHighRedeemNavOnlyMarket(bytes32 poolId_, uint256 nav_) external;
+    function getSubscribeNav(bytes32 poolId_, uint256 time_) external view returns (uint256 nav_, uint256 navTime_);
+    function getAllTimeHighRedeemNav(bytes32 poolId_) external view returns (uint256);
+}

package/contracts/interfaces/Solv/ISolvRouter.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISolvRouter {
+    function createSubscription(bytes32 poolId_, uint256 currencyAmount_) external returns (uint256 shareValue_);
+}

package/contracts/interfaces/Sophon/IPSophonPointManager.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPSophonPointManager {
+    function claimPointReceiptToken() external;
+}

package/contracts/interfaces/Sophon/ISophonFarming.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISophonFarming {
+    function pendingPoints(uint256 _pid, address _user) external view returns (uint256);
+
+    function transferPoints(uint256 _pid, address _sender, address _receiver, uint256 _transferAmount) external;
+
+    function poolInfo(
+        uint256 _pid
+    )
+        external
+        view
+        returns (address, address, uint256, uint256, uint256, uint256, uint256, uint256, uint256, string memory);
+
+    function deposit(uint256 _pid, uint256 _amount, uint256 _boostAmount) external;
+
+    function withdraw(uint256 _pid, uint256 _withdrawAmount) external;
+}

package/contracts/interfaces/Stader/IStaderStakeManager.sol

@@ -0,0 +1,57 @@
+pragma solidity ^0.8.17;
+
+interface IStaderStakeManager {
+    // Errors
+    error InvalidDepositAmount();
+    error UnsupportedOperation();
+    error InsufficientBalance();
+    error TransferFailed();
+    error PoolIdDoesNotExit();
+    error CooldownNotComplete();
+    error UnsupportedOperationInSafeMode();
+
+    // Events
+    event UpdatedStaderConfig(address staderConfig);
+    event Deposited(address indexed caller, address indexed owner, uint256 assets, uint256 shares);
+    event ExecutionLayerRewardsReceived(uint256 amount);
+    event AuctionedEthReceived(uint256 amount);
+    event ReceivedExcessEthFromPool(uint8 indexed poolId);
+    event TransferredETHToUserWithdrawManager(uint256 amount);
+    event ETHTransferredToPool(uint256 indexed poolId, address poolAddress, uint256 validatorCount);
+    event WithdrawVaultUserShareReceived(uint256 amount);
+    event UpdatedExcessETHDepositCoolDown(uint256 excessETHDepositCoolDown);
+
+    function deposit(address _receiver) external payable returns (uint256);
+
+    function previewDeposit(uint256 _assets) external view returns (uint256);
+
+    function previewWithdraw(uint256 _shares) external view returns (uint256);
+
+    function getExchangeRate() external view returns (uint256);
+
+    function totalAssets() external view returns (uint256);
+
+    function convertToShares(uint256 _assets) external view returns (uint256);
+
+    function convertToAssets(uint256 _shares) external view returns (uint256);
+
+    function maxDeposit() external view returns (uint256);
+
+    function minDeposit() external view returns (uint256);
+
+    function receiveExecutionLayerRewards() external payable;
+
+    function receiveWithdrawVaultUserShare() external payable;
+
+    function receiveEthFromAuction() external payable;
+
+    function receiveExcessEthFromPool(uint8 _poolId) external payable;
+
+    function transferETHToUserWithdrawManager(uint256 _amount) external;
+
+    function validatorBatchDeposit(uint8 _poolId) external;
+
+    function depositETHOverTargetWeight() external;
+
+    function isVaultHealthy() external view returns (bool);
+}

package/contracts/interfaces/Swell/IRswETH.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IRswETH {
+    function deposit() external payable;
+
+    function depositWithReferral(address referral) external payable;
+
+    function getRate() external view returns (uint256);
+}

package/contracts/interfaces/Swell/ISwETH.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISwETH {
+    function deposit() external payable;
+
+    function depositWithReferral(address referral) external payable;
+
+    function getRate() external view returns (uint256);
+}

package/contracts/interfaces/Swell/ISwellSimpleStakingERC20.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+interface ISwellSimpleStakingERC20 {
+    /// @notice Struct to hold the supported booleans
+    /// @param deposit true if deposit is supported
+    /// @param withdraw true if withdraw is supported
+    struct Supported {
+        bool deposit;
+        bool withdraw;
+    }
+
+    /// @notice Error emitted when the amount is null
+    error AMOUNT_NULL();
+
+    /// @notice Error emitted when the address is null
+    error ADDRESS_NULL();
+
+    /// @notice Error emitted when the balance is insufficient
+    error INSUFFICIENT_BALANCE();
+
+    /// @notice Error emitted when the token is not allowed
+    error TOKEN_NOT_ALLOWED(address token);
+
+    /// @notice Event emitted when a token is added or removed
+    /// @param token address of the token
+    /// @param supported struct with deposit and withdraw booleans
+    event SupportedToken(address indexed token, Supported supported);
+
+    /// @notice Event emitted when a deposit is made
+    /// @param token address of the token
+    /// @param staker address of the staker
+    /// @param amount amount of the deposit
+    event Deposit(address indexed token, address indexed staker, uint256 amount);
+
+    /// @notice Event emitted when a withdrawal is made
+    /// @param token address of the token
+    /// @param staker address of the staker
+    /// @param amount amount of the withdrawal
+    event Withdraw(address indexed token, address indexed staker, uint256 amount);
+
+    /// @notice Method to deposit tokens
+    /// @dev token are transferred from the sender, and the receiver is credited
+    /// @param _token address of the token
+    /// @param _amount amount to deposit
+    /// @param _receiver address of the receiver
+    function deposit(address _token, uint256 _amount, address _receiver) external;
+
+    /// @notice Method to rescue tokens, only callable by the owner
+    /// @dev difference between balance and internal balance is transferred to the owner
+    /// @param _token address of the token
+    function rescueERC20(address _token) external;
+
+    /// @notice Method to add or remove a token
+    /// @dev only callable by the owner
+    /// @param _token address of the token
+    /// @param _supported struct with deposit and withdraw booleans
+    function supportToken(address _token, Supported calldata _supported) external;
+
+    /// @notice Method to rescue tokens, only callable by the owner
+    /// @dev token are transferred to the receiver and sender is credited
+    /// @param _token address of the token
+    /// @param _amount amount to withdraw
+    /// @param _receiver address of the receiver
+    function withdraw(address _token, uint256 _amount, address _receiver) external;
+}

package/contracts/interfaces/Syrup/ISyrupRouter.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface ISyrupRouter {
+    function pool() external view returns (address);
+
+    function deposit(uint256 amount_, bytes32 depositData_) external returns (uint256 shares_);
+}

package/contracts/interfaces/Tensorplex/ITensorplexStTAO.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ITensorplexStTAO {
+    function wrappedToken() external view returns (address);
+
+    function wrap(uint256 wtaoAmount) external;
+
+    function exchangeRate() external view returns (uint256);
+
+    function maxTaoForWrap() external view returns (uint256);
+
+    function calculateAmtAfterFee(uint256 wtaoAmount) external view returns (uint256, uint256);
+
+    function getWstTAObyWTAO(uint256 wtaoAmount) external view returns (uint256);
+}

package/contracts/interfaces/Thena/IThenaFactory.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IThenaFactory {
+    function allPairsLength() external view returns (uint);
+
+    function isPair(address pair) external view returns (bool);
+
+    function allPairs(uint index) external view returns (address);
+
+    function pairCodeHash() external pure returns (bytes32);
+
+    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 getFee(bool _stable) external view returns (uint256);
+}

package/contracts/interfaces/Thena/IThenaGaugeV2.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+interface IThenaGaugeV2 {
+    function emergency() external returns (bool);
+
+    function depositAll() external;
+
+    function withdrawAll() external;
+
+    function emergencyWithdraw() external;
+
+    function getReward() external;
+
+    function balanceOf(address account) external view returns (uint256);
+}