Update app.py

app.py

@@ -2,6 +2,9 @@ import asyncio
 import json
 import logging
 import time
+import bisect
+import math
+import statistics
 import aiohttp
 from aiohttp import web
 import websockets
@@ -9,107 +12,215 @@ import websockets
 SYMBOL_KRAKEN = "BTC/USD"
 PORT = 7860
 HISTORY_LENGTH = 300
-BROADCAST_RATE = 0.1 # 100ms Updates (High Frequency)
+BROADCAST_RATE = 0.1
+
+DECAY_LAMBDA = 50.0
+IMPACT_SENSITIVITY = 2.0
+Z_SCORE_THRESHOLD = 3.0
+WALL_LOOKBACK = 200
+
+# ML Hyperparameters
+LEARNING_RATE = 0.01
+MOMENTUM = 0.9
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
 
+class OnlineScaler:
+    def __init__(self):
+        self.n = 0
+        self.mean = 0.0
+        self.M2 = 0.0
+
+    def update(self, x):
+        self.n += 1
+        delta = x - self.mean
+        self.mean += delta / self.n
+        delta2 = x - self.mean
+        self.M2 += delta * delta2
+        return self.transform(x)
+
+    def transform(self, x):
+        if self.n < 2: return 0.0
+        var = self.M2 / (self.n - 1)
+        if var == 0: return 0.0
+        std = math.sqrt(var)
+        return (x - self.mean) / std
+
+class QuantModel:
+    def __init__(self, num_features):
+        self.weights = [0.0] * num_features
+        self.bias = 0.0
+        self.velocity = [0.0] * num_features
+        self.bias_velocity = 0.0
+        self.scalers = [OnlineScaler() for _ in range(num_features)]
+        self.prev_features = None
+        self.prev_price = None
+
+    def predict(self, features):
+        scaled = [s.transform(f) for s, f in zip(self.scalers, features)]
+        dot = sum(w * x for w, x in zip(self.weights, scaled))
+        return dot + self.bias
+
+    def train(self, current_price, current_features):
+        if self.prev_features is None or self.prev_price is None:
+            self.prev_features = [s.update(f) for s, f in zip(self.scalers, current_features)]
+            self.prev_price = current_price
+            return
+
+        # Target: Price Change (Delta)
+        actual_delta = current_price - self.prev_price
+        
+        # Predict using PAST features
+        pred_delta = sum(w * x for w, x in zip(self.weights, self.prev_features)) + self.bias
+        
+        # Error
+        error = pred_delta - actual_delta
+        
+        # SGD with Momentum Update
+        for i in range(len(self.weights)):
+            grad = error * self.prev_features[i]
+            self.velocity[i] = MOMENTUM * self.velocity[i] - LEARNING_RATE * grad
+            self.weights[i] += self.velocity[i]
+        
+        self.bias_velocity = MOMENTUM * self.bias_velocity - LEARNING_RATE * error
+        self.bias += self.bias_velocity
+
+        # Store for next tick
+        self.prev_features = [s.update(f) for s, f in zip(self.scalers, current_features)]
+        self.prev_price = current_price
+
+    def get_forecast(self, current_price, current_features):
+        # Predict NEXT delta based on CURRENT features
+        pred_delta = self.predict(current_features)
+        return current_price + pred_delta
+
+# 4 Features: OFI, Depth Area, Best Imbalance, Velocity
+ml_model = QuantModel(4)
+
 market_state = {
     "bids": {},
     "asks": {},
     "history": [],
-    "ofi_history": [],     # Stores the Cumulative OFI
+    "pred_history": [],
+    "ml_history": [],
     "trade_vol_history": [],
     "ohlc_history": [],
     "current_vol_window": {"buy": 0.0, "sell": 0.0, "start": time.time()},
     "current_mid": 0.0,
-    "prev_book": None,     # To track t-1 state for CKS model
-    "cumulative_ofi": 0.0, # The running total of Order Flow Imbalance
+    "prev_mid": 0.0,
     "ready": False
 }
 
 connected_clients = set()
 
