Update app.py

app.py

@@ -2,34 +2,22 @@ import asyncio
 import json
 import logging
 import time
-import bisect
 import math
-import statistics
 import aiohttp
 from collections import deque
 from aiohttp import web
 import websockets
+import statistics
 
 SYMBOL_KRAKEN = "BTC/USD"
 PORT = 7860
 HISTORY_LENGTH = 300 
 BROADCAST_RATE = 0.1
-
-# --- MATH CONSTANTS ---
-# DECAY for Micro-Price weights (focus on near-price liquidity)
 MICROPRICE_DECAY = 0.05 
-# Lookback for VWAP and Volatility
-WINDOW_SIZE = 60 
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
 
-# --- MATHEMATICAL HELPERS ---
-
 class OnlineStats:
-    """
-    Welford's Online Algorithm for calculating Mean and Variance 
-    in a single pass (O(1) complexity).
-    """
     def __init__(self):
         self.count = 0
         self.mean = 0.0
@@ -52,17 +40,12 @@ class OnlineStats:
         return math.sqrt(self.variance)
 
 class KalmanVelocity:
-    """
-    Kalman Filter specifically tuned for tracking Velocity (Trend)
-    rather than Position.
-    Model: Constant Velocity
-    """
     def __init__(self, R=0.001, Q=0.0001):
-        self.z = 0.0 # Position
-        self.v = 0.0 # Velocity
-        self.P = 1.0 # Covariance
-        self.R = R   # Measurement Noise
-        self.Q = Q   # Process Noise
+        self.z = 0.0 
+        self.v = 0.0 
+        self.P = 1.0 
+        self.R = R   
+        self.Q = Q   
         self.last_ts = time.time()
 
     def update(self, price):
@@ -71,48 +54,56 @@ class KalmanVelocity:
         self.last_ts = now
         if dt <= 0: return
 
-        # Predict
         pred_z = self.z + self.v * dt
         pred_v = self.v
         p_cov = self.P + self.Q
 
-        # Update
-        y = price - pred_z # Residual
-        K = p_cov / (p_cov + self.R) # Kalman Gain
+        y = price - pred_z 
+        K = p_cov / (p_cov + self.R) 
         
         self.z = pred_z + K * y
-        # Velocity update derived from residual
         self.v = pred_v + (K / dt) * y 
         self.P = (1 - K) * p_cov
 
-# --- STATE MANAGEMENT ---
-
 market_state = {
     "bids": {},
     "asks": {},
     "history": [], 
-    "trade_history": deque(maxlen=2000), # Store recent trades for VWAP
+    "trade_history": deque(maxlen=2000), 
     "ohlc_history": [], 
     "current_vol_window": {"buy": 0.0, "sell": 0.0, "start": time.time()},
     "current_mid": 0.0,
     "ready": False,
     "kalman": KalmanVelocity(),
-    "stats": OnlineStats(), # Online Volatility Tracker
-    "vwap_numerator": 0.0,
-    "vwap_denominator": 0.0
+    "stats": OnlineStats(), 
+    "walls": {"bids": [], "asks": []}
 }
 
 connected_clients = set()
 
-# --- CORE MATH LOGIC ---
+def detect_walls(order_book, side_name):
+    if not order_book: return []
+    
+    sorted_book = sorted(order_book.items(), key=lambda x: x[0], reverse=(side_name == 'bids'))
+    relevant = sorted_book[:50]
+    
+    volumes = [q for p, q in relevant]
+    if not volumes: return []
+    
+    avg_vol = statistics.mean(volumes)
+    std_vol = statistics.stdev(volumes) if len(volumes) > 1 else 0
+    
+    walls = []
+    for p, q in relevant:
+        if std_vol > 0:
+            z = (q - avg_vol) / std_vol
+            if z > 2.5:
+                walls.append({'p': p, 'q': q, 'z': z})
+    
+    return walls[:3]
 
 def calculate_weighted_micro_price(mid_price):
-    """
-    Calculates the 'Micro-Price' (Stoikov).
-    The mid-price is adjusted by the imbalance of liquidity 
-    weighted by distance from the mid.
-    """
-    bids = sorted(market_state['bids'].items(), reverse=True)[:50] # Top 50 levels
+    bids = sorted(market_state['bids'].items(), reverse=True)[:50] 
     asks = sorted(market_state['asks'].items())[:50]
 
     if not bids or not asks: return mid_price
