Struct LseSubscriber 

pub struct LseSubscriber { /* private fields */ }

The London Strategic Edge WebSocket subscriber.

Why this provider needs a subscriber of its own

Authentication is a message, not a header, and subscriptions are only accepted after the server answers it — so Connector::requests alone cannot express the flow.

The handshake also produces something the guards below need: the authenticated frame enumerates every symbol the key may subscribe to. That list is the only defence against this surface’s quietest failure — see Self::subscribe.

⚠️ One connection per key: clone the subscriber, do not build a second one

The provider allows a key one WebSocket, so every stream this subscriber and its clones open shares one socket — whatever the dataset, the kind or the option underlying, and across every subscribe call. StreamBuilder::subscribe clones the subscriber it is given, so passing one subscriber, or clones of it, to every call is all sharing takes. See connection for how the socket is shared, how a reconnect is coordinated across the streams on it, and what the shared subscription cap means for a batch.

A subscriber built separately — a second LseSubscriber::new or LseSubscriber::from_env for the same key — opens a socket of its own, and the provider refuses it with TOO_MANY_CONNECTIONS.

Example

use rustrade_data::exchange::lse::{LseCrypto, live::LseSubscriber};
use rustrade_data::streams::Streams;
use rustrade_data::subscription::trade::PublicTrades;
use rustrade_instrument::instrument::market_data::kind::MarketDataInstrumentKind;

let subscriber = LseSubscriber::from_env()?;

let streams = Streams::<PublicTrades>::builder()
    .subscribe(subscriber, [(
        LseCrypto::default(), "btc", "usd", MarketDataInstrumentKind::Spot, PublicTrades,
    )])
    .init()
    .await?;

Implementations

impl LseSubscriber

pub fn new(credentials: LseCredentials) -> Self

Construct a subscriber with the provided credentials, without resumption.

Each call opens a connection of its own when first used; clone the result to share it.

pub fn from_env() -> Result<Self, SocketError>

Construct a subscriber from the LSE_API_KEY environment variable.

Errors

See LseCredentials::from_env.

pub fn with_resume(self, state: Arc<LseResumeState>) -> Self

Resume from the last delivered event when a reconnect re-subscribes.

Every stream opened by this subscriber shares state, and the same subscriber instance is cloned into each reconnect attempt, so the watermark it accumulates survives the reconnect that consults it.

⚠️ Replay is not free, which is why this is opt-in

A resumed subscription is served its historical window before a single live tick. That window is large: one hour of a single busy crypto symbol replayed 107,395 ticks before going live, and a 24-hour window had not drained after 30 seconds. A consumer that must stay current will prefer the gap; a consumer recording a continuous tape will prefer the replay. Choosing between those is the caller’s business, so the default is off.

⚠️ The provider retains only 24 hours, and clamps silently

A resume point older than that is moved forward with no error. The stream compares what the provider says it will replay from against what was asked for and warns on a mismatch; see LseMessage::ReplayStarted.

⚠️ One state per duplicated subscription

Watermarks are keyed by dataset, subscription and subscription kind, so one state serves any set of streams that differ in any of those three. Two streams that duplicate all three share one watermark and advance it independently, which resumes the trailing one past events it never delivered — see LseResumeState for the obligation in full.

⚠️ The replayed prefix is skipped by position, not by the replay flag

The provider re-serves every tick sharing the resume instant, and the ones already delivered are dropped by counting rather than by trusting each tick’s replay stamp — a provider that stopped stamping them would otherwise turn every reconnect into a duplicate flood. The cost is a narrow one: if the replay under-delivers at that instant, a genuinely live tick arriving there while the count is still open is dropped as though it were one of the missing duplicates. It requires the whole reconnect to land inside one timestamp quantum of the resume instant, so it is unlikely rather than impossible, and it is reported by a warn! naming the subscription and the instant rather than passing silently.

Streams sharing a symbol share its replay window

Streams on one connection that hold one symbol — two kinds, or two datasets spelling it alike — hold one provider subscription to it, and the provider opens one replay window per subscription. A reconnect therefore opens each symbol’s window at the earliest watermark among the streams holding it, and every stream drops, silently, the replayed ticks before its own watermark: it delivered them before the connection was lost. Replayed ticks reach only the streams that resume that symbol. See connection.

A clone made before this call shares the connection but not the state. That is supported — each stream resumes from its own subscriber’s state — but it is rarely what was meant.

Covers reconnects, not process restarts; see LseResumeState.

Trait Implementations

impl Clone for LseSubscriber

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LseSubscriber

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

Formats the value using the given formatter.

impl Subscriber for LseSubscriber

async fn subscribe<Exchange, Instrument, Kind>( &self, subscriptions: &[Subscription<Exchange, Instrument, Kind>], ) -> Result<Subscribed<Instrument::Key, Self::Transport>, SocketError>

where Exchange: Connector + Send + Sync, Kind: SubscriptionKind + Send + Sync, Instrument: InstrumentData, Subscription<Exchange, Instrument, Kind>: Identifier<Exchange::Channel> + Identifier<Exchange::Market>,

Attach the batch to this subscriber’s shared connection — connecting and authenticating first if nothing is attached yet — check it, then subscribe whatever the connection does not already hold.

⚠️ Every guard runs before the first subscribe leaves the client, deliberately

This surface confirms a subscription to a symbol it has never heard of: it answers subscribed, never errors, never ticks, and holds one of the connection’s slots until it is unsubscribed — which nothing would prompt, since a confirmation is all the client ever sees. So the requested symbols are checked against the list the authenticated frame supplies first, and a batch that fails costs nothing.

Two checks run over that list:

• Membership is enforced. A symbol the provider does not offer fails the batch.
• The category is only cross-checked when the provider supplies a label this integration recognises. Roughly half the published entries carry no category key at all — and some carry neither category nor name — so absence is normal and can never be treated as a mismatch. Neither can a label we do not know: only one we recognise as belonging to a different dataset is evidence of anything.

The subscription cap is enforced in the same pass, because an over-cap batch is rejected anonymously: the provider’s rejection does not name the symbol it refused, leaving no partial recovery. Failing the whole batch before sending is the only outcome that does not leave the caller guessing which subscriptions survived.

⚠️ The cap is the connection’s, not the batch’s

Every stream sharing the connection draws on one subscription cap, so a batch is checked against what the connection would hold with it: the symbols and underlyings already held by other streams count, and a symbol one of them already holds costs nothing more. A batch that fits on its own can therefore be refused here.

Should the provider reject a subscribe anyway, the batch fails and whatever it sent is unsubscribed again, so a failed batch still holds no slot.

Option contracts subscribe per underlying

On LseOptions one subscribe covers an underlying’s whole chain, so the batch is reduced to its distinct underlyings: that is what is sent, what the cap counts, and what the provider confirms. Every contract must spell an OSI symbol, checked before connecting. The offered-symbol check does not apply: the handshake’s list does not hold every underlying that has options (index roots are absent from it), and an underlying with no options is rejected by the provider by name rather than confirmed.

Errors

Returns SocketError::Subscribe if the batch is empty, the key is rejected, the handshake times out, the batch would take the connection over its subscription cap, any requested symbol is not offered, or — on the options dataset — any contract has no OSI symbol or names an underlying with no options.

type SubMapper = LseSubMapper

type Transport = LseAttachment

What a successful subscribe hands the stream to read from.