#!/usr/bin/env python3
"""
Montana Protocol API — Standalone REST API
Fully independent, no Telegram dependencies.

Endpoints:
- /api/health          - Node health check
- /api/network         - Network status (3 nodes)
- /api/status          - Full Montana status
- /api/balance/{addr}  - Balance by Montana address (mt...)
- /api/transfer        - Transfer Ɉ between addresses
- /api/timechain/*     - TimeChain operations
"""

from flask import Flask, jsonify, request
from flask_cors import CORS
import json
import os
import threading
import fcntl
import time as time_module
import hashlib
import hmac
import ipaddress
import re
import logging
from pathlib import Path
from datetime import datetime
from collections import defaultdict
from functools import wraps
from decimal import Decimal, ROUND_DOWN, InvalidOperation

# Post-quantum cryptography
from node_crypto import verify_signature, public_key_to_address, validate_address

# Event Sourcing — P2P replication layer
try:
    from event_ledger import get_event_ledger, EventLedger, EventType
    EVENT_LEDGER_AVAILABLE = True
except ImportError:
    EVENT_LEDGER_AVAILABLE = False

# TIME_BANK — T2 finalization engine
try:
    from time_bank import get_time_bank
    TIME_BANK_AVAILABLE = True
except ImportError:
    TIME_BANK_AVAILABLE = False

# AUCTION SYSTEM — Ascending Auction Model
try:
    from montana_auction import (
        get_auction_registry,
        get_domain_service,
        get_phone_service,
        get_call_pricing_service,
        ServiceType
    )
    AUCTION_AVAILABLE = True
except ImportError:
    AUCTION_AVAILABLE = False

# REAL PHONE BINDING — SMS Verification
try:
    from montana_real_phone import get_real_phone_service
    REAL_PHONE_AVAILABLE = True
except ImportError:
    REAL_PHONE_AVAILABLE = False

log = logging.getLogger("montana_api")

app = Flask(__name__)

# [FIX CWE-942] CORS restricted to Montana origins only
ALLOWED_ORIGINS = os.environ.get("CORS_ORIGINS", "").split(",")
if ALLOWED_ORIGINS == [""]:
    ALLOWED_ORIGINS = ["https://efir.org"]

CORS(app, resources={
    r"/api/*": {
        "origins": ALLOWED_ORIGINS,
        "methods": ["GET", "POST"],
        "allow_headers": ["Content-Type", "Authorization", "X-Montana-Signature",
                          "X-Address", "X-Timestamp", "X-Signature", "X-Public-Key",
                          "X-Signature-Algorithm"],
        "max_age": 3600
    }
})

# ═══════════════════════════════════════════════════════════════════════════════
#                              CONFIGURATION
# ═══════════════════════════════════════════════════════════════════════════════

BOT_DIR = Path(__file__).parent
DATA_DIR = BOT_DIR / "data"
WALLETS_FILE = DATA_DIR / "wallets.json"
REGISTRY_FILE = DATA_DIR / "registry.json"  # Реестр адресов с номерами

# [FIX CWE-502] File size limits (Memory DoS protection)
MAX_WALLET_FILE_SIZE = 50 * 1024 * 1024  # 50MB
MAX_WALLETS = 100_000  # [FIX CWE-400] Disk DoS protection

# [FIX CWE-20] Montana address validation
MONTANA_ADDRESS_RE = re.compile(r'^mt[a-f0-9]{40}$')

# Montana Network Nodes
NODES = {
    "amsterdam": {"ip": "72.56.102.240", "priority": 1, "location": "🇳🇱 Amsterdam"},
    "moscow": {"ip": "176.124.208.93", "priority": 2, "location": "🇷🇺 Moscow"},
    "almaty": {"ip": "91.200.148.93", "priority": 3, "location": "🇰🇿 Almaty"}
}

# P2P Peer nodes for event replication (port 8889 for inter-node sync)
PEER_NODES = [
    {"name": "amsterdam", "url": "http://72.56.102.240:8889", "ip": "72.56.102.240"},
    {"name": "moscow", "url": "http://176.124.208.93:8889", "ip": "176.124.208.93"},
    {"name": "almaty", "url": "http://91.200.148.93:8889", "ip": "91.200.148.93"},
]

# Node identity — determined at startup from local IP
NODE_ID = os.environ.get("MONTANA_NODE_ID", "unknown")

# Connected Mac app clients (dynamic registry)
_mac_peers = {}
_mac_peers_lock = threading.Lock()

# ═══════════════════════════════════════════════════════════════════════════════
#                              RATE LIMITING
# ═══════════════════════════════════════════════════════════════════════════════

# [FIX R8 CWE-807] Trusted proxy IP resolution
# Only trust X-Real-IP / X-Forwarded-For when direct connection is from localhost (nginx proxy)
_LOCALHOST_IPS = frozenset({'127.0.0.1', '::1'})

def _get_client_ip() -> str:
    """Get real client IP, handling reverse proxy (nginx) on localhost."""
    direct_ip = request.remote_addr or 'unknown'
    if direct_ip in _LOCALHOST_IPS:
        # Connection from local nginx — trust proxy headers
        real_ip = request.headers.get('X-Real-IP', '').strip()
        if real_ip:
            try:
                ipaddress.ip_address(real_ip)
                return real_ip
            except ValueError:
                pass
        forwarded = request.headers.get('X-Forwarded-For', '').strip()
        if forwarded:
            first_ip = forwarded.split(',')[0].strip()
            try:
                ipaddress.ip_address(first_ip)
                return first_ip
            except ValueError:
                pass
    return direct_ip


class RateLimiter:
    """Simple in-memory rate limiter with periodic cleanup"""
    def __init__(self):
        self.requests = defaultdict(list)
        self.lock = threading.Lock()
        self._last_cleanup = time_module.time()

    def is_allowed(self, ip: str, limit: int = 60, window: int = 60) -> bool:
        now = time_module.time()
        with self.lock:
            # [FIX R8 CWE-400] Periodic cleanup of stale entries every 5 minutes
            if now - self._last_cleanup > 300:
                stale_ips = [k for k, v in self.requests.items()
                             if not v or now - v[-1] > 300]
                for k in stale_ips:
                    del self.requests[k]
                self._last_cleanup = now

            self.requests[ip] = [t for t in self.requests[ip] if now - t < window]
            if len(self.requests[ip]) >= limit:
                return False
            self.requests[ip].append(now)
            return True

_rate_limiter = RateLimiter()

def rate_limit(limit: int = 60, window: int = 60):
    """Decorator for rate limiting endpoints"""
    def decorator(f):
        @wraps(f)
        def decorated_function(*args, **kwargs):
            ip = _get_client_ip()
            if not _rate_limiter.is_allowed(ip, limit, window):
                return jsonify({
                    "error": "RATE_LIMIT_EXCEEDED",
                    "message": f"Too many requests. Limit: {limit} per {window}s",
                    "retry_after": window
                }), 429
            return f(*args, **kwargs)
        return decorated_function
    return decorator

# ═══════════════════════════════════════════════════════════════════════════════
#                              SIGNATURE VERIFICATION
# ═══════════════════════════════════════════════════════════════════════════════

def verify_signature_beta(public_key_hex: str, message: str, signature_hex: str) -> bool:
    """
    Verify ML-DSA-65 signature (MAINNET only).

    [FIX CWE-320] HMAC-SHA256 "BETA" mode REMOVED — it used public key as HMAC secret,
    which means ANYONE with the public key could forge signatures.
    Only ML-DSA-65 (3309 bytes / 6618 hex) accepted.
    """
    sig_bytes = len(signature_hex) // 2

    if sig_bytes == 3309:
        # MAINNET: ML-DSA-65 (FIPS 204)
        return verify_signature(public_key_hex, message, signature_hex)

    else:
        log.warning("[Auth] Rejected non-ML-DSA-65 signature: %d bytes (expected 3309)", sig_bytes)
        return False

# ═══════════════════════════════════════════════════════════════════════════════
#                              WALLET STORAGE
# ═══════════════════════════════════════════════════════════════════════════════

_wallet_lock = threading.Lock()  # [FIX CWE-362] Process-level lock


def _validate_address(address: str) -> bool:
    """[FIX CWE-20] Validate Montana address format: mt + 40 hex chars"""
    return bool(MONTANA_ADDRESS_RE.match(address))


# ── Shared presence queue for TimeChain node ──
_presence_queue_lock = threading.Lock()
PRESENCE_QUEUE_FILE = Path(__file__).parent / "data" / "presence_queue.json"


MAX_PRESENCE_QUEUE_ENTRIES = 10000  # [FIX R7 CWE-400] Prevent disk DoS

def _queue_presence(address: str, seconds: int):
    """Write presence to shared queue file (read by timechain_node at τ₂ boundary)"""
    with _presence_queue_lock:
        try:
            data = {}
            if PRESENCE_QUEUE_FILE.exists():
                with open(PRESENCE_QUEUE_FILE, 'r') as f:
                    data = json.load(f)
            # [FIX R7 CWE-400] Cap queue size to prevent disk/memory DoS
            if address not in data and len(data) >= MAX_PRESENCE_QUEUE_ENTRIES:
                log.warning(f"Presence queue full ({MAX_PRESENCE_QUEUE_ENTRIES} entries), rejecting {address[:10]}...")
                return
            existing = data.get(address, 0)
            data[address] = min(existing + seconds, 600)  # Max TAU2_SECONDS
            with open(PRESENCE_QUEUE_FILE, 'w') as f:
                json.dump(data, f)
        except Exception as e:
            log.warning(f"Presence queue write error: {e}")


def load_wallets() -> dict:
    """Load wallets from JSON file with size validation and file locking"""
    if not WALLETS_FILE.exists():
        return {}

    # [FIX CWE-502] Check file size before loading
    try:
        file_size = os.path.getsize(WALLETS_FILE)
        if file_size > MAX_WALLET_FILE_SIZE:
            log.critical("Wallets file too large: %d bytes (max %d)",
                         file_size, MAX_WALLET_FILE_SIZE)
            return {}
    except OSError:
        return {}

    try:
        with open(WALLETS_FILE, 'r', encoding='utf-8') as f:
            # [FIX CWE-362] Shared read lock
            fcntl.flock(f.fileno(), fcntl.LOCK_SH)
            try:
                return json.load(f)
            finally:
                fcntl.flock(f.fileno(), fcntl.LOCK_UN)
    except json.JSONDecodeError as e:
        log.error("Invalid JSON in wallets file: %s", e)
        return {}
    except Exception as e:
        log.error("Failed to load wallets: %s", e)
        return {}


def save_wallets(wallets: dict):
    """Save wallets to JSON file with file locking"""
    DATA_DIR.mkdir(parents=True, exist_ok=True)

    # [FIX CWE-362] Exclusive write lock
    with open(WALLETS_FILE, 'w', encoding='utf-8') as f:
        fcntl.flock(f.fileno(), fcntl.LOCK_EX)
        try:
            json.dump(wallets, f, indent=2, ensure_ascii=False)
        finally:
            fcntl.flock(f.fileno(), fcntl.LOCK_UN)


def get_balance(address: str) -> float:
    """Get balance for Montana address"""
    if not _validate_address(address):
        return 0.0
    wallets = load_wallets()
    return wallets.get(address, {}).get('balance', 0.0)


def set_balance(address: str, balance: float):
    """Set balance for Montana address with wallet count limit"""
    if not _validate_address(address):
        raise ValueError(f"Invalid Montana address: {address}")

    with _wallet_lock:  # [FIX CWE-362] Thread safety
        wallets = load_wallets()

        if address not in wallets:
            # [FIX CWE-400] Limit total wallet count
            if len(wallets) >= MAX_WALLETS:
                raise ValueError(f"Maximum wallet limit reached ({MAX_WALLETS})")
            wallets[address] = {'created_at': datetime.utcnow().isoformat()}

        # [FIX CWE-682] Use string representation for precision
        wallets[address]['balance'] = float(Decimal(str(balance)).quantize(
            Decimal('0.00000001'), rounding=ROUND_DOWN))
        wallets[address]['updated_at'] = datetime.utcnow().isoformat()
        save_wallets(wallets)

# ═══════════════════════════════════════════════════════════════════════════════
#                              NETWORK STATUS
# ═══════════════════════════════════════════════════════════════════════════════

def check_node_status(ip: str) -> dict:
    """Check node status via ping with IP validation"""
    import subprocess

    # [FIX CWE-78] Validate IP address format before passing to subprocess
    try:
        ipaddress.ip_address(ip)
    except ValueError:
        log.warning("Invalid IP in check_node_status: %s", ip)
        return {"online": False, "response_time": "invalid_ip"}

    try:
        result = subprocess.run(
            ['ping', '-c', '1', '-W', '1', ip],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            timeout=2,
            shell=False  # Explicit: prevent shell injection
        )
        online = result.returncode == 0
        return {"online": online, "response_time": "< 100ms" if online else "timeout"}
    except subprocess.TimeoutExpired:
        return {"online": False, "response_time": "timeout"}
    except Exception as e:
        log.error("Ping failed for %s: %s", ip, e)
        return {"online": False, "response_time": "error"}

def get_network_status() -> dict:
    """Get full Montana network status"""
    status = {}

    for node_name, node_info in NODES.items():
        node_status = check_node_status(node_info["ip"])
        status[node_name] = {
            **node_info,
            **node_status,
            "name": node_name.title()
        }

    online_count = sum(1 for n in status.values() if n["online"])

    return {
        "nodes": status,
        "summary": {
            "total_nodes": len(NODES),
            "online_nodes": online_count,
            "network_health": f"{(online_count/len(NODES))*100:.0f}%",
            "timestamp": datetime.utcnow().isoformat() + "Z"
        }
    }

