Market Maker RS

https://docs.rs/market_maker_rs/0.3.0
Admin
Market Maker RS is a comprehensive Rust library implementing quantitative market making strategies...
Tokens:3,335
Snippets:30
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Configure and Run Backtest

Source: https://docs.rs/market_maker_rs

Set up a backtest simulation with initial capital, fee rates, and slippage models. Then, run the backtest engine with a strategy and data source to get performance metrics.

```rust
use market_maker_rs::prelude::*;

// Configure backtest
let config = BacktestConfig::default()
    .with_initial_capital(dec!(100000.0))
    .with_fee_rate(dec!(0.001))
    .with_slippage(SlippageModel::Fixed(dec!(0.01)));

// Run backtest with your strategy
let mut engine = BacktestEngine::new(config, strategy, data_source);
let result = engine.run();

println!("Net PnL: {}", result.net_pnl);
println!("Sharpe Ratio: {:?}", result.sharpe_ratio);
println!("Max Drawdown: {}", result.max_drawdown);
```

--------------------------------

### Set Up and Check Position Limits

Source: https://docs.rs/market_maker_rs

Configure risk limits for position size and notional value. Use `check_order` to determine if a proposed order complies with these limits.

```rust
use market_maker_rs::prelude::*;

// Set up position limits
let limits = RiskLimits::new(
    dec!(100.0),   // max 100 units position
    dec!(10000.0), // max $10,000 notional
    dec!(0.5),     // 50% scaling factor
).unwrap();

// Check if order is allowed
let allowed = limits.check_order(dec!(50.0), dec!(10.0), dec!(100.0)).unwrap();
```

--------------------------------

### Create and Use Options Market Maker

Source: https://docs.rs/market_maker_rs

Instantiate an OptionsMarketMaker for Greeks-aware quoting and calculate adjusted quotes or delta hedge suggestions. Requires the `options` feature.

```rust
use market_maker_rs::options::{
    OptionsMarketMaker,
    OptionsMarketMakerImpl,
    OptionsMarketMakerConfig,
    GreeksLimits,
    PortfolioGreeks,
};

// Create market maker with Greeks-aware quoting
let config = OptionsMarketMakerConfig::default();
let market_maker = OptionsMarketMakerImpl::new(config);

// Calculate Greeks-adjusted quotes
let (bid, ask) = market_maker.calculate_greeks_adjusted_quotes(
    &option,
    &portfolio_greeks,
    &risk_limits,
).unwrap();

// Get delta hedge suggestions
let hedges = market_maker.calculate_delta_hedge(
    &portfolio_greeks,
    underlying_price,
    "BTC",
).unwrap();
```

--------------------------------

### Implement Event Broadcasting and Subscription

Source: https://docs.rs/market_maker_rs

Set up an EventBroadcaster for distributing market maker events. Subscribe to all events or specific filtered events, broadcast new events, and retrieve historical events for reconnection. Requires the `events` feature.

```rust
use market_maker_rs::events::{
    EventBroadcaster,
    EventBroadcasterConfig,
    EventFilter,
    EventType,
    MarketMakerEvent,
    Side,
};
use std::sync::Arc;

// Create broadcaster
let config = EventBroadcasterConfig::default();
let broadcaster = Arc::new(EventBroadcaster::new(config));

// Subscribe to all events
let mut all_rx = broadcaster.subscribe();

// Subscribe with filter (fills only)
let filter = EventFilter::new()
    .with_event_types([EventType::OrderFilled])
    .with_symbols(["BTC".to_string()]);
let mut filtered_rx = broadcaster.subscribe_filtered(filter);

// Broadcast an event
broadcaster.broadcast(MarketMakerEvent::OrderFilled {
    order_id: "ORD-001".to_string(),
    symbol: "BTC".to_string(),
    instrument: "BTC-PERP".to_string(),
    side: Side::Buy,
    quantity: 10,
    price: 50000,
    fee: 5,
    edge: 100,
    timestamp: 1234567890,
}).await;

// Get history for reconnection
let missed = broadcaster.get_reconnection_history(last_sequence).await;
```

