foxhunt/CLAUDE.md

CLAUDE.md - Foxhunt HFT Trading System

Last Updated: 2025-10-06

---

🎯 System Overview

Foxhunt is a high-frequency trading system built in Rust with ML/AI-powered decision making. The system uses microservices architecture with gRPC communication, PostgreSQL for persistence, and advanced ML models (MAMBA-2, DQN, PPO, TFT) for trading strategies.

Core Principle: REUSE existing infrastructure. DO NOT rebuild components.

---

🏗️ Architecture

Service Topology

┌─────────────────────────────────────────────────────────────┐
│                         TLI (Terminal)                       │
│                    Pure Client - Port 50051                  │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│                    API Gateway (Port 50051)                  │
│          Auth, Rate Limiting, Config Management              │
│    JWT, MFA, Session Management, Audit Logging              │
└───┬──────────────────┬──────────────────┬───────────────────┘
    │                  │                  │
    ▼                  ▼                  ▼
┌──────────┐    ┌──────────────┐    ┌────────────────┐
│ Trading  │    │ Backtesting  │    │  ML Training   │
│ Service  │    │   Service    │    │    Service     │
│Port 50052│    │  Port 50053  │    │  Port 50054    │
└─────┬────┘    └──────┬───────┘    └────────┬───────┘
      │                │                      │
      └────────────────┴──────────────────────┘
                       │
         ┌─────────────┴─────────────┐
         ▼                           ▼
┌──────────────┐            ┌────────────────┐
│  PostgreSQL  │            │     Redis      │
│ (TimescaleDB)│            │   (Cache)      │
│  Port 5432   │            │   Port 6379    │
└──────────────┘            └────────────────┘

Component Responsibilities

TLI (Terminal Line Interface):

• Pure client - NO server components
• Connects ONLY to API Gateway
• NO database/ML/risk dependencies
• User interface for trading operations

API Gateway:

• Single entry point for all clients
• Centralized authentication (JWT + MFA)
• Rate limiting and request routing
• Configuration hot-reload from PostgreSQL
• Audit logging for compliance

Trading Service:

• Core trading logic and execution
• Position management
• Risk management integration
• Real-time market data processing

Backtesting Service:

• Strategy testing with historical data
• Parquet-based market data replay
• Performance analytics (Sharpe, drawdown, PnL)
• Model versioning support

ML Training Service:

• Model training pipeline
• Feature engineering (technical indicators, microstructure, TLOB)
• Checkpoint management
• Distributed training coordination

---

📁 Codebase Structure

foxhunt/
├── common/              # Shared types, error handling, traits
├── config/              # Central configuration (ONLY crate with Vault access)
├── data/                # Market data providers, Parquet persistence
├── ml/                  # ML models: MAMBA-2, DQN, PPO, TFT, Liquid
├── risk/                # VaR, circuit breakers, compliance
├── storage/             # S3 integration for archival
├── trading_engine/      # Core HFT engine with lockfree queues
├── services/
│   ├── api_gateway/     # Auth + routing gateway
│   ├── trading_service/ # Trading business logic
│   ├── backtesting_service/
│   └── ml_training_service/
├── tli/                 # Terminal client
├── migrations/          # Database migrations (17 applied)
└── test_data/           # Test datasets (Parquet files)

---

🔑 Infrastructure & Credentials

Docker Services

Start all infrastructure:

docker-compose up -d
docker-compose ps  # Verify all services healthy

Database Credentials (from docker-compose.yml)

PostgreSQL (TimescaleDB):

Host: localhost:5432
Database: foxhunt
User: foxhunt
Password: foxhunt_dev_password
Connection URL: postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt

# Connect from CLI
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt

# Run migrations
cargo sqlx migrate run

Redis:

Host: localhost:6379
URL: redis://localhost:6379

# Test connection
redis-cli ping

InfluxDB (Time-series metrics):

Host: localhost:8086
User: foxhunt
Password: foxhunt_dev_password
Org: foxhunt
Bucket: trading_metrics

# Web UI: http://localhost:8086

HashiCorp Vault (Secrets):

Host: localhost:8200
Dev Token: foxhunt-dev-root
URL: http://vault:8200

# Access from services
export VAULT_ADDR=http://localhost:8200
export VAULT_TOKEN=foxhunt-dev-root

Grafana (Dashboards):

URL: http://localhost:3000
Username: admin
Password: foxhunt123

Prometheus (Metrics):

URL: http://localhost:9090

Service Ports

Service	External Port	Internal Port	Metrics Port
API Gateway	50051	50050	9091
Trading Service	50052	50051	9092
Backtesting Service	50053	50052	9093
ML Training Service	50054	50053	9094

Environment Variables

Development (from docker-compose.yml):

DATABASE_URL=postgresql://foxhunt:foxhunt_dev_password@postgres:5432/foxhunt
REDIS_URL=redis://redis:6379
VAULT_ADDR=http://vault:8200
VAULT_TOKEN=foxhunt-dev-root
JWT_SECRET=dev_secret_key_change_in_production
RUST_LOG=info
RUST_BACKTRACE=1

