Struct MarketIter 

pub struct MarketIter<InstrumentKey, T>(pub Vec<Result<MarketEvent<InstrumentKey, T>, DataError>>);

Convenient new type containing a collection of MarketEvent<T>s.

Tuple Fields

0: Vec<Result<MarketEvent<InstrumentKey, T>, DataError>>

Trait Implementations

impl<InstrumentKey: Debug, T: Debug> Debug for MarketIter<InstrumentKey, T>

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

Formats the value using the given formatter.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, BinanceContinuousKline)> for MarketIter<InstrumentKey, Candle>

fn from( (exchange_id, instrument, kline): (ExchangeId, InstrumentKey, BinanceContinuousKline), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, BinanceFuturesOrderBookL2Update)> for MarketIter<InstrumentKey, OrderBookEvent>

fn from( (exchange, instrument, update): (ExchangeId, InstrumentKey, BinanceFuturesOrderBookL2Update), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, BinanceKline)> for MarketIter<InstrumentKey, Candle>

fn from( (exchange_id, instrument, kline): (ExchangeId, InstrumentKey, BinanceKline), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, BinanceLiquidation)> for MarketIter<InstrumentKey, Liquidation>

fn from( (exchange_id, instrument, liquidation): (ExchangeId, InstrumentKey, BinanceLiquidation), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, BinanceOrderBookL1)> for MarketIter<InstrumentKey, OrderBookL1>

fn from( (exchange_id, instrument, book): (ExchangeId, InstrumentKey, BinanceOrderBookL1), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, BinanceSpotOrderBookL2Update)> for MarketIter<InstrumentKey, OrderBookEvent>

fn from( (exchange_id, instrument, update): (ExchangeId, InstrumentKey, BinanceSpotOrderBookL2Update), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, BinanceTrade)> for MarketIter<InstrumentKey, PublicTrade>

fn from( (exchange_id, instrument, trade): (ExchangeId, InstrumentKey, BinanceTrade), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, BitfinexMessage)> for MarketIter<InstrumentKey, PublicTrade>

fn from( (exchange_id, instrument, message): (ExchangeId, InstrumentKey, BitfinexMessage), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, BitfinexTrade)> for MarketIter<InstrumentKey, PublicTrade>

