market_making.py

"""Market Making Engine — What Jane Street Actually Does

Jane Street is primarily a MARKET MAKER, not a directional trader.
They quote bid/ask on options, ETFs, bonds — make money on spread + volume.

Key challenges:
1. Adverse selection: informed traders pick off your quotes
2. Inventory risk: holding positions you don't want
3. Spread optimization: too wide = no volume, too tight = get run over
4. Regulatory constraints: Reg NMS, MiFID II

Based on:
- Avellaneda & Stoikov (2008): "High-frequency trading in a limit order book"
- Guéant et al. (2012): "Dealing with the inventory risk"
- Cartea & Jaimungal (2013): "Modeling asset prices for algorithmic trading"
"""
import numpy as np
import pandas as pd
from typing import Dict, List, Tuple, Optional, Callable
from dataclasses import dataclass
import warnings
warnings.filterwarnings('ignore')


@dataclass
class InventoryState:
    """Current market maker position"""
    position: float = 0.0  # Net position
    cash: float = 0.0       # Cash balance
    pnl_realized: float = 0.0
    pnl_unrealized: float = 0.0
    trades_executed: int = 0
    quotes_submitted: int = 0
    quotes_filled: int = 0
    
    def total_pnl(self, mark_price: float) -> float:
        return self.pnl_realized + self.position * mark_price + self.cash


class MarketMakerQuote:
    """Single market maker quote"""
    def __init__(self, side: str, price: float, quantity: int,
                 aggression: str = 'passive'):
        self.side = side  # 'bid' or 'ask'
        self.price = price
        self.quantity = quantity
        self.aggression = aggression  # 'passive' (resting) or 'aggressive' (crossing)
        self.fill_probability = 0.0
        self.expected_profit = 0.0


