Adriano Dal Pastro
e5e2d3ec9b
ensure_disaster_sl(): garantisce UN solo STOP_MARKET reduce_only a ~-30% coerente con la posizione, ad ogni run del loop, per asset: - flat -> cancella i bracket orfani; - long -> assicura lo stop (size = posizione, prezzo al tick); - gia' coerente (1 bracket, amount~=, stop entro 5%) -> lascia com'e' (niente churn ne' gap di protezione fra cancel e place). - deribit.py: open_orders (merge type all+trigger_all), disaster_stop_price. - execution.py: cancel_order + ensure_disaster_sl. - live_execute.py: gestione bracket ogni run, gated come l'esecuzione. Validato armato: flat -> disaster-SL 'flat' (cleanup), zero ordini. Test 28/28. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
186 lines
9.8 KiB
Python
186 lines
9.8 KiB
Python
"""Esecuzione REALE su Deribit mainnet (via Cerbero MCP) — entrata/uscita verificate.
|
|
|
|
Estende DeribitRead (sola lettura) coi metodi di trading, con la logica PROVATA dello stack pre-reset
|
|
(Old/src/live/execution.py): entrata market verificata (state=='filled' + trade riscontrati, fill/fee
|
|
reali, filled_amount autorevole), uscita market reduce_only, disaster-bracket STOP_MARKET reduce_only.
|
|
|
|
GUARDRAIL: solo strumenti in ALLOWED; cap di size SOLO sulle APERTURE (MAX_AMOUNT). Le CHIUSURE si
|
|
tentano SEMPRE senza cap (principio di sicurezza di Old: si deve poter uscire da qualunque posizione).
|
|
Nessun parametro di leva (Deribit non la accetta per-ordine: l'esposizione la decide la SIZE).
|
|
|
|
⚠️ INVIA ORDINI REALI CON SOLDI VERI. Finestra d'uso attuale: micro-test (scripts/live/microtest.py).
|
|
Il deploy pieno di TP01 resta gated finche' il percorso live non e' abilitato esplicitamente.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass
|
|
|
|
from src.live.deribit import DeribitRead, disaster_stop_price, notional_to_amount, quantize_price
|
|
|
|
# Conto USDC -> perp LINEARE USDC (amount in base-coin). MAX_AMOUNT = TETTO HARD anti-fat-finger
|
|
# (~$630/$430 su un conto ~$600): backstop sopra il sizing di TP01, non il sizing operativo (quello
|
|
# lo decide config/live.json max_notional_per_asset_usd). Il micro-test invia comunque size fissa minima.
|
|
ALLOWED = {"BTC_USDC-PERPETUAL", "ETH_USDC-PERPETUAL"}
|
|
MAX_AMOUNT = {"BTC_USDC-PERPETUAL": 0.01, "ETH_USDC-PERPETUAL": 0.25}
|
|
FLAT_USD = 1.0 # |notional| < $1 = posizione considerata flat
|
|
|
|
|
|
class GuardrailError(RuntimeError):
|
|
pass
|
|
|
|
|
|
@dataclass
|
|
class Fill:
|
|
"""Esito verificato di un ordine reale."""
|
|
instrument: str
|
|
side: str
|
|
amount: float # richiesto (base-coin)
|
|
filled: float # realmente fillato (order.filled_amount, autorevole)
|
|
price: float | None # prezzo medio di fill
|
|
fee_usdc: float # fee reale (lineare USDC: gia' in USDC)
|
|
order_id: str | None
|
|
state: str | None
|
|
verified: bool
|
|
notes: str = ""
|
|
|
|
|
|
def _avg_price(order: dict, trades: list[dict]) -> float | None:
|
|
tr = [t for t in trades if t.get("price") and t.get("amount")]
|
|
if tr:
|
|
amt = sum(float(t["amount"]) for t in tr)
|
|
return (sum(float(t["price"]) * float(t["amount"]) for t in tr) / amt) if amt else None
|
|
return float(order.get("average_price") or 0) or None
|
|
|
|
|
|
class DeribitTrader(DeribitRead):
|
|
"""Trading minimo e verificato. Apre/chiude solo entro i guardrail; le chiusure sempre."""
|
|
|
|
def _submit(self, instrument: str, side: str, amount: float, *, reduce_only: bool,
|
|
label: str, order_type: str = "market", price: float | None = None) -> Fill:
|
|
if instrument not in ALLOWED:
|
|
raise GuardrailError(f"strumento non consentito: {instrument}")
|
|
if side not in ("buy", "sell"):
|
|
raise GuardrailError(f"side non valido: {side}")
|
|
if not reduce_only: # cap SOLO sulle aperture; le chiusure si tentano sempre
|
|
cap = MAX_AMOUNT.get(instrument, 0.0)
|
|
if amount <= 0 or amount > cap:
|
|
raise GuardrailError(f"size {amount} fuori dal cap apertura (0, {cap}]")
|
|
if amount <= 0:
|
|
return Fill(instrument, side, amount, 0.0, None, 0.0, None, None, False, "amount<=0")
|
|
|
|
payload = {"instrument_name": instrument, "side": side, "amount": amount,
|
|
"type": order_type, "label": label}
|
|
if price is not None:
|
|
payload["price"] = price
|
|
if reduce_only:
|
|
payload["reduce_only"] = True
|
|
resp = self._unwrap(self._post("/mcp-deribit/tools/place_order", payload)) or {}
|
|
|
|
if not isinstance(resp, dict) or resp.get("error") or resp.get("state") == "error":
|
|
err = resp.get("error") if isinstance(resp, dict) else resp
|
|
return Fill(instrument, side, amount, 0.0, None, 0.0, None, "error", False,
|
|
notes=f"place_order error: {err}")
|
|
|
|
order = resp.get("order", resp) or {}
|
|
trades = resp.get("trades", []) or []
|
|
order_id = order.get("order_id")
|
|
state = order.get("order_state")
|
|
price_f = _avg_price(order, trades)
|
|
fee_usdc = sum(float(t.get("fee", 0) or 0) for t in trades) # lineare USDC: fee gia' in USDC
|
|
filled = float(order.get("filled_amount") or 0) or sum(float(t.get("amount", 0) or 0) for t in trades)
|
|
|
|
if order_type == "market":
|
|
verified = (state == "filled") and bool(trades)
|
|
elif order_type == "stop_market":
|
|
verified = state in ("untriggered", "open", "filled")
|
|
else:
|
|
verified = state in ("open", "filled")
|
|
notes = "" if verified else f"non verificato (state={state}, trades={len(trades)})"
|
|
if verified and order_type == "market" and filled < amount - 1e-12:
|
|
notes = f"FILL PARZIALE: {filled} su {amount}"
|
|
return Fill(instrument, side, amount, filled, price_f, fee_usdc, order_id, state, verified, notes)
|
|
|
|
# --- ENTRATA ---
|
|
def open(self, instrument: str, side: str, amount: float, label: str = "tp01-open") -> Fill:
|
|
"""Apre a market (NON reduce_only), entro il cap. Verifica il fill reale."""
|
|
return self._submit(instrument, side, amount, reduce_only=False, label=label)
|
|
|
|
# --- USCITA (sempre permessa) ---
|
|
def close(self, instrument: str, label: str = "tp01-close") -> Fill | None:
|
|
"""Chiude la posizione a market reduce_only. Legge la size reale (USD notional), la converte
|
|
in base-coin col mark, e flatta. None se gia' flat. Senza cap: si esce sempre."""
|
|
pos_usd = self.position_usd(instrument)
|
|
if abs(pos_usd) < FLAT_USD:
|
|
return None
|
|
mark = self.mark_price(instrument)
|
|
amount = notional_to_amount(instrument, abs(pos_usd), price=mark)
|
|
side = "sell" if pos_usd > 0 else "buy"
|
|
return self._submit(instrument, side, amount, reduce_only=True, label=label)
|
|
|
|
# --- RIBILANCIO al target (long-only TP01): apre / riduce / chiude ---
|
|
def rebalance_to(self, instrument: str, target_notional_usd: float, mark: float,
|
|
min_usd: float = 5.0) -> list[Fill]:
|
|
"""Porta la posizione su `instrument` al target (USD notional). Long-only: target>=0.
|
|
- delta < min_usd -> niente (gia' a target);
|
|
- target ~0 & posizione -> close() (uscita piena, reduce_only);
|
|
- delta > 0 -> open buy (aumenta);
|
|
- delta < 0 (resta long) -> sell reduce_only del delta (riduce).
|
|
Ritorna i Fill eseguiti."""
|
|
cur = self.position_usd(instrument)
|
|
delta = target_notional_usd - cur
|
|
if abs(delta) < min_usd:
|
|
return []
|
|
if target_notional_usd < FLAT_USD and cur > FLAT_USD:
|
|
f = self.close(instrument, label="tp01-exit")
|
|
return [f] if f else []
|
|
amount = notional_to_amount(instrument, abs(delta), price=mark)
|
|
if amount <= 0:
|
|
return []
|
|
if delta > 0:
|
|
return [self.open(instrument, "buy", amount, label="tp01-buy")]
|
|
return [self._submit(instrument, "sell", amount, reduce_only=True, label="tp01-reduce")]
|
|
|
|
# --- DISASTER BRACKET (assicurazione on-book per outage; da Old) ---
|
|
def place_disaster_sl(self, instrument: str, side_held: str, amount: float,
|
|
stop_price: float, label: str = "disaster-sl") -> Fill:
|
|
"""STOP_MARKET reduce_only LONTANO (~-30%): in operativita' normale non scatta (l'exit della
|
|
strategia esce prima) -> 0 costo Sharpe; copre gli outage del runner. Trigger sul mark."""
|
|
opp = "sell" if side_held == "buy" else "buy"
|
|
return self._submit(instrument, opp, amount, reduce_only=True, label=label,
|
|
order_type="stop_market", price=quantize_price(instrument, stop_price))
|
|
|
|
def cancel_order(self, order_id: str) -> dict:
|
|
return self._unwrap(self._post("/mcp-deribit/tools/cancel_order", {"order_id": order_id})) or {}
|
|
|
|
DISASTER_LABEL = "tp01-disaster"
|
|
|
|
def ensure_disaster_sl(self, instrument: str, sl_pct: float) -> dict:
|
|
"""Garantisce UN disaster-SL coerente con la posizione (lifecycle completo, idempotente):
|
|
- flat -> cancella eventuali bracket orfani;
|
|
- long -> assicura UN solo STOP_MARKET reduce_only a ~-sl_pct, size = posizione;
|
|
- gia' coerente (1 bracket, amount~=, stop entro 5%) -> lascia com'e' (niente churn/gap)."""
|
|
pos = self.position_usd(instrument)
|
|
brackets = [o for o in self.open_orders(instrument) if (o.get("label") or "") == self.DISASTER_LABEL]
|
|
if abs(pos) < FLAT_USD:
|
|
for o in brackets:
|
|
self.cancel_order(o.get("order_id"))
|
|
return {"state": "flat", "cancelled": len(brackets)}
|
|
mark = self.mark_price(instrument)
|
|
long = pos > 0
|
|
want_amount = notional_to_amount(instrument, abs(pos), price=mark)
|
|
want_stop = disaster_stop_price(instrument, mark, sl_pct, long=long)
|
|
if len(brackets) == 1:
|
|
o = brackets[0]
|
|
amt = float(o.get("amount") or 0)
|
|
stp = float(o.get("trigger_price") or o.get("stop_price") or o.get("price") or 0)
|
|
if want_amount and abs(amt - want_amount) < want_amount * 0.1 and stp > 0 \
|
|
and abs(stp - want_stop) / want_stop < 0.05:
|
|
return {"state": "ok", "stop": stp, "amount": amt}
|
|
for o in brackets: # incoerente o multipli -> ricostruisci UN bracket
|
|
self.cancel_order(o.get("order_id"))
|
|
f = self.place_disaster_sl(instrument, "buy" if long else "sell", want_amount, want_stop,
|
|
label=self.DISASTER_LABEL)
|
|
return {"state": "placed" if f.verified else "place-failed", "stop": want_stop,
|
|
"amount": want_amount, "notes": f.notes}
|
|
# trade_history / open_orders ereditati da DeribitRead (read-only)
|