mirror of
https://github.com/jaxperro/winning-wallet-finder.git
synced 2026-07-27 15:57:47 +00:00
Add live/ skilled-wallet scanner + cache; document clean OOS finding
live/: operationalizes the LBS/Yale "skilled ~3%" result against the live data-api. Enumerate recent liquid markets -> top traders -> candidate pool; cache every wallet's resolved bets once in DuckDB (~26k wallets / 12.5M bets, keyed by per-bet resolution time so any cutoff re-scores in seconds); 5-gate skill funnel (n>=15, z>0, BH-FDR, split-half OOS, MM/bot cap); dashboard + daily refresh. Key finding: copying the high-win-rate "favorite-rider" cohort looks +23.6% in-sample but loses -7.4% once selected on pre-June-1 data only (99% -> 68% win rate) — selection bias, reproducing the paper's "lucky winners revert" result on live data. Win rate != edge, again. wide/: bulk subgraph->DuckDB scanner (survivorship-bias-free over all wallets), but the public subgraph is frozen at Jan 2026 -> historical tool only. Large local data (*.duckdb, candidates.json, *_scored.json, history/) gitignored. README + FINDINGS updated with the current logic and the clean result. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
jaxperro
@@ -24,3 +24,12 @@ watcher_state.json
|
||||
huntwide.csv
|
||||
oos.log
|
||||
hunt.log
|
||||
|
||||
# live/ + wide/ — large local data + regenerable artifacts
|
||||
*.duckdb
|
||||
*.duckdb.wal
|
||||
live/candidates.json
|
||||
live/scored.json
|
||||
live/*_scored.json
|
||||
live/watch_prejune*.json
|
||||
live/history/
|
||||
|
||||
+30
@@ -116,6 +116,32 @@ real forward (out-of-sample) data on these wallets — observe before you size u
|
||||
- A durable trading edge has to come from *you* (a niche you know), with this
|
||||
tooling built around your judgment.
|
||||
|
||||
## The skilled-3% scan, and a clean out-of-sample loss (June 2026)
|
||||
|
||||
External validation arrived: an LBS/Yale study (Gomez-Cram, Guo, Kung, Jensen,
|
||||
Apr 2026; SSRN 5910522) over 1.72M accounts found only **~3.14%** of traders are
|
||||
genuinely skilled — measured by randomizing each trader's bet *directions* 10k×
|
||||
(a Monte-Carlo z-score) and requiring out-of-sample persistence. That is exactly
|
||||
this project's z-score + `oos.py` method, independently confirmed.
|
||||
|
||||
Built `live/` to operationalize it at scale: enumerate recent liquid markets →
|
||||
cache every candidate's resolved bets locally (~26k wallets / 12.5M bets, so
|
||||
re-scoring at any cutoff is seconds) → a 5-gate funnel (n≥15, z>0, BH-FDR,
|
||||
split-half OOS, MM/bot cap). It surfaced 107 "validated" wallets.
|
||||
|
||||
**The decisive test.** Copying the high-win-rate "favorite-rider" cohort, $1000,
|
||||
no execution lag, June 1→now:
|
||||
- selected *through* the test window (look-ahead): 99% win rate, **+23.6%**.
|
||||
- selected on **pre-June-1 data only** (honest): 68% win rate, **−7.4%**
|
||||
(−19% on the settled portion).
|
||||
|
||||
The +23.6% was selection bias. Done cleanly, the favorites **lose** — a textbook
|
||||
reproduction of the paper's "~60% of lucky winners become losers out-of-sample,"
|
||||
now on our own live data. *Lesson reinforced: high win rate is the most
|
||||
misleading signal on the platform; favorite-riders are uncopyable.* The
|
||||
underdog/`value` archetype (beats longshot prices) is the only one left worth
|
||||
testing.
|
||||
|
||||
## Repo layout
|
||||
|
||||
- `insider.py` — the detector: z-score/p-value, timing/freshness/sizing signals,
|
||||
@@ -124,5 +150,9 @@ real forward (out-of-sample) data on these wallets — observe before you size u
|
||||
- `copyback.py` / `oos.py` — in-sample and out-of-sample copy-trade backtests.
|
||||
- `webhook_receiver.py` — push-based live trade watcher (Alchemy → Discord).
|
||||
- `smart_money.py` — data foundation + dashboard (true-win-rate scanner).
|
||||
- `live/` — current scanner: cache-backed skilled-3% finder + watchlist + daily
|
||||
refresh + dashboard. See `live/README.md`.
|
||||
- `wide/` — bulk subgraph→DuckDB scanner (survivorship-bias-free, all wallets);
|
||||
public subgraph frozen at Jan 2026, so historical-only. See `wide/README.md`.
|
||||
- `archive/` — the strategies that didn't work, kept for reference. See
|
||||
`archive/README.md`.
|
||||
|
||||
@@ -68,6 +68,8 @@ Two refinements separate signal from noise:
|
||||
| `webhook_receiver.py` | Push-based live watcher: Alchemy on-chain webhook → enrich → Discord. |
|
||||
| `watch.json` | The tracked wallet set + edge weights (shared by the watcher and the tracker). |
|
||||
| paper tracker | Client-side `$1,000` running portfolio → [jaxperro.com/trading](https://jaxperro.com/trading) (page lives in the personal site repo). |
|
||||
| **`live/`** | **The current scanner** — find & track the skilled ~3% from the live API at scale: enumerate → cache → 5-gate skill funnel → dashboard → daily refresh. Caches ~26k wallets / 12.5M bets locally so every re-score is seconds. ([live/README](live/README.md)) |
|
||||
| `wide/` | Bulk subgraph→DuckDB scanner: survivorship-bias-free over all 1.76M wallets, but the public subgraph is **frozen at Jan 2026**, so it's a historical tool only. ([wide/README](wide/README.md)) |
|
||||
| `archive/` | The six strategies that didn't work, kept for reference ([details](archive/README.md)). |
|
||||
|
||||
---
|
||||
@@ -159,6 +161,38 @@ public API (CORS-open) — zero backend, zero added cost.
|
||||
|
||||
---
|
||||
|
||||
## The skilled-wallet scanner (`live/`)
|
||||
|
||||
The newest pipeline operationalizes the [LBS/Yale finding](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=5910522)
|
||||
that ~3% of accounts are genuinely skilled. It scans the **live** data-api at
|
||||
scale and tracks the survivors forward.
|
||||
|
||||
**The 5-gate funnel** — a wallet is "skilled" only if it clears all five:
|
||||
`n ≥ 15 resolved bets` → `z > 0` (beats its entry prices) → `Benjamini–Hochberg
|
||||
FDR @5%` → `split-half out-of-sample persists` → `not a market-maker/bot`. Win
|
||||
rate is never a gate.
|
||||
|
||||
**The cache makes it cheap.** Each wallet's full resolved-bet history is pulled
|
||||
once into `cache.duckdb` (~26k wallets / 12.5M bets), keyed with per-bet
|
||||
resolution times — so any cutoff (pre-June-1, full-window, archetypes) re-scores
|
||||
in **seconds** instead of hours of API pulls.
|
||||
|
||||
**The clean out-of-sample result (June 2026).** Copying the "favorite-rider"
|
||||
skilled wallets, $1000, no execution lag:
|
||||
|
||||
| Selection | Win rate | Forward P&L (June 1+) |
|
||||
|-----------|----------|-----------------------|
|
||||
| In-sample (peeks at test window) | 99% | **+23.6%** |
|
||||
| **Clean (pre-June-1 data only)** | 68% | **−7.4%** (−19% on settled) |
|
||||
|
||||
The +23.6% was pure selection bias. Selected honestly, the favorites **lose** —
|
||||
exactly the paper's "~60% of lucky winners become losers out-of-sample." High
|
||||
win rate ≠ edge, again. (The `value`/longshot archetype — wallets that beat
|
||||
*underdog* prices — is the one worth testing next.) Full pipeline in
|
||||
[`live/README.md`](live/README.md).
|
||||
|
||||
---
|
||||
|
||||
## The honest verdict
|
||||
|
||||
- **Detection works.** z-score + timing + funding-cluster reliably surfaces
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
# live/ — find & track the genuinely-skilled ~3%
|
||||
|
||||
Finds the small fraction of Polymarket wallets with a *real, repeatable* edge —
|
||||
the ~3% the [LBS/Yale study](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=5910522)
|
||||
identifies — from the **live data-api**, caches everything locally, and tracks
|
||||
them forward. This is the going-forward system; the frozen-subgraph bulk approach
|
||||
lives in `../wide/`.
|
||||
|
||||
## Why this and not win rate
|
||||
|
||||
Win rate is survivorship-biased and decoupled from edge (see `../FINDINGS.md`).
|
||||
A wallet is "skilled" only if it **beats the prices it paid** and that edge
|
||||
**persists out-of-sample**. We reproduced the research's own finding on live
|
||||
June data: favorite-rider wallets that looked +23.6% in-sample lost **−7.4%**
|
||||
once selected without look-ahead (see "The clean test" below).
|
||||
|
||||
## The 5-gate funnel (`skill.py`)
|
||||
|
||||
A wallet counts as skilled only if it clears all five:
|
||||
|
||||
1. **n ≥ 15** resolved bets (assessability; the paper's skilled avg ~79).
|
||||
2. **z = (wins − Σp)/√Σp(1−p)** clearly > 0 — wins above what entry odds implied.
|
||||
This is the closed form of the paper's "randomize direction 10k×" benchmark.
|
||||
3. **Benjamini–Hochberg FDR @ 5%** — at scale, thousands clear z>3 by chance.
|
||||
4. **Split-half out-of-sample** — skill in the earlier half persists in the
|
||||
recent half (`z_oos > 0`). The gate that separates the real 3% from the lucky.
|
||||
5. **MM/bot cap** (`n ≤ 2500`) — a thousands-of-bets grinder isn't info-edge.
|
||||
|
||||
Win rate is never a gate — only displayed. Wallets are tagged `value` (beats
|
||||
underdog/longshot prices — the copyable alpha), `balanced`, or `favorite`
|
||||
(high win% riding near-certain favorites — real but thin/uncopyable).
|
||||
|
||||
## Pipeline
|
||||
|
||||
| step | script | what |
|
||||
|------|--------|------|
|
||||
| enumerate | `enumerate.py [days]` | recent liquid markets (Gamma `end_date_min`) → top traders → candidate pool (`candidates.json`), accumulates across runs |
|
||||
| cache | `cache.py` / `collect.py` | pull each wallet's resolved bets **once** into `cache.duckdb` (24s → 0.003s on re-read). Stores `res_t` per bet, so any date cutoff reads the same cache |
|
||||
| score | `skill.py [N]` | the 5-gate funnel over cached candidates → `watch_skilled.json` (webhook-compatible) |
|
||||
| dashboard | `dashboard.py` | self-contained `dashboard.html` — sortable, archetype-tagged, live recent-trade lookup |
|
||||
| backtest | `backtest_june.py [arch]` | copy an archetype's June-1+ entries, $1000, no lag → P&L |
|
||||
| clean test | `clean_test.sh` | **the honest test**: re-select on pre-June-1 data only, then backtest June-1+ forward |
|
||||
|
||||
## The cache is the point
|
||||
|
||||
`cache.duckdb` holds ~26k wallets / 12.5M+ bets, pulled once. Every score —
|
||||
any archetype, any cutoff, the clean OOS test — now runs in **seconds** instead
|
||||
of hours of API pulls. `MAX_AGE_DAYS=14`: the broad pool refreshes biweekly; the
|
||||
watchlist is force-refreshed daily (`cache.invalidate`) for forward tracking.
|
||||
|
||||
## The clean test (why the favorites are a mirage)
|
||||
|
||||
`clean_test.sh` selects favorites using **only bets resolved before June 1**,
|
||||
then copies their June-1+ entries:
|
||||
|
||||
- **In-sample (contaminated):** 21 favorites, 99% win rate, **+23.6%**.
|
||||
- **Clean (pre-June-1 selection):** 15 favorites, 68% win rate, **−7.4%**
|
||||
(−19% on the settled portion).
|
||||
|
||||
The +23.6% was selection bias. This matches the paper: ~60% of "lucky winners"
|
||||
turn into losers out-of-sample. **Don't copy favorite-riders.** The `value`
|
||||
archetype (beats underdog prices) is where real alpha may live — test it with
|
||||
`backtest_june.py value`.
|
||||
|
||||
## Daily (`daily.sh`)
|
||||
|
||||
1. discover (enumerate last 14d) → 2. freshen cache (force-refresh watchlist +
|
||||
top up new wallets) → 3. re-score (instant from cache) → 4. regenerate dashboard
|
||||
+ snapshot to `history/`. Schedule via launchd/cron (Mac must be awake).
|
||||
|
||||
## Usage
|
||||
|
||||
```bash
|
||||
pip install duckdb
|
||||
python3 enumerate.py 180 # build candidate pool (last 6 months)
|
||||
python3 collect.py # cache all candidates (one-time, slow; resumable)
|
||||
python3 skill.py # -> watch_skilled.json (seconds, from cache)
|
||||
python3 dashboard.py # -> dashboard.html
|
||||
./clean_test.sh # the out-of-sample verdict
|
||||
```
|
||||
|
||||
Local data (`*.duckdb`, `candidates.json`, `*_scored.json`, `history/`) is
|
||||
gitignored — regenerate via the steps above.
|
||||
@@ -0,0 +1,150 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Forward copy-test: copy the FAVORITE-rider skilled wallets' new entries from
|
||||
June 1 to now, $1000 bankroll, NO execution lag (we get their exact fill price).
|
||||
|
||||
Method: collect every BUY these wallets made on/after June 1 (data-api), take the
|
||||
first entry per market (basket consensus, one position per market), deploy $1000
|
||||
split equally across them, then settle each via the CLOB winner flag (resolved)
|
||||
or mark to current price (still open). Reports realized + unrealized P&L.
|
||||
|
||||
python3 backtest_june.py # favorites, from 2026-06-01
|
||||
python3 backtest_june.py value # test the value/longshot archetype instead
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import ssl
|
||||
import sys
|
||||
import time
|
||||
import urllib.request
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
HERE = os.path.dirname(__file__)
|
||||
DATA = "https://data-api.polymarket.com"
|
||||
CLOB = "https://clob.polymarket.com/markets"
|
||||
CTX = ssl._create_unverified_context()
|
||||
START = time.mktime(time.strptime("2026-06-01", "%Y-%m-%d"))
|
||||
BANKROLL = 1000.0
|
||||
ARCH = sys.argv[1] if len(sys.argv) > 1 else "favorite"
|
||||
|
||||
|
||||
def get(url):
|
||||
req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
|
||||
return json.loads(urllib.request.urlopen(req, timeout=30, context=CTX).read())
|
||||
|
||||
|
||||
def trades_since(wallet):
|
||||
"""All BUY trades on/after START for one wallet."""
|
||||
out, off = [], 0
|
||||
for _ in range(8):
|
||||
try:
|
||||
page = get(f"{DATA}/activity?user={wallet}&type=TRADE&limit=500&offset={off}")
|
||||
except Exception:
|
||||
break
|
||||
if not page:
|
||||
break
|
||||
for t in page:
|
||||
if (t.get("timestamp") or 0) < START:
|
||||
return out
|
||||
if t.get("side") == "BUY" and t.get("conditionId"):
|
||||
out.append(t)
|
||||
off += 500
|
||||
if len(page) < 500:
|
||||
break
|
||||
return out
|
||||
|
||||
|
||||
_mkt = {}
|
||||
def market(cond):
|
||||
if cond not in _mkt:
|
||||
try:
|
||||
_mkt[cond] = get(f"{CLOB}/{cond}")
|
||||
except Exception:
|
||||
_mkt[cond] = None
|
||||
return _mkt[cond]
|
||||
|
||||
|
||||
def settle(cond, outcome_idx, outcome_name):
|
||||
"""-> (status, value_per_share). status in won/lost/open/unknown."""
|
||||
m = market(cond)
|
||||
if not m:
|
||||
return "unknown", None
|
||||
toks = m.get("tokens") or []
|
||||
tok = None
|
||||
if outcome_idx is not None and outcome_idx < len(toks):
|
||||
tok = toks[outcome_idx]
|
||||
if tok is None:
|
||||
for t in toks:
|
||||
if (t.get("outcome") or "").lower() == (outcome_name or "").lower():
|
||||
tok = t; break
|
||||
if tok is None:
|
||||
return "unknown", None
|
||||
if tok.get("winner") is True:
|
||||
return "won", 1.0
|
||||
if tok.get("winner") is False:
|
||||
return "lost", 0.0
|
||||
return "open", float(tok.get("price") or 0) # not resolved -> mark to price
|
||||
|
||||
|
||||
def main():
|
||||
wl = json.load(open(os.path.join(HERE, os.environ.get("BT_WATCH", "watch_skilled.json"))))
|
||||
wallets = [w for w in wl if (w["avg_entry"] >= 0.85 if ARCH == "favorite"
|
||||
else w["avg_entry"] < 0.5 if ARCH == "value"
|
||||
else True)]
|
||||
print(f"{ARCH}: {len(wallets)} wallets · copying BUYs from "
|
||||
f"{time.strftime('%Y-%m-%d', time.localtime(START))} to now, ${BANKROLL:.0f}, no lag\n",
|
||||
flush=True)
|
||||
|
||||
# gather every favorite's June+ buys, keep the FIRST entry per market
|
||||
picks = {} # cond -> trade (earliest)
|
||||
with ThreadPoolExecutor(max_workers=10) as ex:
|
||||
for ts in ex.map(trades_since, [w["wallet"] for w in wallets]):
|
||||
for t in ts:
|
||||
c = t["conditionId"]
|
||||
if c not in picks or t["timestamp"] < picks[c]["timestamp"]:
|
||||
picks[c] = t
|
||||
n = len(picks)
|
||||
if not n:
|
||||
print("no copied entries in the window."); return
|
||||
stake = BANKROLL / n
|
||||
print(f"{n} unique markets entered → ${stake:.2f} per position\n", flush=True)
|
||||
|
||||
won = lost = openc = unk = 0
|
||||
realized = unreal_val = realized_cost = open_cost = 0.0
|
||||
rows = []
|
||||
with ThreadPoolExecutor(max_workers=10) as ex:
|
||||
results = list(ex.map(
|
||||
lambda kv: (kv[1], settle(kv[0], kv[1].get("outcomeIndex"), kv[1].get("outcome"))),
|
||||
picks.items()))
|
||||
for t, (status, vps) in results:
|
||||
p = t.get("price") or 0.01
|
||||
shares = stake / max(p, 0.001)
|
||||
title = (t.get("title") or "")[:46]
|
||||
if status == "won":
|
||||
won += 1; realized += shares * 1.0; realized_cost += stake
|
||||
rows.append((shares - stake, status, p, title))
|
||||
elif status == "lost":
|
||||
lost += 1; realized += 0.0; realized_cost += stake
|
||||
rows.append((-stake, status, p, title))
|
||||
elif status == "open":
|
||||
openc += 1; unreal_val += shares * vps; open_cost += stake
|
||||
rows.append((shares * vps - stake, status, p, title))
|
||||
else:
|
||||
unk += 1; unreal_val += stake; open_cost += stake # unknown -> hold at cost
|
||||
|
||||
realized_pl = realized - realized_cost
|
||||
equity = realized + unreal_val + 0.0 # all $1000 deployed
|
||||
total_pl = equity - BANKROLL
|
||||
print(f"resolved: {won}W / {lost}L · still open: {openc} · unknown: {unk}")
|
||||
print(f"REALIZED P&L: {realized_pl:+,.2f} (on ${realized_cost:,.0f} settled)")
|
||||
print(f"open positions marked to market: ${unreal_val:,.2f} (cost ${open_cost:,.0f})")
|
||||
print(f"\nFINAL EQUITY: ${equity:,.2f} TOTAL P&L: {total_pl:+,.2f} "
|
||||
f"({100*total_pl/BANKROLL:+.1f}% on ${BANKROLL:.0f})\n")
|
||||
rows.sort()
|
||||
print("worst / best copied bets:")
|
||||
for pl, st, p, title in rows[:4] + rows[-4:]:
|
||||
print(f" {pl:+8.2f} {st:>5} @{p:.2f} {title}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,81 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Local cache of per-wallet resolved bets, so we stop re-pulling the data-api.
|
||||
|
||||
Each wallet's resolved bets (won, entry price p, conditionId, resolution time,
|
||||
size) are stored once in cache.duckdb. Because we keep res_t per bet, ANY date
|
||||
cutoff — pre-June-1, full window, future experiments — reads the same cached
|
||||
rows and filters locally. A pull only happens for wallets not seen, or older
|
||||
than MAX_AGE_DAYS.
|
||||
|
||||
Thread-safe: API pulls (the slow part) run outside the lock; only the small
|
||||
DuckDB reads/writes are serialized, so skill.py's worker pool still parallelizes
|
||||
the network.
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
|
||||
import duckdb
|
||||
|
||||
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
|
||||
import insider # noqa: E402
|
||||
|
||||
DB = os.path.join(os.path.dirname(__file__), "cache.duckdb")
|
||||
WINDOW_DAYS = 180
|
||||
MAX_AGE_DAYS = 14 # broad pool re-pulls only every 2 weeks; watchlist is
|
||||
# force-refreshed daily via invalidate() (see daily.sh)
|
||||
|
||||
_lock = threading.Lock()
|
||||
_con = duckdb.connect(DB)
|
||||
_con.execute("""CREATE TABLE IF NOT EXISTS bets(
|
||||
wallet TEXT, cond TEXT, won BOOLEAN, p DOUBLE, res_t BIGINT, size DOUBLE)""")
|
||||
_con.execute("CREATE INDEX IF NOT EXISTS bets_w ON bets(wallet)")
|
||||
_con.execute("CREATE TABLE IF NOT EXISTS pulled(wallet TEXT PRIMARY KEY, pulled_at BIGINT)")
|
||||
|
||||
|
||||
def get_bets(wallet):
|
||||
"""Resolved bets for a wallet — from cache if fresh, else pull and store."""
|
||||
now = time.time()
|
||||
with _lock:
|
||||
r = _con.execute("SELECT pulled_at FROM pulled WHERE wallet=?", [wallet]).fetchone()
|
||||
if r and now - r[0] < MAX_AGE_DAYS * 86400:
|
||||
rows = _con.execute(
|
||||
"SELECT won,p,cond,res_t,size FROM bets WHERE wallet=?", [wallet]).fetchall()
|
||||
return [{"won": w, "p": p, "cond": c, "res_t": rt, "size": s}
|
||||
for w, p, c, rt, s in rows]
|
||||
# cache miss / stale -> pull (slow, outside the lock so workers stay parallel)
|
||||
try:
|
||||
bets = insider.resolved_bets(wallet, now - WINDOW_DAYS * 86400)
|
||||
except Exception:
|
||||
bets = []
|
||||
with _lock:
|
||||
_con.execute("DELETE FROM bets WHERE wallet=?", [wallet])
|
||||
if bets:
|
||||
_con.executemany(
|
||||
"INSERT INTO bets(wallet,cond,won,p,res_t,size) VALUES (?,?,?,?,?,?)",
|
||||
[(wallet, b["cond"], b["won"], b["p"], b.get("res_t"), b.get("size"))
|
||||
for b in bets])
|
||||
_con.execute("INSERT OR REPLACE INTO pulled VALUES (?,?)", [wallet, int(now)])
|
||||
return bets
|
||||
|
||||
|
||||
def invalidate(wallets):
|
||||
"""Force a re-pull of these wallets on next get_bets (for daily watchlist
|
||||
forward-refresh)."""
|
||||
with _lock:
|
||||
for w in wallets:
|
||||
_con.execute("DELETE FROM pulled WHERE wallet=?", [w])
|
||||
|
||||
|
||||
def stats():
|
||||
with _lock:
|
||||
w = _con.execute("SELECT count(*) FROM pulled").fetchone()[0]
|
||||
b = _con.execute("SELECT count(*) FROM bets").fetchone()[0]
|
||||
return w, b
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
w, b = stats()
|
||||
print(f"cache: {w:,} wallets, {b:,} bets in {DB}")
|
||||
Executable
+13
@@ -0,0 +1,13 @@
|
||||
#!/bin/bash
|
||||
# Clean out-of-sample test:
|
||||
# 1) re-select skilled wallets using ONLY bets resolved before June 1
|
||||
# (selection cannot peek at the June 1+ test window)
|
||||
# 2) copy the resulting FAVORITE-rider wallets' June 1+ entries, $1000, no lag
|
||||
# This removes the selection contamination of the first backtest.
|
||||
set -u
|
||||
cd "$(dirname "$0")"
|
||||
echo "[clean] $(date '+%F %T') re-scoring candidates on PRE-June-1 data only…"
|
||||
SKILL_BEFORE=2026-06-01 SKILL_OUT=watch_prejune.json python3 skill.py 2000
|
||||
echo "[clean] $(date '+%F %T') backtest: copy pre-June-1 favorites' June1+ entries"
|
||||
BT_WATCH=watch_prejune.json python3 backtest_june.py favorite
|
||||
echo "[clean] $(date '+%F %T') done"
|
||||
@@ -0,0 +1,45 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Collect EVERY candidate wallet's resolved bets into the cache, up to present.
|
||||
|
||||
One-time (per refresh window) comprehensive pull so the whole candidate pool is
|
||||
local. Resumable: cache.get_bets skips wallets pulled within MAX_AGE_DAYS, so
|
||||
killing and re-running continues where it left off. Most-active wallets first,
|
||||
so a partial cache already covers the wallets most likely to be skilled.
|
||||
|
||||
python3 collect.py
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
|
||||
import cache
|
||||
|
||||
HERE = os.path.dirname(__file__)
|
||||
WORKERS = 16
|
||||
|
||||
|
||||
def main():
|
||||
cands = json.load(open(os.path.join(HERE, "candidates.json")))
|
||||
cands.sort(key=lambda c: c.get("markets_seen", 0), reverse=True)
|
||||
wallets = [c["wallet"] for c in cands]
|
||||
print(f"collecting {len(wallets):,} wallets up to present · {WORKERS} workers", flush=True)
|
||||
done, t0 = 0, time.time()
|
||||
with ThreadPoolExecutor(max_workers=WORKERS) as ex:
|
||||
futs = [ex.submit(cache.get_bets, w) for w in wallets]
|
||||
for _ in as_completed(futs):
|
||||
done += 1
|
||||
if done % 200 == 0:
|
||||
w, b = cache.stats()
|
||||
rate = done / max(1e-9, time.time() - t0)
|
||||
eta = (len(wallets) - done) / max(1e-9, rate) / 3600
|
||||
print(f" {done:,}/{len(wallets):,} · cache {w:,}w/{b:,}bets · "
|
||||
f"{rate:.1f}/s · ETA {eta:.1f}h", flush=True)
|
||||
w, b = cache.stats()
|
||||
print(f"DONE {time.strftime('%F %T')} — cache: {w:,} wallets, {b:,} bets", flush=True)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+26
@@ -0,0 +1,26 @@
|
||||
#!/bin/bash
|
||||
# Daily skilled-wallet refresh, cache-backed:
|
||||
# 1) discover — enumerate traders of markets resolved in the last ~14 days,
|
||||
# merged into the accumulating candidate pool
|
||||
# 2) freshen — force a re-pull of the current watchlist (forward tracking),
|
||||
# then top up the cache (collect re-pulls only new + >14d-stale
|
||||
# wallets, so it's cheap after the initial collection)
|
||||
# 3) re-score — the 5-gate funnel, instant from cache -> watch_skilled.json
|
||||
# 4) dashboard — regenerate + snapshot for auditable forward history
|
||||
#
|
||||
# Schedule with launchd/cron (Mac must be awake). Logs to daily.log.
|
||||
set -u
|
||||
cd "$(dirname "$0")"
|
||||
echo "[daily] $(date '+%F %T') 1/4 discover (enumerate last 14d)"
|
||||
python3 enumerate.py 14
|
||||
echo "[daily] $(date '+%F %T') 2/4 freshen cache (watchlist forced + new wallets)"
|
||||
python3 -c "import json,os,cache
|
||||
if os.path.exists('watch_skilled.json'):
|
||||
cache.invalidate([w['wallet'] for w in json.load(open('watch_skilled.json'))])" 2>/dev/null || true
|
||||
python3 collect.py
|
||||
echo "[daily] $(date '+%F %T') 3/4 re-score (cache-backed, instant)"
|
||||
python3 skill.py
|
||||
echo "[daily] $(date '+%F %T') 4/4 dashboard"
|
||||
python3 dashboard.py
|
||||
mkdir -p history && cp watch_skilled.json "history/watch_$(date '+%Y%m%d').json" 2>/dev/null
|
||||
echo "[daily] $(date '+%F %T') done -> watch_skilled.json + dashboard.html"
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,173 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Generate a self-contained dashboard.html from watch_skilled.json.
|
||||
|
||||
Embeds the skilled-wallet snapshot (z, out-of-sample z, record, archetype, …)
|
||||
into a sortable/filterable dark dashboard with Polymarket profile links and
|
||||
on-demand live recent-trade lookup (data-api, client-side). Re-runnable — wire
|
||||
into daily.sh so the dashboard refreshes with the watchlist.
|
||||
|
||||
python3 dashboard.py # -> dashboard.html
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
|
||||
HERE = os.path.dirname(__file__)
|
||||
|
||||
|
||||
def archetype(r):
|
||||
if r["avg_entry"] < 0.5:
|
||||
return "value" # longshot / underdog value — the true alpha zone
|
||||
if r["avg_entry"] >= 0.85:
|
||||
return "favorite" # rides near-certain favorites (thin, less copyable)
|
||||
return "balanced"
|
||||
|
||||
|
||||
def main():
|
||||
w = json.load(open(os.path.join(HERE, "watch_skilled.json")))
|
||||
for i, r in enumerate(w, 1):
|
||||
r["rank"] = i
|
||||
r["arch"] = archetype(r)
|
||||
r["wins"] = int(round(r["win_rate"] * r["n"] / 100))
|
||||
gen = time.strftime("%Y-%m-%d %H:%M")
|
||||
med_z = sorted(x["z"] for x in w)[len(w) // 2]
|
||||
med_oos = sorted(x["z_oos"] for x in w if x["z_oos"] is not None)[len(w) // 2]
|
||||
n_val = sum(1 for x in w if x["arch"] == "value")
|
||||
n_fav = sum(1 for x in w if x["arch"] == "favorite")
|
||||
data = json.dumps(w)
|
||||
|
||||
html = HTML.replace("/*DATA*/", data).replace("{{GEN}}", gen) \
|
||||
.replace("{{COUNT}}", str(len(w))).replace("{{MEDZ}}", f"{med_z:.1f}") \
|
||||
.replace("{{MEDOOS}}", f"{med_oos:.1f}").replace("{{NVAL}}", str(n_val)) \
|
||||
.replace("{{NFAV}}", str(n_fav))
|
||||
out = os.path.join(HERE, "dashboard.html")
|
||||
open(out, "w").write(html)
|
||||
print(f"wrote {out} ({len(w)} wallets)")
|
||||
|
||||
|
||||
HTML = r"""<!doctype html><html lang="en"><head><meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width,initial-scale=1">
|
||||
<title>Skilled Wallets — Polymarket</title>
|
||||
<style>
|
||||
:root{--bg:#0b0e14;--card:#141925;--line:#222b3a;--dim:#8a97ad;--fg:#e8edf5;
|
||||
--green:#37d67a;--red:#ff5c6c;--amber:#ffcc55;--blue:#5b9dff;--violet:#b18cff}
|
||||
*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--fg);
|
||||
font:14px/1.5 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif}
|
||||
.wrap{max-width:1180px;margin:0 auto;padding:22px 16px 60px}
|
||||
h1{font-size:26px;margin:0 0 2px}.sub{color:var(--dim);margin:0 0 18px}
|
||||
.cards{display:flex;gap:12px;flex-wrap:wrap;margin-bottom:18px}
|
||||
.card{background:var(--card);border:1px solid var(--line);border-radius:12px;
|
||||
padding:12px 16px;min-width:120px}.card .k{color:var(--dim);font-size:12px}
|
||||
.card .v{font-size:22px;font-weight:700;margin-top:2px}
|
||||
.controls{display:flex;gap:10px;flex-wrap:wrap;margin-bottom:12px;align-items:center}
|
||||
input,select{background:var(--card);border:1px solid var(--line);color:var(--fg);
|
||||
border-radius:9px;padding:8px 11px;font-size:14px}
|
||||
input{flex:1;min-width:180px}
|
||||
.pill{padding:3px 9px;border-radius:999px;font-size:11px;font-weight:600;white-space:nowrap}
|
||||
.value{background:rgba(55,214,122,.15);color:var(--green)}
|
||||
.favorite{background:rgba(255,204,85,.15);color:var(--amber)}
|
||||
.balanced{background:rgba(91,157,255,.15);color:var(--blue)}
|
||||
table{width:100%;border-collapse:collapse;background:var(--card);
|
||||
border:1px solid var(--line);border-radius:12px;overflow:hidden}
|
||||
th,td{padding:10px 12px;text-align:right;border-bottom:1px solid var(--line);white-space:nowrap}
|
||||
th:first-child,td:first-child,th:nth-child(2),td:nth-child(2){text-align:left}
|
||||
th{color:var(--dim);font-size:12px;cursor:pointer;user-select:none;position:sticky;top:0;background:var(--card)}
|
||||
th:hover{color:var(--fg)}tr.row:hover{background:#1a2030;cursor:pointer}
|
||||
td.name{font-weight:600}a{color:var(--blue);text-decoration:none}a:hover{text-decoration:underline}
|
||||
.z{font-weight:700}.mono{font-family:ui-monospace,Menlo,monospace;color:var(--dim);font-size:12px}
|
||||
.det{background:#10141d;color:var(--dim);font-size:13px}
|
||||
.det td{text-align:left;white-space:normal}
|
||||
.bar{display:inline-block;height:7px;border-radius:4px;background:var(--violet);vertical-align:middle}
|
||||
.note{color:var(--dim);font-size:12px;margin-top:14px;line-height:1.6}
|
||||
.trade{display:flex;gap:8px;align-items:center;padding:3px 0;border-bottom:1px solid var(--line)}
|
||||
.b{color:var(--green)}.s{color:var(--red)}
|
||||
</style></head><body><div class="wrap">
|
||||
<h1>Skilled Wallets <span style="color:var(--dim);font-weight:400;font-size:18px">· Polymarket</span></h1>
|
||||
<p class="sub">{{COUNT}} wallets that beat their own entry prices and held up out-of-sample · generated {{GEN}}</p>
|
||||
<div class="cards">
|
||||
<div class="card"><div class="k">Validated wallets</div><div class="v">{{COUNT}}</div></div>
|
||||
<div class="card"><div class="k">Median z</div><div class="v">{{MEDZ}}</div></div>
|
||||
<div class="card"><div class="k">Median OOS z</div><div class="v" style="color:var(--green)">{{MEDOOS}}</div></div>
|
||||
<div class="card"><div class="k">Value / longshot</div><div class="v" style="color:var(--green)">{{NVAL}}</div></div>
|
||||
<div class="card"><div class="k">Favorite-rider</div><div class="v" style="color:var(--amber)">{{NFAV}}</div></div>
|
||||
</div>
|
||||
<div class="controls">
|
||||
<input id="q" placeholder="search name or address…">
|
||||
<select id="arch"><option value="">All archetypes</option>
|
||||
<option value="value">Value / longshot</option>
|
||||
<option value="balanced">Balanced</option>
|
||||
<option value="favorite">Favorite-rider</option></select>
|
||||
<select id="sort">
|
||||
<option value="z">Sort: z (skill)</option>
|
||||
<option value="z_oos">Sort: out-of-sample z</option>
|
||||
<option value="band_0204">Sort: alpha-zone %</option>
|
||||
<option value="n">Sort: # bets</option>
|
||||
<option value="win_rate">Sort: win rate</option>
|
||||
</select>
|
||||
</div>
|
||||
<table id="tbl"><thead><tr>
|
||||
<th data-k="rank">#</th><th data-k="name">Wallet</th>
|
||||
<th data-k="z">z</th><th data-k="z_oos">OOS z</th>
|
||||
<th data-k="n">bets</th><th data-k="win_rate">win%</th>
|
||||
<th data-k="avg_entry">avg entry</th><th data-k="band_0204">alpha 0.2–0.4</th>
|
||||
<th data-k="arch">type</th>
|
||||
</tr></thead><tbody id="body"></tbody></table>
|
||||
<p class="note"><b>How to read it.</b> <b>z</b> = how far the wallet beat the prices it paid (skill; >3 is strong). <b>OOS z</b> = whether that skill held on held-out bets — the gate that separates real edge from luck. <b>Alpha 0.2–0.4</b> = share of bets in the underdog value zone where research finds real edge concentrates. <span class="value" style="padding:1px 7px">Value</span> wallets win by beating longshot/mid prices (the copyable alpha); <span class="favorite" style="padding:1px 7px">Favorite-rider</span> wallets post high win rates buying near-certain favorites (real but thin, hard to copy). Click any row for live recent trades. Not financial advice — split-half OOS, forward-track before sizing.</p>
|
||||
</div>
|
||||
<script>
|
||||
const DATA=/*DATA*/;
|
||||
const fmtW=w=>w.length>14?w.slice(0,6)+'…'+w.slice(-4):w;
|
||||
let sortK='z',asc=false,open=null;
|
||||
const body=document.getElementById('body');
|
||||
function render(){
|
||||
const q=document.getElementById('q').value.toLowerCase();
|
||||
const af=document.getElementById('arch').value;
|
||||
let rows=DATA.filter(r=>(!af||r.arch===af)&&
|
||||
(!q||(r.name||'').toLowerCase().includes(q)||r.wallet.toLowerCase().includes(q)));
|
||||
rows.sort((a,b)=>{const x=a[sortK],y=b[sortK];return (asc?1:-1)*((x>y)-(x<y));});
|
||||
body.innerHTML=rows.map(r=>{
|
||||
const zc=r.z>=10?'var(--violet)':r.z>=6?'var(--green)':'var(--fg)';
|
||||
const oc=r.z_oos>=5?'var(--green)':r.z_oos>=3?'var(--amber)':'var(--red)';
|
||||
const bw=Math.round(r.band_0204*46);
|
||||
return `<tr class="row" data-w="${r.wallet}">
|
||||
<td>${r.rank}</td>
|
||||
<td class="name">${r.name||fmtW(r.wallet)}<div class="mono">${fmtW(r.wallet)}</div></td>
|
||||
<td class="z" style="color:${zc}">${r.z.toFixed(1)}</td>
|
||||
<td class="z" style="color:${oc}">${r.z_oos==null?'—':r.z_oos.toFixed(1)}</td>
|
||||
<td>${r.wins}/${r.n}</td>
|
||||
<td>${r.win_rate.toFixed(0)}%</td>
|
||||
<td>${r.avg_entry.toFixed(2)}</td>
|
||||
<td><span class="bar" style="width:${bw}px"></span> ${(r.band_0204*100).toFixed(0)}%</td>
|
||||
<td><span class="pill ${r.arch}">${r.arch}</span></td></tr>`;
|
||||
}).join('')||'<tr><td colspan="9" style="text-align:center;color:var(--dim);padding:24px">no matches</td></tr>';
|
||||
}
|
||||
body.addEventListener('click',async e=>{
|
||||
const tr=e.target.closest('tr.row'); if(!tr)return;
|
||||
const w=tr.dataset.w;
|
||||
const nx=tr.nextElementSibling;
|
||||
if(nx&&nx.classList.contains('det')){nx.remove();return;}
|
||||
document.querySelectorAll('tr.det').forEach(x=>x.remove());
|
||||
const d=document.createElement('tr');d.className='det';
|
||||
d.innerHTML=`<td colspan="9">loading recent trades… · <a href="https://polymarket.com/profile/${w}" target="_blank">open profile ↗</a></td>`;
|
||||
tr.after(d);
|
||||
try{
|
||||
const r=await fetch(`https://data-api.polymarket.com/activity?user=${w}&type=TRADE&limit=8`);
|
||||
const ts=await r.json();
|
||||
const rows=(ts||[]).map(t=>`<div class="trade"><span class="${t.side==='BUY'?'b':'s'}">${t.side}</span>
|
||||
<span>${(t.outcome||'')} · ${(t.title||'').slice(0,52)}</span>
|
||||
<span style="margin-left:auto;color:var(--dim)">${((t.price||0)*100).toFixed(0)}¢</span></div>`).join('');
|
||||
d.firstChild.innerHTML=`<a href="https://polymarket.com/profile/${w}" target="_blank">open profile ↗</a><div style="margin-top:6px">${rows||'no recent trades'}</div>`;
|
||||
}catch(err){d.firstChild.innerHTML=`<a href="https://polymarket.com/profile/${w}" target="_blank">open profile ↗</a> · live feed unavailable`;}
|
||||
});
|
||||
document.querySelectorAll('th').forEach(th=>th.onclick=()=>{
|
||||
const k=th.dataset.k; if(k===sortK)asc=!asc;else{sortK=k;asc=(k==='rank'||k==='avg_entry');} render();});
|
||||
document.getElementById('q').oninput=render;
|
||||
document.getElementById('arch').onchange=render;
|
||||
document.getElementById('sort').onchange=e=>{sortK=e.target.value;asc=false;render();};
|
||||
render();
|
||||
</script></body></html>"""
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,148 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Enumerate candidate wallets from markets resolved in the last N months.
|
||||
|
||||
The bulk subgraph is frozen at Jan 2026, so recent data comes from the LIVE
|
||||
data-api. We can't cheaply page every global trade back 6 months, but we don't
|
||||
need to: skilled traders concentrate in liquid markets and recur across many of
|
||||
them. So we source high-volume recently-resolved markets from Gamma, pull each
|
||||
market's top traders by notional (insider.market_traders), dedup, and tally how
|
||||
many markets each wallet shows up in (a prioritization signal for scoring).
|
||||
|
||||
Output: candidates.json -> scored by skill.py.
|
||||
|
||||
python3 enumerate.py # last 180 days, liquid markets
|
||||
python3 enumerate.py 90 # last 90 days
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import ssl
|
||||
import sys
|
||||
import time
|
||||
import urllib.request
|
||||
from collections import defaultdict
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
|
||||
import insider # noqa: E402
|
||||
|
||||
GAMMA = "https://gamma-api.polymarket.com/markets"
|
||||
CTX = ssl._create_unverified_context()
|
||||
WINDOW_DAYS = int(sys.argv[1]) if len(sys.argv) > 1 else 180
|
||||
MAX_MARKETS = 1200 # enough high-volume recent markets to surface recurring sharps
|
||||
MAX_SCAN = 25000 # stop scanning the volume ranking after this many markets
|
||||
TOP_TRADERS = 30 # top traders by notional per market
|
||||
MIN_VOLUME = 20000 # $ — focus on liquid markets where skilled traders play
|
||||
|
||||
|
||||
def gamma(params):
|
||||
q = "&".join(f"{k}={v}" for k, v in params.items())
|
||||
req = urllib.request.Request(f"{GAMMA}?{q}", headers={"User-Agent": "Mozilla/5.0"})
|
||||
return json.loads(urllib.request.urlopen(req, timeout=40, context=CTX).read())
|
||||
|
||||
|
||||
def _closed_ts(m):
|
||||
"""Parse Gamma's closedTime ('2026-05-12 06:44:09+00') -> epoch, else 0."""
|
||||
s = m.get("closedTime")
|
||||
if not s:
|
||||
return 0
|
||||
s = s.replace(" ", "T").split("+")[0].split(".")[0]
|
||||
try:
|
||||
return time.mktime(time.strptime(s, "%Y-%m-%dT%H:%M:%S"))
|
||||
except ValueError:
|
||||
return insider._parse_end(m.get("endDateIso")) # fallback to date
|
||||
|
||||
|
||||
def _page(offset, end_min):
|
||||
# end_date_min restricts to recently-resolved markets directly, so we don't
|
||||
# scan the whole (mostly-old) volume ranking. Retry once on transient error.
|
||||
for _ in range(2):
|
||||
try:
|
||||
return gamma({"limit": 100, "offset": offset, "closed": "true",
|
||||
"end_date_min": end_min, "order": "volume",
|
||||
"ascending": "false"})
|
||||
except Exception:
|
||||
time.sleep(2)
|
||||
return "ERR"
|
||||
|
||||
|
||||
def recent_markets():
|
||||
"""Markets that resolved within the window (via end_date_min), kept if liquid
|
||||
(volumeNum >= MIN_VOLUME and closedTime in window). Gamma is slow (~5-11s/
|
||||
page) so we page CONCURRENTLY in waves and stop at end-of-data or MAX_SCAN."""
|
||||
cutoff = time.time() - WINDOW_DAYS * 86400
|
||||
end_min = time.strftime("%Y-%m-%dT00:00:00Z", time.gmtime(cutoff))
|
||||
out, scanned, base, WAVE = [], 0, 0, 4 # low concurrency — gamma throttles bursts
|
||||
with ThreadPoolExecutor(max_workers=WAVE) as ex:
|
||||
while len(out) < MAX_MARKETS and scanned < MAX_SCAN:
|
||||
pages = list(ex.map(lambda o: _page(o, end_min),
|
||||
[base + i * 100 for i in range(WAVE)]))
|
||||
base += WAVE * 100
|
||||
ended = False
|
||||
for page in pages:
|
||||
if page == "ERR" or page is None:
|
||||
continue # skip transient gaps, keep going
|
||||
if len(page) < 100:
|
||||
ended = True # genuine end of data
|
||||
scanned += len(page)
|
||||
for m in page:
|
||||
try:
|
||||
vol = float(m.get("volumeNum") or 0)
|
||||
except (TypeError, ValueError):
|
||||
vol = 0
|
||||
if vol >= MIN_VOLUME and _closed_ts(m) >= cutoff and m.get("conditionId"):
|
||||
out.append((m["conditionId"], m.get("question", "?")[:60]))
|
||||
print(f" scanned {scanned:,}… kept {len(out)}", flush=True)
|
||||
if ended:
|
||||
break
|
||||
return out[:MAX_MARKETS]
|
||||
|
||||
|
||||
def main():
|
||||
print(f"sourcing markets resolved in last {WINDOW_DAYS}d (>= ${MIN_VOLUME:,} vol)…",
|
||||
flush=True)
|
||||
mkts = recent_markets()
|
||||
print(f" {len(mkts)} markets", flush=True)
|
||||
|
||||
seen, name = defaultdict(int), {}
|
||||
|
||||
def grab(cm):
|
||||
try:
|
||||
cands, _ = insider.market_traders(cm[0], top=TOP_TRADERS)
|
||||
return cands
|
||||
except Exception:
|
||||
return []
|
||||
|
||||
done = 0
|
||||
with ThreadPoolExecutor(max_workers=12) as ex:
|
||||
for cands in ex.map(grab, mkts):
|
||||
for c in cands:
|
||||
seen[c["wallet"]] += 1
|
||||
name.setdefault(c["wallet"], c["username"])
|
||||
done += 1
|
||||
if done % 500 == 0:
|
||||
print(f" {done}/{len(mkts)} markets · {len(seen):,} wallets", flush=True)
|
||||
|
||||
# merge with any existing candidates so daily re-runs ACCUMULATE the pool
|
||||
path = os.path.join(os.path.dirname(__file__), "candidates.json")
|
||||
merged = {}
|
||||
if os.path.exists(path):
|
||||
for c in json.load(open(path)):
|
||||
merged[c["wallet"]] = c
|
||||
new = 0
|
||||
for w, n in seen.items():
|
||||
if w in merged:
|
||||
merged[w]["markets_seen"] = max(merged[w].get("markets_seen", 0), n)
|
||||
merged[w].setdefault("username", name[w])
|
||||
else:
|
||||
merged[w] = {"wallet": w, "username": name[w], "markets_seen": n}
|
||||
new += 1
|
||||
rows = sorted(merged.values(), key=lambda c: c["markets_seen"], reverse=True)
|
||||
json.dump(rows, open(path, "w"))
|
||||
print(f"{len(rows):,} candidate wallets (+{new} new this run) -> candidates.json "
|
||||
f"({sum(1 for r in rows if r['markets_seen'] >= 15):,} seen in >=15 markets)",
|
||||
flush=True)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+159
@@ -0,0 +1,159 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Score candidate wallets for genuine skill — the ~3% the research identifies.
|
||||
|
||||
The 5-gate funnel (a wallet must pass all to count as skilled):
|
||||
1. >= MIN_N resolved bets in the window (assessability)
|
||||
2. z = (wins - Σp)/√Σp(1-p) clearly > 0 (beats its entry prices)
|
||||
3. survives Benjamini-Hochberg FDR across the scan (not luck-of-the-draw)
|
||||
4. split-half: skill in the earlier half persists in (out-of-sample — the
|
||||
the recent half (z_oos > 0) decisive gate)
|
||||
5. <= MAX_N bets (market-maker / bot proxy, since the data-api gives no
|
||||
reliable trade count) and not pure favorite-riding
|
||||
|
||||
This mirrors the LBS/Yale method (randomize direction 10k× ≈ the z benchmark;
|
||||
split-events persistence) and uses an UNBIASED win rate (insider.resolved_bets
|
||||
unions /positions + /closed-positions, so unredeemed losers are counted).
|
||||
|
||||
Refinements used for ranking: odds-band 0.2-0.4 concentration (where alpha
|
||||
concentrates per Hubble), entry timing / freshness available via insider.
|
||||
|
||||
python3 skill.py # score top candidates, write watch_skilled.json
|
||||
python3 skill.py 2500 # score the top 2500 candidates by activity
|
||||
"""
|
||||
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
|
||||
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
|
||||
import insider # noqa: E402
|
||||
import cache # noqa: E402 — local per-wallet bet cache (avoids re-pulling)
|
||||
|
||||
HERE = os.path.dirname(__file__)
|
||||
WINDOW_DAYS = 180
|
||||
MIN_N = 15 # floor to say anything (paper's skilled avg ~79)
|
||||
OOS_MIN_N = 24 # need >=12 bets/half for a meaningful split
|
||||
MAX_N = 2500 # market-maker/bot proxy (no trade count available)
|
||||
FDR_Q = 0.05
|
||||
SCORE_TOP = int(sys.argv[1]) if len(sys.argv) > 1 else 2000 # cap scoring cost
|
||||
WORKERS = 10
|
||||
# clean out-of-sample re-selection: SKILL_BEFORE=YYYY-MM-DD scores ONLY bets
|
||||
# resolved before that date, so selection can't peek at the test window.
|
||||
BEFORE = (time.mktime(time.strptime(os.environ["SKILL_BEFORE"], "%Y-%m-%d"))
|
||||
if os.environ.get("SKILL_BEFORE") else 0)
|
||||
OUT = os.environ.get("SKILL_OUT", "watch_skilled.json")
|
||||
|
||||
|
||||
def zstats(bets):
|
||||
n = len(bets)
|
||||
if not n:
|
||||
return 0, 0, 0.0, 0.0
|
||||
wins = sum(1 for b in bets if b["won"])
|
||||
exp = sum(b["p"] for b in bets)
|
||||
var = sum(b["p"] * (1 - b["p"]) for b in bets) or 1e-9
|
||||
return n, wins, exp, (wins - exp) / math.sqrt(var)
|
||||
|
||||
|
||||
def score_wallet(c):
|
||||
bets = cache.get_bets(c["wallet"]) # cached — pulls the data-api only once per wallet
|
||||
if BEFORE: # clean OOS: only bets resolved before cutoff
|
||||
bets = [b for b in bets if (b.get("res_t") or 0) < BEFORE]
|
||||
n = len(bets)
|
||||
if n < MIN_N or n > MAX_N:
|
||||
return None
|
||||
n, wins, exp, z = zstats(bets)
|
||||
# split-half out-of-sample (chronological): does early skill persist forward?
|
||||
bets.sort(key=lambda b: b.get("res_t") or 0)
|
||||
if n >= OOS_MIN_N:
|
||||
h = n // 2
|
||||
_, _, _, z_is = zstats(bets[:h])
|
||||
_, _, _, z_oos = zstats(bets[h:])
|
||||
else:
|
||||
z_is = z_oos = None
|
||||
band = sum(1 for b in bets if 0.2 <= b["p"] <= 0.4) / n
|
||||
avg_p = sum(b["p"] for b in bets) / n
|
||||
return {
|
||||
"wallet": c["wallet"], "username": c.get("username") or c["wallet"][:10],
|
||||
"n": n, "wins": wins, "win_rate": round(100 * wins / n, 1),
|
||||
"exp_wins": round(exp, 1), "z": round(z, 2), "pval": insider.norm_sf(z),
|
||||
"z_is": None if z_is is None else round(z_is, 2),
|
||||
"z_oos": None if z_oos is None else round(z_oos, 2),
|
||||
"avg_entry": round(avg_p, 2), "band_0204": round(band, 2),
|
||||
"markets_seen": c.get("markets_seen", 0),
|
||||
}
|
||||
|
||||
|
||||
def bh_threshold(rows, q):
|
||||
m = len(rows)
|
||||
if not m:
|
||||
return 0.0
|
||||
ps = sorted(r["pval"] for r in rows)
|
||||
k = 0
|
||||
for i, p in enumerate(ps, 1):
|
||||
if p <= q * i / m:
|
||||
k = i
|
||||
return ps[k - 1] if k else 0.0
|
||||
|
||||
|
||||
def main():
|
||||
cands = json.load(open(os.path.join(HERE, "candidates.json")))
|
||||
cands.sort(key=lambda c: c.get("markets_seen", 0), reverse=True)
|
||||
cands = cands[:SCORE_TOP]
|
||||
print(f"scoring {len(cands):,} candidates (window {WINDOW_DAYS}d, "
|
||||
f"min_n {MIN_N}, max_n {MAX_N})…", flush=True)
|
||||
|
||||
rows, done = [], 0
|
||||
with ThreadPoolExecutor(max_workers=WORKERS) as ex:
|
||||
futs = {ex.submit(score_wallet, c): c for c in cands}
|
||||
for f in as_completed(futs):
|
||||
r = f.result()
|
||||
if r:
|
||||
rows.append(r)
|
||||
done += 1
|
||||
if done % 200 == 0:
|
||||
print(f" {done}/{len(cands)} scored · {len(rows)} with >= {MIN_N} bets",
|
||||
flush=True)
|
||||
|
||||
if not rows:
|
||||
print("no wallets cleared the bet minimum.")
|
||||
return
|
||||
thresh = bh_threshold(rows, FDR_Q)
|
||||
|
||||
# the skilled set: FDR-significant AND out-of-sample-positive
|
||||
skilled = [r for r in rows
|
||||
if thresh > 0 and r["pval"] <= thresh
|
||||
and (r["z_oos"] is None or r["z_oos"] > 0)]
|
||||
# tier: "validated" = enough bets for a real OOS split and it held
|
||||
for r in skilled:
|
||||
r["tier"] = ("validated" if (r["z_oos"] is not None and r["z_oos"] > 0)
|
||||
else "candidate")
|
||||
skilled.sort(key=lambda r: (r["tier"] == "validated", r["z"]), reverse=True)
|
||||
|
||||
# z-weighted watchlist, compatible with webhook_receiver (wallet/name/weight)
|
||||
tot = sum(r["z"] for r in skilled) or 1
|
||||
watch = [{"wallet": r["wallet"], "name": r["username"],
|
||||
"weight": round(r["z"] / tot, 4), "tier": r["tier"],
|
||||
"z": r["z"], "z_oos": r["z_oos"], "n": r["n"],
|
||||
"win_rate": r["win_rate"], "avg_entry": r["avg_entry"],
|
||||
"band_0204": r["band_0204"]} for r in skilled]
|
||||
json.dump(watch, open(os.path.join(HERE, OUT), "w"), indent=2)
|
||||
json.dump(rows, open(os.path.join(HERE, OUT.replace(".json", "_scored.json")), "w"))
|
||||
|
||||
val = sum(1 for r in skilled if r["tier"] == "validated")
|
||||
print(f"\nscored {len(rows):,} wallets · BH@{int(FDR_Q*100)}% threshold p<= {thresh:.1e}")
|
||||
print(f"SKILLED: {len(skilled)} ({val} validated OOS, {len(skilled)-val} candidate) "
|
||||
f"-> watch_skilled.json\n")
|
||||
hdr = f"{'tier':>10}{'z':>6}{'z_oos':>6}{'rec':>12}{'win%':>6}{'avgP':>6}{'0.2-0.4':>8} wallet"
|
||||
print(hdr); print("-" * len(hdr))
|
||||
for r in skilled[:40]:
|
||||
oos = "n/a" if r["z_oos"] is None else f"{r['z_oos']:.1f}"
|
||||
rec = f"{r['wins']}/{r['n']}"
|
||||
print(f"{r['tier']:>10}{r['z']:>6.1f}{oos:>6}{rec:>12}"
|
||||
f"{r['win_rate']:>5.0f}%{r['avg_entry']:>6.2f}{r['band_0204']:>8.2f} {r['username'][:18]}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,71 @@
|
||||
# wide/ — bulk subgraph edge scanner
|
||||
|
||||
Find wallets with a real edge across **all** of Polymarket (~1.76M traders,
|
||||
268k conditions) by bulk-ingesting the on-chain subgraph into a local DuckDB
|
||||
and ranking with SQL — instead of per-wallet API calls (which cap out at a few
|
||||
hundred wallets and rate-limit).
|
||||
|
||||
## Why a local DB, not the API
|
||||
|
||||
The Goldsky orderbook subgraph **times out on any `orderBy`** over a
|
||||
non-indexed field (`numTrades`, `scaledProfit`, …). You cannot ask it for "top
|
||||
wallets." The only scalable pattern is: cursor-paginate every row by `id` (the
|
||||
indexed key), land it locally, and rank in DuckDB. That constraint *is* the
|
||||
architecture.
|
||||
|
||||
## Why the win rate here is honest
|
||||
|
||||
The data-api hides losers: Polymarket only redeems winning shares, so losing
|
||||
positions sit unredeemed and never enter `/closed-positions`. Measuring win
|
||||
rate there reads ~90% when the truth is ~50% (see ../FINDINGS.md). The subgraph
|
||||
records a `marketPosition` for **every** buy regardless of redemption, so the
|
||||
survivorship bias structurally does not exist in this data.
|
||||
|
||||
## What "edge" means
|
||||
|
||||
A high win rate is not edge — you can hit 90% by only buying 95¢ favorites.
|
||||
Edge is **beating the prices you paid**:
|
||||
|
||||
```
|
||||
p = valueBought / quantityBought (entry price, 0..1)
|
||||
won = the outcome you held paid out
|
||||
z = (wins − Σp) / sqrt(Σ p(1−p)) standard deviations above odds-implied
|
||||
```
|
||||
|
||||
`z` high over enough bets, on a wallet that isn't a market-maker, is the real
|
||||
signal (the same one ../insider.py computes, here over the entire market).
|
||||
|
||||
## Pipeline
|
||||
|
||||
| step | script | source | notes |
|
||||
|------|--------|--------|-------|
|
||||
| 1 | `ingest.py conditions` | subgraph | resolution + payoutNumerators → winning outcome |
|
||||
| 2 | `gamma_tokens.py` | Gamma | token_id → (condition, outcome_index); subgraph's `outcomeIndex` is null |
|
||||
| 3 | `ingest.py accounts` | subgraph | `numTrades` (market-maker filter), `creationTimestamp` (freshness) |
|
||||
| 4 | `ingest.py market_positions` | subgraph | the heavy table: entry price + win/loss per bet |
|
||||
| 5 | `score.py` | DuckDB | z, true win rate, profit + FDR + out-of-sample |
|
||||
|
||||
All ingests are **resumable** (per-table `id` cursor in `_cursor`), so a long
|
||||
run can be stopped and restarted. Tables join in `edge.sql`.
|
||||
|
||||
## Guardrails (so a 1.76M-wallet scan doesn't just surface luck)
|
||||
|
||||
- **min-n + market-maker cap.** A 300k-trade grinder posts huge z with no
|
||||
information. Require ≥30 resolved bets and cap `numTrades`.
|
||||
- **Benjamini–Hochberg FDR.** Scan 100k wallets and thousands clear z>3 by
|
||||
chance (look-elsewhere effect). `score.py` reports how many survive 5% FDR.
|
||||
- **Out-of-sample.** `score.py --cutoff YYYY-MM-DD` selects wallets on bets
|
||||
resolved before the date, then measures the *same* wallets forward. Edge that
|
||||
is real persists; edge that is curve-fit reverts to z≈0 — which is what every
|
||||
strategy in ../FINDINGS.md did. **Do not size up on in-sample z.**
|
||||
|
||||
## Usage
|
||||
|
||||
```bash
|
||||
pip install duckdb
|
||||
python3 ingest.py conditions accounts # small tables
|
||||
python3 gamma_tokens.py # token→outcome map
|
||||
python3 ingest.py -p market_positions # heavy (~53M rows); parallel + resumable
|
||||
python3 score.py --min-n 15 --max-trades 5000 --top 40
|
||||
python3 score.py --cutoff 2026-04-30 --min-n 15 # in-sample vs forward
|
||||
```
|
||||
@@ -0,0 +1,83 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Build token -> (condition, outcome_index, winner) from the CLOB /markets feed.
|
||||
|
||||
Gamma offset-paginates and 422s past ~10k markets; the subgraph's outcomeIndex
|
||||
is null. CLOB /markets cursor-paginates the full market set (no offset cap),
|
||||
1000 per page, and each token carries `winner` directly — so win/loss comes
|
||||
straight from here instead of parsing payoutNumerators.
|
||||
|
||||
python3 clob_tokens.py # page all markets, fill market_data
|
||||
"""
|
||||
|
||||
import json
|
||||
import ssl
|
||||
import time
|
||||
import urllib.request
|
||||
|
||||
import duckdb
|
||||
|
||||
DB = "pmkt.duckdb"
|
||||
CLOB = "https://clob.polymarket.com/markets"
|
||||
_CTX = ssl._create_unverified_context()
|
||||
END = "LTE=" # CLOB's end-of-pagination cursor (base64 of -1)
|
||||
|
||||
|
||||
def get(cursor, retries=6):
|
||||
url = CLOB + (f"?next_cursor={cursor}" if cursor else "")
|
||||
delay = 1.0
|
||||
for attempt in range(retries):
|
||||
try:
|
||||
req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
|
||||
return json.loads(urllib.request.urlopen(req, timeout=40, context=_CTX).read())
|
||||
except Exception:
|
||||
if attempt == retries - 1:
|
||||
raise
|
||||
time.sleep(delay); delay = min(delay * 2, 20)
|
||||
|
||||
|
||||
def main():
|
||||
con = duckdb.connect(DB)
|
||||
con.execute("""CREATE TABLE IF NOT EXISTS market_data (
|
||||
token_id TEXT PRIMARY KEY, condition_id TEXT,
|
||||
outcome_index INT, winner BOOLEAN);""")
|
||||
con.execute("CREATE TABLE IF NOT EXISTS _cursor (table_name TEXT PRIMARY KEY, last_id TEXT);")
|
||||
row = con.execute("SELECT last_id FROM _cursor WHERE table_name='market_data#clob'").fetchone()
|
||||
cursor = row[0] if row else "" # resume from saved CLOB cursor
|
||||
total, pages, t0 = 0, 0, time.time()
|
||||
if cursor:
|
||||
print(f"resuming token map from cursor {cursor}", flush=True)
|
||||
while cursor != END:
|
||||
d = get(cursor)
|
||||
rows = []
|
||||
for m in d.get("data", []):
|
||||
cond = m.get("condition_id")
|
||||
toks = m.get("tokens") or []
|
||||
if not cond:
|
||||
continue
|
||||
for idx, t in enumerate(toks): # tokens ordered by outcome
|
||||
tid = t.get("token_id")
|
||||
if tid:
|
||||
rows.append((str(tid), cond, idx, bool(t.get("winner"))))
|
||||
pages += 1
|
||||
nxt = d.get("next_cursor")
|
||||
if rows:
|
||||
con.execute("BEGIN TRANSACTION")
|
||||
con.executemany("INSERT OR IGNORE INTO market_data VALUES (?,?,?,?)", rows)
|
||||
# checkpoint the NEXT cursor so a resume continues past this page
|
||||
con.execute("INSERT OR REPLACE INTO _cursor VALUES ('market_data#clob', ?)",
|
||||
[nxt or cursor])
|
||||
con.execute("COMMIT")
|
||||
total += len(rows)
|
||||
if not nxt or nxt == cursor: # safety: no progress
|
||||
break
|
||||
cursor = nxt
|
||||
if pages % 25 == 0:
|
||||
print(f" {pages} pages · {total:,} tokens ({total/max(1e-9,time.time()-t0):,.0f}/s)", flush=True)
|
||||
cnt = con.execute("SELECT count(*) FROM market_data").fetchone()[0]
|
||||
won = con.execute("SELECT count(*) FROM market_data WHERE winner").fetchone()[0]
|
||||
print(f"done — {cnt:,} token rows ({won:,} winning) over {pages} pages", flush=True)
|
||||
con.close()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,47 @@
|
||||
-- Per-wallet edge over RESOLVED markets, computed entirely in DuckDB.
|
||||
--
|
||||
-- The join chain: market_positions (a wallet's buy in one outcome token)
|
||||
-- -> market_data (token -> condition + outcome_index)
|
||||
-- -> conditions (resolution + payoutNumerators -> which outcome won).
|
||||
--
|
||||
-- Why this beats the data-api: market_positions records a buy whether or not
|
||||
-- the wallet redeemed, so losers are NOT hidden. The survivorship bias that
|
||||
-- makes /closed-positions read 90% (truly 48%) does not exist here.
|
||||
--
|
||||
-- entry price p = valueBought / quantityBought (USDC 6dp / shares 6dp -> 0..1)
|
||||
-- won = payoutNumerators[outcome_index] != 0
|
||||
-- z = (wins - Σp) / sqrt(Σ p(1-p)) -- wins above what odds implied
|
||||
--
|
||||
-- :cutoff_ts binds an out-of-sample boundary. Pass 0 to score everything.
|
||||
|
||||
WITH bet AS (
|
||||
SELECT
|
||||
mp.user_id,
|
||||
c.resolution_ts,
|
||||
LEAST(0.999, GREATEST(0.001,
|
||||
mp.val_bought::DOUBLE / mp.qty_bought)) AS p,
|
||||
CASE WHEN md.winner THEN 1 ELSE 0 END AS won
|
||||
FROM market_positions mp
|
||||
JOIN market_data md ON md.token_id = mp.token_id
|
||||
JOIN conditions c ON c.id = md.condition_id
|
||||
WHERE mp.qty_bought > 0
|
||||
AND c.resolution_ts > 0
|
||||
)
|
||||
SELECT
|
||||
b.user_id,
|
||||
count(*) AS n,
|
||||
sum(b.won) AS wins,
|
||||
round(sum(b.p), 1) AS exp_wins,
|
||||
round(100.0 * sum(b.won) / count(*), 1) AS win_rate,
|
||||
round((sum(b.won) - sum(b.p))
|
||||
/ sqrt(nullif(sum(b.p * (1 - b.p)), 0)), 2) AS z,
|
||||
round(avg(b.p), 3) AS avg_entry,
|
||||
a.scaled_profit AS profit,
|
||||
a.scaled_volume AS volume,
|
||||
a.creation_ts
|
||||
FROM bet b
|
||||
LEFT JOIN accounts a ON a.id = b.user_id
|
||||
WHERE b.resolution_ts <= :cutoff_ts OR :cutoff_ts = 0
|
||||
GROUP BY b.user_id, a.scaled_profit, a.scaled_volume, a.creation_ts
|
||||
HAVING count(*) >= :min_n
|
||||
ORDER BY z DESC;
|
||||
+217
@@ -0,0 +1,217 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Bulk-ingest the Polymarket subgraph into a local DuckDB (pmkt.duckdb).
|
||||
|
||||
Each table is cursor-paginated by id and resumable: we checkpoint the last
|
||||
id seen, and re-running continues where it left off (INSERT OR IGNORE makes
|
||||
overlap harmless). All ranking/scoring happens later in SQL — see edge.sql.
|
||||
|
||||
python3 ingest.py conditions market_data accounts # the small tables
|
||||
python3 ingest.py market_positions # the heavy table
|
||||
python3 ingest.py all
|
||||
"""
|
||||
|
||||
import queue
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
|
||||
import duckdb
|
||||
|
||||
import subgraph as sg
|
||||
|
||||
DB = "pmkt.duckdb"
|
||||
BATCH = 5000
|
||||
|
||||
SCHEMA = """
|
||||
CREATE TABLE IF NOT EXISTS conditions (
|
||||
id TEXT PRIMARY KEY, resolution_ts BIGINT,
|
||||
payout_num TEXT, payout_den BIGINT, slots INT);
|
||||
CREATE TABLE IF NOT EXISTS market_data (
|
||||
token_id TEXT PRIMARY KEY, condition_id TEXT, outcome_index INT);
|
||||
CREATE TABLE IF NOT EXISTS accounts (
|
||||
id TEXT PRIMARY KEY, num_trades BIGINT, creation_ts BIGINT,
|
||||
scaled_profit DOUBLE, scaled_volume DOUBLE);
|
||||
CREATE TABLE IF NOT EXISTS market_positions (
|
||||
id TEXT PRIMARY KEY, user_id TEXT, token_id TEXT,
|
||||
qty_bought HUGEINT, val_bought HUGEINT, net_qty HUGEINT);
|
||||
CREATE TABLE IF NOT EXISTS _cursor (table_name TEXT PRIMARY KEY, last_id TEXT);
|
||||
"""
|
||||
|
||||
# entity -> (graphql_fields, where_clause, row_mapper, target_table, columns)
|
||||
def _i(x, d=0):
|
||||
try:
|
||||
return int(x)
|
||||
except (TypeError, ValueError):
|
||||
return d
|
||||
|
||||
def _f(x, d=0.0):
|
||||
try:
|
||||
return float(x)
|
||||
except (TypeError, ValueError):
|
||||
return d
|
||||
|
||||
SPECS = {
|
||||
"conditions": dict(
|
||||
entity="conditions",
|
||||
fields="id resolutionTimestamp payoutNumerators payoutDenominator outcomeSlotCount",
|
||||
where="",
|
||||
table="conditions",
|
||||
cols=("id", "resolution_ts", "payout_num", "payout_den", "slots"),
|
||||
row=lambda c: (c["id"], _i(c.get("resolutionTimestamp")),
|
||||
",".join(c.get("payoutNumerators") or []),
|
||||
_i(c.get("payoutDenominator")), _i(c.get("outcomeSlotCount"))),
|
||||
),
|
||||
# NOTE: market_data (token -> outcome) comes from Gamma, not the subgraph —
|
||||
# the subgraph's marketData.outcomeIndex is null. See gamma_tokens.py.
|
||||
"accounts": dict(
|
||||
entity="accounts",
|
||||
fields="id numTrades creationTimestamp scaledProfit scaledCollateralVolume",
|
||||
where="",
|
||||
table="accounts",
|
||||
cols=("id", "num_trades", "creation_ts", "scaled_profit", "scaled_volume"),
|
||||
row=lambda a: (a["id"], _i(a.get("numTrades")), _i(a.get("creationTimestamp")),
|
||||
_f(a.get("scaledProfit")), _f(a.get("scaledCollateralVolume"))),
|
||||
),
|
||||
# marketPosition.id == user_address (0x + 40 hex = 42 chars) + token_id
|
||||
# (decimal). We split it out instead of selecting the nested user/market
|
||||
# objects, which the subgraph errors on when `market` is null.
|
||||
"market_positions": dict(
|
||||
entity="marketPositions",
|
||||
fields="id quantityBought valueBought netQuantity",
|
||||
where="",
|
||||
table="market_positions",
|
||||
cols=("id", "user_id", "token_id", "qty_bought", "val_bought", "net_qty"),
|
||||
row=lambda p: (p["id"], p["id"][:42], p["id"][42:],
|
||||
_i(p.get("quantityBought")), _i(p.get("valueBought")),
|
||||
_i(p.get("netQuantity"))),
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
def ingest(con, name, limit=0):
|
||||
spec = SPECS[name]
|
||||
last = con.execute("SELECT last_id FROM _cursor WHERE table_name=?", [name]).fetchone()
|
||||
start = last[0] if last else ""
|
||||
placeholders = ",".join("?" * len(spec["cols"]))
|
||||
insert = (f"INSERT OR IGNORE INTO {spec['table']} "
|
||||
f"({','.join(spec['cols'])}) VALUES ({placeholders})")
|
||||
buf, total, t0, last_seen = [], 0, time.time(), start
|
||||
|
||||
def flush(cursor_id):
|
||||
nonlocal buf
|
||||
if buf:
|
||||
con.executemany(insert, buf)
|
||||
buf = []
|
||||
con.execute("INSERT OR REPLACE INTO _cursor VALUES (?, ?)", [name, cursor_id])
|
||||
|
||||
print(f"[{name}] resuming from id={start[:14] or '(start)'}", flush=True)
|
||||
for row in sg.paginate(spec["entity"], spec["fields"], where=spec["where"], start_id=start):
|
||||
buf.append(spec["row"](row))
|
||||
total += 1
|
||||
last_seen = row["id"]
|
||||
if len(buf) >= BATCH:
|
||||
flush(last_seen)
|
||||
rate = total / max(1e-9, time.time() - t0)
|
||||
print(f"[{name}] {total:>9,} ({rate:,.0f}/s)", flush=True)
|
||||
if limit and total >= limit:
|
||||
break
|
||||
flush(last_seen) # remaining buffer + advance cursor to the last id seen
|
||||
cnt = con.execute(f"SELECT count(*) FROM {spec['table']}").fetchone()[0]
|
||||
print(f"[{name}] done — {total:,} pulled this run, {cnt:,} rows total", flush=True)
|
||||
|
||||
|
||||
def ingest_parallel(con, name, shards=16):
|
||||
"""Page `shards` id-ranges concurrently; workers fetch and enqueue, this
|
||||
(single) thread writes to DuckDB and checkpoints each shard's cursor.
|
||||
~`shards`× the sequential throughput, and fully resumable per shard."""
|
||||
spec = SPECS[name]
|
||||
bounds = sg.shard_bounds(shards)
|
||||
placeholders = ",".join("?" * len(spec["cols"]))
|
||||
insert = (f"INSERT OR IGNORE INTO {spec['table']} "
|
||||
f"({','.join(spec['cols'])}) VALUES ({placeholders})")
|
||||
starts = {}
|
||||
for i in range(shards):
|
||||
row = con.execute("SELECT last_id FROM _cursor WHERE table_name=?",
|
||||
[f"{name}#{i:02d}"]).fetchone()
|
||||
starts[i] = row[0] if row else ""
|
||||
q = queue.Queue(maxsize=400)
|
||||
DONE = object()
|
||||
|
||||
def worker(i):
|
||||
try:
|
||||
for rows, last in sg.paginate_pages(spec["entity"], spec["fields"],
|
||||
lo=bounds[i], hi=bounds[i + 1],
|
||||
start_id=starts[i]):
|
||||
q.put((i, [spec["row"](r) for r in rows], last))
|
||||
except Exception as e:
|
||||
q.put((i, "ERR", str(e)[:120]))
|
||||
q.put((i, DONE, None))
|
||||
|
||||
for i in range(shards):
|
||||
threading.Thread(target=worker, args=(i,), daemon=True).start()
|
||||
|
||||
# DuckDB fsyncs per commit, so committing each page caps us at the writer
|
||||
# (~380/s) while fetch concurrency does ~4,600/s. Buffer many pages and
|
||||
# commit in one transaction to amortize the fsync.
|
||||
COMMIT_ROWS = 25000
|
||||
finished, total, t0 = 0, 0, time.time()
|
||||
buf, shard_last = [], {}
|
||||
|
||||
def flush():
|
||||
nonlocal buf
|
||||
if not buf:
|
||||
return
|
||||
con.execute("BEGIN TRANSACTION")
|
||||
con.executemany(insert, buf)
|
||||
for sh, lid in shard_last.items():
|
||||
con.execute("INSERT OR REPLACE INTO _cursor VALUES (?, ?)",
|
||||
[f"{name}#{sh:02d}", lid])
|
||||
con.execute("COMMIT")
|
||||
buf = []
|
||||
|
||||
print(f"[{name}] {shards} parallel shards", flush=True)
|
||||
while finished < shards:
|
||||
i, payload, last = q.get()
|
||||
if payload is DONE:
|
||||
finished += 1
|
||||
continue
|
||||
if payload == "ERR":
|
||||
print(f"[{name}] shard {i:02d} error: {last}", flush=True)
|
||||
continue
|
||||
buf.extend(payload)
|
||||
shard_last[i] = last
|
||||
total += len(payload)
|
||||
if len(buf) >= COMMIT_ROWS:
|
||||
flush()
|
||||
rate = total / max(1e-9, time.time() - t0)
|
||||
print(f"[{name}] {total:>10,} ({rate:,.0f}/s, {finished}/{shards} shards done)",
|
||||
flush=True)
|
||||
flush()
|
||||
cnt = con.execute(f"SELECT count(*) FROM {spec['table']}").fetchone()[0]
|
||||
print(f"[{name}] done — {total:,} pulled this run, {cnt:,} rows total", flush=True)
|
||||
|
||||
|
||||
def main(argv):
|
||||
parallel = False
|
||||
if argv and argv[0] in ("-p", "--parallel"):
|
||||
parallel = True; argv = argv[1:]
|
||||
limit = 0
|
||||
if argv and argv[-1].isdigit(): # optional trailing row-limit (per table)
|
||||
limit = int(argv[-1]); argv = argv[:-1]
|
||||
targets = argv or ["all"]
|
||||
if targets == ["all"]:
|
||||
targets = ["conditions", "accounts", "market_positions"]
|
||||
con = duckdb.connect(DB)
|
||||
con.execute(SCHEMA)
|
||||
for t in targets:
|
||||
if t not in SPECS:
|
||||
print(f"unknown table: {t}", file=sys.stderr); continue
|
||||
if parallel and not limit:
|
||||
ingest_parallel(con, t)
|
||||
else:
|
||||
ingest(con, t, limit)
|
||||
con.close()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main(sys.argv[1:])
|
||||
Executable
+31
@@ -0,0 +1,31 @@
|
||||
#!/bin/bash
|
||||
# Massive ingest of the wallet data we still need, from the FAST subgraph
|
||||
# (accounts + market_positions). The CLOB token map is already sufficient
|
||||
# (1.27M tokens covering every resolved condition), so it's NOT re-run here —
|
||||
# run `python3 clob_tokens.py` separately if you want to refresh it.
|
||||
#
|
||||
# Both steps are parallel (16 id-shards) and resumable (per-shard cursors), so
|
||||
# killing and re-running continues from the last checkpoint.
|
||||
#
|
||||
# nohup ./run_full.sh > run_full.log 2>&1 < /dev/null & disown
|
||||
# tail -f run_full.log
|
||||
set -u
|
||||
cd "$(dirname "$0")"
|
||||
|
||||
until python3 -c "import duckdb;duckdb.connect('pmkt.duckdb',read_only=True).close()" 2>/dev/null; do
|
||||
sleep 5
|
||||
done
|
||||
|
||||
echo "[run] $(date '+%F %T') 1/2 accounts (parallel, resumable) …"
|
||||
python3 ingest.py -p accounts
|
||||
|
||||
echo "[run] $(date '+%F %T') 2/2 market_positions (parallel, resumable, the big one) …"
|
||||
python3 ingest.py -p market_positions
|
||||
|
||||
echo "[run] $(date '+%F %T') DONE"
|
||||
python3 - <<'PY'
|
||||
import duckdb
|
||||
c = duckdb.connect("pmkt.duckdb", read_only=True)
|
||||
for t in ("conditions", "market_data", "accounts", "market_positions"):
|
||||
print(f" {t:18} {c.execute('select count(*) from '+t).fetchone()[0]:,}")
|
||||
PY
|
||||
+145
@@ -0,0 +1,145 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Rank wallets by edge from the ingested DuckDB — with the guardrails that
|
||||
stop a massive scan from just surfacing luck.
|
||||
|
||||
Edge metric: z = (wins - Σp)/√Σp(1-p), wins above what entry odds implied.
|
||||
A high win rate alone is meaningless (buy 95¢ favorites -> 90% wins, no edge),
|
||||
and on this data win rate isn't even biased-high the way the data-api is.
|
||||
|
||||
Guardrails:
|
||||
* min_n resolved bets and a market-maker cap on num_trades (a 300k-trade
|
||||
grinder posts huge z with no information — see FINDINGS.md / bjprolo).
|
||||
* Benjamini-Hochberg FDR: scan 100k wallets and thousands clear z>3 by
|
||||
chance. We report how many survive a 5% false-discovery rate.
|
||||
* Out-of-sample: --cutoff scores wallets on bets resolved on/before a date,
|
||||
then measures the SAME wallets forward. Edge that's real persists; edge
|
||||
that's curve-fit (every strategy we tested) reverts to z~0 / 50%.
|
||||
|
||||
python3 score.py --min-n 30 --max-trades 5000 --top 40
|
||||
python3 score.py --cutoff 2026-04-30 --min-n 30 # in-sample vs forward
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import math
|
||||
import time
|
||||
|
||||
import duckdb
|
||||
|
||||
DB = "pmkt.duckdb"
|
||||
|
||||
|
||||
def norm_sf(z):
|
||||
"""One-sided P(Z > z): the probability this z came from luck."""
|
||||
return 0.5 * math.erfc(z / math.sqrt(2)) if z is not None else 1.0
|
||||
|
||||
|
||||
def load_sql(cutoff_ts, min_n):
|
||||
sql = open("edge.sql").read()
|
||||
# these are ints we control (not user strings) -> safe to template
|
||||
return sql.replace(":cutoff_ts", str(int(cutoff_ts))).replace(":min_n", str(int(min_n)))
|
||||
|
||||
|
||||
def rank(con, cutoff_ts, min_n, max_n):
|
||||
rows = con.execute(load_sql(cutoff_ts, min_n)).fetchall()
|
||||
cols = [d[0] for d in con.description]
|
||||
out = []
|
||||
for r in rows:
|
||||
d = dict(zip(cols, r))
|
||||
# num_trades is null in this subgraph, so use the resolved-bet count as
|
||||
# the market-maker proxy: a wallet with thousands of bets is grinding a
|
||||
# systematic edge (bjprolo-style), not trading on information.
|
||||
if max_n and d["n"] > max_n:
|
||||
continue
|
||||
d["pval"] = norm_sf(d["z"])
|
||||
out.append(d)
|
||||
return out
|
||||
|
||||
|
||||
def bh_fdr(rows, q=0.05):
|
||||
"""Benjamini-Hochberg: how many discoveries survive a q false-discovery rate."""
|
||||
m = len(rows)
|
||||
if not m:
|
||||
return 0, 1.0
|
||||
ps = sorted(r["pval"] for r in rows)
|
||||
k = 0
|
||||
for i, p in enumerate(ps, 1):
|
||||
if p <= q * i / m:
|
||||
k = i
|
||||
thresh = ps[k - 1] if k else 0.0
|
||||
return k, thresh
|
||||
|
||||
|
||||
def to_ts(date_str):
|
||||
if not date_str:
|
||||
return 0
|
||||
return time.mktime(time.strptime(date_str, "%Y-%m-%d"))
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser(description=__doc__,
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
ap.add_argument("--min-n", type=int, default=15, help="min resolved bets")
|
||||
ap.add_argument("--max-n", type=int, default=3000,
|
||||
help="exclude wallets with more resolved bets (market-maker proxy); 0=off")
|
||||
ap.add_argument("--top", type=int, default=40)
|
||||
ap.add_argument("--cutoff", help="YYYY-MM-DD: in-sample/out-of-sample split")
|
||||
args = ap.parse_args()
|
||||
|
||||
con = duckdb.connect(DB, read_only=True)
|
||||
cutoff_ts = to_ts(args.cutoff)
|
||||
rows = rank(con, cutoff_ts, args.min_n, args.max_n)
|
||||
rows.sort(key=lambda r: (r["z"] is not None, r["z"]), reverse=True)
|
||||
|
||||
k, thresh = bh_fdr(rows)
|
||||
label = f"on/before {args.cutoff}" if args.cutoff else "all resolved bets"
|
||||
print(f"\nscored {len(rows):,} wallets (min_n={args.min_n}, "
|
||||
f"max_n={args.max_n or '∞'}) · {label}")
|
||||
print(f"Benjamini-Hochberg @5% FDR: {k:,} wallets survive (p ≤ {thresh:.1e}) "
|
||||
f"— the rest of the high-z tail is consistent with luck\n")
|
||||
|
||||
hdr = f"{'z':>6}{'p(luck)':>10}{'rec':>13}{'win%':>7}{'avgP':>7}{'volume':>12}{'profit':>11} wallet"
|
||||
print(hdr); print("-" * len(hdr))
|
||||
for r in rows[:args.top]:
|
||||
rec = f"{r['wins']}/{r['n']}(E{r['exp_wins']:.0f})"
|
||||
p = r["pval"]
|
||||
ps = "<1e-12" if p <= 0 else (f"{p:.1e}" if p < 1e-3 else f"{p:.3f}")
|
||||
star = " *" if p <= thresh and thresh > 0 else " "
|
||||
print(f"{r['z']:>6.1f}{ps:>10}{rec:>13}{r['win_rate']:>6.1f}%{r['avg_entry']:>7.2f}"
|
||||
f"{(r['volume'] or 0):>12,.0f}{(r['profit'] or 0):>11,.0f}{star}{r['user_id']}")
|
||||
|
||||
if args.cutoff:
|
||||
forward_oos(con, rows[:args.top], cutoff_ts, args.min_n)
|
||||
|
||||
|
||||
def forward_oos(con, picks, cutoff_ts, min_n):
|
||||
"""For the in-sample top picks, measure their record AFTER the cutoff."""
|
||||
print(f"\n{'='*70}\nOUT-OF-SAMPLE: same wallets, only bets resolved AFTER cutoff")
|
||||
print(f"{'='*70}")
|
||||
ids = [r["user_id"] for r in picks]
|
||||
if not ids:
|
||||
return
|
||||
# reuse the same join but flip the time filter and restrict to these wallets
|
||||
sql = open("edge.sql").read()
|
||||
sql = sql.replace("WHERE b.resolution_ts <= :cutoff_ts OR :cutoff_ts = 0",
|
||||
f"WHERE b.resolution_ts > {int(cutoff_ts)} "
|
||||
f"AND b.user_id IN ({','.join(repr(i) for i in ids)})")
|
||||
sql = sql.replace("HAVING count(*) >= :min_n", "HAVING count(*) >= 1")
|
||||
fwd = {r[0]: r for r in con.execute(sql).fetchall()}
|
||||
cols = [d[0] for d in con.description]
|
||||
zi, wi, ni, wri = cols.index("z"), cols.index("wins"), cols.index("n"), cols.index("win_rate")
|
||||
print(f"{'in-sample z':>12}{'fwd z':>8}{'fwd rec':>12}{'fwd win%':>9} wallet")
|
||||
for r in picks:
|
||||
f = fwd.get(r["user_id"])
|
||||
if f:
|
||||
fz = f"{f[zi]:.1f}" if f[zi] is not None else "n/a"
|
||||
print(f"{r['z']:>12.1f}{fz:>8}{f'{f[wi]}/{f[ni]}':>12}{f[wri]:>8.1f}% {r['user_id']}")
|
||||
else:
|
||||
print(f"{r['z']:>12.1f}{'—':>8}{'(no fwd bets)':>12}{'—':>9} {r['user_id']}")
|
||||
fz = [fwd[i][zi] for i in ids if i in fwd and fwd[i][zi] is not None]
|
||||
if fz:
|
||||
print(f"\nmedian forward z of in-sample winners: {sorted(fz)[len(fz)//2]:.2f} "
|
||||
f"(near 0 = the in-sample edge did NOT persist)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,118 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Goldsky Polymarket orderbook subgraph client.
|
||||
|
||||
The hosted subgraph times out on any `orderBy` over a non-indexed field
|
||||
(numTrades, scaledProfit, ...), so we never sort server-side. Instead we
|
||||
cursor-paginate by `id` (the indexed primary key) — `where:{id_gt:<last>}`,
|
||||
`first:1000` — which is stable and resumable. Ranking happens locally in
|
||||
DuckDB after ingest. That constraint is exactly why the bulk-ingest design
|
||||
is the only one that scales here.
|
||||
"""
|
||||
|
||||
import json
|
||||
import ssl
|
||||
import time
|
||||
import urllib.request
|
||||
|
||||
ENDPOINT = ("https://api.goldsky.com/api/public/"
|
||||
"project_cl6mb8i9h0003e201j6li0diw/subgraphs/"
|
||||
"polymarket-orderbook-resync/prod/gn")
|
||||
|
||||
_CTX = ssl._create_unverified_context()
|
||||
PAGE = 1000
|
||||
|
||||
|
||||
def query(gql, variables=None, retries=6):
|
||||
"""POST a GraphQL query, retrying on transient errors / timeouts."""
|
||||
body = json.dumps({"query": gql, "variables": variables or {}}).encode()
|
||||
delay = 1.0
|
||||
for attempt in range(retries):
|
||||
try:
|
||||
req = urllib.request.Request(
|
||||
ENDPOINT, data=body,
|
||||
headers={"Content-Type": "application/json",
|
||||
"User-Agent": "Mozilla/5.0"})
|
||||
r = json.loads(urllib.request.urlopen(req, timeout=60, context=_CTX).read())
|
||||
if "errors" in r:
|
||||
# statement-timeout is transient under load; back off and retry
|
||||
msg = r["errors"][0].get("message", "")
|
||||
if "timeout" in msg.lower() or "timed out" in msg.lower():
|
||||
raise TimeoutError(msg)
|
||||
raise RuntimeError(msg[:300])
|
||||
return r["data"]
|
||||
except Exception as e:
|
||||
if attempt == retries - 1:
|
||||
raise
|
||||
time.sleep(delay)
|
||||
delay = min(delay * 2, 30)
|
||||
return None
|
||||
|
||||
|
||||
def paginate(entity, fields, where="", page=PAGE, start_id="", on_page=None):
|
||||
"""Yield every row of `entity`, cursor-paginating by id.
|
||||
|
||||
`fields` is the GraphQL selection set (a string). `where` is extra filter
|
||||
clauses (without braces), e.g. 'resolutionTimestamp_not: null'. Resume by
|
||||
passing the last id seen as `start_id`.
|
||||
"""
|
||||
last = start_id
|
||||
while True:
|
||||
clauses = f'id_gt: "{last}"'
|
||||
if where:
|
||||
clauses += ", " + where
|
||||
gql = (f'{{ {entity}(first: {page}, orderBy: id, orderDirection: asc, '
|
||||
f'where: {{ {clauses} }}) {{ {fields} }} }}')
|
||||
rows = query(gql).get(entity, [])
|
||||
if not rows:
|
||||
return
|
||||
for row in rows:
|
||||
yield row
|
||||
last = rows[-1]["id"]
|
||||
if on_page:
|
||||
on_page(len(rows), last)
|
||||
if len(rows) < page:
|
||||
return
|
||||
|
||||
|
||||
def shard_bounds(n=16):
|
||||
"""Hex-prefix boundaries after '0x' that split the id space into n shards.
|
||||
ids are lowercase hex; '0xg' sorts after every '0xf…' so it caps the last
|
||||
shard. Returns n+1 bounds; shard i spans [bounds[i], bounds[i+1])."""
|
||||
d = "0123456789abcdef"
|
||||
if n == 16:
|
||||
return ["0x" + c for c in d] + ["0xg"]
|
||||
if n == 256:
|
||||
return ["0x" + a + b for a in d for b in d] + ["0xg"]
|
||||
raise ValueError("n must be 16 or 256")
|
||||
|
||||
|
||||
def paginate_pages(entity, fields, lo="", hi="", start_id="", page=PAGE):
|
||||
"""Yield (rows, last_id) per page for ids in (max(start_id,lo), hi).
|
||||
Page-level so the caller can checkpoint each shard's cursor."""
|
||||
last = start_id or lo
|
||||
while True:
|
||||
clauses = f'id_gt: "{last}"'
|
||||
if hi:
|
||||
clauses += f', id_lt: "{hi}"'
|
||||
gql = (f'{{ {entity}(first: {page}, orderBy: id, orderDirection: asc, '
|
||||
f'where: {{ {clauses} }}) {{ {fields} }} }}')
|
||||
rows = query(gql).get(entity, [])
|
||||
if not rows:
|
||||
return
|
||||
yield rows, rows[-1]["id"]
|
||||
if len(rows) < page:
|
||||
return
|
||||
last = rows[-1]["id"]
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# smoke test: count a few resolved conditions
|
||||
n = 0
|
||||
for c in paginate("conditions", "id resolutionTimestamp payoutNumerators",
|
||||
where="resolutionTimestamp_not: null"):
|
||||
n += 1
|
||||
if n <= 2:
|
||||
print(c)
|
||||
if n >= 2500:
|
||||
break
|
||||
print(f"paged {n} resolved conditions ok")
|
||||
Reference in New Issue
Block a user