# ═══════════════════════════════════════════════════════════════════════════════
#                              API ENDPOINTS
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/health')
def api_health():
    """Quick health check for iOS/clients"""
    result = {
        "status": "ok",
        "node": NODE_ID,
        "version": "3.18.0",
        "p2p": EVENT_LEDGER_AVAILABLE,
        "timestamp": datetime.utcnow().isoformat() + "Z"
    }
    if EVENT_LEDGER_AVAILABLE:
        try:
            ledger = get_event_ledger()
            result["ledger_events"] = ledger._event_counter
            result["ledger_node_id"] = ledger.node_id
        except Exception:
            pass
    return jsonify(result)

@app.route('/api/network')
def api_network():
    """Network status only"""
    return jsonify(get_network_status())

@app.route('/api/status')
def api_status():
    """Full Montana status"""
    network = get_network_status()

    result = {
        "network": network,
        "montana": {
            "version": "3.18.0",
            "mode": "MAINNET",
            "crypto": "ML-DSA-65 (FIPS 204)",
            "node_id": NODE_ID,
            "p2p_enabled": EVENT_LEDGER_AVAILABLE
        }
    }

    if EVENT_LEDGER_AVAILABLE:
        try:
            ledger = get_event_ledger()
            result["montana"]["ledger"] = ledger.stats()
        except Exception:
            pass

    return jsonify(result)

# ═══════════════════════════════════════════════════════════════════════════════
#                              WALLET ENDPOINTS
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/balance/<address>')
@rate_limit(limit=100, window=60)
def api_balance(address: str):
    """
    Get balance for Montana address.
    Post-quantum: ML-DSA-65 signed (FIPS 204).

    Address format: mt + 40 hex chars (e.g., mta46b633d258059b90db46adffc6c5ca08f0e8d6c)
    Client signs: "BALANCE:{address}:{timestamp}"
    """
    # [FIX CWE-20] Validate address format with regex
    if not _validate_address(address):
        return jsonify({
            "error": "INVALID_ADDRESS",
            "message": "Address must match format: mt + 40 hex chars"
        }), 400

    # PQ verification for signed balance requests
    address_hdr = request.headers.get('X-Address', '')
    timestamp_hdr = request.headers.get('X-Timestamp', '')
    verified = False
    if address_hdr and timestamp_hdr:
        pq_message = f"BALANCE:{address_hdr}:{timestamp_hdr}"
        _, verified = _verify_pq_signature(request, message=pq_message)

    # Use EventLedger as single source of truth (not wallets.json cache)
    if EVENT_LEDGER_AVAILABLE:
        try:
            ledger = get_event_ledger()
            balance = ledger.balance(address)
        except Exception:
            balance = get_balance(address)
    else:
        balance = get_balance(address)

    return jsonify({
        "address": address,
        "balance": balance,
        "symbol": "Ɉ",
        "pq_verified": verified,
        "timestamp": datetime.utcnow().isoformat() + "Z"
    })

@app.route('/api/transfer', methods=['POST'])
@rate_limit(limit=10, window=60)
def api_transfer():
    """
    Transfer Ɉ between Montana addresses.

    Required fields:
    - from_address: sender's Montana address (mt...)
    - to_address: recipient's Montana address (mt...)
    - amount: amount to transfer (float)
    - signature: ML-DSA-65 signature of message
    - public_key: sender's public key (hex)

    Message to sign: "TRANSFER:{from}:{to}:{amount}:{timestamp}"
    """
    data = request.get_json()

    if not data:
        return jsonify({"error": "NO_DATA", "message": "Request body required"}), 400

    # Required fields
    from_addr = data.get('from_address')
    to_addr = data.get('to_address')
    amount = data.get('amount')
    signature = data.get('signature')
    public_key = data.get('public_key')
    timestamp = data.get('timestamp')

    # Validate required fields (signature/public_key optional for registered wallets)
    if not all([from_addr, to_addr, amount, timestamp]):
        return jsonify({
            "error": "MISSING_FIELDS",
            "message": "Required: from_address, to_address, amount, timestamp"
        }), 400

    # [FIX CWE-20] Validate addresses with regex
    for addr, name in [(from_addr, 'from_address'), (to_addr, 'to_address')]:
        if not _validate_address(addr):
            return jsonify({
                "error": "INVALID_ADDRESS",
                "message": f"{name} must match format: mt + 40 hex chars"
            }), 400

    # [FIX CWE-682] Validate amount with Decimal precision
    try:
        amount_dec = Decimal(str(amount))
        if amount_dec <= 0:
            raise ValueError("Amount must be positive")
        amount_dec = amount_dec.quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
        # [FIX R10 CWE-697] Reject amounts that round to zero after quantization
        if amount_dec <= 0:
            raise ValueError("Amount rounds to zero (minimum: 0.00000001)")
        # [FIX CWE-682 R5] Keep Decimal for balance arithmetic — no float() conversion
        # float64 loses precision beyond ~15 significant digits; Decimal is exact
        amount = amount_dec
    except (ValueError, InvalidOperation) as e:
        return jsonify({"error": "INVALID_AMOUNT", "message": str(e)}), 400

    # Verify sender identity
    if signature and public_key:
        # ML-DSA-65 signed transfer (full verification)
        derived_address = public_key_to_address(public_key)
        if derived_address != from_addr:
            return jsonify({
                "error": "ADDRESS_MISMATCH",
                "message": "Public key does not match from_address"
            }), 403

        message = f"TRANSFER:{from_addr}:{to_addr}:{amount}:{timestamp}"
        if not verify_signature_beta(public_key, message, signature):
            return jsonify({
                "error": "INVALID_SIGNATURE",
                "message": "Signature verification failed"
            }), 403
    else:
        # [FIX R8 CWE-306] Unsigned transfers REJECTED — ML-DSA-65 signature required
        # Previously allowed for "registered wallets" but provides zero auth
        # (anyone knowing the address could drain funds)
        return jsonify({
            "error": "SIGNATURE_REQUIRED",
            "message": "All transfers require ML-DSA-65 signature (FIPS 204)"
        }), 403

    # [FIX CWE-367] Timestamp freshness — reject stale/future requests
    try:
        ts_val = int(timestamp) if str(timestamp).isdigit() else int(float(timestamp))
        now_ms = int(time_module.time() * 1000)
        # Allow 5 min drift (300_000 ms) for clock skew
        if abs(now_ms - ts_val) > 300_000:
            return jsonify({
                "error": "STALE_TIMESTAMP",
                "message": "Timestamp too old or too far in future (max 5 min drift)"
            }), 400
    except (ValueError, TypeError):
        # [FIX CWE-294] Reject non-numeric timestamps (replay attack vector)
        return jsonify({
            "error": "INVALID_TIMESTAMP",
            "message": "Timestamp must be numeric (milliseconds since epoch)"
        }), 400

    # [FIX] Self-transfer check
    if from_addr == to_addr:
        return jsonify({
            "error": "SELF_TRANSFER",
            "message": "Cannot transfer to self"
        }), 400

    # [FIX CWE-362] Generate unique tx_id with full SHA256 (not truncated)
    tx_nonce = os.urandom(16).hex()
    tx_id = hashlib.sha256(
        f"{from_addr}{to_addr}{amount}{timestamp}{tx_nonce}".encode()
    ).hexdigest()

    # Determine if this was a PQ-signed transfer
    is_pq_signed = bool(signature and public_key)

    # [FIX CWE-362] Atomic balance check + transfer via EventLedger
    # EventLedger.transfer() does balance check internally (skip_balance_check=False)
    if EVENT_LEDGER_AVAILABLE:
        try:
            ledger = get_event_ledger()
            ok, msg, event = ledger.transfer(from_addr, to_addr, float(amount), metadata={
                "tx_id": tx_id,
                "timestamp": timestamp,
                "pq_signed": is_pq_signed
            }, skip_balance_check=False)
            if not ok:
                return jsonify({
                    "error": "TRANSFER_REJECTED",
                    "message": msg
                }), 400
            if event:
                _push_event_to_peers(event.to_dict())
        except Exception as e:
            log.error(f"EventLedger transfer error: {e}")
            return jsonify({
                "error": "LEDGER_ERROR",
                "message": str(e)
            }), 500
    else:
        # Fallback: wallets.json atomic transfer
        with _wallet_lock:
            wallets = load_wallets()
            # [FIX CWE-682 R5] Use Decimal for balance comparison to prevent precision loss
            sender_balance = Decimal(str(wallets.get(from_addr, {}).get('balance', 0)))
            if sender_balance < amount:
                return jsonify({
                    "error": "INSUFFICIENT_FUNDS",
                    "message": f"Balance: {sender_balance} Ɉ, required: {amount} Ɉ"
                }), 400
            wallets[from_addr]['balance'] = float(sender_balance - amount)
            if to_addr not in wallets:
                wallets[to_addr] = {'balance': 0.0, 'created_at': datetime.utcnow().isoformat()}
            recv_bal = Decimal(str(wallets[to_addr].get('balance', 0)))
            wallets[to_addr]['balance'] = float(recv_bal + amount)
            save_wallets(wallets)

    return jsonify({
        "status": "success",
        "tx_id": tx_id,
        "from": from_addr,
        "to": to_addr,
        "amount": float(amount),
        "symbol": "Ɉ",
        "pq_signed": is_pq_signed,
        "timestamp": datetime.utcnow().isoformat() + "Z"
    })

@app.route('/api/register', methods=['POST'])
@rate_limit(limit=5, window=60)
def api_register():
    """
    Register new wallet with public key.

    Required fields:
    - public_key: ML-DSA-65 public key (hex, 3904 chars = 1952 bytes)

    Returns Montana address derived from public key.
    """
    data = request.get_json()

    if not data:
        return jsonify({"error": "NO_DATA", "message": "Request body required"}), 400

    public_key = data.get('public_key')

    if not public_key:
        return jsonify({"error": "MISSING_PUBLIC_KEY", "message": "public_key required"}), 400

    # Validate public key length (1952 bytes = 3904 hex chars)
    if len(public_key) != 3904:
        return jsonify({
            "error": "INVALID_PUBLIC_KEY",
            "message": f"Public key must be 3904 hex chars (1952 bytes), got {len(public_key)}"
        }), 400

    # Derive address
    try:
        address = public_key_to_address(public_key)
    except Exception as e:
        return jsonify({"error": "KEY_DERIVATION_ERROR", "message": str(e)}), 400

    # [FIX R9 CWE-362] Atomic wallet mutation under lock
    with _wallet_lock:
        wallets = load_wallets()
        if address not in wallets:
            wallets[address] = {
                'balance': 0.0,
                'public_key': public_key,
                'created_at': datetime.utcnow().isoformat()
            }
            save_wallets(wallets)
        balance = wallets[address].get('balance', 0.0)

    return jsonify({
        "status": "success",
        "address": address,
        "balance": balance,
        "symbol": "Ɉ"
    })

# ═══════════════════════════════════════════════════════════════════════════════
#                              WALLET REGISTRY (Sequential Numbers)
# ═══════════════════════════════════════════════════════════════════════════════

def load_registry():
    """Load wallet registry with sequential numbers"""
    if REGISTRY_FILE.exists():
        try:
            with open(REGISTRY_FILE, 'r') as f:
                return json.load(f)
        except (json.JSONDecodeError, OSError) as e:
            log.error("Failed to load registry: %s", e)
    return {"next_number": 1, "wallets": {}}

def save_registry(registry):
    """Save wallet registry"""
    DATA_DIR.mkdir(parents=True, exist_ok=True)
    with open(REGISTRY_FILE, 'w') as f:
        json.dump(registry, f, indent=2)

_registry_lock = threading.Lock()

@app.route('/api/wallet/register', methods=['POST'])
@rate_limit(limit=10, window=60)
def api_wallet_register():
    """
    Register wallet address and get sequential number.
    Optionally set @alias (custom nickname).

    POST /api/wallet/register
    Body: { "address": "mt...", "alias": "@montana" }  // alias optional

    Response: { "number": 1, "address": "Ɉ-1-hash", "alias": "Ɉ-1", "custom_alias": "@montana" }

    Unified address formats:
    - Ɉ-{N}           — short (enough for transfers)
    - Ɉ-{N}-{hash}    — full (verifiable)
    - @nickname        — custom alias
    - mt{hash}         — crypto (internal)
    """
    data = request.get_json()

    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    address = data.get('address', '')
    custom_alias = data.get('alias', '').strip()

    # [FIX R7 CWE-862] Require proof of ownership for registration
    # [FIX R8 CWE-294] Include timestamp to prevent replay attacks
    mt_addr = address if address.startswith('mt') else None
    if mt_addr:
        timestamp_hdr = request.headers.get('X-Timestamp', '')
        pq_message = f"REGISTER:{mt_addr}:{custom_alias or ''}:{timestamp_hdr}"
        _, verified = _verify_pq_signature(request, message=pq_message)
        if not verified:
            client_ip = _get_client_ip()
            if client_ip not in ('127.0.0.1', '::1'):
                return jsonify({"error": "SIGNATURE_REQUIRED",
                                "message": "Wallet registration requires ML-DSA-65 signature"}), 403

    # Validate @alias format: @[a-zA-Z0-9_]{1,20}
    if custom_alias and not re.match(r'^@[a-zA-Z0-9_]{1,20}$', custom_alias):
        return jsonify({"error": "INVALID_ALIAS",
                        "message": "Alias must be @name (1-20 alphanumeric/underscore)"}), 400

    # Parse address
    if address.startswith('mt'):
        crypto_hash = address[2:]
    elif address.startswith('Ɉ-'):
        parts = address.split('-')
        if len(parts) >= 3:
            crypto_hash = parts[-1]
        else:
            return jsonify({"error": "INVALID_ADDRESS"}), 400
    else:
        return jsonify({"error": "INVALID_ADDRESS", "message": "Address must start with 'mt' or 'Ɉ-'"}), 400

    if len(crypto_hash) < 10:
        return jsonify({"error": "INVALID_ADDRESS", "message": "Hash too short"}), 400

    with _registry_lock:
        registry = load_registry()

        # Ensure aliases dict exists
        if "aliases" not in registry:
            registry["aliases"] = {}

        # Check @alias uniqueness
        if custom_alias:
            alias_lower = custom_alias.lower()
            existing_owner = registry["aliases"].get(alias_lower)
            if existing_owner and existing_owner != crypto_hash:
                return jsonify({"error": "ALIAS_TAKEN",
                                "message": f"{custom_alias} is already taken"}), 409

        # Register or get existing
        if crypto_hash in registry["wallets"]:
            wallet_data = registry["wallets"][crypto_hash]
            number = wallet_data["number"]
        else:
            number = registry["next_number"]
            registry["wallets"][crypto_hash] = {
                "number": number,
                "registered_at": datetime.utcnow().isoformat() + "Z"
            }
            registry["next_number"] = number + 1

        # Set @alias
        if custom_alias:
            # Remove old alias for this hash if any
            old_aliases = [k for k, v in registry["aliases"].items() if v == crypto_hash]
            for old in old_aliases:
                del registry["aliases"][old]
            registry["aliases"][custom_alias.lower()] = crypto_hash
            registry["wallets"][crypto_hash]["custom_alias"] = custom_alias

        save_registry(registry)

    stored_alias = registry["wallets"][crypto_hash].get("custom_alias", "")

    return jsonify({
        "status": "success",
        "number": number,
        "alias": f"Ɉ-{number}",
        "custom_alias": stored_alias,
        "address": f"Ɉ-{number}-{crypto_hash}",
        "crypto_hash": crypto_hash
    })

