Code
#!/usr/bin/env python3

"""
Distributed Local Computation Network
==========================================

A complete single-file application providing:

1. Automatic Node ID generation.
2. Local LAN peer discovery.
3. Wallet connection through a Web3 wallet.
4. Live ERC-20 ETPY balance verification.
5. Off-chain wallet-control signature verification in browser.
6. Token-gated computation.
7. Continuous local computation.
8. Peer-to-peer result broadcasting.
9. Distributed result merging.
10. Local browser dashboard.
11. No runtime input.
12. Python standard library only.

IMPORTANT:
Set ETPY_TOKEN_ADDRESS below to the official ETPY ERC-20
contract address.

The application does NOT request:
- token transfers
- token approvals
- private keys
- seed phrases

The wallet signature is an OFF-CHAIN message signature.

Network:
    UDP 50505 = peer discovery
    TCP 50506 = peer communication + dashboard

Browser:
    http://127.0.0.1:50506

All PCs running this file on the same LAN can discover one another.
"""

import hashlib
import json
import os
import platform
import socket
import threading
import time
import uuid
import webbrowser
from http.server import BaseHTTPRequestHandler
from http.server import ThreadingHTTPServer
from urllib.parse import urlparse


# ============================================================
# CONFIGURATION
# ============================================================

APP_NAME = "Distributed Computation"

# ------------------------------------------------------------
# IMPORTANT:
# Replace this with the real official ETPY ERC-20 address.
#
# No runtime input is required.
# ------------------------------------------------------------

ETPY_TOKEN_ADDRESS = "0xc8ff7af0b48116922d16a839b16a4d91c57bc3b0"

# ETPY balance required to unlock computation.
REQUIRED_ETPY = 15_000_000_000

# If you know the exact chain ID, put it here.
# 0 means any connected chain is accepted.
#
# Example:
#   ETHEREUM = 1
#   BSC = 56
#   POLYGON = 137
#
REQUIRED_CHAIN_ID = 0

# ------------------------------------------------------------
# Network
# ------------------------------------------------------------

DISCOVERY_PORT = 50505
PEER_PORT = 50506

DISCOVERY_INTERVAL = 3.0
PEER_TIMEOUT = 15.0

# ------------------------------------------------------------
# Computation
# ------------------------------------------------------------

MATRIX_SIZE = 8
LOCAL_ITERATIONS = 300

COMPUTATION_PAUSE = 0.05

# ------------------------------------------------------------
# Browser
# ------------------------------------------------------------

OPEN_BROWSER = True

# Browser ethers.js version.
# The browser needs internet access to load this library.
ETHERS_CDN = (
    "https://cdn.jsdelivr.net/npm/"
    "ethers@6.13.5/dist/ethers.umd.min.js"
)


# ============================================================
# NODE ID
# ============================================================

NODE_ID_FILENAME = (
    ".etpy_distributed_node_id"
)


def create_node_id():
    """
    Creates a persistent unique Node ID.

    No user input.
    """

    path = os.path.join(
        os.path.expanduser("~"),
        NODE_ID_FILENAME
    )

    try:

        if os.path.isfile(path):

            with open(
                path,
                "r",
                encoding="utf-8"
            ) as file:

                existing = file.read().strip()

                if existing:
                    return existing

    except Exception:
        pass

    hostname = socket.gethostname()

    safe_hostname = "".join(
        c if c.isalnum() else "-"
        for c in hostname
    )

    node_id = (
        safe_hostname
        + "-"
        + uuid.uuid4().hex[:12]
    )

    try:

        with open(
            path,
            "w",
            encoding="utf-8"
        ) as file:

            file.write(node_id)

    except Exception:
        pass

    return node_id


NODE_ID = create_node_id()


# ============================================================
# GLOBAL STATE
# ============================================================

running = True

state_lock = threading.RLock()

start_time = time.time()

local_ip = "127.0.0.1"

computation_round = 0

local_computation_count = 0

received_result_count = 0

sent_result_count = 0

merged_result_count = 0


# ------------------------------------------------------------
# Wallet authorization
# ------------------------------------------------------------

wallet_connected = False

authorized_wallet = None

authorized_chain_id = None

authorization_timestamp = None

authorization_signature = None

token_gate_passed = False


# ------------------------------------------------------------
# Peer state
# ------------------------------------------------------------

peers = {}


# ------------------------------------------------------------
# Distributed results
# ------------------------------------------------------------

distributed_results = {}


# ------------------------------------------------------------
# Local result
# ------------------------------------------------------------

local_matrix = [
    [
        0.0
        for _ in range(MATRIX_SIZE)
    ]
    for _ in range(MATRIX_SIZE)
]

local_result = 0.0


# ============================================================
# LOCAL IP
# ============================================================

def detect_local_ip():

    sock = None

    try:

        sock = socket.socket(
            socket.AF_INET,
            socket.SOCK_DGRAM
        )

        sock.connect(
            ("8.8.8.8", 80)
        )

        result = sock.getsockname()[0]

        if result:
            return result

    except Exception:
        pass

    finally:

        if sock is not None:

            try:
                sock.close()
            except Exception:
                pass

    try:

        hostname = socket.gethostname()

        result = socket.gethostbyname(
            hostname
        )

        if result:
            return result

    except Exception:
        pass

    return "127.0.0.1"


local_ip = detect_local_ip()


# ============================================================
# UTILITY
# ============================================================

def now():
    return time.time()


def json_bytes(value):
    return json.dumps(
        value,
        separators=(",", ":")
    ).encode("utf-8")


def safe_float(value, default=0.0):

    try:
        result = float(value)

        if result != result:
            return default

        if result in (
            float("inf"),
            float("-inf")
        ):
            return default

        return result

    except Exception:
        return default


# ============================================================
# WALLET AUTHORIZATION STATE
# ============================================================

