"""Stato SHADOW di TP01 (Deribit mainnet, SOLA LETTURA): target causali + conto/posizioni REALI + ordini di ribilancio COSTRUITI (mai inviati). Modulo condiviso da `scripts/live/live_trend.py` (CLI) e dalla dashboard, cosi' i due non divergono. Robusto ai fallimenti di rete: degrada a offline/flat senza sollevare eccezioni (la dashboard non deve crashare se il mainnet non risponde).""" from __future__ import annotations import json from pathlib import Path import numpy as np import pandas as pd from src.backtest.harness import load from src.live.deribit import INSTRUMENT, DeribitRead, build_rebalance_order from src.strategies.trend_portfolio import CANONICAL, TrendPortfolio, resample_1d PROJECT_ROOT = Path(__file__).resolve().parents[2] ASSETS = ["BTC", "ETH"] WEIGHT = 0.5 FALLBACK_CAPITAL = 2000.0 PAPER_STATE = PROJECT_ROOT / "data" / "paper_trend" / "state.json" def tp01_trades(limit: int = 15) -> list[dict]: """Lista dei TRADE di TP01 = cambi di posizione (ENTRY long / EXIT flat) dedotti dal segnale causale `target_series` sui dati certificati. Account-independent (gira anche offline nel container). Si ricalcola a ogni render -> include sia lo storico sia i trade forward man mano che arrivano. Ritorna gli ultimi `limit` (piu' recenti primi).""" tp = TrendPortfolio(**CANONICAL) out: list[dict] = [] for a in ASSETS: df = resample_1d(load(a, "1h")) c = df["close"].to_numpy(dtype=float) dt = pd.to_datetime(df["datetime"]).to_numpy() tgt = tp.target_series(df) prev = 0.0 for i in range(len(tgt)): if np.sign(tgt[i]) != np.sign(prev): out.append(dict( ts=int(pd.Timestamp(dt[i]).value // 10**6), date=str(pd.Timestamp(dt[i]).date()), asset=a, action="ENTRY" if tgt[i] != 0 else "EXIT", from_pos=round(float(prev), 3), to_pos=round(float(tgt[i]), 3), price=round(float(c[i]), 1), )) prev = tgt[i] out.sort(key=lambda r: r["ts"], reverse=True) return out[:limit] def _safe_client() -> DeribitRead | None: try: return DeribitRead() except Exception: return None def _marks(client, dfs): marks, src = {}, {} for a in ASSETS: if client is None: marks[a], src[a] = float(dfs[a]["close"].iloc[-1]), "close certificata" continue try: marks[a], src[a] = client.mark_price(INSTRUMENT[a]), "mainnet" except Exception as e: marks[a], src[a] = float(dfs[a]["close"].iloc[-1]), f"fallback close ({type(e).__name__})" return marks, src def _positions(client): if client is None: return {a: 0.0 for a in ASSETS}, "offline -> assunto flat" pos, note = {}, "mainnet" for a in ASSETS: try: pos[a] = client.position_usd(INSTRUMENT[a]) except Exception as e: pos[a], note = 0.0, f"read fallito ({type(e).__name__}) -> assunto flat" return pos, note def _equity(client, marks): if client is None: return None, "offline" try: eq = float(client.account_summary("USDC").get("equity") or 0) if eq > 1: return eq, "mainnet USDC" except Exception: pass tot, any_ok = 0.0, False for a in ASSETS: try: eq = float(client.account_summary(a).get("equity") or 0) tot += eq * marks[a] any_ok = True except Exception: pass if any_ok and tot > 1: return tot, "mainnet coin-margined" return None, "conto flat / non finanziato" def shadow_report(offline: bool = False, equity_override: float | None = None) -> dict: """Calcola lo stato shadow completo. NON invia nulla. Ritorna un dict serializzabile.""" dfs = {a: resample_1d(load(a, "1h")) for a in ASSETS} tp = TrendPortfolio(**CANONICAL) targets = {a: tp.current_target(dfs[a]) for a in ASSETS} last_ts = min(int(dfs[a]["timestamp"].iloc[-1]) for a in ASSETS) client = None if offline else _safe_client() marks, marks_src = _marks(client, dfs) positions, pos_src = _positions(client) real_eq, eq_src = _equity(client, marks) paper = json.loads(PAPER_STATE.read_text()) if PAPER_STATE.exists() else None paper_cap = float(paper["capital"]) if paper else FALLBACK_CAPITAL paper_pos = paper.get("positions") if paper else None paper_ts = int(paper["last_ts"]) if paper else 0 equity = equity_override if equity_override is not None else (real_eq if real_eq else paper_cap) eq_basis = ("override" if equity_override is not None else eq_src if real_eq else "paper capital (ipotetico: conto non finanziato)") assets, orders = [], [] for a in ASSETS: inst = INSTRUMENT[a] order = build_rebalance_order(inst, targets[a], WEIGHT, equity, positions[a], price=marks[a]) if order: orders.append(order) parity = None if paper_pos is not None: parity = abs(float(paper_pos.get(a, 0.0)) - targets[a]) < 1e-9 assets.append(dict( asset=a, instrument=inst, target=targets[a], target_notional=WEIGHT * targets[a] * equity, position_usd=positions[a], mark=marks[a], mark_src=marks_src[a], order=order, paper=(float(paper_pos.get(a, 0.0)) if paper_pos else None), parity=parity, )) live_trades = [] if client is not None: for a in ASSETS: try: for tr in client.trade_history(INSTRUMENT[a], limit=8): live_trades.append(dict( ts=int(tr.get("timestamp") or 0), instrument=INSTRUMENT[a], direction=(tr.get("direction") or "").upper(), amount=float(tr.get("amount") or 0), price=float(tr.get("price") or 0), fee=float(tr.get("fee") or 0))) except Exception: pass live_trades.sort(key=lambda r: r["ts"], reverse=True) live_trades = live_trades[:12] return dict( last_data=str(pd.Timestamp(last_ts, unit="ms", tz="UTC").date()), online=(client is not None and marks_src.get("BTC") == "mainnet"), real_equity=real_eq, equity=equity, eq_basis=eq_basis, pos_src=pos_src, assets=assets, orders=orders, live_trades=live_trades, flat=all(abs(targets[a]) < 1e-9 for a in ASSETS), paper_aligned=(paper_ts == last_ts), )