IPORVault

Documentation for eth_defi.ipor.vault.IPORVault Python class.

class IPORVault

Bases: eth_defi.erc_4626.vault.ERC4626Vault

IPOR vault support.

Add specialised reader with fees support
See Fusion vaults here
Example contract and ` Example vault <https://app.ipor.io/fusion/base/0x45aa96f0b3188d47a1dafdbefce1db6b37f58216>`__
IPOR custom error codes like 0x1425ea42 ABI-decoded

IPOR Fusion uses internalised_minting. Both the management fee and the performance fee are realised by minting new vault shares to dedicated technical holding accounts. Fees are therefore paid by existing share holders through dilution — the share price itself is never rewritten, and investors do not pay any explicit fee at deposit or redemption.

Fee caps (from PlasmaVaultLib.sol):

Management fee: up to 5% per year on assets under management (MANAGEMENT_MAX_FEE_IN_PERCENTAGE = 500, 2-decimal precision).
Performance fee: up to 50% on gains above a high-water mark (PERFORMANCE_MAX_FEE_IN_PERCENTAGE = 5000).

Share-minting mechanism (contracts/vaults/PlasmaVault.sol):

Every vault operation (deposit, mint, withdraw, redeem, execute, updateMarketsBalances) runs through fee hooks that call _realizeManagementFee() and _addPerformanceFee() (see call sites at lines 417, 451, 677, 738, 758, 1258, 1275, 1364).
_realizeManagementFee() at line 1413 — NatSpec: “Realizes management fees by minting shares to fee recipient”. Time-based accrual on grossTotalAssets is converted to shares via convertToShares() and those shares are minted directly to MANAGEMENT_FEE_ACCOUNT:
```
_mint(recipient, unrealizedFeeInShares);  // line 1437
```
The management-fee timestamp is only updated after a successful mint (IL-6959 fix) to prevent fee suppression by many small transactions.
_addPerformanceFee() at line 1381 — uses a high-water mark (HWM) model. If totalAssetsAfter >= totalAssetsBefore, the gain above the HWM is multiplied by the performance-fee rate, converted to shares by PlasmaVaultFeesLib.prepareForAddPerformanceFee() and minted:
```
_mint(recipient, feeShares);  // line 1402
```
Both mint paths temporarily disable totalSupplyCap validation so the fee mint cannot be blocked by the cap. The HWM is stored in HighWaterMarkPerformanceFeeStorage and can be auto-lowered on a configurable update interval (updateIntervalHighWaterMarkPerformanceFee).

Downstream distribution (contracts/managers/fee/FeeManager.sol):

harvestManagementFee() (line 194) and harvestPerformanceFee() (line 247) read the already-minted share balances via:

IERC4626(PLASMA_VAULT).balanceOf(MANAGEMENT_FEE_ACCOUNT);
IERC4626(PLASMA_VAULT).balanceOf(PERFORMANCE_FEE_ACCOUNT);

_transferDaoFee() (line 636) moves the IPOR DAO share via PLASMA_VAULT.transferFrom(feeAccount, daoRecipient, amount) (line 650), and _transferRecipientFee() (line 682) distributes the remainder to atomist-defined recipients using the same transferFrom pattern (line 705).
FeeAccount (contracts/managers/fee/FeeAccount.sol) is a tiny holding contract that only exposes approveMaxForFeeManager() so the FeeManager can pull the pre-minted shares — it never mints or burns anything itself.

Summary of why this is internalised_minting and not skimming or externalised:

Skimming would transfer underlying assets out of the vault at the moment of profit. IPOR never moves assets for fees — it mints shares.
Externalised fees (e.g. Lagoon) would deduct from the investor at redemption, so the vault share price is fees-gross. IPOR share price is fees-net: the dilution has already happened on-chain by the time totalAssets() / convertToAssets() are read.
The FeeManager is a distribution layer on top of already-minted fee shares, not a separate fee-collection mechanism.

Optional deposit fee:

FeeManager.setDepositFee() (line 508) allows an atomist to configure an explicit deposit fee with 18-decimal precision. NatSpec says the fee is “deducted from the user’s deposit amount before minting shares”, making it an externalised fee at deposit time. This is a per-vault optional add-on and is orthogonal to the management/performance fee mode. previewDeposit() already returns shares net of this fee.

