init: World Cup prediction agent

.gitignore

@@ -0,0 +1,7 @@
+.env
+logs/
+__pycache__/
+*.pyc
+*.pyo
+venv/
+.venv/

app.py

@@ -0,0 +1,136 @@
+"""World Cup Prediction Agent — Web UI.
+
+FastAPI app deployed on Render. Reads flat files from disk.
+Start with: uvicorn app:app --host 0.0.0.0 --port $PORT
+"""
+
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+from starlette.requests import Request
+
+BASE = Path(__file__).parent
+templates = Jinja2Templates(directory=str(BASE / "templates"))
+
+app = FastAPI(title="World Cup Prediction Agent")
+
+
+def _load_results() -> list[dict]:
+    p = BASE / "results.json"
+    if not p.exists():
+        return []
+    try:
+        return json.loads(p.read_text())
+    except Exception:
+        return []
+
+
+def _load_strategy() -> str:
+    p = BASE / "strategy.md"
+    return p.read_text() if p.exists() else ""
+
+
+def _load_schedule() -> list[dict]:
+    p = BASE / "schedule.json"
+    if not p.exists():
+        return []
+    try:
+        return json.loads(p.read_text())
+    except Exception:
+        return []
+
+
+def _record_stats(results: list[dict]) -> dict:
+    completed = [r for r in results if r.get("correct") is not None]
+    wins = sum(1 for r in completed if r.get("correct"))
+    total = len(completed)
+    return {
+        "total": total,
+        "wins": wins,
+        "losses": total - wins,
+        "pct": f"{wins/total*100:.0f}%" if total else "—",
+    }
+
+
+def _upcoming(schedule: list[dict], results: list[dict]) -> list[dict]:
+    now = datetime.now(timezone.utc)
+    predicted = {(r["home"], r["away"]) for r in results}
+    upcoming = []
+    for f in schedule:
+        k = f.get("kickoff_utc", "")
+        if not k:
+            continue
+        try:
+            dt = datetime.fromisoformat(k.replace("Z", "+00:00"))
+        except ValueError:
+            continue
+        if dt > now and (f["home"], f["away"]) not in predicted:
+            upcoming.append({**f, "kickoff_dt": dt})
+    return sorted(upcoming, key=lambda x: x["kickoff_dt"])[:10]
+
+
+@app.get("/", response_class=HTMLResponse)
+async def dashboard(request: Request):
+    results = list(reversed(_load_results()))
+    strategy = _load_strategy()
+    schedule = _load_schedule()
+    stats = _record_stats(results)
+    upcoming = _upcoming(schedule, _load_results())
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "results": results,
+            "strategy": strategy,
+            "stats": stats,
+            "upcoming": upcoming,
+        },
+    )
+
+
+@app.get("/match/{match_key}", response_class=HTMLResponse)
+async def match_detail(request: Request, match_key: str):
+    home, _, away = match_key.partition("_")
+    home, away = home.upper(), away.upper()
+    results = _load_results()
+    entry = next(
+        (r for r in reversed(results) if r.get("home") == home and r.get("away") == away),
+        None,
+    )
+    if not entry:
+        raise HTTPException(status_code=404, detail=f"No prediction found for {home} vs {away}")
+    return templates.TemplateResponse(
+        "index.html",
+        {"request": request, "detail": entry, "results": [], "strategy": "", "stats": {}, "upcoming": []},
+    )
+
+
+@app.get("/strategy", response_class=HTMLResponse)
+async def strategy_page(request: Request):
+    strategy = _load_strategy()
+    results = _load_results()
+    history = [
+        {"match": r.get("match"), "kickoff": r.get("kickoff"), "snapshot": r.get("strategy_snapshot", "")}
+        for r in results
+        if r.get("strategy_snapshot") is not None
+    ]
+    return templates.TemplateResponse(
+        "index.html",
+        {"request": request, "strategy_page": True, "strategy": strategy, "strategy_history": history,
+         "results": [], "stats": {}, "upcoming": []},
+    )
+
+
+@app.get("/api/results")
+async def api_results():
+    return _load_results()
+
+
+@app.get("/api/schedule")
+async def api_schedule():
+    return _load_schedule()

predict.py