def authorize_wallet(payload):

    global wallet_connected
    global authorized_wallet
    global authorized_chain_id
    global authorization_timestamp
    global authorization_signature
    global token_gate_passed

    if not isinstance(payload, dict):
        return False, "Invalid authorization payload."

    wallet = str(
        payload.get(
            "wallet",
            ""
        )
    ).strip()

    signature = str(
        payload.get(
            "signature",
            ""
        )
    ).strip()

    message = str(
        payload.get(
            "message",
            ""
        )
    ).strip()

    chain_id = str(
        payload.get(
            "chain_id",
            ""
        )
    ).strip()

    if not wallet:
        return False, "Wallet address missing."

    if not signature:
        return False, "Wallet signature missing."

    if not message:
        return False, "Signed message missing."

    if not chain_id:
        return False, "Chain ID missing."

    if (
        REQUIRED_CHAIN_ID != 0
        and chain_id != str(REQUIRED_CHAIN_ID)
    ):
        return (
            False,
            "Incorrect blockchain network."
        )

    # The browser has already:
    # - checked the ERC-20 balance
    # - requested the signature
    # - recovered the signer
    #
    # We retain the complete authorization locally.

    with state_lock:

        wallet_connected = True

        authorized_wallet = wallet

        authorized_chain_id = chain_id

        authorization_timestamp = now()

        authorization_signature = signature

        token_gate_passed = True

    return True, "Wallet authorized."


def revoke_wallet():

    global wallet_connected
    global authorized_wallet
    global authorized_chain_id
    global authorization_timestamp
    global authorization_signature
    global token_gate_passed

    with state_lock:

        wallet_connected = False

        authorized_wallet = None

        authorized_chain_id = None

        authorization_timestamp = None

        authorization_signature = None

        token_gate_passed = False


# ============================================================
# COMPUTATION
# ============================================================

def deterministic_number(
    wallet,
    round_number,
    row,
    column,
    iteration
):

    source = (
        str(wallet)
        + ":"
        + str(NODE_ID)
        + ":"
        + str(round_number)
        + ":"
        + str(row)
        + ":"
        + str(column)
        + ":"
        + str(iteration)
    )

    digest = hashlib.sha256(
        source.encode("utf-8")
    ).digest()

    number = int.from_bytes(
        digest[:8],
        "big"
    )

    return number / float(
        2 ** 64
    )


def compute_one_round():

    global computation_round
    global local_computation_count
    global local_matrix
    global local_result

    # --------------------------------------------------------
    # HARD GATE
    # --------------------------------------------------------

    with state_lock:

        if not token_gate_passed:
            return None

        wallet = authorized_wallet

        computation_round += 1

        current_round = computation_round

    if not wallet:
        return None

    # --------------------------------------------------------
    # Local matrix
    # --------------------------------------------------------

    matrix = [
        [
            0.0
            for _ in range(MATRIX_SIZE)
        ]
        for _ in range(MATRIX_SIZE)
    ]

    for iteration in range(
        LOCAL_ITERATIONS
    ):

        for row in range(
            MATRIX_SIZE
        ):

            for column in range(
                MATRIX_SIZE
            ):

                value = deterministic_number(
                    wallet,
                    current_round,
                    row,
                    column,
                    iteration
                )

                matrix[row][column] += (
                    value
                )

    # --------------------------------------------------------
    # Normalize
    # --------------------------------------------------------

    denominator = float(
        LOCAL_ITERATIONS
    )

    total = 0.0

    for row in range(
        MATRIX_SIZE
    ):

        for column in range(
            MATRIX_SIZE
        ):

            matrix[row][column] = round(
                matrix[row][column]
                / denominator,
                8
            )

            total += (
                matrix[row][column]
            )

    average = round(
        total
        / float(
            MATRIX_SIZE * MATRIX_SIZE
        ),
        10
    )

    timestamp = now()

    result_hash = hashlib.sha256(
        json.dumps(
            {
                "node_id": NODE_ID,
                "wallet": wallet,
                "round": current_round,
                "matrix": matrix,
                "timestamp": timestamp
            },
            sort_keys=True,
            separators=(",", ":")
        ).encode("utf-8")
    ).hexdigest()

    result = {
        "app": APP_NAME,
        "type": "computation_result",
        "node_id": NODE_ID,
        "wallet": wallet,
        "round": current_round,
        "result": average,
        "matrix": matrix,
        "timestamp": timestamp,
        "result_hash": result_hash
    }

    with state_lock:

        local_matrix = matrix

        local_result = average

        local_computation_count += 1

        distributed_results[NODE_ID] = {
            "node_id": NODE_ID,
            "wallet": wallet,
            "round": current_round,
            "result": average,
            "timestamp": timestamp,
            "result_hash": result_hash
        }

    return result


# ============================================================
# RESULT MERGING
# ============================================================

def merge_result(payload):

    global received_result_count
    global merged_result_count

    if not isinstance(
        payload,
        dict
    ):
        return False

    if payload.get(
        "app"
    ) != APP_NAME:
        return False

    node_id = str(
        payload.get(
            "node_id",
            ""
        )
    )

    if not node_id:
        return False

    if node_id == NODE_ID:
        return False

    try:

        result_round = int(
            payload.get(
                "round",
                0
            )
        )

    except Exception:

        return False

    result_value = safe_float(
        payload.get(
            "result",
            0
        )
    )

    result_hash = str(
        payload.get(
            "result_hash",
            ""
        )
    )

    timestamp = safe_float(
        payload.get(
            "timestamp",
            now()
        )
    )

    if result_round < 0:
        return False

    if not result_hash:
        return False

    with state_lock:

        previous = distributed_results.get(
            node_id
        )

        if previous:

            previous_round = int(
                previous.get(
                    "round",
                    -1
                )
            )

            if result_round <= previous_round:
                return False

        distributed_results[node_id] = {
            "node_id": node_id,
            "wallet": payload.get(
                "wallet"
            ),
            "round": result_round,
            "result": result_value,
            "timestamp": timestamp,
            "result_hash": result_hash
        }

        received_result_count += 1

        merged_result_count += 1

    return True


def network_average():

    with state_lock:

        values = []

        for item in distributed_results.values():

            value = safe_float(
                item.get(
                    "result",
                    0
                )
            )

            values.append(value)

    if not values:
        return 0.0

    return round(
        sum(values)
        / len(values),
        10
    )


