Enum ErrorString 

pub enum ErrorString {
    MissingMarket,
    UnknownMarket,
    MissingSide,
    MissingTimeInForce,
    MissingExpiryTimestampForGttTimeInForce,
    ExpiryTimestampInThePast,
    ExpiryTimestampTooFarInFuture,
    ExpiryTimestampOnlyValidForGtt,
    PostOnlyOrderMustBePersisting,
    MissingOrderType,
    UnexpectedPriceForMarketOrder,
    MissingPriceForLimitOrder,
    InvalidOrderPrice,
    OrderPriceCannotBeZero,
    OrderPriceMustBePositive,
    OrderPriceHasTooManyDecimalPlaces,
    MissingOrderQuantity,
    CannotUseOrderLinkQuantityWithoutAConditionOrderUsingOrderLinkedActivation,
    InvalidOrderQuantity,
    OrderQuantityCannotBeZero,
    OrderQuantityMustBePositive,
    OrderQuantityHasTooManyDecimalPlaces,
    OrderQuantityNotMultipleOfLotSize,
    OrderPriceNotMultipleOfTickSize,
    OrderPercentageOfPositionQuantityMustBeGreaterThanZeroAndLesserThanOne,
    InvalidOrderPercentageOfPositionQuantity,
    InvalidPersistentMarketOrder,
    MissingAccount,
    ConflictingOrderIds,
    NewBlockCommandIsRestricted,
    InvalidTransactionPayload,
    TransactionPayloadIsNotValidBase64Encoding,
    TransactionInvalidSignature,
    V2RequiresSigner,
    UnknownTransactionVersion,
    V2SignerNotOwner,
    NonceNotSet,
    NonceTooOld,
    NonceInFuture,
    NonceReused,
    ChainIdMismatch,
    ChainIdEmpty,
    AdminCommandRequiresMultisig,
    AdminCommandNotAuthorizedForQuorum,
    SetPlatformModeUnknownMode,
    SetMarketTradingModeNoImmediatePeriod,
    SetMarketTradingModeUnsortedPeriods,
    SetMarketTradingModePastPeriod,
    SettleMarketInvalidPrice,
    SenderNotAllowed,
    TrailingStopTriggersNotSupported,
    IndexReferencePriceNotSupported,
    MarkReferencePriceNotSupported,
    OrderLinkedActivationNotSupported,
    OrderLinkBothIds,
    OrderLinkMissingParent,
    OrderLinkMissingFillQuantity,
    OrderLinkInvalidFillQuantity,
    OcoOrdersNotSupported,
    InvalidTriggerPrice,
    TriggerPriceCannotBeZero,
    TriggerPriceMustBePositive,
    OrderLinkQuantityNotSupported,
    MissingTriggerCondition,
    ConditionalOrderMustNotHaveMainQuantity,
    ConditionalOrderMustHaveQuantity,
    TriggerPriceHasTooManyDecimalPlaces,
    TriggerPriceNotMultipleOfTickSize,
    OrderBelowMinimumOrderValue,
    OrderAboveMaximumOrderValue,
    MarkPriceUnavailable,
    BatchOfOneRequired,
    ImrBelowMarketMinimum,
    ImrAboveOne,
    ImrNotPositive,
    ImrTooManyDecimals,
    MarginChangePending,
    PlatformRestricted,
    PlatformOffline,
    Unknown(String),
}

Enumeration of all possible error condition descriptions.

Each variant corresponds to a specific error condition that can occur in the matching engine. The serde rename attributes ensure consistent JSON/API serialization format.

ErrorString::Unknown is what keeps adding an error code the additive change this mechanism promises. Without it a client built against an older release fails to deserialize the entire report the first time the sequencer names a code it has not heard of — losing the error_code beside it, which would have said what actually happened.

Variants

MissingMarket

Market identifier was not provided in the request

UnknownMarket

Referenced market does not exist or is not available

MissingSide

Order side (buy/sell) was not specified

MissingTimeInForce

Time in force parameter was not provided

MissingExpiryTimestampForGttTimeInForce

Good-Till-Time orders require an expiry timestamp

ExpiryTimestampInThePast

The provided expiry timestamp is in the past

ExpiryTimestampTooFarInFuture

The provided expiry timestamp is beyond the latest supported date

ExpiryTimestampOnlyValidForGtt

Expiry timestamp is only valid for GTT time in force

PostOnlyOrderMustBePersisting

Post-only orders must have a persisting time in force

MissingOrderType

Order type (market/limit) was not specified

UnexpectedPriceForMarketOrder

Market orders should not include a price parameter

MissingPriceForLimitOrder

Limit orders require a price to be specified

InvalidOrderPrice

The provided price is in an invalid format

OrderPriceCannotBeZero

Order price cannot be zero

OrderPriceMustBePositive

Order price must be a positive value

OrderPriceHasTooManyDecimalPlaces

Order price exceeds the allowed decimal precision

MissingOrderQuantity

Order quantity was not provided

CannotUseOrderLinkQuantityWithoutAConditionOrderUsingOrderLinkedActivation

Order link quantity cannot be used without proper conditional order setup

InvalidOrderQuantity

The provided quantity is in an invalid format

