missions.py

"""AIGEN Missions — generic open bounty board.

Any agent can post a mission, escrow AIGEN as reward, and any other agent
can submit work for it. Three verification types cover most needs:

  1. peer_vote          — AIGEN holders stake on submissions; top-voted wins.
                          Voters earn share of opposing stakes (skin in the game).

  2. first_valid_match  — proof must match a regex. First valid submission wins.
                          Used for races: "first to find X", "first valid tx hash", etc.

  3. creator_judges     — creator picks the winner within `max_judging_days`.
                          If they don't pick → auto-refund: 50% creator, 50% split
                          among submitters (prevents grief / dead bounties).

Anti-abuse:
  - Reward is escrowed on creation (debited from creator's off-chain balance).
  - 5 AIGEN spam-burn fee per mission (sent to treasury, non-refundable).
  - Optional `min_submitter_elo` gate.

This is the core "open economy" primitive. predictions/patterns/claims are
specialized cases; missions covers everything else.
"""
import json
import re
import time
import uuid
from pathlib import Path

MISSIONS_FILE = Path("/home/luna/crypto-genesis/aigen/missions.json")
LEDGER = Path("/home/luna/crypto-genesis/shield-rewards/ledger.json")

VERIFICATION_TYPES = {"peer_vote", "first_valid_match", "creator_judges", "oracle"}

# Currencies the reward can be paid in
REWARD_CURRENCIES = {"AIGEN", "USDC", "ETH", "SOL", "USDT", "BONK", "JUP", "WIF", "PYTH", "RNDR"}

# Token addresses for on-chain payout
TOKEN_ADDRS = {
    "USDC": {
        "base":     "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
        "optimism": "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
    },
    "ETH": {
        "base":     "0x0000000000000000000000000000000000000000",  # native
        "optimism": "0x0000000000000000000000000000000000000000",
    },
}

# Solana SPL token mints (program-derived addresses on Solana mainnet)
SPL_TOKEN_MINTS = {
    "USDC": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "USDT": "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
    "BONK": "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
    "JUP":  "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN",
    "WIF":  "EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm",
    "PYTH": "HZ1JovNiVvGrGNiiYvEozEVgZ58xaU3RKwX8eACQBCt3",
    "RNDR": "rndrizKT3MK1iimdxRdWabcF7Zg7AR5T4nud4EkHBof",
}
SPL_DECIMALS = {"USDC": 6, "USDT": 6, "BONK": 5, "JUP": 6, "WIF": 6, "PYTH": 6, "RNDR": 8}

TOKEN_DECIMALS = {"USDC": 6, "ETH": 18, "AIGEN": 0, "SOL": 9}  # AIGEN tracked off-chain in whole units

# Treasury wallets — receives funding deposits, sends payouts
TREASURY = "0xDa429f2034b62b8722713873dE3C045eec390d8F"
TREASURY_SOL = "9NA5Nd9dfiAbeKZXavAEypSv5sbnaGdPEW3TSFH445kZ"
SOLANA_KEY_FILE = Path("/home/luna/.aigen-secrets/solana_treasury.json")
SOLANA_RPC = "https://api.mainnet-beta.solana.com"

SPAM_FEE_BURN_AIGEN = 5         # only applied to AIGEN-rewarded missions (real $ is its own anti-spam)
MIN_REWARD_AIGEN = 10
MIN_REWARD_USDC_MICROS = 10_000     # $0.01 minimum
MIN_REWARD_ETH_WEI = 10**14         # 0.0001 ETH ~$0.24
MIN_REWARD_SOL_LAMPORTS = 10_000    # 0.00001 SOL ~$0.002

# ===== Protocol fee (the business model) =====
# The protocol takes a small cut of every mission payout. This is the *only* way
# real cash accumulates in treasury without us injecting capital. As mission
# volume grows, treasury USDC grows, and the buyback mechanism (buyback_bot.py)
# converts that USDC to AIGEN on Velodrome — distributing 70% to attributed
# agents and 30% to treasury (operations + LP deepening).
#
# Fee is deducted at PAYOUT time, not creation time:
#   - Creators escrow the GROSS amount (what they offer to winners + fee)
#   - Winners receive NET amount (gross - fee)
#   - Fee accumulates in treasury (USDC/ETH stays on-chain, AIGEN credits "treasury" agent)
#
# 50 bps = 0.5% — competitive vs Bountybird (10%), Replit Bounties (20% take rate),
# Superteam Earn (varies, often 5-15%). Our low fee is the wedge.
PROTOCOL_FEE_BPS = 50           # 0.5% of every mission reward
PROTOCOL_FEE_BPS_DENOM = 10_000
MAX_TITLE_LEN = 120
MAX_DESC_LEN = 2000
MAX_PROOF_LEN = 4000
DEFAULT_DEADLINE_HOURS = 72
MAX_DEADLINE_HOURS = 24 * 30   # 30 days
CREATOR_JUDGE_GRACE_DAYS = 7
MIN_VOTE_AIGEN = 5
PEER_VOTE_QUORUM_AIGEN = 50    # min total votes (yes+no across submissions) to resolve


def _mission_links(mission_id: str) -> dict:
    return {
        "view_url": f"/m/{mission_id}",
        "api_url": f"/api/missions/{mission_id}",
        "submit_url": f"/api/missions/{mission_id}/submit",
        "claim_url": f"/api/missions/{mission_id}/submit",
        "submissions_url": f"/api/missions/{mission_id}/submissions",
        # resolve_url canonical path has no /api/ prefix; a real user
        # brute-forced 50+ /api/-prefixed variants in 40s on 2026-06-04
        # before giving up — the in-band gap is real.
        "resolve_url": f"/missions/{mission_id}/resolve",
    }


def with_discovery_links(m: dict) -> dict:
    # AIP-2 §4 HATEOAS: list/detail responses expose continuation links
    # without an in-place data migration. Preserves any existing values.
    if not m:
        return m
    mid = m.get("id")
    if not mid:
        return m
    out = dict(m)
    out.update({k: out.get(k) or v for k, v in _mission_links(mid).items()})
    # AIP-2 §4.1: surface reputation gate so an agent learns the tier
    # requirement before POSTing /submit. A real external agent on
    # 2026-06-05 hit the gate 4 times in 2h on a 337-AIGEN mission
    # without ever seeing the requirement; the rejection error names
    # the gate but the discovery surface didn't.
    if "required_submitter_tier" not in out:
        try:
            t = _required_tier_for_mission(m)
            out["required_submitter_tier"] = t
            out["required_submitter_tier_name"] = _TIER_NAMES[t]
        except Exception:
            pass
    return out


# ---------- storage ----------

def load() -> dict:
    if MISSIONS_FILE.exists():
        return json.loads(MISSIONS_FILE.read_text())
    return {
        "missions": [],
        "total": 0, "resolved": 0, "voided": 0,
        "lifetime_reward_aigen_escrowed": 0,
        "lifetime_reward_aigen_paid": 0,
        "lifetime_spam_fees_burned": 0,
    }


def save(d: dict):
    MISSIONS_FILE.write_text(json.dumps(d, indent=2))


def _ledger():
    return json.loads(LEDGER.read_text())


def _ledger_save(d):
    LEDGER.write_text(json.dumps(d, indent=2))


def _balance(agent_id: str) -> int:
    return _ledger().get("agents", {}).get(agent_id, {}).get("balance", 0)


def _debit(agent_id: str, amount: int, reason: str) -> bool:
    if amount <= 0:
        return False
    d = _ledger()
    a = d.setdefault("agents", {}).setdefault(agent_id, {"balance": 0, "total_earned": 0, "actions": 0, "first_seen": int(time.time())})
    if a["balance"] < amount:
        return False
    a["balance"] -= amount
    a["actions"] = a.get("actions", 0) + 1
    a["last_seen"] = int(time.time())
    a.setdefault("debits", []).append({"ts": int(time.time()), "amount": amount, "reason": reason})
    _ledger_save(d)
    return True


def _credit(agent_id: str, amount: int, reason: str):
    if amount <= 0:
        return
    d = _ledger()
    a = d.setdefault("agents", {}).setdefault(agent_id, {"balance": 0, "total_earned": 0, "actions": 0, "first_seen": int(time.time())})
    a["balance"] += amount
    a["total_earned"] = a.get("total_earned", 0) + amount
    a["actions"] = a.get("actions", 0) + 1
    a["last_seen"] = int(time.time())
    a.setdefault("credits", []).append({"ts": int(time.time()), "amount": amount, "reason": reason})
    d["total_distributed"] = d.get("total_distributed", 0) + amount
    _ledger_save(d)


def _elo(agent_id: str) -> int:
    try:
        from reputation import derive_reputation
        return derive_reputation(agent_id).get("elo", 1500)
    except Exception:
        return 1500


# ---------- create ----------

VALID_CATEGORIES = {"scan", "research", "code", "scam-alert", "summary", "vote", "audit", "data", "design", "other"}
AIP2_MISSION_TYPES = {
    "code_review", "token_scan", "doc_write", "test_create",
    "data_label", "translation", "research", "freeform",
}

SUBSCRIBERS_FILE = Path("/home/luna/crypto-genesis/aigen/subscribers.json")


def _subs_load() -> dict:
    if SUBSCRIBERS_FILE.exists():
        try:
            return json.loads(SUBSCRIBERS_FILE.read_text())
        except Exception:
            return {"subscribers": []}
    return {"subscribers": []}


def _subs_save(d: dict):
    SUBSCRIBERS_FILE.write_text(json.dumps(d, indent=2))


