Struct BareTradingFunction

pub struct BareTradingFunction {
    pub fee: u32,
    pub p: Amount,
    pub q: Amount,
}

The data describing a trading function.

This implicitly treats the trading function as being between assets 1 and 2, without specifying what those assets are, to avoid duplicating data (each asset ID alone is twice the size of the trading function). Which assets correspond to asset 1 and 2 is given by the canonical ordering of the pair.

The trading function phi(R) = p*R_1 + q*R_2 is a CFMM with a constant-sum, and a fee (0 <= fee < 10_000) expressed in basis points.

The valuations (p, q) for each asset inform the rate (or price) at which these assets trade against each other.

Fields

fee: u32

The fee, expressed in basis points.

The fee percentage of the trading function (gamma) is normalized according to its maximum value (10_000 bps, i.e. 100%): gamma = (10_000 - fee) / 10_000

p: Amount

The valuation for the first asset of the pair, according to canonical ordering.

q: Amount

The valuation for the second asset of the pair, according to canonical ordering.

Implementations

impl BareTradingFunction

pub fn new(fee: u32, p: Amount, q: Amount) -> Self

pub fn flip(&self) -> Self

pub fn fill_input( &self, _reserves: &Reserves, _delta_1: Amount, ) -> Option<(Reserves, Amount)>

👎Deprecated: this method is not yet implemented

pub fn fill_output( &self, reserves: &Reserves, lambda_2: Amount, ) -> Result<Option<(Reserves, Amount)>>

Determine the amount of asset 1 that can be filled for a given amount of asset 2, propagating rounding error to the input amount delta_1 rather than the output amount lambda_2. Returns None if the amount of asset 2 is greater than the reserves of asset 2.

Errors

This method returns an error if an overflow occurs when computing the fillable amount of asset 1.

pub fn fill( &self, delta_1: Amount, reserves: &Reserves, ) -> Result<(Amount, Reserves, Amount)>

Fills a trade of asset 1 to asset 2 against the given reserves, returning the unfilled amount of asset 1, the updated reserves, and the output amount of asset 2.

Errors

This method errors if an overflow occurs when computing the trade output amount, or the fillable amount of asset 1.

pub fn effective_price_key_bytes(&self) -> [u8; 32]

Returns a byte key for this trading function with the property that the lexicographic ordering on byte keys is the same as ordering the corresponding trading functions by effective price.

This allows trading functions to be indexed by price using a key-value store.

pub fn effective_price_inv(&self) -> U128x128

Returns the inverse of the effective_price, in other words, the exchange rate from asset_1 to asset_2: delta_1 * effective_price_inv = lambda_2

pub fn effective_price(&self) -> U128x128

Returns the exchange rate from asset_2 to asset_1, inclusive of fees: lambda_2 * effective_price = delta_1`

pub fn convert_to_lambda_2(&self, delta_1: U128x128) -> Result<U128x128>

Converts an amount delta_1 into lambda_2, using the inverse of the effective price.

pub fn convert_to_delta_1(&self, lambda_2: U128x128) -> Result<U128x128>

Converts an amount of lambda_2 into delta_1, using the effective price.

pub fn gamma(&self) -> U128x128

Returns gamma i.e. the fee percentage. The fee is expressed in basis points (0 <= fee < 5000), where 5000bps = 50%.

Bounds:

Since the fee f is bound by 0 <= < 5_000, we have 1/2 <= gamma <= 1.

Examples:

• A fee of 0% (0 bps) results in a discount factor of 1.
• A fee of 30 bps (30 bps) results in a discount factor of 0.997.
• A fee of 100% (10_000bps) results in a discount factor of 0.

pub fn compose(&self, _phi: BareTradingFunction) -> BareTradingFunction

👎Deprecated: this method is not yet implemented

Compose two trading functions together

Trait Implementations

impl Clone for BareTradingFunction

fn clone(&self) -> BareTradingFunction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BareTradingFunction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BareTradingFunction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl DomainType for BareTradingFunction

type Proto = BareTradingFunction

fn encode_to_vec(&self) -> Vec<u8>

Encode this domain type to a byte vector, via proto type P.

fn to_proto(&self) -> Self::Proto

Convert this domain type to the associated proto type.

fn decode<B>(buf: B) -> Result<Self, Error>

where B: Buf,

Decode this domain type from a byte buffer, via proto type P.

impl From<BareTradingFunction> for BareTradingFunction

fn from(value: BareTradingFunction) -> Self

Converts to this type from the input type.

impl PartialEq for BareTradingFunction

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<BareTradingFunction> for BareTradingFunction

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: BareTradingFunction) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for BareTradingFunction

impl StructuralPartialEq for BareTradingFunction