Enum SwapConstraint 

pub enum SwapConstraint {
    TradeLimitPrice {
        limit: Price,
        tolerance: f64,
        min_amount_in: Option<BigUint>,
        max_amount_in: Option<BigUint>,
    },
    PoolTargetPrice {
        target: Price,
        tolerance: f64,
        min_amount_in: Option<BigUint>,
        max_amount_in: Option<BigUint>,
    },
}

Options on how to constrain the pool swap query.

All prices use units [token_out/token_in] with amounts in atomic units (wei). When selling token_in into a pool, prices decrease due to slippage.

Variants

TradeLimitPrice

Calculates the maximum trade while respecting a minimum trade price.

Fields

limit: Price

The minimum acceptable trade price. The resulting amount_out / amount_in >= limit.

tolerance: f64

Fraction to raise the acceptance threshold above limit. Loosens the search criteria but will never allow violating the trade limit price itself.

min_amount_in: Option<BigUint>

The minimum amount of token_in that must be used for this trade.

max_amount_in: Option<BigUint>

The maximum amount of token_in that can be used for this trade.

PoolTargetPrice

Calculates the swap required to move the pool’s marginal price down to a target.

Edge Cases and Limitations

Computing the exact amount to move a pool’s marginal price to a target has several challenges:

• The definition of marginal price varies between protocols. It is usually not an attribute of the pool but a consequence of its liquidity distribution and current state.
• For protocols with concentrated liquidity, the marginal price is discrete, meaning we can’t always find an exact trade amount to reach the target price.
• Not all protocols support analytical solutions for this problem, requiring numerical methods.

Fields

target: Price

The target marginal price for the pool after the trade. The pool’s price decreases toward this target as token_in is sold into it.

tolerance: f64

Fraction above target considered acceptable. After trading, the pool’s marginal price will be in [target, target * (1 + tolerance)].

min_amount_in: Option<BigUint>

The lower bound for searching algorithms.

max_amount_in: Option<BigUint>

The upper bound for searching algorithms.

Trait Implementations

impl Clone for SwapConstraint

fn clone(&self) -> SwapConstraint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SwapConstraint

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

Formats the value using the given formatter.

impl PartialEq for SwapConstraint

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