paper_portfolio.py)"
+ sh = d.get("shadow")
+ if sh and "error" not in sh:
+ bits = " · ".join(
+ f"{a['asset']} {'FLAT' if abs(a['target'])<1e-9 else 'LONG' if a['target']>0 else 'SHORT'} "
+ f"{a['target']:+.2f}x" for a in sh["assets"])
+ if sh.get("online"):
+ eq = f"${sh['real_equity']:,.2f}" if sh.get("real_equity") else sh.get("eq_basis", "?")
+ pos = ", ".join(f"{a['asset']} ${a['position_usd']:,.0f}" for a in sh["assets"])
+ ordtxt = ("; ".join(f"{o['side'].upper()} {o['amount']:.0f} {o['instrument']}" for o in sh["orders"])
+ if sh.get("orders") else "nessuno (target flat / gia' a target)")
+ shadow_html = (f"mainnet · sola lettura · conto reale {eq} · pos {pos} · dato {sh['last_data']}uv run python scripts/live/live_trend.py (host)")
+ else:
+ shadow_html = "non disponibile" + (f" — {sh['error']}" if sh and sh.get('error') else "")
return f"""
| sleeve | peso | FULL Sh | DD | HOLD Sh |
|---|
⚠️ Paper/monitor. XS01 e' STAT-MODE (book a 19 gambe market-neutral, non eseguibile a €2k). Storia XS ~2.5 anni.
+⚠️ Paper/monitor. XS01 e' STAT-MODE (book a 19 gambe market-neutral, non eseguibile a €2k, storia ~2.5 anni). VRP01 = lead short-vol MODELLATO (non deploy pieno). TP01 e' l'unico deployable pieno: lo "Shadow live" mostra cosa farebbe sul mainnet, ma NON invia ordini.
""" diff --git a/src/live/deribit.py b/src/live/deribit.py new file mode 100644 index 0000000..39c6414 --- /dev/null +++ b/src/live/deribit.py @@ -0,0 +1,139 @@ +"""Accesso Deribit MAINNET in SOLA LETTURA (via Cerbero MCP) + costruttore ordini deterministico. + +Serve lo SHADOW MODE di TP01 (`scripts/live/live_trend.py`): legge prezzi / conto / posizioni REALI +dal mainnet (token `.env.mainnet`) e costruisce gli ordini di ribilancio **senza inviarli**. Qui NON +esiste alcun metodo di trading — by design: l'unica via per piazzare ordini sara' un modulo separato, +abilitato esplicitamente, dopo la validazione shadow + micro-test. + +Disciplina del progetto: **testnet FUORI** (feed farlocco, causa del reset v2.0.0). Solo mainnet reale, +e in questa fase solo in lettura. I contratti sono ristretti a BTC/ETH-PERPETUAL (inverse: `amount` +in USD notional, step verificato su Deribit: BTC $10, ETH $1). +""" +from __future__ import annotations + +import os +from decimal import Decimal +from pathlib import Path + +import requests + +PROJECT_ROOT = Path(__file__).resolve().parents[2] +BASE_URL = os.environ.get("CERBERO_BASE_URL", "https://cerbero-mcp.tielogic.xyz") +TIMEOUT = 15 + +# Inverse perp: amount = USD notional, step in USD. settle = base-coin (per get_positions/fee). +_CONTRACT = { + "BTC-PERPETUAL": {"min": 10.0, "step": 10.0, "tick": 0.5, "settle": "BTC"}, + "ETH-PERPETUAL": {"min": 1.0, "step": 1.0, "tick": 0.05, "settle": "ETH"}, +} +INSTRUMENT = {"BTC": "BTC-PERPETUAL", "ETH": "ETH-PERPETUAL"} + + +# ----------------------------- costruzione ordini (pura, testabile, NIENTE rete) ----------------------------- + +def _quantize_step(value: float, step: float, mn: float) -> float: + """Arrotonda al multiplo di `step` (Decimal, niente artefatti float), clampa al minimo.""" + n = round(value / step) + return float(max(n * Decimal(str(step)), Decimal(str(mn)))) + + +def notional_to_amount(instrument: str, notional_usd: float) -> float: + """USD notional -> `amount` Deribit (inverse: amount in USD), arrotondato allo step e clampato + al minimo. Ritorna 0.0 se |notional| < mezzo step (sotto-soglia: niente ordine).""" + spec = _CONTRACT[instrument] + step, mn = spec["step"], spec["min"] + if abs(notional_usd) < step / 2: + return 0.0 + return _quantize_step(abs(notional_usd), step, mn) + + +def target_notional_usd(target_fraction: float, weight: float, equity_usd: float) -> float: + """Notional bersaglio (USD) di un asset = peso nel book * frazione-di-equity TP01 * equity. + Coerente col paper trader (esposizione asset = WEIGHT * target * equity).""" + return weight * target_fraction * equity_usd + + +def build_rebalance_order(instrument: str, target_fraction: float, weight: float, + equity_usd: float, current_pos_usd: float) -> dict | None: + """COSTRUISCE (non invia) l'ordine di ribilancio verso il target. Ritorna un dict-ordine o None + se sotto-soglia. Long-only TP01 -> target_notional >= 0; delta = target - posizione corrente.""" + tgt = target_notional_usd(target_fraction, weight, equity_usd) + delta = tgt - current_pos_usd + amount = notional_to_amount(instrument, delta) + if amount == 0.0: + return None + is_exit = abs(tgt) < 1e-9 and abs(current_pos_usd) > 0 + return dict( + instrument=instrument, + side="buy" if delta > 0 else "sell", + amount=amount, + type="market", + reduce_only=is_exit, + target_notional=round(tgt, 2), + current_notional=round(current_pos_usd, 2), + delta_notional=round(delta, 2), + ) + + +# ----------------------------- lettura mainnet (Cerbero MCP) — SOLA LETTURA ----------------------------- + +def _load_mainnet_token() -> tuple[str, str]: + """Legge CERBERO_TOKEN (mainnet) + bot-tag da .env.mainnet. Il token NON viene mai stampato.""" + env: dict[str, str] = {} + for ln in (PROJECT_ROOT / ".env.mainnet").read_text().splitlines(): + ln = ln.strip() + if ln and not ln.startswith("#") and "=" in ln: + k, v = ln.split("=", 1) + env[k] = v.strip() + if "CERBERO_TOKEN" not in env: + raise RuntimeError("CERBERO_TOKEN assente in .env.mainnet") + return env["CERBERO_TOKEN"], env.get("CERBERO_BOT_TAG", "pythagoras-shadow") + + +class DeribitRead: + """Accesso Deribit mainnet in SOLA LETTURA via Cerbero MCP. Nessun metodo di trading (by design).""" + + def __init__(self) -> None: + self._token, self._tag = _load_mainnet_token() + + def _post(self, path: str, payload: dict) -> dict | list: + r = requests.post( + f"{BASE_URL}{path}", + headers={"Authorization": f"Bearer {self._token}", "X-Bot-Tag": self._tag, + "Content-Type": "application/json"}, + json=payload, timeout=TIMEOUT, + ) + r.raise_for_status() + return r.json() + + @staticmethod + def _unwrap(resp: dict | list) -> dict | list: + return resp.get("result", resp) if isinstance(resp, dict) else resp + + def ticker(self, instrument: str) -> dict: + return self._unwrap(self._post("/mcp-deribit/tools/get_ticker", {"instrument": instrument})) or {} + + def mark_price(self, instrument: str) -> float: + t = self.ticker(instrument) + for k in ("mark_price", "index_price", "last_price", "last"): + v = t.get(k) + if v: + return float(v) + raise ValueError(f"prezzo assente nel ticker {instrument}: chiavi={list(t)[:8]}") + + def account_summary(self, currency: str) -> dict: + return self._unwrap(self._post("/mcp-deribit/tools/get_account_summary", {"currency": currency})) or {} + + def positions(self, currency: str) -> list[dict]: + out = self._unwrap(self._post("/mcp-deribit/tools/get_positions", {"currency": currency})) + if isinstance(out, list): + return out + return out.get("positions", []) if isinstance(out, dict) else [] + + def position_usd(self, instrument: str) -> float: + """Size netta (USD notional, segno = direzione) della posizione su `instrument`. 0 se flat.""" + cur = _CONTRACT[instrument]["settle"] + for p in self.positions(cur): + if p.get("instrument_name") == instrument or p.get("instrument") == instrument: + return float(p.get("size") or p.get("size_currency") or 0.0) + return 0.0 diff --git a/src/live/shadow.py b/src/live/shadow.py new file mode 100644 index 0000000..0cc5a15 --- /dev/null +++ b/src/live/shadow.py @@ -0,0 +1,120 @@ +"""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 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 _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]) + 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, + )) + 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, + flat=all(abs(targets[a]) < 1e-9 for a in ASSETS), + paper_aligned=(paper_ts == last_ts), + ) diff --git a/tests/test_live_shadow.py b/tests/test_live_shadow.py new file mode 100644 index 0000000..a99041e --- /dev/null +++ b/tests/test_live_shadow.py @@ -0,0 +1,81 @@ +"""Test deterministici dello SHADOW MODE di TP01 (src/live/deribit.py). + +Coprono la logica a rischio zero che NON tocca la rete: quantizzazione notional->contratti, sizing +target, costruzione ordine di ribilancio (buy/sell/exit/None), e PARITA' col backtest (il target +live = ultimo target della serie causale). Il fill reale (slippage/fee) NON e' qui: si valida solo +col micro-test mainnet. +""" +import sys +from pathlib import Path + +PROJECT_ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(PROJECT_ROOT)) + +from src.live.deribit import (build_rebalance_order, notional_to_amount, target_notional_usd) +from src.strategies.trend_portfolio import CANONICAL, TrendPortfolio, resample_1d + + +def test_notional_to_amount_step_and_min(): + # BTC step/min $10 + assert notional_to_amount("BTC-PERPETUAL", 1000) == 1000 + assert notional_to_amount("BTC-PERPETUAL", 1006) == 1010 # round allo step + assert notional_to_amount("BTC-PERPETUAL", 7) == 10 # clamp al minimo (>= mezzo step) + assert notional_to_amount("BTC-PERPETUAL", 3) == 0.0 # < mezzo step -> niente ordine + # ETH step/min $1 + assert notional_to_amount("ETH-PERPETUAL", 33.7) == 34 + assert notional_to_amount("ETH-PERPETUAL", 0.4) == 0.0 + # usa il valore assoluto (il segno lo decide il delta a monte) + assert notional_to_amount("BTC-PERPETUAL", -1000) == 1000 + + +def test_no_float_artifacts(): + # _quantize_step usa Decimal: nessun 0.07200000000000001 & co. + v = notional_to_amount("ETH-PERPETUAL", 72.0) + assert v == 72 and float(v).is_integer() + + +def test_target_notional_5050_weight(): + # 50/50 book: notional asset = 0.5 * frazione * equity + assert target_notional_usd(1.0, 0.5, 2000) == 1000 + assert target_notional_usd(2.0, 0.5, 2000) == 2000 # leva-cap 2x -> piena equity sull'asset + assert target_notional_usd(0.0, 0.5, 2000) == 0.0 + + +def test_build_order_entry(): + o = build_rebalance_order("BTC-PERPETUAL", target_fraction=1.0, weight=0.5, + equity_usd=2000, current_pos_usd=0.0) + assert o["side"] == "buy" and o["amount"] == 1000 and o["reduce_only"] is False + assert o["target_notional"] == 1000 and o["delta_notional"] == 1000 + + +def test_build_order_exit_is_reduce_only(): + o = build_rebalance_order("ETH-PERPETUAL", target_fraction=0.0, weight=0.5, + equity_usd=2000, current_pos_usd=1000.0) + assert o["side"] == "sell" and o["reduce_only"] is True and o["amount"] == 1000 + + +def test_build_order_already_at_target_is_none(): + o = build_rebalance_order("BTC-PERPETUAL", 1.0, 0.5, 2000, current_pos_usd=1000.0) + assert o is None # delta 0 -> nessun ordine + + +def test_build_order_subthreshold_is_none(): + # delta $3 su BTC (< mezzo step $5) -> niente ordine + o = build_rebalance_order("BTC-PERPETUAL", 0.5015, 0.5, 2000, current_pos_usd=498.5) + assert o is None + + +def test_partial_rebalance_direction(): + # target $1000, ho $600 -> compro $400; ho $1400 -> vendo $400 + up = build_rebalance_order("BTC-PERPETUAL", 1.0, 0.5, 2000, 600.0) + dn = build_rebalance_order("BTC-PERPETUAL", 1.0, 0.5, 2000, 1400.0) + assert up["side"] == "buy" and up["amount"] == 400 + assert dn["side"] == "sell" and dn["amount"] == 400 and dn["reduce_only"] is False + + +def test_parity_live_target_equals_backtest(): + # il target live (current_target) DEVE essere l'ultimo della serie causale del backtest + from src.backtest.harness import load + tp = TrendPortfolio(**CANONICAL) + df = resample_1d(load("BTC", "1h")) + assert tp.current_target(df) == tp.target_series(df)[-1]