v0.3.0 - Options Market Making & Multi-Asset Support

Release v0.3.0

🎉 Major Release: Options Market Making & Multi-Asset Support

This release introduces comprehensive options market making capabilities, multi-underlying asset management, and a complete event broadcasting system.

---

✨ New Features

Options Market Making (Feature: options)

• Greeks Calculation: Delta, gamma, theta, vega, rho via OptionStratLib integration
• Portfolio Greeks: Aggregation across multiple positions
• Greeks-Aware Quoting: Spread adjustment based on gamma exposure
• Delta Hedging: Automatic hedge order generation
• Risk Management: Greeks-based limits and circuit breakers
• Auto-Hedging: Configurable triggers for delta neutralization

Option Chain Integration (Feature: chain)

• Multi-Strike Quoting: Quote all strikes in an expiration
• Chain-Level Risk: Aggregate Greeks across the chain
• ATM Detection: Automatic spread adjustment for ATM options
• Chain Risk Manager: Chain-wide limits and hedging

Greeks-Based Risk Management (Feature: options)

• GreeksLimits: Configurable limits for delta, gamma, vega, theta
• GreeksRiskManager: Real-time Greeks tracking with order validation
• Auto-Hedging: Automatic delta neutralization when limits approach
• Greeks Circuit Breakers: Halt quoting on limit breach
• Order Scaling: Automatic size reduction when approaching limits

Real-Time Data Feeds (Feature: data-feeds)

• MarketDataFeed Trait: Abstract interface for data providers
• Price Updates: Real-time underlying price streaming
• Trade Feed: Trade events for order flow analysis
• IV Surface: Implied volatility surface updates
• Mock Feed: Testing without real connectivity

REST/WebSocket API Layer (Feature: api)

• REST Endpoints: Status, configuration, quotes, positions, Greeks, P&L
• OpenAPI Documentation: Auto-generated API docs with utoipa
• CORS Support: Configurable cross-origin resource sharing
• State Management: Thread-safe shared state for the market maker

Persistence Layer (Feature: persistence)

• Fill Records: Trade executions with price, quantity, fees
• Position Snapshots: Point-in-time position state
• Daily P&L: Aggregated daily profit/loss records
• Configuration: Persistent settings storage
• Event Logs: System events and alerts
• In-Memory Implementation: For testing and development

Multi-Underlying Support (Feature: multi-underlying)

• MultiUnderlyingManager: Coordinate market making across multiple assets
• Cross-Asset Correlation: Track correlations between underlyings
• Capital Allocation Strategies: Equal, TargetWeight, RiskParity, VolatilityWeighted, PerformanceBased
• Unified Risk View: Aggregate Greeks and P&L across all positions
• Per-Underlying Limits: Individual risk limits per asset
• Cross-Asset Hedging: Suggestions for hedging across correlated assets

Event System (Feature: events)

• MarketMakerEvent: 13 event types (quotes, fills, cancels, greeks, positions, pnl, alerts, circuit breaker, config, price updates, hedges, status, heartbeat)
• EventBroadcaster: Tokio broadcast channel for event distribution
• Event History: Buffer for reconnection support
• Event Filtering: Filter by type, symbol, or alert level
• FilteredEventReceiver: Filtered subscriptions
• EventAggregator: Batching for high-frequency events
• Heartbeat: Connection keep-alive mechanism

---

📦 New Dependencies

Dependency	Feature	Purpose
optionstratlib	options	Options pricing and Greeks
chrono	options	Date/time handling
option-chain-orderbook	chain	Option chain management
axum	api	HTTP server framework
utoipa	api	OpenAPI documentation
tower-http	api	HTTP middleware (CORS)

---

🚀 Feature Flags

[dependencies]
market-maker-rs = { version = "0.3", features = ["options", "chain", "api", "persistence", "multi-underlying", "events", "data-feeds"] }

Feature	Description
serde	Serialization/deserialization for all types
prometheus	Prometheus metrics export
options	OptionStratLib integration for options pricing
chain	Option chain integration (includes options)
data-feeds	Real-time market data feed abstractions
api	REST/WebSocket API layer with OpenAPI docs
persistence	Data persistence layer
multi-underlying	Multi-asset management with correlation tracking
events	Event broadcasting system for real-time updates

---

📚 New Examples