# ============================================================
# PEERS
# ============================================================

def register_peer(
    node_id,
    ip,
    port,
    round_number=0
):

    if not node_id:
        return

    if node_id == NODE_ID:
        return

    try:
        port = int(port)
    except Exception:
        port = PEER_PORT

    with state_lock:

        peers[node_id] = {
            "node_id": node_id,
            "ip": ip,
            "port": port,
            "round": int(
                round_number
            ),
            "last_seen": now()
        }


def cleanup_peers():

    cutoff = (
        now()
        - PEER_TIMEOUT
    )

    with state_lock:

        expired = [
            node_id
            for node_id, peer
            in peers.items()
            if peer.get(
                "last_seen",
                0
            ) < cutoff
        ]

        for node_id in expired:

            peers.pop(
                node_id,
                None
            )


# ============================================================
# UDP DISCOVERY
# ============================================================

def discovery_listener():

    sock = None

    try:

        sock = socket.socket(
            socket.AF_INET,
            socket.SOCK_DGRAM
        )

        sock.setsockopt(
            socket.SOL_SOCKET,
            socket.SO_REUSEADDR,
            1
        )

        try:

            sock.setsockopt(
                socket.SOL_SOCKET,
                socket.SO_BROADCAST,
                1
            )

        except Exception:
            pass

        sock.bind(
            (
                "",
                DISCOVERY_PORT
            )
        )

        sock.settimeout(
            1.0
        )

        while running:

            try:

                raw, address = sock.recvfrom(
                    65535
                )

            except socket.timeout:
                continue

            except Exception:
                break

            try:

                payload = json.loads(
                    raw.decode(
                        "utf-8"
                    )
                )

            except Exception:
                continue

            if not isinstance(
                payload,
                dict
            ):
                continue

            if payload.get(
                "app"
            ) != APP_NAME:
                continue

            if payload.get(
                "type"
            ) != "hello":
                continue

            register_peer(
                payload.get(
                    "node_id"
                ),
                payload.get(
                    "ip",
                    address[0]
                ),
                payload.get(
                    "port",
                    PEER_PORT
                ),
                payload.get(
                    "round",
                    0
                )
            )

    except Exception as error:

        print(
            "[Discovery listener]",
            error
        )

    finally:

        if sock:

            try:
                sock.close()
            except Exception:
                pass


def discovery_broadcaster():

    sock = None

    try:

        sock = socket.socket(
            socket.AF_INET,
            socket.SOCK_DGRAM
        )

        sock.setsockopt(
            socket.SOL_SOCKET,
            socket.SO_BROADCAST,
            1
        )

        while running:

            with state_lock:

                current_round = (
                    computation_round
                )

            payload = {
                "app": APP_NAME,
                "type": "hello",
                "node_id": NODE_ID,
                "ip": local_ip,
                "port": PEER_PORT,
                "round": current_round,
                "timestamp": now()
            }

            try:

                sock.sendto(
                    json_bytes(payload),
                    (
                        "255.255.255.255",
                        DISCOVERY_PORT
                    )
                )

            except Exception:
                pass

            cleanup_peers()

            time.sleep(
                DISCOVERY_INTERVAL
            )

    except Exception as error:

        print(
            "[Discovery broadcaster]",
            error
        )

    finally:

        if sock:

            try:
                sock.close()
            except Exception:
                pass


# ============================================================
# PEER HTTP CLIENT
# ============================================================

def send_result_to_peer(
    peer,
    payload
):

    ip = peer.get(
        "ip"
    )

    port = peer.get(
        "port",
        PEER_PORT
    )

    if not ip:
        return False

    sock = None

    try:

        sock = socket.create_connection(
            (
                ip,
                int(port)
            ),
            timeout=2.0
        )

        body = json_bytes(
            payload
        )

        request = (
            b"POST /peer/result HTTP/1.1\r\n"
            b"Host: "
            + ip.encode(
                "ascii",
                "ignore"
            )
            + b"\r\n"
            b"Content-Type: application/json\r\n"
            b"Content-Length: "
            + str(
                len(body)
            ).encode(
                "ascii"
            )
            + b"\r\n"
            b"Connection: close\r\n"
            b"\r\n"
            + body
        )

        sock.sendall(
            request
        )

        try:
            sock.recv(4096)
        except Exception:
            pass

        return True

    except Exception:

        return False

    finally:

        if sock:

            try:
                sock.close()
            except Exception:
                pass


def broadcast_result(payload):

    global sent_result_count

    with state_lock:

        peer_list = list(
            peers.values()
        )

    successful = 0

    for peer in peer_list:

        if send_result_to_peer(
            peer,
            payload
        ):

            successful += 1

    with state_lock:

        sent_result_count += successful


# ============================================================
# RESULT BROADCAST WORKER
# ============================================================

def result_worker():

    last_round = -1

    while running:

        try:

            with state_lock:

                if not token_gate_passed:

                    payload = None

                else:

                    item = distributed_results.get(
                        NODE_ID
                    )

                    if item is None:

                        payload = None

                    else:

                        current_round = int(
                            item.get(
                                "round",
                                0
                            )
                        )

                        if current_round == last_round:

                            payload = None

                        else:

                            payload = {
                                "app": APP_NAME,
                                "type": "computation_result",
                                "node_id": NODE_ID,
                                "wallet": authorized_wallet,
                                "round": current_round,
                                "result": item.get(
                                    "result",
                                    0
                                ),
                                "timestamp": item.get(
                                    "timestamp",
                                    now()
                                ),
                                "result_hash": item.get(
                                    "result_hash",
                                    ""
                                )
                            }

                            last_round = current_round

            if payload:

                broadcast_result(
                    payload
                )

        except Exception as error:

            print(
                "[Result broadcast]",
                error
            )

        time.sleep(
            1.0
        )


# ============================================================
# COMPUTATION WORKER
# ============================================================

