AssetoVault

Documentation for eth_defi.tokenised_fund.asseto.vault.AssetoVault Python class.

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.

Attributes summary

`address`	Return the AoABT share-token address used as the vault id.
`chain_id`	Return the product's EVM chain id.
`curator_slug`	Return the reviewed fund manager's curator metadata identifier.
`denomination_token`	Get the token which denominates the vault valuation
`deposit_manager`	Deposit manager assocaited with this vault
`description`	Return a short Asseto product description.
`flow_manager`	Flow manager associated with this vault
`info`	Get info dictionary related to this vault deployment.
`manager_contract`	Return the Asseto request/claim manager fee contract.
`manager_name`	Return the Asseto product's investment manager or advisor.
`name`	Return the AoABT token name with product metadata fallback.
`pricer_contract`	Return the Asseto NAV/share pricer contract.
`share_token`	ERC-20 that presents vault shares.
`short_description`	Return the concise product description used in vault listings.
`symbol`	Return the AoABT share-token symbol with product metadata fallback.
`vault_address`	Return the compatibility alias used by shared vault scanner code.
`whitelist_notes`	Optional qualification for the exported whitelist status.

Methods summary

`__init__`(web3, spec[, token_cache, ...])	Create an Asseto product adapter.
`convert_denomination_to_usd`(value[, timestamp])	Convert an Asseto NAV value from its source currency to USD.
`converts_denomination_to_usd`()	Return whether a non-USD Asseto NAV is converted for the live feed.
`fetch_available_liquidity`([block_identifier])	Get the amount of denomination token available for immediate withdrawal.
`fetch_curator_name`()	Resolve the strategy curator from Asseto's priority partner roles.
`fetch_denomination_token`()	Fetch Asseto's collateral token metadata.
`fetch_denomination_token_address`()	Return the manager's collateral token address when published.
`fetch_deposit_closed_reason`()	Return why the deposit manager is blocked.
`fetch_deposit_next_open`()	Get when deposits will next be open.
`fetch_info`()	Return Asseto product contract metadata.
`fetch_minimum_deposit`([block_identifier])	Fetch a source-proven minimum deposit in decimal token units.
`fetch_minimum_redemption`([block_identifier])	Fetch a source-proven redemption minimum in decimal share units.
`fetch_nav`([block_identifier])	Fetch Asseto product NAV.
`fetch_offchain_price_history`()	Fetch and cache Asseto's public daily NAV/share history.
`fetch_offchain_share_price`(timestamp)	Look up the latest published display NAV at a historical timestamp.
`fetch_portfolio`(universe[, block_identifier])	Return no on-chain portfolio holdings.
`fetch_redemption_closed_reason`()	Return why the redemption manager is blocked.
`fetch_redemption_next_open`()	Get when withdrawals/redemptions will next be open.
`fetch_roles`()	Fetch public Asseto partner roles for this vault product.
`fetch_scan_record_extra_data`()	Return Asseto-specific scan diagnostics.
`fetch_share_price`([block_identifier])	Fetch the latest Asseto NAV/share in USD accounting units.
`fetch_share_token`()	Fetch AoABT ERC-20 token metadata.
`fetch_share_token_address`([block_identifier])	Return the AoABT share-token address.
`fetch_total_assets`([block_identifier])	Calculate TVL from AoABT supply and the administrator-published NAV.
`fetch_total_supply`([block_identifier])	Fetch the outstanding AoABT share supply.
`fetch_utilisation_percent`([block_identifier])	Get the percentage of assets currently lent out.
`get_deposit_fee`(block_identifier)	Read the current entry fee from the manager's `mintFee`.
`get_deposit_manager`()	Return a manager that explicitly refuses public fund operations.
`get_deposit_manager_capability`()	Report explicit lack of public deposit and redemption support.
`get_estimated_lock_up`()	What is the estimated lock-up period for this vault.
`get_fee_data`()	Return Asseto fee data with current manager request fees.
`get_fee_mode`()	Get how this vault accounts its fees.
`get_flags`()	Return vault flags including the tokenised fund classification.
`get_flow_manager`()	Reject generic flow-manager use.
`get_historical_reader`(stateful)	Create the Asseto supply and NAV historical reader.
`get_link`([referral])	Return the official product page or the Asseto product index.
`get_management_fee`(block_identifier)	Return the documented annual underlying-fund management fee.
`get_notes`()	Get a human readable message if we know somethign special is going on with this vault.
`get_performance_fee`(block_identifier)	Return the documented underlying-fund performance fee.
`get_protocol_name`()	Return the name of the vault protocol.
`get_risk`()	Get risk profile of this vault.
`get_share_price_source`()	Return the configured Asseto product price source.
`get_spec`()
`get_whitelist_notes`()	Return an export caveat for the vault-wide whitelist status.
`get_withdraw_fee`(block_identifier)	Read the current exit fee from the manager's `redemptionFee`.
`has_block_range_event_support`()	Return whether generic flow accounting is supported.
`has_custom_fees`()	Report fund fee terms that cannot fit the shared fee model.
`has_deposit_distribution_to_all_positions`()	Return whether deposits are automatically distributed on-chain.
`is_account_whitelisted`(address)	Determine whether an account has completed the vault's KYC policy.
`is_whitelisted_deposit`()	Classify tokenised-fund subscriptions as permissioned.
`uses_onchain_pricer`()	Return whether the product has a verified on-chain NAV contract.
`uses_synthetic_usd_denomination`()	Return whether scanner metadata must expose accounting-only USD.

__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