• options_greeks.rs - Greeks calculation and portfolio aggregation
• options_market_making.rs - Options-specific market making
• options_risk_management.rs - Greeks-based risk management
• chain_market_making.rs - Multi-strike option chain quoting
• multi_underlying.rs - Multi-asset management demo
• event_system.rs - Event broadcasting and filtering

---

📖 Documentation

• Updated lib.rs with comprehensive feature documentation
• Added usage examples for all new features
• Updated module documentation with API examples

---

🔗 Related Issues

• #49: Greeks-Based Risk Management ✅
• #50: Real-Time Data Feeds ✅
• #51: REST/WebSocket API Layer ✅
• #52: Persistence Layer ✅
• #53: Multi-Underlying Support ✅
• #54: Event System ✅

---

⬆️ Upgrade Guide

This release is backward compatible. Existing code using v0.2.x will continue to work. To use new features, enable the corresponding feature flags in your Cargo.toml.

Full Changelog: v0.2.0...v0.3.0

v0.2.0 - Major Feature Release

Market Maker RS v0.2.0

🚀 Major Feature Release

This release introduces comprehensive new features for professional market making, including advanced analytics, backtesting capabilities, execution infrastructure, and enhanced risk management.

---

✨ New Features

Strategy Module

• GLFT Model Extension: Guéant-Lehalle-Fernandez-Tapia model with terminal inventory penalties and dynamic gamma adjustment
• Grid Trading Strategy: Multi-level order placement with arithmetic/geometric spacing
• Adaptive Spread: Order book imbalance-based spread adjustment
• Parameter Calibration: Tools for risk aversion (γ) and order intensity (k) calibration, volatility regime detection

Analytics Module

• Order Flow Analysis: Real-time trade flow tracking with buy/sell imbalance metrics
• VPIN Calculator: Volume-synchronized probability of informed trading for toxicity detection
• Order Intensity Estimation: Dynamic fill rate estimation from historical observations
• Live Metrics: Thread-safe operational metrics tracking (quotes, fills, PnL)
• Prometheus Export: Full metrics export in Prometheus format for monitoring integration

Backtesting Module

• Backtesting Engine: Event-driven tick-by-tick simulation framework
• Fill Models: Realistic fill simulation with multiple slippage models (fixed, percentage, volatility-based)
• Performance Metrics: Sharpe ratio, max drawdown, PnL analysis

Execution Module

• Exchange Connector Trait: Async trait for exchange integration with mock implementation
• Order Management System (OMS): Complete order lifecycle management
• Latency Tracking: Execution latency metrics and monitoring

Risk Module

• Position Limits: Maximum position and notional exposure controls with order scaling
• Circuit Breakers: Automatic trading halts on adverse conditions (loss limits, consecutive losses, drawdown)
• Drawdown Tracker: Peak equity tracking and drawdown limit monitoring
• Alert System: Configurable alerts with severity levels and custom handlers
• Portfolio Risk: Correlation matrix, portfolio variance/VaR, cross-asset hedging calculations

---

📚 Documentation & Examples

• Comprehensive crate-level documentation update covering all 20 implemented features
• New examples: risk_limits, circuit_breaker, drawdown_tracker, alert_system, glft_model
• Improved test coverage for alerts, backtest engine, and decimal modules

---

🔧 Improvements

• Updated dependencies (tokio v1.47)
• Fixed clippy warnings and improved code quality
• Better error handling and validation throughout

---

📦 Installation

[dependencies]
market-maker-rs = "0.2.0"

---

Full Changelog: v0.1.3...v0.2.0

v0.1.3

Release Notes - v0.1.3

Release Date: October 14, 2025
Status: Stable
Breaking Changes: No

---

🎯 Overview

Version 0.1.3 introduces a depth-based market making strategy with integration to the orderbook-rs crate, providing a new approach to liquidity provision based on order book depth analysis.

This release focuses on order book-aware strategies, inventory risk management, and practical trading tools with comprehensive examples and documentation.

---

🚀 Major Features

1. ✨ Depth-Based Offering Strategy

New Module: strategy::depth_based

Complete implementation of a depth-based market making strategy that places orders at specific depth levels in the order book.

Strategy Overview

The DepthBasedOffering strategy:

• Places orders at a target cumulative depth in the order book
• Adjusts order sizes based on current inventory position
• Manages inventory risk through position-based sizing
• Optimizes for execution probability at key liquidity levels

Core API

pub struct DepthBasedOffering {
    max_exposure: Amount,
    target_depth: Amount,
}