fn from( (exchange_id, instrument, trade): (ExchangeId, InstrumentKey, BitfinexTrade), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey: Clone> From<(ExchangeId, InstrumentKey, BitmexMessage<BitmexTradeInner>)> for MarketIter<InstrumentKey, PublicTrade>

fn from( (exchange, instrument, trades): (ExchangeId, InstrumentKey, BitmexTrade), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, BybitPayload<BybitOrderBookInner>)> for MarketIter<InstrumentKey, OrderBookL1>

where InstrumentKey: Clone,

fn from( (exchange, instrument, book): (ExchangeId, InstrumentKey, BybitOrderBookMessage), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, BybitPayload<BybitOrderBookInner>)> for MarketIter<InstrumentKey, OrderBookEvent>

fn from( (exchange, instrument, message): (ExchangeId, InstrumentKey, BybitOrderBookMessage), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey: Clone> From<(ExchangeId, InstrumentKey, BybitPayload<Vec<BybitTradeInner>>)> for MarketIter<InstrumentKey, PublicTrade>

fn from( (exchange, instrument, trades): (ExchangeId, InstrumentKey, BybitTrade), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, CoinbaseTrade)> for MarketIter<InstrumentKey, PublicTrade>

fn from( (exchange_id, instrument, trade): (ExchangeId, InstrumentKey, CoinbaseTrade), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, GateioMessage<GateioSpotTradeInner>)> for MarketIter<InstrumentKey, PublicTrade>

fn from( (exchange_id, instrument, trade): (ExchangeId, InstrumentKey, GateioSpotTrade), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey: Clone> From<(ExchangeId, InstrumentKey, GateioMessage<Vec<GateioFuturesTradeInner>>)> for MarketIter<InstrumentKey, PublicTrade>

fn from( (exchange, instrument, trades): (ExchangeId, InstrumentKey, GateioFuturesTrades), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, HyperliquidL2Book)> for MarketIter<InstrumentKey, OrderBookEvent>

where InstrumentKey: Clone,

fn from( (exchange_id, instrument, book_msg): (ExchangeId, InstrumentKey, HyperliquidL2Book), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, HyperliquidTrade)> for MarketIter<InstrumentKey, PublicTrade>

where InstrumentKey: Clone,

fn from( (exchange_id, instrument, trade_msg): (ExchangeId, InstrumentKey, HyperliquidTrade), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey: Clone> From<(ExchangeId, InstrumentKey, KrakenMessage<KrakenData<KrakenTicker>>)> for MarketIter<InstrumentKey, OrderBookL1>

fn from( (exchange_id, instrument, book): (ExchangeId, InstrumentKey, KrakenOrderBookL1), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey: Clone> From<(ExchangeId, InstrumentKey, KrakenMessage<KrakenData<KrakenTrade>>)> for MarketIter<InstrumentKey, PublicTrade>

fn from( (exchange, instrument, trades): (ExchangeId, InstrumentKey, KrakenTrades), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, LseMessage)> for MarketIter<InstrumentKey, OrderBookL1>

Decode a tick frame as a top-of-book quote.

This is the mapping the frame fits most honestly: the tick carries a bid and an ask, and its price equals the bid on every sample taken. The trade mapping in trade exists alongside it and is documented as the approximation it is.

Both levels carry a ZERO size

The feed publishes no bid or ask size — only prices — so the sizes here are placeholders, not measurements. This is the same choice the provider’s bulk-export decoder makes, for the same reason: a fabricated size would be indistinguishable downstream from a real one. It is safe because DefaultInstrumentMarketData::price in the rustrade crate falls back from the volume-weighted mid to the plain mid when the sizes are absent, so a zero-size book prices correctly rather than not at all. Consumers that genuinely need depth must not read these as available quantity.

The tick’s volume is deliberately not used for either level: it is a traded size, not resting bid or ask liquidity, and on two of the five venues it is a fabricated constant. See trade for that warning in full.

⚠️ A zero PRICE is absent, and it is not the same case as a zero size

The provider publishes 0.0 for a side it has no quote for — a venue outside its session, a symbol quoted on one side only. Published as Some(Level { price: 0, .. }) that becomes a real level asserting someone will trade at zero, and the damage is worse than the obvious one: it is precisely the volume-weighted-mid fallback that makes the zero sizes above harmless which makes a zero price dangerous. mid_price requires only that both sides be Some, and it averages whatever prices they carry — so a book quoting a real ask of 42001 against a zero bid prices at 21000.5, a number that is neither wrong-looking nor recoverable downstream. The consumer cannot filter it either, because nothing distinguishes it from a genuine quote.

So a zero price maps to None, following the same rule as the Binance L1 decoder. None is the spelling every consumer of this type already handles as “no quote on this side”; a one-sided book prices as no book at all, which is the honest answer when there is no quote to average.

fn from( (exchange, instrument, message): (ExchangeId, InstrumentKey, LseMessage), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey> From<(ExchangeId, InstrumentKey, LseMessage)> for MarketIter<InstrumentKey, PublicTrade>

Decode a tick frame as a PublicTrade.

⚠️ The tick is a QUOTE — a PublicTrade from this feed may not be a print

price equals bid exactly on every sample taken — 3,966 of 3,966 ticks spanning every dataset family, plus every sample from the provider’s separate price endpoint. So the price here is a bid-side quote wearing a trade’s shape, and its arrival is not evidence that a transaction occurred, at that price or at all. The mapping ships regardless, because saying so is more useful than withholding a feed whose sizes do reconcile; but a strategy that treats these as executions is reading one side of a quote as a fill.

LseOptions is the exception: its trades ARE prints

Option contract ticks reconcile one-for-one against the provider’s REST option-print tape on (price, volume), so there price is the traded premium per share and amount the number of contracts. They carry no quote at all — bid and ask are null on every one — which is why this is the only kind that venue serves.

⚠️ amount is genuine on some venues and FABRICATED on others

This is per-dataset and there is no in-band signal separating the two:

• LseCrypto and LseEquities carry a real per-tick size. Summing it across three whole minutes of one crypto symbol reproduced the provider’s own one-minute candle volume to the last decimal, ratio 1.000.
• LseFx and LseCfd carry a hard-coded 1.0 — measured on every tick of every FX and commodity symbol sampled, one distinct value across all of them. It is a placeholder, not a measurement. Because it is a plausible-looking positive number it will aggregate into a legitimate-looking total at any resolution, so volume-weighted prices, participation rates and size filters computed on these two venues are meaningless rather than merely imprecise. Note this also differs from the provider’s REST vault, which omits FX volume entirely — the true absence; the WebSocket invents a value instead.

⚠️ Identical consecutive ticks are REAL and are both emitted

This decoder performs no de-duplication, deliberately. See LseTick for the reconciliation that proves the repeats are distinct prints. The property is pinned by identical_live_ticks_are_never_deduplicated in transformer, which is the only place a filter could be added: this impl is a stateless From and has nothing to remember a previous tick with.

fn from( (exchange, instrument, message): (ExchangeId, InstrumentKey, LseMessage), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey: Clone> From<(ExchangeId, InstrumentKey, OkxMessage<OkxTrade>)> for MarketIter<InstrumentKey, PublicTrade>

fn from( (exchange, instrument, trades): (ExchangeId, InstrumentKey, OkxTrades), ) -> Self

Converts to this type from the input type.

impl<InstrumentKey, T> FromIterator<Result<MarketEvent<InstrumentKey, T>, DataError>> for MarketIter<InstrumentKey, T>

fn from_iter<Iter>(iter: Iter) -> Self

where Iter: IntoIterator<Item = Result<MarketEvent<InstrumentKey, T>, DataError>>,

Creates a value from an iterator.