Sync from GitHub with Git LFS

agents/bootstrap.txt

@@ -1,4 +1,3 @@
-DID: "did:hmp:87836dac-a93c-4203-8710-5e4711b07e02"; NAME: "Agent_108"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAzqHBnykJSRs6PsvpsEXdZNSPAs+voBarQYDAR0B664I=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://95.72.96.108:4000", "nonce": 67802, "pow_hash": "00002dbeb3936beffc746b25bdbeff0e20c7c164281f9ebe4d03e76a28592211", "difficulty": 4, "datetime": "2025-08-28T15:44:51.608882+00:00"}, {"addr": "udp://95.72.96.108:4000", "nonce": 8072, "pow_hash": "0000e54c7d2a5e0dabd811e1b1ac3f8ec94029b29382d8bf8a9fe3fc12985dc6", "difficulty": 4, "datetime": "2025-08-28T15:44:51.773206+00:00"}, {"addr": "tcp://195.172.229.108:4000", "nonce": 368, "pow_hash": "000089b642d389d1c5e36f93e0983158c676e2cae21b981fe978c8488ed679e0", "difficulty": 4, "datetime": "2025-08-28T15:44:51.790767+00:00"}, {"addr": "udp://195.172.229.108:4000", "nonce": 24998, "pow_hash": "00004791d6e3042a876d465e63b5d6104ded6e492cd23300b6455eeed2b36701", "difficulty": 4, "datetime": "2025-08-28T15:44:51.791505+00:00"}];
-DID: "did:hmp:377e75d2-9eaf-4bfa-a02c-e9cc063b72d1"; NAME: "Agent_112"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAuvk/l8iJIQ3DcFJg+Jn5SFg+9xc7VRZ7p5SwsKyIwt4=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://95.72.96.112:4000", "nonce": 11491, "pow_hash": "0000b2f6b325bdf17b0da5ba1a3e66ed7cd49ba45ba681477af11e89ccd01ca8", "difficulty": 4, "datetime": "2025-08-28T15:47:03.319703+00:00"}, {"addr": "udp://95.72.96.112:4000", "nonce": 18356, "pow_hash": "0000d2c1e2b48141a15bad3f2be0ad091972be28f8e4e4fba5004bbfbc12f1ef", "difficulty": 4, "datetime": "2025-08-28T15:47:03.362438+00:00"}, {"addr": "tcp://195.172.229.112:4000", "nonce": 171, "pow_hash": "0000c5b7b126e83b93d3e809b022d7bf38225766d194052d15f6a750c465b515", "difficulty": 4, "datetime": "2025-08-28T15:47:03.404411+00:00"}, {"addr": "udp://195.172.229.112:4000", "nonce": 48621, "pow_hash": "000007acb2d37c02f0e3f2ce9bb4c1fd29bbbd2953a3f3218ee1313a18e662d9", "difficulty": 4, "datetime": "2025-08-28T15:47:03.404820+00:00"}];
-DID: "did:hmp:25e6c264-8e16-4bb7-8cce-5930f757df98"; NAME: "Agent_116"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAFgW23nQgQ89si67ZcRbsoZXqSS2rrWFnMAYKib29orA=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://95.72.96.116:4000", "nonce": 19471, "pow_hash": "000049397d5e7f91f09d6aa3da1537fedb95a1ef3456006a739cb4e81d37ee20", "difficulty": 4, "datetime": "2025-08-28T15:48:44.898372+00:00"}, {"addr": "udp://95.72.96.116:4000", "nonce": 67946, "pow_hash": "00002fb896fe39cf18408c5d87ee83a5e8eb76326205e5254e862b70bd336864", "difficulty": 4, "datetime": "2025-08-28T15:48:44.945521+00:00"}, {"addr": "tcp://195.172.229.116:4000", "nonce": 106038, "pow_hash": "000032d57ddc691502e9aea72fc2f3fd9018d6c5127f6c971af6aae2d964d5e9", "difficulty": 4, "datetime": "2025-08-28T15:48:45.097886+00:00"}, {"addr": "udp://195.172.229.116:4000", "nonce": 20754, "pow_hash": "00008df5e84f7d98b3e756784cad7a6518d202273ac5b9fcc6918803da0a815e", "difficulty": 4, "datetime": "2025-08-28T15:48:45.374646+00:00"}];
-DID: "did:hmp:3a30112e-6b14-4161-8ce9-189a6f4bdd1e"; NAME: "Agent_120"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAPIYEVWz9lBfxBI1MCHMoyVqAJpWH5wwLjAAFKV7Q6UM=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://95.72.96.120:4000", "nonce": 48308, "pow_hash": "0000bbf1c4880c752362fe6100d1eddb98530e9b36f7dda366dfbd3e8860a680", "difficulty": 4, "datetime": "2025-08-28T15:50:17.822119+00:00"}, {"addr": "udp://95.72.96.120:4000", "nonce": 277204, "pow_hash": "0000e71c10d990fb4af04a3a171f9735291ab21a8807acf9284fc39817e028a3", "difficulty": 4, "datetime": "2025-08-28T15:50:17.935199+00:00"}, {"addr": "tcp://195.172.229.120:4000", "nonce": 74353, "pow_hash": "0000c16fcdbbc456b93680fdf48e3a844a477d038c362dd01d70219d566defb0", "difficulty": 4, "datetime": "2025-08-28T15:50:18.661732+00:00"}, {"addr": "udp://195.172.229.120:4000", "nonce": 9937, "pow_hash": "000019a037ff2c15c8b88e45d63152dee141a779628370692973626bf0c343f7", "difficulty": 4, "datetime": "2025-08-28T15:50:18.849814+00:00"}];
+DID: "did:hmp:300d25eb-25e2-4f8a-a1a9-818f09f67be4"; NAME: "Agent_203"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAAvaR44j54884fTvTX4qQ1o7bvpaT8ZnP/+FHmhl4xp4=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://97.203.96.27:4010", "nonce": 7364, "pow_hash": "00005fa2053a7dbc7e06269d427540668b7832982be8504189ae60822f17b613", "difficulty": 4, "datetime": "2025-08-28T21:01:16+00:00"}, {"addr": "udp://97.203.96.27:4010", "nonce": 46359, "pow_hash": "00008c063b6964de0bc509f412fc4bb13f6b61a55e96ed7f16ff5f1d2b8615b8", "difficulty": 4, "datetime": "2025-08-28T21:01:16+00:00"}];
+DID: "did:hmp:424e79ff-6d44-4b43-9c04-883f76bce800"; NAME: "Agent_207"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAQ4p/UgxONBwF1Zo7dj0IqseesMpydBmqrWCZZrNnqAw=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://97.207.96.27:4010", "nonce": 90667, "pow_hash": "000078c10f5bf921115e57f73270ce36135ed2d92584bd7477afcd6951db55da", "difficulty": 4, "datetime": "2025-08-28T21:04:08+00:00"}, {"addr": "udp://97.207.96.27:4010", "nonce": 9245, "pow_hash": "000050bb4afd13fec665d289e52df1a71001f47e9cda29665d43a60ac260bb9d", "difficulty": 4, "datetime": "2025-08-28T21:04:08+00:00"}];
+DID: "did:hmp:5f8bd63d-f31e-46aa-b95a-f95775945549"; NAME: "Agent_209"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEA5IZRyvQZDqEo+/W4sHRVyoSh1yRElqmIYKAyO54y8sY=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://97.209.96.27:4010", "nonce": 20846, "pow_hash": "0000736894e8b9a06edaba964cabc5341f18102c4f20248aa27bb13fb4d13d71", "difficulty": 4, "datetime": "2025-08-28T21:07:58+00:00"}, {"addr": "udp://97.209.96.27:4010", "nonce": 117913, "pow_hash": "0000f5b2b30244f7851ccf9473fa89583034201e4d9b26b3261cb6ea70034051", "difficulty": 4, "datetime": "2025-08-28T21:07:58+00:00"}];

