erc_4626.vault_protocol.t3tris.vault

Documentation for eth_defi.erc_4626.vault_protocol.t3tris.vault Python module.

T3tris vault support.

T3tris is a tokenised vault protocol for professional asset managers. It builds vaults around ERC-4626 shares and adds an ERC-7540-like asynchronous request lifecycle with protocol-specific method selectors.

Module Attributes

`STALE_NAV_CORRECTED_ERROR`	Marker exported with rows whose PPS/NAV was corrected by this reader.
`STALE_NAV_FIRST_SAMPLE_ERROR`	Marker exported when a scan appears to start inside an uncorrectable gap.

Classes

`T3trisHistoricalReader`	Read T3tris historical prices with async settlement gap correction.
`T3trisVault`	T3tris protocol vaults.

STALE_NAV_SHARE_PRICE_DROP_THRESHOLD = Decimal('0.90'): Treat a T3tris PPS sample below this fraction of the previous good PPS as a stale-NAV window when async settlement minted shares but the oracle NAV has not yet absorbed the settled assets.

STALE_NAV_FIRST_SAMPLE_WARNING_THRESHOLD = Decimal('0.90'): Warn when the first reader sample is already below this PPS value and there is no previous good PPS to hold for correction.

STALE_NAV_CORRECTED_ERROR = 't3tris_stale_nav_gap_corrected': Marker exported with rows whose PPS/NAV was corrected by this reader.

STALE_NAV_FIRST_SAMPLE_ERROR = 't3tris_stale_nav_gap_possible_first_sample': Marker exported when a scan appears to start inside an uncorrectable gap.

class T3trisHistoricalReader

Bases: eth_defi.erc_4626.vault.ERC4626HistoricalReader

Read T3tris historical prices with async settlement gap correction.

T3tris async vaults can mint shares during deposit settlement before the oracle NAV reflects the settled assets. During this stale-NAV window the standard ERC-4626 convertToAssets(1 share) value can show a large phantom drawdown even though no economic loss happened.

This reader follows the conservative “hold last good PPS” strategy for async vaults. When supply jumps and raw PPS collapses while the vault is closed for async settlement, it keeps the previous good share price and reports effective total assets as held_pps * total_supply while the same stale-NAV window remains open. The hold ends when raw PPS recovers or a later oracle valuation timestamp indicates that the low PPS is now measured NAV instead of stale accounting.

PPS scenarios handled by this reader:

Sync/open vault: isVaultOpen() returns True. T3tris is using live vault accounting, so the generic ERC-4626 PPS is already the effective PPS. No stale-NAV correction is applied.
Normal async vault: isVaultOpen() returns False but supply and PPS move without a large supply-driven collapse. The raw convertToAssets(1 share) value is accepted and stored as the next last_good_share_price.
Async settlement gap starts: total supply increases and raw PPS falls below STALE_NAV_SHARE_PRICE_DROP_THRESHOLD of the previous good PPS. This is the T3tris phantom drawdown case where shares were minted before the oracle NAV absorbed the settled assets. The reader holds the previous PPS and recalculates NAV as held_pps * total_supply.
Settlement timestamp advances at gap start: some real T3tris samples show a newer lastValuationTimestamp() at the settlement sample even though NAV is still stale. A timestamp advance therefore does not block starting a new gap if the supply jump and PPS collapse are present.
Gap continues: once a stale-NAV gap is active, the reader keeps holding PPS while raw PPS remains collapsed and the oracle valuation timestamp is still the same timestamp that opened the gap.
Gap ends by fresh valuation or recovery: if raw PPS recovers, or a later valuation timestamp appears after the gap has started, the reader accepts the raw PPS again and clears the stale-NAV latch.
First sample already inside a gap: there is no previous good PPS to hold. The reader returns the raw sample, emits STALE_NAV_FIRST_SAMPLE_ERROR, and does not seed last_good_share_price from the suspect value.
Protocol-specific call failure: if isVaultOpen() or lastValuationTimestamp() fails while raw PPS is collapsed, the reader avoids poisoning last_good_share_price with the collapsed value. If a gap was already active, it keeps holding PPS for the failed sample.
Real loss ambiguity: a true economic loss that happens in the same sample as a deposit-driven supply increase can look identical to a stale-NAV window. The reader intentionally favours the T3tris accounting correction because the purpose of this protocol-specific reader is to avoid user-facing phantom drawdowns in the historical PPS series.

