tokenised_fund.kinexys.vault

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

ODA-FACT tokenised fund vault adapter.

Kinexys Digital Assets Fungible Asset Contract, or ODA-FACT, instruments are permissioned ERC-20-compatible tokenised fund contracts. They are not ERC-4626 vaults, but the shared vault database and price scanner can track them through the eth_defi.vault.base.VaultBase interface.

The supported production contracts are JPMorgan’s OnChain Liquidity-Token Money Market Fund token JLTXX and My OnChain Net Yield Fund token MONY. Both use a FACT Diamond dispatcher:

Ethereum address: 0x09864f52B035AE22eE739dFa5c748fA080D07bD8
Contract architecture: EIP-2535 diamond
Token decimals: 2
Verified source package reference: @odaplatform/da-fact-smartcontracts

The adapter is scan-only. Active subscription, redemption and portfolio execution are intentionally unsupported.

Module Attributes

`JLTXX_PRODUCT_NAME`	Human-readable JLTXX product name.
`JLTXX_SHORT_DESCRIPTION`	JLTXX fact sheet short product description.
`JLTXX_MANAGER_NAME`	JLTXX issuer/platform display name.
`MONY_PRODUCT_NAME`	Human-readable MONY product name.
`MONY_SHORT_DESCRIPTION`	MONY public product description.
`MONY_MANAGER_NAME`	MONY issuer/platform display name.
`KINEXYS_MONEY_MARKET_FUND_ANNOUNCEMENT_URL`	Official J.P.
`JLTXX_ESTIMATED_NAV_SOURCE`	Diagnostic label for the temporary NAV estimate.
`MONY_NAV_SOURCE`	MONY's FACT Diamond has no on-chain NAV or share-price view.
`JLTXX_FACT_SHEET_URL`	JLTXX prospectus/fact sheet source URL.
`JLTXX_PROSPECTUS_URL`	JLTXX SEC prospectus source URL.
`KINEXYS_WHITELISTED_FLOW_REASON`	Public availability reason for Kinexys ODA-FACT fund flows.
`JLTXX_PROSPECTUS_MANAGEMENT_FEE`	Prospectus management fee, `0.08%` expressed as a fraction.
`JLTXX_PROSPECTUS_SERVICE_FEE`	Prospectus service fee, `0.10%` expressed as a fraction.
`JLTXX_PROSPECTUS_GROSS_EXPENSE_RATIO`	Prospectus gross total annual fund operating expenses, `0.71%` expressed as a fraction.
`JLTXX_PROSPECTUS_NET_EXPENSE_RATIO`	Prospectus net total annual fund operating expenses after waivers, `0.16%` expressed as a fraction.
`JLTXX_PROSPECTUS_FEE_WAIVER_UNTIL`	Prospectus fee waiver expiry date.
`ODA_FACT_FEES_BY_ADDRESS`	Hardcoded ODA-FACT fee lookup by lower-case contract address.

Functions

`export_oda_fact_usd_denomination`(chain_id)	Export synthetic USD accounting denomination metadata.
`is_mony`(address)	Check whether an address is the supported MONY FACT Diamond.

Classes

`OdaFactVault`	Scan-only adapter for ODA-FACT tokenised fund contracts.
`OdaFactVaultInfo`	ODA-FACT token metadata and compatibility settings.

class OdaFactVaultInfo

Bases: eth_defi.vault.base.VaultInfo

ODA-FACT token metadata and compatibility settings.

token: eth_typing.evm.HexAddress: ODA-FACT token and diamond address.

chain_id: int: Chain id.

denomination_token: Optional[eth_typing.evm.HexAddress]: ODA-FACT instruments do not expose an ERC-20 denomination token.

synthetic_usd_denomination: bool: Whether NAV is a USD estimate without an ERC-20 denomination token.

nav_source: str: NAV source label.

nav_estimated: bool: Whether NAV is estimated.

__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.

