Struct SwapLine

pub struct SwapLine {
    pub path: SwapPath,
    pub amount_in: SwapAmountType,
    pub amount_out: SwapAmountType,
    pub calculation_results: Vec<CalculationResult>,
    pub swap_to: Option<Address>,
    pub gas_used: Option<u64>,
}

Fields

path: SwapPath

amount_in: SwapAmountType

Input token amount of the swap

amount_out: SwapAmountType

Output token amount of the swap

calculation_results: Vec<CalculationResult>

The in and out amounts for each swap step

swap_to: Option<Address>

Output token of the swap

gas_used: Option<u64>

Gas used for the swap

Implementations

impl SwapLine

pub fn to_error(&self, msg: String) -> SwapError

pub fn new() -> Self

pub fn contains_pool(&self, pool: &PoolWrapper) -> bool

Check if the path contains a specific pool

pub fn tokens(&self) -> &Vec<Arc<Token>>

Get all involved tokens in the swap line

pub fn pools(&self) -> &Vec<PoolWrapper>

Get all used pools in the swap line

pub fn get_first_token(&self) -> Option<&Arc<Token>>

Get the first token in the swap line

pub fn get_last_token(&self) -> Option<&Arc<Token>>

Get the last token in the swap line

pub fn get_first_pool(&self) -> Option<&PoolWrapper>

Get the first pool in the swap line

pub fn get_last_pool(&self) -> Option<&PoolWrapper>

Get the last pool in the swap line

pub fn to_swap_steps( &self, multicaller: Address, ) -> Option<(SwapStep, SwapStep)>

Convert the swap line to two swap steps for flash swapping

pub fn split(&self, pool_index: usize) -> Result<(SwapLine, SwapLine)>

Split the swap line into two swap lines at a specific pool index

pub fn can_flash_swap(&self) -> bool

Check if all pools in the swap line can be flash swapped

pub fn abs_profit(&self) -> U256

Calculate the absolute profit of the swap line

pub fn abs_profit_eth(&self) -> U256

Calculate the absolute profit of the swap line in ETH

pub fn profit(&self) -> Result<I256>

pub fn calculate_with_in_amount<DB: DatabaseRef<Error = ErrReport>>( &self, state: &DB, env: Env, in_amount: U256, ) -> Result<(U256, u64, Vec<CalculationResult>), SwapError>

Calculate the out amount for the swap line for a given in amount

pub fn calculate_with_out_amount( &self, state: &dyn DatabaseRef<Error = ErrReport>, env: Env, out_amount: U256, ) -> Result<(U256, u64, Vec<CalculationResult>), SwapError>

Calculate the in amount for the swap line for a given out amount

pub fn optimize_with_in_amount<DB: DatabaseRef<Error = ErrReport>>( &mut self, state: &DB, env: Env, in_amount: U256, ) -> Result<&mut Self, SwapError>

Optimize the swap line for a given in amount

Trait Implementations

impl Clone for SwapLine

fn clone(&self) -> SwapLine

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SwapLine

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

Formats the value using the given formatter.

impl Default for SwapLine

fn default() -> SwapLine

Returns the “default value” for a type.

impl Display for SwapLine

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

Formats the value using the given formatter.

impl From<SwapPath> for SwapLine

fn from(value: SwapPath) -> Self

Converts to this type from the input type.

impl Hash for SwapLine

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SwapLine

fn eq(&self, other: &Self) -> 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.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 192 bytes