feat(V2): migrazione common/ (indicators, options, microstructure, stats, http, audit, logging, mcp_bridge + auth)

src/cerbero_mcp/common/microstructure.py

@@ -0,0 +1,74 @@
+"""Microstructure indicators: orderbook imbalance, slope, microprice.
+
+Tutte le funzioni accettano bids/asks come list[list[price, qty]] (formato
+standard dei ticker exchange) e ritornano metriche aggregate exchange-agnostic.
+"""
+from __future__ import annotations
+
+
+def orderbook_imbalance(
+    bids: list[list[float]],
+    asks: list[list[float]],
+    depth: int = 10,
+) -> dict[str, float | None]:
+    """Imbalance ratio = (bid_vol - ask_vol) / (bid_vol + ask_vol) sui top-`depth`
+    livelli. Range [-1, +1]. Positivo = bid pressure, negativo = ask pressure.
+
+    Microprice (Stoll-Bertsimas): mid pesato dalla size opposta
+    → P_micro = (P_bid * Q_ask + P_ask * Q_bid) / (Q_bid + Q_ask). Best level only.
+
+    Slope: variazione cumulata di volume per unità di prezzo (proxy per
+    liquidità in profondità).
+    """
+    if not bids and not asks:
+        return {
+            "imbalance_ratio": None,
+            "bid_volume": 0.0,
+            "ask_volume": 0.0,
+            "microprice": None,
+            "bid_slope": None,
+            "ask_slope": None,
+        }
+
+    top_bids = bids[:depth]
+    top_asks = asks[:depth]
+    bid_vol = sum(q for _, q in top_bids)
+    ask_vol = sum(q for _, q in top_asks)
+    total = bid_vol + ask_vol
+
+    ratio = None if total == 0 else (bid_vol - ask_vol) / total
+
+    # Microprice: best bid, best ask. Weighted by opposite-side size.
+    microprice = None
+    if top_bids and top_asks:
+        bp, bq = top_bids[0]
+        ap, aq = top_asks[0]
+        denom = bq + aq
+        if denom > 0:
+            microprice = (bp * aq + ap * bq) / denom
+
+    bid_slope = _depth_slope(top_bids, ascending_price=False)
+    ask_slope = _depth_slope(top_asks, ascending_price=True)
+
+    return {
+        "imbalance_ratio": ratio,
+        "bid_volume": bid_vol,
+        "ask_volume": ask_vol,
+        "microprice": microprice,
+        "bid_slope": bid_slope,
+        "ask_slope": ask_slope,
+    }
+
+
+def _depth_slope(levels: list[list[float]], ascending_price: bool) -> float | None:
+    """Calcola |Δq / Δp| sul primo vs penultimo livello.
+    Slope alto = liquidità che crolla rapidamente in profondità (book sottile).
+    """
+    if len(levels) < 2:
+        return None
+    p_first, q_first = levels[0]
+    p_last, q_last = levels[-1]
+    dp = abs(p_last - p_first)
+    if dp == 0:
+        return None
+    return abs(q_first - q_last) / dp