impl DepthBasedOffering {
    pub fn new(max_exposure: Amount, target_depth: Amount) -> Self;
    pub fn calculate_ask_size(&self, inventory_position: Decimal) -> Amount;
    pub fn calculate_bid_size(&self, inventory_position: Decimal) -> Amount;
    pub fn price_adjustment(
        &self,
        cumulative_depth_at_level: Amount,
        tick_size: Decimal,
        is_ask: bool,
    ) -> Decimal;
}

Example Usage

use market_maker_rs::strategy::depth_based::DepthBasedOffering;
use market_maker_rs::dec;

// Create strategy with 100 units max exposure at 50 units depth
let strategy = DepthBasedOffering::new(dec!(100.0), dec!(50.0));

// Calculate order sizes based on inventory
let inventory = dec!(20.0); // Long 20 units
let ask_size = strategy.calculate_ask_size(inventory); // 120.0 (sell more)
let bid_size = strategy.calculate_bid_size(inventory); // 80.0 (buy less)

// Price adjustment based on depth
let adjustment = strategy.price_adjustment(
    dec!(50.0),   // cumulative_depth
    dec!(0.01),   // tick_size
    true,         // is_ask
); // -0.01 (one tick inside)

Key Features

• ✅ Inventory-aware sizing - Automatically adjusts order sizes to manage risk
• ✅ Depth-based pricing - Places orders at meaningful liquidity levels
• ✅ Symmetric exposure - Maintains balanced risk profile
• ✅ Tick-aware adjustments - Respects minimum price increments
• ✅ Comprehensive tests - 10 unit tests covering all scenarios

2. 📦 Order Book Integration

New Dependency: orderbook-rs = "0.4"

Integration with the orderbook-rs crate for professional-grade order book management.

Benefits

• Professional order book implementation
• Efficient price level management
• Snapshot capabilities for analysis
• Industry-standard API

Integration Example

use orderbook_rs::prelude::*;
use market_maker_rs::strategy::depth_based::DepthBasedOffering;

let orderbook: OrderBook<OrderId> = OrderBook::new("BTC/USD");
let strategy = DepthBasedOffering::new(dec!(100.0), dec!(50.0));

// Analyze order book and apply strategy
let snapshot = orderbook.create_snapshot(10);
// ... depth analysis and order placement

---

📚 Examples

New Examples Added

Example	Description	Lines	Focus
depth_based_strategy.rs	Complete depth-based strategy demonstration	410	Strategy concepts, inventory management
depth_based_with_orderbook.rs	Integration with orderbook-rs	260	Real order book integration

Example Highlights

depth_based_strategy.rs demonstrates:

• Strategy configuration and initialization
• 4 inventory scenarios (flat, long, short, extreme)
• Price adjustment based on depth analysis
• Complete trading session simulation
• Order sizing calculations
• Integration workflow

depth_based_with_orderbook.rs shows:

• OrderBook creation from orderbook-rs
• Order book depth analysis
• Cumulative depth calculation
• Strategy application with real data
• Price placement recommendations
• Production integration patterns

Total Examples: 14 (was: 12)

Run Examples:

cargo run --example depth_based_strategy
cargo run --example depth_based_with_orderbook

---

🧪 Testing & Quality

Test Coverage

Total Tests: 101 (was: 91)
Coverage: ~95% (maintained)
New Tests: +10

New Test Categories

Depth-Based Strategy Tests (10)

• Strategy creation and configuration
• Ask size calculation (flat, long, short inventory)
• Bid size calculation (flat, long, short inventory)
• Price adjustment for asks and bids
• Symmetric sizing verification

Test Results

✅ make test - 101/101 tests passing
✅ make lint-fix - All linting issues resolved
✅ make pre-push - ALL CHECKS PASSED
✅ cargo clippy -- -W missing-docs - No warnings

---

📖 Documentation

Enhanced Documentation

1. Depth-Based Strategy Module

   • Complete API documentation
   • Usage examples in docstrings
   • Strategy logic explanation
   • Integration patterns

2. Example Documentation

   • Comprehensive comments
   • Step-by-step explanations
   • Output descriptions
   • Production integration notes

Documentation Coverage: 100%

All public APIs fully documented with examples.

---

🔧 Dependencies

New Dependencies

[dependencies]
orderbook-rs = "0.4"    # Professional order book implementation

Dependency Justification

• orderbook-rs: Industry-standard order book management with efficient data structures and snapshot capabilities

---

⚡ Performance

