@pendle/core-v2 5.2.3-beta → 5.2.3

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/Mellow/IMellowVault.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IMellowVault {
+    function underlyingTvl() external view returns (address[] memory tokens, uint256[] memory amounts);
+
+    function deposit(
+        address to,
+        uint256[] memory amounts,
+        uint256 minLpAmount,
+        uint256 deadline,
+        uint256 referralCode
+    ) external returns (uint256[] memory actualAmounts, uint256 lpAmount);
+
+    function deposit(
+        address to,
+        uint256[] memory amounts,
+        uint256 minLpAmount,
+        uint256 deadline
+    ) external returns (uint256[] memory actualAmounts, uint256 lpAmount);
+
+    function configurator() external view returns (address);
+}

package/contracts/interfaces/Mellow/IMellowVaultConfigurator.sol

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

package/contracts/interfaces/PirexETH/IPirexETH.sol

@@ -0,0 +1,27 @@
+pragma solidity ^0.8.0;
+
+interface IPirexETH {
+    enum Fees {
+        Deposit,
+        Redemption,
+        InstantRedemption
+    }
+
+    function deposit(
+        address receiver,
+        bool shouldCompound
+    ) external payable returns (uint256 postFeeAmount, uint256 feeAmount);
+
+    function instantRedeemWithPxEth(
+        uint256 _assets,
+        address _receiver
+    ) external returns (uint256 postFeeAmount, uint256 feeAmount);
+
+    function fees(Fees _feeType) external view returns (uint256);
+
+    function pxEth() external view returns (address);
+
+    function autoPxEth() external view returns (address);
+
+    function buffer() external view returns (uint256);
+}

package/contracts/interfaces/Pump/IPumpStaking.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+interface IPumpStaking {
+    function stake(uint256 amount) external;
+
+    function unstakeInstant(uint256 amount) external;
+
+    function onlyAllowStake() external view returns (bool);
+
+    function instantUnstakeFee() external view returns (uint256);
+
+    function pendingStakeAmount() external view returns (uint256);
+}

package/contracts/interfaces/Renzo/IRenzoDepositL2.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IRenzoDepositL2 {
+    function connext() external view returns (address);
+
+    function swapKey() external view returns (bytes32);
+
+    function collateralToken() external view returns (address);
+
+    function deposit(uint256 _amountIn, uint256 _minOut, uint256 _deadline) external returns (uint256);
+
+    function lastPrice() external view returns (uint256);
+
+    function bridgeRouterFeeBps() external view returns (uint256);
+}

package/contracts/interfaces/Renzo/IRenzoOracle.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IRenzoOracle {
+    function lookupTokenValue(address token, uint256 amount) external view returns (uint256);
+
+    function calculateMintAmount(uint256 tvl, uint256 value, uint256 supply) external view returns (uint256);
+}

package/contracts/interfaces/Renzo/IRenzoRestakeManager.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IRenzoRestakeManager {
+    function depositETH(uint256 _referralId) external payable;
+
+    function deposit(address _collateralToken, uint256 _amount, uint256 _referralId) external;
+
+    function collateralTokens(uint256 i) external view returns (address);
+
+    function calculateTVLs() external view returns (uint256[][] memory, uint256[] memory, uint256);
+
+    function renzoOracle() external view returns (address);
+}

package/contracts/interfaces/Renzo/IRenzoReztake.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IRenzoReztake {
+    function rez() external view returns (address);
+
+    function stake(uint256 _amount) external returns (uint256 totalStaked);
+
+    function unStake(uint256 _amount) external;
+
+    function claim(uint256 _index) 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/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);
+}