References:

Parameters

web3 – Connection we bind this instance to
spec – Chain, address tuple
token_cache –
Cache used with fetch_erc20_details() to avoid multiple calls to the same token.

Reduces the number of RPC calls when scanning multiple vaults.
features – Pass vault feature flags along, externally detected.
default_block_identifier –
Override block identifier for on-chain metadata reads.

When None, use get_safe_cached_latest_block_number() (the default, safe for broken RPCs). Set to "latest" for freshly deployed vaults whose contracts do not exist at the safe-cached block.
require_denomination_token – If True, accessing denomination_token will raise RuntimeError when the on-chain lookup returns None.

Attributes summary

`access_manager`	Get IPOR's contract managing vault access rules.
`address`	Get the vault smart contract address.
`atomist`	IPOR Fusion atomist display name from cached IPOR metadata.
`chain_id`	Chain this vault is on
`denomination_token`	Get the token which denominates the vault valuation
`deposit_manager`	Deposit manager assocaited with this vault
`description`	Full vault strategy description from IPOR's offchain customisation API.
`erc_7540`	Is this ERC-7540 vault with asynchronous deposits.
`flow_manager`	Flow manager associated with this vault
`info`	Get info dictionary related to this vault deployment.
`ipor_metadata`	Offchain metadata from IPOR's customisation API.
`listed_by_ipor`	Whether IPOR lists this vault in its public app/offchain data.
`manager_name`	IPOR Fusion atomist exposed through the generic manager field.
`name`	Vault name.
`plasma_vault`	Get IPOR's proprietary PlasmaVault implementation.
`share_token`	ERC-20 that presents vault shares.
`short_description`	Short vault summary derived from the first sentence of the description.
`symbol`	Vault share token symbol
`underlying_token`	Alias for `denomination_token()`
`vault_address`
`vault_address_checksumless`
`vault_contract`	Get vault deployment.

Methods summary

`__init__`(web3, spec[, token_cache, ...])	param web3
`call_raw_signature`(address, function, ...)	Call a raw IPOR selector.
`can_check_deposit`()	Check if maxDeposit(address(0)) can be used to check global deposit availability.
`can_check_redeem`()	IPOR maxRedeem check is unreliable, so we skip it.
`fetch_available_liquidity`([block_identifier])	Get the amount of denomination token available for immediate withdrawal.
`fetch_denomination_token`()	Read denomination token from onchain.
`fetch_denomination_token_address`()	Get the `asset()` denomination token address of this vault.
`fetch_deposit_closed_reason`()	Check maxDeposit to determine if deposits are closed.
`fetch_deposit_next_open`()	Deposit timing is unpredictable - utilisation-based.
`fetch_fee_manager`(block_identifier)	Read the IPOR FeeManager address.
`fetch_info`()	Use `info()` property for cached access.
`fetch_nav`([block_identifier])	Fetch the most recent onchain NAV value.
`fetch_performance_fee_account`(block_identifier)	Read the IPOR performance fee account address.
`fetch_portfolio`(universe[, ...])	Read the current token balances of a vault.
`fetch_redemption_closed_reason`()	IPOR maxRedeem check is unreliable, so we skip it.
`fetch_redemption_next_open`()	Withdrawal timing is unpredictable - utilisation-based.
`fetch_scan_record_extra_data`()	Fetch protocol-specific private scan row columns.
`fetch_selector_access`(address, selector)	Read an account's IPOR AccessManager result for a vault selector.
`fetch_share_price`(block_identifier)	Get the current share price.
`fetch_share_token`()	Read share token details onchain.
`fetch_share_token_address`([block_identifier])	Get share token of this vault.
`fetch_total_assets`(block_identifier)	What is the total NAV of the vault.
`fetch_total_supply`(block_identifier)	What is the current outstanding shares.
`fetch_utilisation_percent`([block_identifier])	Get the percentage of assets currently allocated to strategies.
`fetch_vault_info`()	Get all information we can extract from the vault smart contracts.
`get_deposit_fee`(block_identifier)	Get the current deposit/onboarding fee as a percent.
`get_deposit_function_selector`()	Return the IPOR ERC-4626 deposit selector used for access checks.
`get_deposit_manager`()	Create the IPOR manager with AccessManager admission pre-flights.
`get_deposit_manager_capability`()	Declare the implemented synchronous IPOR transaction lifecycle.
`get_estimated_lock_up`()	ERC-4626 vaults do not have a lock up by fault.
`get_fee_data`()	Get fee data structure for this vault.
`get_fee_mode`()	Get how this vault accounts its fees.
`get_flags`()	Get vault flags, auto-flagging vaults missing from IPOR's public list.
`get_flow_manager`()	Get flow manager to read indiviaul settle events.
`get_historical_reader`(stateful)	Get share price reader to fetch historical returns.
`get_link`([referral])	Get a link to the vault dashboard on its native site.
`get_management_fee`(block_identifier)	Get the current management fee as a percent.
`get_notes`()	Get notes for this vault.
`get_performance_fee`(block_identifier)	Get the current performancae fee as a percent.
`get_protocol_name`()	Return the name of the vault protocol.
`get_redeem_function_selector`()	Return the IPOR ERC-4626 redemption selector used for access checks.
`get_redemption_delay`()	Get the redemption delay for the vault.
`get_redemption_delay_over`(address)	Get the redemption delay left for an account.
`get_risk`()	Get risk profile of this vault.
`get_spec`()
`get_synchronous_deposit_manager_capability`()	Build static metadata for a verified synchronous manager.
`get_withdraw_fee`(block_identifier)	Withdraw fee is set to zero by default as vaults usually do not have withdraw fees.
`has_block_range_event_support`()	Does this vault support block range-based event queries for deposits and redemptions.
`has_custom_fees`()	Does this vault have fees outside the shared fee model.
`has_deposit_distribution_to_all_positions`()	Deposits go automatically to all open positions.
`is_account_whitelisted`(address)	Determine whether an account belongs to IPOR's deposit access policy.
`is_valid`()	Check if this vault is valid.
`is_whitelisted_deposit`()	Determine whether IPOR restricts the ERC-4626 deposit selector.
`supports_generic_deposit_manager`()	Check whether the live vault exposes the standard ERC-4626 surface.