@app.route('/api/agent/register', methods=['POST'])
@rate_limit(limit=10, window=60)
def api_agent_register():
    """
    AI Agent wallet registration.
    Simplified flow for AI agents to create and manage wallets.

    POST /api/agent/register
    Body: {
        "agent_name": "MyAIAgent",     # required — agent identifier
        "public_key": "hex...",         # optional — ML-DSA-65 key
        "alias": "@myagent"            # optional — custom alias
    }

    Returns: { "address": "mt...", "number": N, "alias": "Ɉ-N", "balance": 0 }
    """
    data = request.get_json()
    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    agent_name = data.get('agent_name', '').strip()
    if not agent_name or len(agent_name) > 64:
        return jsonify({
            "error": "INVALID_AGENT_NAME",
            "message": "agent_name required (1-64 chars)"
        }), 400

    # [FIX CWE-20] Strict agent name validation — alphanumeric, hyphen, underscore only
    if not re.match(r'^[a-zA-Z0-9_-]{1,64}$', agent_name):
        return jsonify({
            "error": "INVALID_AGENT_NAME",
            "message": "agent_name: alphanumeric, hyphen, underscore only (1-64 chars)"
        }), 400

    # Reserved names cannot be registered
    RESERVED_AGENT_NAMES = {'admin', 'root', 'system', 'montana', 'api', 'www', 'server', 'node'}
    if agent_name.lower() in RESERVED_AGENT_NAMES:
        return jsonify({"error": "RESERVED_NAME", "message": "This agent name is reserved"}), 400

    public_key = data.get('public_key', '')
    custom_alias = data.get('alias', '').strip()

    # Generate address from public key or agent name + server entropy
    if public_key and len(public_key) == 3904:
        address = public_key_to_address(public_key)
    else:
        # [FIX CWE-330] Check if agent already registered (idempotent)
        # Use deterministic hash for same agent_name to ensure same address
        agent_hash = hashlib.sha256(f"agent:montana:{agent_name}".encode()).hexdigest()[:40]
        address = f"mt{agent_hash}"

    # Initialize wallet if new
    with _wallet_lock:
        wallets = load_wallets()
        if address not in wallets:
            if len(wallets) >= MAX_WALLETS:
                return jsonify({"error": "MAX_WALLETS_REACHED"}), 429
            wallets[address] = {
                'balance': 0.0,
                'created_at': datetime.utcnow().isoformat(),
                'type': 'ai_agent',
                'agent_name': agent_name
            }
            if public_key:
                wallets[address]['public_key'] = public_key
            save_wallets(wallets)

    # Register in wallet registry for sequential number
    with _registry_lock:
        registry = load_registry()
        if "aliases" not in registry:
            registry["aliases"] = {}

        crypto_hash = address[2:]  # remove 'mt' prefix

        if crypto_hash not in registry["wallets"]:
            number = registry["next_number"]
            registry["wallets"][crypto_hash] = {
                "number": number,
                "registered_at": datetime.utcnow().isoformat() + "Z",
                "type": "ai_agent",
                "agent_name": agent_name
            }
            registry["next_number"] = number + 1
        else:
            number = registry["wallets"][crypto_hash]["number"]

        # Set alias if provided
        if custom_alias and re.match(r'^@[a-zA-Z0-9_]{1,20}$', custom_alias):
            alias_lower = custom_alias.lower()
            existing_owner = registry["aliases"].get(alias_lower)
            if existing_owner and existing_owner != crypto_hash:
                save_registry(registry)
                return jsonify({"error": "ALIAS_TAKEN",
                                "message": f"{custom_alias} is already taken"}), 409
            old_aliases = [k for k, v in registry["aliases"].items() if v == crypto_hash]
            for old in old_aliases:
                del registry["aliases"][old]
            registry["aliases"][alias_lower] = crypto_hash
            registry["wallets"][crypto_hash]["custom_alias"] = custom_alias

        save_registry(registry)

    # Use EventLedger as single source of truth (not wallets.json cache)
    if EVENT_LEDGER_AVAILABLE:
        try:
            ledger = get_event_ledger()
            balance = ledger.balance(address)
        except Exception:
            balance = get_balance(address)
    else:
        balance = get_balance(address)
    stored_alias = registry["wallets"][crypto_hash].get("custom_alias", "")

    return jsonify({
        "status": "success",
        "address": address,
        "number": number,
        "alias": f"\u0248-{number}",
        "custom_alias": stored_alias,
        "balance": int(balance),
        "symbol": "\u0248",
        "agent_name": agent_name
    })


@app.route('/api/agent/transfer', methods=['POST'])
@rate_limit(limit=10, window=60)
def api_agent_transfer():
    """
    AI Agent transfer — simplified transfer for registered AI agents.
    No ML-DSA-65 signature required (agents use deterministic addresses).

    POST /api/agent/transfer
    Body: {
        "from_agent": "Amsterdam-Montana",   # agent_name (must match registration)
        "to_address": "mt..." or number,     # recipient (address, number, or @alias)
        "amount": 100                        # amount in Ɉ (integer)
    }

    Security: agent_name → deterministic address derivation (same as registration).
    Only wallets with type=ai_agent can use this endpoint.
    """
    # [FIX R6 CWE-284] Agent transfers only from trusted sources (localhost or peer nodes)
    client_ip = _get_client_ip()
    trusted_ips = {'127.0.0.1', '::1'} | {p['ip'] for p in PEER_NODES}
    if client_ip not in trusted_ips:
        log.warning(f"Agent transfer rejected from untrusted IP: {client_ip}")
        return jsonify({"error": "UNAUTHORIZED",
                        "message": "Agent transfers only from trusted nodes"}), 403

    data = request.get_json()
    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    agent_name = data.get('from_agent', '').strip()
    to_input = str(data.get('to_address', '')).strip()
    amount = data.get('amount')

    if not agent_name or not to_input or not amount:
        return jsonify({"error": "MISSING_FIELDS",
                        "message": "Required: from_agent, to_address, amount"}), 400

    # Validate agent name format
    if not re.match(r'^[a-zA-Z0-9_-]{1,64}$', agent_name):
        return jsonify({"error": "INVALID_AGENT_NAME"}), 400

    # Derive sender address deterministically (must match registration)
    agent_hash = hashlib.sha256(f"agent:montana:{agent_name}".encode()).hexdigest()[:40]
    from_addr = f"mt{agent_hash}"

    # Verify sender is a registered AI agent
    wallets = load_wallets()
    if from_addr not in wallets or wallets[from_addr].get('type') != 'ai_agent':
        return jsonify({"error": "NOT_AN_AGENT",
                        "message": "from_agent must be a registered AI agent"}), 403

    # Resolve recipient
    to_addr = to_input
    if not to_input.startswith('mt') or len(to_input) != 42:
        # Try resolve by number or alias
        registry = load_registry()
        aliases = registry.get("aliases", {})
        crypto_hash = None

        if to_input.startswith('@'):
            crypto_hash = aliases.get(to_input.lower())
        elif to_input.startswith('\u0248-'):
            try:
                num = int(to_input[2:])
                for h, w in registry["wallets"].items():
                    if w.get("number") == num:
                        crypto_hash = h
                        break
            except ValueError:
                pass
        elif to_input.isdigit():
            num = int(to_input)
            for h, w in registry["wallets"].items():
                if w.get("number") == num:
                    crypto_hash = h
                    break

        if crypto_hash:
            to_addr = f"mt{crypto_hash}"
        else:
            return jsonify({"error": "RECIPIENT_NOT_FOUND"}), 404

    # [FIX CWE-20] Validate resolved to_addr format
    if not _validate_address(to_addr):
        return jsonify({"error": "INVALID_ADDRESS",
                        "message": "Resolved recipient address is invalid"}), 400

    # Validate amount
    try:
        amount = int(amount)
        if amount <= 0:
            raise ValueError("Amount must be positive")
    except (ValueError, TypeError) as e:
        return jsonify({"error": "INVALID_AMOUNT", "message": str(e)}), 400

    # Self-send check
    if from_addr == to_addr:
        return jsonify({"error": "SELF_TRANSFER", "message": "Cannot transfer to self"}), 400

    # [FIX CWE-362 R5] Atomic balance check + transfer — single source of truth
    timestamp = datetime.utcnow().isoformat() + "Z"
    tx_nonce = os.urandom(16).hex()
    tx_id = hashlib.sha256(f"{from_addr}{to_addr}{amount}{timestamp}{tx_nonce}".encode()).hexdigest()

    # [FIX R5] Use EventLedger as primary (atomic, skip_balance_check=False),
    # wallets.json as fallback — mirrors /api/transfer pattern
    if EVENT_LEDGER_AVAILABLE:
        try:
            ledger = get_event_ledger()
            ok, msg, event = ledger.transfer(from_addr, to_addr, amount, metadata={
                "tx_id": tx_id,
                "type": "agent_transfer",
                "agent_name": agent_name,
                "pq_signed": False
            }, skip_balance_check=False)
            if not ok:
                return jsonify({"error": "TRANSFER_REJECTED", "message": msg}), 400
            if event:
                _push_event_to_peers(event.to_dict())
        except Exception as e:
            log.error(f"Agent transfer ledger error: {e}")
            return jsonify({"error": "LEDGER_ERROR", "message": str(e)}), 500
    else:
        # Fallback: wallets.json atomic transfer
        with _wallet_lock:
            wallets = load_wallets()
            sender_bal = wallets.get(from_addr, {}).get('balance', 0)
            if sender_bal < amount:
                return jsonify({"error": "INSUFFICIENT_FUNDS",
                                "message": f"Balance: {int(sender_bal)} Ɉ, required: {amount} Ɉ"}), 400

            wallets[from_addr]['balance'] = sender_bal - amount
            if to_addr not in wallets:
                wallets[to_addr] = {'balance': 0, 'type': 'p2p_sync'}
            wallets[to_addr]['balance'] = wallets.get(to_addr, {}).get('balance', 0) + amount
            wallets[from_addr]['last_seen'] = datetime.utcnow().isoformat()
            save_wallets(wallets)

    return jsonify({
        "status": "success",
        "tx_id": tx_id,
        "from": from_addr,
        "to": to_addr,
        "amount": amount,
        "sender_balance": int(get_balance(from_addr)),
        "timestamp": timestamp
    })


@app.route('/api/wallet/lookup/<identifier>')
def api_wallet_lookup(identifier):
    """
    Lookup wallet by any format.

    GET /api/wallet/lookup/1          -> Find by number
    GET /api/wallet/lookup/Ɉ-1        -> Find by Ɉ-number
    GET /api/wallet/lookup/@nickname   -> Find by @alias
    GET /api/wallet/lookup/abc123     -> Find by hash prefix
    """
    registry = load_registry()
    aliases = registry.get("aliases", {})
    crypto_hash = None
    number = None

    # @alias lookup
    if identifier.startswith('@'):
        alias_lower = identifier.lower()
        crypto_hash = aliases.get(alias_lower)
        if not crypto_hash:
            return jsonify({"error": "NOT_FOUND"}), 404
        wallet_data = registry["wallets"].get(crypto_hash, {})
        number = wallet_data.get("number")

    # Number lookup
    elif identifier.isdigit():
        number = int(identifier)

    # Ɉ-N lookup
    elif identifier.startswith('Ɉ-'):
        try:
            number = int(identifier[2:].split('-')[0])
        except (ValueError, IndexError):
            return jsonify({"error": "INVALID_FORMAT"}), 400

    # Hash prefix lookup
    else:
        for h, data in registry["wallets"].items():
            if h.startswith(identifier) or identifier in h:
                number = data["number"]
                crypto_hash = h
                break
        if number is None:
            return jsonify({"error": "NOT_FOUND"}), 404

    # Find by number
    if number and not crypto_hash:
        for h, data in registry["wallets"].items():
            if data["number"] == number:
                crypto_hash = h
                break

    if not crypto_hash:
        return jsonify({"error": "NOT_FOUND"}), 404

    wallet_data = registry["wallets"].get(crypto_hash, {})
    num = wallet_data.get("number", number)
    custom_alias = wallet_data.get("custom_alias", "")

    return jsonify({
        "number": num,
        "alias": f"Ɉ-{num}",
        "custom_alias": custom_alias,
        "address": f"Ɉ-{num}-{crypto_hash}",
        "crypto_hash": crypto_hash,
        "registered_at": wallet_data.get("registered_at")
    })