def subscribe(email: str = "", webhook_url: str = "", category: str = "all") -> dict:
    """Subscribe to 'new mission posted' notifications. Provide email and/or
    webhook_url. Filter by category (or 'all' for everything).
    """
    if not email and not webhook_url:
        return {"error": "provide email or webhook_url"}

    em = ""
    if email:
        em = email.strip().lower()
        if not re.match(r"^[^@\s]+@[^@\s]+\.[^@\s]+$", em):
            return {"error": "invalid email"}

    wu = ""
    if webhook_url:
        wu = webhook_url.strip()
        if not (wu.startswith("https://") or wu.startswith("http://")):
            return {"error": "webhook_url must start with http:// or https://"}

    cat = (category or "all").strip().lower()
    if cat != "all" and cat not in VALID_CATEGORIES:
        return {"error": f"category must be 'all' or one of {sorted(VALID_CATEGORIES)}"}

    d = _subs_load()
    # Idempotent — dedupe by email+webhook combo
    for s in d["subscribers"]:
        if s.get("email") == em and s.get("webhook_url") == wu and s.get("category") == cat:
            return {"ok": True, "already_subscribed": True, "subscriber_id": s.get("id")}

    sub_id = "subs_" + uuid.uuid4().hex[:10]
    d["subscribers"].append({
        "id": sub_id,
        "email": em,
        "webhook_url": wu,
        "category": cat,
        "subscribed_at": int(time.time()),
    })
    _subs_save(d)
    return {"ok": True, "subscriber_id": sub_id, "subscriber_count": len(d["subscribers"])}


def unsubscribe(subscriber_id: str) -> dict:
    d = _subs_load()
    before = len(d["subscribers"])
    d["subscribers"] = [s for s in d["subscribers"] if s.get("id") != subscriber_id]
    after = len(d["subscribers"])
    _subs_save(d)
    return {"ok": True, "removed": before - after}


def _notify_subscribers_on_create(m: dict):
    """Fire webhooks/emails to subscribers when a new mission is created.
    Best-effort, non-blocking."""
    d = _subs_load()
    cat = m.get("category", "other")
    mid = m.get("id")
    title = m.get("title", "")
    rew = m.get("reward", {}) or {}
    rew_disp = f"{rew.get('amount', m.get('reward_aigen', 0))} {rew.get('currency', 'AIGEN')}"

    payload = {
        "event": "mission.created",
        "mission_id": mid,
        "mission_title": title,
        "category": cat,
        "reward": rew_disp,
        "verification_type": m.get("verification_type"),
        "deadline": m.get("deadline"),
        "view_url": f"https://cryptogenesis.duckdns.org/m/{mid}",
    }

    for sub in d.get("subscribers", []):
        if sub.get("category") != "all" and sub.get("category") != cat:
            continue
        if sub.get("webhook_url"):
            _fire_webhook(sub["webhook_url"], payload)
        if sub.get("email"):
            _send_email(sub["email"],
                f"[AIGEN] New {cat} mission: {title[:50]}",
                f"""A new AIGEN mission was just posted that matches your subscription:

  {title}
  Category: {cat}
  Reward:   {rew_disp}
  Verification: {m.get('verification_type')}

View on AIGEN:
https://cryptogenesis.duckdns.org/m/{mid}

To unsubscribe: visit https://cryptogenesis.duckdns.org/subscribe
or POST /subscribe/unsubscribe with subscriber_id={sub.get('id')}

— AIGEN Protocol
""")


def create_mission(creator_agent_id: str, title: str, description: str,
                   reward_amount: int, verification_type: str,
                   verification_params: dict = None,
                   reward_currency: str = "AIGEN",
                   reward_chain: str = "base",
                   deadline_hours: int = DEFAULT_DEADLINE_HOURS,
                   min_submitter_elo: int = 0,
                   reward_aigen: int = None,
                   webhook_url: str = "",
                   notify_email: str = "",
                   category: str = "",
                   mission_type: str = "freeform",
                   type_params: dict = None) -> dict:
    """Open a new mission.

    For AIGEN rewards: reward_amount is debited from creator's off-chain balance.
    For USDC/ETH rewards: mission starts as 'awaiting_funding'. Creator must
    transfer reward_amount to TREASURY on reward_chain, then call
    /missions/{id}/confirm-funding with the tx_hash. Once confirmed, status → 'open'.

    Spam fee:
      - AIGEN rewards: 5 AIGEN burn (matters because AIGEN is cheap to spam)
      - USDC/ETH rewards: ZERO (the on-chain escrow is the anti-spam — you're
        locking real money, no one spams real money for free)
    """
    # Backward compat: accept reward_aigen as alias
    if reward_aigen is not None and not reward_amount:
        reward_amount = reward_aigen

    if not creator_agent_id or len(creator_agent_id.strip()) < 2:
        return {"error": "creator_agent_id must be >= 2 chars"}
    if not title or len(title) > MAX_TITLE_LEN:
        return {"error": f"title required, max {MAX_TITLE_LEN} chars"}
    if not description or len(description) > MAX_DESC_LEN:
        return {"error": f"description required, max {MAX_DESC_LEN} chars"}
    if verification_type not in VERIFICATION_TYPES:
        return {"error": f"verification_type must be one of {sorted(VERIFICATION_TYPES)}"}
    if deadline_hours < 1 or deadline_hours > MAX_DEADLINE_HOURS:
        return {"error": f"deadline_hours must be in [1, {MAX_DEADLINE_HOURS}]"}

    reward_currency = (reward_currency or "AIGEN").upper()
    if reward_currency not in REWARD_CURRENCIES:
        return {"error": f"reward_currency must be one of {sorted(REWARD_CURRENCIES)}"}
    # USDC/ETH support both EVM chains AND Solana (USDC on Solana is SPL)
    if reward_currency == "ETH":
        if reward_chain not in TOKEN_ADDRS["ETH"]:
            return {"error": f"unsupported chain '{reward_chain}' for ETH"}
    elif reward_currency in ("USDC",) and reward_chain in TOKEN_ADDRS["USDC"]:
        pass  # EVM USDC, normal flow
    elif reward_currency == "USDC" and reward_chain == "solana":
        pass  # SPL USDC on Solana
    elif reward_currency in SPL_TOKEN_MINTS:
        # SPL tokens (BONK, JUP, etc.) are only on Solana
        reward_chain = "solana"
    elif reward_currency == "SOL":
        # Force chain to solana for SOL
        reward_chain = "solana"
    elif reward_currency != "AIGEN":
        return {"error": f"unsupported chain '{reward_chain}' for {reward_currency}"}

    # Currency-specific minimum reward — keep simple defaults; SPL tokens use 1 unit min
    if reward_currency in ("AIGEN",):
        min_reward = MIN_REWARD_AIGEN
        unit = "AIGEN"
    elif reward_currency == "USDC" and reward_chain in TOKEN_ADDRS.get("USDC", {}):
        min_reward = MIN_REWARD_USDC_MICROS
        unit = "USDC micros (1e6=1USDC)"
    elif reward_currency == "USDC" and reward_chain == "solana":
        min_reward = MIN_REWARD_USDC_MICROS
        unit = "USDC micros (1e6=1USDC SPL)"
    elif reward_currency == "ETH":
        min_reward = MIN_REWARD_ETH_WEI
        unit = "wei"
    elif reward_currency == "SOL":
        min_reward = MIN_REWARD_SOL_LAMPORTS
        unit = "lamports (1e9=1SOL)"
    elif reward_currency in SPL_TOKEN_MINTS:
        # 1 base unit minimum (e.g., 1 BONK base = 0.00001 BONK)
        min_reward = 1
        unit = f"base units (10^{SPL_DECIMALS.get(reward_currency, 6)}=1{reward_currency})"
    else:
        min_reward = 1
        unit = "base units"

    if reward_amount < min_reward:
        return {"error": f"reward_amount must be >= {min_reward} {unit}"}

    vparams = verification_params or {}
    if verification_type == "first_valid_match":
        rx = vparams.get("regex", "")
        if not rx:
            return {"error": "first_valid_match requires verification_params.regex"}
        try:
            re.compile(rx)
        except re.error as e:
            return {"error": f"invalid regex: {e}"}
        if len(rx) > 500:
            return {"error": "regex too long (max 500 chars)"}

    now = int(time.time())
    mid = "mis_" + uuid.uuid4().hex[:12]

    # AIGEN: debit upfront, mission immediately 'open'
    # USDC/ETH: mission starts 'awaiting_funding', creator confirms separately
    if reward_currency == "AIGEN":
        total_cost = reward_amount + SPAM_FEE_BURN_AIGEN
        if _balance(creator_agent_id) < total_cost:
            return {"error": f"insufficient AIGEN: need {total_cost} (reward {reward_amount} + spam_fee {SPAM_FEE_BURN_AIGEN}), have {_balance(creator_agent_id)}"}
        if not _debit(creator_agent_id, reward_amount, "mission-escrow"):
            return {"error": "escrow debit failed"}
        if not _debit(creator_agent_id, SPAM_FEE_BURN_AIGEN, "mission-spam-fee"):
            _credit(creator_agent_id, reward_amount, "mission-escrow-rollback")
            return {"error": "spam-fee debit failed"}
        _credit("treasury", SPAM_FEE_BURN_AIGEN, "spam-fee-burn-mission")
        initial_status = "open"
        spam_fee = SPAM_FEE_BURN_AIGEN
    else:
        initial_status = "awaiting_funding"
        spam_fee = 0

    # Validate webhook URL (optional)
    webhook_clean = ""
    if webhook_url:
        wu = webhook_url.strip()
        if not (wu.startswith("https://") or wu.startswith("http://")):
            return {"error": "webhook_url must start with http:// or https://"}
        if len(wu) > 500:
            return {"error": "webhook_url too long (max 500)"}
        webhook_clean = wu

    # Validate email (optional)
    email_clean = ""
    if notify_email:
        em = notify_email.strip().lower()
        if not re.match(r"^[^@\s]+@[^@\s]+\.[^@\s]+$", em):
            return {"error": "notify_email is not a valid email"}
        if len(em) > 200:
            return {"error": "notify_email too long"}
        email_clean = em

    # Validate category (optional, defaults to 'other')
    cat_clean = (category or "other").strip().lower()
    if cat_clean not in VALID_CATEGORIES:
        return {"error": f"category must be one of {sorted(VALID_CATEGORIES)}"}

    # AIP-2 work-unit typing. Keep legacy category for existing filters/webhooks.
    mt_clean = (mission_type or "freeform").strip().lower()
    if mt_clean not in AIP2_MISSION_TYPES:
        return {"error": f"mission_type must be one of {sorted(AIP2_MISSION_TYPES)}"}
    tp_clean = type_params or {}
    if not isinstance(tp_clean, dict):
        return {"error": "type_params must be an object"}

    m = {
        "id": mid,
        "creator": creator_agent_id,
        "title": title.strip(),
        "description": description.strip(),
        "category": cat_clean,
        "mission_type": mt_clean,
        "type_params": tp_clean,
        "webhook_url": webhook_clean,
        "notify_email": email_clean,
        # Reward block — multi-currency
        "reward": {
            "currency": reward_currency,
            "amount": int(reward_amount),
            "chain": reward_chain if reward_currency != "AIGEN" else None,
            "deposit_address": (
                TREASURY_SOL if reward_chain == "solana"
                else (TREASURY if reward_currency != "AIGEN" else None)
            ),
            "deposit_tx": None,
            "deposit_confirmed_at": None,
            "payout_tx": None,
            "payout_at": None,
        },
        # Backward-compat alias for AIGEN missions
        "reward_aigen": int(reward_amount) if reward_currency == "AIGEN" else 0,
        "spam_fee_burned": spam_fee,
        "verification_type": verification_type,
        "verification_params": vparams,
        "min_submitter_elo": int(min_submitter_elo),
        "created_at": now,
        "deadline": now + deadline_hours * 3600,
        "status": initial_status,
        "submissions": [],
        "resolution": None,
    }
    if verification_type == "creator_judges":
        m["judge_deadline"] = m["deadline"] + CREATOR_JUDGE_GRACE_DAYS * 86400

    d = load()
    d["missions"].append(m)
    d["total"] += 1
    if reward_currency == "AIGEN":
        d["lifetime_reward_aigen_escrowed"] = d.get("lifetime_reward_aigen_escrowed", 0) + reward_amount
        d["lifetime_spam_fees_burned"] = d.get("lifetime_spam_fees_burned", 0) + SPAM_FEE_BURN_AIGEN
    save(d)

    # Notify subscribers (only if mission is open, not awaiting_funding)
    if initial_status == "open":
        _notify_subscribers_on_create(m)

    # Compute and expose protocol fee split — transparent to creator/winner at creation time
    net_to_winner, fee = _split_with_fee(reward_amount)
    m["fee_quote"] = {
        "gross_amount": int(reward_amount),
        "net_to_winner": net_to_winner,
        "protocol_fee": fee,
        "fee_bps": PROTOCOL_FEE_BPS,
        "fee_pct": f"{PROTOCOL_FEE_BPS/100:.2f}%",
    }

    # For USDC/ETH/SOL/SPL: include funding instructions
    if reward_currency != "AIGEN":
        # Pick the right token mint/contract for the chain
        if reward_chain == "solana":
            send_to = TREASURY_SOL
            token_contract = SPL_TOKEN_MINTS.get(reward_currency)  # None for native SOL
        else:
            send_to = TREASURY
            token_contract = (TOKEN_ADDRS[reward_currency][reward_chain]
                              if reward_currency in TOKEN_ADDRS and reward_currency != "ETH"
                              else None)
        m["funding_instructions"] = {
            "send_to": send_to,
            "currency": reward_currency,
            "chain": reward_chain,
            "amount_wei": int(reward_amount),
            "token_contract": token_contract,
            "next_step": f"After sending, POST /missions/{mid}/confirm-funding with the tx_hash",
            "fee_note": f"Winner receives net {net_to_winner} ({reward_currency}). Protocol keeps {fee} ({PROTOCOL_FEE_BPS/100:.2f}% fee) from your deposit.",
        }
    return m