property atomist: Optional[str]: IPOR Fusion atomist display name from cached IPOR metadata.

property manager_name: Optional[str]: IPOR Fusion atomist exposed through the generic manager field.

property ipor_metadata: Optional[eth_defi.erc_4626.vault_protocol.ipor.offchain_metadata.IPORVaultMetadata]

Offchain metadata from IPOR’s customisation API.

Fetched from api.ipor.io/fusion/vaults-customization-list
Cached on first access
Returns None if the vault’s atomist has not set a description

property listed_by_ipor: bool: Whether IPOR lists this vault in its public app/offchain data.

property description: Optional[str]

Full vault strategy description from IPOR’s offchain customisation API.

If the vault has a prospectus link, a markdown link is appended to the description text.

property short_description: Optional[str]: Short vault summary derived from the first sentence of the description.

get_flags()

Get vault flags, auto-flagging vaults missing from IPOR’s public list.

If the vault is not in IPOR’s public API, frontend atomist config or customisation API, it is flagged as unofficial
Manual flags from VAULT_FLAGS_AND_NOTES take precedence

Return type: set[eth_defi.vault.flag.VaultFlag]

get_notes()

Get notes for this vault.

Returns manual notes from the vault flags if set
If vault is missing from IPOR’s public list, returns the missing note
Otherwise falls back to the full description

Return type: Optional[str]

property plasma_vault: web3.contract.contract.Contract: Get IPOR’s proprietary PlasmaVault implementation.

property access_manager: Optional[web3.contract.contract.Contract]

Get IPOR’s contract managing vault access rules.

Redemption delay, and such

get_deposit_function_selector()

Return the IPOR ERC-4626 deposit selector used for access checks.

IPOR’s :solidity:`AccessManager` authorises calls by target address and four-byte selector. Constructing the selector from the deployed vault ABI ensures the pre-flight checks the same overloaded entry point that the transaction manager will submit.

Returns: Four-byte deposit(uint256,address) selector.
Return type: hexbytes.main.HexBytes

get_redeem_function_selector()

Return the IPOR ERC-4626 redemption selector used for access checks.

The access policy can differ between deposit and redemption. The specialised manager therefore resolves the selector independently instead of assuming that deposit admission implies redemption access.