__init__(vault, stateful)

Parameters

vault (eth_defi.erc_4626.vault_protocol.t3tris.vault.T3trisVault) –
stateful (bool) –

property oracle_address: eth_typing.evm.HexAddress

Get the T3tris oracle address used for timestamp polling.

T3tris’ live ABI exposes getOracle() even though the minimal oracle interface is usually documented as oracle(). The vault method keeps the ABI-specific lookup in one place.

The scanner constructs one multicall set for the whole historical read, so this address is cached for the reader lifetime. This assumes the vault’s oracle address is immutable for the scanned deployment history. If a future T3tris vault can migrate oracle contracts, the reader must be extended to split the historical scan at oracle-change boundaries before polling lastValuationTimestamp().

Returns: The current oracle contract address.

construct_multicalls()

Get on-chain calls needed for corrected T3tris historical prices.

In addition to the generic ERC-4626 calls we read isVaultOpen() to distinguish sync and async vault modes, and lastValuationTimestamp() from the configured oracle to observe valuation refreshes.

Returns: Encoded calls consumed by the multicall historical reader.
Return type: collections.abc.Iterable[eth_defi.event_reader.multicall_batcher.EncodedCall]

process_result(block_number, timestamp, call_results)

Process one T3tris historical sample.

The raw ERC-4626 values are decoded first. If the sample is inside a correctable stale-NAV window, share_price is replaced by the last known good value and total_assets is recalculated from the corrected price and current total supply. If the first sample already looks like a stale-NAV gap, the reader cannot infer a previous good PPS and therefore only tags the row as suspicious.

PPS handling details:

Decode generic ERC-4626 values without letting the parent reader update adaptive scanner state. The raw values may be a known-bad T3tris stale-NAV sample, so state must only be updated after the T3tris correction decision is made.
Decode isVaultOpen() and oracle lastValuationTimestamp(). isVaultOpen() == True means sync/live accounting. False means async/oracle accounting and may need stale-NAV correction.
Reject out-of-order blocks. The stale-NAV detector depends on the previous supply, current gap valuation timestamp, and previous good PPS; processing historical samples backwards would make the state machine unsafe.
If a stale-NAV gap is detected, hold last_good_share_price and recompute total_assets from the held PPS and the current supply. The row is tagged with STALE_NAV_CORRECTED_ERROR so downstream consumers can see that the value is protocol-corrected, not the raw ERC-4626 value.
If this looks like the first sample inside a gap, emit STALE_NAV_FIRST_SAMPLE_ERROR and do not update last_good_share_price. Without a previous good PPS, any correction would be guesswork.
If T3tris-specific protocol reads fail on a collapsed raw PPS, avoid updating last_good_share_price from the collapsed value. If this is the first low-PPS sample, tag it as a possible uncorrectable gap. When the failed sample is not already part of a confirmed gap, the previous supply baseline is also preserved so the next successful sample can still detect the supply jump and correct the gap.
Update adaptive reader state exactly once, using the corrected PPS and corrected total assets when correction was applied. This prevents the adaptive scanner from learning a phantom drawdown and reducing scan quality for the vault.

Parameters

block_number (int) – Block number of the sample.
timestamp (datetime.datetime) – Naive UTC timestamp of the block.
call_results (list[eth_defi.event_reader.multicall_batcher.EncodedCallResult]) – Results for calls produced by construct_multicalls().

Returns

Historical read with raw or T3tris-corrected share price and total assets.

Return type

eth_defi.vault.base.VaultHistoricalRead

construct_core_erc_4626_multicall()