-def calculate_ofi(best_bid_p, best_bid_q, best_ask_p, best_ask_q):
-    """
-    Cont-Kukanov-Stoikov (CKS) Order Flow Imbalance Model.
-    e_n = I(b_n >= b_{n-1})*q_n^b - I(b_n <= b_{n-1})*q_{n-1}^b ...
-    """
-    prev = market_state['prev_book']
-    if not prev:
-        return 0.0
-
-    ofi_delta = 0.0
-
-    # --- BID SIDE IMPACT (Buying Pressure) ---
-    if best_bid_p > prev['bp']:
-        # Price Improvement: Aggressive Buy (Add full current qty)
-        ofi_delta += best_bid_q
-    elif best_bid_p < prev['bp']:
-        # Price Drop: Support Pulled (Subtract previous qty)
-        ofi_delta -= prev['bq']
-    else:
-        # Price Same: Net change in liquidity
-        # If Qty increases, Support added (+). If Qty decreases, Support pulled (-).
-        ofi_delta += (best_bid_q - prev['bq'])
-
-    # --- ASK SIDE IMPACT (Selling Pressure) ---
-    # Note: Ask logic is inverted. Higher Ask = Less Pressure (Bullish), Lower Ask = More Pressure (Bearish)
-    # We subtract Ask Impact from Total OFI.
-    
-    ask_impact = 0.0
-    if best_ask_p < prev['ap']:
-        # Price Drop: Aggressive Sell (Add full current qty to sell pressure)
-        ask_impact += best_ask_q
-    elif best_ask_p > prev['ap']:
-        # Price Rise: Resistance Removed (Subtract previous qty from sell pressure)
-        ask_impact -= prev['aq']
-    else:
-        # Price Same: Net change in liquidity
-        # If Qty increases, Resistance added (+). If Qty decreases, Resistance removed (-).
-        ask_impact += (best_ask_q - prev['aq'])
-
-    # Net OFI = Bid Impact - Ask Impact
-    return ofi_delta - ask_impact
-
-def process_market_data():
-    if not market_state['ready']: return {"error": "Initializing..."}
+def detect_anomalies(orders, scan_depth):
+    if len(orders) < 10: return []
+    relevant_orders = orders[:scan_depth]
+    volumes = [q for p, q in relevant_orders]
+    if not volumes: return []
 
-    # 1. Sort Book to get Best Bid/Ask
-    sorted_bids = sorted(market_state['bids'].items(), key=lambda x: -x[0])
-    sorted_asks = sorted(market_state['asks'].items(), key=lambda x: x[0])
+    try:
+        avg_vol = statistics.mean(volumes)
+        stdev_vol = statistics.stdev(volumes)
+    except statistics.StatisticsError:
+        return []
+
+    if stdev_vol == 0: return []
+
+    walls = []
+    for price, qty in relevant_orders:
+        z_score = (qty - avg_vol) / stdev_vol
+        if z_score > Z_SCORE_THRESHOLD:
+            walls.append({"price": price, "vol": qty, "z_score": z_score})
+
+    walls.sort(key=lambda x: x['z_score'], reverse=True)
+    return walls[:3]
+
+def calculate_micro_price_structure(diff_x, diff_y_net, current_mid, best_bid, best_ask, walls):
+    if not diff_x or len(diff_x) < 5: return None, 0
+
+    weighted_imbalance = 0.0
+    total_weight = 0.0
+
+    for i in range(len(diff_x)):
+        dist = diff_x[i]
+        net_vol = diff_y_net[i]
+        weight = math.exp(-dist / DECAY_LAMBDA)
+        weighted_imbalance += net_vol * weight
+        total_weight += weight
+
+    rho = weighted_imbalance / total_weight if total_weight > 0 else 0
+
+    spread = best_ask - best_bid
+    theoretical_delta = (spread / 2) * rho * IMPACT_SENSITIVITY
+    projected_price = current_mid + theoretical_delta
+
+    final_delta = theoretical_delta
+    if final_delta > 0 and walls['asks']:
+        nearest_wall = walls['asks'][0]
+        if projected_price >= nearest_wall['price']:
+            damp_factor = 1.0 / (1.0 + (nearest_wall['z_score'] * 0.2))
+            final_delta *= damp_factor
+    elif final_delta < 0 and walls['bids']:
+        nearest_wall = walls['bids'][0]
+        if projected_price <= nearest_wall['price']:
+            damp_factor = 1.0 / (1.0 + (nearest_wall['z_score'] * 0.2))
+            final_delta *= damp_factor
 
-    if not sorted_bids or not sorted_asks: return {"error": "Empty Book"}
+    return {
+        "projected": current_mid + final_delta,
+        "rho": rho
+    }, sum(diff_y_net)
 
-    best_bid_p, best_bid_q = sorted_bids[0]
-    best_ask_p, best_ask_q = sorted_asks[0]
-    mid = (best_bid_p + best_ask_p) / 2
-    market_state['current_mid'] = mid
+def calculate_polr(bids, asks, mid):
+    if not bids or not asks: return []
 
-    now = time.time()
+    sorted_bids = sorted(bids.items(), key=lambda x: -x[0])
+    sorted_asks = sorted(asks.items(), key=lambda x: x[0])
 
-    # 2. CKS OFI Calculation
-    ofi_step = calculate_ofi(best_bid_p, best_bid_q, best_ask_p, best_ask_q)
-    market_state['cumulative_ofi'] += ofi_step
+    path_points = []
+    volume_steps = [i * 0.5 for i in range(1, 61)] 
     
