tokenised_fund.asseto.vault

Documentation for eth_defi.tokenised_fund.asseto.vault Python module.

Asseto tokenised fund vault adapter.

Asseto products are KYC-gated tokenised fund shares, issued and redeemed outside the generic ERC-4626 flow using administrator-published NAV. They are not ERC-4626 or ERC-7540, but can be read through VaultBase.

Module Attributes

`ASSETO_PRICER_ABI`	Asseto `Pricer` view ABI.
`ASSETO_MANAGER_FEE_ABI`	Asseto `AoABTManager` fee view ABI.
`ASSETO_BLOCKED_FLOW_REASON`	Generic manager reason used to keep Asseto outside public transaction flows.
`ASSETO_PRODUCT_INDEX_URL`	Fallback Asseto product index for API-discovered products without a reviewed product-specific homepage.
`ASSETO_NAV_SOURCE`	NAV/share source diagnostic exported with scan rows.

Functions

`convert_asseto_basis_points_to_percent`(...)	Convert Asseto manager fee units to a fractional percent.
`create_asseto_short_description`(description)	Create a product-specific one-line summary from Asseto metadata.
`export_asseto_usd_denomination`(chain_id)	Export non-transferable USD accounting metadata.

Classes

`AssetoVault`	Read-only adapter for Asseto tokenised fund products.
`AssetoVaultInfo`	Asseto product metadata exported by `AssetoVault`.

ASSETO_PRICER_ABI = [{'inputs': [], 'name': 'getLatestPrice', 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}], 'stateMutability': 'view', 'type': 'function'}]: Asseto Pricer view ABI. Source: verified HashKey Chain contract at https://hsk.blockscout.com/address/0xD72529F8b54fcB59010F2141FC328aDa5Aa72abb

ASSETO_MANAGER_FEE_ABI = [{'inputs': [], 'name': 'BPS_DENOMINATOR', 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}], 'stateMutability': 'view', 'type': 'function'}, {'inputs': [], 'name': 'mintFee', 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}], 'stateMutability': 'view', 'type': 'function'}, {'inputs': [], 'name': 'redemptionFee', 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}], 'stateMutability': 'view', 'type': 'function'}]: Asseto AoABTManager fee view ABI. Source: verified HashKey Chain contract at https://hsk.blockscout.com/address/0x6dB7eA55c94fb0F4b22D6b384C18CdAa3B33d746

ASSETO_BLOCKED_FLOW_REASON = 'Asseto deposit manager is blocked: KYC-gated request/claim subscriptions and redemptions are not supported': Generic manager reason used to keep Asseto outside public transaction flows.

ASSETO_PRODUCT_INDEX_URL = 'https://asseto.finance/product': Fallback Asseto product index for API-discovered products without a reviewed product-specific homepage.

create_asseto_short_description(description)

Create a product-specific one-line summary from Asseto metadata.

Asseto registry introductions usually contain several sentences. Vault listings use the opening product sentence and, when needed, the next sentence describing investments so that the underlying strategy is visible instead of generic token-wrapper details.

Parameters: description (Optional[str]) – Asseto registry introduction or curated product text.
Returns: Normalised strategy summary, or None when no meaningful source description is available.
Return type: Optional[str]

ASSETO_NAV_SOURCE = 'asseto_pricer_getLatestPrice': NAV/share source diagnostic exported with scan rows.

convert_asseto_basis_points_to_percent(raw_fee, basis_point_denominator)

Convert Asseto manager fee units to a fractional percent.

AoABTManager specifies mintFee and redemptionFee in basis points and defines BPS_DENOMINATOR as 10,000. The same source applies amount * fee / BPS_DENOMINATOR when processing subscriptions and redemption claims.

Parameters

raw_fee (int) – Fee value returned by the Asseto manager contract.
basis_point_denominator (int) – BPS_DENOMINATOR returned by the same contract.

Returns

Fee as a fractional Percent.

Raises

ValueError – If the manager reports an invalid denominator.

Return type

float

export_asseto_usd_denomination(chain_id)

Export non-transferable USD accounting metadata.