Polling endpoints defined in ERC-4626 spec.

Does not include fee calls which do not have standard

Return type: Iterable[eth_defi.event_reader.multicall_batcher.EncodedCall]

dictify_multicall_results(block_number, call_results, allow_failure=True)

Convert batch of multicalls made for this vault to more digestible dict.

Assert that all multicalls succeed

Returns

Dictionary where each multicall is keyed by its EncodedCall.extra_data["function"]

Parameters

block_number (int) –
call_results (list[eth_defi.event_reader.multicall_batcher.EncodedCallResult]) –

Return type

dict[str, eth_defi.event_reader.multicall_batcher.EncodedCallResult]

get_warmup_calls()

Yield (function_name, callable, contract_call) tuples for warmup testing.

Each callable should execute a single contract call. If it raises, the function is marked as broken.

The optional contract_call is used for gas estimation to detect expensive calls before executing them. If provided, calls using excessive gas (>1M gas) will be marked as broken without execution.

Override in subclasses to add protocol-specific calls.

Returns: Iterable of (function_name, test_callable, contract_call) tuples. contract_call may be None if gas estimation is not needed.
Return type: Iterable[tuple[str, callable, Any]]

process_core_erc_4626_result(call_by_name)

Decode common ERC-4626 calls.

Parameters: call_by_name (dict[str, eth_defi.event_reader.multicall_batcher.EncodedCallResult]) –
Return type: tuple

should_skip_call(function_name)

Check if a specific function call should be skipped.

Uses the reader state’s call_status map if available.

Parameters: function_name (str) – The function name to check
Returns: True if the call should be skipped
Return type: bool

class T3trisVault

Bases: eth_defi.erc_4626.vault.ERC4626Vault

T3tris protocol vaults.

T3tris vaults expose standard ERC-4626 accounting methods
Async deposit/redemption flow uses custom DepositRequest and RedeemRequest events and custom request/claim methods
Fee values are exposed as WAD-scaled integers by the live vault ABI
Offchain descriptions are fetched from the T3tris page API

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.

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

property t3tris_metadata: Optional[eth_defi.erc_4626.vault_protocol.t3tris.offchain_metadata.T3trisVaultMetadata]

Offchain metadata from T3tris’ web app API.

Fetched from api.t3tris.finance/api/v1/vaults and cached on disk and in-process to avoid repeated API calls.

fetch_oracle_address(block_identifier)

Fetch the configured T3tris oracle address.

T3tris live vaults expose getOracle() in their frontend ABI. If a future compatible deployment exposes the documented oracle() getter instead, fall back to the raw selector.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Block number or tag to read.
Returns: Oracle contract address.
Return type: eth_typing.evm.HexAddress

property description: Optional[str]: Full vault strategy description from T3tris’ offchain metadata.

property short_description: Optional[str]: Short vault summary from T3tris’ offchain metadata.

property manager_name: Optional[str]: T3tris curator name from offchain vault metadata.

get_management_fee(block_identifier)

Get the current annual management fee as a fraction.

T3tris returns (managementFeeWad, managementFeeDays). The first value is WAD-scaled where 1e18 is 100%.

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

get_performance_fee(block_identifier)

Get the current performance fee as a fraction.

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

get_deposit_fee(block_identifier)

Get the current entry fee as a fraction.

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

get_withdraw_fee(block_identifier)

Get the current exit fee as a fraction.

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

get_link(referral=None)

Link to the T3tris vault app.

Parameters: referral (Optional[str]) –
Return type: str

get_historical_reader(stateful)

Get the T3tris historical reader.

T3tris async settlement can temporarily expose supply and oracle NAV out of sync. Use T3trisHistoricalReader instead of the generic ERC-4626 reader so the historical PPS series does not record phantom drawdowns.

Parameters: stateful (bool) – Enable adaptive scanner state.
Returns: T3tris-specific historical reader.
Return type: eth_defi.vault.base.VaultHistoricalReader

__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

can_check_redeem()