Production (use Vault for secrets):

# Load from .env (never commit this file!)
cp .env.example .env
# Edit .env with production credentials

---

🚫 Critical Architectural Rules

1. Configuration Management

• ONLY the config crate accesses Vault directly
• NO type aliases or backward compatibility layers
• Services import: use config::{ServiceConfig, ConfigManager};
• NEVER create foxhunt-config-crate or foxhunt-* prefixed crates

2. TLI Architecture

• TLI is a PURE CLIENT - NO server components
• NO WebSocketServer, NO HealthServer
• NO database/ML/risk dependencies
• Connects ONLY to API Gateway (port 50051)

3. Service Boundaries

• API Gateway: Server for TLI, client for backend services
• Trading Service: Monolithic business logic
• Backtesting/ML Services: Independent, specialized services
• All inter-service communication via gRPC

4. Error Handling Patterns

// CommonError factory methods (common/src/error.rs)
CommonError::config("message")           // Configuration errors
CommonError::network("message")          // Network errors
CommonError::service(ErrorCategory, "msg") // Service errors
CommonError::validation("message")       // Validation errors
CommonError::internal("message")         // Internal errors

// StorageError variants (storage/src/error.rs)
StorageError::ConfigError { message }    // Config errors
StorageError::IoError { message }        // I/O errors
StorageError::NetworkError { message }   // Network errors
// NO StorageError::Common variant!

5. Common Compilation Fixes

// Use ::std::core:: not core:: when local crate shadows std
use ::std::core::mem;

// Add async-stream when needed
async-stream = "0.3"

// NO direct vault access outside config crate
// ❌ use vault_service::...
// ✅ use config::ConfigManager;

---

🧪 Testing Infrastructure (REUSE)

See TESTING_PLAN.md for comprehensive testing strategy.

Existing Components

Parquet Market Data Replay:

// data/src/parquet_persistence.rs
let writer = ParquetMarketDataWriter::new(...);
writer.write_event(market_event).await?;

let reader = ParquetMarketDataReader::new(...);
let events = reader.read_file("test.parquet").await?;

Backtesting Service (gRPC):

let client = BacktestingServiceClient::connect("http://localhost:50053").await?;
let response = client.start_backtest(request).await?;

Feature Engineering:

// data/src/training_pipeline.rs
let processor = FeatureProcessor::new(config);
let features = processor.process_batch(&market_data).await?;

Test Database Setup

# 1. Start PostgreSQL
docker-compose up -d postgres

# 2. Run migrations
cargo sqlx migrate run

# 3. Verify schema
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt -c '\dt'

SQLx Offline Mode

For CI/CD without live database:

# Generate metadata
cargo sqlx prepare --workspace

# Enable offline mode
echo 'SQLX_OFFLINE=true' >> .cargo/config.toml

---

🛠️ Development Workflow

Initial Setup

# 1. Clone repository
git clone <repo-url>
cd foxhunt

# 2. Start infrastructure
docker-compose up -d

# 3. Wait for services to be healthy
docker-compose ps

# 4. Run database migrations
cargo sqlx migrate run

# 5. Build workspace
cargo build --workspace

# 6. Run tests
cargo test --workspace

Common Commands

# Build all services
cargo build --workspace --release

# Run specific service
cargo run -p trading_service

# Test specific package
cargo test -p ml

# Check compilation (fast)
cargo check --workspace

# Run linter
cargo clippy --workspace -- -D warnings

# Measure test coverage
cargo llvm-cov --html --output-dir coverage_report

# Clean build artifacts
cargo clean

Running Services

# Via Docker Compose (recommended)
docker-compose up -d api_gateway trading_service backtesting_service ml_training_service

# Via Cargo (development)
cargo run -p api_gateway &
cargo run -p trading_service &
cargo run -p backtesting_service &
cargo run -p ml_training_service &

---

📊 Current Status

Production Readiness: 90.5% (4.5% from deployment)

Complete (100%):

• ✅ Monitoring: Prometheus alerts, Grafana dashboards
• ✅ Documentation: 85K+ lines comprehensive docs
• ✅ Reliability: Circuit breakers, chaos testing
• ✅ Scalability: Horizontal scaling, load balancing
• ✅ Deployment: All 4 services compile + Docker validated

In Progress:

• 🟡 Testing: 51.0% coverage (common 26%, services timeout)
• 🟡 Compliance: 83% SOX/MiFID II (target: 100%)
• 🟡 Performance: 36% (auth validated, full cycle pending)
• 🟡 Security: CVSS 5.9 (1 mitigated vulnerability)

Recent Achievements

Wave 114 (10 agents):

• Service compilation: 96+ errors fixed → 0 errors (100% success)
• Common package coverage: 26.03% measured
• Trading engine tests: 26 errors fixed
• Production readiness: 90.0% → 90.5% (+0.5%)

Wave 113 (39 agents):

• Coverage unblocked: 29.8% → 47.03% (+17.23%)
• Security hardening: 67% vulnerability reduction
• Test suite: 1,532 tests validated (98.3% pass rate)
• Dependencies: 942 → 933 crates (-9)