Asseto stoken products publish USD NAV without an ERC-20 collateral address. Products whose source NAV is HKD are also converted to USD before entering the shared live feed. This token-like record makes that accounting denomination explicit without implying a transferable USD token.

Parameters: chain_id (int) – EVM chain id for the fund record.
Returns: Synthetic USD token metadata.
Return type: dict[str, object]

class AssetoVaultInfo

Bases: eth_defi.vault.base.VaultInfo

Asseto product metadata exported by AssetoVault.

token: eth_typing.evm.HexAddress: ERC-20 AoABT token address.

chain_id: int: EVM chain id.

manager: Optional[eth_typing.evm.HexAddress]: Asseto request/claim manager contract.

pricer: Optional[eth_typing.evm.HexAddress]: Asseto NAV/share price contract.

collateral: Optional[eth_typing.evm.HexAddress]: Subscription and redemption collateral token.

nav_source: str: NAV source label.

source_denomination: Optional[str]: Currency in which Asseto publishes the source NAV.

usd_converted: bool: Whether source NAV is converted to USD for the shared feed.

__init__(*args, **kwargs)

__new__(**kwargs)

clear(): Remove all items from the dict.

copy(): Return a shallow copy of the dict.

fromkeys(value=None, /): Create a new dictionary with keys from iterable and values set to value.

get(key, default=None, /): Return the value for key if key is in the dictionary, else default.

items(): Return a set-like object providing a view on the dict’s items.

keys(): Return a set-like object providing a view on the dict’s keys.

pop(k[, d]) → v, remove specified key and return the corresponding value.: If the key is not found, return the default if given; otherwise, raise a KeyError.

popitem()

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

setdefault(key, default=None, /)

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

update([E, ]**F) → None. Update D from mapping/iterable E and F.: If E is present and has a .keys() method, then does: for k in E.keys(): D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

values(): Return an object providing a view on the dict’s values.

class AssetoVault

Bases: eth_defi.tokenised_fund.vault.TokenisedFundVault

Read-only adapter for Asseto tokenised fund products.

The adapter reads NAV/share from Asseto’s verified Pricer contract or public product history and calculates TVL from NAV and ERC-20 supply. It intentionally blocks deposits because product flows require off-chain KYC, fund dealing-cycle processing and administrator actions.

Create an Asseto product adapter.

Parameters

web3 – Connection to the Asseto product chain.
spec – Chain and AoABT token address.
token_cache – Token metadata cache used by fetch_erc20_details().
features – Shared classification features, expected to include ERC4626Feature.asseto_like.
default_block_identifier – Optional default block for metadata reads.
require_denomination_token – Whether a failed collateral token lookup is a hard error.

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

Create an Asseto product adapter.

Parameters

web3 (web3.main.Web3) – Connection to the Asseto product chain.
spec (eth_defi.vault.base.VaultSpec) – Chain and AoABT token address.
token_cache (Optional[dict]) – Token metadata cache used by fetch_erc20_details().
features (Optional[set[eth_defi.erc_4626.core.ERC4626Feature]]) – Shared classification features, expected to include ERC4626Feature.asseto_like.
default_block_identifier (Optional[Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]]) – Optional default block for metadata reads.
require_denomination_token (bool) – Whether a failed collateral token lookup is a hard error.

property chain_id: int: Return the product’s EVM chain id.

property address: eth_typing.evm.HexAddress: Return the AoABT share-token address used as the vault id.

property vault_address: eth_typing.evm.HexAddress: Return the compatibility alias used by shared vault scanner code.

property pricer_contract: web3.contract.contract.Contract: Return the Asseto NAV/share pricer contract.

property manager_contract: web3.contract.contract.Contract: Return the Asseto request/claim manager fee contract.

property name: str: Return the AoABT token name with product metadata fallback.

property symbol: str: Return the AoABT share-token symbol with product metadata fallback.

property description: Optional[str]: Return a short Asseto product description.

property short_description: Optional[str]: Return the concise product description used in vault listings.

get_link(referral=None)

Return the official product page or the Asseto product index.

Parameters: referral (Optional[str]) – Ignored because Asseto does not expose referral URLs.
Returns: Product-specific reviewed documentation when available, otherwise Asseto’s public product index.
Return type: str

