Enum OrderingViolation 

pub enum OrderingViolation {
    UnauthorizedSubmission {
        subject: Subject,
        order: OrderId,
        authorized_subjects: Vec<Subject>,
    },
    OrderSubjectDrift {
        order: OrderId,
        first: Subject,
        later: Subject,
    },
    AcknowledgmentWithoutSubmission {
        order: OrderId,
    },
    FillWithoutAcknowledgment {
        order: OrderId,
    },
    ReconciliationWithoutFill {
        order: OrderId,
    },
    OutOfOrderTransition {
        order: OrderId,
        attempted: PhaseKind,
        current: Option<PhaseKind>,
    },
    AmbiguousWriteRetriedWithoutKey {
        subject: Subject,
        ambiguous_order: OrderId,
        retry_order: OrderId,
        retry_key: Option<ClientOrderKey>,
    },
    AmbiguityUnavailable {
        subject: Subject,
        prior_order: OrderId,
        retry_order: OrderId,
    },
    DuplicateTransition {
        order: OrderId,
        phase: PhaseKind,
    },
    UnreconciledFill {
        order: OrderId,
    },
    SubmissionWithoutDecision {
        subject: Subject,
        order: OrderId,
    },
    DecisionWithoutObservation {
        subject: Subject,
    },
}

An ordering failure in the trading lifecycle.

Block-severity variants are the ones that let an agent move capital without the control that was supposed to gate it. Warn-severity variants are bookkeeping failures: the control ran, the record is incomplete.

Variants

UnauthorizedSubmission

An order was submitted for a subject that had no passing risk evaluation before it. Block severity.

authorized_subjects lists the subjects that were authorized at that point, so the report distinguishes “no risk evaluation ran at all” from “a risk evaluation ran, on something else”. The second case is the one a subject-blind ordering check would wave through.

Fields

subject: Subject

order: OrderId

authorized_subjects: Vec<Subject>

OrderSubjectDrift

Two transitions for the same order named different subjects. Block severity: whatever was authorized is not what settled.

Fields

order: OrderId

first: Subject

later: Subject

AcknowledgmentWithoutSubmission

An acknowledgment arrived for an order that was never submitted. Block severity.

Fields

order: OrderId

FillWithoutAcknowledgment

An order filled without ever being acknowledged. Block severity.

Fields

order: OrderId

ReconciliationWithoutFill

A reconciliation ran against an order that had not filled. Block severity.

Fields

order: OrderId

OutOfOrderTransition

Any other backwards or skipping transition for an order. Block severity.

Fields

order: OrderId

attempted: PhaseKind

current: Option<PhaseKind>

AmbiguousWriteRetriedWithoutKey

A write whose outcome the trace records as unknown was retried under a different intent, so the venue is free to hold both. Block severity: if the first submission committed, the position just doubled, and no control downstream can tell the two apart.

retry_key names what the retry claimed — None when it claimed nothing, Some when it claimed a key the ambiguous submission did not carry, which is a different order under a borrowed name rather than the same one again.

Fields

subject: Subject

ambiguous_order: OrderId

retry_order: OrderId

retry_key: Option<ClientOrderKey>

AmbiguityUnavailable

A resubmission for a subject whose earlier submission has no recorded outcome: neither acknowledged nor marked unobserved. Warn severity, and deliberately not an ambiguous-write finding — the trace does not establish whether the first write was ambiguous, so the check reports the missing evidence instead of guessing a verdict in either direction.

Fields

subject: Subject

prior_order: OrderId

retry_order: OrderId

DuplicateTransition

The same stage was recorded twice in a row for one order. Warn severity: duplicated bookkeeping, not a bypassed control.

Fields

order: OrderId

phase: PhaseKind

UnreconciledFill

The trace ended with a fill that was never reconciled. Warn severity.

Fields

order: OrderId

SubmissionWithoutDecision

An order was submitted for a subject with no recorded decision. Warn severity: the risk gate still ran, but the stated intent is missing.

Fields

subject: Subject

order: OrderId

DecisionWithoutObservation

A decision was formed for a subject that was never observed. Warn severity.

Fields

subject: Subject

Implementations

impl OrderingViolation

pub fn is_block(&self) -> bool

Whether this violation is catastrophic (a control was bypassed).

Trait Implementations

impl Clone for OrderingViolation

fn clone(&self) -> OrderingViolation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OrderingViolation

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

Formats the value using the given formatter.

impl PartialEq for OrderingViolation

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for OrderingViolation

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 OrderingViolation