-    # Store state for next tick (t-1)
-    market_state['prev_book'] = {
-        'bp': best_bid_p, 'bq': best_bid_q, 
-        'ap': best_ask_p, 'aq': best_ask_q
-    }
-
-    # 3. History Management
-    if not market_state['history'] or (now - market_state['history'][-1]['t'] > 0.5):
-        # Price History
-        market_state['history'].append({'t': now, 'p': mid})
-        if len(market_state['history']) > HISTORY_LENGTH:
-            market_state['history'].pop(0)
+    for i, target_vol in enumerate(volume_steps):
+        ask_cost_dist = 0
+        cum_vol = 0
+        target_ask_price = mid
+        for p, q in sorted_asks:
+            cum_vol += q
+            if cum_vol >= target_vol:
+                target_ask_price = p
+                break
+        ask_cost_dist = target_ask_price - mid
+
+        bid_cost_dist = 0
+        cum_vol = 0
+        target_bid_price = mid
+        for p, q in sorted_bids:
+            cum_vol += q
+            if cum_vol >= target_vol:
+                target_bid_price = p
+                break
+        bid_cost_dist = mid - target_bid_price
+
+        if bid_cost_dist <= 0: bid_cost_dist = 0.01
+        if ask_cost_dist <= 0: ask_cost_dist = 0.01
+
+        projected_p = mid
+        if ask_cost_dist > bid_cost_dist:
+             projected_p = target_ask_price 
+        else:
+             projected_p = target_bid_price
         
-        # OFI History (Synced with price updates)
-        market_state['ofi_history'].append({'t': now, 'v': market_state['cumulative_ofi']})
-        if len(market_state['ofi_history']) > HISTORY_LENGTH:
-            market_state['ofi_history'].pop(0)
+        path_points.append({'index': i, 'p': projected_p})
+
+    return path_points
+
+def process_market_data():
+    if not market_state['ready']: return {"error": "Initializing..."}
 
-    # 4. Volume Window Logic
+    mid = market_state['current_mid']
+    
+    now = time.time()
     if now - market_state['current_vol_window']['start'] >= 1.0:
         market_state['trade_vol_history'].append({
             't': now,
@@ -120,17 +231,100 @@ def process_market_data():
             market_state['trade_vol_history'].pop(0)
         market_state['current_vol_window'] = {"buy": 0.0, "sell": 0.0, "start": now}
 
+    sorted_bids = sorted(market_state['bids'].items(), key=lambda x: -x[0])
+    sorted_asks = sorted(market_state['asks'].items(), key=lambda x: x[0])
+
+    if not sorted_bids or not sorted_asks: return {"error": "Empty Book"}
+
+    best_bid_p, best_bid_q = sorted_bids[0]
+    best_ask_p, best_ask_q = sorted_asks[0]
+
+    bid_walls = detect_anomalies(sorted_bids, WALL_LOOKBACK)
+    ask_walls = detect_anomalies(sorted_asks, WALL_LOOKBACK)
+
+    d_b_x, d_b_y, cum = [], [], 0
+    for p, q in sorted_bids[:300]:
+        d = mid - p
+        if d >= 0:
+            cum += q
+            d_b_x.append(d); d_b_y.append(cum)
+
+    d_a_x, d_a_y, cum = [], [], 0
+    for p, q in sorted_asks[:300]:
+        d = p - mid
+        if d >= 0:
+            cum += q
+            d_a_x.append(d); d_a_y.append(cum)
+
+    diff_x, diff_y_net = [], []
+    chart_bids, chart_asks = [], []
+
+    if d_b_x and d_a_x:
+        max_dist = min(d_b_x[-1], d_a_x[-1])
+        step_size = max_dist / 100
+        steps = [i * step_size for i in range(1, 101)]
+        
+        for s in steps:
+            idx_b = bisect.bisect_right(d_b_x, s)
+            vol_b = d_b_y[idx_b-1] if idx_b > 0 else 0
+            idx_a = bisect.bisect_right(d_a_x, s)
+            vol_a = d_a_y[idx_a-1] if idx_a > 0 else 0
+            
+            diff_x.append(s)
+            diff_y_net.append(vol_b - vol_a)
+            chart_bids.append(vol_b)
+            chart_asks.append(vol_a)
+
+    analysis, depth_integral = calculate_micro_price_structure(
+        diff_x, diff_y_net, mid, best_bid_p, best_ask_p, 
+        {"bids": bid_walls, "asks": ask_walls}
+    )
+    
+    # --- MACHINE LEARNING FEATURE EXTRACTION ---
+    # 1. OFI: Net Buy-Sell Vol in current window
+    feat_ofi = market_state['current_vol_window']['buy'] - market_state['current_vol_window']['sell']
+    # 2. Depth Difference: Area under the Net Liquidity Curve (Bids - Asks)
+    feat_depth = depth_integral 
+    # 3. Orderbook Imbalance at L1
+    feat_l1_imb = (best_bid_q - best_ask_q) / (best_bid_q + best_ask_q)
+    # 4. Price Momentum (Current - Prev)
+    feat_mom = mid - market_state['prev_mid']
+
+    features = [feat_ofi, feat_depth, feat_l1_imb, feat_mom]
+
+    # Train (Learn from last tick's prediction vs this tick's reality)
+    ml_model.train(mid, features)
+    # Predict (Forecast next tick)
+    ml_prediction = ml_model.get_forecast(mid, features)
+    
+    if len(market_state['ml_history']) == 0 or (now - market_state['ml_history'][-1]['t'] > 0.5):
+        market_state['ml_history'].append({'t': now, 'p': ml_prediction})
+        if len(market_state['ml_history']) > HISTORY_LENGTH:
+            market_state['ml_history'].pop(0)
+    # -------------------------------------------
+
+    polr_path = calculate_polr(market_state['bids'], market_state['asks'], mid)
+
+    if analysis:
+        if not market_state['pred_history'] or (now - market_state['pred_history'][-1]['t'] > 0.5):
+            market_state['pred_history'].append({'t': now, 'p': analysis['projected']})
+            if len(market_state['pred_history']) > HISTORY_LENGTH:
+                market_state['pred_history'].pop(0)
+
     return {
         "mid": mid,
         "history": market_state['history'],
-        "ofi": market_state['ofi_history'],
+        "pred_history": market_state['pred_history'],
+        "ml_history": market_state['ml_history'],
+        "polr": polr_path,
         "trade_history": market_state['trade_vol_history'],
         "ohlc": market_state['ohlc_history'],
-        "stats": {
-            "ofi_val": market_state['cumulative_ofi'],
-            "bid_depth": sum(q for p, q in sorted_bids[:10]),
-            "ask_depth": sum(q for p, q in sorted_asks[:10])
-        }
+        "depth_x": diff_x,
+        "depth_net": diff_y_net,
+        "depth_bids": chart_bids,
+        "depth_asks": chart_asks,
+        "analysis": analysis,
+        "walls": {"bids": bid_walls, "asks": ask_walls}
     }
 
 HTML_PAGE = f"""
@@ -138,7 +332,7 @@ HTML_PAGE = f"""
 <html lang="en">
 <head>
     <meta charset="UTF-8">
-    <title>{SYMBOL_KRAKEN} | Institutional OFI</title>
+    <title>{SYMBOL_KRAKEN}</title>
     <script src="https://unpkg.com/lightweight-charts@4.1.1/dist/lightweight-charts.standalone.production.js"></script>
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@500;600&family=JetBrains+Mono:wght@400;700&display=swap" rel="stylesheet">
     <style>
@@ -152,6 +346,8 @@ HTML_PAGE = f"""
             --red: #ff3b3b;
             --blue: #2979ff;
             --yellow: #ffeb3b; 
+            --purple: #d500f9;
+            --cyan: #00bcd4;
         }}
         body {{ 
             margin: 0; padding: 0; 
@@ -194,11 +390,13 @@ HTML_PAGE = f"""
         
         #p-bottom {{ 
             grid-column: 1 / 2; grid-row: 3 / 4; 
-            display: flex;
-            flex-direction: column;
-            background: var(--bg-panel);
+            display: grid; 
+            grid-template-columns: 1fr 1fr; 
+            gap: 1px; 
+            background: var(--border); 
         }}