JLTXX_PRODUCT_NAME = 'JPMorgan OnChain Liquidity-Token Money Market Fund': Human-readable JLTXX product name.

JLTXX_SHORT_DESCRIPTION = 'U.S. Treasury bills, bonds and overnight repurchase-agreement strategy': JLTXX fact sheet short product description.

JLTXX_MANAGER_NAME = 'J.P. Morgan Kinexys': JLTXX issuer/platform display name.

MONY_PRODUCT_NAME = 'My OnChain Net Yield Fund': Human-readable MONY product name.

MONY_SHORT_DESCRIPTION = 'U.S. Treasury and Treasury-backed repurchase-agreement money-market strategy': MONY public product description.

MONY_MANAGER_NAME = 'J.P. Morgan Kinexys': MONY issuer/platform display name.

KINEXYS_MONEY_MARKET_FUND_ANNOUNCEMENT_URL = 'https://am.jpmorgan.com/us/en/asset-management/per/about-us/media/press-releases/jp-morgan-asset-management-launches-second-tokenized-fund-on-ethereum/': Official J.P. Morgan Asset Management announcement for the JLTXX and MONY tokenised money-market funds. Neither fund currently has a public individual landing page, so this is preferred over a generic Kinexys page.

JLTXX_ESTIMATED_NAV_PER_SHARE = Decimal('1'): Temporary JLTXX NAV estimate used until an official historical NAV source is wired in. JLTXX is a tokenised money-market fund share, but the ODA-FACT contract surface does not expose NAV on-chain.

JLTXX_ESTIMATED_NAV_SOURCE = 'estimated_jltxx_usd_1': Diagnostic label for the temporary NAV estimate.

MONY_NAV_SOURCE = 'unavailable_mony_no_onchain_nav': MONY’s FACT Diamond has no on-chain NAV or share-price view.

JLTXX_FACT_SHEET_URL = 'https://am.jpmorgan.com/content/dam/jpm-am-aem/americas/us/en/literature/fact-sheet/money-market/fs-ocltmm-t.pdf': JLTXX prospectus/fact sheet source URL.

JLTXX_PROSPECTUS_URL = 'https://www.sec.gov/Archives/edgar/data/1659326/000119312526217424/d44657d485bpos.htm': JLTXX SEC prospectus source URL.

KINEXYS_WHITELISTED_FLOW_REASON = 'Onchain deposits and redemptions are whitelisted and not available to the general public': Public availability reason for Kinexys ODA-FACT fund flows.

JLTXX_PROSPECTUS_MANAGEMENT_FEE: float = 0.0008: Prospectus management fee, 0.08% expressed as a fraction.

JLTXX_PROSPECTUS_SERVICE_FEE: float = 0.001: Prospectus service fee, 0.10% expressed as a fraction.

JLTXX_PROSPECTUS_GROSS_EXPENSE_RATIO: float = 0.0071: Prospectus gross total annual fund operating expenses, 0.71% expressed as a fraction.

JLTXX_PROSPECTUS_NET_EXPENSE_RATIO: float = 0.0016: Prospectus net total annual fund operating expenses after waivers, 0.16% expressed as a fraction.

JLTXX_PROSPECTUS_FEE_WAIVER_UNTIL = datetime.date(2028, 6, 30): Prospectus fee waiver expiry date.

JLTXX_FEE_DATA = FeeData(fee_mode=<VaultFeeMode.internalised_skimming: 'internalised_skimming'>, management=0.0016, performance=0.0, deposit=0.0, withdraw=0.0, protocol=None)

Shared vault fee model for JLTXX.

FeeData has only one annual management-like field. Use the prospectus net total annual fund operating expense after waivers because this is the investor-facing cost currently advertised for Token Class shares. Keep the gross expense ratio and prospectus breakdown in scan diagnostics.

