feat: add settlement contract boundary

packages/tracker/meshnet_tracker/server.py

@@ -23,6 +23,7 @@ import threading
 import time
 import urllib.parse
 import uuid
+from typing import Any
 
 
 DEFAULT_MODEL_PRESETS: dict[str, dict] = {
@@ -91,12 +92,16 @@ class _TrackerHTTPServer(http.server.HTTPServer):
         lock: threading.Lock,
         heartbeat_timeout: float,
         model_presets: dict,
+        contracts: Any | None,
+        minimum_stake: int,
     ) -> None:
         super().__init__(addr, handler)
         self.registry = registry
         self.lock = lock
         self.heartbeat_timeout = heartbeat_timeout
         self.model_presets = model_presets
+        self.contracts = contracts
+        self.minimum_stake = minimum_stake
 
 
 class _TrackerHandler(http.server.BaseHTTPRequestHandler):
@@ -263,6 +268,11 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
         with server.lock:
             self._purge_expired_nodes()
             alive = list(server.registry.values())
+        if server.contracts is not None:
+            alive = [
+                node for node in alive
+                if not node.wallet_address or not server.contracts.registry.get_wallet(node.wallet_address).banned
+            ]
 
         device = params.get("device", ["cpu"])[0]
         try:
@@ -323,13 +333,30 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
         with server.lock:
             self._purge_expired_nodes()
             alive = list(server.registry.values())
+        if server.contracts is not None:
+            alive = [
+                node for node in alive
+                if not node.wallet_address or not server.contracts.registry.get_wallet(node.wallet_address).banned
+            ]
 
         route, error = _select_route(alive, required_start, required_end)
         if error:
             self._send_json(503, {"error": error})
             return
 
-        self._send_json(200, {"route": [e.endpoint for e in route]})
+        self._send_json(200, {
+            "route": [e.endpoint for e in route],
+            "nodes": [
+                {
+                    "endpoint": e.endpoint,
+                    "wallet_address": e.wallet_address,
+                    "shard_start": e.shard_start,
+                    "shard_end": e.shard_end,
+                    "score": e.score,
+                }
+                for e in route
+            ],
+        })
 
 
 class TrackerServer:
@@ -346,6 +373,8 @@ class TrackerServer:
         port: int = 0,
         heartbeat_timeout: float = 30.0,
         model_presets: dict | None = None,
+        contracts: Any | None = None,
+        minimum_stake: int = 0,
     ) -> None:
         self._host = host
         self._requested_port = port
@@ -353,6 +382,8 @@ class TrackerServer:
         self._model_presets: dict = (
             model_presets if model_presets is not None else dict(DEFAULT_MODEL_PRESETS)
         )
+        self._contracts = contracts
+        self._minimum_stake = minimum_stake
         self._registry: dict[str, _NodeEntry] = {}
         self._lock = threading.Lock()
         self._server: _TrackerHTTPServer | None = None
@@ -369,6 +400,8 @@ class TrackerServer:
             self._lock,
             self._heartbeat_timeout,
             self._model_presets,
+            self._contracts,
+            self._minimum_stake,
         )
         self.port = self._server.server_address[1]
         self._thread = threading.Thread(target=self._server.serve_forever, daemon=True)