CsigmaDepositManager

Documentation for eth_defi.erc_4626.vault_protocol.csigma.deposit_redeem.CsigmaDepositManager Python class.

class CsigmaDepositManager

Bases: eth_defi.erc_4626.deposit_redeem.ERC4626DepositManager

Synchronous cSigma ERC-4626 deposit and reserve-limited redemption flow.

cSigma Finance is an RWA private-credit protocol. Its CsigmaV2Pool is a plain synchronous ERC-4626 share token on the deposit side, but redemptions are limited to the pool’s onchain reserve and the excess is drained off-chain by a withdrawalManager. This manager keeps the whole lifecycle synchronous and preflights both directions so the caller learns of a capacity shortfall before broadcasting instead of decoding a raw revert.

Deposit process

Fully synchronous ERC-4626. create_deposit_request() builds the shared approve + deposit calls after converting the human amount to raw denomination units. The only capacity preflight is maxDeposit(owner) (fetch_depositable_raw_assets()); a request above it raises VaultFlowUnavailable (direction="deposit"). There is no minimum deposit, cooldown or per-account gate. Some deployments (for example cSigma USD) can be Pausable-paused, in which case the onchain deposit reverts.

Redemption process

Reserve-limited synchronous redeem — this is not an ERC-7540 async flow. fetch_redeemable_raw_shares() uses the verified queue gate, owner balance and idle reserve; it deliberately does not trust the pool-wide maxRedeem(owner) view. create_redemption_request() runs fetch_redemption_preflight() (a raw-share comparison, no rounding-sensitive conversion); a request above the immediate capacity raises VaultFlowUnavailable tagged with the decoded WithdrawalPending error and its selector 0xb34f5c6c. Onchain, that same over-capacity case (or an owner who already has a queued withdrawal) reverts WithdrawalPending() and the excess is enqueued off-chain.

Queues and settlement

The excess beyond the immediate reserve is queued off-chain and serviced later by the pool’s withdrawalManager on a first-in-first-out basis. The pool exposes no onchain request/ticket/claim surface for that queue (no requestRedeem / pendingRedeemRequest / claimableRedeemRequest / request id), so the queued portion cannot be modelled as a claimable async ticket and is surfaced only as the typed refusal above.

Lockups and cooldowns

No fixed lock-up or cooldown window. CsigmaVault.get_estimated_lock_up() returns None; when reserves are depleted the effective wait is the off-chain FIFO queue position, whose duration depends on RWA credit-market liquidity and is not deterministic.

Whitelisting / access control

Permissionless. There is no per-account whitelist or access manager; the only access gate is the optional protocol-wide Pausable pause on deposits.

Anvil settlement (force_settle)

No-op. Both directions are synchronous, so force_settle() accepts None for the shared synchronous no-op; there is no ticket to settle.

Note

A capacity result is a point-in-time advisory and can change before transaction inclusion.

Attributes summary

web3

Methods summary