Returns: Four-byte redeem(uint256,address,address) selector.
Return type: hexbytes.main.HexBytes

is_whitelisted_deposit()

Determine whether IPOR restricts the ERC-4626 deposit selector.

OpenZeppelin’s AccessManager assigns PUBLIC_ROLE to selectors that any account may call. Any other target-function role means the vault has a whitelist or role-based deposit policy.

Returns: True when the deposit selector is restricted.
Raises: NotImplementedError – If this IPOR deployment has no readable access manager.
Return type: bool

fetch_selector_access(address, selector)

Read an account’s IPOR AccessManager result for a vault selector.

Web3.py requires checksum addresses for ABI encoding, while scanner and report rows commonly preserve lowercase address strings. Normalising both values here keeps the public account-policy method and transaction pre-flight consistent.

Parameters

address (eth_typing.evm.HexAddress) – Account whose selector permission is queried.
selector (hexbytes.main.HexBytes) – Four-byte vault function selector.

Returns

Tuple of immediate admission and scheduling delay in seconds.

Raises

NotImplementedError – If this IPOR deployment has no readable access manager.

Return type

tuple[bool, int]

is_account_whitelisted(address)

Determine whether an account belongs to IPOR’s deposit access policy.

AccessManager returns both immediate permission and a possible scheduling delay. A non-zero delay proves that the account belongs to the policy but does not mean a synchronous deposit can be submitted immediately; the deposit manager enforces that distinction.

Parameters: address (eth_typing.evm.HexAddress) – Account to query for the deposit selector.
Returns: True for immediate or scheduled policy membership.
Raises: NotImplementedError – If this IPOR deployment has no readable access manager.
Return type: bool

get_deposit_manager()

Create the IPOR manager with AccessManager admission pre-flights.

IPOR uses ordinary ERC-4626 transaction shapes after the caller is admitted. Deployments without a readable AccessManager retain the generic ERC-4626 manager behaviour; their deposit permission is reported as unknown instead of refusing every account.

Returns: Caller-aware IPOR manager when its AccessManager is available, otherwise the generic synchronous ERC-4626 manager.
Return type: Union[eth_defi.erc_4626.vault_protocol.ipor.deposit_redeem.IPORDepositManager, eth_defi.erc_4626.deposit_redeem.ERC4626DepositManager]

get_deposit_manager_capability()

Declare the implemented synchronous IPOR transaction lifecycle.

Access policy is reported separately through is_whitelisted_deposit(); static manager capability does not promise that an arbitrary account is currently admitted.

Returns: Two-way synchronous manager capability.
Return type: eth_defi.vault.deposit_redeem.VaultDepositManagerCapability

get_historical_reader(stateful)

Get share price reader to fetch historical returns.

Parameters: stateful – If True, use a stateful reading strategy.
Returns: None if unsupported
Return type: eth_defi.vault.base.VaultHistoricalReader

call_raw_signature(address, function, signature, block_identifier)

Call a raw IPOR selector.

IPOR Fusion fee helpers live across PlasmaVault, FeeAccount and FeeManager contracts. Some helper ABIs are not bundled locally, so selector-level reads keep the dependency small.

Parameters

address (str) – Contract address to call.
function (str) – Human-readable function name for diagnostics.
signature (bytes) – Four-byte selector.
block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) – Block to read.

Returns

Raw ABI-encoded result bytes.

Return type

bytes

fetch_performance_fee_account(block_identifier)

Read the IPOR performance fee account address.

The performance fee account is a FeeAccount contract that exposes FEE_MANAGER(). The FeeManager stores the deposit/onboarding fee.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) – Block to read.
Returns: Fee account address, or zero address if unset.
Return type: str

fetch_fee_manager(block_identifier)

Read the IPOR FeeManager address.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) – Block to read.
Returns: FeeManager address, or None if the fee account is unset.
Return type: Optional[str]

get_management_fee(block_identifier)

Get the current management fee as a percent.

Returns: 0.1 = 10%
Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) –
Return type: float

get_performance_fee(block_identifier)

Get the current performancae fee as a percent.

Returns: 0.1 = 10%
Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) –
Return type: float

get_deposit_fee(block_identifier)

Get the current deposit/onboarding fee as a percent.