property manager_name: Optional[str]

Return the Asseto product’s investment manager or advisor.

Asseto’s public application lists partners by role. An investment manager takes precedence over an investment advisor, as it is the closer match for the shared vault-curator concept. Unknown partner logos and optional API failures yield None rather than attributing the Asseto technology provider as the strategy curator.

property curator_slug: Optional[str]: Return the reviewed fund manager’s curator metadata identifier.

fetch_roles()

Fetch public Asseto partner roles for this vault product.

Asseto exposes its product partners through an undocumented public application API. The result includes role labels, Asseto logo URLs and an organisation name only where the logo is a recognised official asset. See https://asseto.finance/product for the source application.

Returns

Iterator of AssetoRoleInfo values in Asseto API order.

Raises

AssetoAPIError – If Asseto returns an invalid application response.
requests.RequestException – If the public application request fails.

Return type

collections.abc.Iterator[eth_defi.tokenised_fund.asseto.offchain_api.AssetoRoleInfo]

fetch_curator_name()

Resolve the strategy curator from Asseto’s priority partner roles.

Investment managers have priority over investment advisors. Generic advisory, custody, legal and administration roles intentionally do not produce a curator attribution.

Returns: Resolved investment manager or advisor organisation name, if known.
Return type: Optional[str]

fetch_share_token_address(block_identifier='latest')

Return the AoABT share-token address.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Accepted for scanner compatibility.
Returns: AoABT proxy address.
Return type: eth_typing.evm.HexAddress

fetch_share_token()

Fetch AoABT ERC-20 token metadata.

Returns: AoABT token details.
Return type: eth_defi.token.TokenDetails

fetch_denomination_token_address()

Return the manager’s collateral token address when published.

Collateral-less Asseto products use a synthetic USD accounting unit. They do not have an ERC-20 denomination token, so historical scanners must receive None instead of attempting to load token metadata.

Returns: Collateral address for the registered Asseto product, or None for a synthetic denomination.
Return type: Optional[eth_typing.evm.HexAddress]

fetch_denomination_token()

Fetch Asseto’s collateral token metadata.

Returns: Product collateral token details.
Return type: Optional[eth_defi.token.TokenDetails]

uses_onchain_pricer()

Return whether the product has a verified on-chain NAV contract.

Returns: True for products with an Asseto Pricer contract.
Return type: bool

converts_denomination_to_usd()

Return whether a non-USD Asseto NAV is converted for the live feed.

Returns: True when historical fiat exchange rates are configured.
Return type: bool

uses_synthetic_usd_denomination()

Return whether scanner metadata must expose accounting-only USD.

Returns: True for collateral-less USD products and fiat-converted NAV.
Return type: bool

convert_denomination_to_usd(value, timestamp=None)

Convert an Asseto NAV value from its source currency to USD.

Currency API rates are stored as units of quote currency per one USD, so a source value is divided by the latest observation on or before the NAV timestamp. USD and USD-stablecoin products pass through unchanged.

Parameters

value (decimal.Decimal) – Share price or total value in the Asseto source denomination.
timestamp (Optional[datetime.datetime]) – Naive UTC NAV timestamp. None selects the latest available rate.

Returns

Value in USD.

Raises

RuntimeError – If a non-USD product lacks a rate at the requested timestamp.

Return type

decimal.Decimal

get_share_price_source()

Return the configured Asseto product price source.

Products with a published Pricer are read at an archive block. Other reviewed products use Asseto’s public daily NAV API.

Returns: Smart-contract state or API source for this product.
Return type: eth_defi.vault.price_source.PriceSource

fetch_offchain_price_history()

Fetch and cache Asseto’s public daily NAV/share history.

Registry products without a published on-chain Pricer use this informational source for their historical backfill. The cache avoids making a network request for every historical scanner row.

Returns: Chronologically ordered Asseto display-price observations.
Raises: RuntimeError – If this product has no public Asseto registry identifier.
Return type: tuple[eth_defi.tokenised_fund.asseto.offchain_api.AssetoPricePoint, …]

fetch_offchain_share_price(timestamp)

Look up the latest published display NAV at a historical timestamp.