`__init__`(vault)
`analyse_deposit`(claim_tx_hash, deposit_ticket)	Analyse a mined ERC-4626 deposit or guarded SimpleVault wrapper.
`analyse_redemption`(claim_tx_hash, ...)	Analyse a mined ERC-4626 redemption or guarded SimpleVault wrapper.
`can_create_deposit_request`(owner)	Report whether cSigma presently offers immediate deposit capacity.
`can_create_redemption_request`(owner)	Report whether cSigma presently offers immediate redemption capacity.
`can_finish_deposit`(deposit_ticket)	Synchronous deposits can be finished immediately.
`can_finish_redeem`(redemption_ticket)	Synchronous redemptions can be finished immediately.
`check_deposit_whitelist`(owner)	Reject a deposit when the vault's whitelist excludes the owner.
`create_deposit_request`(owner[, to, amount, ...])	Create a deposit request after checking cSigma asset capacity.
`create_deposit_request_for_guard_validation`(...)	Build ERC-4626 deposit calldata after a proven global closure.
`create_redemption_request`(owner[, to, ...])	Create a redemption request after checking cSigma share capacity.
`estimate_deposit`(owner, amount[, ...])	How many shares we get for a deposit.
`estimate_redeem`(owner, shares[, ...])	How many denomination tokens we get for a redeem.
`estimate_redemption_delay`()	Get the redemption delay for this vault.
`fetch_completed_redemption_tx_hash`(ticket)	Find an operator-owned terminal redemption transaction when available.
`fetch_depositable_raw_assets`(owner)	Fetch the cSigma deposit capacity expressed in raw assets.
`fetch_redeemable_raw_shares`(owner)	Fetch the queue-adjusted, owner-bounded immediate redemption capacity.
`fetch_redemption_preflight`(owner, raw_shares)	Check cSigma's owner-specific immediate redemption capacity.
`fetch_vault_flow_events`(hypersync_client, ...)	Fetch asynchronous vault request events from an indexed backend.
`fetch_withdrawal_manager_due_raw_shares`()	Fetch queue debt that blocks all user-initiated cSigma redemptions.
`finish_deposit`(deposit_ticket)	Can we finish the deposit process in async vault.
`finish_redemption`(redemption_ticket)	Build the depositor-owned final redemption transaction when one exists.
`force_redemption_liquidity`(owner, ...)	Provision an unavailable synchronous redemption on an Anvil fork.
`force_settle`(ticket, *[, mock, ignore_liquidity])	Force the selected ticket forward on an Anvil simulation.
`get_deposit_approval_target`()	Return the ERC-20 spender required for a deposit request.
`get_deposit_delay_over`(address)	Estimate when a pending async deposit request will settle.
`get_deposit_request_status`(ticket)	Query the current status of an async deposit request.
`get_max_deposit`(owner)	How much we can deposit
`get_redemption_delay_over`(address)	Get the redemption timer left for an address.
`get_redemption_request_status`(ticket)	Query the current status of an async redemption request.
`has_synchronous_deposit`()	Does this vault support synchronous deposits?
`has_synchronous_redemption`()	Does this vault support synchronous deposits?
`is_deposit_in_progress`(owner)	Check if the owner has an active deposit request.
`is_redemption_in_progress`(owner)	Check if the owner has an active redemption request.
`reclaim_deposit`(ticket)	Return a function to recover funds after a failed async deposit settlement.
`reclaim_withdrawal`(ticket)	Return a function to recover shares after a failed async withdrawal settlement.
`reconstruct_deposit_ticket`(data)	Reconstruct a deposit ticket from a serialised dict.
`reconstruct_redemption_ticket`(data)	Reconstruct a redemption ticket from a serialised dict.
`serialize_deposit_ticket`(ticket)	Serialise a deposit ticket to a dict for persistence.
`serialize_redemption_ticket`(ticket)	Serialise a redemption ticket to a dict for persistence.

fetch_withdrawal_manager_due_raw_shares()

Fetch queue debt that blocks all user-initiated cSigma redemptions.

The verified CsigmaV2Pool._withdraw() rejects a user redemption while the external withdrawalManager.totalDueLPToken() is non-zero. A read failure is deliberately fail-closed: callers receive None and must treat the immediate capacity as zero instead of broadcasting a redemption known to be unsafe to simulate.

Returns: Raw queued share debt, or None when its authoritative state cannot be read.
Return type: Optional[int]

fetch_redeemable_raw_shares(owner)

Fetch the queue-adjusted, owner-bounded immediate redemption capacity.

maxRedeem(owner) is deliberately not used: the verified V2 pool ignores owner and returns pool-wide idle cash even for an account with no shares. The actual redeem() path first rejects every user redemption while the withdrawal manager has due shares, then requires both an owner balance and enough idle reserve. This method mirrors those conditions without trying to model the offchain partial-fill queue.