agents/examples/bootstrap.txt

@@ -1,4 +1,3 @@
-DID: "did:hmp:87836dac-a93c-4203-8710-5e4711b07e02"; NAME: "Agent_108"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAzqHBnykJSRs6PsvpsEXdZNSPAs+voBarQYDAR0B664I=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://95.72.96.108:4000", "nonce": 67802, "pow_hash": "00002dbeb3936beffc746b25bdbeff0e20c7c164281f9ebe4d03e76a28592211", "difficulty": 4, "datetime": "2025-08-28T15:44:51.608882+00:00"}, {"addr": "udp://95.72.96.108:4000", "nonce": 8072, "pow_hash": "0000e54c7d2a5e0dabd811e1b1ac3f8ec94029b29382d8bf8a9fe3fc12985dc6", "difficulty": 4, "datetime": "2025-08-28T15:44:51.773206+00:00"}, {"addr": "tcp://195.172.229.108:4000", "nonce": 368, "pow_hash": "000089b642d389d1c5e36f93e0983158c676e2cae21b981fe978c8488ed679e0", "difficulty": 4, "datetime": "2025-08-28T15:44:51.790767+00:00"}, {"addr": "udp://195.172.229.108:4000", "nonce": 24998, "pow_hash": "00004791d6e3042a876d465e63b5d6104ded6e492cd23300b6455eeed2b36701", "difficulty": 4, "datetime": "2025-08-28T15:44:51.791505+00:00"}];
-DID: "did:hmp:377e75d2-9eaf-4bfa-a02c-e9cc063b72d1"; NAME: "Agent_112"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAuvk/l8iJIQ3DcFJg+Jn5SFg+9xc7VRZ7p5SwsKyIwt4=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://95.72.96.112:4000", "nonce": 11491, "pow_hash": "0000b2f6b325bdf17b0da5ba1a3e66ed7cd49ba45ba681477af11e89ccd01ca8", "difficulty": 4, "datetime": "2025-08-28T15:47:03.319703+00:00"}, {"addr": "udp://95.72.96.112:4000", "nonce": 18356, "pow_hash": "0000d2c1e2b48141a15bad3f2be0ad091972be28f8e4e4fba5004bbfbc12f1ef", "difficulty": 4, "datetime": "2025-08-28T15:47:03.362438+00:00"}, {"addr": "tcp://195.172.229.112:4000", "nonce": 171, "pow_hash": "0000c5b7b126e83b93d3e809b022d7bf38225766d194052d15f6a750c465b515", "difficulty": 4, "datetime": "2025-08-28T15:47:03.404411+00:00"}, {"addr": "udp://195.172.229.112:4000", "nonce": 48621, "pow_hash": "000007acb2d37c02f0e3f2ce9bb4c1fd29bbbd2953a3f3218ee1313a18e662d9", "difficulty": 4, "datetime": "2025-08-28T15:47:03.404820+00:00"}];
-DID: "did:hmp:25e6c264-8e16-4bb7-8cce-5930f757df98"; NAME: "Agent_116"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAFgW23nQgQ89si67ZcRbsoZXqSS2rrWFnMAYKib29orA=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://95.72.96.116:4000", "nonce": 19471, "pow_hash": "000049397d5e7f91f09d6aa3da1537fedb95a1ef3456006a739cb4e81d37ee20", "difficulty": 4, "datetime": "2025-08-28T15:48:44.898372+00:00"}, {"addr": "udp://95.72.96.116:4000", "nonce": 67946, "pow_hash": "00002fb896fe39cf18408c5d87ee83a5e8eb76326205e5254e862b70bd336864", "difficulty": 4, "datetime": "2025-08-28T15:48:44.945521+00:00"}, {"addr": "tcp://195.172.229.116:4000", "nonce": 106038, "pow_hash": "000032d57ddc691502e9aea72fc2f3fd9018d6c5127f6c971af6aae2d964d5e9", "difficulty": 4, "datetime": "2025-08-28T15:48:45.097886+00:00"}, {"addr": "udp://195.172.229.116:4000", "nonce": 20754, "pow_hash": "00008df5e84f7d98b3e756784cad7a6518d202273ac5b9fcc6918803da0a815e", "difficulty": 4, "datetime": "2025-08-28T15:48:45.374646+00:00"}];
-DID: "did:hmp:3a30112e-6b14-4161-8ce9-189a6f4bdd1e"; NAME: "Agent_120"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAPIYEVWz9lBfxBI1MCHMoyVqAJpWH5wwLjAAFKV7Q6UM=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://95.72.96.120:4000", "nonce": 48308, "pow_hash": "0000bbf1c4880c752362fe6100d1eddb98530e9b36f7dda366dfbd3e8860a680", "difficulty": 4, "datetime": "2025-08-28T15:50:17.822119+00:00"}, {"addr": "udp://95.72.96.120:4000", "nonce": 277204, "pow_hash": "0000e71c10d990fb4af04a3a171f9735291ab21a8807acf9284fc39817e028a3", "difficulty": 4, "datetime": "2025-08-28T15:50:17.935199+00:00"}, {"addr": "tcp://195.172.229.120:4000", "nonce": 74353, "pow_hash": "0000c16fcdbbc456b93680fdf48e3a844a477d038c362dd01d70219d566defb0", "difficulty": 4, "datetime": "2025-08-28T15:50:18.661732+00:00"}, {"addr": "udp://195.172.229.120:4000", "nonce": 9937, "pow_hash": "000019a037ff2c15c8b88e45d63152dee141a779628370692973626bf0c343f7", "difficulty": 4, "datetime": "2025-08-28T15:50:18.849814+00:00"}];
+DID: "did:hmp:300d25eb-25e2-4f8a-a1a9-818f09f67be4"; NAME: "Agent_203"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAAvaR44j54884fTvTX4qQ1o7bvpaT8ZnP/+FHmhl4xp4=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://97.203.96.27:4010", "nonce": 7364, "pow_hash": "00005fa2053a7dbc7e06269d427540668b7832982be8504189ae60822f17b613", "difficulty": 4, "datetime": "2025-08-28T21:01:16+00:00"}, {"addr": "udp://97.203.96.27:4010", "nonce": 46359, "pow_hash": "00008c063b6964de0bc509f412fc4bb13f6b61a55e96ed7f16ff5f1d2b8615b8", "difficulty": 4, "datetime": "2025-08-28T21:01:16+00:00"}];
+DID: "did:hmp:424e79ff-6d44-4b43-9c04-883f76bce800"; NAME: "Agent_207"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAQ4p/UgxONBwF1Zo7dj0IqseesMpydBmqrWCZZrNnqAw=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://97.207.96.27:4010", "nonce": 90667, "pow_hash": "000078c10f5bf921115e57f73270ce36135ed2d92584bd7477afcd6951db55da", "difficulty": 4, "datetime": "2025-08-28T21:04:08+00:00"}, {"addr": "udp://97.207.96.27:4010", "nonce": 9245, "pow_hash": "000050bb4afd13fec665d289e52df1a71001f47e9cda29665d43a60ac260bb9d", "difficulty": 4, "datetime": "2025-08-28T21:04:08+00:00"}];
+DID: "did:hmp:5f8bd63d-f31e-46aa-b95a-f95775945549"; NAME: "Agent_209"; KEY: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEA5IZRyvQZDqEo+/W4sHRVyoSh1yRElqmIYKAyO54y8sY=\n-----END PUBLIC KEY-----\n"; ADDRESS: [{"addr": "tcp://97.209.96.27:4010", "nonce": 20846, "pow_hash": "0000736894e8b9a06edaba964cabc5341f18102c4f20248aa27bb13fb4d13d71", "difficulty": 4, "datetime": "2025-08-28T21:07:58+00:00"}, {"addr": "udp://97.209.96.27:4010", "nonce": 117913, "pow_hash": "0000f5b2b30244f7851ccf9473fa89583034201e4d9b26b3261cb6ea70034051", "difficulty": 4, "datetime": "2025-08-28T21:07:58+00:00"}];