Benchmarks

Operation	Time (µs)	Notes
Calculate ask size	~0.1	Simple arithmetic
Calculate bid size	~0.1	Simple arithmetic
Price adjustment	~0.1	Conditional logic only
Full strategy evaluation	~1	Including depth analysis

Note: Strategy calculations are extremely lightweight (sub-microsecond). Most latency comes from order book analysis.

---

🎯 Strategy Logic

Inventory Management

The depth-based strategy implements sophisticated inventory management:

Ask Size Formula:

ask_size = max_exposure + inventory_position

Bid Size Formula:

bid_size = max_exposure - inventory_position

Behavior Examples

Inventory	Ask Size	Bid Size	Effect
0 (flat)	100	100	Balanced
+30 (long)	130	70	Sell more, buy less
-30 (short)	70	130	Sell less, buy more
+80 (extreme long)	180	20	Strong sell bias

Price Placement

The strategy places orders based on cumulative depth:

1. Analyze order book - Calculate cumulative depth at each level
2. Find target level - Identify where target depth is reached
3. Adjust price - Place order one tick inside for execution priority

Price Adjustment Logic:

if cumulative_depth >= target_depth {
    if is_ask {
        -tick_size  // Place one tick lower (more competitive)
    } else {
        +tick_size  // Place one tick higher (more competitive)
    }
} else {
    0  // No adjustment needed
}

---

📊 Statistics

Metric	Value	Change
Lines of Code	~3,900	+400
Tests	101	+10
Test Coverage	~95%	(maintained)
Examples	14	+2
Modules	8	+1
Dependencies	8	+1

---

🎨 Code Quality

Improvements

• ✅ All new code follows project conventions
• ✅ Complete documentation coverage
• ✅ Comprehensive error handling
• ✅ Clean separation of concerns
• ✅ Type-safe API design
• ✅ Zero clippy warnings

Best Practices

• Type aliases for Price and Amount
• #[must_use] on calculation methods
• Detailed docstring examples
• Clear reasoning in comments
• Symmetric sizing verification

---

🔮 What's Next (v0.1.4+)

Potential Enhancements

• Additional order book analysis methods
• Multi-level depth strategies
• Dynamic depth targets based on volatility
• Order book imbalance indicators
• VWAP calculation utilities
• Market impact estimation

Integration Opportunities

• Real-time order book feeds
• Exchange API connectors
• Backtesting framework
• Performance monitoring
• Risk limits and controls

---

📝 Full Changelog

Added

• ✨ DepthBasedOffering strategy implementation
• ✨ Integration with orderbook-rs crate
• ✨ depth_based_strategy.rs example (410 lines)
• ✨ depth_based_with_orderbook.rs example (260 lines)
• ✨ 10 comprehensive unit tests
• ✨ Complete documentation for new module
• ✨ Price and Amount type aliases

Changed

• 📝 Updated Cargo.toml to include orderbook-rs
• 📝 Enhanced project structure with new strategy
• 📝 Improved example organization

Fixed

• None (new feature addition)

Performance

• ⚡ Sub-microsecond strategy calculations
• ⚡ Minimal memory allocation
• ⚡ Efficient depth analysis

---

💡 Use Cases

The depth-based strategy is ideal for:

Market Making

• Liquidity provision at meaningful depth levels
• Inventory management with automatic position reduction
• Queue position optimization with tick-aware pricing

Trading Strategies

• Depth-based entries for better execution
• Adaptive sizing based on position risk
• Order book analysis for market conditions

Risk Management

• Automatic exposure limits through max_exposure
  ...

v0.1.2

Release Notes - v0.1.2

Release Date: October 14, 2025
Status: Stable
Breaking Changes: Yes - Migration to Decimal types

---

🎯 Overview

Version 0.1.2 represents a major milestone in the market-maker-rs project, introducing arbitrary-precision decimal arithmetic, a complete volatility estimation toolkit, and comprehensive trait-based interfaces for both synchronous and asynchronous operations.

This release focuses on production-grade precision, extensibility, and developer experience with extensive documentation and examples.

---

🚀 Major Features

1. ✨ Decimal Arithmetic Migration

Breaking Change: All price and financial calculations now use rust_decimal::Decimal instead of f64.

Why This Matters

Floating-point arithmetic introduces rounding errors that accumulate in financial calculations:

// ❌ Before (v0.1.1): Floating point errors
let total = 0.1_f64 + 0.2_f64;  // 0.30000000000000004

