erc_4626.vault_protocol.accountable.deposit_redeem

Documentation for eth_defi.erc_4626.vault_protocol.accountable.deposit_redeem Python module.

Accountable synchronous deposits and asynchronous redemption claims.

Accountable vaults use standard ERC-4626 deposit calls. Redemptions are requested with requestRedeem and later become claimable through the normal ERC-4626 redeem entry point. The contract exposes aggregate pending and claimable share balances per controller, rather than an independently claimable balance per request id.

Classes

`AccountableDepositManager`	Accountable adapter with synchronous deposits and claimed redemptions.
`AccountableRedemptionRequest`	Parse one Accountable `requestRedeem` transaction.
`AccountableRedemptionTicket`	Persisted Accountable redemption request identity.

class AccountableRedemptionTicket

Bases: eth_defi.vault.deposit_redeem.RedemptionTicket

Persisted Accountable redemption request identity.

Accountable’s later claimability getters are controller aggregates. The request id is retained for audit and event discovery. The public manager auto-claims only self-controlled tickets to their owner because the contract exposes controller-level, rather than request-level, balances.

request_id: int: Queue id emitted by RedeemRequest. Zero denotes instant fulfilment.

controller: eth_typing.evm.HexAddress: ERC-7540 controller that owns the aggregate pending and claimable state.

block_number: int: Block that emitted the request event.

block_timestamp: datetime.datetime: Naive UTC timestamp of the request block.

get_request_id()

Return the Accountable queue id.

Returns: Request id emitted by the vault.
Return type: int

__init__(vault_address, owner, to, raw_shares, tx_hash, request_id, controller, block_number, block_timestamp)

Parameters

vault_address (eth_typing.evm.HexAddress) –
owner (eth_typing.evm.HexAddress) –
to (eth_typing.evm.HexAddress) –
raw_shares (int) –
tx_hash (hexbytes.main.HexBytes) –
request_id (int) –
controller (eth_typing.evm.HexAddress) –
block_number (int) –
block_timestamp (datetime.datetime) –

Return type

None

class AccountableRedemptionRequest

Bases: eth_defi.vault.deposit_redeem.RedemptionRequest

Parse one Accountable requestRedeem transaction.

parse_redeem_transaction(tx_hashes)

Parse the exact RedeemRequest event emitted by the request.

Parameters: tx_hashes (list[hexbytes.main.HexBytes]) – Broadcast transaction hashes; the final item is the request call.
Returns: Restart-safe Accountable redemption ticket.
Raises: CannotParseRedemptionTransaction – If the receipt does not contain exactly one matching request event.
Return type: eth_defi.erc_4626.vault_protocol.accountable.deposit_redeem.AccountableRedemptionTicket

__init__(vault, owner, to, shares, raw_shares, funcs)

Parameters

vault (VaultBase) –
owner (eth_typing.evm.HexAddress) –
to (eth_typing.evm.HexAddress) –
shares (decimal.Decimal) –
raw_shares (int) –
funcs (list[web3.contract.contract.ContractFunction]) –

Return type

None

broadcast(from_=None, gas=1000000)

Broadcast all the transactions in this request.

Parameters

from – Address to send the transactions from
gas (int) – Gas limit to use for each transaction
from_ (eth_typing.evm.HexAddress) –

Returns

List of transaction hashes

Return type

list[hexbytes.main.HexBytes]

class AccountableDepositManager

Bases: eth_defi.erc_4626.deposit_redeem.ERC4626DepositManager

Accountable adapter with synchronous deposits and claimed redemptions.

create_deposit_request(owner, to=None, amount=None, raw_amount=None, check_max_deposit=True, check_enough_token=True)

Build one standard ERC-4626 deposit with an explicit receiver.

Parameters

owner (eth_typing.evm.HexAddress) – Address funding denomination tokens.
to (Optional[eth_typing.evm.HexAddress]) – Share receiver. Defaults to owner.
amount (Optional[decimal.Decimal]) – Decimal denomination amount, exclusive with raw amount.
raw_amount (Optional[int]) – Raw denomination amount, exclusive with amount.
check_max_deposit (bool) – Check the vault’s current ERC-4626 maximum.
check_enough_token (bool) – Check the owner’s token balance.