Asseto publishes daily observations, while the shared scanner samples at approximate chain blocks. Use the most recent observation at or before the sample timestamp and return None before history starts.

Parameters: timestamp (datetime.datetime) – Naive UTC scanner timestamp.
Returns: Asseto display NAV/share, or None when unavailable.
Return type: Optional[decimal.Decimal]

fetch_share_price(block_identifier='latest')

Fetch the latest Asseto NAV/share in USD accounting units.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Historical or latest block identifier.
Returns: NAV for one human-readable token, or None when Asseto has not published a display-price observation.
Return type: Optional[decimal.Decimal]

fetch_total_supply(block_identifier='latest')

Fetch the outstanding AoABT share supply.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Historical or latest block identifier.
Returns: Human-readable AoABT supply.
Return type: decimal.Decimal

fetch_total_assets(block_identifier='latest')

Calculate TVL from AoABT supply and the administrator-published NAV.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Historical or latest block identifier.
Returns: Total assets in USD accounting units.
Return type: Optional[decimal.Decimal]

fetch_nav(block_identifier='latest')

Fetch Asseto product NAV.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Historical or latest block identifier.
Returns: Total assets in USD accounting units.
Return type: Optional[decimal.Decimal]

fetch_info()

Return Asseto product contract metadata.

Returns: Token, manager, pricer and collateral addresses.
Return type: eth_defi.tokenised_fund.asseto.vault.AssetoVaultInfo

fetch_scan_record_extra_data()

Return Asseto-specific scan diagnostics.

Returns: Product contract addresses, NAV source and blocked-flow status.
Return type: dict[str, object]

fetch_portfolio(universe, block_identifier=None)

Return no on-chain portfolio holdings.

The underlying fund and its custodian operate off-chain; token balances held by the share token or manager do not represent its portfolio.

Parameters

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

Returns

Empty spot portfolio.

Return type

eth_defi.vault.base.VaultPortfolio

has_block_range_event_support()

Return whether generic flow accounting is supported.

Returns: False because Asseto request/claim flow accounting is not yet implemented in this adapter.
Return type: bool

has_deposit_distribution_to_all_positions()

Return whether deposits are automatically distributed on-chain.

Returns: Always False for this tokenised fund adapter.
Return type: bool

get_flow_manager()

Reject generic flow-manager use.

Raises: NotImplementedError – Always, because request/claim event accounting is not implemented.
Return type: eth_defi.vault.base.VaultFlowManager

fetch_deposit_closed_reason()

Return why the deposit manager is blocked.

Returns: Permanent public-integration block reason.
Return type: str

fetch_redemption_closed_reason()

Return why the redemption manager is blocked.

Returns: Permanent public-integration block reason.
Return type: str

get_historical_reader(stateful)

Create the Asseto supply and NAV historical reader.

Parameters: stateful (bool) – Whether to attach adaptive read state.
Returns: Asseto historical reader.
Return type: eth_defi.vault.base.VaultHistoricalReader

get_fee_data()

Return Asseto fee data with current manager request fees.

The underlying-fund management and performance fees are reflected in NAV/share. The manager’s mintFee maps to the shared entry/deposit fee and its redemptionFee maps to the shared exit/withdraw fee. Both settings are read at the requested default block because they can be updated by the Asseto limitation administrator.

Returns: Asseto fund and manager fees in the shared fee data model.
Return type: eth_defi.vault.fee.FeeData

get_management_fee(block_identifier)

Return the documented annual underlying-fund management fee.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Ignored because this fee is fund documentation metadata, not a token-contract value.
Returns: Annual management fee when the Asseto product documents one.
Return type: Optional[float]

get_performance_fee(block_identifier)

Return the documented underlying-fund performance fee.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Ignored because this fee is fund documentation metadata, not a token-contract value.
Returns: Performance fee when the Asseto product documents one.
Return type: Optional[float]

get_deposit_fee(block_identifier)

Read the current entry fee from the manager’s mintFee.

AoABTManager deducts this fee from subscribed collateral before the request is assigned an NAV and claimed.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Historical or latest block identifier.
Returns: Entry/deposit fee as a fraction.
Return type: Optional[float]