ODA_FACT_FEES_BY_ADDRESS = {'0x09864f52b035ae22ee739dfa5c748fa080d07bd8': FeeData(fee_mode=<VaultFeeMode.internalised_skimming: 'internalised_skimming'>, management=0.0016, performance=0.0, deposit=0.0, withdraw=0.0, protocol=None)}: Hardcoded ODA-FACT fee lookup by lower-case contract address.

is_mony(address)

Check whether an address is the supported MONY FACT Diamond.

Parameters: address (Union[eth_typing.evm.HexAddress, str]) – Candidate EVM contract address.
Returns: True for the exact Ethereum MONY token address.
Return type: bool

export_oda_fact_usd_denomination(chain_id)

Export synthetic USD accounting denomination metadata.

ODA-FACT instruments do not expose an ERC-20 denomination token. The address and decimals fields stay None so downstream consumers do not attempt raw token amount conversions or on-chain transfers.

Parameters: chain_id (int) – Chain id for the scan row.
Returns: Fresh token-like metadata dictionary for export.
Return type: dict[str, object]

class OdaFactVault

Bases: eth_defi.tokenised_fund.vault.TokenisedFundVault

Scan-only adapter for ODA-FACT tokenised fund contracts.

The adapter reads ERC-20 supply from the ODA-FACT token itself. For the initial JLTXX integration, share price is an explicitly labelled 1.00 USD estimate until an official NAV feed is available.

Create an ODA-FACT vault adapter.

Parameters

web3 – Web3 connection.
spec – Chain and ODA-FACT token address.
token_cache – Token metadata cache used by fetch_erc20_details().
features – Shared pipeline feature flags. Expected to contain ERC4626Feature.oda_fact_like.
default_block_identifier – Default block for metadata reads.
require_denomination_token – Whether missing denomination token should raise through VaultBase.denomination_token.

synthetic_usd_denomination: ClassVar[bool] = True: ODA-FACT estimates already use USD accounting units. No surrogate ERC-20 is needed for generic scanner admission or freshness conversion.

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

Create an ODA-FACT vault adapter.

Parameters

web3 (web3.main.Web3) – Web3 connection.
spec (eth_defi.vault.base.VaultSpec) – Chain and ODA-FACT token address.
token_cache (Optional[dict]) – Token metadata cache used by fetch_erc20_details().
features (Optional[set[eth_defi.erc_4626.core.ERC4626Feature]]) – Shared pipeline feature flags. Expected to contain ERC4626Feature.oda_fact_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]]) – Default block for metadata reads.
require_denomination_token (bool) – Whether missing denomination token should raise through VaultBase.denomination_token.

property chain_id: int: EVM chain id for this ODA-FACT contract.

property address: eth_typing.evm.HexAddress: ODA-FACT token and diamond address.

property vault_address: eth_typing.evm.HexAddress: Compatibility alias for scanner code that expects vault_address.

property name: str: Token name, falling back to static product metadata.

property symbol: str: Token symbol.

property description: Optional[str]: Human-readable product description.

property short_description: Optional[str]: Short product description.

property manager_name: Optional[str]: Issuer or platform display name.

fetch_share_token_address(block_identifier='latest')

Return the ODA-FACT 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 compatibility with the shared historical scanner.
Returns: ODA-FACT token address.
Return type: eth_typing.evm.HexAddress

fetch_share_token()

Fetch ERC-20 metadata for the ODA-FACT token.

Returns: Token details for the ODA-FACT share token.
Return type: eth_defi.token.TokenDetails

fetch_denomination_token_address()

Return the ERC-20 denomination token address.

ODA-FACT fund accounting is USD-denominated but does not expose an ERC-4626 asset() token or any other ERC-20 denomination token. Exporting a surrogate token would make the vault appear to accept or redeem that asset, so this adapter reports no denomination token.

Returns: Always None.
Return type: Optional[eth_typing.evm.HexAddress]

fetch_denomination_token()

Fetch ERC-20 denomination token metadata.

