soulprint-network 0.4.1 → 0.4.2

package/dist/blockchain/PeerRegistryClient.d.ts

@@ -0,0 +1,40 @@
+export declare const PEER_REGISTRY_RPC = "https://sepolia.base.org";
+export declare const PEER_REGISTRY_ADDRESS: string;
+export interface PeerEntry {
+    peerDid: string;
+    peerId: string;
+    multiaddr: string;
+    score: number;
+    lastSeen: number;
+}
+export declare class PeerRegistryClient {
+    private provider;
+    private contract;
+    private wallet?;
+    private cache;
+    private cacheAt;
+    private cacheTTLMs;
+    private address;
+    constructor(opts?: {
+        rpc?: string;
+        address?: string;
+        privateKey?: string;
+        cacheTTLMs?: number;
+    });
+    /** Get all registered peers (cached, TTL 5 min) */
+    getAllPeers(): Promise<PeerEntry[]>;
+    /** Force refresh from blockchain */
+    refreshPeers(): Promise<PeerEntry[]>;
+    /** Register this node on-chain. Non-blocking — logs warning on failure. */
+    registerSelf(opts: {
+        peerDid: string;
+        peerId: string;
+        multiaddr: string;
+        score?: number;
+    }): Promise<void>;
+    /** Returns multiaddrs of all peers (for bootstrap) */
+    getBootstrapMultiaddrs(): Promise<string[]>;
+    get contractAddress(): string;
+}
+/** Singleton instance (read-only) */
+export declare const peerRegistryClient: PeerRegistryClient;

package/dist/blockchain/PeerRegistryClient.js

@@ -0,0 +1,125 @@
+/**
+ * PeerRegistryClient
+ * On-chain peer discovery for Soulprint validator nodes (Base Sepolia).
+ *
+ * - On startup: reads all peers from contract → used as bootstrap multiaddrs
+ * - On startup: registers self (DID, peerId, multiaddr, score=0)
+ * - Cache TTL 5 min, refreshPeers() to invalidate
+ * - Non-blocking: RPC failures log a warning and continue
+ */
+import { ethers } from "ethers";
+export const PEER_REGISTRY_RPC = "https://sepolia.base.org";
+// Load address from addresses.json
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function loadAddress() {
+    try {
+        const f = join(__dirname, "addresses.json");
+        const d = JSON.parse(readFileSync(f, "utf8"));
+        return d["PeerRegistry"] ?? "";
+    }
+    catch {
+        return "";
+    }
+}
+export const PEER_REGISTRY_ADDRESS = loadAddress();
+const ABI = [
+    "function registerPeer(string peerDid, string peerId, string multiaddr, uint256 score) external",
+    "function removePeer(string peerDid) external",
+    "function getPeer(string peerDid) external view returns (string did, string peerId, string multiaddr, uint256 score, uint256 lastSeen)",
+    "function getAllPeers() external view returns (tuple(string peerDid, string peerId, string multiaddr, uint256 score, uint256 lastSeen, address registrant)[])",
+    "function peerCount() external view returns (uint256)",
+    "event PeerRegistered(string indexed peerDid, string peerId, string multiaddr, uint256 score, address indexed registrant, uint256 timestamp)",
+    "event PeerUpdated(string indexed peerDid, string peerId, string multiaddr, uint256 score, address indexed registrant, uint256 timestamp)",
+    "event PeerRemoved(string indexed peerDid, address indexed removedBy, uint256 timestamp)",
+];
+export class PeerRegistryClient {
+    provider;
+    contract;
+    wallet;
+    cache = null;
+    cacheAt = 0;
+    cacheTTLMs;
+    address;
+    constructor(opts) {
+        this.address = opts?.address ?? PEER_REGISTRY_ADDRESS;
+        this.cacheTTLMs = opts?.cacheTTLMs ?? 5 * 60 * 1000; // 5 min
+        const rpc = opts?.rpc ?? PEER_REGISTRY_RPC;
+        this.provider = new ethers.JsonRpcProvider(rpc);
+        if (!this.address) {
+            console.warn("[peer-registry] ⚠️  No contract address — peer registry disabled");
+            this.contract = null;
+            return;
+        }
+        if (opts?.privateKey) {
+            this.wallet = new ethers.Wallet(opts.privateKey, this.provider);
+            this.contract = new ethers.Contract(this.address, ABI, this.wallet);
+        }
+        else {
+            this.contract = new ethers.Contract(this.address, ABI, this.provider);
+        }
+    }
+    /** Get all registered peers (cached, TTL 5 min) */
+    async getAllPeers() {
+        if (this.cache && Date.now() - this.cacheAt < this.cacheTTLMs) {
+            return this.cache;
+        }
+        return this.refreshPeers();
+    }
+    /** Force refresh from blockchain */
+    async refreshPeers() {
+        if (!this.address) {
+            console.warn("[peer-registry] ⚠️  No contract address configured — skipping peer fetch");
+            return [];
+        }
+        try {
+            const raw = await this.contract.getAllPeers();
+            this.cache = raw.map((p) => ({
+                peerDid: p.peerDid,
+                peerId: p.peerId,
+                multiaddr: p.multiaddr,
+                score: Number(p.score),
+                lastSeen: Number(p.lastSeen),
+            }));
+            this.cacheAt = Date.now();
+            return this.cache;
+        }
+        catch (err) {
+            console.warn(`[peer-registry] ⚠️  Could not fetch peers from chain: ${err.shortMessage ?? err.message}`);
+            return this.cache ?? [];
+        }
+    }
+    /** Register this node on-chain. Non-blocking — logs warning on failure. */
+    async registerSelf(opts) {
+        if (!this.wallet) {
+            console.warn("[peer-registry] ⚠️  No private key — cannot register self on-chain");
+            return;
+        }
+        if (!this.address) {
+            console.warn("[peer-registry] ⚠️  No contract address — skipping self-registration");
+            return;
+        }
+        try {
+            const feeData = await this.provider.getFeeData();
+            const tx = await this.contract.registerPeer(opts.peerDid, opts.peerId, opts.multiaddr, BigInt(opts.score ?? 0), { gasPrice: feeData.gasPrice });
+            console.log(`[peer-registry] 📡 Registering self on-chain... tx: ${tx.hash}`);
+            await tx.wait();
+            console.log(`[peer-registry] ✅ Registered: did=${opts.peerDid.slice(0, 20)}... multiaddr=${opts.multiaddr}`);
+            // Invalidate cache so next getAllPeers() reflects the new entry
+            this.cache = null;
+        }
+        catch (err) {
+            console.warn(`[peer-registry] ⚠️  Self-registration failed (non-fatal): ${err.shortMessage ?? err.message}`);
+        }
+    }
+    /** Returns multiaddrs of all peers (for bootstrap) */
+    async getBootstrapMultiaddrs() {
+        const peers = await this.getAllPeers();
+        return peers.map(p => p.multiaddr).filter(Boolean);
+    }
+    get contractAddress() { return this.address; }
+}
+/** Singleton instance (read-only) */
+export const peerRegistryClient = new PeerRegistryClient();