Parameters: owner (eth_typing.evm.HexAddress) – Address whose immediately redeemable shares are queried.
Returns: Maximum raw vault shares that can be redeemed in full immediately.
Return type: int

fetch_depositable_raw_assets(owner)

Fetch the cSigma deposit capacity expressed in raw assets.

Parameters: owner (eth_typing.evm.HexAddress) – Address that will receive cSigma vault shares.
Returns: Maximum raw denomination-token amount immediately depositable by owner.
Return type: int

fetch_redemption_preflight(owner, raw_shares)

Check cSigma’s owner-specific immediate redemption capacity.

The queue-adjusted capacity is already denominated in raw vault shares, so this compares the requested and available values without a rounding-sensitive conversion.

Note

Trade-executor must map an unavailable result, or the matching VaultFlowUnavailable from create_redemption_request(), to redemption_capacity_limited before treating generic request failures as receipt-analysis failures.

Parameters

owner (eth_typing.evm.HexAddress) – Address whose immediate capacity is queried.
raw_shares (int) – Requested raw cSigma vault shares.

Returns

Available capacity result in raw shares.

Return type

eth_defi.vault.deposit_redeem.VaultRedemptionPreflight

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

Create a deposit request after checking cSigma asset capacity.

Parameters

owner (eth_typing.evm.HexAddress) – Address depositing denomination tokens and receiving shares.
to (Optional[eth_typing.evm.HexAddress]) – Retained for the base manager API compatibility.
amount (Optional[decimal.Decimal]) – Human-readable denomination-token amount when raw_amount is omitted.
raw_amount (Optional[int]) – Requested raw denomination-token amount.
check_max_deposit (bool) – Retained for the base manager API compatibility.
check_enough_token (bool) – Retained for the base manager API compatibility.

Returns

Transaction request ready for broadcast.

Raises

VaultFlowUnavailable – If the requested assets exceed the current cSigma capacity.

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)

Create a redemption request after checking cSigma share capacity.

Parameters

owner (eth_typing.evm.HexAddress) – Address owning the vault shares and receiving denomination tokens.
to (Optional[eth_typing.evm.HexAddress]) – Unsupported alternative receiver.
shares (Optional[decimal.Decimal]) – Human-readable share amount when raw_shares is omitted.
raw_shares (Optional[int]) – Requested raw vault shares.
check_max_deposit (bool) – Retained for the base manager API compatibility.
check_enough_token (bool) – Retained for the base manager API compatibility.

Returns

Transaction request ready for broadcast.

Raises

VaultFlowUnavailable – If the requested shares exceed the current cSigma capacity.

Return type

eth_defi.erc_4626.deposit_redeem.ERC4626RedemptionRequest

can_create_redemption_request(owner)

Report whether cSigma presently offers immediate redemption capacity.

Parameters: owner (eth_typing.evm.HexAddress) – Address whose capacity is queried.
Returns: True when at least one raw share is currently redeemable.
Return type: bool

can_create_deposit_request(owner)

Report whether cSigma presently offers immediate deposit capacity.

Parameters: owner (eth_typing.evm.HexAddress) – Address whose capacity is queried.
Returns: True when at least one raw asset is currently depositable.
Return type: bool

__init__(vault)

Parameters: vault (ERC4626Vault) –

analyse_deposit(claim_tx_hash, deposit_ticket)

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

A ticket permits a settlement call through a non-vault wrapper, such as a SimpleVault Safe or its module. 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 for a guarded non-vault call.

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 permits a non-vault transaction target for a guarded settlement; 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 for a guarded non-vault call.

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) –

can_finish_redeem(redemption_ticket)

Synchronous redemptions can be finished immediately.

Parameters: redemption_ticket (eth_defi.erc_4626.deposit_redeem.ERC4626RedemptionTicket) –

check_deposit_whitelist(owner)

Reject a deposit when the vault’s whitelist excludes the owner.