Returns: Always None because ODA-FACT instruments do not expose a denomination token.
Return type: Optional[eth_defi.token.TokenDetails]

get_share_price_source()

Return the ODA-FACT share-price source classification.

JLTXX is exported using the explicitly labelled USD 1 NAV estimate. MONY has no share-price observation and therefore remains unknown.

Returns: Fixed-price source for JLTXX, otherwise None.
Return type: Optional[eth_defi.vault.price_source.PriceSource]

fetch_share_price(block_identifier='latest')

Fetch ODA-FACT share price when an authorised source is available.

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. The current implementation does not have block-specific NAV data.
Returns: Estimated JLTXX NAV per one human-readable share, or None for MONY because its FACT Diamond has no on-chain price or NAV view.
Return type: Optional[decimal.Decimal]

fetch_total_supply(block_identifier='latest')

Fetch total outstanding ODA-FACT token 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 token supply.
Return type: decimal.Decimal

fetch_total_assets(block_identifier='latest')

Fetch ODA-FACT TVL when a share NAV is available.

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: Estimated total assets in USD-denomination units, or None when the product provides no verified NAV.
Return type: Optional[decimal.Decimal]

fetch_nav(block_identifier='latest')

Fetch ODA-FACT 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: Estimated total assets in USD-denomination units, or None when the product provides no verified NAV.
Return type: Optional[decimal.Decimal]

fetch_info()

Return ODA-FACT metadata for this scan-only adapter.

Returns: Token and NAV-source metadata.
Return type: eth_defi.tokenised_fund.kinexys.vault.OdaFactVaultInfo

fetch_scan_record_extra_data()

Return ODA-FACT-specific scan-row diagnostics.

Returns: Private scan-row fields that make the temporary NAV and denomination assumptions explicit.
Return type: dict[str, object]

fetch_portfolio(universe, block_identifier=None)

Return an empty portfolio for the scan-only adapter.

ODA-FACT fund assets are not represented as on-chain ERC-20 holdings of the token contract. Portfolio composition requires an off-chain fund accounting feed and is intentionally out of scope.

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

Whether event-based deposit/redemption flow accounting is implemented.

Return type: bool

has_deposit_distribution_to_all_positions()

Whether deposits are automatically distributed to positions.

Return type: bool

get_flow_manager()

Get flow manager.

Raises: NotImplementedError – Always, because ODA-FACT flow accounting is not implemented yet.
Return type: eth_defi.vault.base.VaultFlowManager

fetch_deposit_closed_reason()

Return the Kinexys public deposit availability status.

Kinexys ODA-FACT contracts are permissioned tokenised fund contracts. On-chain subscriptions are available only to whitelisted parties and are not exposed through a public ERC-4626-style deposit flow.

Returns: Human-readable reason why public deposits are closed.
Return type: Optional[str]

fetch_redemption_closed_reason()

Return the Kinexys public redemption availability status.

Kinexys ODA-FACT contracts are permissioned tokenised fund contracts. On-chain redemptions are available only to whitelisted parties and are not exposed through a public ERC-4626-style redemption flow.

Returns: Human-readable reason why public redemptions are closed.
Return type: Optional[str]

get_historical_reader(stateful)

Get ODA-FACT historical reader.

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

get_fee_data()

Return hardcoded JLTXX prospectus fee data.

ODA-FACT product fees are not available from the on-chain token surface. J.P. Morgan’s JLTXX prospectus advertises 0.71% gross total annual fund operating expenses and 0.16% net total annual fund operating expenses after waivers through JLTXX_PROSPECTUS_FEE_WAIVER_UNTIL. The shared vault fee model has only one annual management-like field, so the current net expense ratio is exposed as management. performance, deposit and withdraw are reported as zero because they are not advertised as separate Token Class fees.

Returns: Hardcoded fee data for the known ODA-FACT contract, or broken fee data for unknown ODA-FACT addresses.
Return type: eth_defi.vault.fee.FeeData

