"""Per-wallet performance metrics computed from the normalized ledger. Everything here is derived from two inputs: - ledger : normalized activity (see ledger.normalize_activity) - open_df : marked-to-market open positions (see ledger.attach_open_positions) Key definitions: total_pnl = realized cashflow over closed markets + MTM value of open ones roi = total_pnl / capital_deployed (sum of buy cost basis) win_rate = share of *resolved* markets that ended net-positive equity_curve= cumulative realized cashflow over time (+ running deposits view) max_dd = worst peak-to-trough drawdown of the equity curve consistency = fraction of active months that were net green """ from __future__ import annotations from dataclasses import dataclass, asdict import numpy as np import pandas as pd from .ledger import REBATE_TYPES @dataclass class WalletStats: wallet: str total_pnl: float realized_pnl: float open_pnl: float capital_deployed: float roi: float win_rate: float n_trades: int n_markets: int n_resolved_markets: int active_days: int first_ts: str last_ts: str max_drawdown_pct: float monthly_profit_ratio: float avg_trade_usdc: float median_entry_price: float rebate_pnl: float # income from liquidity rewards + maker/taker rebates rebate_share: float # rebate_pnl / total_pnl -> high = market maker (uncopyable) def to_dict(self) -> dict: return asdict(self) def _resolved_market_pnl(ledger: pd.DataFrame) -> pd.Series: """Net cashflow per market. A market is 'resolved' for our purposes when the trader has fully exited it (net share flow ~0) or redeemed it. We approximate resolution by net share balance: BUY adds shares, SELL/REDEEM remove them.""" if ledger.empty: return pd.Series(dtype=float) signed_size = np.where(ledger["side"].eq("BUY"), ledger["size"], -ledger["size"]) tmp = ledger.assign(signed_size=signed_size) pnl = tmp.groupby("market")["cashflow"].sum() net_shares = tmp.groupby("market")["signed_size"].sum().abs() # treat markets with a near-zero residual share balance as resolved/closed resolved = net_shares < 1e-6 pnl.attrs["resolved_mask"] = resolved return pnl def _empty(wallet: str) -> WalletStats: return WalletStats( wallet=wallet, total_pnl=0.0, realized_pnl=0.0, open_pnl=0.0, capital_deployed=0.0, roi=0.0, win_rate=0.0, n_trades=0, n_markets=0, n_resolved_markets=0, active_days=0, first_ts="", last_ts="", max_drawdown_pct=0.0, monthly_profit_ratio=0.0, avg_trade_usdc=0.0, median_entry_price=0.0, rebate_pnl=0.0, rebate_share=0.0, ) def compute(wallet: str, ledger: pd.DataFrame, open_df: pd.DataFrame) -> WalletStats: if ledger.empty: return _empty(wallet) market_pnl = _resolved_market_pnl(ledger) resolved_mask = market_pnl.attrs.get("resolved_mask", pd.Series(dtype=bool)) realized_pnl = float(market_pnl.sum()) open_pnl = float(open_df["cashPnl"].sum()) if not open_df.empty else 0.0 total_pnl = realized_pnl + open_pnl buys = ledger.loc[ledger["side"].eq("BUY"), "usdc"] capital_deployed = float(buys.sum()) roi = total_pnl / capital_deployed if capital_deployed > 0 else 0.0 resolved_pnl = market_pnl[resolved_mask] if len(resolved_mask) else market_pnl n_resolved = int(len(resolved_pnl)) win_rate = float((resolved_pnl > 0).mean()) if n_resolved else 0.0 first_ts, last_ts = ledger["ts"].iloc[0], ledger["ts"].iloc[-1] active_days = int((last_ts - first_ts).days) # equity curve = cumulative realized cashflow through time eq = ledger.sort_values("ts")["cashflow"].cumsum() max_dd = _max_drawdown_pct(eq.values, capital_deployed) # monthly consistency monthly = (ledger.set_index("ts")["cashflow"] .resample("ME").sum()) monthly_profit_ratio = float((monthly > 0).mean()) if len(monthly) else 0.0 trade_rows = ledger[ledger["side"].isin(["BUY", "SELL"])] avg_trade_usdc = float(trade_rows["usdc"].mean()) if not trade_rows.empty else 0.0 median_entry = float(ledger.loc[ledger["side"].eq("BUY"), "price"].median() or 0.0) # copyability: how much of the profit is protocol incentives (market-making) rebate_pnl = float(ledger.loc[ledger["type"].isin(REBATE_TYPES), "usdc"].sum()) rebate_share = rebate_pnl / total_pnl if total_pnl > 0 else (1.0 if rebate_pnl > 0 else 0.0) return WalletStats( wallet=wallet, total_pnl=round(total_pnl, 2), realized_pnl=round(realized_pnl, 2), open_pnl=round(open_pnl, 2), capital_deployed=round(capital_deployed, 2), roi=round(roi, 4), win_rate=round(win_rate, 4), n_trades=int(len(trade_rows)), n_markets=int(ledger["market"].nunique()), n_resolved_markets=n_resolved, active_days=active_days, first_ts=str(first_ts), last_ts=str(last_ts), max_drawdown_pct=round(max_dd, 4), monthly_profit_ratio=round(monthly_profit_ratio, 4), avg_trade_usdc=round(avg_trade_usdc, 2), median_entry_price=round(median_entry, 4), rebate_pnl=round(rebate_pnl, 2), rebate_share=round(min(max(rebate_share, 0.0), 1.0), 4), ) def _max_drawdown_pct(equity: np.ndarray, denom: float) -> float: """Max peak-to-trough drop, normalized by capital deployed so it reads as a fraction. Returns 0..1 (higher = worse).""" if len(equity) == 0 or denom <= 0: return 0.0 running_max = np.maximum.accumulate(equity) drawdown = running_max - equity return float(drawdown.max() / denom)