@@ -120,9 +111,7 @@ def calculate_weighted_micro_price(mid_price):
     sum_wb = 0.0
     sum_wa = 0.0
     
-    # Calculate Volume-Weighted Imbalance
     for p, q in bids:
-        # Weight decays exponentially as distance from mid increases
         distance = abs(mid_price - p)
         weight = q * math.exp(-MICROPRICE_DECAY * distance)
         sum_wb += weight
@@ -135,23 +124,16 @@ def calculate_weighted_micro_price(mid_price):
     total_w = sum_wb + sum_wa
     if total_w == 0: return mid_price
 
-    # Imbalance Ratio
     imbalance = (sum_wb - sum_wa) / total_w
-    
-    # Adjust spread based on imbalance
     spread = asks[0][0] - bids[0][0]
-    
-    # Formula: MicroPrice = Mid + (Imbalance * (Spread / 2))
     micro_price = mid_price + (imbalance * (spread / 2))
     return micro_price
 
 def calculate_vwap_1m():
-    """Calculates Volume Weighted Average Price over the last 60 seconds."""
     cutoff = time.time() - 60
     v_sum = 0.0
     pv_sum = 0.0
     
-    # Iterate trades in reverse (newest first)
     for trade in reversed(market_state['trade_history']):
         if trade['t'] < cutoff: break
         pv_sum += trade['p'] * trade['q']
@@ -160,13 +142,7 @@ def calculate_vwap_1m():
     return pv_sum / v_sum if v_sum > 0 else market_state['current_mid']
 
 def calculate_kyle_lambda(volatility, volume_window):
-    """
-    Kyle's Lambda: A measure of market impact (Liquidity Cost).
-    Lambda ~ sigma / Volume
-    Quantifies how much price moves per $1 of order flow.
-    """
     if volume_window <= 0: return 0
-    # Scaling factor (heuristic normalization for BTC/USD typical volumes)
     return (volatility * 1000) / (math.sqrt(volume_window) + 1)
 
 def process_market_data():
@@ -175,19 +151,15 @@ def process_market_data():
     mid = market_state['current_mid']
     now = time.time()
 
-    # 1. Update Volatility Stats (Welford)
     market_state['stats'].update(mid)
     volatility = market_state['stats'].std_dev
-    if volatility == 0: volatility = 1.0 # fallback
+    if volatility == 0: volatility = 1.0 
 
-    # 2. Update Kalman Filter (Velocity Trend)
     market_state['kalman'].update(mid)
     
-    # 3. Calculate Micro-Structure Features
     micro_price = calculate_weighted_micro_price(mid)
     vwap = calculate_vwap_1m()
     
-    # 4. Calculate Order Flow Imbalance (OFI) - Last 10 seconds
     ofi_buy = 0.0
     ofi_sell = 0.0
     ofi_window = 10.0
@@ -200,36 +172,19 @@ def process_market_data():
     net_ofi = ofi_buy - ofi_sell
     total_vol_10s = ofi_buy + ofi_sell
     
-    # 5. PREDICTION ENGINE (The Math Part)
-    
-    # A. Kyle's Impact Term
-    # How much should the price move based on recent net buying/selling?
-    # Impact = Net_Volume * Lambda
     k_lambda = calculate_kyle_lambda(volatility, total_vol_10s)
     impact_term = net_ofi * k_lambda
 
-    # B. Mean Reversion Term (Ornstein-Uhlenbeck proxy)
-    # Prices tend to revert to VWAP in the short term.
-    # Pull = (VWAP - Price) * alpha
-    mean_reversion_alpha = 0.1 # Reversion strength coefficient
+    mean_reversion_alpha = 0.1 
     reversion_term = (vwap - mid) * mean_reversion_alpha
 
-    # C. Micro-Price Alpha
-    # The divergence between MicroPrice and MidPrice predicts immediate tick direction.
-    micro_alpha = (micro_price - mid) * 0.8 # 0.8 is a sensitivity weight
+    micro_alpha = (micro_price - mid) * 0.8 
 
-    # D. Trend Term (Kalman)
-    # Project current velocity 60 seconds out
     trend_term = market_state['kalman'].v * 60.0
 
-    # TOTAL PREDICTED CHANGE (Delta)
-    # We combine Market Impact (OFI), Micro-structure pressure (MP), Trend, and Mean Reversion.
     predicted_delta = impact_term + micro_alpha + trend_term + reversion_term
-    
     pred_close = mid + predicted_delta
 