-        
+        .bottom-sub {{ background: var(--bg-panel); display: flex; flex-direction: column; position: relative; }}
+
         #p-sidebar {{ 
             grid-column: 2 / 3; 
             grid-row: 2 / 4; 
@@ -228,11 +426,25 @@ HTML_PAGE = f"""
         .label {{ font-size: 10px; color: var(--text-dim); font-weight: 600; text-transform: uppercase; letter-spacing: 0.5px; }}
         .value {{ font-family: 'JetBrains Mono', monospace; font-size: 20px; font-weight: 700; color: #fff; }}
         .value-lg {{ font-size: 26px; }}
-        
+        .value-sub {{ font-family: 'JetBrains Mono', monospace; font-size: 11px; margin-top: 2px; color: #666; }}
+
         .divider {{ height: 1px; background: var(--border); width: 100%; }}
         .c-green {{ color: var(--green); }}
         .c-red {{ color: var(--red); }}
-        .c-yellow {{ color: var(--yellow); }}
+        .c-dim {{ color: var(--text-dim); }}
+        .c-purp {{ color: var(--purple); }}
+        .c-cyan {{ color: var(--cyan); }}
+
+        .list-container {{ display: flex; flex-direction: column; gap: 8px; overflow-y: auto; height: 100px; }}
+        .list-item {{ 
+            display: flex; justify-content: space-between; 
+            font-family: 'JetBrains Mono', monospace; 
+            font-size: 11px; 
+            border-bottom: 1px solid #151515;
+            padding-bottom: 4px;
+        }}
+        .list-item span:first-child {{ color: #e0e0e0; }}
+        .list-item:last-child {{ border: none; }}
         
         .sidebar-chart-box {{
             flex: 1;
@@ -261,42 +473,62 @@ HTML_PAGE = f"""
 
     <div id="p-chart" class="panel">
         <div class="chart-header">
-            PRICE (BLUE - RHS) vs <span class="c-yellow">CUMULATIVE OFI (YELLOW - LHS)</span>
+            PRICE (BLUE) // <span class="c-purp">POLR</span> // <span style="color:var(--yellow)">MICRO</span> // <span class="c-cyan">ML MODEL</span>
         </div>
         <div id="tv-price" style="flex: 1; width: 100%;"></div>
     </div>
 
