Struct 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, ) -> Self

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

fn clone(&self) -> StableSwap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StableSwap

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

Formats the value using the given formatter.

impl From<&SaberSwap> for StableSwap

fn from(swap: &SaberSwap) -> Self

Converts to this type from the input type.

impl PartialEq for StableSwap

fn eq(&self, other: &StableSwap) -> 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 TryFrom<&SwapInfo> for StableSwap

type Error = ProgramError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for StableSwap

impl Eq for StableSwap

impl StructuralPartialEq for StableSwap