@@ -0,0 +1,297 @@
+"""Predict match outcome. Run 30 min before kickoff.
+
+Usage: python predict.py HOME AWAY
+Example: python predict.py NED JPN
+"""
+
+import json
+import logging
+import os
+import re
+import subprocess
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import google.generativeai as genai
+import requests
+from dotenv import load_dotenv
+
+import wallet
+
+# ── Setup ──────────────────────────────────────────────────────────────────
+
+load_dotenv()
+
+if len(sys.argv) != 3:
+    print("Usage: python predict.py HOME AWAY")
+    sys.exit(1)
+
+HOME = sys.argv[1].upper()
+AWAY = sys.argv[2].upper()
+MATCH = f"{HOME} vs {AWAY}"
+WORK_DIR = Path(__file__).parent
+
+os.makedirs(WORK_DIR / "logs", exist_ok=True)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[
+        logging.FileHandler(WORK_DIR / "logs" / f"{HOME}_{AWAY}.log"),
+        logging.StreamHandler(),
+    ],
+)
+log = logging.info
+err = logging.error
+
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+model = genai.GenerativeModel("gemini-2.0-flash")
+BUDGET = float(os.getenv("MATCH_RESEARCH_BUDGET", "0.50"))
+
+# ── Step 1: Load state ─────────────────────────────────────────────────────
+
+log("=== predict.py %s ===", MATCH)
+
+strategy_path = WORK_DIR / "strategy.md"
+results_path = WORK_DIR / "results.json"
+schedule_path = WORK_DIR / "schedule.json"
+
+strategy = strategy_path.read_text() if strategy_path.exists() else ""
+results = json.loads(results_path.read_text()) if results_path.exists() else []
+schedule = json.loads(schedule_path.read_text()) if schedule_path.exists() else []
+
+balance = wallet.get_balance()
+log("Wallet balance: $%.4f USDC", balance)
+
+if balance < 0.10:
+    err("Balance $%.4f too low (min $0.10). Top up and retry.", balance)
+    sys.exit(1)
+
+# Resolve kickoff from schedule
+kickoff = datetime.now(timezone.utc).isoformat()
+for fixture in schedule:
+    if fixture.get("home") == HOME and fixture.get("away") == AWAY:
+        kickoff = fixture.get("kickoff_utc", kickoff)
+        break
+
+# ── Step 2: Fetch service directory ────────────────────────────────────────
+
+network = os.getenv("NETWORK", "base-mainnet")
+services = []
+try:
+    resp = requests.get("https://x402-list.com/api/v1/services", timeout=10)
+    resp.raise_for_status()
+    all_services = resp.json()
+    services = [s for s in all_services if network in s.get("networks", [])]
+    log("Service directory: %d services available for %s", len(services), network)
+except Exception as e:
+    err("Service directory fetch failed: %s — proceeding without paid data", e)
+
+# ── Step 3: Agent plans research ───────────────────────────────────────────
+
+recent_results = results[-3:] if results else []
+
+plan_prompt = f"""You are a World Cup betting research agent planning data purchases.
+
+Match: {MATCH}
+Kickoff: {kickoff}
+Wallet balance: ${balance:.4f} USDC
+Research budget cap: ${BUDGET:.2f} USDC
+
+Current strategy:
+{strategy if strategy else "(no strategy yet — first match)"}
+
+Recent match history:
+{json.dumps(recent_results, indent=2) if recent_results else "(no history yet)"}
+
+Available x402 data services:
+{json.dumps(services, indent=2) if services else "(no services available)"}
+
+Decide which data endpoints to purchase. Return ONLY a valid JSON array (no markdown, no explanation).
+Each item must have: url (string), params (object), cost (number in USDC), reason (one sentence).
+Only include endpoints from the service list above.
+Total cost must not exceed ${BUDGET:.2f} USDC.
+If no services are available or none are useful, return an empty array: []
+
+Example format:
+[
+  {{"url": "https://api.example.com/stats", "params": {{"team": "{HOME}"}}, "cost": 0.05, "reason": "Recent form data for {HOME}"}}
+]"""
+
+research_plan = []
+if services:
+    try:
+        log("Asking Gemini to plan research purchases...")
+        resp = model.generate_content(plan_prompt)
+        raw = resp.text.strip()
+        # Strip markdown code fences if present
+        raw = re.sub(r"^```[a-z]*\n?", "", raw)
+        raw = re.sub(r"\n?```$", "", raw)
+        research_plan = json.loads(raw)
+        log("Gemini planned %d service calls", len(research_plan))
+    except Exception as e:
+        err("Failed to parse Gemini research plan: %s — skipping paid data", e)
+        research_plan = []
+
+# Validate: remove URLs not in service directory, enforce budget
+valid_urls = {
+    endpoint["url"]
+    for svc in services
+    for endpoint in svc.get("endpoints", [])
+}
+research_plan = [p for p in research_plan if p.get("url") in valid_urls]
+
+# Trim to budget (remove most expensive first)
+research_plan.sort(key=lambda x: x.get("cost", 0))
+total_cost = 0.0
+trimmed_plan = []
+for item in research_plan:
+    if total_cost + item.get("cost", 0) <= BUDGET:
+        trimmed_plan.append(item)
+        total_cost += item.get("cost", 0)
+    else:
+        log("Skipping %s ($%.4f) — would exceed budget", item.get("url"), item.get("cost", 0))
+research_plan = trimmed_plan
+
+log("Research plan: %d endpoints, estimated cost $%.4f", len(research_plan), total_cost)
+
+# ── Step 4: Execute research (payments fire here) ──────────────────────────
+
+context = []
+total_spent = 0.0
+services_used = []
+
+if research_plan:
+    try:
+        session = wallet.get_x402_client()
+        for svc in research_plan:
+            url = svc["url"]
+            params = svc.get("params", {})
+            cost = svc.get("cost", 0)
+            try:
+                time.sleep(1)
+                r = session.get(url, params=params, timeout=15)
+                r.raise_for_status()
+                log("paid $%.4f → %s", cost, url)
+                data_text = r.text[:2000]  # cap at 2000 chars
+                context.append({"source": url, "cost": cost, "data": data_text})
+                services_used.append({"source": url, "cost": cost, "reason": svc.get("reason", "")})
+                total_spent += cost
+            except Exception as e:
+                err("Failed %s: %s", url, e)
+    except Exception as e:
+        err("x402 session setup failed: %s", e)
+
+balance_after = balance - total_spent
+log("Research complete. Spent $%.4f. Estimated balance: $%.4f", total_spent, balance_after)
+
+# ── Step 5: Make prediction ────────────────────────────────────────────────
+
+context_text = ""
+if context:
+    for c in context:
+        context_text += f"\n--- {c['source']} (${c['cost']:.4f}) ---\n{c['data']}\n"
+else:
+    context_text = "(no paid research data purchased)"
+
+predict_prompt = f"""You are a World Cup match predictor. Analyze the following and make a prediction.
+
+Match: {MATCH}
+Home team: {HOME}
+Away team: {AWAY}
+Kickoff: {kickoff}
+Remaining wallet balance after research: ${balance_after:.4f} USDC
+
+Current strategy (your accumulated learnings):
+{strategy if strategy else "(no strategy yet — first match)"}
+
+Research data purchased:
+{context_text}
+
+Recent match history and outcomes:
+{json.dumps(recent_results, indent=2) if recent_results else "(no history yet)"}
+
+Analyze the match thoroughly, then end your response with EXACTLY these 4 lines:
+PICK: [home|away|draw]
+CONFIDENCE: [1-10]
+BET: $[amount]
+REASONING: [one sentence max]"""
+
+log("Asking Gemini for prediction...")
+try:
+    pred_resp = model.generate_content(predict_prompt)
+    full_reasoning = pred_resp.text
+except Exception as e:
+    err("Gemini prediction call failed: %s", e)
+    full_reasoning = ""
+
+# Parse structured fields
+def _parse(pattern, text, default):
+    m = re.search(pattern, text, re.IGNORECASE)
+    return m.group(1).strip() if m else default
+
+pick_raw = _parse(r"PICK:\s*(\w+)", full_reasoning, "home").lower()
+pick = pick_raw if pick_raw in ("home", "away", "draw") else "home"
+confidence_raw = _parse(r"CONFIDENCE:\s*(\d+)", full_reasoning, "5")
+confidence = max(1, min(10, int(confidence_raw)))
+bet_raw = _parse(r"BET:\s*\$?([\d.]+)", full_reasoning, "0.10")
+try:
+    bet = round(float(bet_raw), 2)
+except ValueError:
+    bet = 0.10
+reasoning = _parse(r"REASONING:\s*(.+)", full_reasoning, "Insufficient data for strong prediction")
+
+log("Prediction: PICK=%s CONFIDENCE=%d BET=$%.2f", pick, confidence, bet)
+log("Reasoning: %s", reasoning)
+
+# ── Step 6: Save state and push to GitHub ─────────────────────────────────
+
+entry = {
+    "match": MATCH,
+    "home": HOME,
+    "away": AWAY,
+    "kickoff": kickoff,
+    "strategy_snapshot": strategy,
+    "services_planned": research_plan,
+    "services_used": services_used,
+    "research_cost": round(total_spent, 6),
+    "wallet_before": round(balance, 4),
+    "wallet_after": round(balance_after, 4),
+    "prediction": {
+        "pick": pick,
+        "confidence": confidence,
+        "bet": bet,
+        "reasoning": reasoning,
+    },
+    "full_reasoning": full_reasoning,
+    "result": None,
+    "correct": None,
+    "evaluation": None,
+    "reflected": False,
+}
+
+results.append(entry)
+tmp = results_path.with_suffix(".tmp")
+tmp.write_text(json.dumps(results, indent=2))
+tmp.replace(results_path)
+log("Saved prediction to results.json")
+
+try:
+    subprocess.run(["git", "add", "results.json"], cwd=WORK_DIR, check=True, capture_output=True)
+    subprocess.run(
+        ["git", "commit", "-m", f"predict: {MATCH}"],
+        cwd=WORK_DIR, check=True, capture_output=True,
+    )
+    subprocess.run(["git", "push"], cwd=WORK_DIR, check=True, capture_output=True)
+    log("Pushed results.json to GitHub")
+except Exception as e:
+    err("Git push failed (prediction saved locally): %s", e)
+
+print(f"\n{'='*50}")
+print(f"PREDICTION: {MATCH}")
+print(f"  Pick:       {pick.upper()} (confidence {confidence}/10)")
+print(f"  Reasoning:  {reasoning}")
+print(f"  Research:   ${total_spent:.4f} spent on {len(services_used)} endpoint(s)")
+print(f"  Balance:    ${balance:.4f} → ~${balance_after:.4f}")
+print(f"{'='*50}\n")

reflect.py