-    <div id="p-bottom" class="panel">
-        <div class="chart-header">1M KLINE (KRAKEN OHLC)</div>
-        <div id="tv-candles" style="flex: 1; width: 100%;"></div>
+    <div id="p-bottom">
+        <div class="bottom-sub">
+            <div class="chart-header">1M KLINE (KRAKEN OHLC)</div>
+            <div id="tv-candles" style="flex: 1; width: 100%;"></div>
+        </div>
+        <div class="bottom-sub">
+            <div class="chart-header">ORDER FLOW IMBALANCE</div>
+            <div id="tv-net" style="flex: 1; width: 100%;"></div>
+        </div>
     </div>
 
     <div id="p-sidebar" class="panel">
         
         <div class="data-group">
-            <span class="label">Net OFI (Buying Pressure)</span>
-            <span id="ofi-val" class="value value-lg c-yellow">---</span>
+            <span class="label">ML Prediction</span>
+            <span id="ml-val" class="value c-cyan">---</span>
+        </div>
+        
+        <div class="data-group">
+            <span class="label">Micro-Price Delta</span>
+            <div style="display:flex; align-items: baseline; gap: 10px;">
+                <span id="proj-pct" class="value value-lg">--%</span>
+                <span id="proj-val" class="value-sub">---</span>
+            </div>
         </div>
 
         <div class="divider"></div>
 
         <div class="data-group">
-            <span class="label">Interpretation</span>
-            <div style="font-size: 11px; color: #888; line-height: 1.4;">
-                <span class="c-yellow">Yellow Line</span> tracks Order Flow Imbalance.
-                <br><br>
-                <b>Divergence:</b><br>
-                Yellow UP + Price Flat = <span class="c-green">BULLISH COIL</span><br>
-                Yellow DOWN + Price Flat = <span class="c-red">BEARISH DIST</span>
-            </div>
+            <span class="label">OFI Imbalance Ratio</span>
+            <span id="score-val" class="value">0.00</span>
         </div>
 
         <div class="divider"></div>
 
+        <div class="data-group">
+            <span class="label">Detected Walls (Z > 3.0)</span>
+            <div id="wall-list" class="list-container">
+                <span class="c-dim" style="font-size: 11px;">Scanning...</span>
+            </div>
+        </div>
+
         <div class="sidebar-chart-box">
             <span class="label" style="margin-bottom:4px;">Real-time Volume Ticks</span>
             <div id="sidebar-vol" class="mini-chart"></div>
         </div>
+
+        <div class="sidebar-chart-box">
+            <span class="label" style="margin-bottom:4px;">Liquidity Density</span>
+            <div id="sidebar-density" class="mini-chart"></div>
+        </div>
     </div>
 </div>
 