get_withdraw_fee(block_identifier)

Read the current exit fee from the manager’s redemptionFee.

AoABTManager deducts this fee from collateral after calculating the redemption’s NAV value and before transferring it to the investor.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Historical or latest block identifier.
Returns: Exit/withdraw fee as a fraction.
Return type: Optional[float]

has_custom_fees()

Report fund fee terms that cannot fit the shared fee model.

AoABT’s documented performance fee has a 6% hurdle and the underlying fund’s redemption fee depends on the holder’s lock-up period. Those conditions cannot be represented by scalar fee fields.

Returns: True for Asseto products with conditional fund fee terms.
Return type: bool

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

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

Fetch a source-proven minimum deposit in decimal token units.

A None result means this adapter does not expose a known minimum; it does not prove the protocol accepts arbitrarily small deposits. A zero result means the adapter positively established that the vault has no minimum deposit.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Block at which to read the protocol configuration.
Returns: Decimal denomination-token minimum, or None when unknown.
Return type: Optional[decimal.Decimal]

fetch_minimum_redemption(block_identifier='latest')

Fetch a source-proven redemption minimum in decimal share units.

A None result means this adapter does not expose a known minimum; it does not prove the protocol accepts arbitrarily small redemptions. A zero result means the adapter positively established that the vault has no minimum redemption.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Block at which to read the protocol configuration.
Returns: Decimal vault-share minimum, or None when unknown.
Return type: Optional[decimal.Decimal]

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_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]

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

get_deposit_manager()

Return a manager that explicitly refuses public fund operations.

The manager gives runtime callers a typed refusal, while get_deposit_manager_capability() provides the corresponding report metadata. Concrete issuer integrations must replace both only after implementing their complete permission-aware dealing lifecycle.

Returns: Non-operational tokenised-fund deposit manager.
Return type: eth_defi.tokenised_fund.vault.TokenisedFundDepositManager

get_deposit_manager_capability()

Report explicit lack of public deposit and redemption support.

Returns: A two-direction capability with both operations disabled.
Return type: eth_defi.vault.deposit_redeem.VaultDepositManagerCapability

get_estimated_lock_up()

What is the estimated lock-up period for this vault.

Returns: None if not know
Return type: Optional[datetime.timedelta]

get_fee_mode()

Get how this vault accounts its fees.

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

get_flags()

Return vault flags including the tokenised fund classification.

Preserve address- and protocol-specific flags supplied by the generic vault implementation, then add the descriptive flag used by tokenised fund listings.

Returns: A new set containing all generic flags and VaultFlag.tokenised_fund.
Return type: set[eth_defi.vault.flag.VaultFlag]

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

Return an export caveat for the vault-wide whitelist status.

Adapters may attach a concise, stable explanation when a classification is an explicitly requested operating assumption or excludes an integration-specific permission mechanism. The note describes the policy classification only; it must not be used to report temporary deposit availability.

Returns: Export note, or None when the classification needs no caveat.
Return type: Optional[str]

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_account_whitelisted(address)

Determine whether an account has completed the vault’s KYC policy.

The result concerns KYC or manual identity-approval membership only. A protocol may still require scheduling, a token balance, an allowance, available capacity, or an open epoch before a deposit can be submitted. Callers must use the relevant deposit manager pre-flight before broadcasting a transaction.

Parameters: address (eth_typing.evm.HexAddress) – Account whose deposit-policy membership is queried.
Returns: True when the account has the required KYC/identity approval.
Raises: NotImplementedError – If the adapter cannot safely query account membership.
Return type: bool

is_whitelisted_deposit()

Classify tokenised-fund subscriptions as permissioned.

Tokenised-fund adapters model issuer-operated products whose subscriptions require investor eligibility, issuer approval, or both. This is a vault-wide classification: individual adapters may expose different KYC, allow-list, transfer-agent, or offchain settlement mechanisms, so is_account_whitelisted() remains protocol-specific.

Returns: Always True because tokenised-fund deposits are permissioned.
Return type: bool

property share_token: eth_defi.token.TokenDetails

ERC-20 that presents vault shares.

User gets shares on deposit and burns them on redemption

first_seen_at_block: int | None

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.