Known Issues

1. Service Coverage Unmeasurable: Integration tests timeout (5+ min)

   • Solution: Unit test extraction OR CI infrastructure (Wave 115)

2. Test Failures: 26 tests (1.7%) reduce accuracy

   • data (5), ml (6), ml_training_service (2), trading_service (12)
   • Fix effort: 4-6 hours

3. SQLx Offline Mode: 11 compilation errors in api_gateway

   • Workaround: Enable SQLX_OFFLINE=true in .cargo/config.toml

---

🚀 Next Priorities (Wave 115)

Priority 1: ML Testing Infrastructure (1-2 weeks)

See TESTING_PLAN.md for details.

Goal: Validate ML models with realistic crypto data

1. Complete ParquetMarketDataReader (2-4 hours)
2. Implement BinanceCryptoClient for data collection (4-6 hours)
3. Generate test datasets (2-3 hours)
4. Write ML integration tests (8-12 hours)

Expected Impact: +15-20% coverage (51% → 70%)

Priority 2: Fix Test Failures (4-6 hours)

• 26 failing tests reduce coverage accuracy
• Quick wins with immediate impact
• Gain: 100% pass rate → +3-5% coverage

Priority 3: E2E Performance Benchmarks (1-2 days)

• Performance only 36% (auth validated, full cycle untested)
• Latency profiling, load testing
• Gain: +40% performance score (36% → 80%)

---

📖 Documentation

Architecture & Development

• CLAUDE.md: This file - architecture fundamentals
• TESTING_PLAN.md: ML testing strategy with crypto data
• .env.example: Environment variable template

Wave Reports (Latest)

• WAVE114_FINAL_REPORT.md: Service compilation fixes (Phase 2)
• WAVE113_FINAL_SUMMARY.md: Coverage unblocking & security
• WAVE112_FINAL_STATUS.md: Systematic compilation fix

Technical Documentation

• migrations/README.md: Database schema changes
• docs/: Detailed component documentation
• README.md: Project overview

---

🔒 Security Best Practices

Development

• ✅ All .env files gitignored
• ✅ No hardcoded credentials in source
• ✅ API keys from environment variables
• ✅ Docker secrets for production

Production

• Use Vault for all secrets (not environment variables)
• Enable MFA for critical operations
• Rotate JWT secrets regularly
• Use TLS for all gRPC communication
• Enable audit logging (ENABLE_AUDIT_LOGGING=true)

Current Vulnerabilities

• RSA Marvin Attack (CVSS 5.9): Mitigated (PostgreSQL-only, no MySQL)
• 2 unmaintained dependencies (low risk): instant, paste

---

🐛 Anti-Workaround Protocol

FORBIDDEN Approaches

❌ NEVER create stubs or placeholders ❌ NEVER create fallback/compatibility layers ❌ NEVER skip features to avoid fixing them ❌ NEVER estimate when you can measure

REQUIRED Approaches

✅ ALWAYS fix root causes ✅ ALWAYS proper rewrites, not simplifications ✅ ALWAYS complete implementations ✅ ALWAYS reuse existing infrastructure

Examples

Bad:

// ❌ Stub implementation
pub fn read_file(&self, filename: &str) -> Result<Vec<MarketDataEvent>> {
    warn!("Not implemented yet");
    Ok(Vec::new())
}

Good:

// ✅ Complete implementation
pub async fn read_file(&self, filename: &str) -> Result<Vec<MarketDataEvent>> {
    let file = tokio::fs::File::open(filepath).await?;
    let builder = ParquetRecordBatchReaderBuilder::try_new(file).await?;
    // ... full Arrow-based Parquet reading
}

---

📞 Quick Reference

Docker Services

docker-compose up -d         # Start all services
docker-compose ps            # Check status
docker-compose logs -f <service>  # View logs
docker-compose down          # Stop all services

Database Operations

# PostgreSQL
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt
cargo sqlx migrate run
cargo sqlx migrate revert

# Redis
redis-cli -h localhost -p 6379

Service Health Checks

# API Gateway
grpc_health_probe -addr=localhost:50051

# Trading Service
grpc_health_probe -addr=localhost:50052

# All services via Prometheus
curl http://localhost:9090/api/v1/targets

Coverage Measurement

# Workspace coverage
cargo llvm-cov --html --output-dir coverage_report

# Specific package
cargo llvm-cov -p ml --html --output-dir coverage_ml

# View report
open coverage_report/index.html

---

🎓 Learning Resources

Rust + Async

• Tokio Tutorial
• Async Book

gRPC + Tonic

• Tonic Documentation
• gRPC Health Checking

HFT + Trading

• Market microstructure theory
• Order book dynamics
• Latency optimization techniques

ML/AI

• MAMBA-2: State space models
• DQN: Deep Q-learning
• PPO: Proximal Policy Optimization
• TFT: Temporal Fusion Transformer

---

Last Updated: 2025-10-06 Production Status: 90.5% (4.5% from deployment) Next Milestone: Wave 115 - ML testing infrastructure + test failure fixes