Enum LseMessage 

pub enum LseMessage {
    Tick(LseTick),
    ReplayStarted {
        subscription_id: SubscriptionId,
        from: DateTime<Utc>,
    },
    Error {
        code: Option<SmolStr>,
        message: Option<SmolStr>,
    },
    Other,
}

A frame received on the London Strategic Edge WebSocket data stream.

The stream carries control frames (subscription confirmations, replay boundaries, errors) interleaved with ticks, on the same connection and after the handshake has completed. Anything this integration does not act on decodes to Other so a control frame cannot fail the parse and take the stream down with it; the confirmations that carry meaning to the handshake are decoded by the subscription types instead, where they can be acted on.

Two control frames are modelled rather than collapsed into Other, because both carry something no other frame does: ReplayStarted is the only evidence a replay window was clamped, and Error is the only evidence the provider rejected something after the handshake stopped reading.

Variants

Tick(LseTick)

A tick.

ReplayStarted

The boundary frame announcing the replay window the provider actually opened.

⚠️ from is the only signal that a start was clamped

The provider retains 24 hours. A start further back is silently moved forward, with no error: a window requested 48 hours back was answered with one beginning exactly 24 hours back, and streamed from there. Comparing from against what was asked for is the only way to detect it.

Why it is modelled on the stream rather than caught during the handshake

The provider answers subscribe before it announces the window — measured on both a crypto and an FX symbol, the order is subscribed, then replay_started, then the replayed ticks. A subscribe handshake is complete the moment its last confirmation arrives, so a single-symbol resumed subscription never has a replay_started to inspect at handshake time, and a batch never has one for its last symbol. Reading it here instead makes the check independent of frame ordering and of batch size.

The shared connection routes it only to the streams a replay window was opened for — see connection.

Fields

subscription_id: SubscriptionId

The subscription the window belongs to, built from symbol exactly as a tick’s is.

from: DateTime<Utc>

The instant the provider will actually replay from.

Error

A rejection raised outside a subscribe handshake.

Why no stream normally sees one

The provider does not name the symbol it rejected, so a rejection arriving outside a handshake — a later LIMIT_REACHED, a credential that expired mid-connection — cannot be routed to the stream it concerns. The shared connection logs it once instead, and one arriving during a handshake fails that handshake.

It is still decoded rather than collapsed into Other, so a rejection that reaches a stream by any other route is reported rather than discarded in silence — the one thing a rejection must never be, since the only outward sign of one is a subscription that stops ticking.

Both fields are optional for the same reason they are on the handshake’s own rejection: a frame missing one must still decode, because failing the parse on an error frame would take the whole stream down over the message that was trying to report a problem.

Fields

code: Option<SmolStr>

The provider’s error code — LIMIT_REACHED and INVALID_START are the two observed.

message: Option<SmolStr>

The provider’s own diagnostic.

Other

Any other frame — a control frame, or one this integration does not model.

Trait Implementations

impl Clone for LseMessage

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 LseMessage

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LseMessage

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for LseMessage

impl Identifier<Option<SubscriptionId>> for LseMessage

fn id(&self) -> Option<SubscriptionId>

A tick resolves to the subscription its symbol was registered under; anything else resolves to nothing.

The None is what keeps control frames out of the market stream: the transformer drops an unidentifiable frame rather than attempting to convert it, so the two decoders never have to invent an event for a frame that describes none.

impl PartialEq for LseMessage

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LseMessage