Returns

One-call synchronous deposit request.

Return type

eth_defi.erc_4626.deposit_redeem.ERC4626DepositRequest

create_redemption_request(owner, to=None, shares=None, raw_shares=None, check_max_deposit=True, check_enough_token=True)

Build a request that transfers shares into Accountable’s queue.

Accountable uses owner as controller and does not require a share-token allowance: requestRedeem itself escrows the shares. Its aggregate getters make two concurrent tickets ambiguous, so an existing pending or claimable request blocks a further request for this owner.

Parameters

owner (eth_typing.evm.HexAddress) – Share owner and Accountable controller.
to (Optional[eth_typing.evm.HexAddress]) – Final denomination receiver, which must be owner.
shares (Optional[decimal.Decimal]) – Decimal shares, exclusive with raw shares.
raw_shares (Optional[int]) – Raw shares, exclusive with shares.
check_max_deposit (bool) – Retained inherited API parameter; unused.
check_enough_token (bool) – Check the owner’s share balance.

Returns

One-call redemption request.

Return type

eth_defi.erc_4626.vault_protocol.accountable.deposit_redeem.AccountableRedemptionRequest

has_synchronous_deposit()

Return Accountable deposit completion mode.

Returns: Always True.
Return type: bool

has_synchronous_redemption()

Return Accountable redemption completion mode.

Returns: Always False because claims wait for settlement.
Return type: bool

is_deposit_in_progress(owner)

Report Accountable deposit queue state.

Parameters: owner (eth_typing.evm.HexAddress) – Ignored because deposits are synchronous.
Returns: Always False.
Return type: bool

is_redemption_in_progress(owner)

Check aggregate pending or claimable shares for a controller.

Parameters: owner (eth_typing.evm.HexAddress) – Accountable controller address.
Returns: True when an aggregate request or claim remains.
Return type: bool

can_create_deposit_request(owner)

Return the advisory standard ERC-4626 deposit availability.

Parameters: owner (eth_typing.evm.HexAddress) – Prospective deposit receiver.
Returns: Whether the current maximum deposit is positive.
Return type: bool

can_create_redemption_request(owner)

Check that no aggregate request exists and the owner has shares.

Parameters: owner (eth_typing.evm.HexAddress) – Prospective controller and share owner.
Returns: True when a new request is not locally precluded.
Return type: bool

estimate_redemption_delay()

Return no deterministic Accountable queue deadline.

Returns: Zero duration because settlement timing is strategy controlled.
Return type: datetime.timedelta

get_redemption_delay_over(address)

Return no deterministic claimability deadline.

Parameters: address (Union[eth_typing.evm.HexAddress, str]) – Ignored controller address.
Returns: Always None.
Return type: Optional[datetime.datetime]

get_redemption_request_status(ticket)

Map Accountable aggregate balances to the generic request status.

Claimability must be checked before pending status, because immediate settlement may leave a request id of zero and a non-zero claimable aggregate in the same transaction.

Parameters: ticket (eth_defi.erc_4626.vault_protocol.accountable.deposit_redeem.AccountableRedemptionTicket) – Persisted Accountable ticket.
Returns: Claimable, pending, or absent aggregate state.
Return type: eth_defi.vault.deposit_redeem.AsyncVaultRequestStatus

can_finish_redeem(redemption_ticket)

Check current aggregate claimability.

Parameters: redemption_ticket (eth_defi.erc_4626.vault_protocol.accountable.deposit_redeem.AccountableRedemptionTicket) – Accountable request ticket.
Returns: Whether this safe self-controlled ticket has claimable shares.
Return type: bool

finish_redemption(redemption_ticket)

Build a self-controlled claim for current claimable shares.

Accountable exposes a controller aggregate rather than a per-request claim balance. The public manager therefore only claims self-controlled tickets back to their share owner. It never directs an aggregate claim to a custom receiver or auto-claims a delegated-controller ticket. A settlement can make only part of the ticket claimable; claim the current amount, then repeat after the remaining shares settle.