def computation_worker():

    while running:

        try:

            with state_lock:

                unlocked = (
                    token_gate_passed
                )

            if unlocked:

                result = compute_one_round()

                if result:

                    print(
                        "[COMPUTE]"
                        f" node={NODE_ID}"
                        f" round={result['round']}"
                        f" result={result['result']:.8f}"
                    )

            else:

                time.sleep(
                    0.25
                )

        except Exception as error:

            print(
                "[COMPUTATION]",
                error
            )

            time.sleep(
                1.0
            )

        time.sleep(
            COMPUTATION_PAUSE
        )


# ============================================================
# STATUS
# ============================================================

def status():

    with state_lock:

        peer_snapshot = []

        for peer in peers.values():

            peer_snapshot.append({
                "node_id": peer.get(
                    "node_id"
                ),
                "ip": peer.get(
                    "ip"
                ),
                "port": peer.get(
                    "port"
                ),
                "round": peer.get(
                    "round"
                ),
                "last_seen": peer.get(
                    "last_seen"
                )
            })

        result_snapshot = []

        for result in distributed_results.values():

            result_snapshot.append({
                "node_id": result.get(
                    "node_id"
                ),
                "wallet": result.get(
                    "wallet"
                ),
                "round": result.get(
                    "round"
                ),
                "result": result.get(
                    "result"
                ),
                "timestamp": result.get(
                    "timestamp"
                ),
                "result_hash": result.get(
                    "result_hash"
                )
            })

        return {
            "application": APP_NAME,

            "node_id": NODE_ID,

            "hostname": socket.gethostname(),

            "platform": platform.platform(),

            "ip": local_ip,

            "peer_port": PEER_PORT,

            "discovery_port": DISCOVERY_PORT,

            "etpy_token_address":
                ETPY_TOKEN_ADDRESS,

            "required_etpy":
                REQUIRED_ETPY,

            "required_chain_id":
                REQUIRED_CHAIN_ID,

            "wallet_connected":
                wallet_connected,

            "wallet":
                authorized_wallet,

            "chain_id":
                authorized_chain_id,

            "token_gate_passed":
                token_gate_passed,

            "computation_unlocked":
                token_gate_passed,

            "computation_round":
                computation_round,

            "local_computations":
                local_computation_count,

            "known_peers":
                len(peer_snapshot),

            "merged_nodes":
                len(result_snapshot),

            "received_results":
                received_result_count,

            "sent_results":
                sent_result_count,

            "merged_results":
                merged_result_count,

            "network_average":
                network_average(),

            "uptime_seconds":
                round(
                    now()
                    - start_time,
                    2
                ),

            "peers":
                peer_snapshot,

            "results":
                result_snapshot
        }


# ============================================================
# DASHBOARD HTML
# ============================================================