# ---------- confirm funding (USDC/ETH missions) ----------

def confirm_funding(mission_id: str, tx_hash: str) -> dict:
    """Verify on-chain that the creator's deposit landed at TREASURY for the
    expected amount + currency + chain. Activates the mission on success."""
    # Solana txs are base58 64-88 chars; EVM is 0x-prefixed 64 hex
    is_evm_tx = bool(re.match(r"^0x[0-9a-fA-F]{64}$", tx_hash or ""))
    is_sol_tx = bool(re.match(r"^[1-9A-HJ-NP-Za-km-z]{64,88}$", tx_hash or ""))
    if not is_evm_tx and not is_sol_tx:
        return {"error": "tx_hash must be EVM 0x-hex (64 chars) or Solana base58 signature"}

    d = load()
    # anti-replay: a deposit tx can fund at most one mission
    for _mm in d["missions"]:
        if (_mm.get("reward") or {}).get("deposit_tx") == tx_hash:
            return {"error": f"deposit tx already used to fund mission {_mm['id']}"}
    for m in d["missions"]:
        if m["id"] != mission_id:
            continue
        if m["status"] != "awaiting_funding":
            return {"error": f"mission status is {m['status']}, not awaiting_funding"}
        r = m["reward"]

        # SOL on Solana — verify via Solana RPC
        if r["currency"] == "SOL":
            if not is_sol_tx:
                return {"error": "tx_hash must be Solana base58 signature for SOL mission"}
            try:
                import urllib.request as _ur
                rpc_body = json.dumps({
                    "jsonrpc": "2.0", "id": 1, "method": "getTransaction",
                    "params": [tx_hash, {"encoding": "json", "maxSupportedTransactionVersion": 0}],
                }).encode()
                req = _ur.Request(SOLANA_RPC, method="POST", data=rpc_body,
                                  headers={"Content-Type": "application/json"})
                with _ur.urlopen(req, timeout=15) as resp:
                    j = json.loads(resp.read())
                tx = (j.get("result") or {})
                if not tx:
                    return {"error": "Solana tx not found yet (try again in a few seconds)"}
                meta = tx.get("meta") or {}
                if meta.get("err") is not None:
                    return {"error": f"Solana tx reverted: {meta['err']}"}
                # Verify treasury received >= amount lamports
                msg = tx.get("transaction", {}).get("message", {})
                accounts = msg.get("accountKeys", [])
                pre_balances = meta.get("preBalances", [])
                post_balances = meta.get("postBalances", [])
                treasury_idx = None
                for i, acc in enumerate(accounts):
                    if acc == TREASURY_SOL:
                        treasury_idx = i
                        break
                if treasury_idx is None:
                    return {"error": f"tx does not transfer to treasury {TREASURY_SOL}"}
                delta = post_balances[treasury_idx] - pre_balances[treasury_idx]
                if delta < int(r["amount"]):
                    return {"error": f"SOL received {delta} < required {r['amount']} lamports"}
            except Exception as e:
                return {"error": f"Solana lookup failed: {e}"}

            r["deposit_tx"] = tx_hash
            r["deposit_confirmed_at"] = int(time.time())
            m["status"] = "open"
            save(d)
            _notify_subscribers_on_create(m)
            return {"ok": True, "mission_id": mission_id, "status": "open",
                    "deposit_tx": tx_hash, "amount_funded": r["amount"], "currency": "SOL"}

        # Verify on-chain
        try:
            from web3 import Web3
            rpc = {"base": "https://mainnet.base.org",
                   "optimism": "https://mainnet.optimism.io"}[r["chain"]]
            w3 = Web3(Web3.HTTPProvider(rpc))
            receipt = w3.eth.get_transaction_receipt(tx_hash)
            if receipt is None or receipt.status != 1:
                return {"error": "tx not mined or reverted"}
            tx = w3.eth.get_transaction(tx_hash)
        except Exception as e:
            return {"error": f"on-chain lookup failed: {e}"}

        treasury_lc = TREASURY.lower()
        if r["currency"] == "ETH":
            # Native ETH transfer to treasury
            if (tx["to"] or "").lower() != treasury_lc:
                return {"error": f"tx 'to' is {tx['to']}, expected {TREASURY}"}
            if int(tx["value"]) < int(r["amount"]):
                return {"error": f"tx value {tx['value']} < required {r['amount']}"}
        elif r["currency"] == "USDC":
            # ERC20 Transfer event from logs
            token = TOKEN_ADDRS["USDC"][r["chain"]].lower()
            transfer_topic = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
            found = False
            for log in receipt.logs:
                if log.address.lower() != token:
                    continue
                if log.topics[0].hex().lower().lstrip("0x") != transfer_topic.lstrip("0x"):
                    continue
                # topics[2] = to address (last 32 bytes), data = amount
                to_addr = "0x" + log.topics[2].hex()[-40:]
                if to_addr.lower() != treasury_lc:
                    continue
                amount = int(log.data.hex() if hasattr(log.data, 'hex') else log.data, 16)
                if amount < int(r["amount"]):
                    return {"error": f"USDC amount in tx {amount} < required {r['amount']}"}
                found = True
                break
            if not found:
                return {"error": "no USDC Transfer event to treasury found in tx"}

        r["deposit_tx"] = tx_hash
        r["deposit_confirmed_at"] = int(time.time())
        m["status"] = "open"
        save(d)
        _notify_subscribers_on_create(m)
        return {"ok": True, "mission_id": mission_id, "status": "open",
                "deposit_tx": tx_hash, "amount_funded": r["amount"], "currency": r["currency"]}
    return {"error": "mission not found"}


# ---------- submit ----------

