AccountableVault

Documentation for eth_defi.erc_4626.vault_protocol.accountable.vault.AccountableVault Python class.

class AccountableVault

Bases: eth_defi.erc_4626.vault.ERC4626Vault

Accountable Capital vault support.

Accountable Capital develops blockchain-based financial verification technology that enables organisations and investors to demonstrate solvency, liquidity, and compliance through transparent, verifiable attestations. The platform combines cryptographic proofs with auditable financial data to enhance trust across Web3 and traditional finance.

Accountable vaults implement ERC-7540 async redemption pattern with a queue system for processing withdrawal requests.

Accountable’s totalAssets() only returns the idle liquidity held by the vault contract. When the strategy deploys capital via lockAssets(), those assets are subtracted from totalAssets(). This means totalAssets() severely underreports the true vault value.

The true NAV is computed as convertToAssets(totalSupply()), which uses sharePrice() — the oracle/strategy-set price that reflects all capital including deployed positions. Both fetch_total_assets() and AccountableHistoricalReader use this corrected calculation.

The raw totalAssets() value is exposed via fetch_idle_capital() and fetch_available_liquidity() as it represents capital available for immediate withdrawals.

Key contract functions for NAV:

• sharePrice() — current price per share (reflects deployed capital)

• totalSupply() — total shares outstanding

• convertToAssets(shares) — converts shares to assets using share price

• totalAssets() — idle liquidity only (excludes deployed capital)

• lockAssets(assets, sender) — strategy deploys capital (reduces totalAssets)

• releaseAssets(assets, receiver) — strategy returns capital (increases totalAssets)

• reservedLiquidity() — assets reserved for pending redemptions

• Homepage: https://www.accountable.capital/

• Twitter: https://x.com/AccountableData

• No public GitHub repository available for smart contracts

• Example contract: https://monadscan.com/address/0x58ba69b289De313E66A13B7D1F822Fc98b970554

Parameters

• web3 – Connection we bind this instance to

• spec – Chain, address tuple

• token_cache –

  Cache used with fetch_erc20_details() to avoid multiple calls to the same token.

  Reduces the number of RPC calls when scanning multiple vaults.

• features – Pass vault feature flags along, externally detected.

• default_block_identifier –

  Override block identifier for on-chain metadata reads.

  When None, use get_safe_cached_latest_block_number() (the default, safe for broken RPCs). Set to "latest" for freshly deployed vaults whose contracts do not exist at the safe-cached block.

• require_denomination_token – If True, accessing denomination_token will raise RuntimeError when the on-chain lookup returns None.

Attributes summary

accountable_metadata	Offchain metadata from Accountable's yield app API.
address	Get the vault smart contract address.
chain_id	Chain this vault is on
denomination_token	Get the token which denominates the vault valuation
deposit_manager	Deposit manager assocaited with this vault
description	Full vault strategy description from Accountable's offchain metadata.
erc_7540	Is this ERC-7540 vault with asynchronous deposits.
flow_manager	Flow manager associated with this vault
info	Get info dictionary related to this vault deployment.
name	Vault name.
share_token	ERC-20 that presents vault shares.
short_description	Company/manager description from Accountable's offchain metadata.
symbol	Vault share token symbol
underlying_token	Alias for denomination_token()
vault_address
vault_address_checksumless
vault_contract	Get vault deployment with Accountable-specific ABI.

Methods summary