OrderQuantityCannotBeZero

Order quantity cannot be zero

OrderQuantityMustBePositive

Order quantity must be a positive value

OrderQuantityHasTooManyDecimalPlaces

Order quantity exceeds the allowed decimal precision

OrderQuantityNotMultipleOfLotSize

Order quantity is not a multiple of the market’s lot size

OrderPriceNotMultipleOfTickSize

Order price is not a multiple of the market’s tick size

OrderPercentageOfPositionQuantityMustBeGreaterThanZeroAndLesserThanOne

Percentage of position quantity must be between 0 and 1 (exclusive of 0, inclusive of 1)

InvalidOrderPercentageOfPositionQuantity

The percentage of position quantity is in an invalid format

InvalidPersistentMarketOrder

MissingAccount

Account identifier was not provided

ConflictingOrderIds

Both an order id and a client order id were supplied for a cancellation

NewBlockCommandIsRestricted

New block command is restricted and cannot be executed

InvalidTransactionPayload

Transaction payload is malformed or invalid

TransactionPayloadIsNotValidBase64Encoding

Transaction payload is not valid base64 encoding

TransactionInvalidSignature

Transaction signature verification failed

V2RequiresSigner

V2 transaction is missing the required envelope signer field

UnknownTransactionVersion

Transaction version is not recognized

V2SignerNotOwner

V2 transaction with no multisig context has signer != owner

NonceNotSet

Payload nonce was zero — the field was never filled in

NonceTooOld

Payload nonce reaches further into the past than replay protection covers

NonceInFuture

Payload nonce is further ahead of the sequencer’s clock than allowed

NonceReused

Payload nonce was already used by this owner

ChainIdMismatch

Payload chain id names a different network than the one serving the request

ChainIdEmpty

Payload chain id was present but empty

AdminCommandRequiresMultisig

An admin-only command was submitted in a non-multisig transaction

AdminCommandNotAuthorizedForQuorum

The quorum’s name does not authorize the submitted admin command

SetPlatformModeUnknownMode

set_platform_mode mode is not one of the known values

SetMarketTradingModeNoImmediatePeriod

set_market_trading_mode periods must begin with a start_ms == 0 entry: the immediate mode, applied when the proposal executes

SetMarketTradingModeUnsortedPeriods

set_market_trading_mode periods are not strictly ascending by start_ms

SetMarketTradingModePastPeriod

set_market_trading_mode nonzero period start_ms is not in the future

SettleMarketInvalidPrice

settle_market price is not a valid decimal

SenderNotAllowed

The transaction sender is not authorized

TrailingStopTriggersNotSupported

Trailing stop triggers are not supported yet

IndexReferencePriceNotSupported

Index reference price is not supported yet

MarkReferencePriceNotSupported

Mark reference price is not supported yet

OrderLinkedActivationNotSupported

Reserved: order-linked activation is supported and nothing emits this today

OrderLinkBothIds

A linked conditional referenced both a client order id and an order id

OrderLinkMissingParent

A linked conditional did not reference any parent order

OrderLinkMissingFillQuantity

A linked conditional did not specify a fill quantity threshold

OrderLinkInvalidFillQuantity

The order link fill quantity threshold was not a valid quantity

OcoOrdersNotSupported

OCO (One-Cancels-Other) orders are not supported yet

InvalidTriggerPrice

Invalid trigger price format

TriggerPriceCannotBeZero

Trigger price cannot be zero

TriggerPriceMustBePositive

Trigger price must be positive

OrderLinkQuantityNotSupported

Order link quantity is not supported yet

MissingTriggerCondition

Trigger condition was not specified

ConditionalOrderMustNotHaveMainQuantity

Conditional orders must not have a quantity in the main order

ConditionalOrderMustHaveQuantity

Conditional orders must have a quantity specified

TriggerPriceHasTooManyDecimalPlaces

Trigger price exceeds the allowed decimal precision

TriggerPriceNotMultipleOfTickSize

Trigger price is not a multiple of the market’s tick size

OrderBelowMinimumOrderValue

Order’s notional value (price × quantity) is below the market’s minimum

OrderAboveMaximumOrderValue

Order’s notional value (price × quantity) is above the market’s maximum

MarkPriceUnavailable

Market order rejected because the market has no current mark price

BatchOfOneRequired

Margin-parameter commands must be alone in the transaction

ImrBelowMarketMinimum

IMR value is below the market’s minimum IMR

ImrAboveOne

IMR value exceeds 1.0

ImrNotPositive

IMR value must be strictly positive

ImrTooManyDecimals

IMR value has more than 18 decimal places

MarginChangePending

A previous margin-parameter change for this account/market is still pending chain confirmation

PlatformRestricted

Platform is in Restricted mode and the sender is not a market maker

PlatformOffline

Platform is in Offline mode

Unknown(String)

An error kind this build does not know about, preserved verbatim. Serde requires an untagged variant to come last.

Trait Implementations

impl Clone for ErrorString

fn clone(&self) -> ErrorString

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorString

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ErrorString

fn deserialize<__D>( __deserializer: __D, ) -> Result<ErrorString, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ErrorString

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ErrorString

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ErrorString