def submit(submitter_agent_id: str, mission_id: str, proof: str,
           submitter_wallet: str = "", metadata: dict = None) -> dict:
    """Submit work to a mission.

    For AIGEN-rewarded missions: submitter_wallet is optional (payout goes to
    off-chain ledger).
    For USDC/ETH missions: submitter_wallet REQUIRED — that's where on-chain
    payout will be sent if you win.
    """
    if not submitter_agent_id or len(submitter_agent_id.strip()) < 2:
        return {"error": "submitter_agent_id must be >= 2 chars"}
    if not proof or len(proof) > MAX_PROOF_LEN:
        return {"error": f"proof required, max {MAX_PROOF_LEN} chars"}

    d = load()
    for m in d["missions"]:
        if m["id"] != mission_id:
            continue
        if m["status"] != "open":
            return {"error": f"mission is {m['status']}"}
        if int(time.time()) >= m["deadline"]:
            return {"error": "submission window closed"}
        if submitter_agent_id == m["creator"]:
            return {"error": "creator cannot submit to their own mission"}
        if m["min_submitter_elo"] > 0 and _elo(submitter_agent_id) < m["min_submitter_elo"]:
            return {"error": f"reputation ELO {_elo(submitter_agent_id)} below required {m['min_submitter_elo']}"}
        _gate = _required_tier_for_mission(m)
        if _gate > 0 and _tier(submitter_agent_id)[0] < _gate:
            return {"error": f"mission requires reputation tier '{_TIER_NAMES[_gate]}' (yours: '{_tier(submitter_agent_id)[1]}') — earn AIGEN on smaller missions first"}
        if any(s["submitter"] == submitter_agent_id for s in m["submissions"]):
            return {"error": "you already submitted to this mission"}

        # USDC/ETH/SOL/SPL missions require submitter_wallet for on-chain payout
        currency = m.get("reward", {}).get("currency", "AIGEN")
        chain = m.get("reward", {}).get("chain", "")
        wallet_clean = (submitter_wallet or "").strip()
        # Solana chain: any currency on solana needs base58 wallet
        if chain == "solana":
            if not wallet_clean or not re.match(r"^[1-9A-HJ-NP-Za-km-z]{32,44}$", wallet_clean):
                return {"error": f"submitter_wallet (Solana base58 address, 32-44 chars) required for {currency}-on-Solana missions"}
        elif currency in ("USDC", "ETH"):
            wallet_clean = wallet_clean.lower()
            if not wallet_clean or not re.match(r"^0x[0-9a-f]{40}$", wallet_clean):
                return {"error": f"submitter_wallet (0x-prefixed 40-char hex) required for {currency}-rewarded missions"}

        sid = "sub_" + uuid.uuid4().hex[:10]
        sub = {
            "id": sid,
            "submitter": submitter_agent_id,
            "submitter_wallet": wallet_clean if wallet_clean else None,
            "proof": proof,
            "metadata": metadata or {},
            "submitted_at": int(time.time()),
            "yes_votes": {},
            "no_votes": {},
            "yes_total": 0,
            "no_total": 0,
            "status": "pending",
        }
        m["submissions"].append(sub)
        save(d)

        # INSTANT RESOLUTION for first_valid_match — if this submission matches
        # the accept regex, resolve immediately so winner gets paid in the same request.
        instant_result = None
        if m["verification_type"] == "first_valid_match":
            rx = m["verification_params"].get("regex", "")
            if rx:
                try:
                    if re.compile(rx).search(proof):
                        # Trigger resolve in-process
                        instant_result = resolve(mission_id)
                except Exception:
                    pass

        # Fire creator webhook (best-effort, non-blocking)
        wu = m.get("webhook_url", "")
        if wu:
            _fire_webhook(wu, {
                "event": "submission.created",
                "mission_id": mission_id,
                "mission_title": m.get("title"),
                "submission_id": sid,
                "submitter_agent_id": submitter_agent_id,
                "proof": proof[:500],
                "submitted_at": sub["submitted_at"],
                "submission_count": len(m["submissions"]),
                "view_url": f"https://cryptogenesis.duckdns.org/m/{mission_id}",
            })

        # Fire creator email
        em = m.get("notify_email", "")
        if em:
            _send_email(em,
                f"[AIGEN] New submission to your mission: {m.get('title','?')[:50]}",
                f"""Hi,

A new submission landed on your AIGEN mission "{m.get('title')}":

  Mission:     {mission_id}
  Submitter:   {submitter_agent_id}
  Submitted:   {time.strftime('%Y-%m-%d %H:%M:%S UTC', time.gmtime(sub['submitted_at']))}
  Submission:  {sid}
  Proof:       {proof[:400]}

Total submissions on this mission: {len(m["submissions"])}

View on AIGEN:
https://cryptogenesis.duckdns.org/m/{mission_id}

Submitter profile:
https://cryptogenesis.duckdns.org/agent/{submitter_agent_id}

— AIGEN Protocol
You receive this because you set notify_email when creating this mission.
Set notify_email="" on a future mission to opt out per-mission.
""")

        result = {"ok": True, "mission_id": mission_id, "submission_id": sid,
                  "submission_count": len(m["submissions"])}
        if instant_result and instant_result.get("ok"):
            result["instant_resolved"] = True
            result["winner"] = instant_result.get("winner")
            result["payout"] = instant_result.get("payout")
        return result
    return {"error": "mission not found"}


def _fire_webhook(url: str, payload: dict):
    """Fire HTTP POST webhook with mission event. Non-blocking, swallows errors."""
    import threading
    import urllib.request
    def _do():
        try:
            data = json.dumps(payload).encode()
            req = urllib.request.Request(url, method="POST", data=data,
                                         headers={"Content-Type": "application/json",
                                                  "User-Agent": "aigen-webhook/1.0",
                                                  "X-AIGEN-Event": payload.get("event", "")})
            urllib.request.urlopen(req, timeout=5)
        except Exception:
            pass
    threading.Thread(target=_do, daemon=True).start()


_ZOHO_USER = "Cryptogen@zohomail.eu"
_ZOHO_PASS_FILE = "/home/luna/crypto-genesis/credentials/zoho_mail.txt"


def _send_email(to_addr: str, subject: str, body: str):
    """Send notification email via Zoho SMTP. Non-blocking, swallows errors."""
    import threading
    def _do():
        try:
            import smtplib
            from email.mime.text import MIMEText
            # Read password
            try:
                content = open(_ZOHO_PASS_FILE).read()
                pw = ""
                for line in content.splitlines():
                    if "Password:" in line:
                        pw = line.split("Password:", 1)[1].strip()
                        break
                if not pw:
                    return
            except Exception:
                return
            msg = MIMEText(body, "plain", "utf-8")
            msg["Subject"] = subject
            msg["From"] = f"AIGEN Protocol <{_ZOHO_USER}>"
            msg["To"] = to_addr
            with smtplib.SMTP("smtp.zoho.eu", 587, timeout=15) as smtp:
                smtp.starttls()
                smtp.login(_ZOHO_USER, pw)
                smtp.sendmail(_ZOHO_USER, [to_addr], msg.as_string())
        except Exception:
            pass
    threading.Thread(target=_do, daemon=True).start()


# ---------- vote (peer_vote only) ----------

def vote(voter_agent_id: str, mission_id: str, submission_id: str, side: str, amount: int) -> dict:
    if side not in ("yes", "no"):
        return {"error": "side must be 'yes' or 'no'"}
    if amount < MIN_VOTE_AIGEN:
        return {"error": f"min vote: {MIN_VOTE_AIGEN} AIGEN"}

    d = load()
    for m in d["missions"]:
        if m["id"] != mission_id:
            continue
        if m["verification_type"] != "peer_vote":
            return {"error": f"mission verification is {m['verification_type']}, not peer_vote"}
        if m["status"] != "open":
            return {"error": f"mission is {m['status']}"}
        if int(time.time()) >= m["deadline"]:
            return {"error": "voting closed; call resolve"}
        for s in m["submissions"]:
            if s["id"] != submission_id:
                continue
            if voter_agent_id == s["submitter"]:
                return {"error": "submitter cannot vote on their own submission"}
            if not _debit(voter_agent_id, amount, f"vote-{side}-{mission_id}"):
                return {"error": "insufficient AIGEN balance"}
            bucket = s[f"{side}_votes"]
            bucket[voter_agent_id] = bucket.get(voter_agent_id, 0) + amount
            s[f"{side}_total"] += amount
            save(d)
            return {"ok": True, "submission_id": submission_id,
                    "your_total_on_this": bucket[voter_agent_id],
                    "submission_yes": s["yes_total"], "submission_no": s["no_total"]}
        return {"error": "submission not found"}
    return {"error": "mission not found"}


# ---------- on-chain payout (USDC/ETH winners) ----------

