Struct pallet_ema_oracle::OracleEntry

pub struct OracleEntry<BlockNumber> {
    pub price: Price,
    pub volume: Volume<Balance>,
    pub liquidity: Liquidity<Balance>,
    pub timestamp: BlockNumber,
}

A type representing data produced by a trade or liquidity event. Timestamped to the block where it was created.

Fields

price: Price

volume: Volume<Balance>

liquidity: Liquidity<Balance>

timestamp: BlockNumber

Implementations

impl<BlockNumber> OracleEntry<BlockNumber>where
    BlockNumber: AtLeast32BitUnsigned + Copy + UniqueSaturatedInto<u64>,

pub fn into_aggregated(
    self,
    initialized: BlockNumber
) -> AggregatedEntry<Balance, BlockNumber, Price>

Convert the OracleEntry into an AggregatedEntry for consumption. Determines the age by subtracting initialized from the timestamp.

pub fn raw_data(
    &self
) -> (Price, (Balance, Balance, Balance, Balance), (Balance, Balance))

Return the raw data of the entry as a tuple of tuples, excluding the timestamp.

pub fn inverted(self) -> Self

Return an inverted version of the entry where the meaning of assets a and b are inverted. So the price of a/b become the price b/a and the volume switches correspondingly.

pub fn accumulate_volume_and_update_from(&mut self, incoming: &Self)

Update the volume in self by adding in the volume of incoming and taking over the other values from incoming.

pub fn fast_forward_to(&mut self, new_timestamp: BlockNumber)

Fast forward the oracle value to new_timestamp. Updates the timestamp and resets the volume.

pub fn with_added_volume_from(&self, previous_entry: &Self) -> Self

Determine a new entry based on self and a previous entry. Adds the volumes together and takes the values of self for the rest.

pub fn calculate_new_by_integrating_incoming(
    &self,
    period: OraclePeriod,
    incoming: &Self
) -> Option<Self>

Determine the next oracle entry based on a previous (self) and an incoming entry as well as a period.

Returns None if any of the calculations fail (including the incoming entry not being one iteration (block) more recent than self).

The period is used to determine the smoothing factor alpha for an exponential moving average.

pub fn update_to_new_by_integrating_incoming(
    &mut self,
    period: OraclePeriod,
    incoming: &Self
) -> Option<&mut Self>

Update self based on a previous (self) and an incoming oracle entry as well as a period.

pub fn calculate_current_from_outdated(
    &self,
    period: OraclePeriod,
    update_with: &Self
) -> Option<Self>

Determine the current intended oracle entry based on a previous (self) and an update_with entry as well as a period.

Returns None if any of the calculations fail (including the update_with entry not being more recent than self).

The period is used to determine the smoothing factor alpha for an exponential moving average.

Uses the difference between the timestamps to determine the time (i.e. iterations) to cover.

pub fn update_outdated_to_current(
    &mut self,
    period: OraclePeriod,
    update_with: &Self
) -> Option<&mut Self>

Update self based on a previous (self) and an update_with entry as well as a period. See [calculate_current_from_outdated].

Trait Implementations

impl<BlockNumber: Clone> Clone for OracleEntry<BlockNumber>

fn clone(&self) -> OracleEntry<BlockNumber>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<BlockNumber> Debug for OracleEntry<BlockNumber>where
    BlockNumber: Debug,

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

Formats the value using the given formatter.

impl<BlockNumber> Decode for OracleEntry<BlockNumber>where
    BlockNumber: Decode,

fn decode<__CodecInputEdqy: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn skip<I>(input: &mut I) -> Result<(), Error>where
    I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<BlockNumber: Default> Default for OracleEntry<BlockNumber>

fn default() -> OracleEntry<BlockNumber>

Returns the “default value” for a type.

impl<'de, BlockNumber> Deserialize<'de> for OracleEntry<BlockNumber>where
    BlockNumber: Deserialize<'de>,

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

Deserialize this value from the given Serde deserializer.

impl<BlockNumber> Encode for OracleEntry<BlockNumber>where
    BlockNumber: Encode,

fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere
    F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<BlockNumber> From<(Ratio, Volume<u128>, Liquidity<u128>, BlockNumber)> for OracleEntry<BlockNumber>

fn from(
    (price, volume, liquidity, timestamp): (Price, Volume<Balance>, Liquidity<Balance>, BlockNumber)
) -> Self

Converts to this type from the input type.

impl<BlockNumber> MaxEncodedLen for OracleEntry<BlockNumber>where
    BlockNumber: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<BlockNumber: PartialEq> PartialEq<OracleEntry<BlockNumber>> for OracleEntry<BlockNumber>

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

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

Serialize this value into the given Serde serializer.

impl<BlockNumber> TypeInfo for OracleEntry<BlockNumber>where
    BlockNumber: TypeInfo + 'static,

type Identity = OracleEntry<BlockNumber>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<BlockNumber> EncodeLike<OracleEntry<BlockNumber>> for OracleEntry<BlockNumber>where
    BlockNumber: Encode,

impl<BlockNumber: Eq> Eq for OracleEntry<BlockNumber>

impl<BlockNumber> StructuralEq for OracleEntry<BlockNumber>

impl<BlockNumber> StructuralPartialEq for OracleEntry<BlockNumber>