Struct BalanceExit

pub struct BalanceExit<T: LazyBalanceMarker, M: ManualBalanceModel<T>> {
    pub lazy: T::Asset,
    pub manual: T::Asset,
    pub diff: T::Asset,
    pub bps: T::Asset,
    pub sequence: Vec<BalanceOp<T, M>>,
}

Represents a successful withdrawal where the lazy and manual models produce different outputs.

A withdrawal has completed successfully in both models, but the resulting values are not equal, indicating drift between the lazy (deferred) model and the manual (eager reference) model.

This occurs because withdrawals are state-dependent: prior balance adjustments (mint, reap) can change the effective value of a receipt, so the redeemed amount may differ from the original deposit.

This structure captures:

• the outputs from both models
• their absolute difference (diff)
• the difference in basis points (bps)
• the full operation trace leading to the withdrawal

The final operation in sequence is always the BalanceOp::Withdraw that produced this result.

LazyBalanceModelChecker methods may apply tolerance thresholds (e.g. minimum diff or bps) to ignore negligible drift. If the deviation falls within acceptable bounds, this exit may be discarded.

This is primarily used to evaluate whether the lazy model maintains acceptable precision relative to the manual reference model.

Fields

lazy: T::Asset

Value returned by the lazy balance model.

manual: T::Asset

Value returned by the manual (reference) model.

diff: T::Asset

Absolute difference between lazy and manual.

bps: T::Asset

Difference expressed in basis points.

sequence: Vec<BalanceOp<T, M>>

Trace of operations leading to this withdrawal. The last operation is the Withdraw.

Trait Implementations

impl<T: Clone + LazyBalanceMarker, M: Clone + ManualBalanceModel<T>> Clone for BalanceExit<T, M>

where T::Asset: Clone,

fn clone(&self) -> BalanceExit<T, M>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + LazyBalanceMarker, M: Debug + ManualBalanceModel<T>> Debug for BalanceExit<T, M>

where T::Asset: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: PartialEq + LazyBalanceMarker, M: PartialEq + ManualBalanceModel<T>> PartialEq for BalanceExit<T, M>

where T::Asset: PartialEq,

fn eq(&self, other: &BalanceExit<T, M>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq + LazyBalanceMarker, M: Eq + ManualBalanceModel<T>> Eq for BalanceExit<T, M>

where T::Asset: Eq,

impl<T: LazyBalanceMarker, M: ManualBalanceModel<T>> StructuralPartialEq for BalanceExit<T, M>