class AvellanedaStoikovMarketMaker:
    """
    Avellaneda-Stoikov (2008) market making model.
    
    Key insight: Quote prices should DEPEND on current inventory.
    
    Reservation price (where you're indifferent to trade):
    r = s - q * γ * σ² * (T - t)
    
    Spread:
    δ^a + δ^b = γ * σ² * (T - t) + (2/γ) * ln(1 + γ/κ)
    
    Where:
    - s = mid price
    - q = inventory position
    - γ = risk aversion
    - σ = volatility
    - T-t = time remaining
    - κ = order arrival intensity
    
    As inventory grows positive → skew quotes DOWN (want to sell)
    As inventory grows negative → skew quotes UP (want to buy)
    """
    
    def __init__(self,
                 gamma: float = 0.1,        # Risk aversion
                 sigma: float = 0.02,       # Volatility (per period)
                 kappa: float = 1.5,        # Order arrival rate
                 max_position: float = 1000.0,  # Position limit
                 min_spread_bps: float = 1.0,   # Minimum spread in bps
                 max_spread_bps: float = 50.0,  # Maximum spread
                 inventory_skew_factor: float = 2.0):  # How much to skew
        
        self.gamma = gamma
        self.sigma = sigma
        self.kappa = kappa
        self.max_position = max_position
        self.min_spread_bps = min_spread_bps / 10000.0  # Convert to decimal
        self.max_spread_bps = max_spread_bps / 10000.0
        self.inventory_skew_factor = inventory_skew_factor
        
        self.state = InventoryState()
        self.quote_history = []
        self.pnl_history = []
    
    def reset(self):
        """Reset state"""
        self.state = InventoryState()
        self.quote_history = []
        self.pnl_history = []
    
    def calculate_quotes(self, 
                         mid_price: float,
                         time_to_end: float = 1.0,
                         current_inventory: Optional[float] = None) -> Tuple[MarketMakerQuote, MarketMakerQuote]:
        """
        Calculate optimal bid and ask quotes.
        
        Returns: (bid_quote, ask_quote)
        """
        if current_inventory is None:
            current_inventory = self.state.position
        
        # Reservation price (inventory-adjusted mid)
        reservation_price = mid_price - current_inventory * self.gamma * (self.sigma ** 2) * time_to_end
        
        # Optimal spread
        optimal_spread = self.gamma * (self.sigma ** 2) * time_to_end + \
                        (2.0 / self.gamma) * np.log(1 + self.gamma / self.kappa)
        
        # Apply min/max spread constraints
        spread_decimal = max(optimal_spread, self.min_spread_bps * mid_price)
        spread_decimal = min(spread_decimal, self.max_spread_bps * mid_price)
        
        # Inventory skewing
        # If long (q > 0), make ask more attractive (lower ask), bid less attractive
        # If short (q < 0), make bid more attractive (higher bid), ask less attractive
        skew = np.tanh(current_inventory / self.max_position * self.inventory_skew_factor)
        
        half_spread = spread_decimal / 2
        
        # Skew: shift quotes away from reservation price
        bid_offset = half_spread * (1 + skew)  # Higher bid when short
        ask_offset = half_spread * (1 - skew)  # Lower ask when long
        
        bid_price = reservation_price - bid_offset
        ask_price = reservation_price + ask_offset
        
        # Ensure bid < ask
        if bid_price >= ask_price:
            # Emergency: force minimum spread
            avg = (bid_price + ask_price) / 2
            bid_price = avg - self.min_spread_bps * mid_price / 2
            ask_price = avg + self.min_spread_bps * mid_price / 2
        
        # Quantity sizing: larger when inventory is neutral, smaller when extreme
        inventory_ratio = abs(current_inventory) / self.max_position
        qty_multiplier = 1.0 - 0.7 * inventory_ratio  # Reduce size as inventory grows
        base_qty = 100
        
        bid_qty = int(base_qty * qty_multiplier)
        ask_qty = int(base_qty * qty_multiplier)
        
        # If extremely long, don't quote on ask (or tiny qty)
        if current_inventory > self.max_position * 0.9:
            ask_qty = 0
        # If extremely short, don't quote on bid
        if current_inventory < -self.max_position * 0.9:
            bid_qty = 0
        
        bid_quote = MarketMakerQuote('bid', bid_price, bid_qty, 'passive')
        ask_quote = MarketMakerQuote('ask', ask_price, ask_qty, 'passive')
        
        # Expected fill probability (simplified)
        bid_quote.fill_probability = np.exp(-self.kappa * bid_offset)
        ask_quote.fill_probability = np.exp(-self.kappa * ask_offset)
        
        # Expected profit per trade = half spread (simplified)
        bid_quote.expected_profit = bid_offset
        ask_quote.expected_profit = ask_offset
        
        return bid_quote, ask_quote
    
    def process_fill(self, quote: MarketMakerQuote, 
                     fill_qty: int,
                     fill_price: float,
                     is_aggressive_side: bool):
        """
        Process a quote fill.
        
        is_aggressive_side: True if WE were aggressive (market order), 
                           False if counterparty hit our resting quote
        """
        if quote.side == 'bid':
            # We bought
            self.state.position += fill_qty
            self.state.cash -= fill_qty * fill_price
            self.state.trades_executed += 1
        else:
            # We sold
            self.state.position -= fill_qty
            self.state.cash += fill_qty * fill_price
            self.state.trades_executed += 1
        
        self.state.quotes_filled += 1
        
        # Track
        self.quote_history.append({
            'side': quote.side,
            'quote_price': quote.price,
            'fill_price': fill_price,
            'quantity': fill_qty,
            'position_after': self.state.position,
            'cash_after': self.state.cash
        })
    
    def update_mark_price(self, mark_price: float):
        """Update unrealized PnL with current mark"""
        self.state.pnl_unrealized = self.state.position * mark_price + self.state.cash
        self.pnl_history.append({
            'mark_price': mark_price,
            'position': self.state.position,
            'cash': self.state.cash,
            'unrealized_pnl': self.state.pnl_unrealized
        })
    
    def get_summary(self) -> Dict:
        """Get current market maker summary"""
        return {
            'position': self.state.position,
            'cash': self.state.cash,
            'trades': self.state.trades_executed,
            'quotes_filled': self.state.quotes_filled,
            'pnl_realized': self.state.pnl_realized,
            'pnl_unrealized': self.state.pnl_unrealized,
            'inventory_ratio': abs(self.state.position) / self.max_position
        }


