"""Daily 'consistent smart-money' digest engine. Product wedge (from surveying the crowded Polymarket-tracker market): existing whale trackers only flag $10k+ whales and just dump raw trades. Two documented gaps we target instead: 1. COVERAGE — surface *consistent mid-size* traders the whale filters miss. 2. JUDGEMENT — attach a signal-quality score so a move comes with context, not just "someone bought." Inputs are the already-computed metrics table (data/wallets.csv, produced by 02_analyze_wallets.py) plus a live pull of each selected wallet's most recent activity. We deliberately EXCLUDE mega-whales and market-makers — the opposite of what the incumbents rank on. This is market-intelligence tooling, NOT a profit promise. The underlying copy edge is unproven (see README caveats); we sell flow context, like TradingView sells charts, not guaranteed returns. """ from __future__ import annotations from dataclasses import dataclass, field import numpy as np import pandas as pd from .ledger import normalize_activity @dataclass class SelectionConfig: # the wedge: consistent, repeatable, copyable, NOT a mega-whale / market-maker min_monthly_profit_ratio: float = 0.5 # green in >=half of active months min_repeatability: float = 0.30 max_rebate_share: float = 0.35 # reject market-makers (uncopyable) min_profit_usd: float = 5_000 # must be actually profitable... max_profit_usd: float = 2_000_000 # ...but NOT a mega-whale (coverage gap) max_avg_trade_usdc: float = 5_000 # mid-size, not size-you-can't-mirror min_active_days: int = 20 min_resolved_markets: int = 5 top_n: int = 15 def _profit(row: pd.Series) -> float: """Authoritative profit if on leaderboard, else reconstructed total_pnl.""" p = row.get("profit_final") if p is None or (isinstance(p, float) and np.isnan(p)): p = row.get("total_pnl", 0.0) return float(p or 0.0) def _trader_score(row: pd.Series) -> float: """Blend the trustworthy signals into one 0..1 quality score for a trader. Leans on consistency + repeatability + copyability (NOT raw size or the noisy win-rate / reconstructed-PnL fields).""" consistency = float(row.get("monthly_profit_ratio", 0.0) or 0.0) repeat = float(row.get("repeatability", 0.0) or 0.0) copyable = 1.0 - min(1.0, float(row.get("rebate_share", 0.0) or 0.0)) roi = float(row.get("roi", 0.0) or 0.0) roi_signal = float(np.clip(roi / 0.5, 0.0, 1.0)) # 50% ROI -> full return round(float(np.mean([consistency, repeat, copyable, roi_signal])), 4) def select_smart_money(df: pd.DataFrame, cfg: SelectionConfig) -> pd.DataFrame: """Apply the wedge filter and rank. Returns a copy with `trader_score`.""" if df.empty: return df.assign(trader_score=[]) d = df.copy() d["profit"] = d.apply(_profit, axis=1) d["trader_score"] = d.apply(_trader_score, axis=1) m = ( (d["monthly_profit_ratio"].fillna(0) >= cfg.min_monthly_profit_ratio) & (d["repeatability"].fillna(0) >= cfg.min_repeatability) & (d["rebate_share"].fillna(1) <= cfg.max_rebate_share) & (d["profit"] >= cfg.min_profit_usd) & (d["profit"] <= cfg.max_profit_usd) # <-- excludes mega-whales & (d["avg_trade_usdc"].fillna(1e12) <= cfg.max_avg_trade_usdc) & (d["active_days"].fillna(0) >= cfg.min_active_days) & (d["n_resolved_markets"].fillna(0) >= cfg.min_resolved_markets) ) out = d[m].sort_values("trader_score", ascending=False).head(cfg.top_n) return out.reset_index(drop=True) @dataclass class Move: wallet: str trader_score: float title: str outcome: str price: float usdc: float ts: pd.Timestamp conviction: float # this bet vs the trader's own typical size signal_quality: float # trader_score blended with conviction+edge dominant_topic: str = "" def _conviction(usdc: float, avg_usdc: float) -> float: """How big is this bet relative to the trader's own average? >1 means an above-typical, higher-conviction entry. Squashed to 0..1.""" if avg_usdc <= 0: return 0.5 ratio = usdc / avg_usdc return float(np.clip(ratio / 3.0, 0.0, 1.0)) # 3x avg -> max conviction def fresh_moves(client, selected: pd.DataFrame, hours: int = 24, page_limit: int = 200, per_wallet_cap: int = 3) -> list[Move]: """Pull each selected wallet's recent BUYs inside the window, scored.""" cutoff = pd.Timestamp.now("UTC") - pd.Timedelta(hours=hours) moves: list[Move] = [] for _, row in selected.iterrows(): wallet = row["wallet"] try: raw = client.activity(wallet, limit=page_limit, offset=0) except Exception: continue led = normalize_activity(raw) if led.empty: continue led = led[(led["side"] == "BUY") & (led["ts"] >= cutoff)] if led.empty: continue avg_usdc = float(row.get("avg_trade_usdc", 0.0) or 0.0) tscore = float(row["trader_score"]) picked = 0 for t in led.sort_values("usdc", ascending=False).itertuples(index=False): conv = _conviction(float(t.usdc), avg_usdc) edge = abs(float(t.price) - 0.5) * 2.0 sig = round(float(np.mean([tscore, tscore, conv, edge])), 4) # trader weighted 2x moves.append(Move( wallet=wallet, trader_score=tscore, title=str(t.title), outcome=str(t.outcome), price=float(t.price), usdc=float(t.usdc), ts=t.ts, conviction=round(conv, 3), signal_quality=sig, dominant_topic=str(row.get("dominant_topic", "") or ""), )) picked += 1 if picked >= per_wallet_cap: break moves.sort(key=lambda m: m.signal_quality, reverse=True) return moves def _wallet_md(w: str) -> str: """Short label, full address preserved as a verifiable Polymarket link.""" return f"[{w[:6]}…{w[-4:]}](https://polymarket.com/profile/{w})" def _rank_dots(vals: list[float]) -> list[str]: """Relative 1–5 dot rank WITHIN the shown batch, so the bars actually spread instead of clustering (raw signals bunch around 0.5–0.7). Weakest shown move gets ●○○○○, strongest ●●●●●, the rest spaced by percentile rank.""" n = len(vals) if n == 0: return [] order = sorted(range(n), key=lambda i: vals[i]) dots = [""] * n for pos, i in enumerate(order): pct = pos / (n - 1) if n > 1 else 1.0 k = 1 + int(round(pct * 4)) # 1..5 dots[i] = "●" * k + "○" * (5 - k) return dots def render_markdown(selected: pd.DataFrame, moves: list[Move], hours: int, top_moves: int = 12) -> str: date = pd.Timestamp.now("UTC").strftime("%Y-%m-%d %H:%M UTC") lines = [ f"# Consistent Smart-Money Digest — {date}", "", f"_Mid-size, consistently-profitable Polymarket traders (the ones whale " f"trackers skip) and their highest-conviction moves in the last {hours}h. " f"Flow intelligence, not financial advice._", "", f"**Tracking {len(selected)} vetted traders · {len(moves)} fresh moves scored**", "", "## Top moves right now", "", "_Signal = our quality score for a move: the trader's consistency blended " "with how big this bet is for them (conviction) and how far the price is " "from a coin-flip (edge). Dots are a **relative rank among today's moves** — " "●●●●● = strongest signal in this list, ●○○○○ = weakest. Tap any address to " "verify it on Polymarket._", "", ] if not moves: lines.append("_No qualifying fresh moves in the window. Check back next run._") else: shown = moves[:top_moves] dot_bars = _rank_dots([m.signal_quality for m in shown]) lines.append("| Signal | Trader | Move | Price | Size | Conviction |") lines.append("|---|---|---|---|---|---|") for m, bar in zip(shown, dot_bars): title = (m.title[:46] + "…") if len(m.title) > 47 else m.title lines.append( f"| {bar} {m.signal_quality:.2f} " f"| {_wallet_md(m.wallet)} | {title} " f"({m.outcome}) | {m.price:.2f} | ${m.usdc:,.0f} | {m.conviction:.0%} |" ) lines += ["", "## The traders we're tracking", "", "_The mid-size, consistently-profitable wallets that passed our filter — " "the ones we pull fresh moves from. Score blends consistency, " "repeatability and copyability (not size). Tap to verify on Polymarket._", "", "| Trader | Score | Profit | Consistency | Repeatability | Topic |", "|---|---|---|---|---|---|"] for _, r in selected.iterrows(): lines.append( f"| {_wallet_md(r['wallet'])} | {r['trader_score']:.2f} | ${_profit(r):,.0f} | " f"{float(r.get('monthly_profit_ratio',0)):.0%} | " f"{float(r.get('repeatability',0)):.2f} | " f"{r.get('dominant_topic','')} |" ) lines += ["", "---", "_Built from Polymarket public data. Past performance is not " "predictive; consistency scoring ≠ guaranteed profit._"] return "\n".join(lines)