# ═══════════════════════════════════════════════════════════════════════════════
#                              TIMECHAIN ENDPOINTS
# ═══════════════════════════════════════════════════════════════════════════════

# Singleton: инициализируется один раз при первом вызове
_timechain_instance = None
_timechain_lock = threading.Lock()

def get_timechain():
    """
    Lazy singleton TimeChain.
    Auto-generates node keys if not exist (stored in data/timechain_keys.json).
    """
    global _timechain_instance
    if _timechain_instance is not None:
        return _timechain_instance

    with _timechain_lock:
        if _timechain_instance is not None:
            return _timechain_instance

        from timechain import TimeChain
        from node_crypto import generate_keypair, public_key_to_address

        keys_file = DATA_DIR / "timechain_keys.json"
        db_path = str(DATA_DIR / "timechain.db")

        if keys_file.exists():
            with open(keys_file) as f:
                keys = json.load(f)
            node_id = keys["node_id"]
            private_key = keys["private_key"]
            public_key = keys["public_key"]
        else:
            # Auto-generate ML-DSA-65 keys for this node
            DATA_DIR.mkdir(parents=True, exist_ok=True)
            private_key, public_key = generate_keypair()
            node_id = public_key_to_address(public_key)
            keys = {
                "node_id": node_id,
                "private_key": private_key,
                "public_key": public_key,
                "generated_at": datetime.utcnow().isoformat() + "Z",
            }
            with open(keys_file, "w") as f:
                json.dump(keys, f, indent=2)
            # Secure: restrict file permissions
            import stat
            keys_file.chmod(stat.S_IRUSR | stat.S_IWUSR)
            log.info(f"TimeChain: generated keys, node_id={node_id}")

        tc = TimeChain(
            node_id=node_id,
            private_key=private_key,
            public_key=public_key,
            db_path=db_path,
        )
        _timechain_instance = tc
        log.info(f"TimeChain initialized: τ₁={tc.tau1_count}, τ₂={tc.tau2_count}")
        return tc


@app.route('/api/timechain/stats')
def api_timechain_stats():
    """TimeChain statistics — window counts, supply, TIME_BANK"""
    try:
        tc = get_timechain()
        stats = tc.get_stats()
        # Add verification status
        ok, msg = tc.verify_full_chain()
        stats["verified"] = ok
        stats["verify_message"] = msg
        stats["node_id"] = tc.node_id
        return jsonify(stats)
    except Exception as e:
        return jsonify({
            "error": "TIMECHAIN_ERROR",
            "message": str(e)
        }), 500

@app.route('/api/timechain/windows')
def api_timechain_windows():
    """Get recent TimeChain windows (τ₁, τ₂, τ₃, τ₄)"""
    try:
        tc = get_timechain()
        limit = request.args.get('limit', 20, type=int)
        limit = min(limit, 100)
        layer = request.args.get('layer', 'tau1')

        if layer == 'tau1':
            windows = tc.get_recent_tau1_windows(limit=limit)
        elif layer == 'tau2':
            windows = tc.get_recent_tau2_windows(limit=limit)
        elif layer == 'tau3':
            windows = tc.get_recent_tau3_windows(limit=limit)
        elif layer == 'tau4':
            windows = tc.get_recent_tau4_windows(limit=limit)
        else:
            return jsonify({"error": "INVALID_LAYER", "message": "Use: tau1, tau2, tau3, tau4"}), 400

        return jsonify({
            "windows": windows,
            "layer": layer,
            "count": len(windows),
        })
    except Exception as e:
        return jsonify({
            "error": "TIMECHAIN_ERROR",
            "message": str(e)
        }), 500

@app.route('/api/timechain/verify')
@rate_limit(limit=2, window=60)  # [FIX R7 CWE-400] CPU-heavy — 2 req/min
def api_timechain_verify():
    """Full chain verification — horizontal + vertical + signatures + UTXO"""
    try:
        tc = get_timechain()
        ok, msg = tc.verify_full_chain()
        return jsonify({
            "verified": ok,
            "message": msg,
            "tau1_count": tc.tau1_count,
            "tau2_count": tc.tau2_count,
            "tau3_count": tc.tau3_count,
            "tau4_count": tc.tau4_count,
        })
    except Exception as e:
        return jsonify({
            "error": "TIMECHAIN_ERROR",
            "message": str(e)
        }), 500

@app.route('/api/timechain/balances')
@rate_limit(limit=5, window=60)  # [FIX R7 CWE-400] CPU-heavy — 5 req/min
def api_timechain_balances():
    """All UTXO-based balances"""
    try:
        tc = get_timechain()
        balances = tc.get_all_balances()
        return jsonify({
            "balances": balances,
            "total_supply": tc.utxo_set.total_unspent(),
            "count": len(balances),
        })
    except Exception as e:
        return jsonify({
            "error": "TIMECHAIN_ERROR",
            "message": str(e)
        }), 500

@app.route('/api/timechain/balance/<address>')
def api_timechain_balance(address: str):
    """UTXO balance for specific address"""
    if not _validate_address(address):
        return jsonify({"error": "INVALID_ADDRESS"}), 400
    try:
        tc = get_timechain()
        return jsonify(tc.get_balance(address))
    except Exception as e:
        return jsonify({
            "error": "TIMECHAIN_ERROR",
            "message": str(e)
        }), 500

# ═══════════════════════════════════════════════════════════════════════════════
#                              NTS ANCHOR ENDPOINTS
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/nts/servers')
def api_nts_servers():
    """List all 36 NTS servers with region grouping"""
    try:
        from nts_anchor import get_nts_server_list, get_nts_region_summary, REGION_NAMES
        servers = get_nts_server_list()
        regions = get_nts_region_summary()
        return jsonify({
            "servers": servers,
            "total": len(servers),
            "regions": {k: {"count": v, "name": REGION_NAMES.get(k, k)} for k, v in regions.items()},
        })
    except Exception as e:
        return jsonify({"error": "NTS_ERROR", "message": str(e)}), 500


@app.route('/api/nts/status')
def api_nts_status():
    """NTS anchor status — latest τ₂ anchor + overall statistics"""
    try:
        tc = get_timechain()
        anchor_count = tc.db.get_nts_anchor_count("tau2")

        # Get latest anchor if exists
        latest_anchor = None
        if tc.tau2_count > 0:
            anchor = tc.db.get_nts_anchor("tau2", tc.tau2_count - 1)
            if anchor:
                latest_anchor = anchor.to_dict()

        return jsonify({
            "nts_enabled": tc.nts_service is not None,
            "total_anchors": anchor_count,
            "tau2_count": tc.tau2_count,
            "coverage": f"{anchor_count}/{tc.tau2_count}" if tc.tau2_count > 0 else "0/0",
            "latest_anchor": latest_anchor,
        })
    except Exception as e:
        return jsonify({"error": "NTS_ERROR", "message": str(e)}), 500


@app.route('/api/nts/anchor/<int:tau2_number>')
def api_nts_anchor(tau2_number):
    """NTS anchor details for a specific τ₂ window"""
    try:
        tc = get_timechain()
        anchor = tc.db.get_nts_anchor("tau2", tau2_number)
        if not anchor:
            return jsonify({"error": "NOT_FOUND", "message": f"No NTS anchor for τ₂ #{tau2_number}"}), 404

        # Verify if service available
        verified = None
        if tc.nts_service:
            ok, msg = tc.nts_service.verify_anchor(anchor)
            verified = {"ok": ok, "message": msg}

        return jsonify({
            "anchor": anchor.to_dict(),
            "verified": verified,
        })
    except Exception as e:
        return jsonify({"error": "NTS_ERROR", "message": str(e)}), 500


# ═══════════════════════════════════════════════════════════════════════════════
#                              TIME BANK ENDPOINTS
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/timebank/stats')
def api_timebank_stats():
    """Time Bank statistics"""
    try:
        from time_bank import TimeBank
        tb = TimeBank()
        return jsonify(tb.get_stats())
    except Exception as e:
        return jsonify({
            "error": "TIMEBANK_ERROR",
            "message": str(e)
        }), 500

@app.route('/api/timebank/activity', methods=['POST'])
@rate_limit(limit=60, window=60)
def api_timebank_activity():
    """
    Record presence activity for Time Bank emission.

    Required fields:
    - address: Montana address (mt...)
    - signature: proof of presence signature
    - public_key: signer's public key
    """
    data = request.get_json()

    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    address = data.get('address')
    signature = data.get('signature')
    public_key = data.get('public_key')

    if not all([address, signature, public_key]):
        return jsonify({
            "error": "MISSING_FIELDS",
            "message": "Required: address, signature, public_key"
        }), 400

    # Verify address matches public key
    derived = public_key_to_address(public_key)
    if derived != address:
        return jsonify({"error": "ADDRESS_MISMATCH"}), 403

    # [FIX R9 CWE-840] Use client-supplied timestamp with freshness check
    client_timestamp = data.get('timestamp', '')
    if not client_timestamp:
        return jsonify({"error": "MISSING_TIMESTAMP", "message": "timestamp required"}), 400
    # Verify freshness — must be within 5 minutes
    try:
        client_dt = datetime.fromisoformat(client_timestamp.replace('Z', '+00:00'))
        server_dt = datetime.utcnow()
        # Strip tzinfo for comparison (both are UTC)
        if client_dt.tzinfo:
            from datetime import timezone
            server_dt = server_dt.replace(tzinfo=timezone.utc)
        drift = abs((server_dt - client_dt).total_seconds())
        if drift > 300:
            return jsonify({"error": "TIMESTAMP_EXPIRED", "message": "Timestamp drift > 5 min"}), 403
    except (ValueError, TypeError):
        return jsonify({"error": "INVALID_TIMESTAMP"}), 400

    message = f"PRESENCE:{address}:{client_timestamp[:16]}"  # Minute precision
    if not verify_signature(public_key, message, signature):
        return jsonify({"error": "INVALID_SIGNATURE"}), 403

    # Record activity
    try:
        from time_bank import TimeBank
        tb = TimeBank()
        result = tb.activity(address)
        return jsonify(result)
    except Exception as e:
        return jsonify({"error": "TIMEBANK_ERROR", "message": str(e)}), 500

def _verify_pq_signature(req, message=None):
    """
    Verify ML-DSA-65 (FIPS 204) post-quantum signature from request headers.
    Headers: X-Address, X-Timestamp, X-Signature, X-Public-Key, X-Signature-Algorithm
    Returns (address, verified) tuple.

    If message is provided, full signature verification is performed.
    Otherwise, only key→address ownership is checked.
    """
    sig_algo = req.headers.get('X-Signature-Algorithm', '')
    address = req.headers.get('X-Address', '') or req.headers.get('X-Device-ID', '')
    timestamp = req.headers.get('X-Timestamp', '')
    sig_hex = req.headers.get('X-Signature', '')
    pub_hex = req.headers.get('X-Public-Key', '')

    if not address or not _validate_address(address):
        return address, False

    # [FIX CWE-306] Unsigned requests are NOT verified — return False
    if not sig_hex or not pub_hex:
        log.warning("Unsigned request from %s — not verified", address)
        return address, False

    if sig_algo and sig_algo != 'ML-DSA-65':
        return address, False

    try:
        # Verify public key matches claimed address (pub_hex is hex string)
        derived = public_key_to_address(pub_hex)
        if derived != address:
            log.warning(f"PQ: address mismatch {address} vs derived {derived}")
            return address, False

        # Full ML-DSA-65 signature verification — message REQUIRED
        if not message:
            # [FIX CWE-306 R5] No message = cannot verify signature — reject
            log.warning(f"PQ: no message to verify for {address} — rejecting")
            return address, False

        if verify_signature(pub_hex, message, sig_hex):
            log.info(f"PQ: ML-DSA-65 verified for {address}")
            return address, True
        else:
            # [FIX CWE-306 R5] Signature FAILED = NOT verified — no backward compat
            log.warning(f"PQ: ML-DSA-65 signature FAILED for {address}")
            return address, False
    except Exception as e:
        # [FIX CWE-306 R5] Exception during verification = NOT verified
        log.warning(f"PQ verification error: {e}")
        return address, False


@app.route('/api/presence', methods=['POST'])
@rate_limit(limit=60, window=60)
def api_presence():
    """
    Lightweight presence heartbeat for iOS/macOS apps.
    Post-quantum: ML-DSA-65 signed (FIPS 204).

    Headers: X-Address, X-Timestamp, X-Signature (ML-DSA-65), X-Public-Key
    Body: {"seconds": N}  — seconds of presence since last report
    Returns: {"balance": N}

    Client signs: "PRESENCE:{address}:{seconds}:{timestamp}"
    """
    data = request.get_json() or {}
    seconds = int(data.get('seconds', 0))

    # Reconstruct message for ML-DSA-65 verification
    address_hdr = request.headers.get('X-Address', '')
    timestamp_hdr = request.headers.get('X-Timestamp', '')
    pq_message = f"PRESENCE:{address_hdr}:{seconds}:{timestamp_hdr}" if address_hdr and timestamp_hdr else None

    address, verified = _verify_pq_signature(request, message=pq_message)

    # [FIX R7 CWE-306] Enforce ML-DSA-65 signature — unsigned presence = coin minting attack
    if not verified:
        # Allow localhost (for internal tooling) but reject external unsigned
        client_ip = _get_client_ip()
        if client_ip not in ('127.0.0.1', '::1'):
            return jsonify({"error": "SIGNATURE_REQUIRED",
                            "message": "Presence requires ML-DSA-65 signature"}), 403

    # Backward compat: also check old header (only for address, not auth)
    if not address:
        address = request.headers.get('X-Device-ID', '')

    if not _validate_address(address):
        return jsonify({"error": "INVALID_ADDRESS"}), 400

    if seconds < 0 or seconds > 600:  # [FIX R7] max 600s per call (τ₂ window)
        return jsonify({"error": "INVALID_SECONDS"}), 400

    try:
        # ── Write to shared presence queue for timechain_node ──
        # Node reads this at τ₂ boundary to create coinbase emissions
        if seconds > 0:
            _queue_presence(address, seconds)

        # Register activity in TIME_BANK (legacy)
        if seconds > 0 and TIME_BANK_AVAILABLE:
            try:
                bank = get_time_bank()
                bank.activity(address, addr_type="presence_app")
            except Exception as e:
                log.warning(f"TIME_BANK activity error: {e}")

        # Get balance from TimeChain UTXO
        try:
            from timechain import TimeChain
            tc = TimeChain(
                db_path=str(Path(__file__).parent / "data" / "timechain.db"),
                node_id=address,
            )
            balance = tc.utxo_set.get_balance(address)
        except Exception:
            balance = 0

        return jsonify({"balance": int(balance), "pq_verified": verified})
    except Exception as e:
        return jsonify({"error": "PRESENCE_ERROR", "message": str(e)}), 500

