Struct MarketInstrumentData 

pub struct MarketInstrumentData<InstrumentKey> {
    pub key: InstrumentKey,
    pub name_exchange: InstrumentNameExchange,
    pub kind: MarketDataInstrumentKind,
}

Fields

key: InstrumentKey

name_exchange: InstrumentNameExchange

kind: MarketDataInstrumentKind

Implementations

impl<InstrumentKey> MarketInstrumentData<InstrumentKey>

pub fn hyperliquid_perp(key: InstrumentKey, perp: &PerpCoin) -> Self

A Hyperliquid perpetual, keyed by key, to subscribe to with Hyperliquid.

Find perp with HyperliquidMeta::perp_coin, so the subscription names its coin as Hyperliquid spells it.

pub fn hyperliquid_spot(key: InstrumentKey, pair: &SpotPair) -> Self

A Hyperliquid spot pair, keyed by key, to subscribe to with HyperliquidSpot.

Find pair with HyperliquidMeta::spot_pair, so the subscription names its coin (@107) rather than its tokens.

Trait Implementations

impl<InstrumentKey> AlpacaInstrument for MarketInstrumentData<InstrumentKey>

Takes the exchange-side name as given, so it needs no per-feed shape: the caller has already supplied Alpaca’s own symbol, and there is nothing to reconstruct.

Case is still normalised, as the reconstruction path normalises it. Alpaca spells its symbols in uppercase, and a subscribe is confirmed only once Alpaca’s answer names each requested symbol exactly — so a lowercase name_exchange would otherwise fail the subscribe with a timeout naming it. On a correctly spelled exchange name the call is a no-op.

fn alpaca_market(&self, _shape: AlpacaSymbolShape) -> AlpacaMarket

The symbol this instrument subscribes to on a feed spelling symbols as shape.

impl<InstrumentKey: Clone> Clone for MarketInstrumentData<InstrumentKey>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<InstrumentKey: Debug> Debug for MarketInstrumentData<InstrumentKey>

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

Formats the value using the given formatter.

impl<'de, InstrumentKey> Deserialize<'de> for MarketInstrumentData<InstrumentKey>

where InstrumentKey: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<InstrumentKey> Display for MarketInstrumentData<InstrumentKey>

where InstrumentKey: Display,

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

Formats the value using the given formatter.

impl<InstrumentKey: Eq> Eq for MarketInstrumentData<InstrumentKey>

impl<ExchangeKey, AssetKey, InstrumentKey> From<&Keyed<InstrumentKey, Instrument<ExchangeKey, AssetKey>>> for MarketInstrumentData<InstrumentKey>

where InstrumentKey: Clone,

fn from(value: &Keyed<InstrumentKey, Instrument<ExchangeKey, AssetKey>>) -> Self

Converts to this type from the input type.

impl<InstrumentKey: Hash> Hash for MarketInstrumentData<InstrumentKey>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<InstrumentKey> HyperliquidInstrument for MarketInstrumentData<InstrumentKey>

Built from a HyperliquidMeta lookup, so name_exchange is already the venue’s coin, whichever connector subscribes with it.

fn hyperliquid_perp_market(&self) -> HyperliquidMarket

The perpetual market this instrument subscribes to with Hyperliquid.

fn hyperliquid_spot_market(&self) -> HyperliquidMarket

The spot market this instrument subscribes to with HyperliquidSpot.

impl<InstrumentKey> InstrumentData for MarketInstrumentData<InstrumentKey>

where InstrumentKey: Debug + Clone + Eq + Send + Sync,

type Key = InstrumentKey

fn key(&self) -> &Self::Key

fn kind(&self) -> &MarketDataInstrumentKind

impl<InstrumentKey> LseInstrument for MarketInstrumentData<InstrumentKey>

Takes the exchange-side name as given, so it needs no per-dataset shape: the caller has already supplied the provider’s own symbol, and there is nothing to reconstruct.

Case is still normalised, for the same reason the reconstruction path normalises it: the symbol is the instrument-map key a tick resolves through, and the provider echoes EUR/USD on the tick however the subscribe spelled it. A lowercase name_exchange would be confirmed, then tick under a key the map does not hold and deliver nothing — the silent failure the reconstruction path already avoids, and there is no reason for this path to keep it. On a correctly spelled exchange name the call is a no-op.

fn lse_market(&self, _shape: LseSymbolShape) -> LseMarket

The display symbol this instrument subscribes to on a dataset spelling symbols as shape.

impl<InstrumentKey> MassiveInstrument for MarketInstrumentData<InstrumentKey>

Takes the exchange-side name as given: the caller has already supplied the cluster’s own spelling, and there is nothing to reconstruct.

fn massive_market(&self, _symbols: MassiveSymbols) -> MassiveMarket

The market this instrument subscribes to on a cluster spelling markets as symbols.

impl<InstrumentKey: Ord> Ord for MarketInstrumentData<InstrumentKey>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl<InstrumentKey: PartialEq> PartialEq for MarketInstrumentData<InstrumentKey>

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

Equality operator ==.

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

Inequality operator !=.

impl<InstrumentKey: PartialOrd> PartialOrd for MarketInstrumentData<InstrumentKey>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<InstrumentKey> Serialize for MarketInstrumentData<InstrumentKey>

where InstrumentKey: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<InstrumentKey: PartialEq> StructuralPartialEq for MarketInstrumentData<InstrumentKey>