PAGE = r"""
<!DOCTYPE html>

<html lang="en">

<head>

<meta charset="utf-8">

<meta
    name="viewport"
    content="width=device-width,initial-scale=1"
>

<title> Distributed Computation</title>

<script src="__ETHERS_CDN__"></script>

<style>

:root {
    --lavender: #9995f3;
    --lavender-dark: #817ddd;
    --navy: #00202a;
    --dark: #07171c;
    --card: #10282f;
    --card2: #17353d;
    --white: #ffffff;
    --muted: #9eb2b8;
    --green: #50d890;
    --red: #ff6969;
    --yellow: #ffd166;
    --border: #29454d;
}

* {
    box-sizing: border-box;
}

body {
    margin: 0;
    background: var(--dark);
    color: var(--white);
    font-family:
        Arial,
        Helvetica,
        sans-serif;
}

main {
    width: min(
        1150px,
        calc(100% - 30px)
    );

    margin: auto;

    padding:
        25px
        0
        60px;
}

.hero {
    background: var(--lavender);
    color: var(--navy);

    border-radius: 22px;

    padding: 32px;

    box-shadow:
        0 20px 50px
        rgba(0,0,0,.25);
}

.hero h1 {
    margin: 0 0 10px;

    font-size:
        clamp(
            30px,
            6vw,
            55px
        );

    letter-spacing:
        -0.04em;
}

.hero p {
    margin: 0;

    max-width: 800px;

    font-size: 17px;
}

.card {
    margin-top: 20px;

    padding: 24px;

    background: var(--card);

    border:
        1px solid
        var(--border);

    border-radius: 18px;
}

.card h2 {
    margin-top: 0;
}

.grid {
    display: grid;

    grid-template-columns:
        repeat(
            auto-fit,
            minmax(
                190px,
                1fr
            )
        );

    gap: 12px;
}

.stat {
    background: var(--card2);

    border-radius: 13px;

    padding: 16px;
}

.label {
    color: var(--muted);

    font-size: 12px;

    text-transform: uppercase;

    letter-spacing:
        .05em;
}

.value {
    margin-top: 7px;

    font-size: 19px;

    font-weight: bold;

    word-break: break-word;
}

button {
    width: 100%;

    margin-top: 14px;

    padding: 14px 18px;

    border: 0;

    border-radius: 999px;

    background: var(--lavender);

    color: var(--navy);

    font-size: 16px;

    font-weight: bold;

    cursor: pointer;
}

button:hover {
    background:
        var(--lavender-dark);
}

button:disabled {
    opacity: .4;

    cursor: not-allowed;
}

.status {
    margin-top: 14px;

    padding: 17px;

    background: #0c2026;

    border:
        1px solid
        var(--border);

    border-radius: 13px;

    white-space: pre-wrap;

    overflow-wrap: anywhere;
}

.success {
    border-color:
        var(--green);

    color:
        var(--green);
}

.error {
    border-color:
        var(--red);

    color:
        var(--red);
}

.warning {
    border-color:
        var(--yellow);

    color:
        var(--yellow);
}

.locked {
    opacity: .7;
}

pre {
    margin: 0;

    white-space: pre-wrap;

    overflow-wrap: anywhere;

    font-family:
        monospace;

    font-size: 12px;

    color:
        #cce0e4;
}

.badge {
    display: inline-block;

    padding:
        6px
        10px;

    border-radius: 999px;

    background:
        var(--card2);

    font-size: 12px;
}

.online {
    color:
        var(--green);
}

.offline {
    color:
        var(--red);
}

.lock {
    color:
        var(--yellow);
}

</style>

</head>

<body>

<main>

<section class="hero">

<h1>
Distributed Computation
</h1>

<p>
Each authorized PC computes locally,
broadcasts its result, discovers other
nodes automatically, and merges their
latest results.
</p>

</section>


<section class="card">

<h2>
1. Wallet Authorization
</h2>

<div class="grid">

<div class="stat">

<div class="label">
Node ID
</div>

<div
    class="value"
    id="nodeId"
>
Loading...
</div>

</div>


<div class="stat">

<div class="label">
ETPY Requirement
</div>

<div
    class="value"
    id="required"
>
Loading...
</div>

</div>


<div class="stat">

<div class="label">
Token Contract
</div>

<div
    class="value"
    id="token"
>
Loading...
</div>

</div>


<div class="stat">

<div class="label">
Wallet
</div>

<div
    class="value"
    id="wallet"
>
Not connected
</div>

</div>

</div>


<button
    id="connectButton"
>
Connect Wallet
</button>


<button
    id="verifyButton"
    disabled
>
Verify ETPY & Authorize Computation
</button>


<div
    id="walletStatus"
    class="status"
>
Wallet authorization required.
</div>

</section>


<section
    class="card"
    id="computationCard"
>

<h2>
2. Computation
</h2>

<div class="grid">

<div class="stat">

<div class="label">
Local Status
</div>

<div
    class="value"
    id="localStatus"
>
LOCKED
</div>

</div>


<div class="stat">

<div class="label">
Local Round
</div>

<div
    class="value"
    id="round"
>
0
</div>

</div>


<div class="stat">

<div class="label">
Local Computations
</div>

<div
    class="value"
    id="localComputations"
>
0
</div>

</div>


<div class="stat">

<div class="label">
Network Average
</div>

<div
    class="value"
    id="networkAverage"
>
0
</div>

</div>

</div>


<div
    id="computationStatus"
    class="status warning"
>
Computation locked until wallet authorization succeeds.
</div>

</section>


<section class="card">

<h2>
3. Network
</h2>

<div class="grid">

<div class="stat">

<div class="label">
Known Peers
</div>

<div
    class="value"
    id="peerCount"
>
0
</div>

</div>


<div class="stat">

<div class="label">
Merged Nodes
</div>

<div
    class="value"
    id="mergedCount"
>
0
</div>

</div>


<div class="stat">

<div class="label">
Received Results
</div>

<div
    class="value"
    id="receivedResults"
>
0
</div>

</div>


<div class="stat">

<div class="label">
Sent Results
</div>

<div
    class="value"
    id="sentResults"
>
0
</div>

</div>

</div>

</section>


<section class="card">

<h2>
4. Peers
</h2>

<pre id="peers">
No peers discovered.
</pre>

</section>


<section class="card">

<h2>
5. Merged Results
</h2>

<pre id="results">
No results received.
</pre>

</section>


<section class="card">

<h2>
6. Wallet Proof
</h2>

<pre id="proof">
No wallet authorization yet.
</pre>

</section>

</main>


<script>

"use strict";


/* ============================================================
   CONFIGURATION RECEIVED FROM PYTHON
   ============================================================ */

const CONFIG = __CONFIG__;


/* ============================================================
   STATE
   ============================================================ */

let provider = null;

let signer = null;

let walletAddress = null;

let connectedChainId = null;

let tokenVerified = false;

let signatureVerified = false;

let authorizationComplete = false;

let authorizationSignature = null;

let authorizationMessage = null;


/* ============================================================
   DOM
   ============================================================ */

const connectButton =
    document.getElementById(
        "connectButton"
    );

const verifyButton =
    document.getElementById(
        "verifyButton"
    );

const walletStatus =
    document.getElementById(
        "walletStatus"
    );

const computationStatus =
    document.getElementById(
        "computationStatus"
    );

const computationCard =
    document.getElementById(
        "computationCard"
    );


/* ============================================================
   UI
   ============================================================ */

function setStatus(
    element,
    text,
    className
) {

    element.textContent =
        text;

    element.className =
        "status " +
        (className || "");
}


function shortAddress(
    address
) {

    if (!address) {
        return "None";
    }

    if (address.length < 12) {
        return address;
    }

    return (
        address.slice(0, 8)
        + "..."
        + address.slice(-6)
    );
}


/* ============================================================
   INITIAL CONFIG
   ============================================================ */

document.getElementById(
    "nodeId"
).textContent =
    CONFIG.node_id;


document.getElementById(
    "required"
).textContent =
    Number(
        CONFIG.required_etpy
    ).toLocaleString()
    + " ETPY";


document.getElementById(
    "token"
).textContent =
    CONFIG.token_address;


/* ============================================================
   CONNECT WALLET
   ============================================================ */

async function connectWallet() {

    try {

        if (
            typeof ethers ===
            "undefined"
        ) {

            throw new Error(
                "Wallet library failed to load."
            );
        }


        if (!window.ethereum) {

            throw new Error(
                "No Web3 wallet detected."
            );
        }


        provider =
            new ethers.BrowserProvider(
                window.ethereum
            );


        await provider.send(
            "eth_requestAccounts",
            []
        );


        signer =
            await provider.getSigner();


        walletAddress =
            await signer.getAddress();


        const network =
            await provider.getNetwork();


        connectedChainId =
            network.chainId.toString();


        document.getElementById(
            "wallet"
        ).textContent =
            shortAddress(
                walletAddress
            );


        verifyButton.disabled =
            false;


        setStatus(
            walletStatus,

            "WALLET CONNECTED\n\n" +
            "Address:\n" +
            walletAddress +
            "\n\n" +
            "Chain ID: " +
            connectedChainId +
            "\n\n" +
            "Next: verify ETPY balance and sign the authorization message.",

            "success"
        );

    } catch (error) {

        setStatus(
            walletStatus,

            error.shortMessage ||
            error.message ||
            String(error),

            "error"
        );
    }
}


/* ============================================================
   TOKEN + SIGNATURE GATE
   ============================================================ */

async function verifyWallet() {

    try {

        if (!provider || !signer) {

            throw new Error(
                "Connect the wallet first."
            );
        }


        if (
            !ethers.isAddress(
                CONFIG.token_address
            )
        ) {

            throw new Error(
                "ETPY_TOKEN_ADDRESS is not configured with a valid contract address."
            );
        }


        if (
            CONFIG.required_chain_id !== 0 &&
            connectedChainId !==
            String(
                CONFIG.required_chain_id
            )
        ) {

            throw new Error(
                "Wrong network.\n\n" +
                "Connected chain ID: " +
                connectedChainId +
                "\n" +
                "Required chain ID: " +
                CONFIG.required_chain_id
            );
        }


        verifyButton.disabled =
            true;


        setStatus(
            walletStatus,

            "Reading live ETPY balance...",

            "warning"
        );


        const ERC20_ABI = [

            "function balanceOf(address owner) view returns (uint256)",

            "function decimals() view returns (uint8)",

            "function symbol() view returns (string)"

        ];


        const token =
            new ethers.Contract(
                CONFIG.token_address,
                ERC20_ABI,
                provider
            );


        let decimals = 18;

        let symbol = "ETPY";


        try {

            decimals =
                Number(
                    await token.decimals()
                );

        } catch (_) {

            decimals = 18;
        }


        try {

            symbol =
                await token.symbol();

        } catch (_) {

            symbol = "ETPY";
        }


        const balance =
            await token.balanceOf(
                walletAddress
            );


        const required =
            ethers.parseUnits(
                String(
                    CONFIG.required_etpy
                ),
                decimals
            );


        const displayBalance =
            ethers.formatUnits(
                balance,
                decimals
            );


        const displayRequired =
            ethers.formatUnits(
                required,
                decimals
            );


        if (
            balance < required
        ) {

            tokenVerified =
                false;

            signatureVerified =
                false;

            authorizationComplete =
                false;

            setStatus(
                walletStatus,

                "TOKEN GATE FAILED\n\n" +
                "Wallet:\n" +
                walletAddress +
                "\n\n" +
                "Balance:\n" +
                displayBalance +
                " " +
                symbol +
                "\n\n" +
                "Required:\n" +
                displayRequired +
                " " +
                symbol,

                "error"
            );


            verifyButton.disabled =
                false;

            return;
        }


        tokenVerified =
            true;


        setStatus(
            walletStatus,

            "ETPY BALANCE VERIFIED\n\n" +
            "Balance: " +
            displayBalance +
            " " +
            symbol +
            "\n" +
            "Required: " +
            displayRequired +
            " " +
            symbol +
            "\n\n" +
            "Requesting wallet-control signature...",

            "warning"
        );


        /*
         * Cryptographically unique challenge.
         */
        const nonce =
            ethers.hexlify(
                ethers.randomBytes(
                    32
                )
            );


        const timestamp =
            new Date().toISOString();


        authorizationMessage =
            "Distributed Computation Authorization\n\n" +

            "This is an OFF-CHAIN signature.\n" +

            "It does NOT transfer tokens.\n" +

            "It does NOT approve tokens.\n" +

            "It does NOT create a blockchain transaction.\n\n" +

            "Wallet: " +
            walletAddress +
            "\n" +

            "Token contract: " +
            CONFIG.token_address +
            "\n" +

            "Required balance: " +
            displayRequired +
            " " +
            symbol +
            "\n" +

            "Chain ID: " +
            connectedChainId +
            "\n" +

            "Node ID: " +
            CONFIG.node_id +
            "\n" +

            "Nonce: " +
            nonce +
            "\n" +

            "Timestamp: " +
            timestamp;


        authorizationSignature =
            await signer.signMessage(
                authorizationMessage
            );


        /*
         * Verify the signature locally.
         */
        const recovered =
            ethers.verifyMessage(
                authorizationMessage,
                authorizationSignature
            );


        signatureVerified =
            recovered.toLowerCase() ===
            walletAddress.toLowerCase();


        if (!signatureVerified) {

            authorizationComplete =
                false;

            throw new Error(
                "Wallet signature verification failed."
            );
        }


        /*
         * The gate is now complete.
         */
        authorizationComplete =
            tokenVerified &&
            signatureVerified;


        if (!authorizationComplete) {

            throw new Error(
                "Authorization conditions were not satisfied."
            );
        }


        /*
         * Send the local authorization proof to the
         * local Python node.
         */
        const response =
            await fetch(
                "/authorize",
                {
                    method: "POST",

                    headers: {
                        "Content-Type":
                            "application/json"
                    },

                    body: JSON.stringify({

                        wallet:
                            walletAddress,

                        chain_id:
                            connectedChainId,

                        message:
                            authorizationMessage,

                        signature:
                            authorizationSignature,

                        token_balance:
                            displayBalance,

                        token_symbol:
                            symbol,

                        token_contract:
                            CONFIG.token_address

                    })
                }
            );


        if (!response.ok) {

            throw new Error(
                "Local computation node rejected authorization."
            );
        }


        const result =
            await response.json();


        if (!result.ok) {

            throw new Error(
                result.error ||
                "Local authorization failed."
            );
        }


        computationCard.classList.remove(
            "locked"
        );


        setStatus(
            walletStatus,

            "TOKEN GATE PASSED\n\n" +
            "Wallet:\n" +
            walletAddress +
            "\n\n" +
            "ETPY balance: VERIFIED\n" +
            "Wallet control: VERIFIED\n" +
            "Signature: VALID\n\n" +
            "Local computation is now unlocked.",

            "success"
        );


        setStatus(
            computationStatus,

            "COMPUTATION UNLOCKED\n\n" +
            "This node is now computing locally and exchanging results with discovered peers.",

            "success"
        );


        document.getElementById(
            "localStatus"
        ).textContent =
            "UNLOCKED";


        document.getElementById(
            "localStatus"
        ).className =
            "value online";


        document.getElementById(
            "proof"
        ).textContent =
            "Wallet:\n" +
            walletAddress +
            "\n\n" +

            "Chain ID:\n" +
            connectedChainId +
            "\n\n" +

            "Signature:\n" +
            authorizationSignature +
            "\n\n" +

            "Recovered signer:\n" +
            recovered;


    } catch (error) {

        authorizationComplete =
            false;

        tokenVerified =
            false;

        signatureVerified =
            false;

        setStatus(
            walletStatus,

            error.shortMessage ||
            error.message ||
            String(error),

            "error"
        );

    } finally {

        verifyButton.disabled =
            false;
    }
}


/* ============================================================
   STATUS REFRESH
   ============================================================ */

async function refreshStatus() {

    try {

        const response =
            await fetch(
                "/status",
                {
                    cache: "no-store"
                }
            );


        if (!response.ok) {
            return;
        }


        const data =
            await response.json();


        document.getElementById(
            "round"
        ).textContent =
            data.computation_round;


        document.getElementById(
            "localComputations"
        ).textContent =
            data.local_computations;


        document.getElementById(
            "peerCount"
        ).textContent =
            data.known_peers;


        document.getElementById(
            "mergedCount"
        ).textContent =
            data.merged_nodes;


        document.getElementById(
            "receivedResults"
        ).textContent =
            data.received_results;


        document.getElementById(
            "sentResults"
        ).textContent =
            data.sent_results;


        document.getElementById(
            "networkAverage"
        ).textContent =
            Number(
                data.network_average
            ).toFixed(10);


        if (
            data.token_gate_passed
        ) {

            document.getElementById(
                "localStatus"
            ).textContent =
                "UNLOCKED";

            document.getElementById(
                "localStatus"
            ).className =
                "value online";

        } else {

            document.getElementById(
                "localStatus"
            ).textContent =
                "LOCKED";

            document.getElementById(
                "localStatus"
            ).className =
                "value lock";
        }


        document.getElementById(
            "peers"
        ).textContent =
            data.peers.length
                ? JSON.stringify(
                    data.peers,
                    null,
                    2
                )
                : "No peers discovered.";


        document.getElementById(
            "results"
        ).textContent =
            data.results.length
                ? JSON.stringify(
                    data.results,
                    null,
                    2
                )
                : "No results received.";


    } catch (_) {

        /*
         * Temporary network errors are ignored.
         * The next refresh will retry.
         */
    }
}


/* ============================================================
   EVENTS
   ============================================================ */

connectButton.addEventListener(
    "click",
    connectWallet
);


verifyButton.addEventListener(
    "click",
    verifyWallet
);


/* ============================================================
   WALLET EVENTS
   ============================================================ */

if (window.ethereum) {

    window.ethereum.on(
        "accountsChanged",
        function () {

            walletAddress = null;

            tokenVerified = false;

            signatureVerified = false;

            authorizationComplete = false;

            fetch(
                "/revoke",
                {
                    method: "POST"
                }
            ).catch(
                function () {}
            );


            location.reload();
        }
    );


    window.ethereum.on(
        "chainChanged",
        function () {

            fetch(
                "/revoke",
                {
                    method: "POST"
                }
            ).catch(
                function () {}
            );


            location.reload();
        }
    );
}


/* ============================================================
   LIVE DASHBOARD
   ============================================================ */

refreshStatus();

setInterval(
    refreshStatus,
    1000
);

</script>

</body>

</html>
"""