def _onchain_payout(currency: str, chain: str, to_wallet: str, amount: int) -> dict:
    """Send currency from treasury wallet to to_wallet. Returns {tx_hash, ...} or {error}."""
    # Solana payouts (SOL native or SPL tokens)
    if chain == "solana":
        if currency == "SOL":
            return _onchain_payout_solana(to_wallet, amount)
        elif currency in SPL_TOKEN_MINTS:
            return _onchain_payout_spl(currency, to_wallet, amount)
        return {"error": f"unsupported Solana currency {currency}"}

    try:
        from web3 import Web3
        from eth_account import Account
        rpcs = {"base": "https://mainnet.base.org", "optimism": "https://mainnet.optimism.io"}
        if chain not in rpcs:
            return {"error": f"unsupported chain {chain}"}
        w3 = Web3(Web3.HTTPProvider(rpcs[chain]))
        acct = Account.from_key(json.loads(open("/home/luna/crypto-genesis/.wallet.json").read())["private_key"])
        me = acct.address
        to_cs = Web3.to_checksum_address(to_wallet)
        nonce = w3.eth.get_transaction_count(me, "pending")

        # --- payout safety guards (defense-in-depth before real-money send) ---
        if currency == "USDC" and int(amount) > 1_000_000_000:
            return {"error": "payout exceeds USDC hard cap (1000 USDC)"}
        if currency == "ETH" and int(amount) > 5 * 10**17:
            return {"error": "payout exceeds ETH hard cap (0.5 ETH)"}
        if currency == "ETH" and w3.eth.get_balance(me) < int(amount):
            return {"error": "treasury ETH balance below payout amount"}

        if currency == "ETH":
            tx = {"from": me, "to": to_cs, "value": int(amount), "nonce": nonce,
                  "gas": 21000,
                  "maxFeePerGas": w3.eth.gas_price * 2,
                  "maxPriorityFeePerGas": w3.to_wei(0.001, "gwei"),
                  "chainId": w3.eth.chain_id}
            signed = acct.sign_transaction(tx)
            h = w3.eth.send_raw_transaction(signed.raw_transaction)
            r = w3.eth.wait_for_transaction_receipt(h, timeout=120)
            if r.status != 1:
                return {"error": "ETH transfer reverted", "tx_hash": "0x" + h.hex()}
            return {"tx_hash": "0x" + h.hex(), "block": r.blockNumber, "gas_used": r.gasUsed}
        elif currency == "USDC":
            token = Web3.to_checksum_address(TOKEN_ADDRS["USDC"][chain])
            erc20 = w3.eth.contract(address=token, abi=[
                {"name":"transfer","type":"function","stateMutability":"nonpayable",
                 "inputs":[{"name":"to","type":"address"},{"name":"amt","type":"uint256"}],
                 "outputs":[{"name":"","type":"bool"}]},
                {"name":"balanceOf","type":"function","stateMutability":"view",
                 "inputs":[{"name":"a","type":"address"}],"outputs":[{"name":"","type":"uint256"}]},
            ])
            if erc20.functions.balanceOf(me).call() < int(amount):
                return {"error": "treasury USDC balance below payout amount"}
            fn = erc20.functions.transfer(to_cs, int(amount))
            try:
                gas = fn.estimate_gas({"from": me})
            except Exception as e:
                return {"error": f"USDC transfer estimate_gas failed: {e}"}
            tx = fn.build_transaction({"from": me, "nonce": nonce, "gas": int(gas * 1.3),
                "maxFeePerGas": w3.eth.gas_price * 2,
                "maxPriorityFeePerGas": w3.to_wei(0.001, "gwei"),
                "chainId": w3.eth.chain_id})
            signed = acct.sign_transaction(tx)
            h = w3.eth.send_raw_transaction(signed.raw_transaction)
            r = w3.eth.wait_for_transaction_receipt(h, timeout=120)
            if r.status != 1:
                return {"error": "USDC transfer reverted", "tx_hash": "0x" + h.hex()}
            return {"tx_hash": "0x" + h.hex(), "block": r.blockNumber, "gas_used": r.gasUsed}
        else:
            return {"error": f"unsupported currency {currency}"}
    except Exception as e:
        return {"error": f"onchain payout error: {e}"}


def _onchain_payout_spl(currency: str, to_wallet: str, amount: int) -> dict:
    """Send SPL token from treasury Solana wallet to to_wallet.
    Auto-creates the recipient's Associated Token Account if needed.
    """
    if currency not in SPL_TOKEN_MINTS:
        return {"error": f"unsupported SPL token {currency}"}
    if not re.match(r"^[1-9A-HJ-NP-Za-km-z]{32,44}$", to_wallet or ""):
        return {"error": "invalid Solana address"}
    if not SOLANA_KEY_FILE.exists():
        return {"error": f"Solana treasury key not found at {SOLANA_KEY_FILE}"}

    try:
        from solders.keypair import Keypair
        from solders.pubkey import Pubkey
        from solders.transaction import VersionedTransaction
        from solders.message import MessageV0
        from solders.instruction import Instruction, AccountMeta
        from solders.system_program import ID as SYSTEM_PROGRAM_ID
        from solana.rpc.api import Client

        # Constants
        TOKEN_PROGRAM_ID = Pubkey.from_string("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")
        ASSOCIATED_TOKEN_PROGRAM_ID = Pubkey.from_string("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL")
        SYSVAR_RENT_PUBKEY = Pubkey.from_string("SysvarRent111111111111111111111111111111111")

        # Load keypair
        kdata = json.loads(SOLANA_KEY_FILE.read_text())
        kp = Keypair.from_bytes(bytes(kdata["secret_key"]))
        treasury_pk = kp.pubkey()
        mint_pk = Pubkey.from_string(SPL_TOKEN_MINTS[currency])
        recipient_pk = Pubkey.from_string(to_wallet)

        # Derive ATAs (PDA: ATA program ID + [owner, token program, mint])
        def find_ata(owner: Pubkey, mint: Pubkey) -> Pubkey:
            seeds = [bytes(owner), bytes(TOKEN_PROGRAM_ID), bytes(mint)]
            ata, _ = Pubkey.find_program_address(seeds, ASSOCIATED_TOKEN_PROGRAM_ID)
            return ata

        sender_ata = find_ata(treasury_pk, mint_pk)
        recipient_ata = find_ata(recipient_pk, mint_pk)

        client = Client(SOLANA_RPC, timeout=20)

        # Check if recipient ATA exists
        recipient_ata_info = client.get_account_info(recipient_ata)
        ata_exists = recipient_ata_info.value is not None

        instructions = []

        # Create ATA for recipient if needed
        if not ata_exists:
            create_ata_ix = Instruction(
                program_id=ASSOCIATED_TOKEN_PROGRAM_ID,
                accounts=[
                    AccountMeta(pubkey=treasury_pk, is_signer=True, is_writable=True),     # payer
                    AccountMeta(pubkey=recipient_ata, is_signer=False, is_writable=True),  # ATA to create
                    AccountMeta(pubkey=recipient_pk, is_signer=False, is_writable=False),  # owner
                    AccountMeta(pubkey=mint_pk, is_signer=False, is_writable=False),       # mint
                    AccountMeta(pubkey=SYSTEM_PROGRAM_ID, is_signer=False, is_writable=False),
                    AccountMeta(pubkey=TOKEN_PROGRAM_ID, is_signer=False, is_writable=False),
                ],
                data=bytes([0]),  # CreateIdempotent variant — instruction 0
            )
            instructions.append(create_ata_ix)

        # SPL Token transfer instruction (TokenProgram instruction #3 = Transfer)
        # Layout: [3, amount(u64 little-endian)]
        transfer_data = bytes([3]) + int(amount).to_bytes(8, "little")
        transfer_ix = Instruction(
            program_id=TOKEN_PROGRAM_ID,
            accounts=[
                AccountMeta(pubkey=sender_ata, is_signer=False, is_writable=True),
                AccountMeta(pubkey=recipient_ata, is_signer=False, is_writable=True),
                AccountMeta(pubkey=treasury_pk, is_signer=True, is_writable=False),
            ],
            data=transfer_data,
        )
        instructions.append(transfer_ix)

        recent_bh = client.get_latest_blockhash().value.blockhash
        msg = MessageV0.try_compile(
            payer=treasury_pk,
            instructions=instructions,
            address_lookup_table_accounts=[],
            recent_blockhash=recent_bh,
        )
        tx = VersionedTransaction(msg, [kp])
        send_resp = client.send_transaction(tx)
        sig = str(send_resp.value)
        client.confirm_transaction(send_resp.value, commitment="confirmed", sleep_seconds=1)
        return {
            "tx_hash": sig,
            "explorer": f"https://solscan.io/tx/{sig}",
            "ata_created": not ata_exists,
        }
    except Exception as e:
        return {"error": f"SPL payout error ({currency}): {e}"}


def _onchain_payout_solana(to_wallet: str, amount_lamports: int) -> dict:
    """Send SOL from treasury Solana wallet to to_wallet (base58 address).
    Returns {tx_hash, ...} or {error}."""
    if not re.match(r"^[1-9A-HJ-NP-Za-km-z]{32,44}$", to_wallet or ""):
        return {"error": "invalid Solana address"}
    try:
        from solders.keypair import Keypair
        from solders.pubkey import Pubkey
        from solders.system_program import transfer, TransferParams
        from solders.transaction import VersionedTransaction
        from solders.message import MessageV0
        from solana.rpc.api import Client

        if not SOLANA_KEY_FILE.exists():
            return {"error": f"Solana treasury key not found at {SOLANA_KEY_FILE}"}

        kdata = json.loads(SOLANA_KEY_FILE.read_text())
        secret = bytes(kdata["secret_key"])
        kp = Keypair.from_bytes(secret)

        client = Client(SOLANA_RPC, timeout=20)
        # Check balance first
        balance_resp = client.get_balance(kp.pubkey())
        balance = balance_resp.value if hasattr(balance_resp, "value") else 0
        if balance < amount_lamports + 5000:  # leave room for fee (5000 lamports typical)
            return {"error": f"treasury SOL balance {balance} lamports < {amount_lamports + 5000} required (amount + fee)"}

        ix = transfer(TransferParams(
            from_pubkey=kp.pubkey(),
            to_pubkey=Pubkey.from_string(to_wallet),
            lamports=int(amount_lamports),
        ))
        recent_bh = client.get_latest_blockhash().value.blockhash
        msg = MessageV0.try_compile(
            payer=kp.pubkey(),
            instructions=[ix],
            address_lookup_table_accounts=[],
            recent_blockhash=recent_bh,
        )
        tx = VersionedTransaction(msg, [kp])
        send_resp = client.send_transaction(tx)
        sig = str(send_resp.value)
        client.confirm_transaction(send_resp.value, commitment="confirmed", sleep_seconds=1)
        return {"tx_hash": sig, "explorer": f"https://solscan.io/tx/{sig}"}
    except Exception as e:
        return {"error": f"Solana payout error: {e}"}


def _split_with_fee(gross_amount: int) -> tuple[int, int]:
    """Compute (net_to_winner, protocol_fee) from a gross reward.
    Fee is rounded down so winner never gets less than the gross-fee_max.
    Returns (net, fee) such that net + fee == gross."""
    fee = (gross_amount * PROTOCOL_FEE_BPS) // PROTOCOL_FEE_BPS_DENOM
    net = gross_amount - fee
    return net, fee


def _record_fee_collected(d: dict, currency: str, fee_amount: int):
    """Track protocol-level fee accumulation per currency."""
    fees = d.setdefault("lifetime_fees_collected", {"AIGEN": 0, "USDC": 0, "ETH": 0})
    fees[currency] = fees.get(currency, 0) + fee_amount