package/dist/blockchain/addresses.json

@@ -0,0 +1,3 @@
+{
+  "PeerRegistry": "0x452fb66159dFCfC13f2fD9627aA4c56886BfB15b"
+}

package/dist/code-hash.json

@@ -1,9 +1,10 @@
 {
-  "codeHash": "ea2e97f6d94c08b616fd9aea8833250624cb38e94d1d07aad7b3104d158abd9b",
-  "codeHashHex": "0xea2e97f6d94c08b616fd9aea8833250624cb38e94d1d07aad7b3104d158abd9b",
-  "computedAt": "2026-02-25T03:34:08.790Z",
-  "fileCount": 20,
+  "codeHash": "740841a4e4069e7576a21b2da277ae7bb5b65bed028121cbc3277c865f58544f",
+  "codeHashHex": "0x740841a4e4069e7576a21b2da277ae7bb5b65bed028121cbc3277c865f58544f",
+  "computedAt": "2026-03-01T01:46:41.787Z",
+  "fileCount": 21,
   "files": [
+    "blockchain/PeerRegistryClient.ts",
     "blockchain/blockchain-anchor.ts",
     "blockchain/blockchain-client.ts",
     "blockchain/protocol-thresholds-client.ts",

package/dist/server.js

@@ -6,8 +6,9 @@
  *  1. HTTP server (port 4888)    — clientes y legado
  *  2. libp2p P2P node (port 6888) — Kademlia DHT + GossipSub + mDNS
  */
-import { startValidatorNode, setP2PNode } from "./validator.js";
+import { startValidatorNode, setP2PNode, setPeerRegistryClient } from "./validator.js";
 import { createSoulprintP2PNode, MAINNET_BOOTSTRAP, stopP2PNode } from "./p2p.js";
+import { PeerRegistryClient } from "./blockchain/PeerRegistryClient.js";
 // ─── Config ──────────────────────────────────────────────────────────────────
 const HTTP_PORT = parseInt(process.env.SOULPRINT_PORT ?? "4888");
 const P2P_PORT = parseInt(process.env.SOULPRINT_P2P_PORT ?? String(HTTP_PORT + 2000));
@@ -42,6 +43,43 @@ catch (err) {
     console.warn(`⚠️  P2P no disponible — solo HTTP gossip activo`);
     console.warn(`   Error: ${err?.message ?? String(err)}\n`);
 }
+// ─── On-chain PeerRegistry (auto-registro) ────────────────────────────────────
+const adminPrivateKey = process.env.ADMIN_PRIVATE_KEY;
+const peerRegistry = new PeerRegistryClient({
+    privateKey: adminPrivateKey,
+});
+setPeerRegistryClient(peerRegistry);
+// Register self after P2P is ready (non-blocking)
+setTimeout(async () => {
+    try {
+        if (!adminPrivateKey) {
+            console.warn("[peer-registry] ⚠️  ADMIN_PRIVATE_KEY not set — skipping on-chain registration");
+            return;
+        }
+        // Get node identity from validator (fetched via HTTP)
+        const infoRes = await fetch(`http://localhost:${HTTP_PORT}/health`, { signal: AbortSignal.timeout(5000) });
+        const info = await infoRes.json();
+        // Get P2P multiaddr (first non-localhost if available)
+        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;
+        }
+        // Use node DID from keypair (read from health endpoint) and P2P peerId
+        const nodeDid = globalThis._nodeDid ?? `did:soulprint:node:${Date.now()}`;
+        const nodePeer = p2pNode?.peerId?.toString() ?? "";
+        await peerRegistry.registerSelf({
+            peerDid: nodeDid,
+            peerId: nodePeer,
+            multiaddr,
+            score: 0,
+        });
+    }
+    catch (e) {
+        console.warn(`[peer-registry] ⚠️  Could not register self: ${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)

package/dist/validator.d.ts

@@ -1,6 +1,7 @@
 import { IncomingMessage, ServerResponse } from "node:http";
 import { BotAttestation, BotReputation } from "soulprint-core";
 import { type SoulprintP2PNode } from "./p2p.js";
+import { PeerRegistryClient } from "./blockchain/PeerRegistryClient.js";
 export declare function getLiveThresholds(): {
     SCORE_FLOOR: number;
     VERIFIED_SCORE_FLOOR: number;
@@ -12,6 +13,7 @@ export declare function getLiveThresholds(): {
     REPUTATION_MAX: number;
     source: "blockchain" | "local_fallback";
 };
+export declare function setPeerRegistryClient(client: PeerRegistryClient): void;
 /**
  * Inyecta el nodo libp2p al validador.
  * Cuando se llama:

package/dist/validator.js

@@ -70,6 +70,11 @@ async function refreshThresholds() {
 }
 // ── P2P Node (Phase 5) ────────────────────────────────────────────────────────
 let p2pNode = null;
+// ── PeerRegistry Client ───────────────────────────────────────────────────────
+let peerRegistryClient = null;
+export function setPeerRegistryClient(client) {
+    peerRegistryClient = client;
+}
 /**
  * Inyecta el nodo libp2p al validador.
  * Cuando se llama:
@@ -831,6 +836,8 @@ export function startValidatorNode(port = PORT) {
     loadPeers();
     loadAudit();
     const nodeKeypair = loadOrCreateNodeKeypair();
+    // Expose DID globally so server.ts can use it for peer registration
+    globalThis._nodeDid = nodeKeypair.did;
     // ── Cargar thresholds desde blockchain al arrancar ────────────────────────
     // No bloqueante — el nodo arranca con valores locales y los actualiza async
     refreshThresholds().then(() => {
@@ -989,11 +996,37 @@ export function startValidatorNode(port = PORT) {
                 note: "Solo el superAdmin del contrato puede modificar estos valores on-chain",
             });
         }
+        // GET /network/peers — all peers from on-chain PeerRegistry
+        if (cleanUrl === "/network/peers" && req.method === "GET") {
+            try {
+                const chainPeers = peerRegistryClient
+                    ? await peerRegistryClient.getAllPeers()
+                    : [];
+                return json(res, 200, {
+                    ok: true,
+                    peers: chainPeers,
+                    count: chainPeers.length,
+                    contract: peerRegistryClient?.contractAddress ?? null,
+                    timestamp: Date.now(),
+                });
+            }
+            catch (err) {
+                return json(res, 500, { ok: false, error: err.message });
+            }
+        }
         // 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;
+            try {
+                if (peerRegistryClient) {
+                    const chainPeers = await peerRegistryClient.getAllPeers();
+                    registeredPeers = chainPeers.length;
+                }
+            }
+            catch { /* non-fatal */ }
             return json(res, 200, {
                 node_did: nodeKeypair.did.slice(0, 20) + "...",
                 version: VERSION,
@@ -1009,6 +1042,8 @@ export function startValidatorNode(port = PORT) {
                 p2p_enabled: !!p2pNode,
                 // total = max de ambas capas (HTTP gossip es el piso mínimo garantizado)
                 total_peers: Math.max(httpPeers, libp2pPeers),
+                // on-chain registered peers (PeerRegistry)
+                registered_peers: registeredPeers,
                 // estado general
                 uptime_ms: Date.now() - (globalThis._startTime ?? Date.now()),
                 timestamp: Date.now(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soulprint-network",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "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",
@@ -12,7 +12,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc && node scripts/compute-code-hash.mjs",
+    "build": "tsc && node scripts/compute-code-hash.mjs && cp -f src/blockchain/addresses.json dist/blockchain/addresses.json 2>/dev/null || true",
     "start": "node dist/server.js",
     "build:hash": "node scripts/compute-code-hash.mjs"
   },