# ============================================================
# HTTP HANDLER
# ============================================================

class RequestHandler(
    BaseHTTPRequestHandler
):

    def log_message(
        self,
        format_string,
        *args
    ):
        return

    def send_json(
        self,
        payload,
        status_code=200
    ):

        raw = json_bytes(
            payload
        )

        self.send_response(
            status_code
        )

        self.send_header(
            "Content-Type",
            "application/json; charset=utf-8"
        )

        self.send_header(
            "Content-Length",
            str(
                len(raw)
            )
        )

        self.send_header(
            "Cache-Control",
            "no-store"
        )

        self.end_headers()

        self.wfile.write(
            raw
        )


    def read_json_body(self):

        try:

            length = int(
                self.headers.get(
                    "Content-Length",
                    "0"
                )
            )

        except Exception:

            return None


        if length <= 0:
            return None

        if length > 1024 * 1024:
            return None

        try:

            raw = self.rfile.read(
                length
            )

            return json.loads(
                raw.decode(
                    "utf-8"
                )
            )

        except Exception:

            return None


    def do_GET(self):

        path = urlparse(
            self.path
        ).path


        if path == "/status":

            self.send_json(
                status()
            )

            return


        if path == "/":

            config = {
                "node_id":
                    NODE_ID,

                "token_address":
                    ETPY_TOKEN_ADDRESS,

                "required_etpy":
                    REQUIRED_ETPY,

                "required_chain_id":
                    REQUIRED_CHAIN_ID
            }


            page = PAGE.replace(
                "__ETHERS_CDN__",
                ETHERS_CDN
            )


            page = page.replace(
                "__CONFIG__",
                json.dumps(
                    config,
                    separators=(",", ":")
                )
            )


            raw = page.encode(
                "utf-8"
            )


            self.send_response(
                200
            )

            self.send_header(
                "Content-Type",
                "text/html; charset=utf-8"
            )

            self.send_header(
                "Content-Length",
                str(
                    len(raw)
                )
            )

            self.send_header(
                "Cache-Control",
                "no-store"
            )

            self.end_headers()

            self.wfile.write(
                raw
            )

            return


        if path == "/health":

            self.send_json({
                "ok": True,
                "node_id": NODE_ID,
                "token_gate":
                    token_gate_passed,
                "computation":
                    token_gate_passed
            })

            return


        self.send_json(
            {
                "error": "Not found"
            },
            404
        )


    def do_POST(self):

        path = urlparse(
            self.path
        ).path


        # ----------------------------------------------------
        # Wallet authorization
        # ----------------------------------------------------

        if path == "/authorize":

            payload = (
                self.read_json_body()
            )

            ok, message = (
                authorize_wallet(
                    payload
                )
            )


            if not ok:

                self.send_json(
                    {
                        "ok": False,
                        "error": message
                    },
                    403
                )

                return


            self.send_json(
                {
                    "ok": True,
                    "authorized": True,
                    "node_id": NODE_ID
                }
            )

            print(
                "[AUTH]"
                " Wallet authorized:"
                f" {authorized_wallet}"
            )

            return


        # ----------------------------------------------------
        # Wallet revocation
        # ----------------------------------------------------

        if path == "/revoke":

            revoke_wallet()

            self.send_json(
                {
                    "ok": True,
                    "authorized": False
                }
            )

            print(
                "[AUTH] Wallet authorization revoked."
            )

            return


        # ----------------------------------------------------
        # Peer result
        # ----------------------------------------------------

        if path == "/peer/result":

            payload = (
                self.read_json_body()
            )


            if not isinstance(
                payload,
                dict
            ):

                self.send_json(
                    {
                        "ok": False,
                        "error":
                            "Invalid JSON"
                    },
                    400
                )

                return


            node_id = str(
                payload.get(
                    "node_id",
                    ""
                )
            )


            register_peer(
                node_id,
                self.client_address[0],
                PEER_PORT,
                payload.get(
                    "round",
                    0
                )
            )


            accepted = merge_result(
                payload
            )


            self.send_json(
                {
                    "ok": True,
                    "merged": accepted,
                    "node_id": NODE_ID
                }
            )

            return


        self.send_json(
            {
                "error":
                    "Not found"
            },
            404
        )


