Struct LinearTickerDataDelta 

pub struct LinearTickerDataDelta {

    pub symbol: String,
    pub tick_direction: Option<TickDirection>,
    pub price_24h_pcnt: Option<f64>,
    pub last_price: Option<f64>,
    pub prev_price_24h: Option<f64>,
    pub high_price_24h: Option<f64>,
    pub low_price_24h: Option<f64>,
    pub prev_price_1h: Option<f64>,
    pub open_interest_value: Option<f64>,
    pub turnover_24h: Option<f64>,
    pub volume_24h: Option<f64>,
    pub bid_price: Option<f64>,
    pub bid_size: Option<f64>,
    pub ask_price: Option<f64>,
    pub ask_size: Option<f64>,
    pub pre_open_price: Option<f64>,
    pub pre_qty: Option<f64>,
    pub cur_pre_listing_phase: Option<String>,
    pub funding_rate: Option<f64>,
    pub next_funding_time: Option<u64>,
    pub index_price: Option<f64>,
    pub mark_price: Option<f64>,
    pub open_interest: Option<f64>,
}

Fields

symbol: String

The trading pair symbol (e.g., “BTCUSDT”).

The ONLY required field for the ticker data. Bots use this to identify the market they are trading in.

Identifies the perpetual futures contract for the ticker data. Bots use this to verify the correct market.

tick_direction: Option<TickDirection>

The tick direction of the last price change.

Indicates whether the last price change was an uptick or downtick (e.g., “PlusTick”). Bots use this to analyze short-term price momentum.

price_24h_pcnt: Option<f64>

The 24-hour price change percentage.

The percentage change in price over the last 24 hours. Bots use this to assess market trends and volatility.

last_price: Option<f64>

The last traded price.

The most recent price at which the contract was traded. Bots use this for real-time price tracking and technical analysis.

prev_price_24h: Option<f64>

The price 24 hours ago.

The price of the contract 24 hours prior. Bots use this to calculate price changes and validate price_24h_pcnt.

high_price_24h: Option<f64>

The highest price in the last 24 hours.

The peak price reached in the last 24 hours. Bots use this to identify resistance levels and assess volatility.

low_price_24h: Option<f64>

The lowest price in the last 24 hours.

The lowest price reached in the last 24 hours. Bots use this to identify support levels and assess volatility.

prev_price_1h: Option<f64>

The price 1 hour ago.

The price of the contract 1 hour prior. Bots use this to calculate short-term price changes and momentum.

open_interest_value: Option<f64>

The open interest value in settlement currency.

The monetary value of open interest (open_interest * mark_price). Bots use this to assess market exposure and leverage levels.

turnover_24h: Option<f64>

The 24-hour trading turnover.

The total trading value in the last 24 hours, in settlement currency. Bots use this to assess market activity and liquidity.

volume_24h: Option<f64>

The 24-hour trading volume.

The total quantity of contracts traded in the last 24 hours. Bots use this to analyze market activity and trading intensity.

bid_price: Option<f64>

The best bid price.

The highest price at which someone is willing to buy. Bots use this to assess buy-side liquidity and calculate spreads.

bid_size: Option<f64>

The best bid size.

The quantity available at the best bid price. Bots use this to evaluate buy-side liquidity and potential slippage.

ask_price: Option<f64>

The best ask price.

The lowest price at which someone is willing to sell. Bots use this to assess sell-side liquidity and calculate spreads.

ask_size: Option<f64>

The best ask size.

The quantity available at the best ask price. Bots use this to evaluate sell-side liquidity and potential slippage.

pre_open_price: Option<f64>

The pre-open price, set by Bybit for a trading pair before it enters regular trading, often during phases like subscription, announcement, or pre-trading for new pairs. This price guides early trading or subscription activities.

pre_qty: Option<f64>

The pre-open quantity, represents the indicative or reference price for a trading pair during a pre-listing or pre-trading phase. This price is typically set by the exchange to guide trading activity when the pair is not yet fully open for unrestricted trading (e.g., during a subscription or announcement phase for new pairs).

cur_pre_listing_phase: Option<String>

Indicates the current stage of a trading pair in Bybit’s pre-listing process. Pre-listing phases are used for new or upcoming trading pairs that are not yet fully available for trading but may be in a preparatory or promotional stage.

funding_rate: Option<f64>

The current funding rate.

The funding rate applied to positions, as a decimal (e.g., 0.0001 for 0.01%). Bots use this to calculate funding costs or profits for long/short positions.

next_funding_time: Option<u64>

The timestamp of the next funding event in milliseconds.

Indicates when the next funding rate payment will occur. Bots use this to schedule funding fee calculations and position adjustments.

index_price: Option<f64>

The current index price.

The index price, based on external spot markets, used for reference in perpetual futures. Bots use this to compare with mark price for funding rate calculations.

mark_price: Option<f64>

The current mark price.

The mark price used for P&L calculations in perpetual futures. Bots use this to calculate unrealized P&L and assess position health.

open_interest: Option<f64>

The open interest in contracts.

The total number of open contracts in the market. Bots use this to gauge market participation and liquidity.

Trait Implementations

impl Clone for LinearTickerDataDelta

fn clone(&self) -> LinearTickerDataDelta

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinearTickerDataDelta

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LinearTickerDataDelta

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LinearTickerDataDelta

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LinearTickerDataDelta