# ═══════════════════════════════════════════════════════════════════════════════
#                              VERSION / AUTO-UPDATE
# ═══════════════════════════════════════════════════════════════════════════════

# Current app versions — update these on each release
APP_VERSIONS = {
    "macos": {
        "version": "3.17.0",
        "build": 129,
        "url": "https://efir.org/downloads/Montana.app.zip",
        "notes": "NTS Anchor: 36 global atomic time servers (RFC 8915) — chain recalculation impossible",
        "sha256": ""
    },
    "ios": {
        "version": "2.1.0",
        "build": 23,
        "url": "https://efir.org/downloads/Montana_2.1.0.ipa",
        "notes": "Full independence, standalone Montana Protocol"
    }
}

# Urgent update flag — when True, all clients switch to T1 mode (check every 60s)
_urgent_update = {"active": False, "activated_at": None}
_urgent_lock = threading.Lock()

# Admin key for urgent updates (stored on server, NOT in code)
ADMIN_KEY = os.environ.get("MONTANA_ADMIN_KEY", "")

# Urgent auto-deactivation timeout (1 hour)
URGENT_TIMEOUT_SECONDS = 3600

@app.route('/api/version/<platform>')
@rate_limit(limit=60, window=60)
def api_version(platform: str):
    """
    Check latest app version for auto-update.

    GET /api/version/macos → {"version": "1.1.0", "build": 2, "url": "..."}
    GET /api/version/ios   → {"version": "2.0.0", "build": 21, "url": "..."}
    """
    platform = platform.lower().strip()
    if platform not in APP_VERSIONS:
        return jsonify({"error": "UNKNOWN_PLATFORM",
                        "message": f"Supported: {', '.join(APP_VERSIONS.keys())}"}), 400

    # Auto-deactivate urgent mode after timeout
    with _urgent_lock:
        if _urgent_update["active"] and _urgent_update["activated_at"]:
            try:
                activated = datetime.fromisoformat(_urgent_update["activated_at"])
                if (datetime.utcnow() - activated).total_seconds() > URGENT_TIMEOUT_SECONDS:
                    _urgent_update["active"] = False
                    _urgent_update["activated_at"] = None
            except (ValueError, TypeError):
                pass

    info = APP_VERSIONS[platform]
    with _urgent_lock:
        urgent = _urgent_update["active"]

    return jsonify({
        "version": info["version"],
        "build": info["build"],
        "url": info["url"],
        "notes": info["notes"],
        "sha256": info.get("sha256", ""),
        "urgent": urgent,
        "timestamp": datetime.utcnow().isoformat() + "Z"
    })


@app.route('/api/update/urgent', methods=['POST'])
@rate_limit(limit=5, window=60)
def api_update_urgent():
    """
    Activate/deactivate urgent update mode (T1 = 60s check interval).
    REQUIRES X-Admin-Key header (stored in server env as MONTANA_ADMIN_KEY).

    POST /api/update/urgent
    Headers: X-Admin-Key: <key>
    Body: {"active": true, "version": "3.7.6", "url": "...", "notes": "...", "sha256": "..."}
    """
    # Authentication: require admin key
    admin_key = request.headers.get("X-Admin-Key", "")
    if not ADMIN_KEY or not hmac.compare_digest(admin_key, ADMIN_KEY):
        return jsonify({"error": "UNAUTHORIZED"}), 403

    data = request.get_json()
    if not data:
        return jsonify({"error": "JSON_REQUIRED"}), 400

    with _urgent_lock:
        # Update urgent flag
        if "active" in data:
            _urgent_update["active"] = bool(data["active"])
            _urgent_update["activated_at"] = datetime.utcnow().isoformat() if data["active"] else None

    # Optionally update version info at the same time
    if "version" in data and "macos" in APP_VERSIONS:
        APP_VERSIONS["macos"]["version"] = data["version"]
    if "build" in data and "macos" in APP_VERSIONS:
        APP_VERSIONS["macos"]["build"] = int(data["build"])
    if "url" in data and "macos" in APP_VERSIONS:
        APP_VERSIONS["macos"]["url"] = data["url"]
    if "notes" in data and "macos" in APP_VERSIONS:
        APP_VERSIONS["macos"]["notes"] = data["notes"]
    if "sha256" in data and "macos" in APP_VERSIONS:
        APP_VERSIONS["macos"]["sha256"] = data["sha256"]

    with _urgent_lock:
        return jsonify({
            "status": "ok",
            "urgent": _urgent_update["active"],
            "activated_at": _urgent_update["activated_at"],
            "current_version": APP_VERSIONS.get("macos", {})
        })


# ═══════════════════════════════════════════════════════════════════════════════
#                              ACTIVE ADDRESSES / NETWORK VIEW
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/addresses')
@rate_limit(limit=60, window=60)
def api_addresses():
    """
    List all active addresses with types — for Mac app network view.

    GET /api/addresses
    Returns: {
        "addresses": [
            {"address": "mt...", "balance": N, "type": "ai_agent"|"human"|"presence_app", ...}
        ],
        "total": N,
        "agents": N,
        "humans": N
    }
    """
    wallets = load_wallets()
    registry = load_registry()
    aliases = registry.get("aliases", {})

    addresses = []
    agent_count = 0
    human_count = 0

    for addr, data in wallets.items():
        if not addr.startswith("mt"):
            continue

        addr_type = data.get("type", "unknown")
        agent_name = data.get("agent_name", "")
        balance = data.get("balance", 0)

        # Determine type
        if addr_type == "ai_agent" or agent_name:
            display_type = "ai_agent"
            agent_count += 1
        elif addr_type in ("presence_app", "p2p_sync") or balance > 0:
            display_type = "human"
            human_count += 1
        else:
            display_type = "unknown"

        # Find alias
        crypto_hash = addr[2:]
        wallet_reg = registry.get("wallets", {}).get(crypto_hash, {})
        number = wallet_reg.get("number")
        custom_alias = wallet_reg.get("custom_alias", "")

        entry = {
            "address": addr,
            "balance": int(balance),
            "type": display_type,
            "alias": f"Ɉ-{number}" if number else "",
            "custom_alias": custom_alias,
            "agent_name": agent_name,
            "last_seen": data.get("last_seen", data.get("updated_at", "")),
        }
        addresses.append(entry)

    # Sort by balance descending
    addresses.sort(key=lambda x: x["balance"], reverse=True)

    return jsonify({
        "addresses": addresses,
        "total": len(addresses),
        "agents": agent_count,
        "humans": human_count,
        "node_id": NODE_ID,
        "timestamp": datetime.utcnow().isoformat() + "Z"
    })


# ═══════════════════════════════════════════════════════════════════════════════
#                              P2P NODE SYNC
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/node/events')
@rate_limit(limit=60, window=60)
def api_node_events():
    """
    Get events since a given event_id — for P2P pull-based sync.

    GET /api/node/events?since=<event_id>&limit=1000
    Returns: {"events": [...], "node_id": "...", "count": N}
    """
    if not EVENT_LEDGER_AVAILABLE:
        return jsonify({"error": "EVENT_LEDGER_UNAVAILABLE"}), 503

    since = request.args.get('since', '')
    address = request.args.get('address', '')
    limit = min(int(request.args.get('limit', 1000)), 5000)

    try:
        ledger = get_event_ledger()
        if address:
            # Per-address filtering (for История / History view)
            events = ledger.get_events(address=address, limit=limit)
            event_list = [e.to_dict() for e in events]
        elif since:
            # Sync mode: events since last known event_id
            events = ledger.get_events_since(since)
            event_list = [e.to_dict() for e in events[:limit]]
        else:
            # [FIX] Default: get latest events (newest first, sorted by timestamp_ns)
            events = ledger.get_events(limit=limit)
            event_list = [e.to_dict() for e in events]

        # Enrich events with aliases from registry
        registry = load_registry() or {}
        addr_to_alias = {}
        for crypto_hash, info in registry.get("wallets", {}).items():
            addr = f"mt{crypto_hash}"
            number = info.get("number", "?")
            custom_alias = info.get("custom_alias", "")
            display = custom_alias if custom_alias else f"\u0248-{number}"
            addr_to_alias[addr] = display

        for evt in event_list:
            to_addr = evt.get("to_addr", "")
            from_addr = evt.get("from_addr", "")
            evt["to_alias"] = addr_to_alias.get(to_addr, "")
            evt["from_alias"] = addr_to_alias.get(from_addr, "")
            # TIME_BANK emissions have no from_addr
            if evt.get("event_type") == "EMISSION" and not from_addr:
                evt["from_alias"] = "\u0248-0"

        return jsonify({
            "events": event_list,
            "node_id": ledger.node_id,
            "count": len(event_list),
            "last_hash": ledger._last_hash[:16]
        })
    except Exception as e:
        return jsonify({"error": "SYNC_ERROR", "message": str(e)}), 500


@app.route('/api/node/sync', methods=['POST'])
@rate_limit(limit=30, window=60)
def api_node_sync():
    """
    Bidirectional P2P sync — the core of Montana network.

    POST /api/node/sync
    Body: {
        "events": [...],          # events to push to this node
        "last_event_id": "...",   # last event the peer knows about
        "node_id": "..."          # peer's node_id
    }

    Returns: {
        "merged": N,              # events we accepted from peer
        "events": [...],          # events the peer doesn't have
        "node_id": "...",
        "count": N
    }
    """
    if not EVENT_LEDGER_AVAILABLE:
        return jsonify({"error": "EVENT_LEDGER_UNAVAILABLE"}), 503

    # [FIX R6 CWE-302] Only accept sync from trusted peers
    client_ip = _get_client_ip()
    trusted_ips = {'127.0.0.1', '::1'} | {p['ip'] for p in PEER_NODES}
    if client_ip not in trusted_ips:
        log.warning(f"Node sync rejected from untrusted IP: {client_ip}")
        return jsonify({"error": "UNTRUSTED_SOURCE"}), 403

    data = request.get_json()
    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    remote_events = data.get('events', [])
    last_known_id = data.get('last_event_id', '')

    # [FIX R6 CWE-400] Limit incoming events to prevent DoS
    MAX_SYNC_EVENTS = 1000
    if not isinstance(remote_events, list) or len(remote_events) > MAX_SYNC_EVENTS:
        return jsonify({"error": "TOO_MANY_EVENTS",
                        "message": f"Max {MAX_SYNC_EVENTS} events per sync"}), 400

    try:
        ledger = get_event_ledger()

        # Merge incoming events from peer
        merged = 0
        if remote_events:
            merged = ledger.merge_events(remote_events)
            if merged > 0:
                log.info(f"P2P SYNC: merged {merged} events from {data.get('node_id', '?')}")

                # Apply merged events to wallet cache
                _apply_ledger_events_to_wallets(remote_events[:merged] if merged <= len(remote_events) else remote_events)

        # Return events the peer doesn't have
        new_events = ledger.get_events_since(last_known_id)
        event_list = [e.to_dict() for e in new_events[:2000]]

        return jsonify({
            "merged": merged,
            "events": event_list,
            "node_id": ledger.node_id,
            "count": len(event_list)
        })
    except Exception as e:
        log.error(f"P2P sync error: {e}")
        return jsonify({"error": "SYNC_ERROR", "message": str(e)}), 500


@app.route('/api/node/peers')
def api_node_peers():
    """List all known peers — seed nodes + connected Mac apps"""
    peers = []
    for node in PEER_NODES:
        peers.append({
            "name": node["name"],
            "url": node["url"],
            "ip": node["ip"],
            "type": "full_node"
        })

    # Connected Mac app clients
    with _mac_peers_lock:
        for addr, info in list(_mac_peers.items()):
            peers.append({
                "name": f"mac-{addr[:8]}",
                "type": "client",
                "address": addr,
                "last_seen": info.get("last_seen")
            })

    return jsonify({
        "peers": peers,
        "total": len(peers),
        "node_id": NODE_ID
    })


@app.route('/api/node/register', methods=['POST'])
@rate_limit(limit=10, window=60)
def api_node_register():
    """
    Register a Mac app as a peer client.

    POST /api/node/register
    Body: {"address": "mt...", "public_key": "..."}
    """
    data = request.get_json()
    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    address = data.get('address', '')
    if not _validate_address(address):
        return jsonify({"error": "INVALID_ADDRESS"}), 400

    # [FIX R9 CWE-400] Cap peer registrations + evict stale entries
    MAX_MAC_PEERS = 10_000
    PEER_STALE_HOURS = 24
    with _mac_peers_lock:
        # Evict stale peers if at capacity
        if len(_mac_peers) >= MAX_MAC_PEERS:
            now = datetime.utcnow()
            stale_keys = [k for k, v in _mac_peers.items()
                          if (now - datetime.fromisoformat(v.get('last_seen', '2000-01-01'))).total_seconds() > PEER_STALE_HOURS * 3600]
            for k in stale_keys:
                del _mac_peers[k]
        if len(_mac_peers) >= MAX_MAC_PEERS:
            return jsonify({"error": "PEER_LIMIT_REACHED", "message": "Too many registered peers"}), 429
        _mac_peers[address] = {
            "registered_at": datetime.utcnow().isoformat(),
            "last_seen": datetime.utcnow().isoformat(),
            "ip": _get_client_ip(),
            "public_key": data.get('public_key', '')[:200]
        }

    log.info(f"NODE REGISTERED: {address[:16]}... from {_get_client_ip()}")

    return jsonify({
        "status": "registered",
        "address": address,
        "node_type": "client",
        "seed_nodes": [{"name": n["name"], "url": n["url"]} for n in PEER_NODES]
    })