IPOR stores this fee in FeeManager.getDepositFee() using 18-decimal precision where 1e18 is 100%. PlasmaVault previewDeposit() already returns shares after this fee.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) – Block to read.
Returns: 0.008 means 0.8%.
Return type: Optional[float]

get_redemption_delay()

Get the redemption delay for the vault.

Returns: Redemption delay as a timedelta.
Return type: Optional[datetime.timedelta]

get_redemption_delay_over(address)

Get the redemption delay left for an account.

Returns: When the account can redeem.
Parameters: address (str) –
Return type: Optional[datetime.datetime]

get_estimated_lock_up()

ERC-4626 vaults do not have a lock up by fault.

Note

Because of so many protocol specific lockups, this must be explicitly set to zero.

Return type: Optional[datetime.timedelta]

get_link(referral=None)

Get a link to the vault dashboard on its native site.

By default, give RouteScan link

Parameters: referral (Optional[str]) – Optional referral code to append to the URL.
Returns: URL string
Return type: str

fetch_deposit_closed_reason()

Check maxDeposit to determine if deposits are closed.

IPOR vaults are utilisation-based.

Return type: Optional[str]

fetch_redemption_closed_reason()

IPOR maxRedeem check is unreliable, so we skip it.

Return type: Optional[str]

fetch_deposit_next_open()

Deposit timing is unpredictable - utilisation-based.

Return type: Optional[datetime.datetime]

fetch_redemption_next_open()

Withdrawal timing is unpredictable - utilisation-based.

Return type: Optional[datetime.datetime]

can_check_redeem()

IPOR maxRedeem check is unreliable, so we skip it.

Return type: bool

fetch_available_liquidity(block_identifier='latest')

Get the amount of denomination token available for immediate withdrawal.

Uses the idle assets pattern: asset().balanceOf(vault) returns unallocated assets.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) – Block to query. Defaults to “latest”.
Returns: Amount in denomination token units (human-readable Decimal).
Return type: Optional[decimal.Decimal]

fetch_utilisation_percent(block_identifier='latest')

Get the percentage of assets currently allocated to strategies.

Utilisation = (totalAssets - idle) / totalAssets

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) – Block to query. Defaults to “latest”.
Returns: Utilisation as float between 0.0 and 1.0 (0% to 100%).
Return type: Optional[float]

__init__(web3, spec, token_cache=None, features=None, default_block_identifier=None, require_denomination_token=False)

Parameters

web3 (web3.main.Web3) – Connection we bind this instance to
spec (eth_defi.vault.base.VaultSpec) – Chain, address tuple
token_cache (Optional[dict]) –
Cache used with fetch_erc20_details() to avoid multiple calls to the same token.

Reduces the number of RPC calls when scanning multiple vaults.
features (Optional[set[eth_defi.erc_4626.core.ERC4626Feature]]) – Pass vault feature flags along, externally detected.
default_block_identifier (Optional[Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]]) –
Override block identifier for on-chain metadata reads.

When None, use get_safe_cached_latest_block_number() (the default, safe for broken RPCs). Set to "latest" for freshly deployed vaults whose contracts do not exist at the safe-cached block.
require_denomination_token (bool) – If True, accessing denomination_token will raise RuntimeError when the on-chain lookup returns None.

property address: eth_typing.evm.HexAddress: Get the vault smart contract address.

can_check_deposit()

Check if maxDeposit(address(0)) can be used to check global deposit availability.

Most ERC-4626 vaults implement maxDeposit in a way that returns meaningful values when called with address(0):

Returns 0 when deposits are globally closed/capped
Returns a positive value indicating maximum deposit allowed

Override to return False in subclasses where maxDeposit(address(0)) doesn’t provide meaningful global availability information.

Returns: True if maxDeposit(address(0)) returns meaningful values for global deposit availability checking.
Return type: bool

property chain_id: int: Chain this vault is on

property denomination_token: Optional[eth_defi.token.TokenDetails]

Get the token which denominates the vault valuation

Used in deposits and redemptions
Used in NAV calculation
Used in profit benchmarks
Usually USDC

Returns

Token wrapper instance.

Maybe None for broken vaults like https://arbiscan.io/address/0x9d0fbc852deccb7dcdd6cb224fa7561efda74411#code

Note