@@ -0,0 +1,246 @@
+"""Post-match reflection. Run ~2.5 hours after kickoff.
+
+Usage: python reflect.py HOME AWAY
+Example: python reflect.py NED JPN
+"""
+
+import json
+import logging
+import os
+import re
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import google.generativeai as genai
+import requests
+from dotenv import load_dotenv
+
+# ── Setup ──────────────────────────────────────────────────────────────────
+
+load_dotenv()
+
+if len(sys.argv) != 3:
+    print("Usage: python reflect.py HOME AWAY")
+    sys.exit(1)
+
+HOME = sys.argv[1].upper()
+AWAY = sys.argv[2].upper()
+MATCH = f"{HOME} vs {AWAY}"
+WORK_DIR = Path(__file__).parent
+
+os.makedirs(WORK_DIR / "logs", exist_ok=True)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[
+        logging.FileHandler(WORK_DIR / "logs" / f"{HOME}_{AWAY}.log"),
+        logging.StreamHandler(),
+    ],
+)
+log = logging.info
+err = logging.error
+
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+model = genai.GenerativeModel("gemini-2.0-flash")
+
+# ── Step 1: Get match result ───────────────────────────────────────────────
+
+log("=== reflect.py %s ===", MATCH)
+
+result_data = None
+
+def _get_result_from_espn() -> dict | None:
+    """Try ESPN public API to find completed match score."""
+    try:
+        # Try last 2 days to account for timezone offsets
+        from datetime import timedelta
+        for delta in range(3):
+            day = (datetime.now(timezone.utc) - timedelta(days=delta)).strftime("%Y%m%d")
+            url = "https://site.api.espn.com/apis/site/v2/sports/soccer/fifa.world/scoreboard"
+            resp = requests.get(url, params={"dates": day}, timeout=15)
+            resp.raise_for_status()
+            data = resp.json()
+            for event in data.get("events", []):
+                comps = event.get("competitions", [{}])
+                if not comps:
+                    continue
+                comp = comps[0]
+                competitors = comp.get("competitors", [])
+                if len(competitors) != 2:
+                    continue
+                abbrevs = {c["homeAway"]: c["team"].get("abbreviation", "").upper() for c in competitors}
+                if abbrevs.get("home") != HOME or abbrevs.get("away") != AWAY:
+                    continue
+                status = comp.get("status", {}).get("type", {})
+                if not status.get("completed", False):
+                    log("Match found but not yet completed (state: %s)", status.get("state"))
+                    return None
+                scores = {c["homeAway"]: int(c.get("score", 0)) for c in competitors}
+                home_score = scores.get("home", 0)
+                away_score = scores.get("away", 0)
+                if home_score > away_score:
+                    winner = "home"
+                elif away_score > home_score:
+                    winner = "away"
+                else:
+                    winner = "draw"
+                log("ESPN result: %s %d-%d %s → winner: %s", HOME, home_score, away_score, AWAY, winner)
+                return {"home_score": home_score, "away_score": away_score, "winner": winner}
+    except Exception as e:
+        err("ESPN API failed: %s", e)
+    return None
+
+result_data = _get_result_from_espn()
+
+if result_data is None:
+    err("Could not fetch match result from ESPN. Try again in a few minutes.")
+    err("Or set the result manually in results.json and re-run.")
+    sys.exit(1)
+
+# ── Step 2: Find prediction in results.json ────────────────────────────────
+
+results_path = WORK_DIR / "results.json"
+strategy_path = WORK_DIR / "strategy.md"
+
+results = json.loads(results_path.read_text()) if results_path.exists() else []
+strategy = strategy_path.read_text() if strategy_path.exists() else ""
+
+# Find the most recent unprocessed entry for this match
+entry_idx = None
+for i in range(len(results) - 1, -1, -1):
+    e = results[i]
+    if e.get("home") == HOME and e.get("away") == AWAY and not e.get("reflected", False):
+        entry_idx = i
+        break
+
+if entry_idx is None:
+    err("No unprocessed prediction found for %s in results.json", MATCH)
+    sys.exit(1)
+
+entry = results[entry_idx]
+prediction = entry.get("prediction", {})
+log("Found prediction: pick=%s confidence=%d", prediction.get("pick"), prediction.get("confidence"))
+
+# ── Step 3: Evaluator call (separate from predictor) ──────────────────────
+
+pick = prediction.get("pick", "home")
+actual_winner = result_data["winner"]
+correct = (pick == actual_winner)
+wallet_delta = -entry.get("research_cost", 0)
+
+research_summary = ""
+for svc in entry.get("services_used", []):
+    research_summary += f"\n- {svc['source']} (${svc['cost']:.4f}): {svc.get('reason', '')}"
+
+eval_prompt = f"""You are an independent evaluator assessing a World Cup match prediction.
+
+Match: {MATCH}
+Result: {HOME} {result_data['home_score']}-{result_data['away_score']} {AWAY}
+Actual winner: {actual_winner}
+
+Prediction that was made:
+- Pick: {pick}
+- Confidence: {prediction.get('confidence')}/10
+- Reasoning: {prediction.get('reasoning')}
+
+Research purchased (${entry.get('research_cost', 0):.4f} total):{research_summary if research_summary else " (none purchased)"}
+
+Outcome: prediction was {'CORRECT' if correct else 'INCORRECT'}
+Research cost: ${entry.get('research_cost', 0):.4f} USDC
+
+Evaluate honestly:
+1. Was the prediction correct? Why or why not?
+2. Which purchased research was valuable (if any)?
+3. What was the key factor that determined the outcome?
+4. What should the agent learn from this match?
+
+Be specific and critical. This evaluation will update the agent's strategy."""
+
+log("Asking Gemini for evaluation...")
+try:
+    eval_resp = model.generate_content(eval_prompt)
+    evaluation = eval_resp.text
+except Exception as e:
+    err("Gemini evaluation call failed: %s", e)
+    evaluation = f"Evaluation unavailable: {e}"
+
+# ── Step 4: Reflector call (updates strategy) ─────────────────────────────
+
+recent_results = results[-5:]
+
+reflect_prompt = f"""You are updating a World Cup prediction strategy document.
+
+Current strategy (may be empty if this is the first match):
+{strategy if strategy else "(empty — this is the first match)"}
+
+Evaluator's assessment of the latest match ({MATCH}):
+{evaluation}
+
+Recent match history for context:
+{json.dumps([{
+    "match": r.get("match"),
+    "pick": r.get("prediction", {}).get("pick"),
+    "correct": r.get("correct"),
+    "reasoning": r.get("prediction", {}).get("reasoning"),
+} for r in recent_results], indent=2)}
+
+Rewrite the strategy document with EXACTLY ONE change based on this match:
+- Add a new rule, modify an existing rule, or remove an outdated rule
+- Keep all still-valid rules from the current strategy
+- Note which x402 data endpoints have been useful vs not useful
+- Include the match that informed each rule (e.g., "NED vs JPN: ...")
+- Stay under 500 words total
+
+Return ONLY the updated strategy document text. No preamble, no explanation."""
+
+log("Asking Gemini to update strategy...")
+try:
+    strat_resp = model.generate_content(reflect_prompt)
+    new_strategy = strat_resp.text.strip()
+except Exception as e:
+    err("Gemini strategy update failed: %s", e)
+    new_strategy = strategy  # keep current if update fails
+
+strategy_path.write_text(new_strategy)
+log("Updated strategy.md")
+
+# ── Step 5: Update results.json and push to GitHub ─────────────────────────
+
+results[entry_idx].update({
+    "result": result_data,
+    "correct": correct,
+    "evaluation": evaluation,
+    "reflected": True,
+    "reflected_at": datetime.now(timezone.utc).isoformat(),
+})
+
+tmp = results_path.with_suffix(".tmp")
+tmp.write_text(json.dumps(results, indent=2))
+tmp.replace(results_path)
+log("Updated results.json")
+
+try:
+    subprocess.run(
+        ["git", "add", "results.json", "strategy.md"],
+        cwd=WORK_DIR, check=True, capture_output=True,
+    )
+    subprocess.run(
+        ["git", "commit", "-m", f"reflect: {MATCH}"],
+        cwd=WORK_DIR, check=True, capture_output=True,
+    )
+    subprocess.run(["git", "push"], cwd=WORK_DIR, check=True, capture_output=True)
+    log("Pushed to GitHub — Render will redeploy")
+except Exception as e:
+    err("Git push failed (files saved locally): %s", e)
+
+outcome_str = "✓ CORRECT" if correct else "✗ INCORRECT"
+print(f"\n{'='*50}")
+print(f"REFLECTION: {MATCH}")
+print(f"  Result:     {HOME} {result_data['home_score']}-{result_data['away_score']} {AWAY}")
+print(f"  Predicted:  {pick.upper()} → {outcome_str}")
+print(f"  Research:   ${entry.get('research_cost', 0):.4f} spent")
+print(f"\nStrategy update (first 200 chars):")
+print(f"  {new_strategy[:200]}...")
+print(f"{'='*50}\n")

render.yaml

@@ -0,0 +1,9 @@
+services:
+  - type: web
+    name: worldcup-predictions
+    env: python
+    buildCommand: pip install -r requirements.txt
+    startCommand: uvicorn app:app --host 0.0.0.0 --port $PORT
+    envVars:
+      - key: PORT
+        value: 10000

requirements.txt

@@ -0,0 +1,9 @@
+google-generativeai
+eth-account
+x402[requests,evm]
+web3
+requests
+python-dotenv
+fastapi
+uvicorn[standard]
+jinja2

results.json

@@ -0,0 +1 @@
+[]

schedule.json

