@pendle/core-v2 3.0.0-beta-9 → 3.0.0

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

package/contracts/interfaces/Thena/IThenaGaugeV2.sol

@@ -2,7 +2,6 @@
 
 pragma solidity ^0.8.0;
 
-
 interface IThenaGaugeV2 {
     function emergency() external returns (bool);
 
@@ -15,4 +14,4 @@ interface IThenaGaugeV2 {
     function getReward() external;
 
     function balanceOf(address account) external view returns (uint256);
-}
+}

package/contracts/interfaces/Thena/IThenaPair.sol

@@ -16,15 +16,13 @@ interface IThenaPair {
     function getReserves() external view returns (uint _reserve0, uint _reserve1, uint _blockTimestampLast);
     function getAmountOut(uint, address) external view returns (uint);
 
-    function name() external view returns(string memory);
-    function symbol() external view returns(string memory);
+    function name() external view returns (string memory);
+    function symbol() external view returns (string memory);
     function totalSupply() external view returns (uint);
     function decimals() external view returns (uint8);
 
     function claimable0(address _user) external view returns (uint);
     function claimable1(address _user) external view returns (uint);
 
-    function isStable() external view returns(bool);
-
-
+    function isStable() external view returns (bool);
 }