get_management_fee(block_identifier)

Return JLTXX net annual expense ratio.

The fee is hardcoded from the JLTXX prospectus, because it is not readable from the ODA-FACT token contract.

Parameters: block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Ignored. Prospectus fee disclosure is not block-specific.
Returns: 0.0016 for JLTXX, representing 0.16% net annual fund operating expenses after waivers.
Return type: Optional[float]

get_performance_fee(block_identifier)

Return JLTXX 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. Prospectus fee disclosure is not block-specific.
Returns: 0 because the JLTXX Token Class prospectus does not advertise a separate performance fee.
Return type: Optional[float]

get_notes()

Return markdown notes for the known ODA-FACT vault.

The notes are stored in the shared vault notes matrix so both direct adapter users and downstream vault metric exports see the same vault-specific description.

Returns: Markdown note for JLTXX, or None for unknown ODA-FACT addresses.
Return type: Optional[str]

get_estimated_lock_up()

Return unknown lock-up.

Returns: None because subscription/redemption terms are off-chain.
Return type: Optional[datetime.timedelta]

get_link(referral=None)

Return the official fund-announcement link.

Parameters: referral (Optional[str]) – Ignored.
Returns: J.P. Morgan Asset Management announcement covering the product.
Return type: str

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')

Read the adapter’s available denomination-token liquidity.

Single-market adapters report market liquidity. Multi-market adapters such as Morpho and IPOR currently report idle vault assets, which can understate redeemable liquidity in their underlying markets. A user’s withdrawal can also be limited by share ownership or protocol restrictions. Non-lending adapters should leave this method unimplemented.

maxRedeem(address(0)) cannot measure market-wide liquidity because ERC-4626 caps redemptions by the owner’s share balance. The zero address normally holds no shares, so a zero result says nothing about 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_deposit_open()

Fetch the current protocol-defined deposit availability.

This is deliberately a tri-state value. True and False mean that the adapter read an authoritative vault-wide state; None means that the generic adapter cannot safely determine the state. It is separate from fetch_deposit_closed_reason(), because an absent human-readable reason does not prove that deposits are open.

Returns: True when deposits are open, False when they are closed, or None when the protocol does not expose a reliable global availability read.
Return type: Optional[bool]

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')

Read the adapter’s lending or capital-deployment utilisation.

Single-market adapters measure borrower utilisation. Multi-market adapters such as Morpho and IPOR currently measure allocation outside the vault, rather than aggregate utilisation by underlying borrowers. Non-lending adapters 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_fee(block_identifier)

Deposit fee is set to zero by default as vaults usually do not have deposit 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: Optional[float]

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_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. This base class is reserved for products with a legal fund structure, and must not be used merely because a DeFi vault issues epoch-settled shares.

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

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

Get the known investment strategy classifications for this vault.

Override this method when an adapter or its metadata source can determine the vault’s strategy. None means the strategy information is missing or has not yet been classified; it is distinct from an empty set, which would mean the strategy was evaluated but did not match any available tag. Maintained mappings normally omit an unclassified address; use StrategyTag.unknown only when research establishes that the strategy itself is unknown.

Returns: Strategy tag set, or None when the information is missing.
Return type: Optional[set[eth_defi.vault.strategy_tag.StrategyTag]]

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]

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

get_withdrawal_period()

Return binding withdrawal timing and optional settlement estimates.

Unlike get_estimated_lock_up(), this reports the redemption lifecycle after a user submits a valid withdrawal request. Adapters use min_period and max_period only for a binding smart-contract timing rule. An adapter may instead return a non-binding estimated_settlement for backtesting an offchain operating cadence or redemption wait; that estimate never establishes claimability and does not require a synthetic timing bound.

Returns: Withdrawal period details, or None when unavailable.
Return type: Optional[eth_defi.vault.base.WithdrawalPeriod]

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

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, manual identity approval, or recipient allowlist 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 pre-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.