@@ -0,0 +1,802 @@
+[
+  {
+    "home": "MEX",
+    "away": "RSA",
+    "home_name": "Mexico",
+    "away_name": "South Africa",
+    "kickoff_utc": "2026-06-11T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "KOR",
+    "away": "CZE",
+    "home_name": "South Korea",
+    "away_name": "Czechia",
+    "kickoff_utc": "2026-06-12T02:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "CAN",
+    "away": "BIH",
+    "home_name": "Canada",
+    "away_name": "Bosnia-Herzegovina",
+    "kickoff_utc": "2026-06-12T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "USA",
+    "away": "PAR",
+    "home_name": "United States",
+    "away_name": "Paraguay",
+    "kickoff_utc": "2026-06-13T01:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "QAT",
+    "away": "SUI",
+    "home_name": "Qatar",
+    "away_name": "Switzerland",
+    "kickoff_utc": "2026-06-13T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "BRA",
+    "away": "MAR",
+    "home_name": "Brazil",
+    "away_name": "Morocco",
+    "kickoff_utc": "2026-06-13T22:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "HAI",
+    "away": "SCO",
+    "home_name": "Haiti",
+    "away_name": "Scotland",
+    "kickoff_utc": "2026-06-14T01:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "AUS",
+    "away": "TUR",
+    "home_name": "Australia",
+    "away_name": "T\u00fcrkiye",
+    "kickoff_utc": "2026-06-14T04:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "GER",
+    "away": "CUW",
+    "home_name": "Germany",
+    "away_name": "Cura\u00e7ao",
+    "kickoff_utc": "2026-06-14T17:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "NED",
+    "away": "JPN",
+    "home_name": "Netherlands",
+    "away_name": "Japan",
+    "kickoff_utc": "2026-06-14T20:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "CIV",
+    "away": "ECU",
+    "home_name": "Ivory Coast",
+    "away_name": "Ecuador",
+    "kickoff_utc": "2026-06-14T23:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "SWE",
+    "away": "TUN",
+    "home_name": "Sweden",
+    "away_name": "Tunisia",
+    "kickoff_utc": "2026-06-15T02:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "ESP",
+    "away": "CPV",
+    "home_name": "Spain",
+    "away_name": "Cape Verde",
+    "kickoff_utc": "2026-06-15T16:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "BEL",
+    "away": "EGY",
+    "home_name": "Belgium",
+    "away_name": "Egypt",
+    "kickoff_utc": "2026-06-15T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "KSA",
+    "away": "URU",
+    "home_name": "Saudi Arabia",
+    "away_name": "Uruguay",
+    "kickoff_utc": "2026-06-15T22:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "IRN",
+    "away": "NZL",
+    "home_name": "Iran",
+    "away_name": "New Zealand",
+    "kickoff_utc": "2026-06-16T01:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "FRA",
+    "away": "SEN",
+    "home_name": "France",
+    "away_name": "Senegal",
+    "kickoff_utc": "2026-06-16T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "IRQ",
+    "away": "NOR",
+    "home_name": "Iraq",
+    "away_name": "Norway",
+    "kickoff_utc": "2026-06-16T22:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "ARG",
+    "away": "ALG",
+    "home_name": "Argentina",
+    "away_name": "Algeria",
+    "kickoff_utc": "2026-06-17T01:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "AUT",
+    "away": "JOR",
+    "home_name": "Austria",
+    "away_name": "Jordan",
+    "kickoff_utc": "2026-06-17T04:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "POR",
+    "away": "COD",
+    "home_name": "Portugal",
+    "away_name": "Congo DR",
+    "kickoff_utc": "2026-06-17T17:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "ENG",
+    "away": "CRO",
+    "home_name": "England",
+    "away_name": "Croatia",
+    "kickoff_utc": "2026-06-17T20:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "GHA",
+    "away": "PAN",
+    "home_name": "Ghana",
+    "away_name": "Panama",
+    "kickoff_utc": "2026-06-17T23:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "UZB",
+    "away": "COL",
+    "home_name": "Uzbekistan",
+    "away_name": "Colombia",
+    "kickoff_utc": "2026-06-18T02:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "CZE",
+    "away": "RSA",
+    "home_name": "Czechia",
+    "away_name": "South Africa",
+    "kickoff_utc": "2026-06-18T16:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "SUI",
+    "away": "BIH",
+    "home_name": "Switzerland",
+    "away_name": "Bosnia-Herzegovina",
+    "kickoff_utc": "2026-06-18T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "CAN",
+    "away": "QAT",
+    "home_name": "Canada",
+    "away_name": "Qatar",
+    "kickoff_utc": "2026-06-18T22:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "MEX",
+    "away": "KOR",
+    "home_name": "Mexico",
+    "away_name": "South Korea",
+    "kickoff_utc": "2026-06-19T01:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "USA",
+    "away": "AUS",
+    "home_name": "United States",
+    "away_name": "Australia",
+    "kickoff_utc": "2026-06-19T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "SCO",
+    "away": "MAR",
+    "home_name": "Scotland",
+    "away_name": "Morocco",
+    "kickoff_utc": "2026-06-19T22:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "BRA",
+    "away": "HAI",
+    "home_name": "Brazil",
+    "away_name": "Haiti",
+    "kickoff_utc": "2026-06-20T00:30Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "TUR",
+    "away": "PAR",
+    "home_name": "T\u00fcrkiye",
+    "away_name": "Paraguay",
+    "kickoff_utc": "2026-06-20T03:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "NED",
+    "away": "SWE",
+    "home_name": "Netherlands",
+    "away_name": "Sweden",
+    "kickoff_utc": "2026-06-20T17:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "GER",
+    "away": "CIV",
+    "home_name": "Germany",
+    "away_name": "Ivory Coast",
+    "kickoff_utc": "2026-06-20T20:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "ECU",
+    "away": "CUW",
+    "home_name": "Ecuador",
+    "away_name": "Cura\u00e7ao",
+    "kickoff_utc": "2026-06-21T00:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "TUN",
+    "away": "JPN",
+    "home_name": "Tunisia",
+    "away_name": "Japan",
+    "kickoff_utc": "2026-06-21T04:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "ESP",
+    "away": "KSA",
+    "home_name": "Spain",
+    "away_name": "Saudi Arabia",
+    "kickoff_utc": "2026-06-21T16:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "BEL",
+    "away": "IRN",
+    "home_name": "Belgium",
+    "away_name": "Iran",
+    "kickoff_utc": "2026-06-21T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "URU",
+    "away": "CPV",
+    "home_name": "Uruguay",
+    "away_name": "Cape Verde",
+    "kickoff_utc": "2026-06-21T22:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "NZL",
+    "away": "EGY",
+    "home_name": "New Zealand",
+    "away_name": "Egypt",
+    "kickoff_utc": "2026-06-22T01:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "ARG",
+    "away": "AUT",
+    "home_name": "Argentina",
+    "away_name": "Austria",
+    "kickoff_utc": "2026-06-22T17:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "FRA",
+    "away": "IRQ",
+    "home_name": "France",
+    "away_name": "Iraq",
+    "kickoff_utc": "2026-06-22T21:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "NOR",
+    "away": "SEN",
+    "home_name": "Norway",
+    "away_name": "Senegal",
+    "kickoff_utc": "2026-06-23T00:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "JOR",
+    "away": "ALG",
+    "home_name": "Jordan",
+    "away_name": "Algeria",
+    "kickoff_utc": "2026-06-23T03:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "POR",
+    "away": "UZB",
+    "home_name": "Portugal",
+    "away_name": "Uzbekistan",
+    "kickoff_utc": "2026-06-23T17:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "ENG",
+    "away": "GHA",
+    "home_name": "England",
+    "away_name": "Ghana",
+    "kickoff_utc": "2026-06-23T20:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "PAN",
+    "away": "CRO",
+    "home_name": "Panama",
+    "away_name": "Croatia",
+    "kickoff_utc": "2026-06-23T23:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "COL",
+    "away": "COD",
+    "home_name": "Colombia",
+    "away_name": "Congo DR",
+    "kickoff_utc": "2026-06-24T02:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "BIH",
+    "away": "QAT",
+    "home_name": "Bosnia-Herzegovina",
+    "away_name": "Qatar",
+    "kickoff_utc": "2026-06-24T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "SUI",
+    "away": "CAN",
+    "home_name": "Switzerland",
+    "away_name": "Canada",
+    "kickoff_utc": "2026-06-24T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "MAR",
+    "away": "HAI",
+    "home_name": "Morocco",
+    "away_name": "Haiti",
+    "kickoff_utc": "2026-06-24T22:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "SCO",
+    "away": "BRA",
+    "home_name": "Scotland",
+    "away_name": "Brazil",
+    "kickoff_utc": "2026-06-24T22:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "CZE",
+    "away": "MEX",
+    "home_name": "Czechia",
+    "away_name": "Mexico",
+    "kickoff_utc": "2026-06-25T01:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "RSA",
+    "away": "KOR",
+    "home_name": "South Africa",
+    "away_name": "South Korea",
+    "kickoff_utc": "2026-06-25T01:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "CUW",
+    "away": "CIV",
+    "home_name": "Cura\u00e7ao",
+    "away_name": "Ivory Coast",
+    "kickoff_utc": "2026-06-25T20:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "ECU",
+    "away": "GER",
+    "home_name": "Ecuador",
+    "away_name": "Germany",
+    "kickoff_utc": "2026-06-25T20:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "JPN",
+    "away": "SWE",
+    "home_name": "Japan",
+    "away_name": "Sweden",
+    "kickoff_utc": "2026-06-25T23:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "TUN",
+    "away": "NED",
+    "home_name": "Tunisia",
+    "away_name": "Netherlands",
+    "kickoff_utc": "2026-06-25T23:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "PAR",
+    "away": "AUS",
+    "home_name": "Paraguay",
+    "away_name": "Australia",
+    "kickoff_utc": "2026-06-26T02:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "TUR",
+    "away": "USA",
+    "home_name": "T\u00fcrkiye",
+    "away_name": "United States",
+    "kickoff_utc": "2026-06-26T02:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "NOR",
+    "away": "FRA",
+    "home_name": "Norway",
+    "away_name": "France",
+    "kickoff_utc": "2026-06-26T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "SEN",
+    "away": "IRQ",
+    "home_name": "Senegal",
+    "away_name": "Iraq",
+    "kickoff_utc": "2026-06-26T19:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "CPV",
+    "away": "KSA",
+    "home_name": "Cape Verde",
+    "away_name": "Saudi Arabia",
+    "kickoff_utc": "2026-06-27T00:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "URU",
+    "away": "ESP",
+    "home_name": "Uruguay",
+    "away_name": "Spain",
+    "kickoff_utc": "2026-06-27T00:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "EGY",
+    "away": "IRN",
+    "home_name": "Egypt",
+    "away_name": "Iran",
+    "kickoff_utc": "2026-06-27T03:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "NZL",
+    "away": "BEL",
+    "home_name": "New Zealand",
+    "away_name": "Belgium",
+    "kickoff_utc": "2026-06-27T03:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "CRO",
+    "away": "GHA",
+    "home_name": "Croatia",
+    "away_name": "Ghana",
+    "kickoff_utc": "2026-06-27T21:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "PAN",
+    "away": "ENG",
+    "home_name": "Panama",
+    "away_name": "England",
+    "kickoff_utc": "2026-06-27T21:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "COL",
+    "away": "POR",
+    "home_name": "Colombia",
+    "away_name": "Portugal",
+    "kickoff_utc": "2026-06-27T23:30Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "COD",
+    "away": "UZB",
+    "home_name": "Congo DR",
+    "away_name": "Uzbekistan",
+    "kickoff_utc": "2026-06-27T23:30Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "ALG",
+    "away": "AUT",
+    "home_name": "Algeria",
+    "away_name": "Austria",
+    "kickoff_utc": "2026-06-28T02:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "JOR",
+    "away": "ARG",
+    "home_name": "Jordan",
+    "away_name": "Argentina",
+    "kickoff_utc": "2026-06-28T02:00Z",
+    "stage": "Group Stage"
+  },
+  {
+    "home": "2A",
+    "away": "2B",
+    "home_name": "Group A 2nd Place",
+    "away_name": "Group B 2nd Place",
+    "kickoff_utc": "2026-06-28T19:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1C",
+    "away": "2F",
+    "home_name": "Group C Winner",
+    "away_name": "Group F 2nd Place",
+    "kickoff_utc": "2026-06-29T17:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1E",
+    "away": "3RD",
+    "home_name": "Group E Winner",
+    "away_name": "Third Place Group A/B/C/D/F",
+    "kickoff_utc": "2026-06-29T20:30Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1F",
+    "away": "2C",
+    "home_name": "Group F Winner",
+    "away_name": "Group C 2nd Place",
+    "kickoff_utc": "2026-06-30T01:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "2E",
+    "away": "2I",
+    "home_name": "Group E 2nd Place",
+    "away_name": "Group I 2nd Place",
+    "kickoff_utc": "2026-06-30T17:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1I",
+    "away": "3RD",
+    "home_name": "Group I Winner",
+    "away_name": "Third Place Group C/D/F/G/H",
+    "kickoff_utc": "2026-06-30T21:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1A",
+    "away": "3RD",
+    "home_name": "Group A Winner",
+    "away_name": "Third Place Group C/E/F/H/I",
+    "kickoff_utc": "2026-07-01T01:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1L",
+    "away": "3RD",
+    "home_name": "Group L Winner",
+    "away_name": "Third Place Group E/H/I/J/K",
+    "kickoff_utc": "2026-07-01T16:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1G",
+    "away": "3RD",
+    "home_name": "Group G Winner",
+    "away_name": "Third Place Group A/E/H/I/J",
+    "kickoff_utc": "2026-07-01T20:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1D",
+    "away": "3RD",
+    "home_name": "Group D Winner",
+    "away_name": "Third Place Group B/E/F/I/J",
+    "kickoff_utc": "2026-07-02T00:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1H",
+    "away": "2J",
+    "home_name": "Group H Winner",
+    "away_name": "Group J 2nd Place",
+    "kickoff_utc": "2026-07-02T19:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "2K",
+    "away": "2L",
+    "home_name": "Group K 2nd Place",
+    "away_name": "Group L 2nd Place",
+    "kickoff_utc": "2026-07-02T23:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1B",
+    "away": "3RD",
+    "home_name": "Group B Winner",
+    "away_name": "Third Place Group E/F/G/I/J",
+    "kickoff_utc": "2026-07-03T03:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "2D",
+    "away": "2G",
+    "home_name": "Group D 2nd Place",
+    "away_name": "Group G 2nd Place",
+    "kickoff_utc": "2026-07-03T18:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1J",
+    "away": "2H",
+    "home_name": "Group J Winner",
+    "away_name": "Group H 2nd Place",
+    "kickoff_utc": "2026-07-03T22:00Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "1K",
+    "away": "3RD",
+    "home_name": "Group K Winner",
+    "away_name": "Third Place Group D/E/I/J/L",
+    "kickoff_utc": "2026-07-04T01:30Z",
+    "stage": "Round Of 32"
+  },
+  {
+    "home": "RD32",
+    "away": "RD32",
+    "home_name": "Round of 32 1 Winner",
+    "away_name": "Round of 32 3 Winner",
+    "kickoff_utc": "2026-07-04T17:00Z",
+    "stage": "Round Of 16"
+  },
+  {
+    "home": "RD32",
+    "away": "RD32",
+    "home_name": "Round of 32 2 Winner",
+    "away_name": "Round of 32 5 Winner",
+    "kickoff_utc": "2026-07-04T21:00Z",
+    "stage": "Round Of 16"
+  },
+  {
+    "home": "RD32",
+    "away": "RD32",
+    "home_name": "Round of 32 4 Winner",
+    "away_name": "Round of 32 6 Winner",
+    "kickoff_utc": "2026-07-05T20:00Z",
+    "stage": "Round Of 16"
+  },
+  {
+    "home": "RD32",
+    "away": "RD32",
+    "home_name": "Round of 32 7 Winner",
+    "away_name": "Round of 32 8 Winner",
+    "kickoff_utc": "2026-07-06T00:00Z",
+    "stage": "Round Of 16"
+  },
+  {
+    "home": "RD32",
+    "away": "RD32",
+    "home_name": "Round of 32 11 Winner",
+    "away_name": "Round of 32 12 Winner",
+    "kickoff_utc": "2026-07-06T19:00Z",
+    "stage": "Round Of 16"
+  },
+  {
+    "home": "RD32",
+    "away": "RD32",
+    "home_name": "Round of 32 9 Winner",
+    "away_name": "Round of 32 10 Winner",
+    "kickoff_utc": "2026-07-07T00:00Z",
+    "stage": "Round Of 16"
+  },
+  {
+    "home": "RD32",
+    "away": "RD32",
+    "home_name": "Round of 32 14 Winner",
+    "away_name": "Round of 32 16 Winner",
+    "kickoff_utc": "2026-07-07T16:00Z",
+    "stage": "Round Of 16"
+  },
+  {
+    "home": "RD32",
+    "away": "RD32",
+    "home_name": "Round of 32 13 Winner",
+    "away_name": "Round of 32 15 Winner",
+    "kickoff_utc": "2026-07-07T20:00Z",
+    "stage": "Round Of 16"
+  },
+  {
+    "home": "RD16 W1",
+    "away": "RD16 W2",
+    "home_name": "Round of 16 1 Winner",
+    "away_name": "Round of 16 2 Winner",
+    "kickoff_utc": "2026-07-09T20:00Z",
+    "stage": "Quarterfinals"
+  },
+  {
+    "home": "RD16 W5",
+    "away": "RD16 W6",
+    "home_name": "Round of 16 5 Winner",
+    "away_name": "Round of 16 6 Winner",
+    "kickoff_utc": "2026-07-10T19:00Z",
+    "stage": "Quarterfinals"
+  },
+  {
+    "home": "RD16 W3",
+    "away": "RD16 W4",
+    "home_name": "Round of 16 3 Winner",
+    "away_name": "Round of 16 4 Winner",
+    "kickoff_utc": "2026-07-11T21:00Z",
+    "stage": "Quarterfinals"
+  },
+  {
+    "home": "RD16 W7",
+    "away": "RD16 W8",
+    "home_name": "Round of 16 7 Winner",
+    "away_name": "Round of 16 8 Winner",
+    "kickoff_utc": "2026-07-12T01:00Z",
+    "stage": "Quarterfinals"
+  }
+]

