Enum SwapConstraint 

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

Defines constraints for advanced quote calculations.

These constraints allow sophisticated trading strategies by limiting swaps based on price thresholds or targeting specific pool states.

Variants

#[non_exhaustive]

TradeLimitPrice

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

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

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.

#[non_exhaustive]

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

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

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.

Implementations

impl SwapConstraint

pub fn trade_limit_price(limit: Price, tolerance: f64) -> Self

Creates a trade limit price constraint.

This constraint finds the maximum trade size while respecting a minimum price threshold. See SwapConstraint::TradeLimitPrice for details.

Arguments

• limit - The minimum acceptable price for the trade
• tolerance - Additional tolerance as a fraction to loosen the constraint

pub fn pool_target_price(target: Price, tolerance: f64) -> Self

Creates a pool target price constraint.

This constraint calculates the trade needed to move the pool’s price to a target level. See SwapConstraint::PoolTargetPrice for details.`

Arguments

• target - The desired final marginal price of the pool
• tolerance - Acceptable variance from the target price as a fraction

pub fn with_lower_bound(self, lower: BigUint) -> SimulationResult<Self>

Adds a lower bound to the constraint’s search range.

Arguments

• lower - The minimum amount_in to consider

Returns

The modified constraint with the lower bound applied.

pub fn with_upper_bound(self, upper: BigUint) -> SimulationResult<Self>

Adds an upper bound to the constraint’s search range.

Arguments

• upper - The maximum amount_in to consider

Returns

The modified constraint with the upper bound applied.

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