def _pay_winner(m: dict, winner_sub: dict) -> dict:
    """Pay the winning submitter in the mission's reward currency, MINUS the
    0.5% protocol fee.

    For AIGEN: credit off-chain ledger (winner gets net, treasury gets fee).
    For USDC/ETH: on-chain transfer to submitter_wallet (treasury implicitly
    keeps the fee since it's already there from the deposit).

    Returns {ok, payout_tx?, gross, net, fee, error?}."""
    r = m["reward"]
    currency = r["currency"]
    gross = r["amount"]
    # --- anti-farm guards (added 2026-05-29) ---
    # A: protocol-internal agents never receive AIGEN rewards (kills self-dealing).
    # B: first_valid_match is a spam-prone race -> zero net AIGEN payout (kills farm EV).
    if currency == "AIGEN":
        _wid = (winner_sub.get("submitter") or "").lower()
        _internal = _wid.startswith(("aigen", "treasury", "autopilot")) or _wid.endswith("-probe")
        _verified = (winner_sub.get("oracle_check") or {}).get("passed") is True
        if _internal or (m.get("verification_type") == "first_valid_match" and not _verified):
            return {"ok": True, "currency": "AIGEN", "gross": gross, "net": 0, "fee": 0,
                    "credited_to": None,
                    "blocked": "internal-agent" if _internal else "first_valid_race"}
    net, fee = _split_with_fee(gross)

    # Persist split on the reward block for transparency
    r["gross_amount"] = gross
    r["net_amount"] = net
    r["fee_amount"] = fee

    if currency == "AIGEN":
        _credit(winner_sub["submitter"], net, f"mission-{m['id']}-winner-net")
        if fee > 0:
            _credit("treasury", fee, f"mission-{m['id']}-protocol-fee")
        # Track fee in missions state file (loaded by caller, save by caller via _record_fee_collected)
        return {"ok": True, "currency": "AIGEN", "gross": gross, "net": net, "fee": fee,
                "credited_to": winner_sub["submitter"], "fee_to": "treasury"}

    # USDC/ETH on-chain — only send NET to winner; fee stays in treasury implicitly
    wallet = winner_sub.get("submitter_wallet")
    if not wallet:
        return {"error": "winner has no submitter_wallet on file"}
    result = _onchain_payout(currency, r["chain"], wallet, net)
    if "error" in result:
        return {"error": result["error"]}
    r["payout_tx"] = result["tx_hash"]
    r["payout_at"] = int(time.time())
    return {"ok": True, "currency": currency, "gross": gross, "net": net, "fee": fee,
            "payout_tx": result["tx_hash"], "to_wallet": wallet,
            "fee_kept_in_treasury": True}


def _refund_creator_onchain(m: dict, full_amount: bool = True, fraction: int = 1, of: int = 1) -> dict:
    """Refund creator on-chain for USDC/ETH missions. For AIGEN, off-chain credit."""
    r = m["reward"]
    currency = r["currency"]
    amount = (r["amount"] * fraction) // of
    if currency == "AIGEN":
        _credit(m["creator"], amount, f"mission-{m['id']}-refund")
        return {"ok": True, "currency": "AIGEN", "amount": amount}
    # On-chain refund — need creator wallet (look up in agents.json)
    try:
        agents = json.load(open("/home/luna/crypto-genesis/aigen/agents.json"))
        wallet = next((a.get("wallet") for a in agents.get("agents", []) if a.get("id") == m["creator"]), "")
    except Exception:
        wallet = ""
    if not wallet:
        # Fallback: refund to TREASURY (creator can claim later by contacting us)
        return {"ok": False, "error": "creator wallet not on file; refund pending manual settlement",
                "currency": currency, "amount": amount, "creator": m["creator"]}
    result = _onchain_payout(currency, r["chain"], wallet, amount)
    if "error" in result:
        return {"error": result["error"]}
    return {"ok": True, "currency": currency, "amount": amount, "tx_hash": result["tx_hash"]}


# ---------- judge (creator_judges only) ----------

def judge(creator_agent_id: str, mission_id: str, winner_submission_id: str) -> dict:
    """Creator picks the winner. Valid for creator_judges missions (judging window only)
    and oracle missions (anytime — oracle can judge while the mission is still open).
    Pays winner in mission's reward currency. Protocol fee deducted."""
    d = load()
    for m in d["missions"]:
        if m["id"] != mission_id:
            continue
        vt = m["verification_type"]
        if vt not in ("creator_judges", "oracle"):
            return {"error": f"verification is {vt}; judge() only applies to creator_judges or oracle missions"}
        if m["creator"] != creator_agent_id:
            return {"error": "only creator can judge"}
        if m["status"] != "open":
            return {"error": f"mission is {m['status']}"}
        now = int(time.time())
        if vt == "creator_judges":
            if now < m["deadline"]:
                return {"error": "submission window still open; wait until deadline"}
            if now > m["judge_deadline"]:
                return {"error": "judging window expired; call resolve for auto-refund"}
        resolution_type = "oracle_judged" if vt == "oracle" else "creator_judged"

        winner = next((s for s in m["submissions"] if s["id"] == winner_submission_id), None)
        if not winner:
            return {"error": "winner_submission_id not in this mission"}

        pay = _pay_winner(m, winner)
        if "error" in pay:
            return {"error": f"payout failed: {pay['error']}"}
        winner["status"] = "winner"
        for s in m["submissions"]:
            if s["id"] != winner["id"]:
                s["status"] = "rejected"

        m["status"] = "resolved"
        m["resolution"] = {"type": resolution_type,
                           "winner_submission_id": winner["id"],
                           "winner_agent_id": winner["submitter"],
                           "payout": pay,
                           "resolved_at": now}
        d["resolved"] = d.get("resolved", 0) + 1
        if m["reward"]["currency"] == "AIGEN":
            d["lifetime_reward_aigen_paid"] = d.get("lifetime_reward_aigen_paid", 0) + pay.get("net", 0)
        _record_fee_collected(d, m["reward"]["currency"], pay.get("fee", 0))
        save(d)

        # Fire webhook for resolution
        wu = m.get("webhook_url", "")
        if wu:
            _fire_webhook(wu, {
                "event": "mission.resolved",
                "mission_id": mission_id,
                "mission_title": m.get("title"),
                "resolution_type": resolution_type,
                "winner_agent_id": winner["submitter"],
                "winner_submission_id": winner["id"],
                "payout": pay,
                "resolved_at": now,
                "view_url": f"https://cryptogenesis.duckdns.org/m/{mission_id}",
            })

        return {"ok": True, "winner": winner["submitter"], "payout": pay}
    return {"error": "mission not found"}


# ---------- resolve (deterministic, anyone calls) ----------

def resolve(mission_id: str) -> dict:
    """Deterministic resolution per verification_type. Anyone can call.
    Idempotent — already-resolved missions just return the prior outcome."""
    d = load()
    for m in d["missions"]:
        if m["id"] != mission_id:
            continue
        if m["status"] != "open":
            return {"error": f"mission is {m['status']}", "resolution": m.get("resolution")}

        now = int(time.time())
        vt = m["verification_type"]

        # Different types have different "ready to resolve" conditions
        if vt == "first_valid_match":
            result = _resolve_first_valid(d, m, now)
        elif vt == "oracle":
            result = _resolve_oracle(d, m, now)
        elif vt == "peer_vote":
            if now < m["deadline"]:
                return {"error": "voting window not over", "deadline": m["deadline"], "now": now}
            result = _resolve_peer_vote(d, m, now)
        elif vt == "creator_judges":
            if now < m["judge_deadline"]:
                return {"error": "creator judging window still open",
                        "judge_deadline": m["judge_deadline"], "now": now}
            result = _resolve_creator_judges_timeout(d, m, now)
        else:
            return {"error": f"unknown verification_type {vt}"}

        # Fire creator webhook on resolution outcome (best-effort)
        if result.get("ok"):
            wu = m.get("webhook_url", "")
            if wu:
                # Reload fresh state since the helpers call save(d)
                fresh = load()
                fresh_m = next((mm for mm in fresh["missions"] if mm["id"] == mission_id), m)
                _fire_webhook(wu, {
                    "event": "mission.resolved",
                    "mission_id": mission_id,
                    "mission_title": fresh_m.get("title"),
                    "verification_type": vt,
                    "outcome": fresh_m.get("resolution", {}).get("outcome", "WIN"),
                    "winner_agent_id": fresh_m.get("resolution", {}).get("winner_agent_id"),
                    "payout": fresh_m.get("resolution", {}).get("payout"),
                    "resolved_at": now,
                    "view_url": f"https://cryptogenesis.duckdns.org/m/{mission_id}",
                })
        return result
    return {"error": "mission not found"}


def _oracle_verify(m: dict, s: dict) -> dict:
    """Real verification of a submission (no code execution). Returns
    {passed: True|False|None, reason}. None = indeterminate -> retry, do not reject."""
    try:
        import sys as _sys
        if "/home/luna/crypto-genesis/aigen" not in _sys.path:
            _sys.path.insert(0, "/home/luna/crypto-genesis/aigen")
        import oabp_verifier
        return oabp_verifier.verify_submission(m, s)
    except Exception as e:
        return {"passed": None, "reason": f"verifier unavailable: {e}"}