schedule_match.py

@@ -0,0 +1,61 @@
+"""Helper: write predict + reflect cron entries for a single match.
+
+Imported by setup_schedule.py. Can also be run directly:
+  python schedule_match.py NED JPN 2026-06-14T20:00:00Z
+"""
+
+import subprocess
+import sys
+from datetime import datetime, timedelta, timezone
+
+
+def make_cron_lines(home: str, away: str, kickoff_utc: str) -> tuple[str, str]:
+    """Return (predict_cron_line, reflect_cron_line) for the match."""
+    dt = datetime.fromisoformat(kickoff_utc.replace("Z", "+00:00")).astimezone(timezone.utc)
+
+    predict_dt = dt - timedelta(minutes=30)
+    reflect_dt = dt + timedelta(minutes=150)  # 2.5 hours after kickoff
+
+    def cron_time(d: datetime) -> str:
+        return f"{d.minute} {d.hour} {d.day} {d.month} *"
+
+    log_file = f"logs/{home}_{away}.log"
+    base_cmd = f"cd /home/ubuntu/worldcup && source .env && /home/ubuntu/worldcup/venv/bin/python"
+
+    predict_line = (
+        f"# {home} vs {away} — predict (30 min before kickoff {dt.strftime('%Y-%m-%d %H:%M')} UTC)\n"
+        f"{cron_time(predict_dt)} {base_cmd} predict.py {home} {away} >> {log_file} 2>&1"
+    )
+    reflect_line = (
+        f"# {home} vs {away} — reflect (2.5h after kickoff)\n"
+        f"{cron_time(reflect_dt)} {base_cmd} reflect.py {home} {away} >> {log_file} 2>&1"
+    )
+    return predict_line, reflect_line
+
+
+def add_cron_entries(home: str, away: str, kickoff_utc: str) -> tuple[str, str]:
+    """Add cron entries if not already present. Returns the two lines added."""
+    predict_line, reflect_line = make_cron_lines(home, away, kickoff_utc)
+
+    result = subprocess.run(["crontab", "-l"], capture_output=True, text=True)
+    existing = result.stdout if result.returncode == 0 else ""
+
+    skip_marker = f"predict.py {home} {away}"
+    if skip_marker in existing:
+        return predict_line, reflect_line  # already scheduled, skip
+
+    new_crontab = existing.rstrip() + "\n\n" + predict_line + "\n" + reflect_line + "\n"
+    subprocess.run(["crontab", "-"], input=new_crontab, text=True, check=True)
+    return predict_line, reflect_line
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 4:
+        print("Usage: python schedule_match.py HOME AWAY KICKOFF_UTC")
+        print("Example: python schedule_match.py NED JPN 2026-06-14T20:00:00Z")
+        sys.exit(1)
+    home, away, kickoff = sys.argv[1].upper(), sys.argv[2].upper(), sys.argv[3]
+    p, r = add_cron_entries(home, away, kickoff)
+    print("Added cron entries:")
+    print(p)
+    print(r)