# ═══════════════════════════════════════════════════════════════════════════════
#                              WALLET & REGISTRY SYNC (Full Balance Consensus)
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/node/wallet-sync', methods=['POST'])
@rate_limit(limit=30, window=60)
def api_node_wallet_sync():
    """
    Full wallet state sync between nodes.
    Ensures all nodes have identical balances (like Bitcoin UTXO consensus).

    POST /api/node/wallet-sync
    Body: {"node_id": "...", "wallets_hash": "sha256 of wallets.json"}
    Returns: {
        "wallets": {full wallets dict},
        "wallets_hash": "our hash",
        "ledger_events": N,
        "node_id": "..."
    }
    """
    # [FIX R6 CWE-200] Only allow trusted peers to access full wallet data
    client_ip = _get_client_ip()
    trusted_ips = {'127.0.0.1', '::1'} | {p['ip'] for p in PEER_NODES}
    if client_ip not in trusted_ips:
        return jsonify({"error": "UNTRUSTED_SOURCE"}), 403

    data = request.get_json() or {}
    remote_hash = data.get('wallets_hash', '')

    wallets = load_wallets()
    local_hash = hashlib.sha256(json.dumps(wallets, sort_keys=True).encode()).hexdigest()

    ledger_count = 0
    if EVENT_LEDGER_AVAILABLE:
        try:
            ledger_count = get_event_ledger()._event_counter
        except Exception:
            pass

    return jsonify({
        "wallets": wallets,
        "wallets_hash": local_hash,
        "hashes_match": local_hash == remote_hash,
        "ledger_events": ledger_count,
        "node_id": NODE_ID,
        "timestamp": datetime.utcnow().isoformat() + "Z"
    })


@app.route('/api/node/registry-sync', methods=['POST'])
@rate_limit(limit=30, window=60)
def api_node_registry_sync():
    """
    Full registry sync between nodes.
    Ensures all nodes know about all wallet numbers and aliases.

    POST /api/node/registry-sync
    Body: {"node_id": "..."}
    Returns: {"registry": {full registry dict}, "node_id": "..."}
    """
    # [FIX R6 CWE-200] Only allow trusted peers to access full registry
    client_ip = _get_client_ip()
    trusted_ips = {'127.0.0.1', '::1'} | {p['ip'] for p in PEER_NODES}
    if client_ip not in trusted_ips:
        return jsonify({"error": "UNTRUSTED_SOURCE"}), 403

    registry = load_registry()
    return jsonify({
        "registry": registry,
        "node_id": NODE_ID,
        "timestamp": datetime.utcnow().isoformat() + "Z"
    })


# ═══════════════════════════════════════════════════════════════════════════════
#                              LEDGER VERIFY
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/ledger/verify/<address>')
@rate_limit(limit=60, window=60)
def api_ledger_verify(address: str):
    """
    Verify balance against EventLedger.

    GET /api/ledger/verify/<address>
    Returns: {"ledger_balance": N, "cached_balance": N, "verified": bool}
    """
    if not _validate_address(address):
        return jsonify({"error": "INVALID_ADDRESS"}), 400

    cached_balance = int(get_balance(address))

    ledger_balance = 0
    if EVENT_LEDGER_AVAILABLE:
        try:
            ledger = get_event_ledger()
            ledger_balance = ledger.balance(address)
        except Exception as e:
            log.warning(f"Ledger verify error: {e}")

    return jsonify({
        "address": address,
        "ledger_balance": ledger_balance,
        "cached_balance": cached_balance,
        "verified": ledger_balance == cached_balance or ledger_balance == 0,
        "timestamp": datetime.utcnow().isoformat() + "Z"
    })


@app.route('/api/ledger/stats')
def api_ledger_stats():
    """EventLedger statistics"""
    if not EVENT_LEDGER_AVAILABLE:
        return jsonify({"error": "EVENT_LEDGER_UNAVAILABLE"}), 503

    try:
        ledger = get_event_ledger()
        return jsonify(ledger.stats())
    except Exception as e:
        return jsonify({"error": "LEDGER_ERROR", "message": str(e)}), 500


# ═══════════════════════════════════════════════════════════════════════════════
#                              P2P BACKGROUND SYNC
# ═══════════════════════════════════════════════════════════════════════════════

def _apply_ledger_events_to_wallets(events_data):
    """Apply merged EventLedger events to wallet JSON cache"""
    try:
        # [FIX R6 CWE-362] Use _wallet_lock for atomic wallet updates
        with _wallet_lock:
            wallets = load_wallets()
            changed = False

            for evt in events_data:
                evt_type = evt.get("event_type", "")
                to_addr = evt.get("to_addr", "")
                from_addr = evt.get("from_addr", "")
                amount = evt.get("amount", 0)

                # [FIX R6] Validate addresses before applying
                if to_addr and not _validate_address(to_addr):
                    continue
                if from_addr and not _validate_address(from_addr):
                    continue

                if evt_type == "EMISSION" and to_addr and amount > 0:
                    if to_addr not in wallets:
                        wallets[to_addr] = {"balance": 0, "type": "p2p_sync"}
                    wallets[to_addr]["balance"] = wallets[to_addr].get("balance", 0) + amount
                    changed = True

                elif evt_type == "TRANSFER" and from_addr and to_addr and amount > 0:
                    if from_addr in wallets:
                        wallets[from_addr]["balance"] = max(0, wallets[from_addr].get("balance", 0) - amount)
                    if to_addr not in wallets:
                        wallets[to_addr] = {"balance": 0, "type": "p2p_sync"}
                    wallets[to_addr]["balance"] = wallets[to_addr].get("balance", 0) + amount
                    changed = True

            if changed:
                save_wallets(wallets)
    except Exception as e:
        log.warning(f"Apply ledger events error: {e}")


def _detect_node_identity():
    """Detect which node we are based on local IP"""
    global NODE_ID
    import socket

    try:
        hostname = socket.gethostname()
        local_ips = set()

        # Get all local IPs
        for info in socket.getaddrinfo(hostname, None):
            local_ips.add(info[4][0])

        # Also try getting the outbound IP
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            s.connect(("8.8.8.8", 80))
            local_ips.add(s.getsockname()[0])
            s.close()
        except Exception:
            pass

        # Match against known nodes
        for node in PEER_NODES:
            if node["ip"] in local_ips:
                NODE_ID = node["name"]
                return NODE_ID

    except Exception as e:
        log.warning(f"Node identity detection error: {e}")

    NODE_ID = os.environ.get("MONTANA_NODE_ID", hostname if 'hostname' in dir() else "unknown")
    return NODE_ID


_push_executor = None

def _get_push_executor():
    """ThreadPoolExecutor с лимитом 3 потоков для push."""
    global _push_executor
    if _push_executor is None:
        from concurrent.futures import ThreadPoolExecutor
        _push_executor = ThreadPoolExecutor(max_workers=3, thread_name_prefix="event-push")
    return _push_executor


def _push_event_to_peers(event_dict: dict):
    """
    INSTANT PUSH: отправляет новое событие на все пиры немедленно.
    Только события созданные ЭТИМ узлом (без relay).
    ThreadPoolExecutor с лимитом 3 потоков.
    """
    # Без relay — только свои события
    if event_dict.get("node_id") != NODE_ID:
        return

    import urllib.request

    def _push_to_peer(peer):
        try:
            push_data = json.dumps({
                "event": event_dict,
                "source_node": NODE_ID,
                "timestamp_ns": time_module.time_ns()
            }).encode('utf-8')

            req = urllib.request.Request(
                f"{peer['url']}/api/node/push-event",
                data=push_data,
                headers={"Content-Type": "application/json"},
                method="POST"
            )
            with urllib.request.urlopen(req, timeout=5) as resp:
                result = json.loads(resp.read())
                if result.get("accepted"):
                    log.info(f"PUSH: event → {peer['name']} (instant)")
        except Exception as e:
            log.debug(f"PUSH to {peer['name']}: {e}")

    executor = _get_push_executor()
    for peer in PEER_NODES:
        if peer["name"] == NODE_ID:
            continue
        executor.submit(_push_to_peer, peer)


@app.route('/api/node/push-event', methods=['POST'])
def api_node_push_event():
    """
    Приём мгновенного push от пира.
    Моментальная финализация — T1 окно = 0.
    Только от known peers.
    """
    if not EVENT_LEDGER_AVAILABLE:
        return jsonify({"accepted": False, "reason": "no_ledger"}), 503

    # [FIX R6 CWE-302] Validate source by IP, not just claimed name
    client_ip = _get_client_ip()
    trusted_ips = {'127.0.0.1', '::1'} | {p['ip'] for p in PEER_NODES}
    if client_ip not in trusted_ips:
        log.warning(f"Push event rejected from untrusted IP: {client_ip}")
        return jsonify({"accepted": False, "reason": "untrusted_source"}), 403

    data = request.get_json(silent=True) or {}
    event_data = data.get("event")
    source_node = data.get("source_node", "unknown")

    # Also validate source_node name matches a known peer
    known_names = {p["name"] for p in PEER_NODES}
    if source_node not in known_names:
        return jsonify({"accepted": False, "reason": "unknown_peer"}), 403

    if not event_data or not isinstance(event_data, dict):
        return jsonify({"accepted": False, "reason": "invalid_event"}), 400

    try:
        ledger = get_event_ledger()
        merged = ledger.merge_events([event_data])

        if merged > 0:
            _apply_ledger_events_to_wallets([event_data])
            log.info(f"PUSH RECEIVED: {event_data.get('event_type')} from {source_node} (instant)")
            return jsonify({
                "accepted": True,
                "merged": merged,
                "node_id": NODE_ID,
                "timestamp_ns": time_module.time_ns()
            })
        else:
            return jsonify({
                "accepted": True,
                "merged": 0,
                "reason": "duplicate",
                "node_id": NODE_ID
            })

    except Exception as e:
        log.error(f"Push event error: {e}")
        return jsonify({"accepted": False, "reason": str(e)}), 500


