# Struct pyth_sdk_solana::Price

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

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

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);``````

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
(btc_usd, 10, -2),
(eth_usd, 5, -2)
], -8);
println!("0.1 BTC and 0.05 ETH are worth: ({} +- {}) x 10^{} USD",

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.

Add `other` to this, propagating uncertainty in both prices.

Requires both `Price`s to have the same exponent – use `scale_to_exponent` on the arguments if necessary.

TODO: could generalize this method to support different exponents.

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

Multiply this `Price` by `other`, propagating any uncertainty.

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`.

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

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

Deserialize this instance from a slice of bytes.

Serialize this instance into a vector of bytes.

Returns a copy of the value. Read more

Performs copy-assignment from `source`. Read more

Formats the value using the given formatter. Read more

Returns the “default value” for a type. Read more

Deserialize this value from the given Serde deserializer. Read more

The name of the generated JSON Schema. Read more

Generates a JSON Schema for this type. Read more

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

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

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

Serialize this value into the given Serde serializer. Read more

## Blanket Implementations

Gets the `TypeId` of `self`. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

The alignment of pointer.

The type for initializers.

Initializes a with the given initializer. Read more

Dereferences the given pointer. Read more

Mutably dereferences the given pointer. Read more

Drops the object pointed to by the given pointer. Read more

Should always be `Self`

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.