hypercall_sdk_types/

enums.rs

//! Core enums used throughout Hypercall.

use serde::{Deserialize, Serialize};
use std::fmt;
use std::str::FromStr;

/// Order side (buy or sell).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub enum Side {
    /// Buy side
    Buy,
    /// Sell side
    Sell,
}

/// Time in force for orders.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub enum TimeInForce {
    /// Good Till Cancelled
    #[serde(rename = "gtc")]
    #[default]
    GTC,
    /// Immediate or Cancel
    #[serde(rename = "ioc")]
    IOC,
    /// Fill or Kill
    #[serde(rename = "fok")]
    FOK,
}

/// Option type (call or put).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub enum OptionType {
    /// Call option
    #[serde(rename = "CALL", alias = "Call", alias = "call")]
    Call,
    /// Put option
    #[serde(rename = "PUT", alias = "Put", alias = "put")]
    Put,
}

impl OptionType {
    pub const fn as_db_str(self) -> &'static str {
        match self {
            Self::Call => "call",
            Self::Put => "put",
        }
    }

    pub const fn is_call(self) -> bool {
        matches!(self, Self::Call)
    }
}

impl fmt::Display for OptionType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_db_str())
    }
}

impl FromStr for OptionType {
    type Err = ();

    fn from_str(value: &str) -> Result<Self, Self::Err> {
        if value.eq_ignore_ascii_case("call") {
            return Ok(Self::Call);
        }
        if value.eq_ignore_ascii_case("put") {
            return Ok(Self::Put);
        }
        Err(())
    }
}

/// Order status in the order lifecycle.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub enum OrderStatus {
    /// Order acknowledged by the system
    #[serde(rename = "ACKED", alias = "ACK")]
    Acked,
    /// Order is open on the book
    #[serde(rename = "OPEN_ORDER", alias = "OPEN")]
    OpenOrder,
    /// Order was rejected
    #[serde(
        rename = "REJECT_ORDER",
        alias = "REJECT",
        alias = "REJECTED",
        alias = "Rejected"
    )]
    RejectOrder,
    /// Order fully filled
    #[serde(rename = "FILLED", alias = "Filled")]
    Filled,
    /// Order partially filled
    #[serde(rename = "PARTIALLY_FILLED", alias = "PartiallyFilled")]
    PartiallyFilled,
    /// Order was canceled
    #[serde(rename = "CANCELED", alias = "CANCELLED")]
    Canceled,
}

/// Order update status (used in order update messages).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub enum OrderUpdateStatus {
    /// Order acknowledged by the system
    #[serde(rename = "ACKED")]
    Acked,
    /// Order is open on the book
    #[serde(rename = "OPEN")]
    Open,
    /// Order partially filled
    #[serde(rename = "PARTIALLY_FILLED")]
    PartiallyFilled,
    /// Order fully filled
    #[serde(rename = "FILLED")]
    Filled,
    /// Order was canceled
    #[serde(rename = "CANCELED")]
    Canceled,
    /// Order was rejected
    #[serde(rename = "REJECTED")]
    Rejected,
}

/// Trade side for trade messages.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub enum TradeSide {
    #[serde(rename = "BUY", alias = "Buy", alias = "buy")]
    Buy,
    #[serde(rename = "SELL", alias = "Sell", alias = "sell")]
    Sell,
}

/// Market action (create, delete, or expire).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum MarketAction {
    #[serde(rename = "CREATE_MARKET")]
    CreateMarket,
    #[serde(rename = "DELETE_MARKET")]
    DeleteMarket,
    #[serde(rename = "EXPIRE_MARKET")]
    ExpireMarket,
}

/// Market update status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub enum MarketUpdateStatus {
    /// Market was created
    #[serde(rename = "MARKET_CREATED")]
    MarketCreated,
    /// Market already exists (idempotent - not an error)
    #[serde(rename = "MARKET_ALREADY_EXISTS")]
    MarketAlreadyExists,
    /// Market was deleted
    #[serde(rename = "MARKET_DELETED")]
    MarketDeleted,
    /// Market expired
    #[serde(rename = "MARKET_EXPIRED")]
    MarketExpired,
    /// Market transitioned to expired pending settlement (price unavailable or settlement deferred)
    #[serde(rename = "MARKET_PENDING_SETTLEMENT")]
    MarketPendingSettlement,
    /// Market creation failed
    #[serde(rename = "MARKET_CREATION_FAILED")]
    MarketCreationFailed,
    /// Market deletion failed
    #[serde(rename = "MARKET_DELETION_FAILED")]
    MarketDeletionFailed,
}

/// Order action (create, cancel, or replace).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum OrderAction {
    #[serde(rename = "CREATE_ORDER")]
    CreateOrder,
    #[serde(rename = "CANCEL_ORDER")]
    CancelOrder,
    #[serde(rename = "REPLACE_ORDER")]
    ReplaceOrder,
}

