tokenised_fund.asseto.vault

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

Asseto tokenised fund vault adapter.

Asseto AoABT is a KYC-gated tokenised fund share, issued and redeemed through a separate request/claim manager using an administrator-published NAV. It is 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_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.

Classes

`AssetoVault`	Read-only adapter for Asseto AoABT 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_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

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.

__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.vault.base.VaultBase

Read-only adapter for Asseto AoABT tokenised fund products.

The adapter reads NAV/share from Asseto’s verified Pricer contract and calculates TVL from that NAV and the AoABT ERC-20 supply. It intentionally blocks the deposit manager because the on-chain request flow requires 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.

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.

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.

Returns: USDT collateral address for the registered Asseto product.
Return type: 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

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 collateral denomination.

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 collateral denomination.
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 the collateral denomination.
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

get_deposit_manager()

Block the public transaction manager.

Asseto subscriptions and redemptions require KYC eligibility, fund dealing-cycle settlement and privileged NAV/price-ID assignment.

Raises: NotImplementedError – Always, by deliberate product policy.
Return type: eth_defi.vault.deposit_redeem.VaultDepositManager

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

Return static public transaction-adapter support, if any.

This method deliberately does not attempt to construct a manager or query live pause, cap, epoch, balance, allow-list, or liquidity state. Adapters opt in only after their complete deposit and redemption lifecycles have focused coverage. None is therefore the safe default for unknown and protocol-specific vaults.

Returns: Adapter-specific capability object, or None when unsupported.
Return type: Optional[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()

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_link(referral=None)

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

By default, give RouteScan link

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

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]

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

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