Struct stable_swap::curve::StableSwap

pub struct StableSwap { /* private fields */ }

The StableSwap invariant calculator.

This is primarily used to calculate two quantities:

• D, the swap invariant, and
• Y, the amount of tokens swapped in an instruction.

This calculator also contains several helper utilities for computing swap, withdraw, and deposit amounts.

Resources:

• Curve StableSwap paper
• StableSwap Python model

Implementations

impl StableSwap

pub fn new_from_swap_info(info: &SwapInfo, current_ts: i64) -> StableSwap

Constructs a new StableSwap from a SwapInfo.

pub fn new(
    initial_amp_factor: u64,
    target_amp_factor: u64,
    current_ts: i64,
    start_ramp_ts: i64,
    stop_ramp_ts: i64
) -> StableSwap

Constructs a new StableSwap invariant calculator.

pub fn compute_amp_factor(&self) -> Option<u64>

Compute the amplification coefficient (A).

The amplification coefficient is used to determine the slippage incurred when performing swaps. The lower it is, the closer the invariant is to the constant product¹.

The amplication coefficient linearly increases with respect to time, based on the SwapInfo::start_ramp_ts and SwapInfo::stop_ramp_ts parameters.

---

1. Egorov, “StableSwap,” 2019. ↩

pub fn compute_d(&self, amount_a: u64, amount_b: u64) -> Option<U192>

Computes the Stable Swap invariant (D).

The invariant is defined as follows:

A * sum(x_i) * n**n + D = A * D * n**n + D**(n+1) / (n**n * prod(x_i))

Arguments

• amount_a - The amount of token A owned by the LP pool. (i.e. token A reserves)
• amount_b - The amount of token B owned by the LP pool. (i.e. token B reserves)

For more info on reserves, see stable_swap_client::state::SwapTokenInfo::reserves.

pub fn compute_mint_amount_for_deposit(
    &self,
    deposit_amount_a: u64,
    deposit_amount_b: u64,
    swap_amount_a: u64,
    swap_amount_b: u64,
    pool_token_supply: u64,
    fees: &Fees
) -> Option<u64>

Computes the amount of pool tokens to mint after a deposit.

pub fn compute_y_raw(&self, x: u64, d: U192) -> Option<U192>

Compute the swap amount y in proportion to x.

Solve for y:

y**2 + y * (sum' - (A*n**n - 1) * D / (A * n**n)) = D ** (n + 1) / (n ** (2 * n) * prod' * A)
y**2 + b*y = c

pub fn compute_y(&self, x: u64, d: U192) -> Option<u64>

Computes the swap amount y in proportion to x.

pub fn compute_withdraw_one(
    &self,
    pool_token_amount: u64,
    pool_token_supply: u64,
    swap_base_amount: u64,
    swap_quote_amount: u64,
    fees: &Fees
) -> Option<(u64, u64)>

Calculates the withdrawal amount when withdrawing only one type of token.

Calculation:

1. Get current D
2. Solve Eqn against y_i for D - _token_amount

pub fn swap_to(
    &self,
    source_amount: u64,
    swap_source_amount: u64,
    swap_destination_amount: u64,
    fees: &Fees
) -> Option<SwapResult>

Compute SwapResult after an exchange

Trait Implementations

impl Clone for StableSwap

pub fn clone(&self) -> StableSwap

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StableSwap

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

Formats the value using the given formatter.

impl<'_> From<&'_ SaberSwap> for StableSwap

pub fn from(swap: &SaberSwap) -> StableSwap

Performs the conversion.

impl PartialEq<StableSwap> for StableSwap

pub fn eq(&self, other: &StableSwap) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<'_> TryFrom<&'_ SwapInfo> for StableSwap

type Error = ProgramError

The type returned in the event of a conversion error.

pub fn try_from(info: &SwapInfo) -> Result<StableSwap, ProgramError>

Performs the conversion.

impl Copy for StableSwap

impl Eq for StableSwap

impl StructuralEq for StableSwap

impl StructuralPartialEq for StableSwap