None results are not cached — the next access will retry the on-chain call. This avoids permanently caching a transient RPC failure.

property deposit_manager: eth_defi.vault.deposit_redeem.VaultDepositManager: Deposit manager assocaited with this vault

property erc_7540: bool

Is this ERC-7540 vault with asynchronous deposits.

For example previewDeposit() function and other functions will revert

fetch_denomination_token()

Read denomination token from onchain.

Use denomination_token() for cached access.

Return type: Optional[eth_defi.token.TokenDetails]

fetch_denomination_token_address()

Get the asset() denomination token address of this vault.

Results are disk-cached per (chain_id, vault_address) via eth_defi.erc_4626.vault_token when the vault was constructed with a eth_defi.token.TokenDiskCache and no pinned default_block_identifier. The denomination token is immutable post-deployment, so the cached value is correct regardless of which block the caller would have asked for.

Only a definitive non-null answer is persisted. The None path taken on revert / broken contract is never cached, matching the behaviour of eth_defi.vault.base.VaultBase.denomination_token() which explicitly avoids memoising None so transient failures can be retried.

To disable the cache, pass token_cache=None (or any non- TokenDiskCache dict) when constructing the vault, or construct with a pinned default_block_identifier.

Returns: Denomination token address, or None if the vault contract is broken and did not return a valid address.
Return type: Optional[eth_typing.evm.HexAddress]

fetch_info()

Use info() property for cached access.

Returns: See LagoonVaultInfo
Return type: eth_defi.erc_4626.vault.ERC4626VaultInfo

fetch_nav(block_identifier=None)

Fetch the most recent onchain NAV value.

In the case of Lagoon, this is the last value written in the contract with updateNewTotalAssets() and ` settleDeposit()`
TODO: updateNewTotalAssets() there is no way to read pending asset update on chain

Returns: Vault NAV, denominated in denomination_token()
Return type: decimal.Decimal

fetch_portfolio(universe, block_identifier=None, allow_fallback=True)

Read the current token balances of a vault.

SHould be supported by all implementations

Parameters

universe (eth_defi.vault.base.TradingUniverse) –
block_identifier (Optional[Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]]) –
allow_fallback (bool) –

Return type

eth_defi.vault.base.VaultPortfolio

fetch_scan_record_extra_data()

Fetch protocol-specific private scan row columns.

Some vault protocols expose structured metadata that is useful for the raw scanner output but does not fit the shared human-readable columns. Override this hook in protocol-specific subclasses instead of adding a separate branch to eth_defi.erc_4626.scan.create_vault_scan_record().

Returns: Mapping of private scan-row column names, usually prefixed with _. The default implementation returns no extra data.
Return type: dict[str, object]

fetch_share_price(block_identifier)

Get the current share price.

Returns

The share price in underlying token.

If supply is zero return zero.

Parameters

block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) –

Return type

decimal.Decimal

fetch_share_token()

Read share token details onchain.

Use share_token() for cached access.

Return type: eth_defi.token.TokenDetails

fetch_share_token_address(block_identifier='latest')

Get share token of this vault.

Vault itself (ERC-4626)
share() accessor (ERC-7575)

Results are disk-cached per (chain_id, vault_address) via eth_defi.erc_4626.vault_token when the vault was constructed with a eth_defi.token.TokenDiskCache. Under normal circumstances the block_identifier argument is effectively ignored on cache hits — ERC-4626 share tokens are immutable post-deployment, so the cached value is correct regardless of which block the caller asked for.

Only a definitive answer from the chain is ever persisted: a successful call, or a revert matching KNOWN_SHARE_TOKEN_ERROR_MESSAGES (which positively classifies the contract as non-ERC-7575). Transient RPC failures (ProbablyNodeHasNoBlock, HTTP 502) fall back to self.vault_address but are not written to the cache, so a flaky node cannot poison a real ERC-7575 vault’s entry.

To disable the cache, pass token_cache=None (or any non- TokenDiskCache dict) when constructing the vault, or construct with a pinned default_block_identifier to force the uncached historical-read path on every call.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) – Block to query. Cache is only consulted/written when the caller passes the default "latest" and the vault instance has no pinned default_block_identifier.
Return type: eth_typing.evm.HexAddress

fetch_total_assets(block_identifier)