agents/init.py

@@ -55,8 +55,8 @@ def init_identity(storage, config):
             "pubkey": pubkey,
             "privkey": privkey,
             "metadata": json.dumps({"role": config.get("agent_role", "core")}),
-            "created_at": datetime.now(UTC).isoformat(),
-            "updated_at": datetime.now(UTC).isoformat()
+            "created_at": datetime.now(UTC).replace(microsecond=0).isoformat(),
+            "updated_at": datetime.now(UTC).replace(microsecond=0).isoformat()
         }
         storage.add_identity(identity)
 
@@ -109,7 +109,7 @@ def init_llm_backends(storage, config):
             "name": backend["name"],
             "endpoint": desc,
             "metadata": json.dumps(backend),
-            "created_at": datetime.now(UTC).isoformat()
+            "created_at": datetime.now(UTC).replace(microsecond=0).isoformat()
         }
         storage.add_llm(llm)
         print(f"[+] Зарегистрирован LLM: {backend['name']}")
@@ -140,7 +140,7 @@ def update_pow_for_addresses(storage, difficulty=4):
         "nonce": 108834,
         "pow_hash": "0000665ea1440781356d7a9b899fc03a01a4f8342d3cfa3d75bb2619b66b4cfb",
         "difficulty": 4,
-        "datetime": "2025-08-28T11:00:00+03:00"
+        "datetime": "2025-08-28T11:00:00+00:00"
     }
     """
     raw_id = storage.get_config_value("agent_id")
@@ -171,7 +171,7 @@ def update_pow_for_addresses(storage, difficulty=4):
 
         enriched = []
         for addr in addresses:
-            dt_now = datetime.now(UTC).isoformat()
+            dt_now = datetime.now(UTC).replace(microsecond=0).isoformat()
 
             if isinstance(addr, dict) and "addr" in addr and "pow_hash" in addr:
                 # уже в новом формате → оставляем как есть
@@ -180,7 +180,7 @@ def update_pow_for_addresses(storage, difficulty=4):
 
             # строка → нужно сгенерировать PoW
             addr_str = addr if isinstance(addr, str) else addr.get("address")
-            dt_now = datetime.now(UTC).isoformat()
+            dt_now = datetime.now(UTC).replace(microsecond=0).isoformat()
             if addr_str:
                 nonce, hash_value, dt_now = storage.generate_pow(
                     peer_id=agent_id,
@@ -227,7 +227,7 @@ def init_prompts_and_ethics():
                 ON CONFLICT(id) DO UPDATE SET
                     content=excluded.content,
                     updated_at=excluded.updated_at
-            """, (pid, fname, ptype, "1.0", "local", content, datetime.now(UTC).isoformat()))
+            """, (pid, fname, ptype, "1.0", "local", content, datetime.now(UTC).replace(microsecond=0).isoformat()))
             print(f"[+] Загружен промпт: {fname} ({ptype})")
 
         # Загружаем ethics.yml
@@ -273,7 +273,7 @@ def init_prompts_and_ethics():
                 json.dumps(ethics_data.get("evaluation"), ensure_ascii=False),
                 json.dumps(ethics_data.get("violation_policy"), ensure_ascii=False),
                 json.dumps(ethics_data.get("audit"), ensure_ascii=False),
-                datetime.now(UTC).isoformat()
+                datetime.now(UTC).replace(microsecond=0).isoformat()
             ))
             print(f"[+] Загружена этическая политика: {eid}")
         else:

agents/peer_sync.py

@@ -8,6 +8,9 @@ import select
 import netifaces
 import re
 import ipaddress
+import asyncio
+import dateutil.parser
+
 
 from datetime import datetime, timezone as UTC
 from tools.storage import Storage
@@ -134,67 +137,76 @@ def load_bootstrap_peers(filename="bootstrap.txt"):
 # UDP Discovery
 # ---------------------------
 def udp_discovery():
+    import dateutil.parser  # для парсинга ISO datetime
     DISCOVERY_INTERVAL = 30
 
-    while True:
-        try:
-            # Получаем локальные адреса из storage
-            local_addresses = storage.get_config_value("local_addresses", [])
-            msg_data = json.dumps({
-                "id": my_id,
-                "name": agent_name,
-                "addresses": local_addresses
-            }).encode("utf-8")
+    try:
+        # --- Создаём слушающие сокеты один раз ---
+        listen_sockets = []
+        local_addresses = storage.get_config_value("local_addresses", [])
+        print(f"[UDP Discovery] Local addresses (init): {local_addresses}")
+
+        for entry in local_addresses:
+            addr_str = entry.get("addr") if isinstance(entry, dict) else entry
+            if not addr_str:
+                continue
 
-            # Создаём UDP сокеты для прослушки
-            listen_sockets = []
-            for entry in local_addresses:
-                addr_str = entry.get("addr") if isinstance(entry, dict) else entry
-                pubkey = entry.get("pubkey") if isinstance(entry, dict) else None
-                if not addr_str:
-                    continue
+            proto, hostport = addr_str.split("://", 1)
+            host, port = storage.parse_hostport(hostport)
+            if not port or proto.lower() != "udp":
+                continue
 
-                proto, hostport = addr_str.split("://", 1)
-                host, port = storage.parse_hostport(hostport)
-                if not port or proto.lower() != "udp":
-                    continue
+            # IPv4
+            if not host.startswith("["):
+                try:
+                    sock4 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+                    sock4.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                    sock4.bind(("", port))
+                    listen_sockets.append(sock4)
+                    print(f"[UDP Discovery] Listening IPv4 on *:{port}")
+                except Exception as e:
+                    print(f"[UDP Discovery] IPv4 bind failed on port {port}: {e}")
 
-                # IPv4
-                if not host.startswith("["):
-                    try:
-                        sock4 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-                        sock4.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-                        sock4.bind(("", port))
-                        listen_sockets.append(sock4)
-                        print(f"[UDP Discovery] Listening IPv4 on *:{port}")
-                    except Exception as e:
-                        print(f"[UDP Discovery] IPv4 bind failed on port {port}: {e}")
+            # IPv6
+            else:
+                try:
+                    sock6 = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
+                    sock6.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                    sock6.bind(("::", port))
+                    listen_sockets.append(sock6)
+                    print(f"[UDP Discovery] Listening IPv6 on [::]:{port}")
+                except Exception as e:
+                    print(f"[UDP Discovery] IPv6 bind failed on port {port}: {e}")
 
-                # IPv6
-                else:
-                    try:
-                        sock6 = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
-                        sock6.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-                        sock6.bind(("::", port))
-                        listen_sockets.append(sock6)
-                        print(f"[UDP Discovery] Listening IPv6 on [::]:{port}")
-                    except Exception as e:
-                        print(f"[UDP Discovery] IPv6 bind failed on port {port}: {e}")
+    except Exception as init_e:
+        print(f"[UDP Discovery] init error: {init_e}")
+        return
+
+    # --- Основной цикл ---
+    agent_pubkey = storage.get_config_value("agent_pubkey")
 
-            # Приём сообщений
+    while True:
+        try:
+            # Приём входящих пакетов
             if listen_sockets:
                 rlist, _, _ = select.select(listen_sockets, [], [], 0.5)
                 for sock in rlist:
                     try:
                         data, addr = sock.recvfrom(2048)
-                        msg = json.loads(data.decode("utf-8"))
+                        print(f"[UDP Discovery] RAW from {addr}: {data!r}")
+
+                        try:
+                            msg = json.loads(data.decode("utf-8"))
+                        except Exception as e:
+                            print(f"[UDP Discovery] JSON decode error from {addr}: {e}")
+                            continue
+
                         peer_id = msg.get("id")
                         if peer_id == my_id:
                             continue
                         name = msg.get("name", "unknown")
                         addresses = msg.get("addresses", [])
 
-                        # Фильтруем адреса по PoW и datetime
                         valid_addresses = []
                         for a in addresses:
                             addr_str = a.get("addr")
@@ -204,20 +216,28 @@ def udp_discovery():
                             dt = a.get("datetime")
                             pubkey = a.get("pubkey")
 
-                            if not addr_str:
+                            if not addr_str or not pubkey:
                                 continue
 
                             # Проверка PoW
-                            if nonce is not None and pow_hash and difficulty is not None and pubkey:
-                                if not storage.verify_pow(peer_id, pubkey, addr_str, nonce, pow_hash, dt, difficulty):
+                            if nonce is not None and pow_hash and difficulty is not None:
+                                ok = storage.verify_pow(peer_id, pubkey, addr_str, nonce, pow_hash, dt, difficulty)
+                                print(f"[UDP Discovery] Verify PoW for {addr_str} = {ok}")
+                                if not ok:
                                     continue
 
-                            # Проверяем datetime
+                            # Проверка datetime
                             existing = storage.get_peer_address(peer_id, addr_str)
-                            if existing:
-                                existing_dt = existing.get("datetime")
-                                if existing_dt and existing_dt >= dt:
-                                    continue
+                            try:
+                                existing_dt = dateutil.parser.isoparse(existing.get("datetime")) if existing else None
+                                dt_obj = dateutil.parser.isoparse(dt) if dt else None
+                            except Exception as e:
+                                print(f"[UDP Discovery] datetime parse error: {e}")
+                                continue
+
+                            if existing_dt and dt_obj and existing_dt >= dt_obj:
+                                print(f"[UDP Discovery] Skip {addr_str}: old datetime {dt}")
+                                continue
 
                             valid_addresses.append(a)
 
@@ -229,27 +249,31 @@ def udp_discovery():
                                 source="discovery",
                                 status="online"
                             )
-                            print(f"[UDP Discovery] peer={peer_id} from {addr}")
+                            print(f"[UDP Discovery] Accepted peer {peer_id} ({addr}), {len(valid_addresses)} addresses")
 
                     except Exception as e:
                         print(f"[UDP Discovery] receive error: {e}")
 
-            # Отправка broadcast/multicast с фильтрацией по PoW и datetime
+            # --- Отправка broadcast/multicast ---
+            local_addresses = storage.get_config_value("local_addresses", [])
             valid_local_addresses = []
+
             for a in local_addresses:
                 addr_str = a.get("addr") if isinstance(a, dict) else a
                 nonce = a.get("nonce")
                 pow_hash = a.get("pow_hash")
                 difficulty = a.get("difficulty")
                 dt = a.get("datetime")
-                pubkey = a.get("pubkey") if isinstance(a, dict) else None
+                pubkey = a.get("pubkey") if isinstance(a, dict) else agent_pubkey  # self-check
 
-                if not addr_str or not pubkey:
+                if not addr_str:
                     continue
 
-                # Проверка PoW
+                # Проверка PoW только если есть необходимые поля
                 if nonce is not None and pow_hash and difficulty is not None:
-                    if not storage.verify_pow(my_id, pubkey, addr_str, nonce, pow_hash, dt, difficulty):
+                    ok = storage.verify_pow(my_id, pubkey, addr_str, nonce, pow_hash, dt, difficulty)
+                    print(f"[UDP Discovery] Self-check PoW for {addr_str} = {ok}")
+                    if not ok:
                         continue
 
                 valid_local_addresses.append(a)
@@ -260,6 +284,8 @@ def udp_discovery():
                 "addresses": valid_local_addresses
             }).encode("utf-8")
 
+            print(f"[UDP Discovery] Broadcasting: {msg_data}")
+
             for entry in valid_local_addresses:
                 addr_str = entry.get("addr")
                 proto, hostport = addr_str.split("://", 1)
@@ -276,10 +302,11 @@ def udp_discovery():
                                 try:
                                     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                                     sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+                                    print(f"[UDP Discovery] Sending broadcast -> {a['broadcast']}:{port}")
                                     sock.sendto(msg_data, (a["broadcast"], port))
                                     sock.close()
-                                except Exception:
-                                    continue
+                                except Exception as e:
+                                    print(f"[UDP Discovery] Broadcast error {a['broadcast']}:{port}: {e}")
 
                 # IPv6 multicast ff02::1
                 else:
@@ -294,10 +321,11 @@ def udp_discovery():
                                 sock6 = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
                                 sock6.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_IF, socket.if_nametoindex(iface))
                                 sock6.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_HOPS, 1)
+                                print(f"[UDP Discovery] Sending multicast -> {multicast_addr}:{port}")
                                 sock6.sendto(msg_data, (multicast_addr, port))
                                 sock6.close()
-                            except Exception:
-                                continue
+                            except Exception as e:
+                                print(f"[UDP Discovery] Multicast error {multicast_addr}:{port}: {e}")
 
             time.sleep(DISCOVERY_INTERVAL)
 
@@ -309,6 +337,7 @@ def udp_discovery():
 # TCP Peer Exchange (исходящие)
 # ---------------------------
 def tcp_peer_exchange():
+    import dateutil.parser  # для корректного парсинга ISO datetime
     PEER_EXCHANGE_INTERVAL = 20  # секунды для отладки
 
     while True:
@@ -336,23 +365,29 @@ def tcp_peer_exchange():
                 dt = addr_entry.get("datetime")
                 pubkey = addr_entry.get("pubkey")
 
-                # Нормализация адреса
                 norm = storage.normalize_address(addr_str)
                 if not norm:
                     continue
 
                 # Проверка PoW
                 if nonce is not None and pow_hash and difficulty is not None and pubkey:
-                    if not storage.verify_pow(peer_id, pubkey, addr_str, nonce, pow_hash, dt, difficulty):
-                        print(f"[PeerExchange] PoW check failed for {addr_str}")
+                    ok = storage.verify_pow(peer_id, pubkey, addr_str, nonce, pow_hash, dt, difficulty)
+                    print(f"[PeerExchange] Verify PoW for {peer_id}@{addr_str} = {ok}")
+                    if not ok:
                         continue
 
-                # Проверяем datetime
+                # Проверка datetime с использованием dateutil
                 existing = storage.get_peer_address(peer_id, addr_str)
-                if existing:
-                    existing_dt = existing.get("datetime")
-                    if existing_dt and existing_dt >= dt:
-                        continue  # старый адрес, пропускаем
+                try:
+                    existing_dt = dateutil.parser.isoparse(existing.get("datetime")) if existing else None
+                    dt_obj = dateutil.parser.isoparse(dt) if dt else None
+                except Exception as e:
+                    print(f"[PeerExchange] datetime parse error for {addr_str}: {e}")
+                    continue
+
+                if existing_dt and dt_obj and existing_dt >= dt_obj:
+                    print(f"[PeerExchange] Skip {addr_str}: old datetime {dt}")
+                    continue
 
                 # Парсим host и port
                 proto, hostport = norm.split("://", 1)
@@ -380,7 +415,7 @@ def tcp_peer_exchange():
                         sock.settimeout(3)
                         sock.connect((host, port))
 
-                    # Отправка своих адресов
+                    # Отправляем handshake
                     if storage.is_private(host):
                         send_addresses = all_addresses
                     else:
@@ -395,8 +430,11 @@ def tcp_peer_exchange():
                         "name": agent_name,
                         "addresses": send_addresses,
                     }
-                    sock.sendall(json.dumps(handshake).encode("utf-8"))
+                    raw_handshake = json.dumps(handshake).encode("utf-8")
+                    print(f"[PeerExchange] Sending handshake -> {host}:{port}: {raw_handshake}")
+                    sock.sendall(raw_handshake)
 
+                    # Читаем ответ
                     data = sock.recv(64 * 1024)
                     sock.close()
 
@@ -404,15 +442,25 @@ def tcp_peer_exchange():
                         print(f"[PeerExchange] No data from {host}:{port}")
                         continue
 
+                    print(f"[PeerExchange] RAW recv from {host}:{port}: {data!r}")
+
                     try:
                         peers_recv = json.loads(data.decode("utf-8"))
+                        print(f"[PeerExchange] Parsed recv from {host}:{port}: {peers_recv}")
                         for p in peers_recv:
-                            # Сохраняем только новые адреса или более новые datetime
                             new_addrs = []
                             for a in p.get("addresses", []):
-                                existing_addr = storage.get_peer_address(p["id"], a.get("addr"))
-                                if existing_addr is None or existing_addr.get("datetime", "") < a.get("datetime", ""):
-                                    new_addrs.append(a)
+                                try:
+                                    existing_addr = storage.get_peer_address(p["id"], a.get("addr"))
+                                    existing_dt = dateutil.parser.isoparse(existing_addr.get("datetime")) if existing_addr else None
+                                    dt_obj = dateutil.parser.isoparse(a.get("datetime")) if a.get("datetime") else None
+                                    if existing_addr is None or (existing_dt and dt_obj and existing_dt < dt_obj) or existing_dt is None:
+                                        new_addrs.append(a)
+                                    else:
+                                        print(f"[PeerExchange] Ignored old {a.get('addr')} from {p['id']}")
+                                except Exception as e:
+                                    print(f"[PeerExchange] Error parsing datetime for {a.get('addr')}: {e}")
+                                    continue
 
                             if new_addrs:
                                 storage.add_or_update_peer(
@@ -422,9 +470,10 @@ def tcp_peer_exchange():
                                     source="peer_exchange",
                                     status="online"
                                 )
+                                print(f"[PeerExchange] Stored {len(new_addrs)} new addrs for peer {p['id']}")
                         print(f"[PeerExchange] Received {len(peers_recv)} peers from {host}:{port}")
                     except Exception as e:
-                        print(f"[PeerExchange] Decode error from {host}:{port} -> {e}")
+                        print(f"[PeerExchange] Decode error from {host}:{port}: {e}")
                         continue
 
                     break
@@ -463,11 +512,15 @@ def tcp_listener():
                 conn, addr = s.accept()
                 data = conn.recv(64 * 1024)
                 if not data:
+                    print(f"[TCP Listener] Empty data from {addr}, closing")
                     conn.close()
                     continue
 
+                print(f"[TCP Listener] RAW recv from {addr}: {data!r}")
+
                 try:
                     msg = json.loads(data.decode("utf-8"))
+                    print(f"[TCP Listener] Decoded JSON from {addr}: {msg}")
                 except Exception as e:
                     print(f"[TCP Listener] JSON decode error from {addr}: {e}")
                     conn.close()
@@ -478,7 +531,6 @@ def tcp_listener():
                     peer_name = msg.get("name", "unknown")
                     peer_addrs = msg.get("addresses", [])
 
-                    # Добавляем/обновляем пира только если PoW валидный и datetime новее
                     valid_addrs = []
                     for a in peer_addrs:
                         addr_value = a.get("addr")
@@ -489,16 +541,25 @@ def tcp_listener():
                         pubkey = a.get("pubkey")
 
                         if not addr_value or nonce is None or not pow_hash or not pubkey:
+                            print(f"[TCP Listener] Skip addr (incomplete): {a}")
                             continue
 
-                        if not storage.verify_pow(peer_id, pubkey, addr_value, nonce, pow_hash, dt, difficulty):
+                        ok = storage.verify_pow(peer_id, pubkey, addr_value, nonce, pow_hash, dt, difficulty)
+                        print(f"[TCP Listener] Verify PoW for {addr_value} = {ok}")
+                        if not ok:
                             continue
 
                         existing = storage.get_peer_address(peer_id, addr_value)
-                        if existing:
-                            existing_dt = existing.get("datetime")
-                            if existing_dt and existing_dt >= dt:
-                                continue  # старый адрес
+                        try:
+                            existing_dt = dateutil.parser.isoparse(existing.get("datetime")) if existing else None
+                            dt_obj = dateutil.parser.isoparse(dt) if dt else None
+                        except Exception as e:
+                            print(f"[TCP Listener] datetime parse error for {addr_value}: {e}")
+                            continue
+
+                        if existing_dt and dt_obj and existing_dt >= dt_obj:
+                            print(f"[TCP Listener] Skip old addr {addr_value} (dt={dt})")
+                            continue
 
                         valid_addrs.append(a)
 
@@ -510,10 +571,13 @@ def tcp_listener():
                             source="incoming",
                             status="online"
                         )
+                        print(f"[TCP Listener] Stored {len(valid_addrs)} addrs for peer {peer_id}")
+                    else:
+                        print(f"[TCP Listener] No valid addrs from {peer_id}")
 
-                    print(f"[TCP Listener] Handshake from {peer_id} ({addr})")
+                    print(f"[TCP Listener] Handshake from {peer_id} ({addr}) -> name={peer_name}")
 
-                    # Отправляем актуальные адреса собеседнику
+                    # Готовим список пиров для ответа
                     is_lan = storage.is_private(addr[0])
                     peers_list = []
 
@@ -526,24 +590,34 @@ def tcp_listener():
 
                         updated_addresses = []
                         for a in addresses:
-                            proto, hostport = a["addr"].split("://")
-                            host, port = storage.parse_hostport(hostport)
+                            try:
+                                proto, hostport = a["addr"].split("://", 1)
+                                host, port = storage.parse_hostport(hostport)
+                                if not host or not port:
+                                    continue
 
-                            # Фильтруем по LAN/Internet
-                            if not is_lan and not is_public(host):
-                                continue
+                                if not is_lan and not is_public(host):
+                                    continue
 
-                            # IPv6 link-local
-                            if storage.is_ipv6(host) and host.startswith("fe80:"):
-                                scope_id = storage.get_ipv6_scope(host)
-                                if scope_id:
-                                    host = f"{host}%{scope_id}"
+                                if storage.is_ipv6(host) and host.startswith("fe80:"):
+                                    scope_id = storage.get_ipv6_scope(host)
+                                    if scope_id:
+                                        host = f"{host}%{scope_id}"
 
-                            updated_addresses.append(f"{proto}://{host}:{port}")
+                                updated_addresses.append({
+                                    "addr": f"{proto}://{host}:{port}"
+                                })
+                            except Exception:
+                                continue
 
-                        peers_list.append({"id": peer_id_local, "addresses": updated_addresses})
+                        peers_list.append({
+                            "id": peer_id_local,
+                            "addresses": updated_addresses
+                        })
 
+                    print(f"[TCP Listener] Sending {len(peers_list)} peers back to {peer_id}")
                     conn.sendall(json.dumps(peers_list).encode("utf-8"))
+
                 conn.close()
             except Exception as e:
                 print(f"[TCP Listener] Connection handling error: {e}")

agents/requirements.txt

@@ -14,4 +14,5 @@ passlib[bcrypt]
 werkzeug
 itsdangerous
 bleach
-netifaces
+netifaces
+python-dateutil

agents/tools/storage.py

@@ -677,12 +677,14 @@ class Storage:
         self.conn.commit()
         return cursor.lastrowid
 
+    # --- Генерация PoW ---
     def generate_pow(self, peer_id, pubkey, address, dt=None, difficulty=4):
         """
         Генерирует PoW для (peer_id + pubkey + address + datetime).
