foxhunt/trading_engine

Trading Engine Crate

Overview

The trading_engine crate provides the high-performance core infrastructure essential for High-Frequency Trading (HFT) operations. It focuses on ultra-low latency execution, precise timing, and efficient order management to handle demanding market conditions.

Features

• Extreme Performance Optimization: Utilizes RDTSC for precise timing, CPU affinity for dedicated core execution, and SIMD instructions for vectorized data processing.
• Robust Order Management: Manages the lifecycle of orders, from placement to execution and cancellation, ensuring accuracy and low-latency updates.
• Flexible Execution Engine: Implements a highly optimized engine capable of processing trading strategies and executing orders across various venues.
• Multi-Broker Connectivity: Seamlessly integrates with multiple brokers, including Interactive Brokers and ICMarkets, via specialized adapters.
• Event-Sourced Architecture: Employs event sourcing for deterministic state reconstruction, coupled with comprehensive metrics and persistent storage.
• Concurrent Lock-Free Data Structures: Leverages advanced lock-free data structures to minimize contention and maximize throughput in multi-threaded environments.

Architecture

The trading_engine is structured around several key components:

• Execution Core: The central logic for strategy evaluation and trade decision-making.
• Order Manager: Handles all order-related operations, maintaining order state and communicating with broker adapters.
• Broker Adapters: Abstract interfaces and concrete implementations for connecting to specific trading venues (e.g., IbAdapter, IcMarketsAdapter).
• Performance Utilities: Modules for RDTSC access, CPU core pinning, and SIMD instruction sets.
• Event Store: A mechanism for recording all significant events, enabling replay and auditability.
• Metrics System: Collects and reports performance and operational statistics.
• Persistence Layer: Stores critical state and event data for recovery and analysis.
• Concurrency Primitives: Custom lock-free queues, rings, and other data structures.

Usage

To initialize the trading engine and place a simple order:

use trading_engine::{
    engine::TradingEngine,
    order::{Order, OrderSide, OrderType},
    broker::BrokerType,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut engine = TradingEngine::new();
    engine.connect_broker(BrokerType::InteractiveBrokers).await?;

    let order = Order {
        symbol: "ESZ23".to_string(),
        side: OrderSide::Buy,
        order_type: OrderType::Limit,
        quantity: 1,
        price: Some(4500.0),
        // ... other order details
    };

    let order_id = engine.place_order(order).await?;
    println!("Placed order with ID: {}", order_id);

    Ok(())
}

Testing

To run the tests for the trading_engine crate:

cargo test --package trading_engine

Documentation

Comprehensive API documentation is available at docs.rs/trading_engine.