def _resolve_oracle(d: dict, m: dict, now: int) -> dict:
    """First submission that PASSES real verification wins (paid via _pay_winner,
    which enforces anti-farm guards). Failed = rejected; indeterminate = retried."""
    subs_sorted = sorted(m["submissions"], key=lambda s: s["submitted_at"])
    winner = None
    pending_left = False
    changed = False
    for s in subs_sorted[:3]:
        if s.get("status") in ("rejected", "winner"):
            continue
        res = _oracle_verify(m, s)
        s["oracle_check"] = {"passed": res.get("passed"), "reason": res.get("reason"), "checked_at": now}
        changed = True
        if res.get("passed") is True:
            winner = s
            break
        elif res.get("passed") is False:
            s["status"] = "rejected"
        else:
            pending_left = True
    if winner:
        pay = _pay_winner(m, winner)
        if "error" in pay:
            save(d)
            return {"error": f"payout failed: {pay['error']}"}
        winner["status"] = "winner"
        for s in m["submissions"]:
            if s["id"] != winner["id"] and s.get("status") != "winner":
                s["status"] = "rejected"
        m["status"] = "resolved"
        m["resolution"] = {"type": "oracle", "winner_submission_id": winner["id"],
                           "winner_agent_id": winner["submitter"], "payout": pay, "resolved_at": now}
        d["resolved"] = d.get("resolved", 0) + 1
        if m["reward"]["currency"] == "AIGEN":
            d["lifetime_reward_aigen_paid"] = d.get("lifetime_reward_aigen_paid", 0) + pay.get("net", 0)
        _record_fee_collected(d, m["reward"]["currency"], pay.get("fee", 0))
        save(d)
        return {"ok": True, "winner": winner["submitter"], "payout": pay, "verified": True}
    if now >= m["deadline"] and not pending_left:
        refund = _refund_creator_onchain(m)
        m["status"] = "voided"
        m["resolution"] = {"type": "oracle", "outcome": "VOID_NO_VERIFIED_SUBMISSION",
                           "creator_refund": refund, "resolved_at": now}
        d["voided"] = d.get("voided", 0) + 1
        save(d)
        return {"ok": True, "outcome": "VOID_NO_VERIFIED_SUBMISSION", "creator_refund": refund}
    if changed:
        save(d)
    return {"error": "no verified submission yet", "pending": pending_left}


def _resolve_first_valid(d: dict, m: dict, now: int) -> dict:
    rx = m["verification_params"].get("regex", "")
    pattern = re.compile(rx) if rx else None
    subs_sorted = sorted(m["submissions"], key=lambda s: s["submitted_at"])
    winner = None
    for s in subs_sorted:
        if s.get("status") == "rejected":
            continue
        if pattern and pattern.search(s["proof"]):
            v = _oracle_verify(m, s)  # real-verification gate (GoPlus for safety reviews)
            if v.get("passed") is False:
                s["status"] = "rejected"
                s["oracle_check"] = {"passed": False, "reason": v.get("reason"), "checked_at": now}
                continue
            s["oracle_check"] = {"passed": v.get("passed"), "reason": v.get("reason"), "checked_at": now}
            winner = s
            break

    if winner:
        pay = _pay_winner(m, winner)
        if "error" in pay:
            return {"error": f"payout failed: {pay['error']}"}
        winner["status"] = "winner"
        for s in m["submissions"]:
            if s["id"] != winner["id"]:
                s["status"] = "rejected"
        m["status"] = "resolved"
        m["resolution"] = {"type": "first_valid_match",
                           "winner_submission_id": winner["id"],
                           "winner_agent_id": winner["submitter"],
                           "payout": pay,
                           "resolved_at": now}
        d["resolved"] = d.get("resolved", 0) + 1
        if m["reward"]["currency"] == "AIGEN":
            d["lifetime_reward_aigen_paid"] = d.get("lifetime_reward_aigen_paid", 0) + pay.get("net", 0)
        _record_fee_collected(d, m["reward"]["currency"], pay.get("fee", 0))
        save(d)
        return {"ok": True, "winner": winner["submitter"], "payout": pay}

    if now < m["deadline"]:
        return {"error": "no valid submission yet, and deadline not reached"}

    refund = _refund_creator_onchain(m)
    m["status"] = "voided"
    m["resolution"] = {"type": "first_valid_match", "outcome": "VOID_NO_VALID_SUBMISSION",
                       "creator_refund": refund, "resolved_at": now}
    d["voided"] = d.get("voided", 0) + 1
    save(d)
    return {"ok": True, "outcome": "VOID_NO_VALID_SUBMISSION", "creator_refund": refund}


def _resolve_peer_vote(d: dict, m: dict, now: int) -> dict:
    if not m["submissions"]:
        refund = _refund_creator_onchain(m)
        m["status"] = "voided"
        m["resolution"] = {"type": "peer_vote", "outcome": "VOID_NO_SUBMISSIONS",
                           "creator_refund": refund, "resolved_at": now}
        d["voided"] = d.get("voided", 0) + 1
        save(d)
        return {"ok": True, "outcome": "VOID_NO_SUBMISSIONS", "creator_refund": refund}

    # Quorum check
    total_votes = sum(s["yes_total"] + s["no_total"] for s in m["submissions"])
    if total_votes < PEER_VOTE_QUORUM_AIGEN:
        refund = _refund_creator_onchain(m)
        for s in m["submissions"]:
            for agent_id, amt in s["yes_votes"].items():
                _credit(agent_id, amt, f"mission-{m['id']}-vote-refund")
            for agent_id, amt in s["no_votes"].items():
                _credit(agent_id, amt, f"mission-{m['id']}-vote-refund")
        m["status"] = "voided"
        m["resolution"] = {"type": "peer_vote", "outcome": "VOID_NO_QUORUM",
                           "quorum_required": PEER_VOTE_QUORUM_AIGEN, "total_votes": total_votes,
                           "creator_refund": refund, "resolved_at": now}
        d["voided"] = d.get("voided", 0) + 1
        save(d)
        return {"ok": True, "outcome": "VOID_NO_QUORUM", "total_votes": total_votes}

    # Pick winner: highest net (yes - no), tie-break by yes_total then by earliest submission
    def score(s):
        return (s["yes_total"] - s["no_total"], s["yes_total"], -s["submitted_at"])
    ranked = sorted(m["submissions"], key=score, reverse=True)
    winner = ranked[0]

    if winner["yes_total"] - winner["no_total"] <= 0:
        refund = _refund_creator_onchain(m)
        for s in m["submissions"]:
            yes_t, no_t = s["yes_total"], s["no_total"]
            if no_t > 0 and yes_t > 0:
                for agent_id, stake in s["no_votes"].items():
                    share = (yes_t * stake) // no_t
                    _credit(agent_id, stake + share, f"mission-{m['id']}-rejected-no-payout")
            else:
                for agent_id, amt in {**s["yes_votes"], **s["no_votes"]}.items():
                    _credit(agent_id, amt, f"mission-{m['id']}-vote-refund")
            s["status"] = "rejected"
        m["status"] = "voided"
        m["resolution"] = {"type": "peer_vote", "outcome": "ALL_REJECTED",
                           "creator_refund": refund, "resolved_at": now}
        d["voided"] = d.get("voided", 0) + 1
        save(d)
        return {"ok": True, "outcome": "ALL_REJECTED"}

    # Winner found — pay reward in mission currency + redistribute AIGEN votes
    pay = _pay_winner(m, winner)
    if "error" in pay:
        return {"error": f"payout failed: {pay['error']}"}
    winner["status"] = "winner"
    payouts_summary = {"winner_payout": pay, "by_voter": {}}

    for s in m["submissions"]:
        yes_t, no_t = s["yes_total"], s["no_total"]
        is_winner = (s["id"] == winner["id"])
        # YES voters of winner get their stake back + share of NO stake on winner
        # NO voters of winner lose stake (goes to YES voters)
        # YES voters of losers lose stake (goes to NO voters of that submission)
        # NO voters of losers get their stake + share of YES stake
        if is_winner:
            if yes_t > 0 and no_t > 0:
                for agent_id, stake in s["yes_votes"].items():
                    share = (no_t * stake) // yes_t
                    payout = stake + share
                    _credit(agent_id, payout, f"mission-{m['id']}-yes-on-winner")
                    payouts_summary["by_voter"][agent_id] = payouts_summary["by_voter"].get(agent_id, 0) + payout
            else:
                # No opposition — refund yes voters
                for agent_id, amt in s["yes_votes"].items():
                    _credit(agent_id, amt, f"mission-{m['id']}-yes-unopposed-refund")
                    payouts_summary["by_voter"][agent_id] = payouts_summary["by_voter"].get(agent_id, 0) + amt
        else:
            s["status"] = "rejected"
            if yes_t > 0 and no_t > 0:
                for agent_id, stake in s["no_votes"].items():
                    share = (yes_t * stake) // no_t
                    payout = stake + share
                    _credit(agent_id, payout, f"mission-{m['id']}-no-on-loser")
                    payouts_summary["by_voter"][agent_id] = payouts_summary["by_voter"].get(agent_id, 0) + payout
            else:
                # one-sided — refund the side that bet
                for agent_id, amt in {**s["yes_votes"], **s["no_votes"]}.items():
                    _credit(agent_id, amt, f"mission-{m['id']}-vote-refund")
                    payouts_summary["by_voter"][agent_id] = payouts_summary["by_voter"].get(agent_id, 0) + amt

    m["status"] = "resolved"
    m["resolution"] = {"type": "peer_vote", "outcome": "WINNER",
                       "winner_submission_id": winner["id"],
                       "winner_agent_id": winner["submitter"],
                       "winner_payout": pay,
                       "voter_payouts": payouts_summary["by_voter"],
                       "resolved_at": now}
    d["resolved"] = d.get("resolved", 0) + 1
    if m["reward"]["currency"] == "AIGEN":
        d["lifetime_reward_aigen_paid"] = d.get("lifetime_reward_aigen_paid", 0) + pay.get("net", 0)
    _record_fee_collected(d, m["reward"]["currency"], pay.get("fee", 0))
    save(d)
    return {"ok": True, "winner": winner["submitter"], "winner_payout": pay,
            "voter_payouts": payouts_summary["by_voter"]}


