gavindiaz/winning-wallet-finder
1
0
Fork 0
Code Issues Pull Requests Actions 49 Packages Projects Releases Wiki Activity

live retune (user 2026-07-10): caps off, 4% paper-parity, abs guard, pending registry

Browse Source 
1. Caps retired: risk block mirrors the paper sentinels; sizing is the
   paper bot's 4%-of-equity (class_pct 0.04/0.12), floored at the venue's
   $1 min order (4% of a $22 book is $0.89 — sub-min stakes died at the
   gate). bankroll rebased to the real $22.28 equity; spend tracker reset
   (the confusing $35 is gone with the daily cap).
2. Price guard is now ABSOLUTE +0.05 (both books): 0.14→0.15 follows,
   0.14→0.20 skips. The relative 5% blocked one-tick moves on cheap
   in-play books.
3. Pending-order registry: in-play 'delayed' holds are no longer cancelled
   at 20s — the executor hands them to state.pending_orders with full copy
   context; the heartbeat resolver adopts the fill whenever it lands
   (bets/my_pos/cash/ledger, TTL 600s → cancel + honest miss). Recovers
   Rune-Eaters-class holds (+$7.50 forfeited by the old cancel).
   5 stub-client paths pass incl. adopt + expire.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
jaxperro
2026-07-10 17:17:26 -04:00
parent fd840ba9e3
commit 705f8b2c39
5 changed files with 6430 additions and 6282 deletions
Download Patch File Download Diff File Expand all files Collapse all files
config.live.example.json
+11 -12
View File
@@ -1,9 +1,9 @@
{
"mode": "live",
"_comment": "Live-test config, SECRET-FREE and committed. The Fly live worker (wwf-copybot-live, COPYBOT_ROLE=live) reads THIS file and takes secrets from env (LIVE_PRIVATE_KEY/LIVE_FUNDER_ADDRESS + LIVE_CONFIRM to arm). Mac use: cp -> config.live.json and fill live.*. RULES: bankroll_usd MUST equal the actual USDC deposit at arm time (the 1.4 cash-anchor checks state cash vs chain); risk caps are LIVE_ROLLOUT rule 0.6 \u2014 never raise before Phase 6; follow set mirrors copybot.paper.json (Set E) so paper and live books stay comparable.",
"bankroll_usd": 24.73,
"bankroll_pct": 0.2022,
"price_guard_pct": 0.05,
"_comment": "Live-test config, SECRET-FREE and committed. The Fly live worker (wwf-copybot-live, COPYBOT_ROLE=live) reads THIS file and takes secrets from env (LIVE_PRIVATE_KEY/LIVE_FUNDER_ADDRESS + LIVE_CONFIRM to arm). Mac use: cp -> config.live.json and fill live.*. RULES: bankroll_usd MUST equal actual equity at rebase time (the 1.4 cash-anchor checks state cash vs chain). 2026-07-10 USER decision: hard caps retired \u2014 sizing is paper-parity 4%-of-equity (floored at the venue $1 min order); follow set mirrors copybot.paper.json (Set E) so paper and live books stay comparable.",
"bankroll_usd": 22.28,
"bankroll_pct": 0.04,
"price_guard_abs": 0.05,
"taker_fee_rate": 0.03,
"discord_webhook": "",
"follow": {
@@ -21,16 +21,16 @@
"min_entry": 0.0,
"max_entry": 0.95,
"class_pct": {
"volume": 0.2022,
"whale": 0.2022
"volume": 0.04,
"whale": 0.12
}
},
"risk": {
"max_trade_usd": 5.0,
"max_position_usd": 5.0,
"daily_spend_cap_usd": 25.0,
"max_total_exposure_usd": 30.0,
"max_open_positions": 6,
"max_trade_usd": 1000000.0,
"max_position_usd": 1000000.0,
"daily_spend_cap_usd": 1000000.0,
"max_total_exposure_usd": 1000000.0,
"max_open_positions": 1000,
"max_per_event": 0,
"min_price": 0.01,
"max_price": 0.95,
@@ -44,7 +44,6 @@
"auto_redeem": false,
"rpc_url": ""
},
"stake_cap_usd": 24.73,
"wallets": [
{
"wallet": "0x41558102a796ba971c7567cad41c307e59f8fa41",
copybot.py
+130 -22
View File
@@ -286,13 +286,15 @@ class LedgerLiveExecutor:
return b.balance / 1e6
def _settle_uncertain(self, token_id, side, bal0, price, order_id=None,
deadline_s=20):
deadline_s=20, cancel=True):
"""An order may be resting/held at the exchange (in-play 'delayed'
acceptance, or an exception after posting). Poll it to a terminal
state, cancel whatever remains, and return (filled, avg_price) from
the exchange's own balance diff. INVARIANT (2026-07-10 incident: six
state, cancel whatever remains (unless the caller keeps it alive for
the pending registry), and return (filled, avg_price) from the
exchange's own balance diff. INVARIANT (2026-07-10 incident: six
in-play acceptances were logged as misses and filled untracked
minutes later): no order outlives this call untracked."""
minutes later): no order outlives this call untracked — it either
reports its fill here or is handed to state["pending_orders"]."""
import time
px = price
deadline = time.time() + deadline_s
@@ -306,16 +308,17 @@ class LedgerLiveExecutor:
break
except Exception: # gone from the open view — terminal
break
try:
if order_id:
self.client.cancel_order(order_id=order_id)
else: # exception path: sweep the whole token
ids = [o.id for o in self.client.list_open_orders(
token_id=str(token_id))]
if ids:
self.client.cancel_orders(order_ids=ids)
except Exception:
pass # cancel of a just-matched order — fine
if cancel:
try:
if order_id:
self.client.cancel_order(order_id=order_id)
else: # exception path: sweep the whole token
ids = [o.id for o in self.client.list_open_orders(
token_id=str(token_id))]
if ids:
self.client.cancel_orders(order_ids=ids)
except Exception:
pass # cancel of a just-matched order — fine
try:
bal1 = self._shares_held(token_id)
except Exception:
@@ -363,10 +366,20 @@ class LedgerLiveExecutor:
px = usd / filled if filled else price
if filled <= 0:
# ACCEPTED with zero matched = in-play 'delayed'/'live' hold, NOT
# a rejection (the 2026-07-10 lesson). Wait it out briefly, then
# cancel-and-measure so the ledger always matches the exchange.
# a rejection (the 2026-07-10 lesson). Wait briefly in-call; if
# still held, hand the order to the PENDING registry — the
# heartbeat resolver adopts the fill when it lands or cancels at
# TTL (the 20s cancel-everything version forfeited a Rune-Eaters
# hold that filled at +4.5min and paid +$7.50).
filled, px = self._settle_uncertain(token_id, side, bal0, price,
order_id=r.order_id)
order_id=r.order_id,
deadline_s=8, cancel=False)
if filled <= 0:
return {"ok": False, "filled_shares": 0.0, "price": price,
"pending": {"order_id": r.order_id, "bal0": bal0},
"resp": {"order_id": r.order_id, "status": r.status,
"note": "in-play hold — pending resolver"},
"paper": False}
return {"ok": filled > 0, "filled_shares": filled, "price": px,
"resp": {"order_id": r.order_id, "status": r.status,
"making": making, "taking": taking,
@@ -1021,6 +1034,96 @@ class Copybot:
log(f"baseline: {n} historical trades marked seen · {fresh} fresh trades "
f"left copyable — only NEW trades from now")
def resolve_pendings(self):
"""Settle state["pending_orders"] — in-play holds the executor handed
off instead of cancelling (2026-07-10 registry). Each pending either
ADOPTS its fill (full bookkeeping: spend, position, cash drain,
ledger row, bet record) or expires at TTL into a cancel + honest
miss. The exchange's balance diff is the fill arbiter, same as the
executor's own uncertain path."""
st = self.engine.state
pend = st.get("pending_orders") or []
if not pend or not self.engine.ex.live:
return
ex = self.engine.ex
now = time.time()
keep = []
for p in pend:
tok = p["token"]
px, status, matched = p["price"], "gone", 0.0
try:
o = ex.client.get_order(order_id=p["order_id"])
matched = float(o.size_matched or 0)
status = o.status
if matched > 0:
px = float(o.price or px)
except Exception:
pass # gone from open view — terminal
expired = now - p["ts"] > p.get("ttl_s", 600)
if status in ("live", "delayed") and not expired and matched <= 0:
keep.append(p) # still held — check again next tick
continue
if status in ("live", "delayed"): # expired: kill the remainder
try:
ex.client.cancel_order(order_id=p["order_id"])
except Exception:
pass
filled = matched
try: # balance diff is the arbiter
bal1 = ex._shares_held(tok)
diff = (bal1 - p["bal0"]) if p["side"] == "BUY" else (p["bal0"] - bal1)
filled = max(filled, diff)
except Exception:
pass
if filled <= 0.01:
log(f"pending expired unfilled: {p['outcome']} · {p['title'][:40]}")
if p["side"] == "BUY" and not p.get("is_add"):
self.engine.record_miss(
p["wallet"], tok, p.get("cond"), p["title"], p["outcome"],
p["price"], p.get("stake", 0),
f"in-play hold expired unfilled ({int(now - p['ts'])}s)")
continue
spent = filled * px
if p["side"] == "BUY":
st["spend"]["usd"] += spent
mine = st["my_pos"].get(tok)
if p.get("is_add") and mine:
mine["shares"] += filled
mine["cost"] += spent
if p.get("cond"):
mine.setdefault("cond", p["cond"])
else:
st["my_pos"][tok] = {
"shares": filled, "cost": spent, "title": p["title"],
"outcome": p["outcome"], "event": p.get("event"),
"wallet": p["wallet"], "cond": p.get("cond")}
if p.get("cond"):
self.conds[tok] = p["cond"]
ex.fills.append({"side": "BUY", "token": tok,
"shares": filled, "price": px})
synth = {"timestamp": p.get("their_ts"), "price": p["their_price"],
"outcome": p["outcome"], "title": p["title"]}
for f in self._drain_fills():
self._record_lag(p["wallet"], synth, f)
log(f"PENDING FILLED · {p['outcome']} · {p['title'][:40]} — "
f"buy {filled:.2f} @ {px:.3f} (${spent:.2f}, held "
f"{int(now - p['ts'])}s)")
else: # SELL adoption: reduce the position
mine = st["my_pos"].get(tok)
if mine and mine.get("shares"):
frac = min(1.0, filled / mine["shares"])
mine["cost"] *= (1 - frac)
mine["shares"] -= filled
if mine["shares"] <= 0.01:
st["my_pos"].pop(tok, None)
ex.fills.append({"side": "SELL", "token": tok,
"shares": filled, "price": px})
self._drain_fills()
log(f"PENDING EXIT FILLED · {p['outcome']} · {p['title'][:40]} — "
f"sold {filled:.2f} @ {px:.3f}")
st["pending_orders"] = keep
self.engine.persist()
_chain_bal = (0.0, None) # (checked_at, usdc) — cached; poll ≤1/min
def chain_cash_gap(self):
@@ -1738,11 +1841,14 @@ def main():
log(f"copybot · mode: {mode}")
log(f"on-chain settle fallback: {'ON' if _RPC_URL else 'OFF — set ALCHEMY_RPC_URL'}")
log(f"watching {len(cfg.get('watchlist', []))} wallets · {filt.describe()}")
log(f"bankroll ${cfg['bankroll_usd']:.0f} @ {cfg['bankroll_pct']:.1%}/entry · "
f"guard {cfg['price_guard_pct']:.0%} · "
f"caps: ${cfg['risk']['max_trade_usd']:.0f}/trade, "
f"${cfg['risk']['daily_spend_cap_usd']:.0f}/day, "
f"${cfg['risk']['max_total_exposure_usd']:.0f} exposure")
guard = cfg.get("price_guard_abs", cfg.get("price_guard_pct", 0.05))
def _cap(v):
return "off" if v >= 1e5 else f"${v:,.0f}"
log(f"bankroll ${cfg['bankroll_usd']:.2f} @ {cfg['bankroll_pct']:.1%}/entry · "
f"guard +{guard:.2f} abs · "
f"caps: {_cap(cfg['risk']['max_trade_usd'])}/trade, "
f"{_cap(cfg['risk']['daily_spend_cap_usd'])}/day, "
f"{_cap(cfg['risk']['max_total_exposure_usd'])} exposure")
bot.seed()
# boot invariant pass: rebuild any missing bet/conds records and — only
# here, where no trade is in flight — heal a never-debited orphan's cash
@@ -1793,6 +1899,7 @@ def main():
cycle = 0
try:
while True:
bot.resolve_pendings() # adopt/expire in-play held orders
bot.settle_resolved() # recycle capital at resolution
if cycle % 5 == 0:
bot.reconcile_exits()
@@ -1829,6 +1936,7 @@ def main():
time.sleep(60)
cycle += 1
try:
bot.resolve_pendings() # adopt/expire in-play held orders
bot.settle_resolved()
if cycle % 5 == 0:
bot.reconcile_exits()
copybot_state.live.json
+6237 -6236
View File
File diff suppressed because it is too large Load Diff
copytrade.py
+50 -10
View File
@@ -58,7 +58,10 @@ DEFAULT_CONFIG = {
# past cap/bankroll_pct — surplus cash is SWEPT to
# state["reserve"], a banked pot that never bets
# (profit ratchet + keeps fills inside book depth)
"price_guard_pct": 0.05, # skip if price moved >5% from their fill
"price_guard_abs": 0.05, # skip if price moved >5 POINTS above their
# fill (absolute, 2026-07-10: 0.14→0.15 must
# follow; relative % blocked 1-tick moves on
# cheap in-play books)
"risk": {
"max_trade_usd": 50.0, # hard ceiling on any single copy
"max_position_usd": 40.0, # hard ceiling on total cost in one market
@@ -307,7 +310,10 @@ class CopyTrader:
stake = frac * eq
if their and stake > their:
stake = their
return stake
# venue floor: the CLOB rejects sub-$1 orders, so a small book's pct
# stake must round UP to the minimum or every copy dies at the gate
# (4% of the $22 live book = $0.89 — 2026-07-10 paper-parity retune)
return max(stake, self.risk.get("min_order_usd", 1.0))
def record_miss(self, wallet, token, cond, title, outcome, price, want, reason):
"""A bet the strategy WOULD have copied but the book couldn't take —
@@ -377,7 +383,8 @@ class CopyTrader:
if side == "BUY":
self._handle_their_buy(wallet, token, their_size, their_price,
label, title, outcome, event=event_key(t),
cond=t.get("conditionId"))
cond=t.get("conditionId"),
their_ts=t.get("timestamp"))
their_book[token] = their_prev + their_size
elif side == "SELL":
self._handle_their_sell(token, their_size, their_prev, label)
@@ -398,13 +405,18 @@ class CopyTrader:
# ASYMMETRIC by rule: a better price than the sharp paid is never blocked
# (paying less for the same outcome is strictly better odds — the guard
# once skipped a 0.70→0.51 improvement that went on to win). Only adverse
# drift — chasing the price UP — is gated by price_guard_pct.
# drift — chasing the price UP — is gated, in ABSOLUTE points: the old
# relative 5% blocked one-tick moves on cheap in-play books (0.14→0.15
# is +7% relative but the same bet; 0.14→0.19 is where the edge is gone).
if current <= their_price:
return True
return (current - their_price) / their_price <= self.cfg["price_guard_pct"]
guard = self.cfg.get("price_guard_abs",
self.cfg.get("price_guard_pct", 0.05))
return (current - their_price) <= guard
def _handle_their_buy(self, wallet, token, their_size, their_price,
label, title, outcome, event=None, cond=None):
label, title, outcome, event=None, cond=None,
their_ts=None):
mine = self.state["my_pos"].get(token)
is_add = mine is not None
# the signal's position in this token BEFORE this trade — the their-bet
@@ -447,7 +459,8 @@ class CopyTrader:
return
if not self._price_guard_ok(price, their_price):
self.log(f"BUY {label} — skip (price {price:.3f} vs their "
f"{their_price:.3f}, >{self.cfg['price_guard_pct']:.0%})")
f"{their_price:.3f}, moved >"
f"{self.cfg.get('price_guard_abs', 0.05):.2f} abs)")
self.record_miss(wallet, token, cond, title, outcome, price,
self.stake_usd(wallet),
f"price moved {their_price:.2f}→{price:.2f}")
@@ -484,6 +497,21 @@ class CopyTrader:
shares = allowed / price
res = self.ex.buy(token, shares, price, {"title": title})
if not res["ok"]:
# in-play books ACCEPT orders with a delayed hold — the executor
# reports those as pending (order id + pre-order balance) instead
# of failed. Park the full copy context; the heartbeat resolver
# adopts the fill when it lands or converts to a miss at TTL.
if res.get("pending"):
self.state.setdefault("pending_orders", []).append({
**res["pending"], "token": token, "side": "BUY",
"wallet": wallet, "title": title, "outcome": outcome,
"event": event, "cond": cond, "their_price": their_price,
"their_ts": their_ts, "price": price, "is_add": is_add,
"stake": allowed, "ts": time.time(), "ttl_s": 600})
self.log(f"{kind} {label} — PENDING (in-play hold, "
f"order {str(res['pending'].get('order_id'))[:14]}…)")
self.persist()
return
self.log(f"{kind} {label} — ORDER FAILED: {res.get('resp')}")
if not is_add: # a rejected OPEN is a missed bet
self.record_miss(wallet, token, cond, title, outcome, price,
@@ -525,6 +553,17 @@ class CopyTrader:
return
res = self.ex.sell(token, sell_shares, price, {})
if not res["ok"]:
if res.get("pending"): # in-play hold — resolver adopts
self.state.setdefault("pending_orders", []).append({
**res["pending"], "token": token, "side": "SELL",
"wallet": mine.get("wallet", ""), "title": mine.get("title", ""),
"outcome": mine.get("outcome", ""), "event": mine.get("event"),
"cond": mine.get("cond"), "their_price": price,
"their_ts": None, "price": price, "is_add": False,
"stake": sell_shares * price, "ts": time.time(), "ttl_s": 600})
self.log(f"EXIT {label} — PENDING (in-play hold)")
self.persist()
return
self.log(f"EXIT {label} — ORDER FAILED: {res.get('resp')}")
return
proceeds = res["filled_shares"] * res["price"]
@@ -605,9 +644,10 @@ class CopyTrader:
def confirm_live(cfg):
print("\n" + "=" * 64)
print(" LIVE MODE — this will place REAL orders with REAL money.")
print(f" Bankroll ${cfg['bankroll_usd']:.0f} · {cfg['bankroll_pct']:.1%}/entry"
f" · max ${cfg['risk']['max_trade_usd']:.0f}/trade"
f" · daily cap ${cfg['risk']['daily_spend_cap_usd']:.0f}")
mt, dc = cfg['risk']['max_trade_usd'], cfg['risk']['daily_spend_cap_usd']
print(f" Bankroll ${cfg['bankroll_usd']:.2f} · {cfg['bankroll_pct']:.1%}/entry"
f" · max {'off' if mt >= 1e5 else '$%.0f' % mt}/trade"
f" · daily cap {'off' if dc >= 1e5 else '$%.0f' % dc}")
print(f" Watching {len(cfg['watchlist'])} wallets.")
print("=" * 64)
# Headless arm (Fly live worker): the USER types the exact phrase into
live/copybot.paper.json
+2 -2
View File
@@ -2,7 +2,6 @@
"mode": "paper",
"bankroll_usd": 1000.0,
"bankroll_pct": 0.04,
"price_guard_pct": 0.05,
"wallets": [
{
"wallet": "0x41558102a796ba971c7567cad41c307e59f8fa41",
@@ -67,5 +66,6 @@
"max_price": 0.99,
"min_order_usd": 5.0,
"max_per_event": 0
}
},
"price_guard_abs": 0.05
}