Struct Price 

pub struct Price {
    pub numerator: BigUint,
    pub denominator: BigUint,
}

Represents a price as a fraction in the token_in -> token_out direction. With units [token_out/token_in].

Fields

• numerator - The amount of token_out (what you receive), including token decimals
• denominator - The amount of token_in (what you pay), including token decimals

A fraction struct is used for price to have flexibility in precision independent of the decimal precisions of the numerator and denominator tokens. This allows for:

• Exact price representation without floating-point errors
• Handling tokens with different decimal places without loss of precision

Example

If we want to represent that token A is worth 2.5 units of token B:

use num_bigint::BigUint;
use tycho_common::simulation::protocol_sim::Price;

let numerator = BigUint::from(25u32); // Represents 25 units of token B
let denominator = BigUint::from(10u32); // Represents 10 units of token A
let price = Price::new(numerator, denominator);

If you want to define a limit price for a trade, where you expect to get at least 120 T1 for 50 T2:

use num_bigint::BigUint;
use tycho_common::simulation::protocol_sim::Price;

let min_amount_out = BigUint::from(120u32); // The minimum amount of T1 you expect
let amount_in = BigUint::from(50u32); // The amount of T2 you are selling
let limit_price = Price::new(min_amount_out, amount_in);

Fields

numerator: BigUint

denominator: BigUint

Implementations

impl Price

pub fn new(numerator: BigUint, denominator: BigUint) -> Self

Trait Implementations

impl Clone for Price

fn clone(&self) -> Price

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Price

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

Formats the value using the given formatter.

impl PartialEq for Price

fn eq(&self, other: &Price) -> 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 Eq for Price

impl StructuralPartialEq for Price