__init__(web3, spec[, token_cache, ...])	param web3
can_check_deposit()	Check if maxDeposit(address(0)) can be used to check global deposit availability.
can_check_redeem()	Check if maxRedeem(address(0)) can be used to check global redemption availability.
fetch_available_liquidity([block_identifier])	Get the amount of denomination token available for immediate withdrawal.
fetch_denomination_token()	Read denomination token from onchain.
fetch_denomination_token_address()	Get the asset() denomination token address of this vault.
fetch_deposit_closed_reason()	Check if deposits are closed using maxDeposit(address(0)).
fetch_deposit_next_open()	Get when deposits will next be open.
fetch_idle_capital([block_identifier])	Fetch idle capital held by the vault contract.
fetch_info()	Use info() property for cached access.
fetch_nav([block_identifier])	Fetch the most recent onchain NAV value.
fetch_portfolio(universe[, ...])	Read the current token balances of a vault.
fetch_redemption_closed_reason()	Check if redemptions are closed using maxRedeem(address(0)).
fetch_redemption_next_open()	Get when withdrawals/redemptions will next be open.
fetch_share_price(block_identifier)	Get the current share price.
fetch_share_token()	Read share token details onchain.
fetch_share_token_address([block_identifier])	Get share token of this vault.
fetch_total_assets(block_identifier)	Fetch the true vault NAV including deployed capital.
fetch_total_supply(block_identifier)	What is the current outstanding shares.
fetch_utilisation_percent([block_identifier])	Get the percentage of assets currently deployed by the strategy.
fetch_vault_info()	Get all information we can extract from the vault smart contracts.
get_deposit_fee(block_identifier)	Deposit fee is set to zero by default as vaults usually do not have deposit fees.
get_deposit_manager()	Get deposit manager to deposit/redeem from the vault.
get_estimated_lock_up()	Accountable vaults use async redemption queue.
get_fee_data()	Get fee data structure for this vault.
get_fee_mode()	Get how this vault accounts its fees.
get_flags()	Get various vault state flags from the smart contract.
get_flow_manager()	Get flow manager to read indiviaul settle events.
get_historical_reader(stateful)	Get share price reader to fetch historical returns.
get_link([referral])	Return the yield app link.
get_management_fee(block_identifier)	Management fee is not publicly available.
get_notes()	Get a human readable message if we know somethign special is going on with this vault.
get_performance_fee(block_identifier)	Performance fee from Accountable's offchain metadata.
get_protocol_name()	Return the name of the vault protocol.
get_risk()	Get risk profile of this vault.
get_spec()
get_withdraw_fee(block_identifier)	Withdraw fee is set to zero by default as vaults usually do not have withdraw fees.
has_block_range_event_support()	Does this vault support block range-based event queries for deposits and redemptions.
has_custom_fees()	Does this vault have custom fee structure reading methods.
has_deposit_distribution_to_all_positions()	Deposits go automatically to all open positions.
is_valid()	Check if this vault is valid.

property vault_contract: web3.contract.contract.Contract

Get vault deployment with Accountable-specific ABI.

get_historical_reader(stateful)

Get share price reader to fetch historical returns.

Parameters

stateful – If True, use a stateful reading strategy.

Returns

None if unsupported

Return type

eth_defi.vault.base.VaultHistoricalReader

fetch_idle_capital(block_identifier='latest')

Fetch idle capital held by the vault contract.

This is the raw totalAssets() value — assets sitting in the vault that have not been deployed by the strategy via lockAssets(). This is the capital available for immediate withdrawals.

Parameters

block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Block number to read.

Returns

Idle capital in underlying token, or None if denomination token is unavailable.

Return type

Optional[decimal.Decimal]

fetch_total_assets(block_identifier)

Fetch the true vault NAV including deployed capital.

Accountable’s totalAssets() only returns idle liquidity. We compute the true NAV as convertToAssets(totalSupply()), which uses the strategy-set sharePrice() to account for all capital including deployed positions.

Parameters

block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) – Block number to read.

Returns

The vault NAV in underlying token, or None if denomination token is unavailable.

Return type

Optional[decimal.Decimal]

fetch_nav(block_identifier=None)

Fetch the most recent onchain NAV value.

Uses convertToAssets(totalSupply()) instead of totalAssets() because Accountable’s totalAssets() excludes deployed capital.

Returns

Vault NAV, denominated in denomination_token()

Return type

decimal.Decimal

fetch_available_liquidity(block_identifier='latest')

Get the amount of denomination token available for immediate withdrawal.

For Accountable vaults, this is totalAssets() which returns only idle capital not deployed by the strategy.

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

Returns

Amount in denomination token units (human-readable Decimal).

Return type

Optional[decimal.Decimal]

fetch_utilisation_percent(block_identifier='latest')

Get the percentage of assets currently deployed by the strategy.

Utilisation = (true NAV - idle capital) / true NAV

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

Returns

Utilisation as float between 0.0 and 1.0 (0% to 100%).

Return type

Optional[float]

property accountable_metadata: Optional[eth_defi.erc_4626.vault_protocol.accountable.offchain_metadata.AccountableVaultMetadata]

Offchain metadata from Accountable’s yield app API.

Fetched from yield.accountable.capital/api/loan. Cached on disk and in-process to avoid repeated API calls.

property description: Optional[str]

Full vault strategy description from Accountable’s offchain metadata.

property short_description: Optional[str]

Company/manager description from Accountable’s offchain metadata.

get_management_fee(block_identifier)

Management fee is not publicly available.

Accountable vaults do not expose fee information on-chain.

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

Performance fee from Accountable’s offchain metadata.

Falls back to None if metadata is unavailable.

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

Accountable vaults use async redemption queue.

Lock-up period depends on the vault strategy and available liquidity.

Return type

Optional[datetime.timedelta]

get_link(referral=None)

Return the yield app link.

Accountable’s yield app URLs use the loan/strategy contract address, not the ERC-4626 vault (share token) address. Falls back to the vault address if metadata is unavailable.

Parameters

referral (Optional[str]) –

Return type

str

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

Parameters

• web3 (web3.main.Web3) – Connection we bind this instance to

