John Doe
1330 lines
48 KiB
Python
1330 lines
48 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
Weather Trading Bot v3 — Polymarket CLOB Real Trading
|
|
======================================================
|
|
bot_v2 strategy logic + py_clob_client on-chain order execution.
|
|
Only trades US cities (F) for now — EU/Asia cities need CLOB market support.
|
|
|
|
Usage:
|
|
python bot_v3.py run # Full trading loop (scan + monitor)
|
|
python bot_v3.py scan # One-shot scan + trade signals
|
|
python bot_v3.py status # Show open positions + balance
|
|
python bot_v3.py cancel # Cancel all open orders
|
|
python bot_v3.py cancel --market <market_id> # Cancel orders for a market
|
|
"""
|
|
|
|
import re
|
|
import sys
|
|
import json
|
|
import math
|
|
import time
|
|
import os
|
|
import logging
|
|
import dotenv
|
|
import requests
|
|
import threading
|
|
from datetime import datetime, timezone, timedelta
|
|
from pathlib import Path
|
|
from typing import Callable, Any
|
|
|
|
# =============================================================================
|
|
# CONFIG
|
|
# =============================================================================
|
|
|
|
BOT_DIR = Path(__file__).parent
|
|
dotenv.load_dotenv(BOT_DIR / ".env")
|
|
|
|
with open(BOT_DIR / "config.json", encoding="utf-8") as f:
|
|
_cfg = json.load(f)
|
|
|
|
# --- Wallet ---
|
|
PK = os.getenv("PK", "")
|
|
WALLET = os.getenv("WALLET", "")
|
|
SIG_TYPE = int(os.getenv("SIG_TYPE", "0"))
|
|
|
|
# --- Trading ---
|
|
MAX_BET = _cfg.get("max_bet", 2.0)
|
|
MIN_EV = _cfg.get("min_ev", 0.10)
|
|
MAX_PRICE = _cfg.get("max_price", 0.45)
|
|
MIN_VOLUME = _cfg.get("min_volume", 500)
|
|
MIN_HOURS = _cfg.get("min_hours", 2.0)
|
|
MAX_HOURS = _cfg.get("max_hours", 72.0)
|
|
KELLY_FRAC = _cfg.get("kelly_fraction", 0.25)
|
|
MAX_SLIPPAGE = _cfg.get("max_slippage", 0.03)
|
|
SCAN_INTERVAL = _cfg.get("scan_interval", 3600)
|
|
VC_KEY = _cfg.get("vc_key", "")
|
|
|
|
# --- CLOB ---
|
|
CLOB_HOST = "https://clob.polymarket.com"
|
|
CHAIN_ID = 137 # Polygon
|
|
|
|
# --- Telegram ---
|
|
TELEGRAM_BOT_TOKEN = _cfg.get("telegram_bot_token", "")
|
|
TELEGRAM_CHAT_ID = _cfg.get("telegram_chat_id", "")
|
|
|
|
# --- Contract addresses (Polygon) ---
|
|
USDC_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
|
|
CTF_EXCHANGE = "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E"
|
|
NEG_RISK_EXCHANGE = "0xC5d563A36AE78145C45a50134d48A1215220f80a"
|
|
ROUTER = "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296"
|
|
CONDITIONAL_TOKENS = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"
|
|
|
|
# --- Gas ---
|
|
MAX_FEE_PER_GAS = 200e9 # 200 gwei
|
|
|
|
# =============================================================================
|
|
# MATH
|
|
# =============================================================================
|
|
|
|
def norm_cdf(x):
|
|
return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))
|
|
|
|
def bucket_prob(forecast, t_low, t_high, sigma=2.0):
|
|
"""
|
|
Gaussian probability that forecast falls in [t_low, t_high].
|
|
Uses error function (math.erf) — no scipy needed.
|
|
"""
|
|
if t_low == -999:
|
|
return norm_cdf((t_high - float(forecast)) / sigma)
|
|
if t_high == 999:
|
|
return 1.0 - norm_cdf((t_low - float(forecast)) / sigma)
|
|
# Bounded range: P(t_low <= X <= t_high) = CDF(t_high) - CDF(t_low)
|
|
z_low = (t_low - float(forecast)) / sigma
|
|
z_high = (t_high - float(forecast)) / sigma
|
|
return norm_cdf(z_high) - norm_cdf(z_low)
|
|
|
|
def calc_ev(p, price):
|
|
if price <= 0 or price >= 1: return 0.0
|
|
return round(p * (1.0 / price - 1.0) - (1.0 - p), 4)
|
|
|
|
def calc_kelly(p, price):
|
|
if price <= 0 or price >= 1: return 0.0
|
|
b = 1.0 / price - 1.0
|
|
f = (p * b - (1.0 - p)) / b
|
|
return round(min(max(0.0, f) * KELLY_FRAC, 1.0), 4)
|
|
|
|
def bet_size(kelly):
|
|
"""Calculate bet size from Kelly fraction. Always uses MAX_BET as cap for consistency."""
|
|
raw = kelly * MAX_BET
|
|
return round(min(raw, MAX_BET), 2)
|
|
|
|
# =============================================================================
|
|
# COLORS
|
|
# =============================================================================
|
|
|
|
class C:
|
|
GREEN = "\033[92m"
|
|
YELLOW = "\033[93m"
|
|
RED = "\033[91m"
|
|
CYAN = "\033[96m"
|
|
GRAY = "\033[90m"
|
|
RESET = "\033[0m"
|
|
BOLD = "\033[1m"
|
|
|
|
def ok(msg): print(f"{C.GREEN} ✅ {msg}{C.RESET}")
|
|
def warn(msg): print(f"{C.YELLOW} ⚠️ {msg}{C.RESET}")
|
|
def info(msg): print(f"{C.CYAN} {msg}{C.RESET}")
|
|
def skip(msg): print(f"{C.GRAY} ⏸️ {msg}{C.RESET}")
|
|
def live(msg): print(f"{C.GREEN} {msg}{C.RESET}")
|
|
|
|
# =============================================================================
|
|
# TIMEOUT WRAPPER — prevents CLOB/HTTP calls from hanging forever
|
|
# =============================================================================
|
|
|
|
def _timeout_call(func: Callable, args: tuple = (), kwargs: dict = None,
|
|
timeout: float = 10.0, default: Any = None) -> Any:
|
|
"""Run func in a thread with a timeout. Returns default on timeout."""
|
|
kwargs = kwargs or {}
|
|
result = [default]
|
|
error = [None]
|
|
|
|
def target():
|
|
try:
|
|
result[0] = func(*args, **kwargs)
|
|
except Exception as e:
|
|
error[0] = e
|
|
|
|
t = threading.Thread(target=target, daemon=True)
|
|
t.start()
|
|
t.join(timeout=timeout)
|
|
if t.is_alive():
|
|
return default
|
|
if error[0]:
|
|
raise error[0]
|
|
return result[0]
|
|
|
|
# =============================================================================
|
|
# SELF-LEARNING SYSTEM — adapts strategy based on trade history
|
|
# =============================================================================
|
|
|
|
LEARNING_DIR = BOT_DIR / "data" / "learning"
|
|
LEARNING_DIR.mkdir(exist_ok=True)
|
|
TRADE_LOG = LEARNING_DIR / "trade_log.json"
|
|
MODEL_FILE = LEARNING_DIR / "model.json"
|
|
LEARNING_WINDOW = 30 # Consider last N trades for adaptation
|
|
|
|
# Default model (conservative start)
|
|
_DEFAULT_MODEL = {
|
|
"version": 1,
|
|
"city_knowledge": {}, # city_slug -> {wins, losses, total_pnl, trades}
|
|
"bucket_knowledge": {}, # bucket_range -> {wins, losses}
|
|
"global": {"wins": 0, "losses": 0, "total_pnl": 0.0, "trades": 0},
|
|
"kelly_adjustment": 1.0, # multiplier on Kelly fraction
|
|
"ev_floor": MIN_EV, # adaptive EV threshold
|
|
"max_kelly_frac": KELLY_FRAC,
|
|
"confidence": 0.0, # 0-1, how much to trust learned params
|
|
}
|
|
|
|
def _load_model() -> dict:
|
|
if MODEL_FILE.exists():
|
|
return json.loads(MODEL_FILE.read_text(encoding="utf-8"))
|
|
return _DEFAULT_MODEL.copy()
|
|
|
|
def _save_model(model: dict):
|
|
MODEL_FILE.write_text(json.dumps(model, indent=2, ensure_ascii=False), encoding="utf-8")
|
|
|
|
def record_trade(city_slug: str, bucket_low: int, bucket_high: int,
|
|
outcome: str, pnl: float, cost: float, kelly: float, ev: float):
|
|
"""
|
|
Record a completed trade for self-learning.
|
|
outcome: 'win' | 'loss' | 'pending'
|
|
pnl: profit/loss amount in USDC
|
|
"""
|
|
model = _load_model()
|
|
|
|
# Load existing trade log
|
|
log = []
|
|
if TRADE_LOG.exists():
|
|
log = json.loads(TRADE_LOG.read_text(encoding="utf-8"))
|
|
|
|
# Append new trade
|
|
trade = {
|
|
"id": len(log) + 1,
|
|
"timestamp": datetime.now(timezone.utc).isoformat(),
|
|
"city": city_slug,
|
|
"bucket": f"{bucket_low}-{bucket_high}",
|
|
"outcome": outcome,
|
|
"pnl": round(pnl, 4),
|
|
"cost": round(cost, 4),
|
|
"kelly": round(kelly, 4),
|
|
"ev": round(ev, 4),
|
|
}
|
|
log.append(trade)
|
|
|
|
# Keep only recent trades
|
|
log = log[-LEARNING_WINDOW:]
|
|
TRADE_LOG.write_text(json.dumps(log, indent=2, ensure_ascii=False), encoding="utf-8")
|
|
|
|
# Update model based on resolved trades only
|
|
resolved = [t for t in log if t["outcome"] in ("win", "loss")]
|
|
if not resolved:
|
|
_save_model(model)
|
|
return
|
|
|
|
wins = sum(1 for t in resolved if t["outcome"] == "win")
|
|
losses = sum(1 for t in resolved if t["outcome"] == "loss")
|
|
total_pnl = sum(t["pnl"] for t in resolved)
|
|
total_trades = len(resolved)
|
|
winrate = wins / total_trades if total_trades > 0 else 0.5
|
|
|
|
avg_win = sum(t["pnl"] for t in resolved if t["outcome"] == "win") / wins if wins > 0 else 1.0
|
|
avg_loss = abs(sum(t["pnl"] for t in resolved if t["outcome"] == "loss") / losses) if losses > 0 else 1.0
|
|
|
|
# Global update
|
|
model["global"] = {
|
|
"wins": wins, "losses": losses,
|
|
"total_pnl": round(total_pnl, 4),
|
|
"trades": total_trades,
|
|
}
|
|
|
|
# City-level knowledge
|
|
for city in set(t["city"] for t in resolved):
|
|
city_trades = [t for t in resolved if t["city"] == city]
|
|
city_wins = sum(1 for t in city_trades if t["outcome"] == "win")
|
|
city_losses = sum(1 for t in city_trades if t["outcome"] == "loss")
|
|
city_pnl = sum(t["pnl"] for t in city_trades)
|
|
model["city_knowledge"][city] = {
|
|
"wins": city_wins, "losses": city_losses,
|
|
"total_pnl": round(city_pnl, 4),
|
|
"trades": len(city_trades),
|
|
}
|
|
|
|
# Bucket-level knowledge
|
|
for bucket in set(t["bucket"] for t in resolved):
|
|
b_trades = [t for t in resolved if t["bucket"] == bucket]
|
|
b_wins = sum(1 for t in b_trades if t["outcome"] == "win")
|
|
b_losses = sum(1 for t in b_trades if t["outcome"] == "loss")
|
|
model["bucket_knowledge"][bucket] = {
|
|
"wins": b_wins, "losses": b_losses,
|
|
}
|
|
|
|
# Adaptive Kelly: lower if winrate < 50% or poor PnL
|
|
if total_trades >= 5:
|
|
if winrate < 0.45 or total_pnl < -1.0:
|
|
model["kelly_adjustment"] = max(0.25, model["kelly_adjustment"] * 0.8)
|
|
model["ev_floor"] = min(0.20, model["ev_floor"] * 1.1)
|
|
elif winrate > 0.55 and total_pnl > 2.0:
|
|
model["kelly_adjustment"] = min(1.0, model["kelly_adjustment"] * 1.1)
|
|
model["ev_floor"] = max(MIN_EV, model["ev_floor"] * 0.95)
|
|
|
|
model["max_kelly_frac"] = round(KELLY_FRAC * model["kelly_adjustment"], 4)
|
|
model["confidence"] = min(1.0, total_trades / 20.0)
|
|
|
|
_save_model(model)
|
|
|
|
def get_adjusted_kelly(base_kelly: float) -> float:
|
|
"""Apply learned adjustment to Kelly fraction."""
|
|
model = _load_model()
|
|
adj = model.get("kelly_adjustment", 1.0)
|
|
capped = min(base_kelly * adj, model.get("max_kelly_frac", KELLY_FRAC))
|
|
return round(capped, 4)
|
|
|
|
def get_adjusted_ev_floor() -> float:
|
|
"""Get adaptive EV threshold based on recent performance."""
|
|
model = _load_model()
|
|
return model.get("ev_floor", MIN_EV)
|
|
|
|
def get_city_winrate(city_slug: str) -> float:
|
|
"""Get learned winrate for a specific city (0.5 if unknown)."""
|
|
model = _load_model()
|
|
city = model.get("city_knowledge", {}).get(city_slug)
|
|
if not city or city["trades"] < 2:
|
|
return 0.5
|
|
total = city["wins"] + city["losses"]
|
|
return city["wins"] / total
|
|
|
|
def get_learning_stats() -> dict:
|
|
"""Return current learning model summary."""
|
|
model = _load_model()
|
|
g = model.get("global", {})
|
|
trades = g.get("trades", 0)
|
|
if trades == 0:
|
|
return {"trades": 0, "winrate": "N/A", "pnl": "$0.00", "confidence": "0%",
|
|
"kelly_adj": "1.0x", "ev_floor": f"{MIN_EV*100:.0f}%"}
|
|
wr = g.get("wins", 0) / trades
|
|
return {
|
|
"trades": trades,
|
|
"winrate": f"{wr:.0%}",
|
|
"pnl": f"${g.get('total_pnl', 0):.2f}",
|
|
"confidence": f"{model.get('confidence', 0)*100:.0f}%",
|
|
"kelly_adj": f"{model.get('kelly_adjustment', 1.0):.2f}x",
|
|
"ev_floor": f"{model.get('ev_floor', MIN_EV)*100:.0f}%",
|
|
}
|
|
|
|
# =============================================================================
|
|
# CLOB CLIENT
|
|
# =============================================================================
|
|
|
|
from py_clob_client.client import ClobClient
|
|
from py_clob_client.clob_types import OrderArgs, MarketOrderArgs, OrderType
|
|
|
|
_clob: ClobClient = None
|
|
|
|
def get_clob() -> ClobClient:
|
|
global _clob
|
|
if _clob is None:
|
|
_clob = ClobClient(
|
|
host=CLOB_HOST,
|
|
chain_id=CHAIN_ID,
|
|
key=PK,
|
|
)
|
|
return _clob
|
|
|
|
# =============================================================================
|
|
# ON-CHAIN HELPERS
|
|
# =============================================================================
|
|
|
|
from web3 import Web3
|
|
from eth_account import Account
|
|
|
|
_w3: Web3 = None
|
|
|
|
def get_w3() -> Web3:
|
|
global _w3
|
|
if _w3 is None:
|
|
_w3 = Web3(Web3.HTTPProvider("https://1rpc.io/matic"))
|
|
return _w3
|
|
|
|
def get_nonce(wallet: str) -> int:
|
|
return get_w3().eth.get_transaction_count(wallet)
|
|
|
|
def send_tx(w3, signed_txn):
|
|
return w3.eth.send_raw_transaction(signed_txn).hex()
|
|
|
|
def wait_for_receipt(w3, tx_hash: str, timeout=120):
|
|
start = time.time()
|
|
while time.time() - start < timeout:
|
|
try:
|
|
receipt = w3.eth.get_transaction_receipt(tx_hash)
|
|
if receipt and receipt["status"] == 1:
|
|
return receipt
|
|
except Exception:
|
|
pass
|
|
time.sleep(2)
|
|
return None
|
|
|
|
# =============================================================================
|
|
# BALANCE CHECK
|
|
# =============================================================================
|
|
def get_usdc_balance(wallet: str) -> float:
|
|
"""Get USDC.e balance on Polygon via raw eth_call (avoids web3 contract ABI issues)."""
|
|
w3 = get_w3()
|
|
wallet_checksum = Web3.to_checksum_address(wallet)
|
|
usdc_checksum = Web3.to_checksum_address(USDC_ADDRESS)
|
|
|
|
#balanceOf(address) — the "data" is the function selector hash + padded address
|
|
selector = "0x70a08231" # balanceOf(address)
|
|
data = selector + wallet_checksum[2:].lower().rjust(64, '0')
|
|
|
|
try:
|
|
result = w3.eth.call({
|
|
"to": usdc_checksum,
|
|
"data": data,
|
|
})
|
|
bal = int.from_bytes(result, "big")
|
|
return bal / 1e6 # USDC.e = 6 decimals
|
|
except Exception as e:
|
|
warn(f"Balance check failed: {e}")
|
|
return 0.0
|
|
|
|
def get_pol_balance(wallet: str) -> float:
|
|
w3 = get_w3()
|
|
bal = w3.eth.get_balance(Web3.to_checksum_address(wallet))
|
|
return int(bal) / 1e18
|
|
|
|
# =============================================================================
|
|
# TELEGRAM NOTIFICATIONS
|
|
# =============================================================================
|
|
|
|
_tg_session = requests.Session()
|
|
|
|
def send_telegram(text: str, retry=2) -> bool:
|
|
"""Send a message via Telegram Bot API. Returns True on success."""
|
|
if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
|
|
return False
|
|
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
|
|
payload = {
|
|
"chat_id": TELEGRAM_CHAT_ID,
|
|
"text": text,
|
|
"parse_mode": "HTML",
|
|
"disable_web_page_preview": True,
|
|
}
|
|
for attempt in range(retry + 1):
|
|
try:
|
|
r = _tg_session.post(url, json=payload, timeout=(5, 10))
|
|
if r.status_code == 200:
|
|
return True
|
|
except Exception:
|
|
pass
|
|
if attempt < retry:
|
|
time.sleep(1)
|
|
return False
|
|
|
|
def tg_signal(city: str, horizon: str, date: str, bucket_label: str,
|
|
forecast_temp: float, entry_price: float, cost: float,
|
|
ev: float, kelly: float, success: bool, reason: str = ""):
|
|
"""Send a trade signal notification to Telegram."""
|
|
if success:
|
|
msg = (
|
|
f"📍 <b>{city} {horizon}</b> — {date}\n"
|
|
f"🌡 Forecast: <b>{forecast_temp}°F</b>\n"
|
|
f"🎯 Bucket: <b>{bucket_label}</b>\n"
|
|
f"💰 Cost: <b>${cost:.2f}</b> @ <b>${entry_price:.3f}</b>\n"
|
|
f"📈 EV: <b>+{ev:.2f}</b> | Kelly: <b>{kelly:.2f}</b>\n"
|
|
f"✅ <b>ORDER FILLED</b>"
|
|
)
|
|
else:
|
|
msg = (
|
|
f"📍 <b>{city} {horizon}</b> — {date}\n"
|
|
f"🌡 Forecast: <b>{forecast_temp}°F</b>\n"
|
|
f"🎯 Bucket: <b>{bucket_label}</b>\n"
|
|
f"❌ <b>ORDER FAILED:</b> {reason}"
|
|
)
|
|
send_telegram(msg)
|
|
|
|
def tg_scan_summary(new_trades: int, errors: int, balance: float, cities: int,
|
|
top_signals: list = None, open_positions: list = None):
|
|
"""Send a detailed scan summary to Telegram."""
|
|
status_emoji = "✅" if errors == 0 else "⚠️"
|
|
|
|
# Build header
|
|
lines = [
|
|
f"🔔 <b>Weather Bot — Scan Report</b>",
|
|
f"{status_emoji} Cities: {cities} | New trades: {new_trades} | Errors: {errors}",
|
|
f"💰 Balance: <b>${balance:.4f}</b> USDC.e",
|
|
]
|
|
|
|
# Open positions
|
|
if open_positions:
|
|
lines.append("")
|
|
lines.append(f"📊 <b>Open Positions ({len(open_positions)}):</b>")
|
|
for pos in open_positions[:5]: # Max 5 shown
|
|
label = f"{pos['bucket_low']}-{pos['bucket_high']}°F"
|
|
pnl_str = f"${pos.get('pnl', 0):.2f}" if pos.get('pnl') else "pending"
|
|
entry = pos.get('entry_price', 0)
|
|
cost = pos.get('cost', 0)
|
|
lines.append(
|
|
f" • {pos['city_name']} {pos['date']} | {label} | "
|
|
f"entry ${entry:.3f} | cost ${cost:.2f} | PnL {pnl_str}"
|
|
)
|
|
if len(open_positions) > 5:
|
|
lines.append(f" ...and {len(open_positions) - 5} more")
|
|
else:
|
|
lines.append("")
|
|
lines.append("📊 <b>Open Positions:</b> 0")
|
|
|
|
# Top signals from this scan
|
|
if top_signals:
|
|
lines.append("")
|
|
lines.append(f"🎯 <b>Top EV Signals ({len(top_signals)} found):</b>")
|
|
for sig in top_signals[:5]: # Max 5 shown
|
|
lines.append(
|
|
f" • {sig['city']} {sig['horizon']} | "
|
|
f"{sig['bucket']} | EV <b>+{sig['ev']:.2f}</b> | "
|
|
f"${sig['price']:.3f} (market) vs ${sig['true_prob']:.3f} (model)"
|
|
)
|
|
|
|
msg = "\n".join(lines)
|
|
send_telegram(msg)
|
|
|
|
# =============================================================================
|
|
# APPROVAL CHECK
|
|
# =============================================================================
|
|
|
|
def is_approved(token: str, spender: str, wallet: str) -> bool:
|
|
"""Check if spender is approved for token (USDC.e)."""
|
|
w3 = get_w3()
|
|
usdc_abi = [
|
|
{
|
|
"name": "allowance",
|
|
"inputs": [
|
|
{"name": "owner", "type": "address"},
|
|
{"name": "spender", "type": "address"}
|
|
],
|
|
"outputs": [{"name": "", "type": "uint256"}],
|
|
"stateMutability": "view",
|
|
"type": "function"
|
|
}
|
|
]
|
|
usdc = w3.eth.contract(
|
|
address=Web3.to_checksum_address(token),
|
|
abi=usdc_abi
|
|
)
|
|
try:
|
|
allowance = usdc.functions.allowance(
|
|
Web3.to_checksum_address(wallet),
|
|
Web3.to_checksum_address(spender)
|
|
).call()
|
|
return allowance > 0
|
|
except Exception:
|
|
return False
|
|
|
|
def approve_token(token: str, spender: str, wallet: str, private_key: str,
|
|
amount_wei: int = 2**256 - 1, max_fee: int = MAX_FEE_PER_GAS):
|
|
"""Approve spender to spend token on behalf of wallet."""
|
|
w3 = get_w3()
|
|
usdc_abi = [
|
|
{
|
|
"name": "approve",
|
|
"inputs": [
|
|
{"name": "spender", "type": "address"},
|
|
{"name": "amount", "type": "uint256"}
|
|
],
|
|
"outputs": [{"name": "", "type": "bool"}],
|
|
"stateMutability": "nonpayable",
|
|
"type": "function"
|
|
}
|
|
]
|
|
usdc = w3.eth.contract(
|
|
address=Web3.to_checksum_address(token),
|
|
abi=usdc_abi
|
|
)
|
|
nonce = get_nonce(wallet)
|
|
build = usdc.functions.approve(
|
|
Web3.to_checksum_address(spender),
|
|
amount_wei
|
|
).build_transaction({
|
|
"from": wallet,
|
|
"nonce": nonce,
|
|
"maxFeePerGas": max_fee,
|
|
"maxPriorityFeePerGas": 25e9,
|
|
"chainId": CHAIN_ID,
|
|
})
|
|
signed = w3.eth.account.sign_transaction(build, private_key)
|
|
tx_hash = send_tx(w3, signed.raw_transaction)
|
|
live(f"Approve tx: {tx_hash}")
|
|
receipt = wait_for_receipt(w3, tx_hash)
|
|
if receipt:
|
|
ok(f"Approved {spender} for {token[:10]}...")
|
|
return True
|
|
warn(f"Approval tx failed: {tx_hash}")
|
|
return False
|
|
|
|
def ensure_approvals():
|
|
"""Ensure all required approvals are set before trading."""
|
|
wallet = WALLET
|
|
required = [
|
|
(USDC_ADDRESS, CTF_EXCHANGE),
|
|
(USDC_ADDRESS, NEG_RISK_EXCHANGE),
|
|
(USDC_ADDRESS, ROUTER),
|
|
]
|
|
for token, spender in required:
|
|
if not is_approved(token, spender, wallet):
|
|
warn(f"Missing approval: {spender[:10]} for {token[:10]}")
|
|
ok(f"Approving {spender[:10]}...")
|
|
approve_token(token, spender, wallet, PK)
|
|
time.sleep(5) # Wait for confirmation
|
|
else:
|
|
ok(f"Already approved: {spender[:10]}")
|
|
|
|
# =============================================================================
|
|
# ORDER EXECUTION
|
|
# =============================================================================
|
|
|
|
def place_buy_order(market_id: str, token_id: str, price: float, shares: float,
|
|
private_key: str, wallet: str) -> dict:
|
|
"""
|
|
Place a BUY order on Polymarket CLOB.
|
|
Uses FOK (Fill-Or-Kill) market order to guarantee execution.
|
|
Returns dict with success status and details.
|
|
Uses _timeout_call to prevent indefinite hangs.
|
|
Balance check is done on-chain — we always attempt the order for consistency.
|
|
"""
|
|
cost = round(shares * price, 4)
|
|
|
|
if not is_approved(USDC_ADDRESS, ROUTER, wallet):
|
|
return {"success": False, "reason": "Router approval missing"}
|
|
|
|
# --- Market order via CLOB (with 10s timeout) ---
|
|
order_args = MarketOrderArgs(
|
|
token_id=token_id,
|
|
amount=cost, # For BUY: amount is in dollars (USDC)
|
|
side="BUY",
|
|
price=price,
|
|
)
|
|
|
|
try:
|
|
clob = get_clob()
|
|
# assert_level_1_auth first (fast, with timeout)
|
|
auth_ok = _timeout_call(clob.assert_level_1_auth, timeout=10.0)
|
|
if auth_ok is None:
|
|
return {"success": False, "reason": "CLOB auth timeout (>10s)"}
|
|
|
|
# create_market_order (network call, with 10s timeout)
|
|
order_result = _timeout_call(
|
|
clob.create_market_order, args=(order_args,), timeout=10.0
|
|
)
|
|
if order_result is None:
|
|
return {"success": False, "reason": "Order execution timeout (>10s)"}
|
|
|
|
live(f"Market order placed: {order_result}")
|
|
|
|
except Exception as e:
|
|
return {"success": False, "reason": f"Order failed: {e}"}
|
|
|
|
return {
|
|
"success": True,
|
|
"market_id": market_id,
|
|
"token_id": token_id,
|
|
"price": price,
|
|
"shares": shares,
|
|
"cost": cost,
|
|
"order_id": order_result.get("orderID") if isinstance(order_result, dict) else str(order_result),
|
|
}
|
|
|
|
def cancel_order(order_id: str) -> bool:
|
|
"""Cancel a specific order by ID."""
|
|
clob = get_clob()
|
|
try:
|
|
clob.cancel(order_id)
|
|
ok(f"Cancelled order: {order_id[:20]}...")
|
|
return True
|
|
except Exception as e:
|
|
warn(f"Cancel failed: {e}")
|
|
return False
|
|
|
|
def cancel_all_orders() -> int:
|
|
"""Cancel all open orders. Returns count of cancelled orders."""
|
|
clob = get_clob()
|
|
try:
|
|
result = clob.cancel_all()
|
|
count = result.get("count", 0) if isinstance(result, dict) else 0
|
|
ok(f"Cancelled {count} orders")
|
|
return count
|
|
except Exception as e:
|
|
warn(f"Cancel all failed: {e}")
|
|
return 0
|
|
|
|
# =============================================================================
|
|
# LOCATIONS & WEATHER DATA
|
|
# =============================================================================
|
|
|
|
LOCATIONS = {
|
|
"nyc": {"lat": 40.7772, "lon": -73.8726, "name": "New York City", "station": "KLGA", "unit": "F", "region": "us"},
|
|
"chicago": {"lat": 41.9742, "lon": -87.9073, "name": "Chicago", "station": "KORD", "unit": "F", "region": "us"},
|
|
"miami": {"lat": 25.7959, "lon": -80.2870, "name": "Miami", "station": "KMIA", "unit": "F", "region": "us"},
|
|
"dallas": {"lat": 32.8471, "lon": -96.8518, "name": "Dallas", "station": "KDAL", "unit": "F", "region": "us"},
|
|
"seattle": {"lat": 47.4502, "lon":-122.3088, "name": "Seattle", "station": "KSEA", "unit": "F", "region": "us"},
|
|
"atlanta": {"lat": 33.6407, "lon": -84.4277, "name": "Atlanta", "station": "KATL", "unit": "F", "region": "us"},
|
|
}
|
|
|
|
TIMEZONES = {
|
|
"nyc": "America/New_York", "chicago": "America/Chicago",
|
|
"miami": "America/New_York", "dallas": "America/Chicago",
|
|
"seattle": "America/Los_Angeles", "atlanta": "America/New_York",
|
|
}
|
|
|
|
MONTHS = ["january","february","march","april","may","june",
|
|
"july","august","september","october","november","december"]
|
|
|
|
|
|
def get_ecmwf(city_slug, dates):
|
|
"""ECMWF via Open-Meteo. Returns dict {date: temp_f}."""
|
|
loc = LOCATIONS[city_slug]
|
|
url = (
|
|
f"https://api.open-meteo.com/v1/forecast"
|
|
f"?latitude={loc['lat']}&longitude={loc['lon']}"
|
|
f"&daily=temperature_2m_max&temperature_unit=fahrenheit"
|
|
f"&forecast_days=7&timezone={TIMEZONES.get(city_slug, 'UTC')}"
|
|
f"&models=ecmwf_ifs025&bias_correction=true"
|
|
)
|
|
result = {}
|
|
for attempt in range(3):
|
|
try:
|
|
data = requests.get(url, timeout=(5, 10)).json()
|
|
if "error" not in data:
|
|
for date, temp in zip(data["daily"]["time"], data["daily"]["temperature_2m_max"]):
|
|
if date in dates and temp is not None:
|
|
result[date] = round(temp)
|
|
break
|
|
except Exception as e:
|
|
if attempt < 2:
|
|
time.sleep(2)
|
|
else:
|
|
warn(f"ECMWF error for {city_slug}: {e}")
|
|
return result
|
|
|
|
def get_metar(city_slug):
|
|
"""Current observed temperature from METAR station. D+0 only."""
|
|
loc = LOCATIONS[city_slug]
|
|
try:
|
|
url = f"https://aviationweather.gov/api/data/metar?ids={loc['station']}&format=json"
|
|
data = requests.get(url, timeout=(5, 8)).json()
|
|
if data and isinstance(data, list):
|
|
temp_c = data[0].get("temp")
|
|
if temp_c is not None:
|
|
return round(float(temp_c) * 9/5 + 32)
|
|
except Exception as e:
|
|
warn(f"METAR error for {city_slug}: {e}")
|
|
return None
|
|
|
|
def get_forecast_snapshot(city_slug, dates):
|
|
"""Get best temperature forecast for each date. Returns {date: temp_f}."""
|
|
ecmwf = get_ecmwf(city_slug, dates)
|
|
today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
|
|
result = {}
|
|
for date in dates:
|
|
best = ecmwf.get(date)
|
|
best_source = "ecmwf"
|
|
# METAR for today if available
|
|
if date == today:
|
|
metar = get_metar(city_slug)
|
|
if metar is not None:
|
|
best = metar
|
|
best_source = "metar"
|
|
if best is not None:
|
|
result[date] = {"temp": best, "source": best_source}
|
|
return result
|
|
|
|
# =============================================================================
|
|
# POLYMARKET
|
|
# =============================================================================
|
|
|
|
def get_polymarket_event(city_slug, month, day, year):
|
|
slug = f"highest-temperature-in-{city_slug}-on-{month}-{day}-{year}"
|
|
try:
|
|
r = requests.get(f"https://gamma-api.polymarket.com/events?slug={slug}", timeout=(5, 8))
|
|
data = r.json()
|
|
if data and isinstance(data, list) and len(data) > 0:
|
|
return data[0]
|
|
except Exception as e:
|
|
warn(f"Polymarket API error: {e}")
|
|
return None
|
|
|
|
def get_market_price(market_id):
|
|
try:
|
|
r = requests.get(f"https://gamma-api.polymarket.com/markets/{market_id}", timeout=(3, 5))
|
|
data = r.json()
|
|
prices = json.loads(data.get("outcomePrices", "[0.5,0.5]"))
|
|
return float(prices[0]), float(prices[1]) if len(prices) > 1 else float(prices[0])
|
|
except Exception:
|
|
return None, None
|
|
|
|
def parse_temp_range(question):
|
|
if not question: return None
|
|
num = r'(-?\d+(?:\.\d+)?)'
|
|
if re.search(r'or below', question, re.IGNORECASE):
|
|
m = re.search(num + r'[°]?[FC] or below', question, re.IGNORECASE)
|
|
if m: return (-999.0, float(m.group(1)))
|
|
if re.search(r'or higher', question, re.IGNORECASE):
|
|
m = re.search(num + r'[°]?[FC] or higher', question, re.IGNORECASE)
|
|
if m: return (float(m.group(1)), 999.0)
|
|
m = re.search(r'between ' + num + r'-' + num + r'[°]?[FC]', question, re.IGNORECASE)
|
|
if m: return (float(m.group(1)), float(m.group(2)))
|
|
m = re.search(r'be ' + num + r'[°]?[FC] on', question, re.IGNORECASE)
|
|
if m:
|
|
v = float(m.group(1))
|
|
return (v, v)
|
|
return None
|
|
|
|
def hours_to_resolution(end_date_str):
|
|
try:
|
|
end = datetime.fromisoformat(end_date_str.replace("Z", "+00:00"))
|
|
return max(0.0, (end - datetime.now(timezone.utc)).total_seconds() / 3600)
|
|
except Exception:
|
|
return 999.0
|
|
|
|
def in_bucket(forecast, t_low, t_high):
|
|
if t_low == t_high:
|
|
return round(float(forecast)) == round(t_low)
|
|
return t_low <= float(forecast) <= t_high
|
|
|
|
def get_condition_id(market_id: str) -> str:
|
|
"""Get condition ID for a market from Polymarket (with 8s timeout)."""
|
|
try:
|
|
r = _timeout_call(
|
|
requests.get,
|
|
args=(f"https://gamma-api.polymarket.com/markets/{market_id}",),
|
|
kwargs={"timeout": (5, 8)},
|
|
timeout=8.0,
|
|
)
|
|
if r is None:
|
|
warn(f"get_condition_id timeout for {market_id[:16]}...")
|
|
return ""
|
|
data = r.json()
|
|
return data.get("conditionId", "")
|
|
except Exception:
|
|
return ""
|
|
|
|
# =============================================================================
|
|
# STATE (local JSON)
|
|
# =============================================================================
|
|
|
|
DATA_DIR = BOT_DIR / "data"
|
|
DATA_DIR.mkdir(exist_ok=True)
|
|
MARKETS_DIR = DATA_DIR / "markets"
|
|
MARKETS_DIR.mkdir(exist_ok=True)
|
|
STATE_FILE = DATA_DIR / "state_v3.json"
|
|
|
|
def load_state():
|
|
if STATE_FILE.exists():
|
|
return json.loads(STATE_FILE.read_text(encoding="utf-8"))
|
|
return {
|
|
"balance": 0.0,
|
|
"starting_balance": 0.0,
|
|
"total_trades": 0,
|
|
"wins": 0,
|
|
"losses": 0,
|
|
"open_orders": {},
|
|
}
|
|
|
|
def save_state(state):
|
|
STATE_FILE.write_text(json.dumps(state, indent=2, ensure_ascii=False), encoding="utf-8")
|
|
|
|
def market_path(city_slug, date_str):
|
|
return MARKETS_DIR / f"{city_slug}_{date_str}.json"
|
|
|
|
def load_market(city_slug, date_str):
|
|
p = market_path(city_slug, date_str)
|
|
if p.exists():
|
|
return json.loads(p.read_text(encoding="utf-8"))
|
|
return None
|
|
|
|
def save_market(market):
|
|
p = market_path(market["city"], market["date"])
|
|
p.write_text(json.dumps(market, indent=2, ensure_ascii=False), encoding="utf-8")
|
|
|
|
def load_all_markets():
|
|
markets = []
|
|
for f in MARKETS_DIR.glob("*.json"):
|
|
try:
|
|
markets.append(json.loads(f.read_text(encoding="utf-8")))
|
|
except Exception:
|
|
pass
|
|
return markets
|
|
|
|
# =============================================================================
|
|
# SIGMA (weather forecast uncertainty)
|
|
# =============================================================================
|
|
|
|
SIGMA_F = 2.0
|
|
|
|
def get_sigma(city_slug):
|
|
return SIGMA_F # Flat sigma for now; calibration can be added later
|
|
|
|
# =============================================================================
|
|
# OPEN POSITIONS from CLOB
|
|
# =============================================================================
|
|
|
|
def get_clob_positions():
|
|
"""Get all open orders/positions from CLOB."""
|
|
clob = get_clob()
|
|
try:
|
|
orders = clob.get_orders()
|
|
return orders if orders else []
|
|
except Exception as e:
|
|
warn(f"Failed to fetch CLOB orders: {e}")
|
|
return []
|
|
|
|
# =============================================================================
|
|
# SCAN & TRADE (one shot)
|
|
# =============================================================================
|
|
|
|
def scan_and_trade():
|
|
"""
|
|
One-shot scan: check all cities for trade signals and execute real orders.
|
|
Returns (new_trades, errors).
|
|
"""
|
|
now = datetime.now(timezone.utc)
|
|
state = load_state()
|
|
balance = get_usdc_balance(WALLET)
|
|
if balance != state.get("balance"):
|
|
state["balance"] = balance
|
|
save_state(state)
|
|
|
|
print(f"\n{C.BOLD}{C.CYAN}🌤 Weather Trading Bot v3 — Live Mode{C.RESET}")
|
|
print("=" * 60)
|
|
print(f" Wallet: {WALLET[:8]}...{WALLET[-4:]}")
|
|
print(f" USDC.e: ${balance:.4f}")
|
|
print(f" POL balance: {get_pol_balance(WALLET):.4f} POL")
|
|
print(f" Max bet: ${MAX_BET} | Min EV: {MIN_EV*100:.0f}%")
|
|
print()
|
|
|
|
new_trades = 0
|
|
errors = []
|
|
|
|
# Collect city market data for Telegram report (top signals)
|
|
city_market_data = []
|
|
|
|
for city_slug, loc in LOCATIONS.items():
|
|
print(f" -> {loc['name']}...", end=" ", flush=True)
|
|
unit_sym = "F"
|
|
|
|
try:
|
|
# --- Step 1: Fetch forecasts ---
|
|
t0 = time.time()
|
|
dates = [(now + timedelta(days=i)).strftime("%Y-%m-%d") for i in range(4)]
|
|
forecasts = get_forecast_snapshot(city_slug, dates)
|
|
info(f"[{loc['name']}] forecast loaded in {time.time()-t0:.1f}s")
|
|
|
|
time.sleep(0.3)
|
|
except Exception as e:
|
|
print(f"error ({e})")
|
|
continue
|
|
|
|
# --- Step 2: Find signal per date ---
|
|
city_found_signal = False
|
|
for i, date in enumerate(dates):
|
|
t0 = time.time()
|
|
try:
|
|
event = get_polymarket_event(
|
|
city_slug,
|
|
MONTHS[datetime.strptime(date, "%Y-%m-%d").month - 1],
|
|
datetime.strptime(date, "%Y-%m-%d").day,
|
|
datetime.strptime(date, "%Y-%m-%d").year
|
|
)
|
|
info(f" [{loc['name']} D+{i}] event fetched in {time.time()-t0:.1f}s")
|
|
except Exception as e:
|
|
warn(f"Polymarket error for {loc['name']} D+{i}: {e}")
|
|
continue
|
|
|
|
if not event:
|
|
continue
|
|
|
|
end_date = event.get("endDate", "")
|
|
hours = hours_to_resolution(end_date) if end_date else 0
|
|
horizon = f"D+{i}"
|
|
|
|
if hours < MIN_HOURS or hours > MAX_HOURS:
|
|
continue
|
|
|
|
# Parse all outcome buckets from Polymarket
|
|
outcomes = []
|
|
for market in event.get("markets", []):
|
|
question = market.get("question", "")
|
|
mid = str(market.get("id", ""))
|
|
volume = float(market.get("volume", 0))
|
|
rng = parse_temp_range(question)
|
|
if not rng:
|
|
continue
|
|
try:
|
|
prices = json.loads(market.get("outcomePrices", "[0.5,0.5]"))
|
|
bid = float(prices[0])
|
|
ask = float(prices[1]) if len(prices) > 1 else bid
|
|
except Exception:
|
|
continue
|
|
outcomes.append({
|
|
"question": question,
|
|
"market_id": mid,
|
|
"range": rng,
|
|
"bid": round(bid, 4),
|
|
"ask": round(ask, 4),
|
|
"price": round(bid, 4),
|
|
"spread": round(ask - bid, 4),
|
|
"volume": round(volume, 0),
|
|
})
|
|
|
|
if not outcomes:
|
|
continue
|
|
|
|
forecastsnap = forecasts.get(date, {})
|
|
forecast_temp = forecastsnap.get("temp")
|
|
best_source = forecastsnap.get("source", "ecmwf")
|
|
|
|
if forecast_temp is None:
|
|
continue
|
|
|
|
# Guard against invalid API readings (e.g. -999 from ECMWF)
|
|
if forecast_temp < -40 or forecast_temp > 130:
|
|
warn(f" ⚠️ Invalid forecast temp {forecast_temp}°F — skipping city")
|
|
break
|
|
|
|
# Skip sentinel/unbounded bucket ranges (t_high=999 or t_low=-999 from Polymarket)
|
|
sentinel_buckets = [(o["range"][0], o["range"][1]) for o in outcomes
|
|
if o["range"][0] == -999 or o["range"][1] == 999]
|
|
if sentinel_buckets:
|
|
info(f" ⚠️ Sentinel buckets detected — ignoring for EV calculation")
|
|
|
|
# Collect for Telegram top-signals report
|
|
city_market_data.append((city_slug, loc, outcomes, forecastsnap, horizon, end_date, date))
|
|
|
|
sigma = get_sigma(city_slug)
|
|
best_signal = None
|
|
|
|
# Find the bucket that matches our forecast
|
|
for o in outcomes:
|
|
t_low, t_high = o["range"]
|
|
# Skip unbounded sentinel buckets from Polymarket
|
|
if t_low == -999 or t_high == 999:
|
|
continue
|
|
if not in_bucket(forecast_temp, t_low, t_high):
|
|
continue
|
|
|
|
volume = o["volume"]
|
|
ask = o["ask"]
|
|
spread = o["spread"]
|
|
|
|
if volume < MIN_VOLUME:
|
|
continue
|
|
if ask >= MAX_PRICE:
|
|
continue
|
|
if spread > MAX_SLIPPAGE:
|
|
continue
|
|
|
|
# Calculate probability FIRST (needed for Kelly and EV)
|
|
p = bucket_prob(forecast_temp, t_low, t_high, sigma)
|
|
|
|
# Use adaptive EV floor and Kelly from self-learning
|
|
adaptive_ev_floor = get_adjusted_ev_floor()
|
|
base_kelly = calc_kelly(p, ask)
|
|
adjusted_kelly = get_adjusted_kelly(base_kelly)
|
|
|
|
ev = calc_ev(p, ask)
|
|
if ev < adaptive_ev_floor:
|
|
continue
|
|
|
|
size = bet_size(adjusted_kelly)
|
|
if size < 0.50:
|
|
continue
|
|
|
|
shares = round(size / ask, 2)
|
|
token_id = get_condition_id(o["market_id"])
|
|
|
|
best_signal = {
|
|
"market_id": o["market_id"],
|
|
"token_id": token_id,
|
|
"question": o["question"],
|
|
"bucket_low": t_low,
|
|
"bucket_high": t_high,
|
|
"entry_price": ask,
|
|
"bid": o["bid"],
|
|
"spread": spread,
|
|
"shares": shares,
|
|
"cost": round(shares * ask, 4),
|
|
"p": round(p, 4),
|
|
"ev": round(ev, 4),
|
|
"kelly": round(adjusted_kelly, 4),
|
|
"forecast_temp": forecast_temp,
|
|
"forecast_src": best_source,
|
|
"sigma": sigma,
|
|
"volume": volume,
|
|
}
|
|
break # Only one bucket per market
|
|
|
|
if best_signal:
|
|
city_found_signal = True
|
|
bucket_label = f"{best_signal['bucket_low']}-{best_signal['bucket_high']}{unit_sym}"
|
|
print(f"\n {C.BOLD}📍 {loc['name']} {horizon} — {date}{C.RESET}")
|
|
print(f" {C.CYAN} Forecast: {forecast_temp}°F ({best_source}) | {bucket_label}{C.RESET}")
|
|
print(f" {C.GREEN} ✅ BUY SIGNAL | ${best_signal['cost']:.2f} @ ${ask:.3f} | "
|
|
f"EV {best_signal['ev']:+.2f} | Kel {best_signal['kelly']:.2f}{C.RESET}")
|
|
|
|
# --- EXECUTE REAL ORDER ---
|
|
result = place_buy_order(
|
|
market_id=best_signal["market_id"],
|
|
token_id=best_signal["token_id"],
|
|
price=best_signal["entry_price"],
|
|
shares=best_signal["shares"],
|
|
private_key=PK,
|
|
wallet=WALLET,
|
|
)
|
|
|
|
if result["success"]:
|
|
new_trades += 1
|
|
state["total_trades"] += 1
|
|
balance -= best_signal["cost"]
|
|
|
|
# Record trade for self-learning (outcome='pending' until resolved)
|
|
record_trade(
|
|
city_slug=city_slug,
|
|
bucket_low=best_signal["bucket_low"],
|
|
bucket_high=best_signal["bucket_high"],
|
|
outcome="pending",
|
|
pnl=0.0, # will be updated when market resolves
|
|
cost=best_signal["cost"],
|
|
kelly=best_signal["kelly"],
|
|
ev=best_signal["ev"],
|
|
)
|
|
|
|
live(f" [LIVE] BUY {loc['name']} {horizon} | {bucket_label} @ ${best_signal['entry_price']:.3f} "
|
|
f"| EV {best_signal['ev']:+.2f} | ${best_signal['cost']:.2f}")
|
|
|
|
# Save to market record
|
|
mkt_record = load_market(city_slug, date) or {
|
|
"city": city_slug,
|
|
"city_name": loc["name"],
|
|
"date": date,
|
|
"unit": "F",
|
|
"event_end_date": end_date,
|
|
"status": "open",
|
|
"position": None,
|
|
}
|
|
mkt_record["position"] = {
|
|
**best_signal,
|
|
"order_id": result.get("order_id"),
|
|
"opened_at": datetime.now(timezone.utc).isoformat(),
|
|
"status": "open",
|
|
"closed_at": None,
|
|
"close_reason": None,
|
|
"exit_price": None,
|
|
"pnl": None,
|
|
}
|
|
save_market(mkt_record)
|
|
|
|
# Telegram notification — success
|
|
tg_signal(
|
|
city=loc["name"], horizon=horizon, date=date,
|
|
bucket_label=bucket_label, forecast_temp=best_signal["forecast_temp"],
|
|
entry_price=best_signal["entry_price"], cost=best_signal["cost"],
|
|
ev=best_signal["ev"], kelly=best_signal["kelly"],
|
|
success=True,
|
|
)
|
|
else:
|
|
errors.append(f"{loc['name']} {horizon}: {result['reason']}")
|
|
warn(f" ❌ Order failed: {result['reason']}")
|
|
|
|
# Telegram notification — failure
|
|
tg_signal(
|
|
city=loc["name"], horizon=horizon, date=date,
|
|
bucket_label=bucket_label, forecast_temp=best_signal["forecast_temp"],
|
|
entry_price=best_signal["entry_price"], cost=best_signal.get("cost", 0),
|
|
ev=best_signal["ev"], kelly=best_signal["kelly"],
|
|
success=False, reason=result.get("reason", "unknown"),
|
|
)
|
|
else:
|
|
# No signal — show why (skip sentinel buckets to avoid confusing EV)
|
|
for o in outcomes:
|
|
t_low, t_high = o["range"]
|
|
if t_low == -999 or t_high == 999:
|
|
continue
|
|
if not in_bucket(forecast_temp, t_low, t_high):
|
|
continue
|
|
ask = o["ask"]
|
|
p = bucket_prob(forecast_temp, t_low, t_high, sigma)
|
|
ev = calc_ev(p, ask)
|
|
skip(f" {forecast_temp}°F bucket {t_low}-{t_high}F @ ${ask:.3f} EV={ev:.2f} — skipped")
|
|
break
|
|
|
|
# Print "ok" regardless of whether signal found
|
|
if not city_found_signal:
|
|
# Show first skip reason for this city
|
|
print("ok", end="", flush=True)
|
|
print() # newline after city
|
|
|
|
# Build top signals from this scan for Telegram
|
|
top_signals = []
|
|
for city_slug, loc, outcomes, forecastsnap, horizon, end_date, date in city_market_data:
|
|
if not outcomes or not forecastsnap:
|
|
continue
|
|
forecast_temp = forecastsnap.get("temp")
|
|
if forecast_temp is None:
|
|
continue
|
|
if forecast_temp < -40 or forecast_temp > 130:
|
|
continue
|
|
sigma = get_sigma(city_slug)
|
|
for o in outcomes:
|
|
t_low, t_high = o["range"]
|
|
# Skip sentinel/unbounded buckets — they give false EV signals
|
|
if t_low == -999 or t_high == 999:
|
|
continue
|
|
if not in_bucket(forecast_temp, t_low, t_high):
|
|
continue
|
|
p = bucket_prob(forecast_temp, t_low, t_high, sigma)
|
|
ev = calc_ev(p, o["ask"])
|
|
if ev > 0:
|
|
top_signals.append({
|
|
"city": loc["name"],
|
|
"horizon": horizon,
|
|
"bucket": f"{t_low}-{t_high}°F",
|
|
"ev": ev,
|
|
"price": o["ask"],
|
|
"true_prob": p,
|
|
})
|
|
top_signals.sort(key=lambda x: x["ev"], reverse=True)
|
|
|
|
# Open positions
|
|
markets = load_all_markets()
|
|
open_positions = [
|
|
m for m in markets
|
|
if m.get("position") and m["position"].get("status") == "open"
|
|
]
|
|
|
|
# Save updated balance
|
|
state["balance"] = round(balance, 4)
|
|
save_state(state)
|
|
|
|
print(f"\n{'=' * 60}")
|
|
print(f" Scanned: {len(LOCATIONS)} cities")
|
|
print(f" New trades: {C.GREEN}{new_trades}{C.RESET}")
|
|
print(f" Errors: {len(errors)}")
|
|
print(f" Balance: ${balance:.4f}")
|
|
print(f"{'=' * 60}\n")
|
|
|
|
# Telegram scan summary
|
|
tg_scan_summary(new_trades=new_trades, errors=len(errors),
|
|
balance=balance, cities=len(LOCATIONS),
|
|
top_signals=top_signals,
|
|
open_positions=open_positions)
|
|
|
|
return new_trades, errors
|
|
|
|
# =============================================================================
|
|
# STATUS
|
|
# =============================================================================
|
|
|
|
def show_status():
|
|
"""Show current balance, positions, and open orders."""
|
|
balance = get_usdc_balance(WALLET)
|
|
pol_bal = get_pol_balance(WALLET)
|
|
|
|
print(f"\n{C.BOLD}{C.CYAN}📊 Bot v3 — Status{C.RESET}")
|
|
print("=" * 60)
|
|
print(f" Wallet: {WALLET[:8]}...{WALLET[-4:]}")
|
|
print(f" USDC.e: ${balance:.4f}")
|
|
print(f" POL: {pol_bal:.4f}")
|
|
print()
|
|
|
|
# Open orders from CLOB
|
|
orders = get_clob_positions()
|
|
if orders:
|
|
print(f" Open orders: {len(orders)}")
|
|
for o in orders:
|
|
print(f" {o.get('side','?')} {o.get('size','?')} @ ${o.get('price','?')} "
|
|
f"[{o.get('marketID','')[:16]}...]")
|
|
else:
|
|
print(f" Open orders: 0")
|
|
|
|
# Local market positions
|
|
markets = load_all_markets()
|
|
open_pos = [m for m in markets if m.get("position") and m["position"].get("status") == "open"]
|
|
if open_pos:
|
|
print(f"\n Open positions (local): {len(open_pos)}")
|
|
for m in open_pos:
|
|
pos = m["position"]
|
|
unit_sym = "F"
|
|
label = f"{pos['bucket_low']}-{pos['bucket_high']}{unit_sym}"
|
|
print(f" {m['city_name']} {m['date']} | {label} | "
|
|
f"entry ${pos['entry_price']:.3f} | cost ${pos.get('cost',0):.2f}")
|
|
else:
|
|
print(f"\n Open positions: 0")
|
|
|
|
print(f"{'=' * 60}\n")
|
|
|
|
# =============================================================================
|
|
# MAIN LOOP
|
|
# =============================================================================
|
|
|
|
MONITOR_INTERVAL = 600 # 10 minutes between monitor cycles
|
|
|
|
def run_loop():
|
|
print(f"\n{C.BOLD}{C.CYAN}🌤 Weather Trading Bot v3 — LIVE{C.RESET}")
|
|
print("=" * 60)
|
|
print(f" Wallet: {WALLET[:8]}...{WALLET[-4:]}")
|
|
print(f" Cities: {len(LOCATIONS)}")
|
|
print(f" Max bet: ${MAX_BET} | Kelly fraction: {KELLY_FRAC}")
|
|
print(f" Min EV: {MIN_EV*100:.0f}%")
|
|
print(f" Scan: every {SCAN_INTERVAL//60} min")
|
|
print(f" Monitor: every {MONITOR_INTERVAL//60} min")
|
|
print()
|
|
|
|
# Check approvals on startup
|
|
ok("Checking approvals...")
|
|
ensure_approvals()
|
|
|
|
last_full_scan = 0
|
|
|
|
while True:
|
|
now_ts = time.time()
|
|
now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
|
|
|
if now_ts - last_full_scan >= SCAN_INTERVAL:
|
|
print(f"[{now_str}] Full scan...")
|
|
try:
|
|
new_trades, errors = scan_and_trade()
|
|
last_full_scan = time.time()
|
|
except Exception as e:
|
|
warn(f"Scan error: {e}")
|
|
time.sleep(60)
|
|
continue
|
|
else:
|
|
print(f"[{now_str}] Monitoring...")
|
|
time.sleep(MONITOR_INTERVAL)
|
|
|
|
# =============================================================================
|
|
# CLI
|
|
# =============================================================================
|
|
|
|
if __name__ == "__main__":
|
|
if not PK or not WALLET:
|
|
print("ERROR: PK and WALLET must be set in weatherbot/.env")
|
|
sys.exit(1)
|
|
|
|
cmd = sys.argv[1] if len(sys.argv) > 1 else "scan"
|
|
|
|
if cmd == "run":
|
|
run_loop()
|
|
elif cmd == "scan":
|
|
scan_and_trade()
|
|
elif cmd == "status":
|
|
show_status()
|
|
elif cmd == "cancel":
|
|
market_id = sys.argv[2] if len(sys.argv) > 2 else None
|
|
if market_id:
|
|
print(f"Cancelling orders for market: {market_id}")
|
|
else:
|
|
count = cancel_all_orders()
|
|
print(f"Cancelled {count} orders")
|
|
else:
|
|
print(f"Usage: python bot_v3.py [scan|run|status|cancel]")
|