mirror of
https://github.com/jaxperro/winning-wallet-finder.git
synced 2026-07-28 00:07:47 +00:00
jaxperro
0c7d97c5d0
strategy.py (train pre-May-30 / test June1+ on copy-ROI + z + consistency + diversification) and followability.py (entry-time/lead-time/cadence filter) surface wallets with real, copyable, out-of-sample edge (49/77 profitable forward, p=0.011, +23.4% pooled). pnl_basket.py / pnl_focused.py add $1000 capital-constrained copy sims with missed-trade accounting: the broad basket loses (can't follow 1,200 trades on $1k), but 1-2 wallets + a conviction (bet-size) filter clears out-of-sample. cache.py gains entry-time caching. Findings documented. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
107 lines
4.3 KiB
Python
107 lines
4.3 KiB
Python
#!/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)")
|
|
_con.execute("CREATE TABLE IF NOT EXISTS entries(wallet TEXT, cond TEXT, first_buy BIGINT)")
|
|
_con.execute("CREATE INDEX IF NOT EXISTS entries_w ON entries(wallet)")
|
|
_con.execute("CREATE TABLE IF NOT EXISTS pulled_entries(wallet TEXT PRIMARY KEY, pulled_at BIGINT)")
|
|
|
|
|
|
def get_entries(wallet):
|
|
"""{conditionId: earliest BUY timestamp} for a wallet — cached. Lets us
|
|
compute entry->resolution lead time and trade cadence (followability)."""
|
|
now = time.time()
|
|
with _lock:
|
|
r = _con.execute("SELECT pulled_at FROM pulled_entries WHERE wallet=?", [wallet]).fetchone()
|
|
if r and now - r[0] < MAX_AGE_DAYS * 86400:
|
|
rows = _con.execute("SELECT cond,first_buy FROM entries WHERE wallet=?", [wallet]).fetchall()
|
|
return {c: t for c, t in rows}
|
|
try:
|
|
first_buy, _ = insider.entry_times(wallet)
|
|
except Exception:
|
|
first_buy = {}
|
|
with _lock:
|
|
_con.execute("DELETE FROM entries WHERE wallet=?", [wallet])
|
|
if first_buy:
|
|
_con.executemany("INSERT INTO entries(wallet,cond,first_buy) VALUES (?,?,?)",
|
|
[(wallet, c, t) for c, t in first_buy.items()])
|
|
_con.execute("INSERT OR REPLACE INTO pulled_entries VALUES (?,?)", [wallet, int(now)])
|
|
return first_buy
|
|
|
|
|
|
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}")
|