--------------------------------

### Create Correlation Matrix and Calculate Portfolio Risk

Source: https://docs.rs/market_maker_rs

Build a correlation matrix for multiple assets and set individual asset positions. Use the `PortfolioRiskCalculator` to compute portfolio volatility.

```rust
use market_maker_rs::risk::portfolio::*;
use market_maker_rs::dec;

// Create correlation matrix
let btc = AssetId::new("BTC");
let eth = AssetId::new("ETH");
let mut matrix = CorrelationMatrix::new(vec![btc.clone(), eth.clone()]);
matrix.set_correlation(&btc, &eth, dec!(0.8)).unwrap();

// Calculate portfolio risk
let mut portfolio = PortfolioPosition::new();
portfolio.set_position(btc, dec!(1.0), dec!(0.05));
portfolio.set_position(eth, dec!(10.0), dec!(0.08));

let calculator = PortfolioRiskCalculator::new(matrix);
let vol = calculator.portfolio_volatility(&portfolio).unwrap();
```

--------------------------------

### Implement Option Chain Market Making

Source: https://docs.rs/market_maker_rs

Set up a ChainMarketMaker to manage quotes across an entire option chain. Use `refresh_all_quotes` to update prices and `check_chain_risk` to monitor overall risk exposure. Requires the `chain` feature.

```rust
use market_maker_rs::chain::{ChainMarketMaker, ChainMarketMakerConfig};
use option_chain_orderbook::orderbook::ExpirationOrderBook;
use std::sync::Arc;

// Create chain market maker
let chain = Arc::new(ExpirationOrderBook::new("BTC", expiration));
let config = ChainMarketMakerConfig::default();
let mm = ChainMarketMaker::new(chain, config);

// Refresh all quotes across the chain
let quotes = mm.refresh_all_quotes(underlying_price).unwrap();

// Check chain risk status
let status = mm.check_chain_risk();
if !status.can_quote() {
    // Stop quoting or hedge
}
```

--------------------------------

### Manage Greeks Risk with Auto-Hedging

Source: https://docs.rs/market_maker_rs

Initialize a GreeksRiskManager for automated hedging. Use `check_order` to validate trades against risk limits and `needs_hedge` to determine if hedging is required. Requires the `options` feature.

```rust
use market_maker_rs::options::{
    GreeksRiskManager,
    AutoHedgerConfig,
    GreeksLimits,
    OrderDecision,
};

// Create risk manager with auto-hedging
let limits = GreeksLimits::default();
let hedger_config = AutoHedgerConfig::default();
let mut risk_manager = GreeksRiskManager::new("BTC", limits, hedger_config);

// Check if order is allowed
let decision = risk_manager.check_order(&option_greeks, dec!(10.0));
match decision {
    OrderDecision::Allowed => { /* proceed */ },
    OrderDecision::Scaled { new_size, .. } => { /* use scaled size */ },
    OrderDecision::Rejected { reason } => { /* reject */ },
}

// Check if hedging is needed
if risk_manager.needs_hedge() {
    let hedge = risk_manager.calculate_hedge_order(underlying_price);
}
```

--------------------------------

### Manage Multi-Underlying Portfolios

Source: https://docs.rs/market_maker_rs

Utilize MultiUnderlyingManager for sophisticated portfolio management across different assets. Configure capital allocation, set correlations, update market data, and obtain unified risk views or cross-asset hedge suggestions. Requires the `multi-underlying` feature.