What is the total NAV of the vault.

Example:

assert vault.denomination_token.symbol == "USDC"
assert vault.share_token.symbol == "ipUSDCfusion"
assert vault.fetch_total_assets(block_identifier=test_block_number) == Decimal("1437072.77357")
assert vault.fetch_total_supply(block_identifier=test_block_number) == Decimal("1390401.22652875")

Parameters

Block number to read.

Use web3.eth.block_number for the last block.

Returns

The vault value in underlyinh token

Return type

Optional[decimal.Decimal]

fetch_total_supply(block_identifier)

What is the current outstanding shares.

Example:

Parameters

Block number to read.

Use web3.eth.block_number for the last block.

Returns

The vault value in underlyinh token

Return type

decimal.Decimal

fetch_vault_info()

Get all information we can extract from the vault smart contracts.

Return type: eth_defi.erc_4626.vault.ERC4626VaultInfo

property flow_manager: eth_defi.vault.base.VaultFlowManager: Flow manager associated with this vault

get_fee_data()

Get fee data structure for this vault.

Raises: ValueError – In the case of broken or unimplemented fee reading methods in the smart contract
Return type: eth_defi.vault.fee.FeeData

get_fee_mode()

Get how this vault accounts its fees.

Return type: Optional[eth_defi.vault.fee.VaultFeeMode]

get_flow_manager()

Get flow manager to read indiviaul settle events.

Only supported if has_block_range_event_support() is True

Return type: eth_defi.vault.base.VaultFlowManager

get_protocol_name()

Return the name of the vault protocol.

Return type: str

get_risk()

Get risk profile of this vault.

Return type: Optional[eth_defi.vault.risk.VaultTechnicalRisk]

get_synchronous_deposit_manager_capability()

Build static metadata for a verified synchronous manager.

A caller must already have established the reader class’ guarded fork evidence. This deliberately performs no RPC reads: the capability is static library metadata, not a live vault availability check.

Returns: Synchronous two-way capability.
Return type: eth_defi.vault.deposit_redeem.VaultDepositManagerCapability

get_withdraw_fee(block_identifier)

Withdraw fee is set to zero by default as vaults usually do not have withdraw fees.

Internal: Use get_fee_data().

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) –
Return type: float

has_block_range_event_support()

Does this vault support block range-based event queries for deposits and redemptions.

If not we use chain balance polling-based approach

has_custom_fees()

Does this vault have fees outside the shared fee model.

Custom fees cause risk in vault comparison because the shared management/performance/deposit/withdraw fee fields cannot describe the full fee structure.

Do not return True merely because a vault implements custom accessors for ordinary management, performance, deposit, or withdraw fees. Return True only when some vault fee cannot be reflected in those standard fields as a fee-like value.

Returns: True if the vault has fees outside the shared fee model.
Return type: bool

has_deposit_distribution_to_all_positions()

Deposits go automatically to all open positions.

Deposits do not land into the vault as cash
Instead, smart contracts automatically increase all open positions
The behaviour of Velvet Capital

property info: eth_defi.vault.base.VaultInfo

Get info dictionary related to this vault deployment.

Get cached data on the various vault parameters

Returns: Vault protocol specific information dictionary

is_valid()

Check if this vault is valid.

Call a known smart contract function to verify the function exists

Return type: bool

property name: str: Vault name.

property share_token: eth_defi.token.TokenDetails

ERC-20 that presents vault shares.

User gets shares on deposit and burns them on redemption

supports_generic_deposit_manager()

Check whether the live vault exposes the standard ERC-4626 surface.

This is deliberately an interface check, not a public support claim. Callers must still execute a guarded fork probe before relying on the generic manager for a protocol-specific adapter.

Returns: True when asset succeeds with a non-zero asset address. Deposit and redemption availability is established only by a guarded fork transaction, not by ERC-4626 max* advisory values.
Return type: bool

property symbol: str: Vault share token symbol

property underlying_token: eth_defi.token.TokenDetails: Alias for denomination_token()

property vault_contract: web3.contract.contract.Contract: Get vault deployment.

first_seen_at_block: Optional[int]

Block number hint when this vault was deployed.

Must be set externally, as because of shitty Ethereum RPC we cannot query this. Allows us to avoid unnecessary work when scanning historical price data.