@@ -309,45 +541,62 @@ HTML_PAGE = f"""
     document.addEventListener('DOMContentLoaded', () => {{
         const dom = {{
             ticker: document.getElementById('price-ticker'),
-            ofiVal: document.getElementById('ofi-val')
+            score: document.getElementById('score-val'),
+            projVal: document.getElementById('proj-val'),
+            projPct: document.getElementById('proj-pct'),
+            mlVal: document.getElementById('ml-val'),
+            wallList: document.getElementById('wall-list')
         }};
 
-        // --- MASTER CHART (Dual Axis) ---
-        const priceChart = LightweightCharts.createChart(document.getElementById('tv-price'), {{
+        const chartOpts = {{
             layout: {{ background: {{ type: 'solid', color: '#0a0a0a' }}, textColor: '#888', fontFamily: 'JetBrains Mono' }},
             grid: {{ vertLines: {{ color: '#151515' }}, horzLines: {{ color: '#151515' }} }},
-            rightPriceScale: {{ visible: true, borderColor: '#2979ff' }}, // Price on Right
-            leftPriceScale: {{ visible: true, borderColor: '#ffeb3b' }},  // OFI on Left
+            rightPriceScale: {{ borderColor: '#222', scaleMargins: {{ top: 0.1, bottom: 0.1 }} }},
             timeScale: {{ borderColor: '#222', timeVisible: true, secondsVisible: true }},
-        }});
-
-        // Price Series (Blue, Right Axis)
-        const priceSeries = priceChart.addLineSeries({{ 
-            color: '#2979ff', lineWidth: 2, title: 'Price',
-            priceScaleId: 'right' 
-        }});
+            crosshair: {{ mode: 1, vertLine: {{ color: '#444', labelBackgroundColor: '#444' }}, horzLine: {{ color: '#444', labelBackgroundColor: '#444' }} }}
+        }};
 
-        // OFI Series (Yellow, Left Axis)
-        const ofiSeries = priceChart.addLineSeries({{ 
-            color: '#ffeb3b', lineWidth: 2, title: 'Cumulative OFI',
-            priceScaleId: 'left',
-            lastValueVisible: true
-        }});
+        const priceChart = LightweightCharts.createChart(document.getElementById('tv-price'), chartOpts);
+        
+        const polrLines = [];
+        const polrCount = 60; 
+        
+        for(let i=0; i<polrCount; i++) {{
+            const opacity = 1.0 - (i / (polrCount + 5)); 
+            const color = `rgba(213, 0, 249, ${{opacity.toFixed(2)}})`; 
+            
+            polrLines.push(
+                priceChart.addLineSeries({{
+                    color: color,
+                    lineWidth: 1,
+                    crosshairMarkerVisible: false,
+                    lastValueVisible: false,
+                    priceLineVisible: false,
+                    title: '' 
+                }})
+            );
+        }}
 
-        // --- CANDLE CHART ---
+        const priceSeries = priceChart.addLineSeries({{ color: '#2979ff', lineWidth: 2, title: 'Price' }}); 
+        const predSeries = priceChart.addLineSeries({{ color: '#ffeb3b', lineWidth: 2, lineStyle: 2, title: 'Micro-Structure' }});
+        const mlSeries = priceChart.addLineSeries({{ color: '#00bcd4', lineWidth: 2, lineStyle: 0, title: 'ML Forecast' }});
+        
         const candleChart = LightweightCharts.createChart(document.getElementById('tv-candles'), {{
-            layout: {{ background: {{ type: 'solid', color: '#0a0a0a' }}, textColor: '#888', fontFamily: 'JetBrains Mono' }},
-            grid: {{ vertLines: {{ color: '#151515' }}, horzLines: {{ color: '#151515' }} }},
-            timeScale: {{ timeVisible: true, secondsVisible: false }},
+            ...chartOpts, 
+            timeScale: {{ timeVisible: true, secondsVisible: false }}
         }});
         const candleSeries = candleChart.addCandlestickSeries({{ 
             upColor: '#00ff9d', downColor: '#ff3b3b', borderVisible: false, wickUpColor: '#00ff9d', wickDownColor: '#ff3b3b' 
         }});
 
-        // --- VOLUME CHART ---
+        const netChart = LightweightCharts.createChart(document.getElementById('tv-net'), {{
+            ...chartOpts, localization: {{ timeFormatter: t => '$' + t.toFixed(2) }}
+        }});
+        const netSeries = netChart.addHistogramSeries({{ color: '#2979ff' }});
+
         const volChart = LightweightCharts.createChart(document.getElementById('sidebar-vol'), {{
-            layout: {{ background: {{ type: 'solid', color: '#0a0a0a' }}, textColor: '#888' }},
-            grid: {{ visible: false }},
+            ...chartOpts,
+            grid: {{ vertLines: {{ visible: false }}, horzLines: {{ visible: false }} }},
             rightPriceScale: {{ visible: false }},
             timeScale: {{ visible: false }},
             handleScroll: false, handleScale: false
@@ -355,13 +604,27 @@ HTML_PAGE = f"""
         const volBuySeries = volChart.addHistogramSeries({{ color: '#00ff9d' }});
         const volSellSeries = volChart.addHistogramSeries({{ color: '#ff3b3b' }});
 
-        // Resize Logic
+        const denChart = LightweightCharts.createChart(document.getElementById('sidebar-density'), {{
+            ...chartOpts,
+            grid: {{ vertLines: {{ visible: false }}, horzLines: {{ visible: false }} }},
+            rightPriceScale: {{ visible: false }},
+            timeScale: {{ visible: false }},
+            handleScroll: false, handleScale: false
+        }});
+        const bidSeries = denChart.addAreaSeries({{ lineColor: '#00ff9d', topColor: 'rgba(0, 255, 157, 0.15)', bottomColor: 'rgba(0,0,0,0)', lineWidth: 1 }});
+        const askSeries = denChart.addAreaSeries({{ lineColor: '#ff3b3b', topColor: 'rgba(255, 59, 59, 0.15)', bottomColor: 'rgba(0,0,0,0)', lineWidth: 1 }});
+
+        let activeLines = [];
+        let activeCandleLines = [];
+
         new ResizeObserver(entries => {{
             for(let entry of entries) {{
                 const {{width, height}} = entry.contentRect;
                 if(entry.target.id === 'tv-price') priceChart.applyOptions({{width, height}});
                 if(entry.target.id === 'tv-candles') candleChart.applyOptions({{width, height}});
+                if(entry.target.id === 'tv-net') netChart.applyOptions({{width, height}});
                 if(entry.target.id === 'sidebar-vol') volChart.applyOptions({{width, height}});
+                if(entry.target.id === 'sidebar-density') denChart.applyOptions({{width, height}});
             }}
         }}).observe(document.body);
 