Check if maxRedeem(address(0)) can be used to check global redemption availability.

Most protocols return 0 for maxRedeem(address(0)) because that address has no balance/shares, not because redemptions are closed:

Gearbox: maxRedeem returns min(balanceOf(owner), convertToShares(availableLiquidity))
Most vaults: Return 0 because address(0) has no shares

Some protocols do use maxRedeem(address(0)) meaningfully:

Morpho, IPOR, Plutus: Return 0 when redemptions are globally blocked

Override to return True in subclasses that support address(0) redemption checks.

Returns: True if maxRedeem(address(0)) returns meaningful values for global redemption 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_available_liquidity(block_identifier='latest')

Get the amount of denomination token available for immediate withdrawal.

Only applicable to lending protocol vaults (IPOR, Euler, Morpho, Gearbox, etc.). Non-lending protocols should leave this method unimplemented.

Note: maxRedeem(address(0)) does NOT work as a proxy for available liquidity because it requires a specific address that has already deposited shares. For address(0), balanceOf is always 0, so maxRedeem returns 0 regardless of actual liquidity.

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

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_deposit_closed_reason()

Check if deposits are closed using maxDeposit(address(0)).

Uses the ERC-4626 standard maxDeposit function to determine if deposits are available. Returns a human-readable reason with the max deposit amount if deposits are restricted.

Returns: Human-readable string if deposits are closed/restricted, or None if deposits are open (maxDeposit > 0).
Return type: Optional[str]

fetch_deposit_next_open()

Get when deposits will next be open.

For epoch-based vaults (Ostium, D2), return calculated window open time
For non-epoch vaults (Plutus, IPOR, Morpho), return None
Override in protocol-specific subclasses

Returns

Naive UTC datetime when deposits will next be available, or None if:

Deposits are currently open
Timing is unpredictable (manually controlled)
Protocol does not support timing information

Return type

Optional[datetime.datetime]

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_redemption_closed_reason()

Check if redemptions are closed using maxRedeem(address(0)).

Only works for protocols that implement maxRedeem in a way that returns meaningful values for address(0). Most protocols return 0 because address(0) has no shares, not because redemptions are closed.

Returns: Human-readable string if redemptions are closed, or None if redemptions are open or check is not supported.
Return type: Optional[str]

fetch_redemption_next_open()

Get when withdrawals/redemptions will next be open.

For epoch-based vaults (Ostium, D2), return calculated window open time
For non-epoch vaults (Plutus, IPOR, Morpho), return None
Override in protocol-specific subclasses

Returns

Naive UTC datetime when withdrawals will next be available, or None if:

Withdrawals are currently open
Timing is unpredictable (manually controlled)
Protocol does not support timing information

Return type

Optional[datetime.datetime]

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_utilisation_percent(block_identifier='latest')

Get the percentage of assets currently lent out.

Only applicable to lending protocol vaults (IPOR, Euler, Morpho, Gearbox, etc.). Non-lending protocols should leave this method unimplemented.

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

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_deposit_manager()

Get deposit manager to deposit/redeem from the vault.

Return type: ERC4626DepositManager

get_deposit_manager_capability()

Declare the exact generic ERC-4626 implementation’s two-way flow.

Subclasses need exact-type inclusion in CERTIFIED_SYNCHRONOUS_DEPOSIT_MANAGER_CLASSES. The guarded probe may separately use supports_generic_deposit_manager() as a temporary fallback without advertising it as public metadata.

Returns: Synchronous two-way capability for the exact base class, otherwise None.
Return type: Optional[eth_defi.vault.deposit_redeem.VaultDepositManagerCapability]

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_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_flags()

Get various vault state flags from the smart contract.

Override to add status flags
Also add flags from our manual flag list in eth_defi.vault.flag

Returns

Flag set.

Do not modify in place.

Return type

set[eth_defi.vault.flag.VaultFlag]

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_notes()

Get a human readable message if we know somethign special is going on with this vault.

Return type: Optional[str]

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

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()

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.