-    # Calculate Confidence Interval (2 Sigma) for the ghost candle
-    # Volatility scales with square root of time
     sigma_1m = volatility * math.sqrt(60) 
     
     pred_candle = {
@@ -240,31 +195,17 @@ def process_market_data():
         'low': min(mid, pred_close) - (2 * sigma_1m)
     }
 
-    # Data management for charts
     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)
 
-    # Calculate Depth Chart Arrays
-    bids = sorted(market_state['bids'].items(), reverse=True)[:100]
-    asks = sorted(market_state['asks'].items())[:100]
-    depth_x, depth_net, depth_bids, depth_asks = [], [], [], []
-    
-    if bids and asks:
-        center_price = mid
-        for i in range(min(len(bids), len(asks))):
-            dist = (asks[i][0] - bids[i][0]) / 2
-            p_level = dist 
-            depth_x.append(p_level)
-            depth_bids.append(bids[i][1])
-            depth_asks.append(asks[i][1])
-            depth_net.append(bids[i][1] - asks[i][1])
-
-    # Analysis Object for Frontend
+    bid_walls = detect_walls(market_state['bids'], 'bids')
+    ask_walls = detect_walls(market_state['asks'], 'asks')
+
     analysis = {
         "projected": pred_close,
-        "rho": (micro_price - mid), # Storing MP divergence as 'rho'
+        "rho": (micro_price - mid), 
         "vwap": vwap,
         "lambda": k_lambda
     }
@@ -273,17 +214,11 @@ def process_market_data():
         "mid": mid,
         "history": market_state['history'],
         "ohlc": market_state['ohlc_history'],
-        "trade_history": [], # Reduced payload, handled by client cumulative logic
         "pred_candle": pred_candle,
-        "depth_x": depth_x,
-        "depth_net": depth_net,
-        "depth_bids": depth_bids,
-        "depth_asks": depth_asks,
         "analysis": analysis,
-        "walls": {"bids": [], "asks": []} # Removed legacy walls for cleaner math view
+        "walls": {"bids": bid_walls, "asks": ask_walls}
     }
 
-# --- HTML FRONTEND (Unchanged visual structure, updated data mapping) ---
 HTML_PAGE = f"""
 <!DOCTYPE html>
 <html lang="en">
@@ -323,7 +258,7 @@ HTML_PAGE = f"""
             <div id="tv-price" style="flex: 1;"></div>
         </div>
         <div id="p-bottom" class="panel">
-            <div class="chart-header">1M KLINE + GHOST PREDICTION (PURPLE)</div>
+            <div class="chart-header">1M KLINE + WALLS + GHOST PREDICTION (PURPLE)</div>
             <div id="tv-candles" style="flex: 1;"></div>
         </div>
         <div id="p-sidebar" class="panel">
@@ -361,7 +296,14 @@ HTML_PAGE = f"""
         const candleSeries = candleChart.addCandlestickSeries({{ upColor: '#00ff9d', downColor: '#ff3b3b', borderVisible: false }});
         const ghostSeries = candleChart.addCandlestickSeries({{ upColor: 'rgba(213, 0, 249, 0.5)', downColor: 'rgba(213, 0, 249, 0.5)', borderVisible: true, borderColor: '#d500f9' }});
 
-        new ResizeObserver(e => {{ priceChart.timeScale().fitContent(); }}).observe(document.body);
+        let activeWallLines = [];
+
+        new ResizeObserver(e => {{ 
+            const t1 = document.getElementById('tv-price');
+            const t2 = document.getElementById('tv-candles');
+            priceChart.applyOptions({{ width: t1.clientWidth, height: t1.clientHeight }});
+            candleChart.applyOptions({{ width: t2.clientWidth, height: t2.clientHeight }});
+        }}).observe(document.body);
 
         function connect() {{
             const ws = new WebSocket((location.protocol === 'https:' ? 'wss' : 'ws') + '://' + location.host + '/ws');
@@ -376,23 +318,20 @@ HTML_PAGE = f"""
                     dom.ticker.innerText = cleanHist[cleanHist.length-1].value.toFixed(2);
                     
                     if(data.analysis) {{
-                         // Plot Prediction Line
                          predSeries.setData([
                             cleanHist[cleanHist.length-1],
                             {{ time: cleanHist[cleanHist.length-1].time + 60, value: data.analysis.projected }}
                          ]);
                          
-                         // Plot VWAP Line (simple point for now)
                          vwapSeries.setData([
                             {{ time: cleanHist[0].time, value: data.analysis.vwap }},
                             {{ time: cleanHist[cleanHist.length-1].time, value: data.analysis.vwap }}
                          ]);
 
-                         // Update Sidebar
-                         dom.lambdaVal.innerText = (data.analysis.lambda * 1000).toFixed(4); // Scaled for display
+                         dom.lambdaVal.innerText = (data.analysis.lambda * 1000).toFixed(4); 
                          const vwapDiff = cleanHist[cleanHist.length-1].value - data.analysis.vwap;
                          dom.vwapDiv.innerText = vwapDiff.toFixed(2);
-                         dom.vwapDiv.style.color = vwapDiff > 0 ? '#ff3b3b' : '#00ff9d'; // Red if price > vwap (overbought)
+                         dom.vwapDiv.style.color = vwapDiff > 0 ? '#ff3b3b' : '#00ff9d'; 
                     }}
                 }}
 