@@ -372,38 +635,86 @@ HTML_PAGE = f"""
                 const data = JSON.parse(e.data);
                 if (data.error) return;
 
-                // 1. Update Price
                 if (data.history.length) {{
                     const hist = data.history.map(d => ({{ time: Math.floor(d.t), value: d.p }}));
-                    const uniqueHist = [...new Map(hist.map(i => [i.time, i])).values()];
-                    priceSeries.setData(uniqueHist);
+                    const cleanHist = [...new Map(hist.map(i => [i.time, i])).values()];
+                    priceSeries.setData(cleanHist);
 
-                    const lastP = uniqueHist[uniqueHist.length-1].value;
+                    const lastP = cleanHist[cleanHist.length-1].value;
+                    const lastTime = cleanHist[cleanHist.length-1].time;
                     dom.ticker.innerText = lastP.toLocaleString('en-US', {{ minimumFractionDigits: 2 }});
-                }}
-
-                // 2. Update OFI
-                if (data.ofi.length) {{
-                    const ofiData = data.ofi.map(d => ({{ time: Math.floor(d.t), value: d.v }}));
-                    const uniqueOfi = [...new Map(ofiData.map(i => [i.time, i])).values()];
-                    ofiSeries.setData(uniqueOfi);
 
-                    // Update Sidebar Value
-                    const lastOfi = data.stats.ofi_val;
-                    dom.ofiVal.innerText = lastOfi.toLocaleString('en-US', {{ minimumFractionDigits: 0 }});
-                    dom.ofiVal.style.color = lastOfi >= 0 ? 'var(--yellow)' : 'var(--text-dim)';
+                    if (data.analysis) {{
+                        const proj = data.analysis.projected;
+                        const rho = data.analysis.rho; 
+                        predSeries.setData([
+                            cleanHist[cleanHist.length-1],
+                            {{ time: lastTime + 60, value: proj }}
+                        ]);
+                        const pct = ((proj - lastP) / lastP) * 100;
+                        const sign = pct >= 0 ? "+" : "";
+                        dom.projPct.innerText = `${{sign}}${{pct.toFixed(4)}}%`;
+                        dom.projPct.style.color = pct >= 0 ? "var(--green)" : "var(--red)";
+                        dom.projVal.innerText = proj.toLocaleString('en-US', {{ minimumFractionDigits: 2 }});
+                        dom.score.innerText = rho.toFixed(3);
+                        dom.score.style.color = rho > 0 ? "var(--green)" : (rho < 0 ? "var(--red)" : "var(--text-main)");
+                    }}
+                    
+                    if (data.ml_history && data.ml_history.length) {{
+                         const mlLast = data.ml_history[data.ml_history.length-1];
+                         dom.mlVal.innerText = mlLast.p.toLocaleString('en-US', {{ minimumFractionDigits: 2 }});
+                         
+                         mlSeries.setData([
+                            cleanHist[cleanHist.length-1],
+                            {{ time: lastTime + 30, value: mlLast.p }}
+                         ]);
+                    }}
+
+                    if (data.polr && data.polr.length) {{
+                        data.polr.forEach((point, index) => {{
+                            if (index < polrLines.length) {{
+                                polrLines[index].update({{
+                                    time: lastTime, 
+                                    value: point.p
+                                }});
+                            }}
+                        }});
+                    }}
                 }}
 
-                // 3. Update Candles
-                if (data.ohlc.length) {{
+                if (data.ohlc && data.ohlc.length) {{
                     const candles = data.ohlc.map(c => ({{
-                        time: c.time, open: c.open, high: c.high, low: c.low, close: c.close
+                        time: c.time,
+                        open: c.open,
+                        high: c.high,
+                        low: c.low,
+                        close: c.close
                     }}));
                     const uniqueCandles = [...new Map(candles.map(i => [i.time, i])).values()];
                     candleSeries.setData(uniqueCandles);
                 }}
 
-                // 4. Update Volume
+                if (data.walls) {{
+                    activeLines.forEach(l => priceSeries.removePriceLine(l));
+                    activeLines = [];
+                    activeCandleLines.forEach(l => candleSeries.removePriceLine(l));
+                    activeCandleLines = [];
+                    
+                    let html = "";
+                    const addWall = (w, type) => {{
+                        const color = type === 'BID' ? '#00ff9d' : '#ff3b3b';
+                        const lineOpts = {{ price: w.price, color: color, lineWidth: 1, lineStyle: 2, axisLabelVisible: false }};
+                        
+                        activeLines.push(priceSeries.createPriceLine(lineOpts));
+                        activeCandleLines.push(candleSeries.createPriceLine(lineOpts));
+                        
+                        html += `<div class="list-item"><span style="color:${{color}}">${{type}} ${{w.price}}</span><span class="c-dim">Z:${{w.z_score.toFixed(1)}}</span></div>`;
+                    }};
+                    data.walls.asks.forEach(w => addWall(w, 'ASK'));
+                    data.walls.bids.forEach(w => addWall(w, 'BID'));
+                    dom.wallList.innerHTML = html || '<span class="c-dim" style="font-size:11px">Scanning...</span>';
+                }}
+
                 if (data.trade_history && data.trade_history.length) {{
                     const buyData = [], sellData = [];
                     data.trade_history.forEach(t => {{
@@ -414,6 +725,19 @@ HTML_PAGE = f"""
                     volBuySeries.setData([...new Map(buyData.map(i => [i.time, i])).values()]);
                     volSellSeries.setData([...new Map(sellData.map(i => [i.time, i])).values()]);
                 }}