setup_schedule.py

@@ -0,0 +1,145 @@
+"""Fetch World Cup 2026 fixture list and write all cron entries at once.
+
+Run once at the start of the tournament:
+  python setup_schedule.py           # fetch + schedule + push schedule.json
+  python setup_schedule.py --dry-run # print only, no cron writes
+"""
+
+import json
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import requests
+
+import schedule_match
+
+WORK_DIR = Path(__file__).parent
+
+# World Cup 2026 date range
+WC_START = "20260611"
+WC_END   = "20260719"
+
+ESPN_URL = "https://site.api.espn.com/apis/site/v2/sports/soccer/fifa.world/scoreboard"
+
+
+def fetch_fixtures() -> list[dict]:
+    """Fetch all WC 2026 fixtures from ESPN public API."""
+    print(f"Fetching fixtures from ESPN ({WC_START}–{WC_END})...")
+    resp = requests.get(ESPN_URL, params={"dates": f"{WC_START}-{WC_END}"}, timeout=30)
+    resp.raise_for_status()
+    data = resp.json()
+
+    fixtures = []
+    for event in data.get("events", []):
+        comps = event.get("competitions", [{}])
+        if not comps:
+            continue
+        comp = comps[0]
+        competitors = comp.get("competitors", [])
+        if len(competitors) != 2:
+            continue
+
+        home_team = next((c for c in competitors if c.get("homeAway") == "home"), None)
+        away_team = next((c for c in competitors if c.get("homeAway") == "away"), None)
+        if not home_team or not away_team:
+            continue
+
+        kickoff_utc = event.get("date", "")  # ISO format from ESPN
+        stage = (
+            event.get("season", {}).get("slug", "")
+            or "group-stage"
+        ).replace("-", " ").title()
+
+        fixtures.append({
+            "home": home_team["team"].get("abbreviation", "").upper(),
+            "away": away_team["team"].get("abbreviation", "").upper(),
+            "home_name": home_team["team"].get("displayName", ""),
+            "away_name": away_team["team"].get("displayName", ""),
+            "kickoff_utc": kickoff_utc,
+            "stage": stage,
+        })
+
+    print(f"Found {len(fixtures)} fixtures")
+    return fixtures
+
+
+def main():
+    dry_run = "--dry-run" in sys.argv
+
+    try:
+        fixtures = fetch_fixtures()
+    except Exception as e:
+        print(f"ERROR: ESPN API failed: {e}")
+        sys.exit(1)
+
+    if not fixtures:
+        print("No fixtures found. Check ESPN API or date range.")
+        sys.exit(1)
+
+    # Save schedule.json regardless of dry-run
+    schedule_path = WORK_DIR / "schedule.json"
+    schedule_path.write_text(json.dumps(fixtures, indent=2))
+    print(f"Saved {len(fixtures)} fixtures to schedule.json")
+
+    now = datetime.now(timezone.utc)
+    upcoming = [
+        f for f in fixtures
+        if f.get("kickoff_utc") and datetime.fromisoformat(
+            f["kickoff_utc"].replace("Z", "+00:00")
+        ) > now
+    ]
+    past = len(fixtures) - len(upcoming)
+    print(f"  {len(upcoming)} upcoming, {past} already past")
+
+    added = 0
+    skipped = 0
+
+    for fixture in upcoming:
+        home = fixture["home"]
+        away = fixture["away"]
+        kickoff = fixture["kickoff_utc"]
+
+        if not home or not away or not kickoff:
+            continue
+
+        p_line, r_line = schedule_match.make_cron_lines(home, away, kickoff)
+        print(f"\n  {home} vs {away} — {kickoff}")
+        print(f"    {p_line.splitlines()[-1]}")
+        print(f"    {r_line.splitlines()[-1]}")
+
+        if not dry_run:
+            try:
+                schedule_match.add_cron_entries(home, away, kickoff)
+                added += 1
+            except Exception as e:
+                print(f"    WARNING: cron write failed: {e}")
+                skipped += 1
+        else:
+            added += 1
+
+    if dry_run:
+        print(f"\nDRY RUN: would schedule {added} matches. Run without --dry-run to apply.")
+    else:
+        print(f"\nScheduled {added} matches ({skipped} failed).")
+        # Push schedule.json to GitHub
+        try:
+            subprocess.run(
+                ["git", "add", "schedule.json"],
+                cwd=WORK_DIR, check=True, capture_output=True,
+            )
+            subprocess.run(
+                ["git", "commit", "-m", "setup: add WC 2026 fixture schedule"],
+                cwd=WORK_DIR, check=True, capture_output=True,
+            )
+            subprocess.run(["git", "push"], cwd=WORK_DIR, check=True, capture_output=True)
+            print("Pushed schedule.json to GitHub")
+        except Exception as e:
+            print(f"Git push failed (schedule.json saved locally): {e}")
+
+    print("\nDone. Verify with: crontab -l")
+
+
+if __name__ == "__main__":
+    main()

setup_wallet.py

@@ -0,0 +1,61 @@
+"""One-time wallet setup. Run manually once before first match.
+
+Generates a fresh Ethereum keypair and prints the values to add to .env.
+For base-sepolia testing, prints faucet URLs to get test USDC.
+"""
+
+import os
+import sys
+
+from dotenv import load_dotenv
+from eth_account import Account
+
+load_dotenv()
+
+
+def main():
+    network = os.getenv("NETWORK", "base-mainnet")
+    print(f"Generating new Ethereum wallet for {network}...\n")
+
+    account = Account.create()
+    address = account.address
+    private_key = account.key.hex()
+    if not private_key.startswith("0x"):
+        private_key = "0x" + private_key
+
+    print("=" * 60)
+    print("Add these to your .env file:")
+    print("=" * 60)
+    print(f"WALLET_ADDRESS={address}")
+    print(f"WALLET_PRIVATE_KEY={private_key}")
+    print("=" * 60)
+    print()
+
+    if network == "base-sepolia":
+        print("TESTNET SETUP — fund your wallet with test USDC:")
+        print(f"  Address: {address}")
+        print()
+        print("  1. Get test ETH (for gas) from:")
+        print("     https://www.coinbase.com/faucets/base-ethereum-goerli-faucet")
+        print()
+        print("  2. Get test USDC from:")
+        print("     https://faucet.circle.com/  (select Base Sepolia)")
+        print()
+        print("  USDC contract on Base Sepolia:")
+        print("  0x036CbD53842c5426634e7929541eC2318f3dCF7e")
+    else:
+        print("MAINNET SETUP — fund your wallet with real USDC on Base:")
+        print(f"  Address: {address}")
+        print()
+        print("  Transfer USDC to this address on Base mainnet.")
+        print("  Minimum recommended balance: $2.00 USDC")
+        print()
+        print("  USDC contract on Base mainnet:")
+        print("  0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913")
+
+    print()
+    print("WARNING: Store your private key securely. Never commit .env to git.")
+
+
+if __name__ == "__main__":
+    main()