Shared deposit-preflight helper implementing the whitelisting contract every manager must honour: when a vault applies a deposit whitelist policy that is applicable and queryable, and owner is not a member of it, raise WhitelistingRequired before any transaction is broadcast so the caller can surface a “whitelisting required” state instead of paying gas for a guaranteed revert.

The check is intentionally conservative — it only raises when the whitelist information can be obtained and is applicable:

if is_whitelisted_deposit() raises NotImplementedError, the vault-wide policy cannot be determined for this adapter/version, so no exception is raised;
if the vault is permissionless, no exception is raised;
if is_account_whitelisted() raises NotImplementedError, per-account membership cannot be queried, so no exception is raised;
only when the policy is applicable and the owner is provably not admitted is WhitelistingRequired raised.

Adapters that need a stricter fail-closed policy for an unknown admission state should override their own preflight and raise VaultFlowUnavailable in addition to calling this helper (see the Lagoon manager for an example).

Parameters: owner (eth_typing.evm.HexAddress) – Deposit owner and controller whose whitelist membership is checked.
Raises: WhitelistingRequired – When the vault applies an applicable, queryable whitelist policy and owner is not permitted to deposit.
Return type: None

create_deposit_request_for_guard_validation(owner, raw_amount)

Build ERC-4626 deposit calldata after a proven global closure.

This Anvil-only diagnostic path is available only when the selected vault’s authoritative global closure reader reports that deposits are unavailable to every account. It preserves the normal protocol admission preflight and all permanent amount constraints, while omitting the temporary closed-deposit capacity and token-balance checks needed to encode the production-equivalent deposit call.

Parameters

owner (eth_typing.evm.HexAddress) – Safe/SimpleVault address that would own the minted shares.
raw_amount (int) – Raw denomination-token amount from the rejected real-deposit attempt.

Returns

Single ERC-4626 deposit request for isolated GuardV0 validation.

Raises

UnsupportedVaultSimulation – If the provider is not Anvil or the vault is not globally closed.
WhitelistingRequired – If the protocol admission policy excludes owner.

Return type

eth_defi.erc_4626.deposit_redeem.ERC4626DepositRequest

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

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

How many denomination tokens we get for a redeem.

Parameters

owner (eth_typing.evm.HexAddress) –
shares (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

estimate_redemption_delay()

Get the redemption delay for this vault.

What is overall redemption delay: not related to the current moment
How long it takes before a redemption request is allowed
This is not specific for any address, but the general vault rule
E.g. you get 0xa592703b is an IPOR Fusion error code AccountIsLocked, if you try to instantly redeem from IPOR vaults

Returns: Redemption delay as a datetime.timedelta
Raises: NotImplementedError – If not implemented for this vault protocoll.
Return type: datetime.timedelta

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]

fetch_vault_flow_events(hypersync_client, start_block, end_block)

Fetch asynchronous vault request events from an indexed backend.

The base implementation returns no events for vault managers that do not have a two-phase deposit or redemption flow.

Parameters

hypersync_client – Configured Hypersync client for this vault’s chain.
start_block (int) – Inclusive start block.
end_block (int) – Inclusive end block.

Returns

Iterator of protocol-neutral pending vault flow events.

Return type

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

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

finish_redemption(redemption_ticket)

Build the depositor-owned final redemption transaction when one exists.

Some asynchronous vaults, such as Ember, transfer funds directly from an operator transaction. They deliberately return None here: an asset manager must not attempt to invoke an operator-only settlement method on behalf of its depositor.

Parameters: redemption_ticket (eth_defi.vault.deposit_redeem.RedemptionTicket) – Persisted asynchronous redemption request.
Returns: Bound depositor claim call, or None when the protocol has no depositor-owned finish action.
Return type: web3.contract.contract.ContractFunction

force_redemption_liquidity(owner, raw_shares, failure)

Provision an unavailable synchronous redemption on an Anvil fork.

