Initial commit (clean, no build artifacts)

benches/fill_processing.rs

@@ -0,0 +1,194 @@
+//! Benchmark for fill processing
+//!
+//! This benchmark measures the performance of trade execution and
+//! fill processing operations.
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use polyfill_rs::{
+    book::OrderBook,
+    fill::{FillEngine, FillProcessor},
+    types::{FillEvent, MarketOrderRequest, OrderDelta, Side},
+};
+use rust_decimal::{Decimal, Decimal as RustDecimal};
+use rust_decimal_macros::dec;
+use std::time::Instant;
+
+fn bench_fill_engine_creation(c: &mut Criterion) {
+    c.bench_function("fill_engine_creation", |b| {
+        b.iter(|| {
+            let _engine = FillEngine::new(
+                black_box(dec!(1)),
+                black_box(dec!(5)),
+                black_box(10),
+            );
+        });
+    });
+}
+
+fn bench_market_order_execution(c: &mut Criterion) {
+    let mut engine = FillEngine::new(dec!(1), dec!(5), 10);
+    let mut book = OrderBook::new("test_token".to_string(), 100);
+    
+    // Pre-populate book with levels
+    for i in 1..=20 {
+        let price = Decimal::from(50 + i) / Decimal::from(100);
+        let delta = OrderDelta {
+            token_id: "test_token".to_string(),
+            timestamp: chrono::Utc::now(),
+            side: if i % 2 == 0 { Side::BUY } else { Side::SELL },
+            price,
+            size: dec!(100),
+            sequence: i,
+        };
+        book.apply_delta(delta).unwrap();
+    }
+
+    c.bench_function("market_order_execution", |b| {
+        b.iter(|| {
+            let request = MarketOrderRequest {
+                token_id: "test_token".to_string(),
+                side: black_box(Side::BUY),
+                amount: black_box(dec!(50)),
+                slippage_tolerance: Some(dec!(1.0)),
+                client_id: Some("bench_order".to_string()),
+            };
+            
+            let _result = engine.execute_market_order(&request, &book);
+        });
+    });
+}
+
+fn bench_fill_processor(c: &mut Criterion) {
+    let mut processor = FillProcessor::new(1000);
+    
+    c.bench_function("fill_processor", |b| {
+        b.iter(|| {
+            let fill = FillEvent {
+                id: "fill_1".to_string(),
+                order_id: "order_1".to_string(),
+                token_id: "test_token".to_string(),
+                side: black_box(Side::BUY),
+                price: black_box(dec!(0.5)),
+                size: black_box(dec!(100)),
+                timestamp: chrono::Utc::now(),
+                maker_address: alloy_primitives::Address::ZERO,
+                taker_address: alloy_primitives::Address::ZERO,
+                fee: black_box(dec!(0.1)),
+            };
+            
+            processor.process_fill(fill).unwrap();
+        });
+    });
+}
+
+fn bench_market_impact_calculation(c: &mut Criterion) {
+    let mut book = OrderBook::new("test_token".to_string(), 100);
+    
+    // Pre-populate with realistic order book
+    for i in 1..=30 {
+        let price = Decimal::from(50 + i) / Decimal::from(100);
+        let size = Decimal::from(100 + i * 10);
+        let delta = OrderDelta {
+            token_id: "test_token".to_string(),
+            timestamp: chrono::Utc::now(),
+            side: if i % 2 == 0 { Side::BUY } else { Side::SELL },
+            price,
+            size,
+            sequence: i,
+        };
+        book.apply_delta(delta).unwrap();
+    }
+
+    c.bench_function("market_impact_calculation", |b| {
+        b.iter(|| {
+            let _impact = book.calculate_market_impact(Side::BUY, dec!(50));
+            let _impact = book.calculate_market_impact(Side::SELL, dec!(50));
+        });
+    });
+}
+
+fn bench_high_frequency_fills(c: &mut Criterion) {
+    c.bench_function("high_frequency_fills", |b| {
+        b.iter(|| {
+            let mut engine = FillEngine::new(dec!(1), dec!(2), 5);
+            let mut book = OrderBook::new("test_token".to_string(), 100);
+            let start_time = Instant::now();
+            
+            // Simulate high-frequency fill processing
+            for i in 1..=100 {
+                // Add some market depth
+                let price = Decimal::from(500 + (i % 10)) / Decimal::from(1000);
+                let size = Decimal::from(10 + (i % 90));
+                let delta = OrderDelta {
+                    token_id: "test_token".to_string(),
+                    timestamp: chrono::Utc::now(),
+                    side: if i % 2 == 0 { Side::BUY } else { Side::SELL },
+                    price,
+                    size,
+                    sequence: i,
+                };
+                book.apply_delta(delta).unwrap();
+                
+                // Execute market orders
+                if i % 5 == 0 {
+                    let request = MarketOrderRequest {
+                        token_id: "test_token".to_string(),
+                        side: if i % 2 == 0 { Side::BUY } else { Side::SELL },
+                        amount: dec!(10),
+                        slippage_tolerance: Some(dec!(1.0)),
+                        client_id: Some(format!("order_{}", i)),
+                    };
+                    
+                    let _result = engine.execute_market_order(&request, &book);
+                }
+            }
+            
+            let duration = start_time.elapsed();
+            black_box(duration);
+        });
+    });
+}
+
+fn bench_fill_statistics(c: &mut Criterion) {
+    let mut engine = FillEngine::new(dec!(1), dec!(5), 10);
+    
+    // Add some fills
+    for i in 1..=100 {
+        let request = MarketOrderRequest {
+            token_id: "test_token".to_string(),
+            side: if i % 2 == 0 { Side::BUY } else { Side::SELL },
+            amount: dec!(10),
+            slippage_tolerance: Some(dec!(1.0)),
+            client_id: Some(format!("order_{}", i)),
+        };
+        
+        let mut book = OrderBook::new("test_token".to_string(), 100);
+        book.apply_delta(OrderDelta {
+            token_id: "test_token".to_string(),
+            timestamp: chrono::Utc::now(),
+            side: request.side.opposite(),
+            price: dec!(0.5),
+            size: dec!(100),
+            sequence: i,
+        }).unwrap();
+        
+        let _result = engine.execute_market_order(&request, &book);
+    }
+
+    c.bench_function("fill_statistics", |b| {
+        b.iter(|| {
+            let _stats = engine.get_stats();
+        });
+    });
+}
+
+criterion_group!(
+    benches,
+    bench_fill_engine_creation,
+    bench_market_order_execution,
+    bench_fill_processor,
+    bench_market_impact_calculation,
+    bench_high_frequency_fills,
+    bench_fill_statistics,
+);
+criterion_main!(benches);