Enum OptimizationOutcome 

pub enum OptimizationOutcome {
    Completed {
        rounds_executed: u32,
    },
    InProgress,
}

Outcome of a [BreezSdk::optimize_leaves] call.

rounds_executed on Completed refers to rounds run by this call. The SDK holds no cross-call state — callers driving a SingleRound loop maintain their own cumulative counter if they need one.

A Completed { rounds_executed: 0 } outcome means the wallet was already optimal at call time (no swap was needed).

SingleRound loop pattern: terminate on anything that isn’t InProgress. Completed covers both the final swap of a productive run and the “already optimal” no-op case (the latter as rounds_executed: 0).

loop {
    let request = OptimizeLeavesRequest { mode: OptimizationMode::SingleRound };
    match sdk.optimize_leaves(request).await?.outcome {
        OptimizationOutcome::InProgress => continue,
        OptimizationOutcome::Completed { .. } => break,
    }
}

Variants

Completed

All planned optimization work was executed in this call. Returned by Full runs on success, and by SingleRound runs whose swap was the final one needed (the planner produced a single-swap plan with a convergence guarantee). rounds_executed == 0 means the wallet was already optimal — no work was performed.

Fields

rounds_executed: u32

InProgress

SingleRound only: a round ran but the planner could not guarantee it was the last. The caller should invoke optimize_leaves again.

Trait Implementations

impl Clone for OptimizationOutcome

fn clone(&self) -> OptimizationOutcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OptimizationOutcome

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OptimizationOutcome

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<OptimizationOutcome> for OptimizationOutcome

fn from(value: OptimizationOutcome) -> Self

Converts to this type from the input type.

impl PartialEq for OptimizationOutcome

fn eq(&self, other: &OptimizationOutcome) -> 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 Serialize for OptimizationOutcome

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for OptimizationOutcome