Concrete managers may implement this only for a source-proven liquidity failure. The default is deliberately unsupported: this hook must never bypass admission, minimums, maturity or time locks.

Parameters

owner (eth_typing.evm.HexAddress) – Redemption owner.
raw_shares (int) – Exact raw share quantity requested.
failure (eth_defi.vault.deposit_redeem.VaultFlowUnavailable) – Typed preflight failure that prompted the intervention request.

Returns

Structured intervention evidence from a concrete manager.

Raises

UnsupportedVaultSimulation – Always for managers without a protocol-specific implementation.

Return type

eth_defi.vault.deposit_redeem.VaultRedemptionSimulationIntervention

force_settle(ticket, *, mock=None, ignore_liquidity=False)

Force the selected ticket forward on an Anvil simulation.

Synchronous managers do not require settlement and return a no-op result when called with None. Asynchronous managers must override this method and supply their request ticket.

Parameters

ticket (Optional[Union[eth_defi.vault.deposit_redeem.DepositTicket, eth_defi.vault.deposit_redeem.RedemptionTicket]]) – Pending async request ticket, or None for a synchronous flow.
mock (Optional[object]) – Optional deployed protocol mock used only by focused local tests. Concrete asynchronous managers may use it to execute their operator/keeper settlement path without broadening production Anvil-fork authority. Passing a mock to a manager that does not implement mock settlement remains a typed unsupported simulation.
ignore_liquidity (bool) – Permit a protocol-specific, Anvil-only mock or fork driver to bypass an otherwise unavailable redemption-liquidity gate. This base implementation defaults to False; a documented protocol override may choose a different Anvil-only default. Managers must reject this request unless they have a tested, explicit implementation; it must never weaken a production preflight or live settlement path.

Returns

Settlement outcome with before/after status and transaction hashes.

Raises

UnsupportedVaultSimulation – If the provider is not Anvil or an async manager lacks a driver.

Return type

eth_defi.vault.deposit_redeem.VaultForcedSettlementResult

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 onchain 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 onchain 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]

get_redemption_delay_over(address)

Get the redemption timer left for an address.

How long it takes before a redemption request is allowed
This is not specific for any address, but the general vault rule
E.g. you get 0xa592703b is an IPOR Fusion error code AccountIsLocked, if you try to instantly redeem from IPOR vaults

Returns

UTC timestamp when the account can redeem.

Naive datetime, or None when the protocol has no deterministic onchain deadline.

Raises

NotImplementedError – If not implemented for this vault protocoll.

Parameters

address (Union[eth_typing.evm.HexAddress, str]) –

Return type

datetime.datetime

get_redemption_request_status(ticket)

Query the current status of an async redemption request.

Default implementation probes via can_finish_redeem(). Subclasses should override for more accurate status reporting.

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

has_synchronous_deposit()

Does this vault support synchronous deposits?

E.g. ERC-4626 vaults

Return type: bool

has_synchronous_redemption()

Does this vault support synchronous deposits?

E.g. ERC-4626 vaults

Return type: bool

is_deposit_in_progress(owner)

Check if the owner has an active deposit request.

Parameters: owner (eth_typing.evm.HexAddress) – Owner of the shares
Returns: True if there is an active redemption request
Return type: bool

is_redemption_in_progress(owner)

Check if the owner has an active redemption request.

Parameters: owner (eth_typing.evm.HexAddress) – Owner of the shares
Returns: True if there is an active redemption request
Return type: bool

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

reconstruct_redemption_ticket(data)

Reconstruct a redemption ticket from a serialised dict.

Async vault managers must override this to return their protocol-specific ticket subclass. The base implementation raises NotImplementedError because RedemptionTicket has abstract methods.

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

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

serialize_redemption_ticket(ticket)

Serialise a redemption ticket to a dict for persistence.

Default implementation stores base RedemptionTicket fields. Subclasses override to add protocol-specific fields.

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