• spec (eth_defi.vault.base.VaultSpec) – Chain, address tuple

• token_cache (Optional[dict]) –

  Cache used with fetch_erc20_details() to avoid multiple calls to the same token.

  Reduces the number of RPC calls when scanning multiple vaults.

• features (Optional[set[eth_defi.erc_4626.core.ERC4626Feature]]) – Pass vault feature flags along, externally detected.

• default_block_identifier (Optional[Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]]) –

  Override block identifier for on-chain metadata reads.

  When None, use get_safe_cached_latest_block_number() (the default, safe for broken RPCs). Set to "latest" for freshly deployed vaults whose contracts do not exist at the safe-cached block.

• require_denomination_token (bool) – If True, accessing denomination_token will raise RuntimeError when the on-chain lookup returns None.

property address: eth_typing.evm.HexAddress

Get the vault smart contract address.

can_check_deposit()

Check if maxDeposit(address(0)) can be used to check global deposit availability.

Most ERC-4626 vaults implement maxDeposit in a way that returns meaningful values when called with address(0):

• Returns 0 when deposits are globally closed/capped

• Returns a positive value indicating maximum deposit allowed

Override to return False in subclasses where maxDeposit(address(0)) doesn’t provide meaningful global availability information.

Returns

True if maxDeposit(address(0)) returns meaningful values for global deposit availability checking.

Return type

bool

can_check_redeem()

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

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

• Gearbox: maxRedeem returns min(balanceOf(owner), convertToShares(availableLiquidity))

• Most vaults: Return 0 because address(0) has no shares

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

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

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

Returns

True if maxRedeem(address(0)) returns meaningful values for global redemption availability checking.

Return type

bool

property chain_id: int

Chain this vault is on

property denomination_token: Optional[eth_defi.token.TokenDetails]

Get the token which denominates the vault valuation

• Used in deposits and redemptions

• Used in NAV calculation

• Used in profit benchmarks

• Usually USDC

Returns

Token wrapper instance.

Maybe None for broken vaults like https://arbiscan.io/address/0x9d0fbc852deccb7dcdd6cb224fa7561efda74411#code

Note

None results are not cached — the next access will retry the on-chain call. This avoids permanently caching a transient RPC failure.

property deposit_manager: eth_defi.vault.deposit_redeem.VaultDepositManager

Deposit manager assocaited with this vault

property erc_7540: bool

Is this ERC-7540 vault with asynchronous deposits.

• For example previewDeposit() function and other functions will revert

fetch_denomination_token()

Read denomination token from onchain.

Use denomination_token() for cached access.

Return type

Optional[eth_defi.token.TokenDetails]

fetch_denomination_token_address()

Get the asset() denomination token address of this vault.

Results are disk-cached per (chain_id, vault_address) via eth_defi.erc_4626.vault_token when the vault was constructed with a eth_defi.token.TokenDiskCache and no pinned default_block_identifier. The denomination token is immutable post-deployment, so the cached value is correct regardless of which block the caller would have asked for.

Only a definitive non-null answer is persisted. The None path taken on revert / broken contract is never cached, matching the behaviour of eth_defi.vault.base.VaultBase.denomination_token() which explicitly avoids memoising None so transient failures can be retried.

To disable the cache, pass token_cache=None (or any non- TokenDiskCache dict) when constructing the vault, or construct with a pinned default_block_identifier.

Returns

Denomination token address, or None if the vault contract is broken and did not return a valid address.

Return type

Optional[eth_typing.evm.HexAddress]

fetch_deposit_closed_reason()

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

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

Returns

Human-readable string if deposits are closed/restricted, or None if deposits are open (maxDeposit > 0).

Return type

Optional[str]

fetch_deposit_next_open()

Get when deposits will next be open.

• For epoch-based vaults (Ostium, D2), return calculated window open time

• For non-epoch vaults (Plutus, IPOR, Morpho), return None

• Override in protocol-specific subclasses

Returns

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

• Deposits are currently open

• Timing is unpredictable (manually controlled)

• Protocol does not support timing information

Return type

Optional[datetime.datetime]

fetch_info()

Use info() property for cached access.

Returns

See LagoonVaultInfo

Return type

eth_defi.erc_4626.vault.ERC4626VaultInfo

fetch_portfolio(universe, block_identifier=None, allow_fallback=True)

Read the current token balances of a vault.

• SHould be supported by all implementations

Parameters

• universe (eth_defi.vault.base.TradingUniverse) –

• block_identifier (Optional[Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]]) –

• allow_fallback (bool) –

Return type

eth_defi.vault.base.VaultPortfolio

fetch_redemption_closed_reason()

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

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

Returns

Human-readable string if redemptions are closed, or None if redemptions are open or check is not supported.

Return type

Optional[str]

fetch_redemption_next_open()

