npm - soulprint-network - Versions diffs - 0.5.1 → 0.6.0 - Mend

soulprint-network 0.5.1 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/code-hash.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
-  "codeHash": "f950501263286e0f1beb6035756d5b2bd64e39a786fea55be1cdfff475d11c70",
-  "codeHashHex": "0xf950501263286e0f1beb6035756d5b2bd64e39a786fea55be1cdfff475d11c70",
-  "computedAt": "2026-03-01T03:42:20.739Z",
+  "codeHash": "3e63098b6a2421a17bad6792cbc231982327b32c2e77d0ff2be0eda630690f8c",
+  "codeHashHex": "0x3e63098b6a2421a17bad6792cbc231982327b32c2e77d0ff2be0eda630690f8c",
+  "computedAt": "2026-03-01T03:57:58.085Z",
   "fileCount": 25,
   "files": [
     "blockchain/NullifierRegistryClient.ts",

package/dist/index.d.ts CHANGED Viewed

@@ -1,4 +1,2 @@
-export { startValidatorNode, setP2PNode, submitToNode, attestBot, getBotReputation, getNodeInfo, BOOTSTRAP_NODES, } from "./validator.js";
+export { startValidatorNode, submitToNode, attestBot, getBotReputation, getNodeInfo, BOOTSTRAP_NODES, } from "./validator.js";
 export type { NodeVerifyResult } from "./validator.js";
-export { createSoulprintP2PNode, publishAttestationP2P, onAttestationReceived, getP2PStats, stopP2PNode, TOPIC_ATTESTATIONS, TOPIC_NULLIFIERS, MAINNET_BOOTSTRAP, } from "./p2p.js";
-export type { P2PConfig, P2PStats, SoulprintP2PNode } from "./p2p.js";

package/dist/index.js CHANGED Viewed

@@ -1,2 +1 @@
-export { startValidatorNode, setP2PNode, submitToNode, attestBot, getBotReputation, getNodeInfo, BOOTSTRAP_NODES, } from "./validator.js";
-export { createSoulprintP2PNode, publishAttestationP2P, onAttestationReceived, getP2PStats, stopP2PNode, TOPIC_ATTESTATIONS, TOPIC_NULLIFIERS, MAINNET_BOOTSTRAP, } from "./p2p.js";
+export { startValidatorNode, submitToNode, attestBot, getBotReputation, getNodeInfo, BOOTSTRAP_NODES, } from "./validator.js";

package/dist/p2p.d.ts CHANGED Viewed

@@ -1,38 +1,33 @@
 /**
- * Soulprint P2P Layer — Phase 5
- *
- * libp2p con:
- *  - TCP transport
- *  - Noise encryption
- *  - Yamux multiplexing
- *  - Kademlia DHT (peer discovery internet)
- *  - GossipSub (attestation pub/sub)
- *  - mDNS (descubrimiento en LAN)
- *  - Bootstrap nodes (entry points a la red)
+ * p2p.ts — stub (v0.6.0)
+ * libp2p removed. The blockchain IS the network.
+ * This file exists only for backward compatibility with any external imports.
+ * @deprecated Use PeerRegistryClient for peer discovery.
  */
-import type { Libp2p } from "libp2p";
-import type { BotAttestation } from "soulprint-core";
 export declare const TOPIC_ATTESTATIONS = "soulprint:attestations:v1";
 export declare const TOPIC_NULLIFIERS = "soulprint:nullifiers:v1";
 export declare const MAINNET_BOOTSTRAP: string[];
-export interface P2PConfig {
-    /** Puerto TCP para libp2p (default: HTTP_PORT + 2000, e.g. 6888) */
-    port: number;
-    /** Multiaddrs de nodos bootstrap (para conectar a la red principal) */
-    bootstraps: string[];
-    /** true = solo mDNS (desarrollo local). false = DHT público activado */
-    localOnly: boolean;
-}
-export interface P2PStats {
+export type P2PConfig = {
+    port?: number;
+    bootstraps?: string[];
+    localOnly?: boolean;
+};
+export type P2PStats = {
     peerId: string;
     peers: number;
-    multiaddrs: string[];
     pubsubPeers: number;
-}
-export type SoulprintP2PNode = Libp2p;
-export declare function createSoulprintP2PNode(config: P2PConfig): Promise<SoulprintP2PNode>;
-export declare function publishAttestationP2P(node: SoulprintP2PNode, att: BotAttestation): Promise<number>;
-export declare function onAttestationReceived(node: SoulprintP2PNode, handler: (att: BotAttestation, fromPeer: string) => void): void;
-export declare function getP2PStats(node: SoulprintP2PNode): P2PStats;
-export declare function stopP2PNode(node: SoulprintP2PNode): Promise<void>;
-export declare function dialP2PPeer(node: SoulprintP2PNode, maddrStr: string, timeoutMs?: number): Promise<boolean>;
+    multiaddrs: string[];
+};
+export type SoulprintP2PNode = never;
+/** @deprecated No-op stub */
+export declare function createSoulprintP2PNode(_cfg?: P2PConfig): Promise<never>;
+/** @deprecated No-op stub */
+export declare function publishAttestationP2P(_node: any, _att: any): Promise<number>;
+/** @deprecated No-op stub */
+export declare function onAttestationReceived(_node: any, _cb: any): void;
+/** @deprecated No-op stub */
+export declare function getP2PStats(_node: any): P2PStats;
+/** @deprecated No-op stub */
+export declare function stopP2PNode(_node: any): Promise<void>;
+/** @deprecated No-op stub */
+export declare function dialP2PPeer(_node: any, _ma: string): Promise<boolean>;

package/dist/p2p.js CHANGED Viewed

@@ -1,148 +1,29 @@
 /**
- * Soulprint P2P Layer — Phase 5
- *
- * libp2p con:
- *  - TCP transport
- *  - Noise encryption
- *  - Yamux multiplexing
- *  - Kademlia DHT (peer discovery internet)
- *  - GossipSub (attestation pub/sub)
- *  - mDNS (descubrimiento en LAN)
- *  - Bootstrap nodes (entry points a la red)
+ * p2p.ts — stub (v0.6.0)
+ * libp2p removed. The blockchain IS the network.
+ * This file exists only for backward compatibility with any external imports.
+ * @deprecated Use PeerRegistryClient for peer discovery.
  */
-import { createLibp2p } from "libp2p";
-import { tcp } from "@libp2p/tcp";
-import { noise } from "@chainsafe/libp2p-noise";
-import { yamux } from "@chainsafe/libp2p-yamux";
-import { kadDHT } from "@libp2p/kad-dht";
-import { gossipsub } from "@chainsafe/libp2p-gossipsub";
-import { mdns } from "@libp2p/mdns";
-import { bootstrap } from "@libp2p/bootstrap";
-import { identify } from "@libp2p/identify";
-import { ping } from "@libp2p/ping";
-import { fromString, toString } from "uint8arrays";
-// ─── Topics ──────────────────────────────────────────────────────────────────
 export const TOPIC_ATTESTATIONS = "soulprint:attestations:v1";
 export const TOPIC_NULLIFIERS = "soulprint:nullifiers:v1";
-// ─── Bootstrap nodes públicos (mainnet) ──────────────────────────────────────
-// Vacíos hasta que desplegamos nodos públicos.
-// Se pueden pasar vía SOULPRINT_BOOTSTRAP=multiaddr1,multiaddr2
 export const MAINNET_BOOTSTRAP = [];
-// ─── Crear nodo libp2p ────────────────────────────────────────────────────────
-export async function createSoulprintP2PNode(config) {
-    // Peer discovery: siempre mDNS (LAN) + bootstrap si hay nodos configurados
-    const peerDiscovery = [mdns()];
-    if (config.bootstraps.length > 0) {
-        peerDiscovery.push(bootstrap({ list: config.bootstraps }));
-    }
-    const node = await createLibp2p({
-        addresses: {
-            listen: [`/ip4/0.0.0.0/tcp/${config.port}`],
-        },
-        transports: [tcp()],
-        connectionEncrypters: [noise()],
-        streamMuxers: [yamux()],
-        peerDiscovery,
-        services: {
-            // Kademlia DHT — descubrimiento de peers en internet
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            dht: kadDHT({ clientMode: false }),
-            // GossipSub — broadcast de attestations
-            pubsub: gossipsub({
-                allowPublishToZeroTopicPeers: true, // publica aunque no haya peers aún
-                emitSelf: false,
-                // Thresholds permisivos para redes pequeñas
-                scoreThresholds: {
-                    gossipThreshold: -Infinity,
-                    publishThreshold: -Infinity,
-                    graylistThreshold: -Infinity,
-                },
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            }),
-            // Identify — intercambio de metadatos entre peers
-            identify: identify(),
-            // Ping — requerido por KadDHT para health checks
-            ping: ping(),
-        },
-    });
-    await node.start();
-    // Suscribirse a los topics de Soulprint
-    node.services.pubsub.subscribe(TOPIC_ATTESTATIONS);
-    node.services.pubsub.subscribe(TOPIC_NULLIFIERS);
-    return node;
+/** @deprecated No-op stub */
+export async function createSoulprintP2PNode(_cfg) {
+    throw new Error("libp2p removed in v0.6.0 — use blockchain peer discovery");
 }
-// ─── Publicar attestation via P2P ────────────────────────────────────────────
-export async function publishAttestationP2P(node, att) {
-    try {
-        const data = fromString(JSON.stringify(att), "utf8");
-        const result = await node.services.pubsub.publish(TOPIC_ATTESTATIONS, data);
-        return result?.recipients?.length ?? 0;
-    }
-    catch {
-        return 0; // sin peers aún — no es error
-    }
+/** @deprecated No-op stub */
+export async function publishAttestationP2P(_node, _att) {
+    return 0;
 }
-// ─── Recibir attestations via P2P ─────────────────────────────────────────────
-export function onAttestationReceived(node, handler) {
-    node.services.pubsub.addEventListener("message", (evt) => {
-        if (evt.detail?.topic !== TOPIC_ATTESTATIONS)
-            return;
-        try {
-            const att = JSON.parse(toString(evt.detail.data, "utf8"));
-            const fromPeer = evt.detail?.from?.toString() ?? "unknown";
-            handler(att, fromPeer);
-        }
-        catch {
-            // mensaje malformado — ignorar
-        }
-    });
+/** @deprecated No-op stub */
+export function onAttestationReceived(_node, _cb) { }
+/** @deprecated No-op stub */
+export function getP2PStats(_node) {
+    return { peerId: "", peers: 0, pubsubPeers: 0, multiaddrs: [] };
 }
-// ─── Stats ───────────────────────────────────────────────────────────────────
-export function getP2PStats(node) {
-    const pubsub = node.services.pubsub;
-    return {
-        peerId: node.peerId.toString(),
-        peers: node.getPeers().length,
-        multiaddrs: node.getMultiaddrs().map((m) => m.toString()),
-        pubsubPeers: pubsub.getPeers?.()?.length ?? 0,
-    };
-}
-// ─── Graceful shutdown ────────────────────────────────────────────────────────
-export async function stopP2PNode(node) {
-    try {
-        await node.stop();
-    }
-    catch { /* ignorar */ }
-}
-// ── dial a peer by multiaddr string (best-effort — HTTP gossip is the primary mechanism) ──
-// Note: in WSL2/NAT environments mDNS multicast doesn't work.
-// This function attempts libp2p TCP dial using the peer's advertised multiaddrs.
-// Falls back gracefully — HTTP gossip layer (known_peers) handles message propagation.
-export async function dialP2PPeer(node, maddrStr, timeoutMs = 5_000) {
-    try {
-        // Extract PeerId from the multiaddr string and add multiaddr to peer store
-        // so libp2p can use its own internal Multiaddr class (avoids version mismatch)
-        const peerIdStr = maddrStr.split("/p2p/")[1];
-        if (!peerIdStr)
-            return false;
-        // Use peer store to register the address, then dial by PeerId
-        // This lets libp2p use its own Multiaddr parsing internally
-        const { peerIdFromString } = await import("@libp2p/peer-id");
-        const peerId = peerIdFromString(peerIdStr);
-        // Register the address in the peer store
-        await node.peerStore.merge(peerId, {
-            multiaddrs: [maddrStr],
-        }).catch(() => {
-            // peerStore.merge signature varies by libp2p version — try patch
-            return node.peerStore.patch(peerId, { multiaddrs: [maddrStr] }).catch(() => { });
-        });
-        await Promise.race([
-            node.dial(peerId),
-            new Promise((_, rej) => setTimeout(() => rej(new Error("dial timeout")), timeoutMs)),
-        ]);
-        return true;
-    }
-    catch {
-        return false;
-    }
+/** @deprecated No-op stub */
+export async function stopP2PNode(_node) { }
+/** @deprecated No-op stub */
+export async function dialP2PPeer(_node, _ma) {
+    return false;
 }

package/dist/server.js CHANGED Viewed

@@ -1,129 +1,77 @@
 #!/usr/bin/env node
 /**
- * Soulprint Validator Node — entrypoint
+ * Soulprint Validator Node — entrypoint v0.6.0
  *
- * Arranca:
- *  1. HTTP server (port 4888)    — clientes y legado
- *  2. libp2p P2P node (port 6888) — Kademlia DHT + GossipSub + mDNS
+ * Pure blockchain architecture — no libp2p.
+ * The blockchain IS the network.
  */
-import { startValidatorNode, setP2PNode, setPeerRegistryClient, getNodeState, setLastSyncTs } from "./validator.js";
+import { startValidatorNode, setPeerRegistryClient, setNullifierRegistry, setReputationRegistry, getNodeState, setLastSyncTs } from "./validator.js";
 import { computeHash, saveState } from "./state/StateStore.js";
-import { createSoulprintP2PNode, MAINNET_BOOTSTRAP, stopP2PNode } from "./p2p.js";
 import { PeerRegistryClient } from "./blockchain/PeerRegistryClient.js";
+import { NullifierRegistryClient } from "./blockchain/NullifierRegistryClient.js";
+import { ReputationRegistryClient } from "./blockchain/ReputationRegistryClient.js";
 // ─── Config ──────────────────────────────────────────────────────────────────
-const HTTP_PORT = parseInt(process.env.SOULPRINT_PORT ?? "4888");
-const P2P_PORT = parseInt(process.env.SOULPRINT_P2P_PORT ?? String(HTTP_PORT + 2000));
+const HTTP_PORT = parseInt(process.env.PORT ?? process.env.SOULPRINT_PORT ?? "4888");
+const adminPrivateKey = process.env.ADMIN_PRIVATE_KEY;
+const adminToken = process.env.ADMIN_TOKEN;
 globalThis._startTime = Date.now();
-// Bootstrap nodes: variables de entorno o mainnet predefinidos
-const bootstrapEnv = (process.env.SOULPRINT_BOOTSTRAP ?? "")
-    .split(",")
-    .map(s => s.trim())
-    .filter(Boolean);
-const bootstraps = bootstrapEnv.length > 0 ? bootstrapEnv : MAINNET_BOOTSTRAP;
-const localOnly = bootstraps.length === 0;
-// ─── Arranque ────────────────────────────────────────────────────────────────
+// ─── Start HTTP server ────────────────────────────────────────────────────────
 const httpServer = startValidatorNode(HTTP_PORT);
-let p2pNode = null;
-// Intentar arrancar P2P (no fatal si falla)
-try {
-    console.log(`\n🔗 Arrancando nodo P2P en puerto ${P2P_PORT}...`);
-    console.log(`   Modo: ${localOnly ? "local (mDNS only)" : `red principal + ${bootstraps.length} bootstrap(s)`}`);
-    p2pNode = await createSoulprintP2PNode({ port: P2P_PORT, bootstraps, localOnly });
-    setP2PNode(p2pNode);
-    console.log(`✅ P2P activo`);
-    console.log(`   Peer ID:    ${p2pNode.peerId.toString()}`);
-    console.log(`   Multiaddrs: ${p2pNode.getMultiaddrs().map((m) => m.toString()).join(", ") || "(pendiente)"}`);
-    console.log(`\n   Gossip:     HTTP fallback + GossipSub P2P`);
-    console.log(`   Discovery:  mDNS${bootstraps.length > 0 ? " + DHT + Bootstrap" : " (LAN only)"}\n`);
-    if (localOnly) {
-        console.log(`   💡 Para conectarte a la red principal, configura SOULPRINT_BOOTSTRAP`);
-        console.log(`      con multiaddrs de nodos conocidos y reinicia.\n`);
-    }
-}
-catch (err) {
-    console.warn(`⚠️  P2P no disponible — solo HTTP gossip activo`);
-    console.warn(`   Error: ${err?.message ?? String(err)}\n`);
-}
-// ─── On-chain PeerRegistry (auto-registro + bootstrap desde chain) ────────────
-const adminPrivateKey = process.env.ADMIN_PRIVATE_KEY;
-const peerRegistry = new PeerRegistryClient({
-    privateKey: adminPrivateKey,
-});
+// ─── Init blockchain clients ──────────────────────────────────────────────────
+const peerRegistry = new PeerRegistryClient({ privateKey: adminPrivateKey });
+const nullifierRegistry = new NullifierRegistryClient({ privateKey: adminPrivateKey });
+const reputationRegistry = new ReputationRegistryClient({ privateKey: adminPrivateKey });
 setPeerRegistryClient(peerRegistry);
-// Bootstrap P2P + register self after node is ready (non-blocking)
+setNullifierRegistry(nullifierRegistry);
+setReputationRegistry(reputationRegistry);
+// ─── Bootstrap: read on-chain peers, register self ────────────────────────────
 setTimeout(async () => {
     try {
-        // 1. Leer peers on-chain y hacer dial P2P a sus multiaddrs
         const chainPeers = await peerRegistry.getAllPeers().catch(() => []);
-        if (chainPeers.length > 0) {
-            console.log(`[peer-registry] 🔗 ${chainPeers.length} peer(s) encontrados on-chain — conectando...`);
-            for (const peer of chainPeers) {
-                try {
-                    if (!peer.multiaddr)
-                        continue;
-                    // Si es multiaddr P2P (/ip4/.../tcp/.../p2p/...) intentamos dial
-                    if (peer.multiaddr.startsWith("/ip4") || peer.multiaddr.startsWith("/dns")) {
-                        // Agregar como peer conocido via HTTP bootstrap (más estable que dial directo)
-                        const httpUrl = peer.multiaddr.replace(/\/ip4\/([^/]+)\/tcp\/(\d+).*/, "http://$1:$2").replace("/p2p/", "");
-                        if (httpUrl.startsWith("http")) {
-                            const PROTOCOL_HASH = "dfe1ccca1270ec86f93308dc4b981bab1d6bd74bdcc334059f4380b407ca07ca";
-                            await fetch(`http://localhost:${HTTP_PORT}/peers/register`, {
-                                method: "POST",
-                                headers: { "Content-Type": "application/json" },
-                                body: JSON.stringify({ url: httpUrl, protocol_hash: PROTOCOL_HASH }),
-                                signal: AbortSignal.timeout(5_000),
-                            }).catch(() => null);
-                        }
-                        console.log(`[peer-registry]   ✅ Peer P2P registrado: ${peer.multiaddr.slice(0, 40)}`);
-                    }
-                    else if (peer.multiaddr.startsWith("http")) {
-                        // HTTP peer — registrar vía /peers/register
-                        const PROTOCOL_HASH = "dfe1ccca1270ec86f93308dc4b981bab1d6bd74bdcc334059f4380b407ca07ca";
-                        await fetch(`http://localhost:${HTTP_PORT}/peers/register`, {
-                            method: "POST",
-                            headers: { "Content-Type": "application/json" },
-                            body: JSON.stringify({ url: peer.multiaddr, protocol_hash: PROTOCOL_HASH }),
-                            signal: AbortSignal.timeout(5_000),
-                        }).catch(() => null);
-                        console.log(`[peer-registry]   🌐 Peer HTTP registrado: ${peer.multiaddr}`);
-                    }
-                }
-                catch (e) {
-                    console.warn(`[peer-registry]   ⚠️  No se pudo conectar a ${peer.multiaddr}: ${e.message}`);
+        console.log(`[peer-registry] ${chainPeers.length} peer(s) on-chain`);
+        // Register HTTP peers
+        for (const peer of chainPeers) {
+            try {
+                if (!peer.multiaddr)
+                    continue;
+                if (peer.multiaddr.startsWith("http")) {
+                    const PROTOCOL_HASH = "dfe1ccca1270ec86f93308dc4b981bab1d6bd74bdcc334059f4380b407ca07ca";
+                    await fetch(`http://localhost:${HTTP_PORT}/peers/register`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({ url: peer.multiaddr, protocol_hash: PROTOCOL_HASH }),
+                        signal: AbortSignal.timeout(5_000),
+                    }).catch(() => null);
+                    console.log(`[peer-registry]   🌐 Peer HTTP registrado: ${peer.multiaddr}`);
                 }
             }
+            catch (e) {
+                console.warn(`[peer-registry]   ⚠️  No se pudo conectar a ${peer.multiaddr}: ${e.message}`);
+            }
         }
-        else {
-            console.log("[peer-registry] ℹ️  No hay peers registrados on-chain aún — primer nodo de la red");
-        }
-        // 2. Registrar self on-chain
+        // Register self on-chain
         if (!adminPrivateKey) {
             console.warn("[peer-registry] ⚠️  ADMIN_PRIVATE_KEY not set — skipping on-chain registration");
             return;
         }
-        let multiaddr = `http://localhost:${HTTP_PORT}`;
-        if (p2pNode) {
-            const addrs = p2pNode.getMultiaddrs().map((m) => m.toString());
-            const publicAddr = addrs.find(a => !a.includes("127.0.0.1") && !a.includes("/ip4/0.0.0.0"));
-            multiaddr = publicAddr ?? addrs[0] ?? multiaddr;
-        }
         const nodeDid = globalThis._nodeDid ?? `did:soulprint:node:${Date.now()}`;
-        const nodePeer = p2pNode?.peerId?.toString() ?? "";
-        await peerRegistry.registerSelf({ peerDid: nodeDid, peerId: nodePeer, multiaddr, score: 0 });
-        console.log(`[peer-registry] ✅ Registrado on-chain: ${nodeDid.slice(0, 30)}…`);
+        await peerRegistry.registerSelf({
+            peerDid: nodeDid,
+            peerId: "",
+            multiaddr: `http://localhost:${HTTP_PORT}`,
+            score: 0,
+        });
+        console.log(`[peer-registry] ✅ Registered on-chain: ${nodeDid.slice(0, 30)}…`);
     }
     catch (e) {
-        console.warn(`[peer-registry] ⚠️  Error en bootstrap on-chain: ${e.message}`);
+        console.warn(`[peer-registry] ⚠️  Bootstrap error: ${e.message}`);
     }
 }, 3_000);
-// ─── HTTP Bootstrap Peers (auto-registro) ─────────────────────────────────────
-// SOULPRINT_BOOTSTRAP_HTTP=http://node1:4888,http://node2:4888
-// Registra peers HTTP automáticamente al arrancar (útil en WSL2 / Docker / cloud)
+// ─── HTTP Bootstrap Peers ─────────────────────────────────────────────────────
 const httpBootstraps = (process.env.SOULPRINT_BOOTSTRAP_HTTP ?? "")
     .split(",").map(s => s.trim()).filter(s => s.startsWith("http"));
 if (httpBootstraps.length > 0) {
     console.log(`🔗 Bootstrap HTTP: ${httpBootstraps.length} peer(s) configurados`);
-    // Esperar 2s a que el HTTP server esté listo antes de registrar
     setTimeout(async () => {
         const PROTOCOL_HASH = process.env.SOULPRINT_PROTOCOL_HASH
             ?? "dfe1ccca1270ec86f93308dc4b981bab1d6bd74bdcc334059f4380b407ca07ca";
@@ -149,9 +97,19 @@ if (httpBootstraps.length > 0) {
         }
     }, 2_000);
 }
-// ─── Anti-entropy sync loop (v0.4.4) ─────────────────────────────────────────
-// Every 60 seconds: compare state hash with each known peer.
-// If diverged, fetch full state and merge locally.
+// ─── HTTP peer sync every 5 min (simple HTTP gossip — no libp2p) ─────────────
+setInterval(async () => {
+    try {
+        const peers = await peerRegistry.getAllPeers().catch(() => []);
+        for (const peer of peers) {
+            if (peer.multiaddr?.startsWith("http")) {
+                await fetch(`${peer.multiaddr}/state/hash`, { signal: AbortSignal.timeout(3_000) }).catch(() => null);
+            }
+        }
+    }
+    catch { }
+}, 5 * 60 * 1000);
+// ─── Anti-entropy sync loop ───────────────────────────────────────────────────
 setInterval(async () => {
     const { nullifiers, repStore, peers: knownPeers } = getNodeState();
     if (knownPeers.length === 0)
@@ -163,17 +121,11 @@ setInterval(async () => {
             if (!hashRes.ok)
                 continue;
             const hashData = await hashRes.json();
-            const peerHash = hashData.hash;
-            if (peerHash === localHash) {
-                console.log(`[sync] peer ${peerUrl}: hash match ✅`);
+            if (hashData.hash === localHash)
                 continue;
-            }
-            // Hashes differ — fetch full state and merge
             const exportRes = await fetch(`${peerUrl}/state/export`, { signal: AbortSignal.timeout(10_000) });
-            if (!exportRes.ok) {
-                console.warn(`[sync] peer ${peerUrl}: export failed (${exportRes.status})`);
+            if (!exportRes.ok)
                 continue;
-            }
             const peerState = await exportRes.json();
             const mergeRes = await fetch(`http://localhost:${HTTP_PORT}/state/merge`, {
                 method: "POST",
@@ -182,8 +134,7 @@ setInterval(async () => {
                 signal: AbortSignal.timeout(5_000),
             });
             const merged = await mergeRes.json();
-            console.log(`[sync] peer ${peerUrl}: diverged → merged ${merged.new_nullifiers ?? 0} nullifiers, ${merged.new_attestations ?? 0} attestations`);
-            // Persist updated state
+            console.log(`[sync] peer ${peerUrl}: merged ${merged.new_nullifiers ?? 0} nullifiers, ${merged.new_attestations ?? 0} attestations`);
             const { nullifiers: n2, repStore: r2, peers: p2 } = getNodeState();
             const ts = Date.now();
             saveState({
@@ -204,10 +155,6 @@ setInterval(async () => {
 // ─── Graceful shutdown ────────────────────────────────────────────────────────
 async function shutdown(signal) {
     console.log(`\n${signal} recibido — cerrando...`);
-    if (p2pNode) {
-        await stopP2PNode(p2pNode);
-        console.log("  ✓ Nodo P2P cerrado");
-    }
     httpServer.close(() => {
         console.log("  ✓ HTTP server cerrado");
         process.exit(0);

package/dist/validator.d.ts CHANGED Viewed

@@ -1,6 +1,5 @@
 import { IncomingMessage, ServerResponse } from "node:http";
 import { BotAttestation, BotReputation } from "soulprint-core";
-import { type SoulprintP2PNode } from "./p2p.js";
 import { PeerRegistryClient } from "./blockchain/PeerRegistryClient.js";
 import { NullifierRegistryClient } from "./blockchain/NullifierRegistryClient.js";
 import { ReputationRegistryClient } from "./blockchain/ReputationRegistryClient.js";
@@ -20,13 +19,6 @@ export declare function setNullifierRegistry(client: NullifierRegistryClient): v
 export declare function setReputationRegistry(client: ReputationRegistryClient): void;
 export declare function getNullifierRegistry(): NullifierRegistryClient | null;
 export declare function getReputationRegistry(): ReputationRegistryClient | null;
-/**
- * Inyecta el nodo libp2p al validador.
- * Cuando se llama:
- *  1. Se registra el handler de attestations entrantes por GossipSub
- *  2. Desde ese momento, gossipAttestation() también publica por P2P
- */
-export declare function setP2PNode(node: SoulprintP2PNode): void;
 /**
  * Per-DID reputation: score (0-20) + attestation history.
  * Persisted to disk - survives node restarts.

package/dist/validator.js CHANGED Viewed

@@ -16,7 +16,6 @@ import { SoulprintBlockchainClient, loadBlockchainConfig, } from "./blockchain/b
 import { thresholdsClient, PROTOCOL_THRESHOLDS_ADDRESS, PROTOCOL_THRESHOLDS_CHAIN, } from "./blockchain/protocol-thresholds-client.js";
 import { getCodeIntegrity, logCodeIntegrity, computeRuntimeHash } from "./code-integrity.js";
 import { getMCPEntry, getVerifiedMCPEntries, getAllMCPEntries, getRegistryInfo, verifyMCPOnChain, revokeMCPOnChain, registerMCPOnChain, } from "./mcp-registry-client.js";
-import { publishAttestationP2P, onAttestationReceived, getP2PStats, dialP2PPeer, } from "./p2p.js";
 // ── Config ────────────────────────────────────────────────────────────────────
 const PORT = parseInt(process.env.SOULPRINT_PORT ?? String(PROTOCOL.DEFAULT_HTTP_PORT));
 const NODE_DIR = join(homedir(), ".soulprint", "node");
@@ -25,7 +24,7 @@ const NULLIFIER_DB = join(NODE_DIR, "nullifiers.json");
 const REPUTE_DB = join(NODE_DIR, "reputation.json");
 const PEERS_DB = join(NODE_DIR, "peers.json");
 const AUDIT_DB = join(NODE_DIR, "audit.json");
-const VERSION = "0.5.0";
+const VERSION = "0.6.0";
 const MAX_BODY_BYTES = 64 * 1024;
 // ── Protocol constants (inamovibles - no cambiar directamente aquí) ───────────
 const RATE_LIMIT_MS = PROTOCOL.RATE_LIMIT_WINDOW_MS;
@@ -70,8 +69,6 @@ async function refreshThresholds() {
     }
     catch { /* usa los valores actuales */ }
 }
-// ── P2P Node (Phase 5) ────────────────────────────────────────────────────────
-let p2pNode = null;
 // ── PeerRegistry Client ───────────────────────────────────────────────────────
 let peerRegistryClient = null;
 export function setPeerRegistryClient(client) {
@@ -94,27 +91,6 @@ export function getNullifierRegistry() {
 export function getReputationRegistry() {
     return reputationRegistry;
 }
-/**
- * Inyecta el nodo libp2p al validador.
- * Cuando se llama:
- *  1. Se registra el handler de attestations entrantes por GossipSub
- *  2. Desde ese momento, gossipAttestation() también publica por P2P
- */
-export function setP2PNode(node) {
-    p2pNode = node;
-    // Recibir attestations de otros nodos via GossipSub
-    onAttestationReceived(node, (att, fromPeer) => {
-        // Validar firma antes de aplicar
-        if (!verifyAttestation(att)) {
-            console.warn(`[p2p] Attestation inválida de peer ${fromPeer.slice(0, 16)}... - descartada`);
-            return;
-        }
-        // Anti-replay ya está dentro de applyAttestation()
-        applyAttestation(att);
-        console.log(`[p2p] Attestation recibida de peer ${fromPeer.slice(0, 16)}... → ${att.target_did.slice(0, 20)}... (${att.value > 0 ? "+" : ""}${att.value})`);
-    });
-    console.log(`[p2p] P2P integrado → ${node.peerId.toString().slice(0, 16)}...`);
-}
 // ── Rate limiter ──────────────────────────────────────────────────────────────
 const rateLimits = new Map();
 // ── DPoP Nonce Store — anti-replay para request signing ──────────────────────
@@ -248,25 +224,10 @@ function loadPeers() {
 }
 function savePeers() { writeFileSync(PEERS_DB, JSON.stringify(peers, null, 2)); }
 /**
- * Gossip: propaga la attestation a la red.
- *
- * Estrategia:
- *  1. P2P GossipSub (Phase 5) - si el nodo libp2p está activo
- *  2. HTTP fire-and-forget (Phase 3) - fallback para nodos legacy sin libp2p
- *
- * Ambos canales son fire-and-forget: no bloquean la respuesta al cliente.
+ * Gossip: propaga la attestation a la red via HTTP fire-and-forget.
  */
 async function gossipAttestation(att, excludeUrl) {
-    // ── Canal 1: libp2p GossipSub ─────────────────────────────────────────────
-    if (p2pNode) {
-        const recipients = await publishAttestationP2P(p2pNode, att);
-        if (recipients > 0) {
-            console.log(`[p2p] Attestation publicada → ${recipients} peer(s) via GossipSub`);
-        }
-    }
-    // ── Canal 2: HTTP gossip con cifrado AES-256-GCM + XOR routing ────────────
-    // Selección de peers: XOR routing hacia el DID objetivo → O(log n)
-    // Con ≤10 peers: broadcast total. Con más: solo K=6 más cercanos.
+    // HTTP gossip con cifrado AES-256-GCM + XOR routing
     const targets = selectGossipPeers(peers, att.target_did, excludeUrl);
     if (targets.length < peers.length - (excludeUrl ? 1 : 0)) {
         console.log(routingStats(peers.length, targets.length, att.target_did));
@@ -340,26 +301,32 @@ function getIP(req) {
 }
 // ── GET /info ─────────────────────────────────────────────────────────────────
 function handleInfo(res, nodeKeypair) {
-    const p2pStats = p2pNode ? getP2PStats(p2pNode) : null;
+    const addresses = (() => {
+        try {
+            const { default: addrs } = require("./blockchain/addresses.json");
+            return addrs;
+        }
+        catch {
+            return {};
+        }
+    })();
     json(res, 200, {
         node_did: nodeKeypair.did,
         version: VERSION,
         protocol: PROTOCOL.VERSION,
-        protocol_hash: PROTOCOL_HASH, // ← cualquier modificación cambia este hash
+        protocol_hash: PROTOCOL_HASH,
+        network: "base-sepolia",
+        contracts: {
+            PeerRegistry: "0x452fb66159dFCfC13f2fD9627aA4c56886BfB15b",
+            NullifierRegistry: addresses?.NullifierRegistry ?? "",
+            ReputationRegistry: addresses?.ReputationRegistry ?? "",
+        },
         total_verified: Object.keys(nullifiers).length,
         total_reputation: Object.keys(repStore).length,
         known_peers: peers.length,
         supported_countries: ["CO"],
-        capabilities: ["zk-verify", "anti-sybil", "co-sign", "bot-reputation", "p2p-gossipsub", "credential-validators", "anti-farming"],
+        capabilities: ["zk-verify", "anti-sybil", "co-sign", "bot-reputation", "registraduria-validation", "on-chain-state"],
         rate_limit: `${PROTOCOL.RATE_LIMIT_MAX} req/min per IP`,
-        // P2P stats (Phase 5)
-        p2p: p2pStats ? {
-            enabled: true,
-            peer_id: p2pStats.peerId,
-            peers: p2pStats.peers,
-            pubsub_peers: p2pStats.pubsubPeers,
-            multiaddrs: p2pStats.multiaddrs,
-        } : { enabled: false },
     });
 }
 // ── GET /protocol ──────────────────────────────────────────────────────────────
@@ -640,32 +607,6 @@ async function handlePeerRegister(req, res) {
     }
     peers.push(url);
     savePeers();
-    // ── Auto-dial libp2p layer ──────────────────────────────────────────────────
-    // WSL2 / NAT: mDNS no funciona → al registrar un peer HTTP, intentamos
-    // conectar también vía libp2p usando sus multiaddrs del /info endpoint.
-    if (p2pNode) {
-        setImmediate(async () => {
-            try {
-                const infoRes = await fetch(`${url}/info`, { signal: AbortSignal.timeout(3_000) });
-                if (infoRes.ok) {
-                    const info = await infoRes.json();
-                    const addrs = info?.p2p?.multiaddrs ?? [];
-                    let dialed = false;
-                    for (const ma of addrs) {
-                        const ok = await dialP2PPeer(p2pNode, ma);
-                        if (ok) {
-                            console.log(`[peer] 🔗 P2P dial OK: ${ma}`);
-                            dialed = true;
-                            break;
-                        }
-                    }
-                    if (!dialed)
-                        console.log(`[peer] ℹ️  P2P dial failed for ${url} (mDNS fallback)`);
-                }
-            }
-            catch { /* non-critical — HTTP gossip is the fallback */ }
-        });
-    }
     json(res, 200, { ok: true, peers: peers.length, protocol_hash: PROTOCOL_HASH });
 }
 // ── GET /peers ─────────────────────────────────────────────────────────────────
@@ -1089,9 +1030,7 @@ export function startValidatorNode(port = PORT) {
         }
         // GET /network/stats — stats públicas para la landing page
         if (cleanUrl === "/network/stats" && req.method === "GET") {
-            const p2pStats = p2pNode ? getP2PStats(p2pNode) : null;
             const httpPeers = peers.length;
-            const libp2pPeers = p2pStats?.peers ?? 0;
             let registeredPeers = 0;
             let nullifiersOnchain = 0;
             let reputationOnchain = 0;
@@ -1116,25 +1055,24 @@ export function startValidatorNode(port = PORT) {
                 node_did: nodeKeypair.did.slice(0, 20) + "...",
                 version: VERSION,
                 protocol_hash: PROTOCOL_HASH.slice(0, 16) + "...",
+                network: "base-sepolia",
+                contracts: {
+                    PeerRegistry: "0x452fb66159dFCfC13f2fD9627aA4c56886BfB15b",
+                },
                 // identidades y reputación (in-memory cache)
                 verified_identities: Object.keys(nullifiers).length,
                 reputation_profiles: Object.keys(repStore).length,
-                // on-chain state (v0.5.0) — blockchain IS the shared state
+                // on-chain state (v0.6.0) — blockchain IS the shared state
                 nullifiers_onchain: nullifiersOnchain,
                 reputation_onchain: reputationOnchain,
-                // peers — HTTP gossip
+                // peers
                 known_peers: httpPeers,
-                // peers — libp2p P2P
-                p2p_peers: libp2pPeers,
-                p2p_pubsub_peers: p2pStats?.pubsubPeers ?? 0,
-                p2p_enabled: !!p2pNode,
-                total_peers: Math.max(httpPeers, libp2pPeers),
-                // on-chain registered peers (PeerRegistry)
                 registered_peers: registeredPeers,
-                // state sync (v0.5.0 — blockchain is source of truth)
+                total_peers: Math.max(httpPeers, registeredPeers),
+                // state sync
                 state_hash: computeHash(Object.keys(nullifiers)).slice(0, 16) + "...",
                 last_sync: lastSyncTs,
-                // estado general
+                // general
                 uptime_ms: Date.now() - (globalThis._startTime ?? Date.now()),
                 timestamp: Date.now(),
                 mcps_verified: null,

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "soulprint-network",
-  "version": "0.5.1",
-  "description": "Soulprint validator node \u2014 HTTP server that verifies ZK proofs, co-signs SPTs, anti-Sybil registry",
+  "version": "0.6.0",
+  "description": "Soulprint validator node — HTTP server that verifies ZK proofs, co-signs SPTs, anti-Sybil registry",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -35,25 +35,12 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@chainsafe/libp2p-gossipsub": "14.1.2",
-    "@chainsafe/libp2p-noise": "16.1.5",
-    "@chainsafe/libp2p-yamux": "7.0.4",
-    "@libp2p/bootstrap": "11.0.47",
-    "@libp2p/identify": "3.0.39",
-    "@libp2p/kad-dht": "16.1.3",
-    "@libp2p/mdns": "11.0.47",
-    "@libp2p/peer-id": "^6.0.4",
-    "@libp2p/ping": "2.0.37",
-    "@libp2p/tcp": "10.1.19",
-    "@multiformats/multiaddr": "^13.0.1",
     "ethers": "^6.16.0",
-    "libp2p": "2.10.0",
     "nodemailer": "^8.0.1",
     "otpauth": "^9.5.0",
     "otplib": "^13.3.0",
     "soulprint-core": "0.1.11",
-    "soulprint-zkp": "0.1.6",
-    "uint8arrays": "5.1.0"
+    "soulprint-zkp": "0.1.6"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -70,4 +57,4 @@
       "types": "./dist/index.d.ts"
     }
   }
-}
+}