# ============================================================
# SERVER
# ============================================================

def start_server():

    server = None

    try:

        server = ThreadingHTTPServer(
            (
                "0.0.0.0",
                PEER_PORT
            ),
            RequestHandler
        )

        server.daemon_threads = True

        print(
            "[SERVER]"
            f" http://127.0.0.1:{PEER_PORT}"
        )

        print(
            "[LAN]"
            f" http://{local_ip}:{PEER_PORT}"
        )

        while running:

            server.handle_request()

    except Exception as error:

        print(
            "[SERVER ERROR]",
            error
        )

    finally:

        if server:

            try:
                server.server_close()
            except Exception:
                pass


# ============================================================
# AUTOMATIC BROWSER
# ============================================================

def open_browser():

    time.sleep(
        1.2
    )

    try:

        webbrowser.open(
            "http://127.0.0.1:"
            + str(PEER_PORT)
            + "/"
        )

    except Exception:
        pass


# ============================================================
# CLEAN SHUTDOWN
# ============================================================

def shutdown():

    global running

    running = False

    print()
    print(
        "[SYSTEM] Shutting down."
    )


# ============================================================
# MAIN
# ============================================================

def main():

    global running

    print()
    print(
        "=" * 72
    )

    print(
        " ETPY DISTRIBUTED LOCAL COMPUTATION"
    )

    print(
        "=" * 72
    )

    print()

    print(
        "Node ID:"
    )

    print(
        " ",
        NODE_ID
    )

    print()

    print(
        "Local IP:"
    )

    print(
        " ",
        local_ip
    )

    print()

    print(
        "Peer server:"
    )

    print(
        " ",
        f"{local_ip}:{PEER_PORT}"
    )

    print()

    print(
        "Discovery:"
    )

    print(
        " ",
        f"UDP {DISCOVERY_PORT}"
    )

    print()

    print(
        "ETPY contract:"
    )

    print(
        " ",
        ETPY_TOKEN_ADDRESS
    )

    print()

    print(
        "Required ETPY:"
    )

    print(
        " ",
        f"{REQUIRED_ETPY:,}"
    )

    print()

    if (
        ETPY_TOKEN_ADDRESS
        ==
        "0xc8ff7af0b48116922d16a839b16a4d91c57bc3b0"
    ):

        print(
            "[WARNING]"
        )

        print(
            "Set ETPY_TOKEN_ADDRESS to the official"
        )

        print(
            "ETPY ERC-20 contract address."
        )

        print()

    print(
        "Wallet gate:"
    )

    print(
        " LOCKED until wallet balance and"
    )

    print(
        " off-chain wallet signature are verified."
    )

    print()

    print(
        "Computation:"
    )

    print(
        " LOCKED until authorization."
    )

    print()

    print(
        "=" * 72
    )

    print()


    # --------------------------------------------------------
    # HTTP / peer server
    # --------------------------------------------------------

    threading.Thread(
        target=start_server,
        daemon=True
    ).start()


    # --------------------------------------------------------
    # UDP listener
    # --------------------------------------------------------

    threading.Thread(
        target=discovery_listener,
        daemon=True
    ).start()


    # --------------------------------------------------------
    # UDP broadcaster
    # --------------------------------------------------------

    threading.Thread(
        target=discovery_broadcaster,
        daemon=True
    ).start()


    # --------------------------------------------------------
    # Computation
    # --------------------------------------------------------

    threading.Thread(
        target=computation_worker,
        daemon=True
    ).start()


    # --------------------------------------------------------
    # Result broadcasting
    # --------------------------------------------------------

    threading.Thread(
        target=result_worker,
        daemon=True
    ).start()


    # --------------------------------------------------------
    # Browser
    # --------------------------------------------------------

    if OPEN_BROWSER:

        threading.Thread(
            target=open_browser,
            daemon=True
        ).start()


    # --------------------------------------------------------
    # Main monitoring
    # --------------------------------------------------------

    try:

        while running:

            time.sleep(
                5
            )

            with state_lock:

                gate = (
                    token_gate_passed
                )

                peers_count = len(
                    peers
                )

                nodes_count = len(
                    distributed_results
                )

                round_number = (
                    computation_round
                )

                average = (
                    network_average()
                )

                wallet = (
                    authorized_wallet
                )


            print()

            print(
                "[STATUS]"
                f" gate={'OPEN' if gate else 'LOCKED'}"
                f" round={round_number}"
                f" peers={peers_count}"
                f" nodes={nodes_count}"
                f" average={average:.10f}"
            )


            if wallet:

                print(
                    "[WALLET]"
                    f" {wallet}"
                )

    except KeyboardInterrupt:

        shutdown()

    except Exception as error:

        print(
            "[SYSTEM ERROR]",
            error
        )

        shutdown()


# ============================================================
# ENTRY POINT
# ============================================================

if __name__ == "__main__":

    main()