Quant Trading Systems: Architecture & Infrastructure › Execution Management System

# Demonstrate FIX message structure (simplified representation)
# Real FIX uses tag=value format with SOH delimiters


class SimpleFIXMessage:
    """Simplified FIX message builder for demonstration."""

    # Common FIX tags
    TAGS = {
        "BeginString": "8",
        "MsgType": "35",
        "SenderCompID": "49",
        "TargetCompID": "56",
        "ClOrdID": "11",
        "Symbol": "55",
        "Side": "54",
        "OrderQty": "38",
        "OrdType": "40",
        "Price": "44",
        "TransactTime": "60",
    }

    # Message types
    MSG_TYPES = {
        "NewOrderSingle": "D",
        "ExecutionReport": "8",
        "OrderCancelRequest": "F",
    }

    def __init__(self, msg_type: str):
        self.fields = {
            "BeginString": "FIX.4.4",
            "MsgType": self.MSG_TYPES.get(msg_type, msg_type),
        }

    def set_field(self, name: str, value: str):
        self.fields[name] = value
        return self

    def to_string(self) -> str:
        """Convert to FIX-like string representation."""
        parts = []
        for name, value in self.fields.items():
            tag = self.TAGS.get(name, name)
            parts.append(f"{tag}={value}")
        return "|".join(parts)


# Build a sample new order message
new_order = SimpleFIXMessage("NewOrderSingle")
new_order.set_field("SenderCompID", "QUANT_FIRM")
new_order.set_field("TargetCompID", "EXCHANGE")
new_order.set_field("ClOrdID", "ORD-2024-001")
new_order.set_field("Symbol", "AAPL")
new_order.set_field("Side", "1")  # 1 = Buy
new_order.set_field("OrderQty", "100")
new_order.set_field("OrdType", "2")  # 2 = Limit
new_order.set_field("Price", "185.50")

@dataclass
class VenueQuote:
    """Quote from a specific trading venue."""

    venue_id: str
    bid_price: float
    bid_size: int
    ask_price: float
    ask_size: int
    latency_ms: float  # Expected latency to venue
    fee_per_share: float  # Negative means rebate


class SmartOrderRouter:
    """Simple smart order router for demonstration."""

    def __init__(self, venues: list[str]):
        self.venues = venues
        self.venue_quotes: dict[str, VenueQuote] = {}

    def update_quote(self, quote: VenueQuote):
        """Update quote for a venue."""
        self.venue_quotes[quote.venue_id] = quote

    def route_order(
        self, side: str, quantity: int, strategy: str = "best_price"
    ) -> list[tuple[str, int]]:
        """
        Route order across venues.
        Returns list of (venue_id, quantity) allocations.
        """
        if not self.venue_quotes:
            return []

        if strategy == "best_price":
            return self._route_best_price(side, quantity)
        elif strategy == "minimize_impact":
            return self._route_minimize_impact(side, quantity)
        else:
            raise ValueError(f"Unknown routing strategy: {strategy}")

    def _route_best_price(
        self, side: str, quantity: int
    ) -> list[tuple[str, int]]:
        """Route to venues with best prices, sweeping through order book."""
        allocations = []
        remaining = quantity

        if side == "BUY":
            # Sort venues by ask price (lowest first), then by fee
            sorted_venues = sorted(
                self.venue_quotes.values(),
                key=lambda v: (v.ask_price, v.fee_per_share),
            )

            for venue in sorted_venues:
                if remaining <= 0:
                    break
                fill_qty = min(remaining, venue.ask_size)
                if fill_qty > 0:
                    allocations.append((venue.venue_id, fill_qty))
                    remaining -= fill_qty
        else:
            # Sort by bid price (highest first)
            sorted_venues = sorted(
                self.venue_quotes.values(),
                key=lambda v: (-v.bid_price, v.fee_per_share),
            )

            for venue in sorted_venues:
                if remaining <= 0:
                    break
                fill_qty = min(remaining, venue.bid_size)
                if fill_qty > 0:
                    allocations.append((venue.venue_id, fill_qty))
                    remaining -= fill_qty

        return allocations

    def _route_minimize_impact(
        self, side: str, quantity: int
    ) -> list[tuple[str, int]]:
        """Spread order across venues to minimize market impact."""
        total_liquidity = sum(
            v.ask_size if side == "BUY" else v.bid_size
            for v in self.venue_quotes.values()
        )

        if total_liquidity == 0:
            return []

        allocations = []
        for venue in self.venue_quotes.values():
            venue_liquidity = (
                venue.ask_size if side == "BUY" else venue.bid_size
            )
            proportion = venue_liquidity / total_liquidity
            venue_qty = int(quantity * proportion)
            if venue_qty > 0:
                allocations.append((venue.venue_id, venue_qty))

        return allocations

# Demonstrate smart order routing
router = SmartOrderRouter(["NYSE", "NASDAQ", "BATS", "IEX"])

# Set up venue quotes
quotes = [
    VenueQuote("NYSE", 185.48, 500, 185.50, 300, 0.5, 0.003),
    VenueQuote("NASDAQ", 185.47, 200, 185.49, 400, 0.3, -0.002),  # Rebate
    VenueQuote("BATS", 185.48, 300, 185.50, 200, 0.4, 0.001),
    VenueQuote("IEX", 185.47, 400, 185.51, 600, 0.8, 0.0009),
]

for quote in quotes:
    router.update_quote(quote)

# Route a buy order using different strategies
buy_qty = 500
allocations_best = router.route_order("BUY", buy_qty, "best_price")
allocations_impact = router.route_order("BUY", buy_qty, "minimize_impact")