Get when withdrawals/redemptions will next be open.

• For epoch-based vaults (Ostium, D2), return calculated window open time

• For non-epoch vaults (Plutus, IPOR, Morpho), return None

• Override in protocol-specific subclasses

Returns

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

• Withdrawals are currently open

• Timing is unpredictable (manually controlled)

• Protocol does not support timing information

Return type

Optional[datetime.datetime]

fetch_share_price(block_identifier)

Get the current share price.

Returns

The share price in underlying token.

If supply is zero return zero.

Parameters

block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) –

Return type

decimal.Decimal

fetch_share_token()

Read share token details onchain.

Use share_token() for cached access.

Return type

eth_defi.token.TokenDetails

fetch_share_token_address(block_identifier='latest')

Get share token of this vault.

• Vault itself (ERC-4626)

• share() accessor (ERC-7575)

Results are disk-cached per (chain_id, vault_address) via eth_defi.erc_4626.vault_token when the vault was constructed with a eth_defi.token.TokenDiskCache. Under normal circumstances the block_identifier argument is effectively ignored on cache hits — ERC-4626 share tokens are immutable post-deployment, so the cached value is correct regardless of which block the caller asked for.

Only a definitive answer from the chain is ever persisted: a successful call, or a revert matching KNOWN_SHARE_TOKEN_ERROR_MESSAGES (which positively classifies the contract as non-ERC-7575). Transient RPC failures (ProbablyNodeHasNoBlock, HTTP 502) fall back to self.vault_address but are not written to the cache, so a flaky node cannot poison a real ERC-7575 vault’s entry.

To disable the cache, pass token_cache=None (or any non- TokenDiskCache dict) when constructing the vault, or construct with a pinned default_block_identifier to force the uncached historical-read path on every call.

Parameters

block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) – Block to query. Cache is only consulted/written when the caller passes the default "latest" and the vault instance has no pinned default_block_identifier.

Return type

eth_typing.evm.HexAddress

fetch_total_supply(block_identifier)

What is the current outstanding shares.

Example:

Parameters

block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, hexbytes.main.HexBytes, int]) –

Block number to read.

Use web3.eth.block_number for the last block.

Returns

The vault value in underlyinh token

Return type

decimal.Decimal

fetch_vault_info()

Get all information we can extract from the vault smart contracts.

Return type

eth_defi.erc_4626.vault.ERC4626VaultInfo

property flow_manager: eth_defi.vault.base.VaultFlowManager

Flow manager associated with this vault

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

Get deposit manager to deposit/redeem from the vault.

Return type

eth_defi.erc_4626.deposit_redeem.ERC4626DepositManager

get_fee_data()

Get fee data structure for this vault.

Raises

ValueError – In the case of broken or unimplemented fee reading methods in the smart contract

Return type

eth_defi.vault.fee.FeeData

get_fee_mode()

Get how this vault accounts its fees.

Return type

Optional[eth_defi.vault.fee.VaultFeeMode]

get_flags()

Get various vault state flags from the smart contract.

• Override to add status flags

• Also add flags from our manual flag list in eth_defi.vault.flag

Returns

Flag set.

Do not modify in place.

Return type

set[eth_defi.vault.flag.VaultFlag]

get_flow_manager()

Get flow manager to read indiviaul settle events.

• Only supported if has_block_range_event_support() is True

Return type

eth_defi.vault.base.VaultFlowManager

get_notes()

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

Return type

Optional[str]

get_protocol_name()

Return the name of the vault protocol.

Return type

str

get_risk()

Get risk profile of this vault.

Return type

Optional[eth_defi.vault.risk.VaultTechnicalRisk]

get_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

has_block_range_event_support()

Does this vault support block range-based event queries for deposits and redemptions.

• If not we use chain balance polling-based approach

has_custom_fees()

Does this vault have custom fee structure reading methods.

Causes risk in the vault comparison.

E.g.

• Withdraw fee

• Deposit fee

Returns

True if custom fee reading methods are implemented

Return type

bool

has_deposit_distribution_to_all_positions()

Deposits go automatically to all open positions.

• Deposits do not land into the vault as cash

• Instead, smart contracts automatically increase all open positions

• The behaviour of Velvet Capital

property info: eth_defi.vault.base.VaultInfo

Get info dictionary related to this vault deployment.

• Get cached data on the various vault parameters

Returns

Vault protocol specific information dictionary

is_valid()

Check if this vault is valid.

• Call a known smart contract function to verify the function exists

Return type

bool

property name: str

Vault name.

property share_token: eth_defi.token.TokenDetails

ERC-20 that presents vault shares.

• User gets shares on deposit and burns them on redemption

property symbol: str

Vault share token symbol

property underlying_token: eth_defi.token.TokenDetails

Alias for denomination_token()