Parameters: redemption_ticket (eth_defi.erc_4626.vault_protocol.accountable.deposit_redeem.AccountableRedemptionTicket) – Accountable request ticket.
Returns: Current-claimable redeem function call.
Raises: ValueError – If this ticket is delegated, has a custom receiver, or has no claimable shares.
Return type: web3.contract.contract.ContractFunction

estimate_redeem(owner, shares, block_identifier='latest')

Estimate assets using Accountable’s non-reverting conversion method.

Accountable intentionally makes previewRedeem revert, while convertToAssets reflects its current share price.

Parameters

owner (eth_typing.evm.HexAddress) – Ignored owner retained for the common manager API.
shares (decimal.Decimal) – Decimal share amount.
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 conversion.

Returns

Estimated denomination assets.

Return type

decimal.Decimal

serialize_redemption_ticket(ticket)

Serialise Accountable request identity for restart-safe claims.

Parameters: ticket (eth_defi.erc_4626.vault_protocol.accountable.deposit_redeem.AccountableRedemptionTicket) – Ticket to serialise.
Returns: JSON-compatible ticket data.
Return type: dict

reconstruct_redemption_ticket(data)

Rebuild an Accountable ticket from persisted data.

Parameters: data (dict) – JSON-compatible serialised ticket data.
Returns: Restored Accountable ticket.
Return type: eth_defi.erc_4626.vault_protocol.accountable.deposit_redeem.AccountableRedemptionTicket

fetch_vault_flow_events(hypersync_client, start_block, end_block)

Fetch historical Accountable RedeemRequest logs.

Parameters

hypersync_client (hypersync.HypersyncClient) – Configured Monad Hypersync client.
start_block (int) – Inclusive request-event range start.
end_block (int) – Inclusive request-event range end.

Returns

Event-derived pending redemption discovery hints.

Return type

collections.abc.Iterator[eth_defi.vault.flow_events.PendingVaultFlow]

__init__(vault)

Parameters: vault (ERC4626Vault) –

analyse_deposit(claim_tx_hash, deposit_ticket)

Analyse a mined ERC-4626 deposit or guarded SimpleVault wrapper.

A ticket identifies an expected SimpleVault wrapper by address. The event analyser still filters events by the underlying vault address.

Parameters

claim_tx_hash (Union[hexbytes.main.HexBytes, str]) – Mined deposit transaction hash.
deposit_ticket (Optional[eth_defi.vault.deposit_redeem.DepositTicket]) – Optional ticket whose owner identifies a guarded wrapper.

Returns

Decoded executed deposit quantities or a revert description.

Return type

Union[eth_defi.vault.deposit_redeem.DepositRedeemEventAnalysis, eth_defi.vault.deposit_redeem.DepositRedeemEventFailure]

analyse_redemption(claim_tx_hash, redemption_ticket)

Analyse a mined ERC-4626 redemption or guarded SimpleVault wrapper.

A ticket identifies the wrapper only for the transaction-target check; the decoded Withdraw event must still originate from this vault.

Parameters

claim_tx_hash (Union[hexbytes.main.HexBytes, str]) – Mined redemption transaction hash.
redemption_ticket (Optional[eth_defi.vault.deposit_redeem.RedemptionTicket]) – Optional ticket whose owner identifies a guarded wrapper.

Returns

Decoded executed redemption quantities or a revert description.

Return type

Union[eth_defi.vault.deposit_redeem.DepositRedeemEventAnalysis, eth_defi.vault.deposit_redeem.DepositRedeemEventFailure]

can_finish_deposit(deposit_ticket)

Synchronous deposits can be finished immediately.

Parameters: deposit_ticket (eth_defi.erc_4626.deposit_redeem.ERC4626DepositTicket) –

estimate_deposit(owner, amount, block_identifier='latest')

How many shares we get for a deposit.

Parameters

