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

Variants

TradeLimitPrice

This mode will calculate the maximum trade that this pool can execute while respecting a trade limit price.

Fields

limit: Price

The minimum acceptable price for the resulting trade, as a Price struct. The resulting amount_out / amount_in must be >= trade_limit_price

tolerance: f64

The tolerance as a fraction to be applied on top of (increasing) the trade limit price, raising the acceptance threshold. This is used to loosen the acceptance criteria for implementations of this method, 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

This mode will Calculate the amount of token_in required to move the pool’s marginal price down to a target price, and the amount of token_out received.

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 marginal price we want the pool to be after the trade, as a Price struct. The pool’s price will move down to this level as token_in is sold into it

tolerance: f64

The tolerance as a fraction of the resulting pool marginal price. After trading, the pool’s price will decrease to the interval [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