@@ -400,6 +339,17 @@ HTML_PAGE = f"""
                     candleSeries.setData(data.ohlc.map(c => ({{ time: c.time, open: c.open, high: c.high, low: c.low, close: c.close }})));
                 }}
 
+                if (data.walls) {{
+                    activeWallLines.forEach(l => candleSeries.removePriceLine(l));
+                    activeWallLines = [];
+                    data.walls.bids.forEach(w => {{
+                        activeWallLines.push(candleSeries.createPriceLine({{ price: w.p, color: '#00ff9d', lineWidth: 2, lineStyle: 2, axisLabelVisible: true, title: 'BID WALL' }}));
+                    }});
+                    data.walls.asks.forEach(w => {{
+                        activeWallLines.push(candleSeries.createPriceLine({{ price: w.p, color: '#ff3b3b', lineWidth: 2, lineStyle: 2, axisLabelVisible: true, title: 'ASK WALL' }}));
+                    }});
+                }}
+
                 if (data.pred_candle) {{
                     ghostSeries.setData([data.pred_candle]);
                     const currentP = parseFloat(dom.ticker.innerText);
@@ -420,8 +370,6 @@ HTML_PAGE = f"""
 
 async def kraken_worker():
     global market_state
-    
-    # Initial fetch for OHLC
     try:
         async with aiohttp.ClientSession() as session:
             url = "https://api.kraken.com/0/public/OHLC?pair=XBTUSD&interval=1"
@@ -429,7 +377,6 @@ async def kraken_worker():
                 if response.status == 200:
                     data = await response.json()
                     if 'result' in data:
-                        # Extract OHLC
                         raw = list(data['result'].values())[0]
                         market_state['ohlc_history'] = [
                             {'time': int(c[0]), 'open': float(c[1]), 'high': float(c[2]), 'low': float(c[3]), 'close': float(c[4])}
@@ -441,7 +388,7 @@ async def kraken_worker():
     while True:
         try:
             async with websockets.connect("wss://ws.kraken.com/v2") as ws:
-                logging.info(f"🔌 Connected to Kraken ({SYMBOL_KRAKEN})")
+                logging.info(f"Connected to Kraken ({SYMBOL_KRAKEN})")
                 
                 await ws.send(json.dumps({"method": "subscribe", "params": {"channel": "book", "symbol": [SYMBOL_KRAKEN], "depth": 100}}))
                 await ws.send(json.dumps({"method": "subscribe", "params": {"channel": "trade", "symbol": [SYMBOL_KRAKEN]}}))
@@ -459,7 +406,6 @@ async def kraken_worker():
                             for ask in item.get('asks', []):
                                 market_state['asks'][float(ask['price'])] = float(ask['qty'])
                         
-                        # Cleanup zero qty
                         market_state['bids'] = {k: v for k, v in market_state['bids'].items() if v > 0}
                         market_state['asks'] = {k: v for k, v in market_state['asks'].items() if v > 0}
 
@@ -482,7 +428,6 @@ async def kraken_worker():
                             except: pass
 
                     elif channel == "ohlc":
-                        # Update OHLC array
                         for c in data:
                             c_data = {
                                 'time': int(float(c['endtime'])), 
@@ -541,7 +486,7 @@ async def main():
     await runner.setup()
     site = web.TCPSite(runner, '0.0.0.0', PORT)
     await site.start()
-    print(f"🚀 Quant Dashboard: http://localhost:{PORT}")
+    print(f"Quant Dashboard: http://localhost:{PORT}")
     await asyncio.Event().wait()
 
 if __name__ == "__main__":