class InventoryRiskManager:
    """
    Advanced inventory risk management for market making.
    
    When inventory exceeds limits:
    1. Hedge via correlated instruments
    2. Cross the spread (aggressive unwind)
    3. Reduce quote sizes
    4. Stop quoting on the bad side entirely
    """
    
    def __init__(self,
                 max_inventory: float = 1000,
                 hedge_threshold: float = 0.6,   # Hedge at 60% of max
                 stop_threshold: float = 0.9,      # Stop quoting at 90%
                 aggressive_unwind_threshold: float = 0.95):  # Market order at 95%
        
        self.max_inventory = max_inventory
        self.hedge_threshold = hedge_threshold
        self.stop_threshold = stop_threshold
        self.aggressive_unwind_threshold = aggressive_unwind_threshold
    
    def check_inventory(self, position: float) -> Dict:
        """Determine actions needed based on inventory"""
        ratio = abs(position) / self.max_inventory
        
        actions = {
            'hedge': False,
            'stop_quoting_bad_side': False,
            'aggressive_unwind': False,
            'reduce_size': 1.0,  # Size multiplier
            'status': 'normal'
        }
        
        if ratio >= self.aggressive_unwind_threshold:
            actions['aggressive_unwind'] = True
            actions['stop_quoting_bad_side'] = True
            actions['reduce_size'] = 0.0
            actions['status'] = 'CRITICAL'
        
        elif ratio >= self.stop_threshold:
            actions['stop_quoting_bad_side'] = True
            actions['reduce_size'] = 0.1
            actions['status'] = 'SEVERE'
        
        elif ratio >= self.hedge_threshold:
            actions['hedge'] = True
            actions['reduce_size'] = 0.5
            actions['status'] = 'WARNING'
        
        elif ratio >= 0.5:
            actions['reduce_size'] = 0.8
            actions['status'] = 'MODERATE'
        
        return actions
    
    def hedge_recommendation(self, 
                           position: float,
                           correlated_assets: Dict[str, float]) -> Optional[Dict]:
        """
        Recommend hedge position in correlated assets.
        
        correlated_assets: {symbol: correlation_with_primary}
        """
        if abs(position) < self.max_inventory * self.hedge_threshold:
            return None
        
        # Find best hedge: highest absolute correlation
        best_hedge = None
        best_corr = 0
        
        for symbol, corr in correlated_assets.items():
            if abs(corr) > best_corr:
                best_corr = abs(corr)
                best_hedge = symbol
        
        if best_hedge is None:
            return None
        
        # Hedge amount: offset position in primary
        hedge_direction = -np.sign(position)
        hedge_size = abs(position) * abs(correlated_assets[best_hedge])
        
        return {
            'hedge_symbol': best_hedge,
            'direction': 'buy' if hedge_direction > 0 else 'sell',
            'quantity': hedge_size,
            'correlation': correlated_assets[best_hedge],
            'expected_hedge_effectiveness': best_corr ** 2  # R²
        }


class AdverseSelectionDetector:
    """
    Detect and respond to adverse selection.
    
    Adverse selection: Informed traders know something you don't.
    When they buy from you, price drops. When they sell to you, price rises.
    
    Detection methods:
    1. Post-trade price movement
    2. Order flow toxicity (VPIN)
    3. Large order detection
    4. Timing patterns (orders arrive in clusters before news)
    """
    
    def __init__(self, 
                 lookback_window: int = 20,
                 toxicity_threshold: float = 0.6):
        self.lookback_window = lookback_window
        self.toxicity_threshold = toxicity_threshold
        self.trade_history = []
        self.toxicity_score = 0.0
    
    def record_trade(self, 
                     side: str,           # Which side WE filled
                     our_price: float,    # Price we got
                     post_prices: List[float],  # Prices after trade (1min, 5min, 15min)
                     quantity: int,
                     counterparty: Optional[str] = None):
        """Record a trade for adverse selection analysis"""
        
        # Calculate post-trade drift
        drift = 0
        if post_prices and len(post_prices) >= 1:
            # If we SOLD and price went UP → bad (gave away value)
            # If we BOUGHT and price went DOWN → bad (overpaid)
            if side == 'ask':  # We sold
                drift = post_prices[0] - our_price
            else:  # We bought
                drift = our_price - post_prices[0]
        
        self.trade_history.append({
            'side': side,
            'our_price': our_price,
            'post_drift': drift,
            'quantity': quantity,
            'counterparty': counterparty,
            'adverse': drift > 0  # True if trade was bad for us
        })
        
        # Keep only recent trades
        if len(self.trade_history) > self.lookback_window:
            self.trade_history.pop(0)
    
    def get_toxicity_score(self) -> float:
        """Current toxicity score (0-1, higher = more adverse selection)"""
        if len(self.trade_history) < 5:
            return 0.0
        
        adverse_count = sum(1 for t in self.trade_history if t['adverse'])
        self.toxicity_score = adverse_count / len(self.trade_history)
        
        return self.toxicity_score
    
    def should_widen_spread(self) -> Tuple[bool, float]:
        """Should we widen spread due to adverse selection?"""
        toxicity = self.get_toxicity_score()
        
        if toxicity > self.toxicity_threshold:
            # Widen spread proportionally
            widen_factor = 1.0 + (toxicity - self.toxicity_threshold) * 2
            return True, min(widen_factor, 3.0)  # Max 3x wider
        
        return False, 1.0
    
    def get_recent_pnl(self) -> Dict:
        """P&L attribution from adverse selection"""
        if not self.trade_history:
            return {}
        
        adverse_trades = [t for t in self.trade_history if t['adverse']]
        good_trades = [t for t in self.trade_history if not t['adverse']]
        
        adverse_drift = sum(t['post_drift'] * t['quantity'] for t in adverse_trades)
        good_drift = sum(t['post_drift'] * t['quantity'] for t in good_trades)
        
        return {
            'total_trades': len(self.trade_history),
            'adverse_trades': len(adverse_trades),
            'adverse_pct': len(adverse_trades) / len(self.trade_history) * 100,
            'total_adverse_cost': adverse_drift,
            'total_good_gain': -good_drift,
            'net_selection_cost': adverse_drift + good_drift
        }