```rust
use market_maker_rs::multi_underlying::{
    MultiUnderlyingManager,
    UnderlyingConfig,
    CapitalAllocationStrategy,
};
use market_maker_rs::dec;

// Create manager with $1M capital
let mut manager = MultiUnderlyingManager::new(dec!(1_000_000))
    .with_allocation_strategy(CapitalAllocationStrategy::RiskParity)
    .with_max_total_delta(dec!(50000));

// Add underlyings with target weights
manager.add_underlying(UnderlyingConfig::new("BTC", dec!(0.40))).unwrap();
manager.add_underlying(UnderlyingConfig::new("ETH", dec!(0.30))).unwrap();

// Set correlations
manager.set_correlation("BTC", "ETH", dec!(0.85));

// Update market data
manager.update_price("BTC", dec!(45000));
manager.update_greeks("BTC", dec!(5.5), dec!(0.02), dec!(1500));

// Get unified risk view
let risk = manager.get_unified_risk();
println!("Total delta: {}", risk.greeks.total_dollar_delta);

// Get cross-asset hedge suggestions
let hedges = manager.get_cross_asset_hedges();
```

--------------------------------

### Calculate Options Greeks and Hedge Delta

Source: https://docs.rs/market_maker_rs

Compute the Greeks (Delta, Gamma, etc.) for a given option using `OptionsAdapter`. Aggregate Greeks for a portfolio and determine the number of shares needed to hedge delta.

```rust
use market_maker_rs::options::{OptionsAdapter, PortfolioGreeks, PositionGreeks};
use optionstratlib::model::option::Options;

// Calculate Greeks for an option
let greeks = OptionsAdapter::calculate_greeks(&option).unwrap();
println!("Delta: {}, Gamma: {}", greeks.delta, greeks.gamma);

// Aggregate portfolio Greeks
let mut portfolio = PortfolioGreeks::new();
portfolio.add(&greeks, dec!(10.0)); // 10 contracts

// Check delta neutrality
let shares_to_hedge = portfolio.shares_to_hedge(dec!(100.0));
```

--------------------------------

### Configure Circuit Breaker for Trading Halts

Source: https://docs.rs/market_maker_rs

Set up a circuit breaker to automatically halt trading based on various risk parameters like daily loss, loss per trade, consecutive losses, and drawdown. Includes cooldown and loss window settings.

```rust
use market_maker_rs::prelude::*;

// Circuit breaker for automatic trading halts
let config = CircuitBreakerConfig::new(
    dec!(1000.0), // max daily loss
    dec!(0.05),   // max loss per trade (5%)
    5,            // max consecutive losses
    dec!(0.10),   // max drawdown (10%)
    300_000,      // cooldown period (5 min)
    60_000,       // loss window (1 min)
).unwrap();
let breaker = CircuitBreaker::new(config);
```

--------------------------------

### Calculate Optimal Quotes with Avellaneda-Stoikov

Source: https://docs.rs/market_maker_rs

Use this function to calculate optimal bid and ask quotes based on the Avellaneda-Stoikov strategy. Requires market data like mid-price, inventory, risk aversion, volatility, time to terminal, and order intensity.

```rust
use market_maker_rs::prelude::*;

// Calculate optimal quotes using Avellaneda-Stoikov
let mid_price = dec!(100.0);
let inventory = dec!(5.0);
let risk_aversion = dec!(0.5);    // γ
let volatility = dec!(0.02);
let time_to_terminal_ms = 3600_000; // 1 hour
let order_intensity = dec!(1.5);  // k

let (bid, ask) = market_maker_rs::strategy::avellaneda_stoikov::calculate_optimal_quotes(
    mid_price,
    inventory,
    risk_aversion,
    volatility,
    time_to_terminal_ms,
    order_intensity,
).unwrap();

println!("Bid: {}, Ask: {}", bid, ask);
```

--------------------------------

### Calculate Reservation Price

Source: https://docs.rs/market_maker_rs

Formula for determining the reservation price based on inventory, risk aversion, and volatility.

```text
r = s - q × γ × σ² × (T - t)
```

--------------------------------

### Calculate Optimal Spread

Source: https://docs.rs/market_maker_rs

Formula for determining the optimal spread using risk aversion, volatility, and order arrival intensity.

```text
spread = γ × σ² × (T - t) + (2/γ) × ln(1 + γ/k)
```
Tokens:
Raw