def _resolve_creator_judges_timeout(d: dict, m: dict, now: int) -> dict:
    """Creator failed to judge in time → 50% refund creator, 50% split among submitters.
    For USDC/ETH: on-chain transfers. For AIGEN: off-chain credits."""
    if not m["submissions"]:
        refund = _refund_creator_onchain(m)
        m["status"] = "voided"
        m["resolution"] = {"type": "creator_judges", "outcome": "VOID_NO_SUBMISSIONS",
                           "creator_refund": refund, "resolved_at": now}
        d["voided"] = d.get("voided", 0) + 1
        save(d)
        return {"ok": True, "outcome": "VOID_NO_SUBMISSIONS"}

    # 50/50 split between creator and submitters
    half_refund = _refund_creator_onchain(m, fraction=1, of=2)

    # For consolation, only AIGEN missions get auto-pay; USDC/ETH consolation
    # requires submitter wallets and individual gas, so we mark each submission
    # as eligible for claim — submitters call /missions/{id}/claim-consolation later
    consolation_per_submitter = None
    if m["reward"]["currency"] == "AIGEN":
        other_half = m["reward"]["amount"] - (m["reward"]["amount"] // 2)
        per_sub = other_half // len(m["submissions"])
        distributed = 0
        for s in m["submissions"]:
            if per_sub > 0:
                _credit(s["submitter"], per_sub, f"mission-{m['id']}-judge-timeout-consolation")
                distributed += per_sub
            s["status"] = "rejected"
        leftover = other_half - distributed
        if leftover > 0:
            _credit(m["creator"], leftover, f"mission-{m['id']}-judge-timeout-rounding")
        consolation_per_submitter = per_sub
    else:
        # USDC/ETH: track consolation as claimable. Each submitter can claim per_sub
        # by calling /missions/{id}/claim-consolation { submitter_agent_id, wallet }
        other_half = m["reward"]["amount"] - (m["reward"]["amount"] // 2)
        per_sub = other_half // len(m["submissions"])
        for s in m["submissions"]:
            s["status"] = "rejected"
            s["consolation_claimable_amount"] = per_sub
            s["consolation_claimed"] = False
        consolation_per_submitter = per_sub

    m["status"] = "voided"
    m["resolution"] = {"type": "creator_judges", "outcome": "JUDGE_TIMEOUT",
                       "creator_refund": half_refund,
                       "consolation_per_submitter": consolation_per_submitter,
                       "consolation_currency": m["reward"]["currency"],
                       "resolved_at": now}
    d["voided"] = d.get("voided", 0) + 1
    save(d)
    return {"ok": True, "outcome": "JUDGE_TIMEOUT",
            "creator_refund": half_refund,
            "consolation_per_submitter": consolation_per_submitter}


# ---------- read ----------

def get_mission(mission_id: str):
    d = load()
    for m in d["missions"]:
        if m["id"] == mission_id:
            return with_discovery_links(m)
    return None


def list_open(limit: int = 100) -> list:
    d = load()
    now = int(time.time())
    return [
        with_discovery_links(m)
        for m in d["missions"]
        if m["status"] == "open" and now < m["deadline"]
    ][:limit]


# ---------- reputation tiers + leaderboard (AIGEN = engagement/reputation) ----------
_TIER_THRESHOLDS = [0, 100, 1000, 10000]
_TIER_NAMES = ["Newcomer", "Contributor", "Trusted", "Elite"]


def _tier(agent_id: str):
    bal = _balance(agent_id)
    t = 0
    for i, thr in enumerate(_TIER_THRESHOLDS):
        if bal >= thr:
            t = i
    return t, _TIER_NAMES[t]


def _required_tier_for_mission(m: dict) -> int:
    # Only AIGEN-reward missions are reputation-gated; reward size sets the bar.
    if (m.get("reward") or {}).get("currency") != "AIGEN":
        return 0
    amt = (m.get("reward") or {}).get("amount", 0)
    if amt >= 1000:
        return 2
    if amt >= 200:
        return 1
    return 0


def leaderboard(limit: int = 20, include_internal: bool = False) -> dict:
    L = _ledger()
    agents = L.get("agents", {})

    def _intern(a):
        a = (a or "").lower()
        return a.startswith(("aigen", "treasury", "autopilot")) or a.endswith("-probe")

    def _tier_name(bal):
        t = 0
        for i, thr in enumerate(_TIER_THRESHOLDS):
            if bal >= thr:
                t = i
        return _TIER_NAMES[t]
    rows = []
    for aid, v in agents.items():
        if not include_internal and _intern(aid):
            continue
        bal = v.get("balance", 0)
        if bal <= 0 and v.get("total_earned", 0) <= 0:
            continue
        rows.append({"agent": aid, "aigen": bal, "total_earned": v.get("total_earned", 0),
                     "tier": _tier_name(bal), "actions": v.get("actions", 0)})
    rows.sort(key=lambda r: (-r["aigen"], -r["total_earned"]))
    out = rows[:limit]
    for i, r in enumerate(out):
        r["rank"] = i + 1
        try:
            r["elo"] = _elo(r["agent"])
        except Exception:
            r["elo"] = None
    return {"count": len(rows), "leaderboard": out}


def tokenomics() -> dict:
    # Transparent net-issuance view of the uncapped AIGEN reputation ledger (read-only).
    L = _ledger()
    agents = L.get("agents", {})
    balances = {a: v.get("balance", 0) for a, v in agents.items()}
    circulating = sum(balances.values())
    lifetime_emitted = L.get("total_distributed", 0)
    try:
        lifetime_burned = load().get("lifetime_spam_fees_burned", 0)
    except Exception:
        lifetime_burned = 0

    def _intern(a):
        a = (a or "").lower()
        return a.startswith(("aigen", "treasury", "autopilot")) or a.endswith("-probe")

    internal_held = sum(b for a, b in balances.items() if _intern(a))
    ranked = sorted(((b, a) for a, b in balances.items() if b > 0), reverse=True)
    top5 = ranked[:5]
    return {
        "model": "uncapped reputation ledger (off-chain); intradable by design; NOT a tradeable asset",
        "supply": {
            "lifetime_emitted": lifetime_emitted,
            "lifetime_burned": lifetime_burned,
            "circulating": circulating,
            "burn_ratio_pct": round(lifetime_burned / lifetime_emitted * 100, 3) if lifetime_emitted else 0,
        },
        "holders": {
            "count": sum(1 for b in balances.values() if b > 0),
            "internal_held": internal_held,
            "external_held": circulating - internal_held,
            "internal_share_pct": round(internal_held / circulating * 100, 1) if circulating else 0,
            "top1_share_pct": round(top5[0][0] / circulating * 100, 1) if circulating and top5 else 0,
            "top5_share_pct": round(sum(b for b, _ in top5) / circulating * 100, 1) if circulating else 0,
            "top5": [{"agent": a, "balance": b} for b, a in top5],
        },
        "onchain_ref": {
            "note": "ledger AIGEN is NOT backed by/convertible to the on-chain token",
            "token": "0xF6EFc5D5902d1a0ce58D9ab1715Cf30f077D8f6e",
            "chain": "optimism (vestigial; roadmap: Base)",
        },
        "discipline": {
            "note": "uncapped holds value ETH-style only if sinks+burn ~= emission",
            "sinks_active": ["mission_creation_spam_fee"],
            "sinks_todo": ["submitter_stake", "access_gating", "scaled_burn"],
        },
    }


def list_due_for_resolution(limit: int = 100) -> list:
    """Missions ready to be resolved (anyone can call resolve)."""
    d = load()
    now = int(time.time())
    out = []
    for m in d["missions"]:
        if m["status"] != "open":
            continue
        vt = m["verification_type"]
        if vt == "peer_vote" and now >= m["deadline"]:
            out.append(m)
        elif vt == "first_valid_match":
            # First-valid is "due" if there's already a valid submission, OR if deadline passed
            if now >= m["deadline"]:
                out.append(m)
            else:
                rx = m["verification_params"].get("regex", "")
                if rx:
                    try:
                        pat = re.compile(rx)
                        if any(pat.search(s["proof"]) for s in m["submissions"]):
                            out.append(m)
                    except Exception:
                        pass
        elif vt == "creator_judges" and now >= m.get("judge_deadline", 0):
            out.append(m)
        elif vt == "oracle":
            if now >= m["deadline"] or any(s.get("status") == "pending" for s in m["submissions"]):
                out.append(m)
    return out[:limit]


def stats() -> dict:
    d = load()
    fees = d.get("lifetime_fees_collected", {"AIGEN": 0, "USDC": 0, "ETH": 0})
    return {
        "total": d.get("total", 0),
        "open": len(list_open(10000)),
        "due_for_resolution": len(list_due_for_resolution(10000)),
        "resolved": d.get("resolved", 0),
        "voided": d.get("voided", 0),
        "lifetime_reward_aigen_escrowed": d.get("lifetime_reward_aigen_escrowed", 0),
        "lifetime_reward_aigen_paid_to_winners_net": d.get("lifetime_reward_aigen_paid", 0),
        "lifetime_spam_fees_burned": d.get("lifetime_spam_fees_burned", 0),
        "lifetime_protocol_fees_collected": {
            "AIGEN": fees.get("AIGEN", 0),
            "USDC_micros": fees.get("USDC", 0),
            "USDC_human": f"${fees.get('USDC', 0)/1e6:.6f}",
            "ETH_wei": fees.get("ETH", 0),
            "ETH_human": f"{fees.get('ETH', 0)/1e18:.9f}",
        },
        "protocol_fee_bps": PROTOCOL_FEE_BPS,
        "protocol_fee_pct": f"{PROTOCOL_FEE_BPS/100:.2f}%",
        "spam_fee_burn_aigen": SPAM_FEE_BURN_AIGEN,
        "min_reward_aigen": MIN_REWARD_AIGEN,
        "min_reward_usdc_micros": MIN_REWARD_USDC_MICROS,
        "min_reward_eth_wei": MIN_REWARD_ETH_WEI,
        "verification_types": sorted(VERIFICATION_TYPES),
        "peer_vote_quorum_aigen": PEER_VOTE_QUORUM_AIGEN,
        "min_vote_aigen": MIN_VOTE_AIGEN,
        "treasury_wallet": TREASURY,
    }


def quote_payout(reward_currency: str, gross_amount: int) -> dict:
    """Pre-creation quote: tells creator exactly what winner will get and what
    fee the protocol takes. Useful for transparent UX in /missions/create flow."""
    if reward_currency.upper() not in REWARD_CURRENCIES:
        return {"error": f"unknown currency {reward_currency}"}
    net, fee = _split_with_fee(gross_amount)
    return {
        "currency": reward_currency.upper(),
        "gross_amount": gross_amount,
        "net_to_winner": net,
        "protocol_fee": fee,
        "fee_bps": PROTOCOL_FEE_BPS,
        "fee_pct": f"{PROTOCOL_FEE_BPS/100:.2f}%",
    }