templates/index.html

@@ -0,0 +1,318 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>⚽ World Cup Prediction Agent</title>
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body { background: #0d0d0d; color: #e0e0e0; font-family: 'JetBrains Mono', 'Fira Code', monospace; font-size: 14px; line-height: 1.6; }
+  a { color: #4dabf7; text-decoration: none; }
+  a:hover { text-decoration: underline; }
+
+  .container { max-width: 900px; margin: 0 auto; padding: 24px 16px; }
+
+  header { border-bottom: 1px solid #333; padding-bottom: 16px; margin-bottom: 24px; }
+  header h1 { font-size: 20px; color: #fff; }
+  header .meta { display: flex; gap: 24px; margin-top: 8px; color: #888; font-size: 12px; }
+  header .meta span { color: #e0e0e0; }
+
+  nav { margin-bottom: 24px; display: flex; gap: 16px; font-size: 13px; }
+
+  h2 { font-size: 14px; color: #aaa; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 12px; border-bottom: 1px solid #222; padding-bottom: 6px; }
+
+  .section { margin-bottom: 32px; }
+
+  /* Upcoming */
+  .upcoming-grid { display: flex; flex-direction: column; gap: 6px; }
+  .upcoming-item { background: #161616; border: 1px solid #2a2a2a; border-radius: 4px; padding: 8px 12px; display: flex; justify-content: space-between; align-items: center; }
+  .upcoming-item .teams { font-weight: bold; color: #fff; }
+  .upcoming-item .kick { color: #666; font-size: 12px; }
+  .upcoming-item .stage { color: #555; font-size: 11px; }
+
+  /* Match cards */
+  .match-card { background: #111; border: 1px solid #2a2a2a; border-radius: 6px; margin-bottom: 16px; overflow: hidden; }
+  .match-header { padding: 12px 16px; display: flex; justify-content: space-between; align-items: center; background: #161616; border-bottom: 1px solid #222; }
+  .match-title { font-size: 15px; font-weight: bold; color: #fff; }
+  .match-time { font-size: 11px; color: #555; }
+  .badge { display: inline-block; padding: 2px 8px; border-radius: 3px; font-size: 11px; font-weight: bold; }
+  .badge.correct { background: #1a3a1a; color: #4caf50; border: 1px solid #4caf50; }
+  .badge.incorrect { background: #3a1a1a; color: #f44336; border: 1px solid #f44336; }
+  .badge.pending { background: #1a1a3a; color: #888; border: 1px solid #444; }
+
+  .match-body { padding: 12px 16px; }
+
+  .prediction-row { display: flex; gap: 24px; margin-bottom: 12px; flex-wrap: wrap; }
+  .pred-item { }
+  .pred-label { font-size: 10px; color: #555; text-transform: uppercase; }
+  .pred-value { font-size: 14px; color: #e0e0e0; }
+  .pred-value.pick { font-size: 16px; font-weight: bold; color: #fff; }
+
+  .reasoning { font-size: 12px; color: #888; font-style: italic; margin-bottom: 12px; }
+
+  /* x402 table */
+  .x402-section { margin-top: 8px; }
+  .x402-label { font-size: 10px; color: #555; text-transform: uppercase; margin-bottom: 4px; }
+  .x402-table { width: 100%; border-collapse: collapse; font-size: 12px; }
+  .x402-table th { text-align: left; color: #555; font-weight: normal; padding: 3px 6px; border-bottom: 1px solid #222; }
+  .x402-table td { padding: 4px 6px; color: #aaa; border-bottom: 1px solid #1a1a1a; vertical-align: top; }
+  .x402-table td:first-child { color: #4dabf7; font-size: 11px; word-break: break-all; max-width: 300px; }
+  .x402-table td.cost { color: #f9a825; white-space: nowrap; }
+  .no-x402 { font-size: 12px; color: #444; font-style: italic; }
+
+  .result-bar { margin-top: 10px; padding: 8px 12px; border-radius: 4px; font-size: 13px; }
+  .result-bar.correct { background: #0d1f0d; border-left: 3px solid #4caf50; }
+  .result-bar.incorrect { background: #1f0d0d; border-left: 3px solid #f44336; }
+  .result-score { font-weight: bold; color: #fff; }
+
+  .evaluation { margin-top: 8px; font-size: 12px; color: #777; }
+  .detail-link { font-size: 11px; color: #555; margin-top: 6px; display: block; }
+
+  /* Strategy page */
+  .strategy-box { background: #111; border: 1px solid #2a2a2a; border-radius: 6px; padding: 16px; }
+  pre { white-space: pre-wrap; word-wrap: break-word; color: #bbb; font-size: 13px; }
+  .strategy-empty { color: #444; font-style: italic; }
+
+  .history-item { border-bottom: 1px solid #1a1a1a; padding: 10px 0; }
+  .history-match { font-size: 12px; color: #888; margin-bottom: 6px; }
+  .history-snapshot { font-size: 11px; color: #555; }
+
+  /* Detail page */
+  .detail-section { margin-bottom: 24px; }
+  .detail-section h3 { font-size: 12px; color: #555; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 8px; }
+  .full-text { font-size: 12px; color: #aaa; white-space: pre-wrap; background: #0a0a0a; border: 1px solid #1e1e1e; border-radius: 4px; padding: 12px; max-height: 400px; overflow-y: auto; }
+</style>
+</head>
+<body>
+<div class="container">
+
+<header>
+  <h1>⚽ World Cup Prediction Agent</h1>
+  <div class="meta">
+    {% if stats %}
+    <div>Record: <span>{{ stats.wins }}W–{{ stats.losses }}L ({{ stats.pct }})</span></div>
+    <div>Matches predicted: <span>{{ stats.total }}</span></div>
+    {% endif %}
+    <div><a href="/">Dashboard</a> · <a href="/strategy">Strategy</a></div>
+  </div>
+</header>
+
+{% if detail %}
+<!-- ─── Match Detail Page ─── -->
+<div>
+  <a href="/" style="color:#555;font-size:12px;">← Back to dashboard</a>
+</div>
+<br>
+
+{% set r = detail %}
+{% set pred = r.prediction %}
+{% set res = r.result %}
+{% if res %}
+  {% if r.correct %}
+    <div class="result-bar correct">
+      <span class="result-score">{{ r.home }} {{ res.home_score }}–{{ res.away_score }} {{ r.away }}</span>
+      &nbsp;·&nbsp; <span class="badge correct">✓ CORRECT</span>
+    </div>
+  {% else %}
+    <div class="result-bar incorrect">
+      <span class="result-score">{{ r.home }} {{ res.home_score }}–{{ res.away_score }} {{ r.away }}</span>
+      &nbsp;·&nbsp; <span class="badge incorrect">✗ INCORRECT</span>
+    </div>
+  {% endif %}
+{% else %}
+  <div style="font-size:13px;color:#555;">Result not yet available</div>
+{% endif %}
+<br>
+
+<div class="detail-section">
+  <h3>Prediction</h3>
+  <div class="prediction-row">
+    <div class="pred-item"><div class="pred-label">Pick</div><div class="pred-value pick">{{ pred.pick | upper }}</div></div>
+    <div class="pred-item"><div class="pred-label">Confidence</div><div class="pred-value">{{ pred.confidence }}/10</div></div>
+    <div class="pred-item"><div class="pred-label">Bet Size</div><div class="pred-value">${{ pred.bet }}</div></div>
+    <div class="pred-item"><div class="pred-label">Kickoff</div><div class="pred-value" style="font-size:12px;">{{ r.kickoff }}</div></div>
+  </div>
+  <div class="reasoning">{{ pred.reasoning }}</div>
+</div>
+
+<div class="detail-section">
+  <h3>x402 Research ({{ r.services_used | length }} purchased, ${{ "%.4f" | format(r.research_cost) }} spent)</h3>
+  {% if r.services_planned %}
+  <table class="x402-table">
+    <tr><th>Endpoint</th><th>Cost</th><th>Status</th><th>Reason</th></tr>
+    {% set used_urls = r.services_used | map(attribute='source') | list %}
+    {% for svc in r.services_planned %}
+    <tr>
+      <td>{{ svc.url }}</td>
+      <td class="cost">${{ "%.4f" | format(svc.cost) }}</td>
+      <td>{% if svc.url in used_urls %}<span style="color:#4caf50">✓ bought</span>{% else %}<span style="color:#555">skipped</span>{% endif %}</td>
+      <td>{{ svc.reason }}</td>
+    </tr>
+    {% endfor %}
+  </table>
+  {% if r.services_used %}
+  <br>
+  <div style="font-size:11px;color:#555;">Data received:</div>
+  {% for svc in r.services_used %}
+  <div style="margin-top:8px;font-size:11px;color:#4dabf7;">{{ svc.source }}</div>
+  {% endfor %}
+  {% endif %}
+  {% else %}
+  <div class="no-x402">No services were considered for this match.</div>
+  {% endif %}
+</div>
+
+<div class="detail-section">
+  <h3>Full Gemini Reasoning</h3>
+  <div class="full-text">{{ r.full_reasoning }}</div>
+</div>
+
+{% if r.evaluation %}
+<div class="detail-section">
+  <h3>Post-Match Evaluation</h3>
+  <div class="full-text">{{ r.evaluation }}</div>
+</div>
+{% endif %}
+
+{% if r.strategy_snapshot %}
+<div class="detail-section">
+  <h3>Strategy at Time of Prediction</h3>
+  <div class="full-text">{{ r.strategy_snapshot if r.strategy_snapshot else "(no strategy yet at time of prediction)" }}</div>
+</div>
+{% endif %}
+
+{% elif strategy_page %}
+<!-- ─── Strategy Page ─── -->
+<div class="section">
+  <h2>Current Strategy</h2>
+  <div class="strategy-box">
+    {% if strategy %}
+      <pre>{{ strategy }}</pre>
+    {% else %}
+      <div class="strategy-empty">No strategy yet — will be written after the first match reflection.</div>
+    {% endif %}
+  </div>
+</div>
+
+{% if strategy_history %}
+<div class="section">
+  <h2>Strategy Evolution</h2>
+  {% for item in strategy_history | reverse %}
+  <div class="history-item">
+    <div class="history-match">After {{ item.match }} ({{ item.kickoff[:10] if item.kickoff else '?' }})</div>
+    <div class="history-snapshot">{{ item.snapshot[:300] if item.snapshot else "(empty at this point)" }}{% if item.snapshot and item.snapshot | length > 300 %}…{% endif %}</div>
+  </div>
+  {% endfor %}
+{% endif %}
+
+{% else %}
+<!-- ─── Dashboard ─── -->
+
+{% if upcoming %}
+<div class="section">
+  <h2>Upcoming Matches</h2>
+  <div class="upcoming-grid">
+    {% for f in upcoming %}
+    <div class="upcoming-item">
+      <div>
+        <span class="teams">{{ f.home }} vs {{ f.away }}</span>
+        <span class="stage" style="margin-left:8px;">{{ f.stage }}</span>
+      </div>
+      <div class="kick">{{ f.kickoff_utc[:16].replace("T", " ") }} UTC</div>
+    </div>
+    {% endfor %}
+  </div>
+</div>
+{% endif %}
+
+{% if results %}
+<div class="section">
+  <h2>Predictions</h2>
+  {% for r in results %}
+  {% set pred = r.prediction %}
+  {% set res = r.result %}
+  <div class="match-card">
+    <div class="match-header">
+      <div>
+        <div class="match-title">{{ r.match }}</div>
+        <div class="match-time">{{ r.kickoff[:16].replace("T", " ") }} UTC</div>
+      </div>
+      <div>
+        {% if r.correct is not none %}
+          {% if r.correct %}
+            <span class="badge correct">✓ CORRECT</span>
+          {% else %}
+            <span class="badge incorrect">✗ INCORRECT</span>
+          {% endif %}
+        {% else %}
+          <span class="badge pending">PENDING</span>
+        {% endif %}
+      </div>
+    </div>
+    <div class="match-body">
+      <div class="prediction-row">
+        <div class="pred-item"><div class="pred-label">Pick</div><div class="pred-value pick">{{ pred.pick | upper }}</div></div>
+        <div class="pred-item"><div class="pred-label">Confidence</div><div class="pred-value">{{ pred.confidence }}/10</div></div>
+        <div class="pred-item"><div class="pred-label">Bet</div><div class="pred-value">${{ pred.bet }}</div></div>
+        <div class="pred-item"><div class="pred-label">Research cost</div><div class="pred-value" style="color:#f9a825;">${{ "%.4f" | format(r.research_cost) }}</div></div>
+      </div>
+      <div class="reasoning">"{{ pred.reasoning }}"</div>
+
+      <!-- x402 purchase log -->
+      {% if r.services_used %}
+      <div class="x402-section">
+        <div class="x402-label">x402 data purchased</div>
+        <table class="x402-table">
+          <tr><th>Endpoint</th><th>Cost</th><th>Reason</th></tr>
+          {% for svc in r.services_used %}
+          <tr>
+            <td>{{ svc.source }}</td>
+            <td class="cost">${{ "%.4f" | format(svc.cost) }}</td>
+            <td>{{ svc.get('reason', '') }}</td>
+          </tr>
+          {% endfor %}
+        </table>
+      </div>
+      {% elif r.services_planned %}
+      <div class="no-x402">{{ r.services_planned | length }} endpoint(s) considered but none purchased (budget or availability).</div>
+      {% else %}
+      <div class="no-x402">No x402 data purchased for this match.</div>
+      {% endif %}
+
+      {% if res %}
+      <div class="result-bar {{ 'correct' if r.correct else 'incorrect' }}" style="margin-top:10px;">
+        Result: <span class="result-score">{{ r.home }} {{ res.home_score }}–{{ res.away_score }} {{ r.away }}</span>
+        {% if r.evaluation %}
+        <div class="evaluation">{{ r.evaluation[:200] }}{% if r.evaluation | length > 200 %}…{% endif %}</div>
+        {% endif %}
+      </div>
+      {% endif %}
+
+      <a href="/match/{{ r.home }}_{{ r.away }}" class="detail-link">View full reasoning & reflection →</a>
+    </div>
+  </div>
+  {% endfor %}
+</div>
+
+{% else %}
+<div style="color:#444;font-style:italic;padding:32px 0;">
+  No predictions yet. The agent will make its first prediction 30 minutes before the next match.
+</div>
+{% endif %}
+
+{% if strategy %}
+<div class="section">
+  <h2>Current Strategy <a href="/strategy" style="font-size:11px;color:#555;font-weight:normal;margin-left:8px;">full history →</a></h2>
+  <div class="strategy-box">
+    <pre>{{ strategy[:600] }}{% if strategy | length > 600 %}
+
+<a href="/strategy">… read more</a>{% endif %}</pre>
+  </div>
+</div>
+{% endif %}
+
+{% endif %}
+
+</div>
+</body>
+</html>

wallet.py

@@ -0,0 +1,68 @@
+"""Wallet helpers — balance checking and x402 payment session creation."""
+
+import logging
+import os
+
+from dotenv import load_dotenv
+from eth_account import Account
+from web3 import Web3
+from x402 import x402ClientSync
+from x402.http.clients.requests import x402_requests
+from x402.mechanisms.evm.exact import ExactEvmScheme
+
+load_dotenv()
+
+log = logging.getLogger(__name__)
+
+USDC_ABI = [
+    {
+        "inputs": [{"name": "account", "type": "address"}],
+        "name": "balanceOf",
+        "outputs": [{"name": "", "type": "uint256"}],
+        "stateMutability": "view",
+        "type": "function",
+    }
+]
+
+USDC_MAINNET = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+USDC_SEPOLIA = "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+
+
+def _network_config() -> tuple[str, str, str]:
+    """Return (network_name, rpc_url, usdc_address, chain_pattern)."""
+    network = os.getenv("NETWORK", "base-mainnet")
+    if network == "base-mainnet":
+        return "base-mainnet", "https://mainnet.base.org", USDC_MAINNET, "eip155:8453"
+    return "base-sepolia", "https://sepolia.base.org", USDC_SEPOLIA, "eip155:84532"
+
+
+def get_balance() -> float:
+    """Return current USDC balance of WALLET_ADDRESS as a float."""
+    try:
+        _, rpc_url, usdc_address, _ = _network_config()
+        address = os.getenv("WALLET_ADDRESS", "")
+        if not address:
+            log.warning("WALLET_ADDRESS not set in .env")
+            return 0.0
+        w3 = Web3(Web3.HTTPProvider(rpc_url))
+        contract = w3.eth.contract(
+            address=Web3.to_checksum_address(usdc_address), abi=USDC_ABI
+        )
+        raw = contract.functions.balanceOf(Web3.to_checksum_address(address)).call()
+        return raw / 1_000_000
+    except Exception as e:
+        log.warning("Balance check failed: %s", e)
+        return 0.0
+
+
+def get_x402_client():
+    """Return a requests.Session that auto-handles 402 payment responses."""
+    _, _, _, chain_pattern = _network_config()
+    private_key = os.getenv("WALLET_PRIVATE_KEY", "")
+    if not private_key.startswith("0x"):
+        private_key = "0x" + private_key
+    account = Account.from_key(private_key)
+    scheme = ExactEvmScheme(signer=account)
+    client = x402ClientSync()
+    client.register(chain_pattern, scheme)
+    return x402_requests(client)