Enum LseSubResponse 

pub enum LseSubResponse {
    Subscribed {
        symbol: Option<SmolStr>,
        count: Option<u32>,
        max: Option<u32>,
    },
    OptionsSubscribed {
        underlying: Option<SmolStr>,
        contracts: Option<u32>,
        count: Option<u32>,
        max: Option<u32>,
    },
    Error {
        code: Option<SmolStr>,
        message: Option<SmolStr>,
    },
}

The provider’s answer to a subscribe request.

One frame arrives per request — {"action":"subscribe","symbol":"EUR/USD"} is answered by {"type":"subscribed","symbol":"EUR/USD","count":1,"max":16}. The subscriber sends one request per distinct symbol, or on the options dataset per distinct underlying, and the connector’s expected_responses counts the same way.

⚠️ A confirmation is NOT evidence the symbol exists

Subscribing to a symbol the provider has never heard of is confirmed, not rejected: it answers subscribed, never errors, never ticks, and permanently consumes one of the connection’s subscription slots. Validation here therefore cannot catch a typo, and does not try to. That guard runs in the subscriber, against the symbol list the authenticated frame supplies, before any subscribe is sent — which is also what keeps a bad batch from spending slots it can never get back.

Why replay frames are deliberately not modelled here

A validator counts every frame that deserialises into this type and validates Ok as one more subscription confirmed — the connector’s declared SubValidator does. The shared connection decodes a frame as this type only when its type names an answer, but the type must stay safe for any validator to count. A replay_started frame modelled as a success would inflate that count and end validation before the last real confirmation arrived. It is decoded on the stream instead, and reaches the transformer as stream data — the same route ticks take. For the same reason this enum has no catch-all variant: one would swallow ticks into the success count.

Variants

Subscribed

A subscription was accepted, and the connection now holds count of its max slots.

No field is required to deserialise, symbol included. All three are reported by the provider and modelled for the reader, but nothing acts on any of them: a validator counts confirmations rather than matching them to symbols, and the cap is enforced before a subscribe is sent, against the authenticated frame. Requiring a field nothing reads would let a rename or an omission upstream turn an arriving confirmation into a ten-second validation timeout blaming latency — and symbol is not privileged here, because a confirmation that cannot be matched to a request is worth exactly as much as one that can. The same reasoning the Error variant is built on.

Fields

symbol: Option<SmolStr>

The symbol, case-normalised by the provider (eur/usd is confirmed as EUR/USD).

count: Option<u32>

Slots held on this connection after the subscription.

max: Option<u32>

Slots this connection may hold in total.

OptionsSubscribed

An underlying’s option chain was subscribed, and the connection now holds count of its max slots.

Answers {"action":"subscribe_options","underlying":"SPY"} with {"type":"options_subscribed","underlying":"SPY","contracts":10649,"active_underlyings":1, "count":1,"max":100}. One arrives per subscribe, including a repeated one, which is why the subscriber sends each underlying once.

No field is required, for the reason given on Subscribed.

Fields

underlying: Option<SmolStr>

The underlying, case-normalised by the provider (spy is confirmed as SPY).

contracts: Option<u32>

Contracts in the underlying’s chain. Advisory: it drifts within a session, and says nothing about whether any registered contract is among them.

count: Option<u32>

Slots held on this connection after the subscription.

max: Option<u32>

Slots this connection may hold in total.

Error

A subscription was rejected.

Both fields are optional so that a rejection missing one cannot fail to deserialise and be silently reclassified as stream data — an error frame must never be the thing that gets swallowed.

Fields

code: Option<SmolStr>

The provider’s error code. LIMIT_REACHED, INVALID_START and — for an option underlying with no options — INVALID_UNDERLYING are those observed; the field is kept as text rather than an enum so an unrecognised code reaches the caller intact instead of collapsing into a catch-all.

message: Option<SmolStr>

The provider’s own diagnostic.

Trait Implementations

impl Clone for LseSubResponse

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 LseSubResponse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LseSubResponse

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for LseSubResponse

impl PartialEq for LseSubResponse

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for LseSubResponse

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 LseSubResponse

impl Validator for LseSubResponse

type Error = SocketError

fn validate(self) -> Result<Self, SocketError>

Check if Self is valid for some use case.