Struct DerivativesTick 

#[non_exhaustive]
pub struct DerivativesTick {
    pub funding_rate: f64,
    pub mark_price: f64,
    pub index_price: f64,
    pub futures_price: f64,
    pub open_interest: f64,
    pub long_size: f64,
    pub short_size: f64,
    pub taker_buy_volume: f64,
    pub taker_sell_volume: f64,
    pub long_liquidation: f64,
    pub short_liquidation: f64,
    pub timestamp: i64,
}

A single derivatives / perpetual-futures market tick.

Field invariants enforced by new:

• funding_rate is finite and may be negative (a negative funding rate means shorts pay longs).
• mark_price, index_price and futures_price are finite and strictly positive.
• open_interest, long_size, short_size, taker_buy_volume, taker_sell_volume, long_liquidation and short_liquidation are finite and non-negative.

timestamp is a caller-defined epoch / resolution and is not validated.

Construction and the limits of its guarantee

The struct is #[non_exhaustive], so code outside this crate cannot build one from a field literal and must go through new, which validates, or new_unchecked, which is an explicit opt-out for values already known to be sound.

The fields stay public because reading them is by far the common operation and an accessor on each would buy nothing. That does mean a validated value can still be written into an invalid state afterwards, and nothing detects it: the indicators that consume this type rely on the constructor’s guarantee rather than re-checking every bar. Treat a mutation the way you would treat new_unchecked — you are asserting the invariants still hold.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

funding_rate: f64

Current funding rate for the interval (finite; may be negative).

mark_price: f64

Perpetual mark price (finite, strictly positive).

index_price: f64

Spot / index price the perpetual tracks (finite, strictly positive).

futures_price: f64

Dated (e.g. quarterly) futures mark price (finite, strictly positive).

open_interest: f64

Open interest — outstanding contracts / notional (finite, non-negative).

long_size: f64

Aggregate long size / long account count (finite, non-negative).

short_size: f64

Aggregate short size / short account count (finite, non-negative).

taker_buy_volume: f64

Taker buy (ask-lifting) volume (finite, non-negative).

taker_sell_volume: f64

Taker sell (bid-hitting) volume (finite, non-negative).

long_liquidation: f64

Long-side liquidation notional (finite, non-negative).

short_liquidation: f64

Short-side liquidation notional (finite, non-negative).

timestamp: i64

Tick timestamp (caller-defined epoch / resolution).

Implementations

impl DerivativesTick

pub fn new( funding_rate: f64, mark_price: f64, index_price: f64, futures_price: f64, open_interest: f64, long_size: f64, short_size: f64, taker_buy_volume: f64, taker_sell_volume: f64, long_liquidation: f64, short_liquidation: f64, timestamp: i64, ) -> Result<Self>

Construct a derivatives tick, validating every field invariant.

Errors

Returns Error::InvalidDerivatives if funding_rate is not finite; any of mark_price, index_price, futures_price is not a finite positive number; or any of the six size / volume / liquidation fields is not a finite non-negative number.

pub const fn new_unchecked( funding_rate: f64, mark_price: f64, index_price: f64, futures_price: f64, open_interest: f64, long_size: f64, short_size: f64, taker_buy_volume: f64, taker_sell_volume: f64, long_liquidation: f64, short_liquidation: f64, timestamp: i64, ) -> Self

Construct a derivatives tick without validation. The caller asserts that every field invariant documented on DerivativesTick holds.

Trait Implementations

impl Clone for DerivativesTick

fn clone(&self) -> DerivativesTick

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DerivativesTick

impl Debug for DerivativesTick

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

Formats the value using the given formatter.

impl PartialEq for DerivativesTick

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for DerivativesTick