# ═══════════════════════════════════════════════════════════════════════════════
#                       AUCTION SYSTEM — Ascending Auction Model
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/auction/price/<service_type>')
def api_auction_price(service_type):
    """
    Получить текущую цену для следующей покупки сервиса.

    GET /api/auction/price/domain
    Response: {"service_type": "domain", "next_price": 42, "total_sold": 41}
    """
    try:
        from montana_auction import get_auction_registry, ServiceType

        if service_type not in ServiceType.all():
            return jsonify({
                "error": "INVALID_SERVICE_TYPE",
                "valid_types": ServiceType.all()
            }), 400

        auction = get_auction_registry(DATA_DIR)
        next_price = auction.get_current_price(service_type)
        total_sold = auction.get_total_sold(service_type)

        return jsonify({
            "service_type": service_type,
            "next_price": next_price,
            "total_sold": total_sold
        })

    except Exception as e:
        log.error(f"Auction price error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/auction/stats')
def api_auction_stats():
    """
    Статистика аукциона по всем сервисам.

    GET /api/auction/stats
    Response: {
        "total_services_sold": 100,
        "total_revenue": 5050,
        "services": {
            "domain": {"total_sold": 50, "next_price": 51, "revenue": 1275},
            "vpn": {"total_sold": 30, "next_price": 31, "revenue": 465},
            ...
        }
    }
    """
    try:
        from montana_auction import get_auction_registry

        auction = get_auction_registry(DATA_DIR)
        stats = auction.get_stats()

        return jsonify(stats)

    except Exception as e:
        log.error(f"Auction stats error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/auction/history/<service_type>')
def api_auction_history(service_type):
    """
    История покупок для сервиса.

    GET /api/auction/history/domain?limit=50
    """
    try:
        from montana_auction import get_auction_registry, ServiceType

        if service_type not in ServiceType.all():
            return jsonify({
                "error": "INVALID_SERVICE_TYPE",
                "valid_types": ServiceType.all()
            }), 400

        limit = min(int(request.args.get('limit', 100)), 500)

        auction = get_auction_registry(DATA_DIR)
        history = auction.get_purchase_history(service_type, limit)

        return jsonify({
            "service_type": service_type,
            "purchases": history,
            "count": len(history)
        })

    except Exception as e:
        log.error(f"Auction history error: {e}")
        return jsonify({"error": str(e)}), 500


# ═══════════════════════════════════════════════════════════════════════════════
#                       DOMAIN SERVICE — Montana Name Service (MNS)
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/domain/available/<domain>')
def api_domain_available(domain):
    """
    Проверить доступность домена.

    GET /api/domain/available/alice
    Response: {"domain": "alice", "available": true, "price": 42}
    """
    try:
        from montana_auction import get_domain_service, get_auction_registry, ServiceType

        # Убрать @efir.org если есть
        domain = domain.lower().replace("@efir.org", "")

        domains = get_domain_service(DATA_DIR)
        auction = get_auction_registry(DATA_DIR)

        available = domains.is_available(domain)
        price = auction.get_current_price(ServiceType.DOMAIN)

        return jsonify({
            "domain": domain,
            "full_domain": f"{domain}@efir.org",
            "available": available,
            "price": price if available else None
        })

    except Exception as e:
        log.error(f"Domain availability check error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/domain/lookup/<domain>')
def api_domain_lookup(domain):
    """
    Найти владельца домена.

    GET /api/domain/lookup/alice
    Response: {
        "domain": "alice@efir.org",
        "owner": "mt1234...5678",
        "registered": "2026-02-13T12:00:00Z",
        "price_paid": 42
    }
    """
    try:
        from montana_auction import get_domain_service

        domains = get_domain_service(DATA_DIR)
        info = domains.lookup(domain)

        if not info:
            return jsonify({"error": "DOMAIN_NOT_FOUND"}), 404

        return jsonify(info)

    except Exception as e:
        log.error(f"Domain lookup error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/domain/register', methods=['POST'])
@rate_limit(limit=5, window=60)
def api_domain_register():
    """
    Зарегистрировать домен через аукцион.

    POST /api/domain/register
    Body: {
        "domain": "alice",
        "owner_address": "mt1234...5678",
        "amount": 42
    }

    Response: {
        "success": true,
        "domain": "alice@efir.org",
        "owner": "mt1234...5678",
        "price_paid": 42,
        "purchase_number": 42
    }
    """
    data = request.get_json()
    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    domain = data.get('domain', '').lower()
    owner_address = data.get('owner_address', '')
    amount = data.get('amount', 0)

    # Валидация
    if not domain:
        return jsonify({"error": "DOMAIN_REQUIRED"}), 400

    if not _validate_address(owner_address):
        return jsonify({"error": "INVALID_ADDRESS"}), 400

    if not isinstance(amount, int) or amount <= 0:
        return jsonify({"error": "INVALID_AMOUNT"}), 400

    # [FIX R6 CWE-862] Require proof of ownership — signature or localhost
    # [FIX R8 CWE-294] Include timestamp to prevent replay attacks
    timestamp_hdr = request.headers.get('X-Timestamp', '')
    pq_message = f"DOMAIN_REGISTER:{owner_address}:{domain}:{amount}:{timestamp_hdr}"
    address, verified = _verify_pq_signature(request, message=pq_message)
    if not verified:
        client_ip = _get_client_ip()
        if client_ip not in ('127.0.0.1', '::1'):
            return jsonify({"error": "SIGNATURE_REQUIRED",
                            "message": "Domain registration requires ML-DSA-65 signature"}), 403

    try:
        from montana_auction import get_domain_service

        # [FIX R6 CWE-362] Atomic balance check + debit under lock
        with _wallet_lock:
            wallets = load_wallets()
            balance = wallets.get(owner_address, {}).get('balance', 0)

            if balance < amount:
                return jsonify({
                    "error": "INSUFFICIENT_BALANCE",
                    "balance": balance,
                    "required": amount
                }), 400

            # Зарегистрировать домен через аукцион
            domains = get_domain_service(DATA_DIR)
            result = domains.register(
                domain=domain,
                owner_address=owner_address,
                price_paid=amount
            )

            # Списать Ɉ с баланса (inside lock)
            wallets[owner_address]['balance'] -= amount
            save_wallets(wallets)

        log.info(
            f"Domain registered: {domain}@efir.org → {owner_address[:10]}... "
            f"for {amount} Ɉ"
        )

        # Создать событие в EventLedger если доступен
        if EVENT_LEDGER_AVAILABLE:
            try:
                ledger = get_event_ledger()
                ledger.add_event(
                    event_type=EventType.DOMAIN_REGISTER,
                    from_address=owner_address,
                    to_address="efir.org",
                    amount=amount,
                    metadata={
                        "domain": f"{domain}@efir.org",
                        "purchase_number": result["purchase_number"]
                    }
                )
            except Exception as ledger_err:
                log.error(f"EventLedger error: {ledger_err}")

        return jsonify(result)

    except ValueError as ve:
        return jsonify({"error": str(ve)}), 400
    except Exception as e:
        log.error(f"Domain register error: {e}")
        return jsonify({"error": str(e)}), 500


# ═══════════════════════════════════════════════════════════════════════════════
#                   PHONE SERVICE — Virtual Phone Numbers & Calls
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/phone/available/<int:number>')
def api_phone_available(number):
    """
    Проверить доступность виртуального номера.

    GET /api/phone/available/42
    Response: {"number": 42, "formatted": "+montana-000042", "available": true, "price": 123}
    """
    try:
        from montana_auction import get_phone_service, get_auction_registry, ServiceType

        phones = get_phone_service(DATA_DIR)
        auction = get_auction_registry(DATA_DIR)

        available = phones.is_available(number)
        price = auction.get_current_price(ServiceType.PHONE_NUMBER)
        formatted = phones.format_number(number)

        return jsonify({
            "number": number,
            "formatted": formatted,
            "available": available,
            "price": price if available else None
        })

    except Exception as e:
        log.error(f"Phone availability check error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/phone/lookup/<int:number>')
def api_phone_lookup(number):
    """
    Найти владельца виртуального номера.

    GET /api/phone/lookup/42
    Response: {
        "phone_number": "+montana-000042",
        "owner": "mt1234...5678",
        "registered": "2026-02-13T12:00:00Z",
        "price_paid": 42
    }
    """
    try:
        from montana_auction import get_phone_service

        phones = get_phone_service(DATA_DIR)
        info = phones.lookup(number)

        if not info:
            return jsonify({"error": "PHONE_NUMBER_NOT_FOUND"}), 404

        return jsonify(info)

    except Exception as e:
        log.error(f"Phone lookup error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/phone/register', methods=['POST'])
@rate_limit(limit=5, window=60)
def api_phone_register():
    """
    Зарегистрировать виртуальный номер через аукцион.

    POST /api/phone/register
    Body: {
        "number": 42,
        "owner_address": "mt1234...5678",
        "amount": 123
    }

    Response: {
        "success": true,
        "phone_number": "+montana-000042",
        "owner": "mt1234...5678",
        "price_paid": 123,
        "purchase_number": 123
    }
    """
    data = request.get_json()
    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    number = data.get('number', 0)
    owner_address = data.get('owner_address', '')
    amount = data.get('amount', 0)

    # Валидация
    if not isinstance(number, int) or number <= 0:
        return jsonify({"error": "INVALID_NUMBER"}), 400

    if not _validate_address(owner_address):
        return jsonify({"error": "INVALID_ADDRESS"}), 400

    if not isinstance(amount, int) or amount <= 0:
        return jsonify({"error": "INVALID_AMOUNT"}), 400

    # [FIX R6 CWE-862] Require proof of ownership — signature or localhost
    # [FIX R8 CWE-294] Include timestamp to prevent replay attacks
    timestamp_hdr = request.headers.get('X-Timestamp', '')
    pq_message = f"PHONE_REGISTER:{owner_address}:{number}:{amount}:{timestamp_hdr}"
    address, verified = _verify_pq_signature(request, message=pq_message)
    if not verified:
        client_ip = _get_client_ip()
        if client_ip not in ('127.0.0.1', '::1'):
            return jsonify({"error": "SIGNATURE_REQUIRED",
                            "message": "Phone registration requires ML-DSA-65 signature"}), 403

    try:
        from montana_auction import get_phone_service

        # [FIX R6 CWE-362] Atomic balance check + debit under lock
        with _wallet_lock:
            wallets = load_wallets()
            balance = wallets.get(owner_address, {}).get('balance', 0)

            if balance < amount:
                return jsonify({
                    "error": "INSUFFICIENT_BALANCE",
                    "balance": balance,
                    "required": amount
                }), 400

            # Зарегистрировать номер через аукцион
            phones = get_phone_service(DATA_DIR)
            result = phones.register(
                number=number,
                owner_address=owner_address,
                price_paid=amount
            )

            # Списать Ɉ с баланса (inside lock)
            wallets[owner_address]['balance'] -= amount
            save_wallets(wallets)

        log.info(
            f"Phone registered: {result['phone_number']} → {owner_address[:10]}... "
            f"for {amount} Ɉ"
        )

        # Создать событие в EventLedger если доступен
        if EVENT_LEDGER_AVAILABLE:
            try:
                ledger = get_event_ledger()
                ledger.add_event(
                    event_type=EventType.PHONE_REGISTER,
                    from_address=owner_address,
                    to_address="montana.phone",
                    amount=amount,
                    metadata={
                        "phone_number": result['phone_number'],
                        "purchase_number": result["purchase_number"]
                    }
                )
            except Exception as ledger_err:
                log.error(f"EventLedger error: {ledger_err}")

        return jsonify(result)

    except ValueError as ve:
        return jsonify({"error": str(ve)}), 400
    except Exception as e:
        log.error(f"Phone register error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/call/pricing')
def api_call_pricing():
    """
    Получить текущие цены на звонки.

    GET /api/call/pricing
    Response: {
        "audio_per_second": 1 Ɉ (fixed for number owners),
        "video_per_second": 1 Ɉ (fixed for number owners),
        "requires_phone_number": true
    }
    """
    try:
        return jsonify({
            "audio_per_second": 1,
            "video_per_second": 1,
            "requires_phone_number": True,
            "note": "Fixed pricing for phone number owners: 1 Ɉ per second"
        })

    except Exception as e:
        log.error(f"Call pricing error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/call/calculate', methods=['POST'])
def api_call_calculate():
    """
    Рассчитать стоимость звонка.

    POST /api/call/calculate
    Body: {
        "call_type": "audio" or "video",
        "duration_seconds": 60
    }

    Response: {
        "call_type": "audio",
        "duration_seconds": 60,
        "cost": 60,
        "price_per_second": 1
    }
    """
    data = request.get_json()
    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    call_type = data.get('call_type', 'audio')
    duration = data.get('duration_seconds', 0)

    if call_type not in ['audio', 'video']:
        return jsonify({"error": "INVALID_CALL_TYPE"}), 400

    if not isinstance(duration, int) or duration <= 0:
        return jsonify({"error": "INVALID_DURATION"}), 400

    try:
        # Fixed pricing: 1 Ɉ per second for number owners
        price_per_second = 1
        cost = duration * price_per_second

        return jsonify({
            "call_type": call_type,
            "duration_seconds": duration,
            "cost": cost,
            "price_per_second": price_per_second
        })

    except Exception as e:
        log.error(f"Call calculation error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/call/record', methods=['POST'])
@rate_limit(limit=30, window=60)
def api_call_record():
    """
    Записать завершенный звонок и списать Ɉ.

    POST /api/call/record
    Body: {
        "caller_address": "mt1234...",
        "callee_address": "mt5678...",
        "call_type": "audio" or "video",
        "duration_seconds": 60
    }

    Response: {
        "success": true,
        "call_type": "audio",
        "duration_seconds": 60,
        "cost": 60,
        "caller_balance": 1234
    }
    """
    data = request.get_json()
    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    caller_address = data.get('caller_address', '')
    callee_address = data.get('callee_address', '')
    call_type = data.get('call_type', 'audio')
    duration = data.get('duration_seconds', 0)

    # Валидация
    if not _validate_address(caller_address):
        return jsonify({"error": "INVALID_CALLER_ADDRESS"}), 400

    if not _validate_address(callee_address):
        return jsonify({"error": "INVALID_CALLEE_ADDRESS"}), 400

    if call_type not in ['audio', 'video']:
        return jsonify({"error": "INVALID_CALL_TYPE"}), 400

    if not isinstance(duration, int) or duration <= 0 or duration > 86400:
        return jsonify({"error": "INVALID_DURATION"}), 400

    # [FIX R6 CWE-862] Require proof of ownership — signature or localhost
    # [FIX R8 CWE-294] Include timestamp to prevent replay attacks
    timestamp_hdr = request.headers.get('X-Timestamp', '')
    pq_message = f"CALL_RECORD:{caller_address}:{callee_address}:{call_type}:{duration}:{timestamp_hdr}"
    address, verified = _verify_pq_signature(request, message=pq_message)
    if not verified:
        client_ip = _get_client_ip()
        if client_ip not in ('127.0.0.1', '::1'):
            return jsonify({"error": "SIGNATURE_REQUIRED",
                            "message": "Call recording requires ML-DSA-65 signature"}), 403

    try:
        from montana_auction import get_phone_service

        phones = get_phone_service(DATA_DIR)

        # Fixed pricing: 1 Ɉ per second
        cost = duration * 1

        # [FIX R6 CWE-362] Atomic balance check + debit under lock
        with _wallet_lock:
            wallets = load_wallets()

            if caller_address not in wallets:
                return jsonify({"error": "CALLER_NOT_FOUND"}), 404

            if wallets[caller_address]['balance'] < cost:
                return jsonify({
                    "error": "INSUFFICIENT_BALANCE",
                    "balance": wallets[caller_address]['balance'],
                    "required": cost
                }), 400

            # Списать Ɉ с баланса звонящего (inside lock)
            wallets[caller_address]['balance'] -= cost
            save_wallets(wallets)

        log.info(
            f"Call recorded: {caller_address[:10]}... → {callee_address[:10]}... "
            f"{call_type} {duration}s ({cost} Ɉ)"
        )

        # Создать событие в EventLedger
        if EVENT_LEDGER_AVAILABLE:
            try:
                ledger = get_event_ledger()
                ledger.add_event(
                    event_type=f"call_{call_type}",
                    from_address=caller_address,
                    to_address=callee_address,
                    amount=cost,
                    metadata={
                        "call_type": call_type,
                        "duration_seconds": duration,
                        "price_per_second": 1
                    }
                )
            except Exception as ledger_err:
                log.error(f"EventLedger error: {ledger_err}")

        return jsonify({
            "success": True,
            "call_type": call_type,
            "duration_seconds": duration,
            "cost": cost,
            "caller_balance": wallets[caller_address]['balance']
        })

    except ValueError as ve:
        return jsonify({"error": str(ve)}), 400
    except Exception as e:
        log.error(f"Call record error: {e}")
        return jsonify({"error": str(e)}), 500


# ═══════════════════════════════════════════════════════════════════════════════
#           REAL PHONE BINDING — SMS Verification for Real Numbers
# ═══════════════════════════════════════════════════════════════════════════════

@app.route('/api/phone/bind/request', methods=['POST'])
@rate_limit(limit=5, window=60)
def api_phone_bind_request():
    """
    Запросить привязку реального телефонного номера.
    Отправляет SMS с кодом верификации.

    POST /api/phone/bind/request
    Body: {
        "phone": "+7-921-123-4567",
        "montana_address": "mt1234...5678"
    }

    Response: {
        "status": "code_sent",
        "phone": "+79211234567",
        "expires": "2026-02-13T12:10:00Z"
    }
    """
    data = request.get_json()
    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    phone = data.get('phone', '')
    montana_address = data.get('montana_address', '')

    # Валидация
    if not phone:
        return jsonify({"error": "PHONE_REQUIRED"}), 400

    if not _validate_address(montana_address):
        return jsonify({"error": "INVALID_ADDRESS"}), 400

    try:
        from montana_real_phone import get_real_phone_service

        real_phones = get_real_phone_service(DATA_DIR)
        result = real_phones.request_verification(
            phone=phone,
            montana_address=montana_address
        )

        log.info(
            f"Phone bind requested: {result['phone']} → {montana_address[:10]}..."
        )

        return jsonify(result)

    except ValueError as ve:
        return jsonify({"error": str(ve)}), 400
    except Exception as e:
        log.error(f"Phone bind request error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/phone/bind/verify', methods=['POST'])
@rate_limit(limit=10, window=60)
def api_phone_bind_verify():
    """
    Проверить код верификации и завершить привязку номера.

    POST /api/phone/bind/verify
    Body: {
        "phone": "+7-921-123-4567",
        "code": "123456"
    }

    Response: {
        "status": "verified",
        "phone": "+79211234567",
        "montana_address": "mt1234...5678",
        "verified": "2026-02-13T12:05:00Z"
    }
    """
    data = request.get_json()
    if not data:
        return jsonify({"error": "NO_DATA"}), 400

    phone = data.get('phone', '')
    code = data.get('code', '')

    # Валидация
    if not phone:
        return jsonify({"error": "PHONE_REQUIRED"}), 400

    if not code or len(code) != 6:
        return jsonify({"error": "INVALID_CODE"}), 400

    try:
        from montana_real_phone import get_real_phone_service

        real_phones = get_real_phone_service(DATA_DIR)
        result = real_phones.verify_code(
            phone=phone,
            code=code
        )

        log.info(
            f"Phone verified: {result['phone']} → {result['montana_address'][:10]}..."
        )

        # Создать событие в EventLedger
        if EVENT_LEDGER_AVAILABLE:
            try:
                ledger = get_event_ledger()
                ledger.add_event(
                    event_type="phone_verified",
                    from_address=result['montana_address'],
                    to_address="montana.phone",
                    amount=0,  # Привязка бесплатная
                    metadata={
                        "phone": result['phone'],
                        "verified": result['verified']
                    }
                )
            except Exception as ledger_err:
                log.error(f"EventLedger error: {ledger_err}")

        return jsonify(result)

    except ValueError as ve:
        return jsonify({"error": str(ve)}), 400
    except Exception as e:
        log.error(f"Phone bind verify error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/phone/bind/lookup/<phone>')
def api_phone_bind_lookup(phone):
    """
    Найти Montana адрес по реальному телефонному номеру.

    GET /api/phone/bind/lookup/+79211234567
    Response: {
        "phone": "+79211234567",
        "montana_address": "mt1234...5678",
        "verified": "2026-02-13T12:00:00Z"
    }
    """
    try:
        from montana_real_phone import get_real_phone_service

        real_phones = get_real_phone_service(DATA_DIR)
        info = real_phones.lookup(phone)

        if not info:
            return jsonify({"error": "PHONE_NOT_FOUND"}), 404

        return jsonify(info)

    except Exception as e:
        log.error(f"Phone bind lookup error: {e}")
        return jsonify({"error": str(e)}), 500


@app.route('/api/phone/bind/address/<address>')
def api_phone_bind_address(address):
    """
    Найти все реальные номера привязанные к Montana адресу.

    GET /api/phone/bind/address/mt1234...5678
    Response: {
        "montana_address": "mt1234...5678",
        "phones": ["+79211234567", "+15551234567"]
    }
    """
    if not _validate_address(address):
        return jsonify({"error": "INVALID_ADDRESS"}), 400

    try:
        from montana_real_phone import get_real_phone_service

        real_phones = get_real_phone_service(DATA_DIR)
        phones = real_phones.get_by_address(address)

        return jsonify({
            "montana_address": address,
            "phones": phones,
            "count": len(phones)
        })

    except Exception as e:
        log.error(f"Phone bind address lookup error: {e}")
        return jsonify({"error": str(e)}), 500


def _p2p_sync_loop():
    """
    Background thread: periodically sync events with peer nodes.
    Runs every 30 seconds. Pulls new events from all peers.
    """
    import urllib.request

    # Wait for app to start
    time_module.sleep(10)

    log.info(f"P2P SYNC: background thread started (node={NODE_ID})")

    # Track last known event_id per peer
    last_known = {}

    while True:
        try:
            if not EVENT_LEDGER_AVAILABLE:
                time_module.sleep(60)
                continue

            ledger = get_event_ledger()

            for peer in PEER_NODES:
                # Skip self
                if peer["name"] == NODE_ID:
                    continue

                try:
                    # Get our events to send
                    peer_last = last_known.get(peer["name"], "")
                    our_events = ledger.get_events_since(peer_last)
                    our_event_list = [e.to_dict() for e in our_events[:500]]

                    # Bidirectional sync via POST /api/node/sync
                    sync_data = json.dumps({
                        "events": our_event_list,
                        "last_event_id": peer_last,
                        "node_id": NODE_ID
                    }).encode('utf-8')

                    req = urllib.request.Request(
                        f"{peer['url']}/api/node/sync",
                        data=sync_data,
                        headers={
                            "Content-Type": "application/json",
                            "Accept": "application/json"
                        },
                        method="POST"
                    )

                    with urllib.request.urlopen(req, timeout=15) as resp:
                        resp_data = json.loads(resp.read())

                        # Merge events from peer
                        remote_events = resp_data.get("events", [])
                        if remote_events:
                            merged = ledger.merge_events(remote_events)
                            if merged > 0:
                                log.info(f"P2P SYNC: merged {merged} events from {peer['name']}")
                                _apply_ledger_events_to_wallets(remote_events)

                        # Update tracking
                        if remote_events:
                            last_known[peer["name"]] = remote_events[-1].get("event_id", "")
                        elif our_event_list:
                            last_known[peer["name"]] = our_event_list[-1].get("event_id", "")

                        peer_merged = resp_data.get("merged", 0)
                        if peer_merged > 0:
                            log.info(f"P2P SYNC: {peer['name']} accepted {peer_merged} of our events")

                except Exception as e:
                    log.debug(f"P2P sync with {peer['name']}: {e}")

                # ── WALLET STATE SYNC ──
                try:
                    wallets = load_wallets()
                    wallets_hash = hashlib.sha256(
                        json.dumps(wallets, sort_keys=True).encode()
                    ).hexdigest()

                    ws_data = json.dumps({
                        "node_id": NODE_ID,
                        "wallets_hash": wallets_hash
                    }).encode('utf-8')

                    ws_req = urllib.request.Request(
                        f"{peer['url']}/api/node/wallet-sync",
                        data=ws_data,
                        headers={"Content-Type": "application/json"},
                        method="POST"
                    )

                    with urllib.request.urlopen(ws_req, timeout=15) as ws_resp:
                        ws_result = json.loads(ws_resp.read())
                        remote_wallets = ws_result.get("wallets", {})
                        remote_hash = ws_result.get("wallets_hash", "")

                        # [FIX R6 CWE-347] Do NOT trust remote balances — only register
                        # new addresses with ZERO balance. Actual balances come from
                        # EventLedger events (cryptographically validated).
                        if remote_hash != wallets_hash and isinstance(remote_wallets, dict):
                            merged_count = 0
                            for addr, info in remote_wallets.items():
                                # Validate address format (mt + 40 hex = 42 chars)
                                if not isinstance(addr, str) or len(addr) != 42 or not addr.startswith("mt"):
                                    continue
                                if not isinstance(info, dict):
                                    continue
                                # Only add NEW wallets (not seen locally) — with zero balance
                                # Balance will be populated by EventLedger events
                                if addr not in wallets:
                                    wallets[addr] = {"balance": 0, "type": info.get("type", "p2p_sync")}
                                    merged_count += 1
                            if merged_count > 0:
                                save_wallets(wallets)
                                log.info(f"WALLET SYNC: registered {merged_count} new addresses from {peer['name']}")

                except Exception as ws_e:
                    log.debug(f"Wallet sync with {peer['name']}: {ws_e}")

                # ── REGISTRY SYNC ──
                try:
                    registry = load_registry()

                    rs_data = json.dumps({
                        "node_id": NODE_ID
                    }).encode('utf-8')

                    rs_req = urllib.request.Request(
                        f"{peer['url']}/api/node/registry-sync",
                        data=rs_data,
                        headers={"Content-Type": "application/json"},
                        method="POST"
                    )

                    with urllib.request.urlopen(rs_req, timeout=15) as rs_resp:
                        rs_result = json.loads(rs_resp.read())
                        remote_registry = rs_result.get("registry", {})

                        if remote_registry:
                            merged_count = 0
                            for num, info in remote_registry.items():
                                if num not in registry:
                                    registry[num] = info
                                    merged_count += 1
                            if merged_count > 0:
                                save_registry(registry)
                                log.info(f"REGISTRY SYNC: merged {merged_count} entries from {peer['name']}")

                except Exception as rs_e:
                    log.debug(f"Registry sync with {peer['name']}: {rs_e}")

        except Exception as e:
            log.error(f"P2P sync loop error: {e}")

        # Background consistency check every 10 seconds (push handles instant sync)
        time_module.sleep(10)


# ═══════════════════════════════════════════════════════════════════════════════
#                              MAIN
# ═══════════════════════════════════════════════════════════════════════════════

if __name__ == '__main__':
    # Create data directory
    DATA_DIR.mkdir(parents=True, exist_ok=True)

    # Detect node identity
    _detect_node_identity()

    port = int(os.environ.get('PORT', 8889))
    host = os.environ.get('HOST', '0.0.0.0')

    print(f"""
╔═══════════════════════════════════════════════════════════════╗
║           MONTANA PROTOCOL API v3.1.0                         ║
║           P2P Network • Post-Quantum • Independent            ║
╠═══════════════════════════════════════════════════════════════╣
║  Node: {NODE_ID:<53s}║
║                                                               ║
║  Core Endpoints:                                              ║
║    GET  /api/health              - Health check               ║
║    GET  /api/network             - Network status             ║
║    GET  /api/status              - Full status                ║
║    GET  /api/balance/<address>   - Get balance                ║
║    POST /api/transfer            - Transfer Ɉ                 ║
║    POST /api/presence            - Presence heartbeat         ║
║    POST /api/register            - Register wallet            ║
║    POST /api/agent/register      - AI agent wallet            ║
║    GET  /api/timechain/stats     - TimeChain stats            ║
║    GET  /api/timebank/stats      - Time Bank stats            ║
║    GET  /api/version/<platform>  - App version (auto-update)  ║
║                                                               ║
║  Auction System (Ascending Auction Model):                    ║
║    GET  /api/auction/price/<t>   - Current price (N+1 Ɉ)      ║
║    GET  /api/auction/stats       - Auction statistics         ║
║    GET  /api/auction/history/<t> - Purchase history           ║
║                                                               ║
║  Montana Name Service (MNS):                                  ║
║    GET  /api/domain/available/<d> - Check domain availability ║
║    GET  /api/domain/lookup/<d>    - Lookup domain owner       ║
║    POST /api/domain/register      - Register domain (auction) ║
║                                                               ║
║  Montana Phone Service (Virtual Numbers & Calls):             ║
║    GET  /api/phone/available/<n>  - Check number availability ║
║    GET  /api/phone/lookup/<n>     - Lookup number owner       ║
║    POST /api/phone/register       - Register number (auction) ║
║    GET  /api/call/pricing         - Call pricing (1 Ɉ/sec)    ║
║    POST /api/call/calculate       - Calculate call cost       ║
║    POST /api/call/record          - Record completed call     ║
║                                                               ║
║  Real Phone Binding (SMS Verification):                       ║
║    POST /api/phone/bind/request   - Request SMS verification  ║
║    POST /api/phone/bind/verify    - Verify code & bind        ║
║    GET  /api/phone/bind/lookup/<p>- Lookup by real phone      ║
║    GET  /api/phone/bind/address/<a>- Get phones by address    ║
║                                                               ║
║  P2P (instant sync):                                          ║
║    POST /api/node/push-event     - Instant event push (T1=0)  ║
║    GET  /api/node/events         - Pull events (sync)         ║
║    POST /api/node/sync           - Bidirectional sync         ║
║    GET  /api/node/peers          - List peers                 ║
║    POST /api/node/register       - Register Mac app client    ║
║    GET  /api/ledger/verify/<a>   - Verify balance vs ledger   ║
║    GET  /api/ledger/stats        - EventLedger stats          ║
╚═══════════════════════════════════════════════════════════════╝
    """)

    # Start P2P background sync thread
    if EVENT_LEDGER_AVAILABLE:
        sync_thread = threading.Thread(target=_p2p_sync_loop, daemon=True, name="p2p-sync")
        sync_thread.start()
        print(f"P2P: Background sync thread started (node={NODE_ID})")
    else:
        print("P2P: EventLedger not available — sync disabled")

    # Start TIME_BANK for T2 finalization (every 10 minutes)
    if TIME_BANK_AVAILABLE:
        bank = get_time_bank()
        print(f"⏱️ TIME_BANK: Started (T2 finalization every 10 minutes)")
    else:
        print("⏱️ TIME_BANK: Not available")

    print(f"Starting Montana API on http://{host}:{port}")
    app.run(host=host, port=port, debug=False, threaded=True)