// ✅ After (v0.1.2): Exact precision
let total = dec!(0.1) + dec!(0.2);  // 0.3 (exactly)

Changes

Affected Types:

• MarketState - mid_price, volatility
• Quote - bid_price, ask_price, bid_size, ask_size
• StrategyConfig - risk_aversion, order_intensity, min_spread
• InventoryPosition - quantity, avg_entry_price
• PnL - realized, unrealized, total

All Functions Updated:

• calculate_optimal_quotes() - Now returns (Decimal, Decimal)
• calculate_reservation_price() - Returns Decimal
• calculate_optimal_spread() - Returns Decimal

Migration Guide:

// v0.1.1 (old)
let quotes = calculate_optimal_quotes(
    100.0_f64,
    0.0_f64,
    0.1_f64,
    0.2_f64,
    3600000,
    1.5_f64,
)?;

// v0.1.2 (new)
use market_maker_rs::dec;
let quotes = calculate_optimal_quotes(
    dec!(100.0),
    dec!(0.0),
    dec!(0.1),
    dec!(0.2),
    3600000,
    dec!(1.5),
)?;

Math Helpers Added:

// New decimal math functions in types::decimal
pub fn decimal_ln(value: Decimal) -> MMResult<Decimal>;
pub fn decimal_powi(value: Decimal, exponent: i32) -> MMResult<Decimal>;
pub fn decimal_sqrt(value: Decimal) -> MMResult<Decimal>;

2. 📊 Volatility Estimator Implementation

New Module: market_state::volatility

Complete implementation of VolatilityEstimator with three calculation methods:

Methods

1. Simple Historical Volatility

let estimator = VolatilityEstimator::new();
let vol = estimator.calculate_simple(&prices)?;

• Standard deviation of log returns
• Annualized by default (252 trading days)
• Best for stable markets

2. EWMA (Exponentially Weighted Moving Average)

let vol = estimator.calculate_ewma(&prices, dec!(0.94))?;

• More weight to recent observations
• λ = 0.94 (RiskMetrics standard for daily data)
• Responsive to regime changes

3. Parkinson's Range-Based Estimator

let vol = estimator.calculate_parkinson(&highs, &lows)?;

• Uses high-low price range
• ~30% more statistically efficient
• Requires OHLC data

Features

• ✅ Configurable annualization factor
• ✅ Comprehensive error handling
• ✅ 11 unit tests
• ✅ Full documentation with examples

3. 🎨 Trait-Based Strategy Interface

New Module: strategy::interface

Extensible trait system for implementing custom strategies:

Synchronous Trait

pub trait AvellanedaStoikov {
    fn calculate_reservation_price(...) -> MMResult<Decimal>;
    fn calculate_optimal_spread(...) -> MMResult<Decimal>;
    fn calculate_optimal_quotes(...) -> MMResult<(Decimal, Decimal)>;
}

Asynchronous Trait

#[async_trait]
pub trait AsyncAvellanedaStoikov {
    async fn calculate_reservation_price(...) -> MMResult<Decimal>;
    async fn calculate_optimal_spread(...) -> MMResult<Decimal>;
    async fn calculate_optimal_quotes(...) -> MMResult<(Decimal, Decimal)>;
}

Default Implementation

pub struct DefaultAvellanedaStoikov;

// Implements both AvellanedaStoikov and AsyncAvellanedaStoikov

Use Cases:

• Custom spread adjustments
• Integration with external data sources
• Real-time parameter adaptation
• Strategy composition

---

📚 Examples

New Examples Added

Example	Description	Lines
trait_sync_example.rs	Custom synchronous strategy implementation	210
trait_async_example.rs	Async strategy with parallel execution	230
volatility_estimation.rs	Compare volatility methods	200

Total Examples: 12

All examples migrated to Decimal and fully documented.

Run Examples:

cargo run --example basic_quoting
cargo run --example trait_sync_example
cargo run --example trait_async_example
cargo run --example volatility_estimation

---

🧪 Testing & Quality

Test Coverage

Total Tests: 91 (was: 65)
Coverage: ~95% (was: ~86%)
New Tests: +26

New Test Categories

1. Decimal Math Tests (6)

   • Conversion error handling
   • Edge cases for ln, powi, sqrt
   • Precision validation

2. Volatility Estimator Tests (11)

   • All three calculation methods
   • Error conditions
   • Edge cases (empty data, invalid prices)