+        Используется ISO 8601 без микросекунд, UTC.
         """
         if dt is None:
-            dt = datetime.now(UTC).isoformat()
+            dt = datetime.now(timezone.utc).replace(microsecond=0).isoformat()
 
         nonce = 0
         prefix = "0" * difficulty
@@ -1008,10 +1010,12 @@ class Storage:
         return did.strip().strip('"').strip("'")
 
     # Работа с пирам (agent_peers)
+    # --- Проверка PoW ---
     @staticmethod
     def verify_pow(peer_id, pubkey, address, nonce, pow_hash, dt, difficulty=4):
         """
         Проверяет PoW (peer_id + pubkey + address + datetime).
+        dt ожидается в формате ISO 8601 без микросекунд, UTC.
         """
         base = f"{peer_id}{pubkey}{address}{dt}{nonce}".encode()
         h = hashlib.sha256(base).hexdigest()
@@ -1029,7 +1033,18 @@ class Storage:
         norm_addresses = []
         for a in (addresses or []):
             if isinstance(a, dict) and "addr" in a:
-                dt = a.get("datetime") or datetime.now(UTC).isoformat()
+                # нормализация datetime: ISO 8601 без микросекунд
+                dt_raw = a.get("datetime")
+                if dt_raw:
+                    try:
+                        dt_obj = datetime.fromisoformat(dt_raw)
+                        dt_obj = dt_obj.astimezone(timezone.utc).replace(microsecond=0)
+                        dt = dt_obj.isoformat()
+                    except Exception:
+                        dt = datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+                else:
+                    dt = datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
                 norm_addresses.append({
                     "addr": self.normalize_address(a["addr"]),
                     "nonce": a.get("nonce"),
@@ -1041,7 +1056,7 @@ class Storage:
                     "addr": self.normalize_address(a),
                     "nonce": None,
                     "pow_hash": None,
-                    "datetime": datetime.now(UTC).isoformat()
+                    "datetime": datetime.now(timezone.utc).replace(microsecond=0).isoformat()
                 })
 
         # получаем существующую запись
@@ -1120,7 +1135,7 @@ class Storage:
             json.dumps(combined_addresses),
             source,
             status,
-            datetime.now(UTC).isoformat(),
+            datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
             final_pubkey,
             json.dumps(final_capabilities),
             json.dumps(combined_heard_from)