/// Transaction status for on-chain transactions.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum TransactionStatus {
    #[serde(rename = "PENDING")]
    Pending,
    #[serde(rename = "SUBMITTED")]
    Submitted,
    #[serde(rename = "CONFIRMED")]
    Confirmed,
    #[serde(rename = "FAILED")]
    Failed,
    #[serde(rename = "EXPIRED")]
    Expired,
}

/// RFQ lifecycle status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub enum RfqStatus {
    Created,
    SentToQps,
    QuotesReceived,
    NoQuotes,
    Expired,
    Accepted,
    Executed,
    Failed,
}

impl RfqStatus {
    pub fn is_terminal(&self) -> bool {
        matches!(
            self,
            RfqStatus::NoQuotes | RfqStatus::Expired | RfqStatus::Executed | RfqStatus::Failed
        )
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            RfqStatus::Created => "created",
            RfqStatus::SentToQps => "sent_to_qps",
            RfqStatus::QuotesReceived => "quotes_received",
            RfqStatus::NoQuotes => "no_quotes",
            RfqStatus::Expired => "expired",
            RfqStatus::Accepted => "accepted",
            RfqStatus::Executed => "executed",
            RfqStatus::Failed => "failed",
        }
    }
}

impl std::fmt::Display for RfqStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

/// Quote provider tier.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub enum QpTier {
    Qp1,
    Qp2,
    Qp3Internal,
}

impl QpTier {
    pub fn as_str(&self) -> &'static str {
        match self {
            QpTier::Qp1 => "qp1",
            QpTier::Qp2 => "qp2",
            QpTier::Qp3Internal => "qp3_internal",
        }
    }
}

impl std::fmt::Display for QpTier {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

/// Quote provider status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub enum QpStatus {
    Active,
    Suspended,
}

/// Source of a fill (orderbook matching or RFQ execution).
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub enum FillSource {
    #[default]
    Orderbook,
    Rfq {
        rfq_id: String,
        quote_id: String,
    },
}

bitflags::bitflags! {
    /// Set of trading modes enabled for an instrument. Empty means the
    /// instrument is fully disabled. New variants can be added without
    /// the combinatorial explosion of an enum.
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
    pub struct TradingModes: u8 {
        const ORDERBOOK = 0b0000_0001;
        const RFQ       = 0b0000_0010;
    }
}

impl Default for TradingModes {
    fn default() -> Self {
        TradingModes::ORDERBOOK
    }
}

impl TradingModes {
    pub fn allows_orderbook(&self) -> bool {
        self.contains(Self::ORDERBOOK)
    }

    pub fn allows_rfq(&self) -> bool {
        self.contains(Self::RFQ)
    }

    /// Canonical wire / DB representation: pipe-joined lowercase tokens
    /// (e.g. `"orderbook"`, `"rfq"`, `"orderbook|rfq"`, `""` for empty).
    pub fn as_db_str(&self) -> String {
        let mut parts = Vec::with_capacity(2);
        if self.contains(Self::ORDERBOOK) {
            parts.push("orderbook");
        }
        if self.contains(Self::RFQ) {
            parts.push("rfq");
        }
        parts.join("|")
    }

    /// Parse from DB / wire format. Accepts the canonical pipe-delimited
    /// form and the legacy single-value form (`orderbook_only`, `rfq_only`,
    /// `both`) so snapshots written before the bitflags migration still
    /// rehydrate during the rollout window.
    pub fn from_db_str(s: &str) -> Self {
        // Fast path for legacy single-value snapshots written before the
        // bitflags migration; accept them as-is so the rollout window
        // doesn't require a full backfill.
        match s {
            "" => return Self::empty(),
            "orderbook_only" => return Self::ORDERBOOK,
            "rfq_only" => return Self::RFQ,
            "both" => return Self::ORDERBOOK | Self::RFQ,
            _ => {}
        }
        let mut modes = Self::empty();
        for part in s.split('|') {
            match part.trim() {
                "" => {}
                "orderbook" => modes |= Self::ORDERBOOK,
                "rfq" => modes |= Self::RFQ,
                other => {
                    // Unknown tokens previously panicked and took the
                    // whole API process down on schema drift. Log loudly
                    // instead and ignore the bad token — boundary parsing
                    // should never crash a production binary. The fall-
                    // back mode becomes whatever other tokens in `s`
                    // resolved to (may be empty).
                    tracing::error!(
                        "TradingModes::from_db_str: unknown token '{}' in '{}', \
                         ignoring — may indicate schema drift or corruption",
                        other,
                        s
                    );
                }
            }
        }
        modes
    }
}

impl std::fmt::Display for TradingModes {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&self.as_db_str())
    }
}

impl Serialize for TradingModes {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(&self.as_db_str())
    }
}

impl<'de> Deserialize<'de> for TradingModes {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from_db_str(&s))
    }
}