Struct pyth_sdk_solana::Price

pub struct Price {
    pub price: i64,
    pub conf: u64,
    pub expo: i32,
}

A price with a degree of uncertainty, represented as a price +- a confidence interval.

The confidence interval roughly corresponds to the standard error of a normal distribution. Both the price and confidence are stored in a fixed-point numeric representation, x * 10^expo, where expo is the exponent. For example:

use pyth_sdk::Price;
Price { price: 12345, conf: 267, expo: -2 }; // represents 123.45 +- 2.67
Price { price: 123, conf: 1, expo: 2 }; // represents 12300 +- 100

Price supports a limited set of mathematical operations. All of these operations will propagate any uncertainty in the arguments into the result. However, the uncertainty in the result may overestimate the true uncertainty (by at most a factor of sqrt(2)) due to computational limitations. Furthermore, all of these operations may return None if their result cannot be represented within the numeric representation (e.g., the exponent is so small that the price does not fit into an i64). Users of these methods should (1) select their exponents to avoid this problem, and (2) handle the None case gracefully.

Fields

price: i64

Price.

conf: u64

Confidence Interval.

expo: i32

Exponent.

Implementations

impl Price

pub fn get_price_in_quote(&self, quote: &Price, result_expo: i32) -> Option<Price>

Get the current price of this account in a different quote currency.

If this account represents the price of the product X/Z, and quote represents the price of the product Y/Z, this method returns the price of X/Y. Use this method to get the price of e.g., mSOL/SOL from the mSOL/USD and SOL/USD accounts.

result_expo determines the exponent of the result, i.e., the number of digits below the decimal point. This method returns None if either the price or confidence are too large to be represented with the requested exponent.

Example:

let btc_usd: Price = ...;
let eth_usd: Price = ...;
// -8 is the desired exponent for the result
let btc_eth: Price = btc_usd.get_price_in_quote(&eth_usd, -8);
println!("BTC/ETH price: ({} +- {}) x 10^{}", price.price, price.conf, price.expo);

pub fn price_basket(
    amounts: &[(Price, i64, i32)],
    result_expo: i32
) -> Option<Price>

Get the price of a basket of currencies.

Each entry in amounts is of the form (price, qty, qty_expo), and the result is the sum of price * qty * 10^qty_expo. The result is returned with exponent result_expo.

An example use case for this function is to get the value of an LP token.

Example:

let btc_usd: Price = ...;
let eth_usd: Price = ...;
// Quantity of each asset in fixed-point a * 10^e.
// This represents 0.1 BTC and .05 ETH.
// -8 is desired exponent for result
let basket_price: Price = Price::price_basket(&[
    (btc_usd, 10, -2),
    (eth_usd, 5, -2)
  ], -8);
println!("0.1 BTC and 0.05 ETH are worth: ({} +- {}) x 10^{} USD",
         basket_price.price, basket_price.conf, basket_price.expo);

pub fn div(&self, other: &Price) -> Option<Price>

Divide this price by other while propagating the uncertainty in both prices into the result.

This method will automatically select a reasonable exponent for the result. If both self and other are normalized, the exponent is self.expo + PD_EXPO - other.expo (i.e., the fraction has PD_EXPO digits of additional precision). If they are not normalized, this method will normalize them, resulting in an unpredictable result exponent. If the result is used in a context that requires a specific exponent, please call scale_to_exponent on it.

pub fn add(&self, other: &Price) -> Option<Price>

Add other to this, propagating uncertainty in both prices.

Requires both Prices to have the same exponent – use scale_to_exponent on the arguments if necessary.

TODO: could generalize this method to support different exponents.

pub fn cmul(&self, c: i64, e: i32) -> Option<Price>

Multiply this Price by a constant c * 10^e.

pub fn mul(&self, other: &Price) -> Option<Price>

Multiply this Price by other, propagating any uncertainty.

pub fn normalize(&self) -> Option<Price>

Get a copy of this struct where the price and confidence have been normalized to be between MIN_PD_V_I64 and MAX_PD_V_I64.

pub fn scale_to_exponent(&self, target_expo: i32) -> Option<Price>

Scale this price/confidence so that its exponent is target_expo.

Return None if this number is outside the range of numbers representable in target_expo, which will happen if target_expo is too small.

Warning: if target_expo is significantly larger than the current exponent, this function will return 0 +- 0.

Trait Implementations

impl BorshDeserialize for Price where
    i64: BorshDeserialize,
    u64: BorshDeserialize,
    i32: BorshDeserialize, 

fn deserialize(buf: &mut &[u8]) -> Result<Price, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

impl BorshSerialize for Price where
    i64: BorshSerialize,
    u64: BorshSerialize,
    i32: BorshSerialize, 

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error> where
    W: Write, 

fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

impl Clone for Price

fn clone(&self) -> Price

Returns a copy 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<(), Error>

Formats the value using the given formatter.

impl Default for Price

fn default() -> Price

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Price

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Price, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Price

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq<Price> for Price

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Price

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

Serialize this value into the given Serde serializer.

impl Copy for Price

impl Eq for Price

impl StructuralEq for Price

impl StructuralPartialEq for Price