def simulate_market_making(n_steps: int = 1000,
                           price_drift: float = 0.0001,
                           volatility: float = 0.01,
                           arrival_rate: float = 0.3) -> pd.DataFrame:
    """
    Simulate a market maker in a random walk market.
    
    Generates synthetic tick data and lets the market maker quote and fill.
    """
    np.random.seed(42)
    
    # Initialize
    mm = AvellanedaStoikovMarketMaker(
        gamma=0.1,
        sigma=volatility,
        kappa=1.5,
        max_position=1000
    )
    
    detector = AdverseSelectionDetector(lookback_window=20)
    risk_mgr = InventoryRiskManager()
    
    # Price process
    price = 100.0
    prices = [price]
    
    results = []
    
    for step in range(n_steps):
        # Update price
        price_change = np.random.randn() * volatility * price + price_drift * price
        price += price_change
        price = max(price, 0.01)
        prices.append(price)
        
        # Calculate quotes
        bid_quote, ask_quote = mm.calculate_quotes(price, time_to_end=1.0)
        
        # Check inventory risk
        inventory_actions = risk_mgr.check_inventory(mm.state.position)
        
        # Check adverse selection
        widen, widen_factor = detector.should_widen_spread()
        if widen:
            # Widen spread
            spread_adj = (widen_factor - 1.0) * (ask_quote.price - bid_quote.price) / 2
            bid_quote.price -= spread_adj
            ask_quote.price += spread_adj
        
        # Simulate order arrivals
        if np.random.rand() < arrival_rate:
            # Someone hits our bid
            if np.random.rand() < bid_quote.fill_probability:
                fill_qty = np.random.randint(10, bid_quote.quantity + 1)
                mm.process_fill(bid_quote, fill_qty, bid_quote.price, False)
                
                # Record for adverse selection
                future_prices = prices[-5:] if len(prices) >= 5 else prices
                detector.record_trade('bid', bid_quote.price, future_prices, fill_qty)
        
        if np.random.rand() < arrival_rate:
            # Someone lifts our ask
            if np.random.rand() < ask_quote.fill_probability:
                fill_qty = np.random.randint(10, ask_quote.quantity + 1)
                mm.process_fill(ask_quote, fill_qty, ask_quote.price, False)
                
                future_prices = prices[-5:] if len(prices) >= 5 else prices
                detector.record_trade('ask', ask_quote.price, future_prices, fill_qty)
        
        # Mark to market
        mm.update_mark_price(price)
        
        # Record
        summary = mm.get_summary()
        results.append({
            'step': step,
            'price': price,
            'bid': bid_quote.price,
            'ask': ask_quote.price,
            'spread_bps': (ask_quote.price - bid_quote.price) / price * 10000,
            'position': summary['position'],
            'cash': summary['cash'],
            'inventory_ratio': summary['inventory_ratio'],
            'unrealized_pnl': summary['pnl_unrealized'],
            'toxicity': detector.get_toxicity_score(),
            'status': inventory_actions['status']
        })
    
    return pd.DataFrame(results)


if __name__ == '__main__':
    print("=" * 70)
    print("  MARKET MAKING ENGINE SIMULATION")
    print("=" * 70)
    
    results = simulate_market_making(n_steps=5000)
    
    # Summary
    final = results.iloc[-1]
    
    print(f"\nSimulation: 5000 steps, random walk market")
    print(f"  Initial Price: $100.00")
    print(f"  Final Price:   ${final['price']:.2f}")
    print(f"  Final Position: {final['position']:.0f}")
    print(f"  Final Cash:     ${final['cash']:.2f}")
    print(f"  Unrealized PnL: ${final['unrealized_pnl']:.2f}")
    print(f"  Avg Spread:     {results['spread_bps'].mean():.1f} bps")
    print(f"  Avg Position:   {abs(results['position']).mean():.0f}")
    print(f"  Max Position:   {results['position'].abs().max():.0f}")
    print(f"  Avg Toxicity:   {results['toxicity'].mean():.3f}")
    
    # Strategy attribution
    pnl_from_spread = results['spread_bps'].mean() / 10000 * 2 * 100  # Simplified
    
    print(f"\n  PnL Attribution:")
    print(f"    Spread capture: ~${pnl_from_spread * 50:.0f} (per 100 trades)")
    print(f"    Inventory risk: ${final['unrealized_pnl'] - pnl_from_spread * 50:.0f}")
    
    print(f"\n  This is how Jane Street makes money:")
    print(f"    1. Quote tight spreads 1000s of times per day")
    print(f"    2. Inventory management keeps risk bounded")
    print(f"    3. Adverse selection detection widens when toxic flow arrives")
    print(f"    4. Volume × Small spread margin = Big PnL")