soulprint-network 0.3.8 → 0.4.0

package/dist/code-hash.json

@@ -1,8 +1,8 @@
 {
-  "codeHash": "cede7ea2b4acfb3c25dd603fa290f41ea12f02394d617857e0c3247f30d0e0a3",
-  "codeHashHex": "0xcede7ea2b4acfb3c25dd603fa290f41ea12f02394d617857e0c3247f30d0e0a3",
-  "computedAt": "2026-02-24T22:57:27.288Z",
-  "fileCount": 18,
+  "codeHash": "71e41f8c443a60f95aa13ae942aa7c36a242ca69b02c43cdb973aaed92f004d5",
+  "codeHashHex": "0x71e41f8c443a60f95aa13ae942aa7c36a242ca69b02c43cdb973aaed92f004d5",
+  "computedAt": "2026-02-25T03:16:23.336Z",
+  "fileCount": 19,
   "files": [
     "blockchain/blockchain-anchor.ts",
     "blockchain/blockchain-client.ts",
@@ -18,6 +18,7 @@
     "crypto/gossip-cipher.ts",
     "crypto/peer-router.ts",
     "index.ts",
+    "mcp-registry-client.ts",
     "p2p.ts",
     "peer-challenge.ts",
     "server.ts",

package/dist/mcp-registry-client.d.ts

@@ -0,0 +1,49 @@
+export interface MCPEntry {
+    address: string;
+    owner: string;
+    name: string;
+    url: string;
+    did: string;
+    category: string;
+    description: string;
+    registeredAt: number;
+    verifiedAt: number;
+    revokedAt: number;
+    exists: boolean;
+    verified: boolean;
+}
+export declare function isVerifiedOnChain(mcpAddress: string): Promise<boolean>;
+export declare function getMCPEntry(mcpAddress: string): Promise<MCPEntry | null>;
+export declare function getAllMCPEntries(): Promise<MCPEntry[]>;
+export declare function getVerifiedMCPEntries(): Promise<MCPEntry[]>;
+export declare function getSuperAdmin(): Promise<string>;
+export declare function registerMCPOnChain(params: {
+    ownerPrivateKey: string;
+    mcpAddress: string;
+    name: string;
+    url: string;
+    did?: string;
+    category?: string;
+    description?: string;
+}): Promise<{
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}>;
+export declare function verifyMCPOnChain(mcpAddress: string): Promise<{
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}>;
+export declare function revokeMCPOnChain(mcpAddress: string, reason: string): Promise<{
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}>;
+export declare function getRegistryInfo(): Promise<{
+    contract: string;
+    network: string;
+    superAdmin: string;
+    totalMCPs: number;
+    explorer: string;
+}>;

package/dist/mcp-registry-client.js

@@ -0,0 +1,164 @@
+/**
+ * mcp-registry.ts — Cliente para MCPRegistry.sol en Base Sepolia
+ *
+ * Expone:
+ *  - isVerifiedOnChain(address)    → bool
+ *  - getMCPEntry(address)          → MCPEntry
+ *  - getVerifiedMCPs()             → lista pública
+ *  - verifyMCP / revokeMCP         → solo desde la wallet admin (con ADMIN_PRIVATE_KEY)
+ *  - registerMCP                   → cualquiera puede registrar
+ */
+import { ethers } from "ethers";
+// ── Config ──────────────────────────────────────────────────────────────────
+const RPC_URL = process.env.BASE_RPC_URL || "https://sepolia.base.org";
+const MCP_REGISTRY_ADDR = process.env.MCP_REGISTRY_ADDR || "0x59EA3c8f60ecbAe22B4c323A8dDc2b0BCd9D3C2a";
+const ADMIN_PRIVATE_KEY = process.env.ADMIN_PRIVATE_KEY || ""; // solo admin lo tiene
+const ABI = [
+    // Lectura pública
+    "function isVerified(address mcpAddress) view returns (bool)",
+    "function totalMCPs() view returns (uint256)",
+    "function superAdmin() view returns (address)",
+    "function getAllMCPs() view returns (address[])",
+    "function mcps(address) view returns (address owner, string name, string url, string did, string category, string description, uint64 registeredAt, uint64 verifiedAt, uint64 revokedAt, bool exists)",
+    // Escritura (cualquiera puede registrar)
+    "function registerMCP(address mcpAddress, string name, string url, string did, string category, string description)",
+    // Escritura (solo admin)
+    "function verify(address mcpAddress)",
+    "function revoke(address mcpAddress, string reason)",
+    "function updateMCP(address mcpAddress, string newUrl, string newDid, string newDescription)",
+    // Eventos
+    "event MCPRegistered(address indexed mcpAddress, string name, string url, string category)",
+    "event MCPVerified(address indexed mcpAddress, string name, address verifiedBy)",
+    "event MCPRevoked(address indexed mcpAddress, string name, string reason)",
+];
+function getProvider() {
+    return new ethers.JsonRpcProvider(RPC_URL);
+}
+function getReadContract() {
+    return new ethers.Contract(MCP_REGISTRY_ADDR, ABI, getProvider());
+}
+function getWriteContract() {
+    if (!ADMIN_PRIVATE_KEY)
+        throw new Error("ADMIN_PRIVATE_KEY no configurada");
+    const provider = getProvider();
+    const wallet = new ethers.Wallet(ADMIN_PRIVATE_KEY, provider);
+    return new ethers.Contract(MCP_REGISTRY_ADDR, ABI, wallet);
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function formatEntry(addr, raw) {
+    return {
+        address: addr,
+        owner: raw.owner,
+        name: raw.name,
+        url: raw.url,
+        did: raw.did,
+        category: raw.category,
+        description: raw.description,
+        registeredAt: Number(raw.registeredAt),
+        verifiedAt: Number(raw.verifiedAt),
+        revokedAt: Number(raw.revokedAt),
+        exists: raw.exists,
+        verified: raw.verifiedAt > 0n && raw.revokedAt === 0n,
+    };
+}
+// ── Consultas públicas ───────────────────────────────────────────────────────
+export async function isVerifiedOnChain(mcpAddress) {
+    try {
+        const c = getReadContract();
+        return await c.isVerified(mcpAddress);
+    }
+    catch {
+        return false;
+    }
+}
+export async function getMCPEntry(mcpAddress) {
+    try {
+        const c = getReadContract();
+        const raw = await c.mcps(mcpAddress);
+        if (!raw.exists)
+            return null;
+        return formatEntry(mcpAddress, raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function getAllMCPEntries() {
+    try {
+        const c = getReadContract();
+        const addrs = await c.getAllMCPs();
+        const entries = await Promise.all(addrs.map(a => getMCPEntry(a)));
+        return entries.filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+export async function getVerifiedMCPEntries() {
+    const all = await getAllMCPEntries();
+    return all.filter(e => e.verified);
+}
+export async function getSuperAdmin() {
+    try {
+        const c = getReadContract();
+        return await c.superAdmin();
+    }
+    catch {
+        return "";
+    }
+}
+// ── Escritura: registro (cualquiera) ─────────────────────────────────────────
+export async function registerMCPOnChain(params) {
+    try {
+        const provider = getProvider();
+        const wallet = new ethers.Wallet(params.ownerPrivateKey, provider);
+        const contract = new ethers.Contract(MCP_REGISTRY_ADDR, ABI, wallet);
+        const tx = await contract.registerMCP(params.mcpAddress, params.name, params.url, params.did ?? "", params.category ?? "general", params.description ?? "");
+        const receipt = await tx.wait();
+        return { success: true, txHash: receipt.hash };
+    }
+    catch (e) {
+        return { success: false, error: e.message };
+    }
+}
+// ── Escritura: admin — verificar ─────────────────────────────────────────────
+export async function verifyMCPOnChain(mcpAddress) {
+    try {
+        const c = getWriteContract();
+        const tx = await c.verify(mcpAddress);
+        const r = await tx.wait();
+        return { success: true, txHash: r.hash };
+    }
+    catch (e) {
+        return { success: false, error: e.message };
+    }
+}
+// ── Escritura: admin — revocar ───────────────────────────────────────────────
+export async function revokeMCPOnChain(mcpAddress, reason) {
+    try {
+        const c = getWriteContract();
+        const tx = await c.revoke(mcpAddress, reason);
+        const r = await tx.wait();
+        return { success: true, txHash: r.hash };
+    }
+    catch (e) {
+        return { success: false, error: e.message };
+    }
+}
+// ── Info del registry ────────────────────────────────────────────────────────
+export async function getRegistryInfo() {
+    try {
+        const c = getReadContract();
+        const [admin, total] = await Promise.all([c.superAdmin(), c.totalMCPs()]);
+        return {
+            contract: MCP_REGISTRY_ADDR,
+            network: "Base Sepolia (chainId: 84532)",
+            superAdmin: admin,
+            totalMCPs: Number(total),
+            explorer: `https://sepolia.basescan.org/address/${MCP_REGISTRY_ADDR}`,
+        };
+    }
+    catch {
+        return { contract: MCP_REGISTRY_ADDR, network: "Base Sepolia", superAdmin: "", totalMCPs: 0, explorer: "" };
+    }
+}

package/dist/p2p.d.ts

@@ -35,3 +35,4 @@ export declare function publishAttestationP2P(node: SoulprintP2PNode, att: BotAt
 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>;

package/dist/p2p.js

@@ -114,3 +114,35 @@ export async function stopP2PNode(node) {
     }
     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;
+    }
+}

package/dist/server.js

@@ -11,6 +11,7 @@ import { createSoulprintP2PNode, MAINNET_BOOTSTRAP, stopP2PNode } from "./p2p.js
 // ─── Config ──────────────────────────────────────────────────────────────────
 const HTTP_PORT = parseInt(process.env.SOULPRINT_PORT ?? "4888");
 const P2P_PORT = parseInt(process.env.SOULPRINT_P2P_PORT ?? String(HTTP_PORT + 2000));
+globalThis._startTime = Date.now();
 // Bootstrap nodes: variables de entorno o mainnet predefinidos
 const bootstrapEnv = (process.env.SOULPRINT_BOOTSTRAP ?? "")
     .split(",")
@@ -41,6 +42,39 @@ catch (err) {
     console.warn(`⚠️  P2P no disponible — solo HTTP gossip activo`);
     console.warn(`   Error: ${err?.message ?? String(err)}\n`);
 }
+// ─── 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)
+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";
+        for (const peerUrl of httpBootstraps) {
+            try {
+                const r = await fetch(`http://localhost:${HTTP_PORT}/peers/register`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ url: peerUrl, protocol_hash: PROTOCOL_HASH }),
+                    signal: AbortSignal.timeout(15_000),
+                });
+                const d = await r.json();
+                if (d.ok) {
+                    console.log(`  ✅ Bootstrap peer registrado: ${peerUrl} (total peers: ${d.peers})`);
+                }
+                else {
+                    console.warn(`  ⚠️  Bootstrap peer rechazado: ${peerUrl} — ${d.error ?? d.reason ?? "?"}`);
+                }
+            }
+            catch (e) {
+                console.warn(`  ❌ No se pudo conectar a bootstrap peer: ${peerUrl} — ${e.message}`);
+            }
+        }
+    }, 2_000);
+}
 // ─── Graceful shutdown ────────────────────────────────────────────────────────
 async function shutdown(signal) {
     console.log(`\n${signal} recibido — cerrando...`);

package/dist/validator.js

@@ -12,7 +12,8 @@ import { NullifierConsensus, AttestationConsensus, StateSyncManager } from "./co
 import { BlockchainAnchor } from "./blockchain/blockchain-anchor.js";
 import { SoulprintBlockchainClient, loadBlockchainConfig, } from "./blockchain/blockchain-client.js";
 import { getCodeIntegrity, logCodeIntegrity, computeRuntimeHash } from "./code-integrity.js";
-import { publishAttestationP2P, onAttestationReceived, getP2PStats, } from "./p2p.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");
@@ -565,6 +566,32 @@ 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 ─────────────────────────────────────────────────────────────────
@@ -897,6 +924,32 @@ export function startValidatorNode(port = PORT) {
             return handleInfo(res, nodeKeypair);
         if (cleanUrl === "/protocol" && req.method === "GET")
             return handleProtocol(res);
+        // 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;
+            return json(res, 200, {
+                node_did: nodeKeypair.did.slice(0, 20) + "...",
+                version: VERSION,
+                protocol_hash: PROTOCOL_HASH.slice(0, 16) + "...",
+                // identidades y reputación
+                verified_identities: Object.keys(nullifiers).length,
+                reputation_profiles: Object.keys(repStore).length,
+                // peers — HTTP gossip (funciona en todos los entornos)
+                known_peers: httpPeers,
+                // peers — libp2p P2P (requiere multicast/bootstrap; 0 en WSL2)
+                p2p_peers: libp2pPeers,
+                p2p_pubsub_peers: p2pStats?.pubsubPeers ?? 0,
+                p2p_enabled: !!p2pNode,
+                // total = max de ambas capas (HTTP gossip es el piso mínimo garantizado)
+                total_peers: Math.max(httpPeers, libp2pPeers),
+                // estado general
+                uptime_ms: Date.now() - (globalThis._startTime ?? Date.now()),
+                timestamp: Date.now(),
+                mcps_verified: null,
+            });
+        }
         if (cleanUrl === "/verify" && req.method === "POST")
             return handleVerify(req, res, nodeKeypair, ip);
         if (cleanUrl === "/token/renew" && req.method === "POST")
@@ -1074,6 +1127,137 @@ export function startValidatorNode(port = PORT) {
                 return json(res, 500, { error: "Execute failed - timelock not expired or proposal not approved" });
             return json(res, 200, { txHash, proposalId: body.proposalId, executed: true });
         }
+        // ── MCPRegistry — consulta pública ────────────────────────────────────────
+        // GET /mcps/verified — lista todos los MCPs verificados on-chain
+        if (cleanUrl === "/mcps/verified" && req.method === "GET") {
+            const [verified, info] = await Promise.all([getVerifiedMCPEntries(), getRegistryInfo()]);
+            return json(res, 200, {
+                total: verified.length,
+                registry: info,
+                mcps: verified.map(e => ({
+                    address: e.address,
+                    name: e.name,
+                    url: e.url,
+                    category: e.category,
+                    description: e.description,
+                    verified_at: new Date(e.verifiedAt * 1000).toISOString(),
+                    badge: "✅ VERIFIED",
+                })),
+            });
+        }
+        // GET /mcps/all — lista todos los MCPs (verificados + pendientes)
+        if (cleanUrl === "/mcps/all" && req.method === "GET") {
+            const [all, info] = await Promise.all([getAllMCPEntries(), getRegistryInfo()]);
+            return json(res, 200, {
+                total: all.length,
+                registry: info,
+                mcps: all.map(e => ({
+                    address: e.address,
+                    name: e.name,
+                    url: e.url,
+                    category: e.category,
+                    verified: e.verified,
+                    registered_at: new Date(e.registeredAt * 1000).toISOString(),
+                    verified_at: e.verifiedAt > 0 ? new Date(e.verifiedAt * 1000).toISOString() : null,
+                    revoked_at: e.revokedAt > 0 ? new Date(e.revokedAt * 1000).toISOString() : null,
+                })),
+            });
+        }
+        // GET /mcps/status/:address — estado de un MCP específico
+        if (cleanUrl.match(/^\/mcps\/status\/0x[0-9a-fA-F]{40}$/) && req.method === "GET") {
+            const addr = cleanUrl.split("/").pop();
+            const entry = await getMCPEntry(addr);
+            if (!entry)
+                return json(res, 404, { address: addr, registered: false, verified: false });
+            return json(res, 200, {
+                address: addr,
+                name: entry.name,
+                url: entry.url,
+                category: entry.category,
+                registered: true,
+                verified: entry.verified,
+                registered_at: new Date(entry.registeredAt * 1000).toISOString(),
+                verified_at: entry.verifiedAt > 0 ? new Date(entry.verifiedAt * 1000).toISOString() : null,
+                revoked_at: entry.revokedAt > 0 ? new Date(entry.revokedAt * 1000).toISOString() : null,
+                badge: entry.verified ? "✅ VERIFIED by Soulprint" : "⏳ Registered — pending verification",
+            });
+        }
+        // ── MCPRegistry — admin (requiere ADMIN_TOKEN o ADMIN_PRIVATE_KEY) ──────
+        // Verificar admin token (Bearer header o ADMIN_TOKEN env)
+        const ADMIN_TOKEN = process.env.ADMIN_TOKEN || "";
+        function isAdmin() {
+            if (!ADMIN_TOKEN)
+                return !!process.env.ADMIN_PRIVATE_KEY; // fallback: solo key
+            const auth = (req.headers["authorization"] ?? "");
+            return auth === `Bearer ${ADMIN_TOKEN}`;
+        }
+        // POST /admin/mcp/verify — verificar un MCP
+        if (cleanUrl === "/admin/mcp/verify" && req.method === "POST") {
+            if (!isAdmin())
+                return json(res, 401, { error: "Unauthorized — Bearer ADMIN_TOKEN required" });
+            if (!process.env.ADMIN_PRIVATE_KEY)
+                return json(res, 503, { error: "ADMIN_PRIVATE_KEY not configured" });
+            const body = await readBody(req);
+            if (!body?.address)
+                return json(res, 400, { error: "Required: address" });
+            const result = await verifyMCPOnChain(body.address);
+            if (!result.success)
+                return json(res, 500, { error: result.error });
+            return json(res, 200, {
+                address: body.address,
+                verified: true,
+                txHash: result.txHash,
+                explorer: `https://sepolia.basescan.org/tx/${result.txHash}`,
+                message: `✅ MCP ${body.address} verified on-chain by Soulprint`,
+            });
+        }
+        // POST /admin/mcp/revoke — revocar un MCP
+        if (cleanUrl === "/admin/mcp/revoke" && req.method === "POST") {
+            if (!isAdmin())
+                return json(res, 401, { error: "Unauthorized — Bearer ADMIN_TOKEN required" });
+            if (!process.env.ADMIN_PRIVATE_KEY)
+                return json(res, 503, { error: "ADMIN_PRIVATE_KEY not configured" });
+            const body = await readBody(req);
+            if (!body?.address || !body?.reason)
+                return json(res, 400, { error: "Required: address, reason" });
+            const result = await revokeMCPOnChain(body.address, body.reason);
+            if (!result.success)
+                return json(res, 500, { error: result.error });
+            return json(res, 200, {
+                address: body.address,
+                revoked: true,
+                reason: body.reason,
+                txHash: result.txHash,
+                explorer: `https://sepolia.basescan.org/tx/${result.txHash}`,
+                message: `🚫 MCP ${body.address} revoked. Reason: "${body.reason}"`,
+            });
+        }
+        // POST /admin/mcp/register — registrar MCP (permissionless, cualquiera)
+        if (cleanUrl === "/admin/mcp/register" && req.method === "POST") {
+            const body = await readBody(req);
+            if (!body?.ownerKey || !body?.address || !body?.name || !body?.url) {
+                return json(res, 400, { error: "Required: ownerKey, address, name, url" });
+            }
+            const result = await registerMCPOnChain({
+                ownerPrivateKey: body.ownerKey,
+                mcpAddress: body.address,
+                name: body.name,
+                url: body.url,
+                did: body.did ?? "",
+                category: body.category ?? "general",
+                description: body.description ?? "",
+            });
+            if (!result.success)
+                return json(res, 500, { error: result.error });
+            return json(res, 201, {
+                address: body.address,
+                name: body.name,
+                txHash: result.txHash,
+                explorer: `https://sepolia.basescan.org/tx/${result.txHash}`,
+                message: `✅ MCP registered. Contact Soulprint admin to verify.`,
+                next_step: "POST /admin/mcp/verify with Bearer ADMIN_TOKEN",
+            });
+        }
         json(res, 404, { error: "Not found" });
     });
     server.listen(port, () => {
@@ -1108,6 +1292,13 @@ export function startValidatorNode(port = PORT) {
         console.log(`   GET  /consensus/state-info    handshake para state-sync`);
         console.log(`   GET  /consensus/state         bulk state sync paginado`);
         console.log(`   POST /consensus/message       recibir msg PROPOSE/VOTE/COMMIT/ATTEST`);
+        console.log(`\n   MCPRegistry (on-chain, Base Sepolia):`);
+        console.log(`   GET  /mcps/verified             MCPs verificados por Soulprint`);
+        console.log(`   GET  /mcps/all                  todos los MCPs registrados`);
+        console.log(`   GET  /mcps/status/:address      estado de un MCP`);
+        console.log(`   POST /admin/mcp/register        registrar MCP (permissionless)`);
+        console.log(`   POST /admin/mcp/verify    🔐    verificar  (Bearer ADMIN_TOKEN)`);
+        console.log(`   POST /admin/mcp/revoke    🔐    revocar    (Bearer ADMIN_TOKEN)`);
         console.log(`\n`);
     });
     return server;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soulprint-network",
-  "version": "0.3.8",
+  "version": "0.4.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",
@@ -11,11 +11,6 @@
     "dist",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsc && node scripts/compute-code-hash.mjs",
-    "start": "node dist/server.js",
-    "build:hash": "node scripts/compute-code-hash.mjs"
-  },
   "publishConfig": {
     "access": "public"
   },
@@ -42,16 +37,18 @@
     "@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": "workspace:*",
-    "soulprint-zkp": "workspace:*",
-    "uint8arrays": "5.1.0"
+    "uint8arrays": "5.1.0",
+    "soulprint-core": "0.1.11",
+    "soulprint-zkp": "0.1.5"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -67,5 +64,10 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
+  },
+  "scripts": {
+    "build": "tsc && node scripts/compute-code-hash.mjs",
+    "start": "node dist/server.js",
+    "build:hash": "node scripts/compute-code-hash.mjs"
   }
-}
+}