+
+                if (data.depth_x.length) {{
+                    const bids = [], asks = [], nets = [];
+                    for(let i=0; i<data.depth_x.length; i++) {{
+                        const t = data.depth_x[i];
+                        bids.push({{ time: t, value: data.depth_bids[i] }});
+                        asks.push({{ time: t, value: data.depth_asks[i] }});
+                        nets.push({{ time: t, value: data.depth_net[i], color: data.depth_net[i] > 0 ? '#00ff9d' : '#ff3b3b' }});
+                    }}
+                    bidSeries.setData(bids);
+                    askSeries.setData(asks);
+                    netSeries.setData(nets);
+                }}
             }};
             ws.onclose = () => setTimeout(connect, 2000);
         }}
@@ -426,8 +750,6 @@ HTML_PAGE = f"""
 
 async def kraken_worker():
     global market_state
-    
-    # 1. Fetch History
     try:
         async with aiohttp.ClientSession() as session:
             url = "https://api.kraken.com/0/public/OHLC?pair=XBTUSD&interval=1"
@@ -452,16 +774,14 @@ async def kraken_worker():
     except Exception as e:
         logging.error(f"History fetch failed: {e}")
 
-    # 2. Real-time Connection
     while True:
         try:
             async with websockets.connect("wss://ws.kraken.com/v2") as ws:
                 logging.info(f"🔌 Connected to Kraken ({SYMBOL_KRAKEN})")
                 
-                # Subscribe to Book (Level 1 is actually enough for CKS, but we take more for vol check)
                 await ws.send(json.dumps({
                     "method": "subscribe",
-                    "params": {"channel": "book", "symbol": [SYMBOL_KRAKEN], "depth": 10}
+                    "params": {"channel": "book", "symbol": [SYMBOL_KRAKEN], "depth": 500}
                 }))
                 await ws.send(json.dumps({
                     "method": "subscribe",
@@ -478,7 +798,6 @@ async def kraken_worker():
                     data = payload.get("data", [])
 
                     if channel == "book":
-                        # Standard Book Maintenance
                         for item in data:
                             for bid in item.get('bids', []):
                                 q, p = float(bid['qty']), float(bid['price'])
@@ -490,7 +809,18 @@ async def kraken_worker():
                                 else: market_state['asks'][p] = q
                         
                         if market_state['bids'] and market_state['asks']:
+                            market_state['prev_mid'] = market_state['current_mid']
+                            best_bid = max(market_state['bids'].keys())
+                            best_ask = min(market_state['asks'].keys())
+                            mid = (best_bid + best_ask) / 2
+                            market_state['current_mid'] = mid
                             market_state['ready'] = True
+                            
+                            now = time.time()
+                            if not market_state['history'] or (now - market_state['history'][-1]['t'] > 0.5):
+                                market_state['history'].append({'t': now, 'p': mid})
+                                if len(market_state['history']) > HISTORY_LENGTH:
+                                    market_state['history'].pop(0)
                     
                     elif channel == "trade":
                         for trade in data:
@@ -499,20 +829,27 @@ async def kraken_worker():
                                 price = float(trade['price'])
                                 side = trade['side']
                                 
-                                # Vol Accumulation
                                 if side == 'buy': market_state['current_vol_window']['buy'] += qty
                                 else: market_state['current_vol_window']['sell'] += qty
 
-                                # Live Candle Logic
                                 current_minute_start = int(time.time()) // 60 * 60
+                                
                                 if market_state['ohlc_history']:
                                     last_candle = market_state['ohlc_history'][-1]
+                                    
                                     if last_candle['time'] == current_minute_start:
                                         last_candle['close'] = price
                                         if price > last_candle['high']: last_candle['high'] = price
                                         if price < last_candle['low']: last_candle['low'] = price
+                                    
                                     elif current_minute_start > last_candle['time']:
-                                        new_candle = {'time': current_minute_start, 'open': price, 'high': price, 'low': price, 'close': price}
+                                        new_candle = {
+                                            'time': current_minute_start,
+                                            'open': price,
+                                            'high': price,
+                                            'low': price,
+                                            'close': price
+                                        }
                                         market_state['ohlc_history'].append(new_candle)
                                         if len(market_state['ohlc_history']) > 200:
                                             market_state['ohlc_history'].pop(0)
@@ -529,6 +866,7 @@ async def kraken_worker():
                                     'low': float(candle['low']),
                                     'close': float(candle['close'])
                                 }
+                                
                                 if market_state['ohlc_history']:
                                     if market_state['ohlc_history'][-1]['time'] == start_time:
                                         market_state['ohlc_history'][-1] = c_data
@@ -536,7 +874,8 @@ async def kraken_worker():
                                         market_state['ohlc_history'].append(c_data)
                                         if len(market_state['ohlc_history']) > 200:
                                             market_state['ohlc_history'].pop(0)
-                            except: pass
+                            except Exception as e:
+                                pass
 
         except Exception as e:
             logging.warning(f"⚠️ Reconnecting: {e}")
@@ -586,7 +925,7 @@ async def main():
     await runner.setup()
     site = web.TCPSite(runner, '0.0.0.0', PORT)
     await site.start()
-    print(f"🚀 Quant OFI Dashboard: http://localhost:{PORT}")
+    print(f"🚀 Quant Dashboard: http://localhost:{PORT}")
     await asyncio.Event().wait()
 
 if __name__ == "__main__":