owner (eth_typing.evm.HexAddress) –
amount (decimal.Decimal) –
block_identifier (Union[Literal['latest', 'earliest', 'pending', 'safe', 'finalized'], eth_typing.evm.BlockNumber, eth_typing.evm.Hash32, eth_typing.encoding.HexStr, int]) –

Return type

decimal.Decimal

fetch_completed_redemption_tx_hash(ticket)

Find an operator-owned terminal redemption transaction when available.

Claim-based protocols finish through finish_redemption() and do not need this lookup. Operator-finalised protocols override the hook to find and validate the transaction that paid the requested receiver.

Parameters: ticket (eth_defi.vault.deposit_redeem.RedemptionTicket) – Persisted redemption request to locate.
Returns: Terminal transaction hash, or None if the protocol has not observed one yet.
Return type: Optional[hexbytes.main.HexBytes]

finish_deposit(deposit_ticket)

Can we finish the deposit process in async vault.

We can claim our shares from the vault now

Parameters: deposit_ticket (eth_defi.vault.deposit_redeem.DepositTicket) –
Return type: web3.contract.contract.ContractFunction

get_deposit_approval_target()

Return the ERC-20 spender required for a deposit request.

Standard ERC-4626 and the currently supported async adapters pull denomination tokens from the vault address itself. An adapter using a different router or silo must override this method; guarded callers use it to whitelist and validate the exact approval calldata.

Returns: ERC-20 approval spender address.
Return type: eth_typing.evm.HexAddress

get_deposit_delay_over(address)

Estimate when a pending async deposit request will settle.

Mirror of get_redemption_delay_over() for the deposit side.
Used to show an estimated settlement time for unsettled deposits (e.g. in the trade-executor trade-ui table).
Default returns None: the protocol has no deterministic on-chain settlement schedule (e.g. operator-driven ERC-7540 vaults like Lagoon). Subclasses with a predictable settlement cadence (e.g. Ostium V1.5) override this to return an estimated UTC timestamp.

Parameters: address (Union[eth_typing.evm.HexAddress, str]) – Owner of the pending deposit request.
Returns: Naive UTC timestamp when the deposit is expected to settle, or None when no on-chain estimate is available.
Return type: Optional[datetime.datetime]

get_deposit_request_status(ticket)

Query the current status of an async deposit request.

Default implementation probes via can_finish_deposit(). Subclasses should override for more accurate status reporting (e.g. distinguishing reclaimable from pending).

Parameters: ticket (eth_defi.vault.deposit_redeem.DepositTicket) –
Return type: eth_defi.vault.deposit_redeem.AsyncVaultRequestStatus

get_max_deposit(owner)

How much we can deposit

Parameters: owner (eth_typing.evm.HexAddress) –
Return type: Optional[decimal.Decimal]

reclaim_deposit(ticket)

Return a function to recover funds after a failed async deposit settlement.

Returns None if the protocol does not support reclaim.

Parameters: ticket (eth_defi.vault.deposit_redeem.DepositTicket) –
Return type: Optional[web3.contract.contract.ContractFunction]

reclaim_withdrawal(ticket)

Return a function to recover shares after a failed async withdrawal settlement.

Returns None if the protocol does not support reclaim.

Parameters: ticket (eth_defi.vault.deposit_redeem.RedemptionTicket) –
Return type: Optional[web3.contract.contract.ContractFunction]

reconstruct_deposit_ticket(data)

Reconstruct a deposit ticket from a serialised dict.

Default returns a base DepositTicket. Subclasses override for protocol-specific ticket types.

Parameters: data (dict) –
Return type: eth_defi.vault.deposit_redeem.DepositTicket

serialize_deposit_ticket(ticket)

Serialise a deposit ticket to a dict for persistence.

The trade-executor stores this in trade.other_data so that the settlement retry module can reconstruct the ticket after a process restart.

Default implementation stores base DepositTicket fields. Subclasses override to add protocol-specific fields (e.g. settlement_id for Ostium, requestId for ERC-7540).

Parameters: ticket (eth_defi.vault.deposit_redeem.DepositTicket) –
Return type: dict