3. Interface Trait Tests (4)

   • Sync and async implementations
   • Individual method coverage
   • Default implementation validation

4. Integration Tests (5)

   • End-to-end workflows
   • Strategy composition
   • Error propagation

Quality Assurance

✅ make lint - PASSED
✅ make test - 91/91 tests passing
✅ make pre-push - ALL CHECKS PASSED
✅ cargo clippy - No warnings
✅ cargo fmt - Formatted

---

📖 Documentation

New Documentation

1. User Guide (doc/USER_GUIDE.md)

   • 679 lines of comprehensive documentation
   • Getting started guide
   • API reference
   • Architecture overview
   • Performance benchmarks
   • FAQ section

2. Enhanced API Docs

   • All public items documented
   • Code examples in docstrings
   • Error documentation
   • Usage patterns

3. README Updates

   • Quick start guide
   • Feature highlights
   • Example links

Documentation Coverage: 100%

---

🔧 Dependencies

New Dependencies

[dependencies]
rust_decimal = "1.36"           # Arbitrary-precision decimals
rust_decimal_macros = "1.36"    # dec!() macro
async-trait = "0.1"             # Async trait support

[dev-dependencies]
tokio = { version = "1.0", features = ["macros", "rt", "time", "rt-multi-thread"] }

Updated Dependencies

• thiserror → 2.0 (was: 1.0)

---

⚡ Performance

Benchmarks

Operation	Time (µs)	Throughput (ops/sec)
Calculate quotes	25	~40,000
Calculate reservation price	10	~100,000
Calculate spread	15	~66,000
Simple volatility (20 prices)	50	~20,000
EWMA volatility (100 prices)	200	~5,000

Note: Decimal arithmetic adds ~10-15% overhead vs f64, but provides exact precision.

---

🐛 Bug Fixes

1. Floating-point precision errors eliminated throughout codebase
2. Clippy warnings resolved (single_match pattern)
3. Edge case handling improved in all calculations
4. Error messages made more descriptive

---

💥 Breaking Changes

API Changes

1. All numeric types changed to Decimal

Before:

pub struct Quote {
    pub bid_price: f64,
    pub ask_price: f64,
    // ...
}

After:

pub struct Quote {
    pub bid_price: Decimal,
    pub ask_price: Decimal,
    // ...
}

2. Function signatures updated

Before:

pub fn calculate_optimal_quotes(
    mid_price: f64,
    inventory: f64,
    // ...
) -> MMResult<(f64, f64)>

After:

pub fn calculate_optimal_quotes(
    mid_price: Decimal,
    inventory: Decimal,
    // ...
) -> MMResult<(Decimal, Decimal)>

Migration Checklist

• ✅ Replace all f64 with Decimal or use dec!() macro
• ✅ Add use market_maker_rs::dec; to imports
• ✅ Update constants: 0.0 → Decimal::ZERO, 1.0 → Decimal::ONE
• ✅ Replace arithmetic: /2.0 → /Decimal::from(2)
• ✅ Update comparisons to use Decimal types

---

🎯 Highlights by Category

Developer Experience

• ✅ Comprehensive examples (12 total)
• ✅ Full documentation with usage patterns
• ✅ Clear error messages
• ✅ Type-safe API

Extensibility

• ✅ Trait-based interfaces
• ✅ Async support
• ✅ Custom strategy patterns
• ✅ Pluggable volatility estimators

Reliability

• ✅ 95% test coverage
• ✅ Exact decimal arithmetic
• ✅ Comprehensive error handling
• ✅ Input validation

Performance

• ✅ Zero-cost abstractions
• ✅ Efficient algorithms
• ✅ Minimal allocations
• ✅ Microsecond latency

---

📊 Statistics

Metric	Value	Change
Lines of Code	~3,500	+1,200
Tests	91	+26
Test Coverage	~95%	+9%
Examples	12	+3
Documentation	679 lines	New
Dependencies	7	+3

---

🚧 Known Limitations

1. Decimal Performance: ~10-15% slower than f64 for math operations
2. Async Runtime: Requires tokio for async examples
3. Precision Limits: Decimal has 28-29 significant digits (sufficient for finance)

---

🔮 What's Next (v0.1.3+)

Planned Features

• GARCH volatility models
• Garman-Klass volatility estimator
• Multi-asset strategies
• Historical backtesting framework
• WebSocket integration examples
• Risk limits and circuit breakers

Under Consideration

• Machine learning ...