soulprint-network 0.3.0 → 0.3.2

package/dist/blockchain/blockchain-anchor.d.ts

@@ -0,0 +1,112 @@
+/**
+ * blockchain-anchor.ts — Backup asíncrono de datos P2P a blockchain.
+ *
+ * ARQUITECTURA HÍBRIDA:
+ * ─────────────────────────────────────────────────────────────────────────────
+ * PRIMARIO   → BFT P2P Consensus (fast, $0, real-time)
+ * BACKUP     → Base Sepolia / Base mainnet (permanent, auditable, free testnet)
+ *
+ * FLUJO NORMAL:
+ *   1. BFT P2P: PROPOSE → VOTE → COMMIT (~2s, sin gas)
+ *   2. onCommitted() → blockchainClient.registerIdentity() (async, no bloquea)
+ *   3. Si blockchain falla → P2P sigue operando normal
+ *
+ * FLUJO DE RESTAURACIÓN (nodo arranca sin peers P2P):
+ *   1. StateSyncManager no encuentra peers
+ *   2. BlockchainAnchor.restoreFromBlockchain() carga nullifiers desde on-chain
+ *   3. Nodo queda sincronizado aunque todos los peers P2P estuvieran caídos
+ *
+ * RETRY POLICY:
+ *   - Reintentos con backoff exponencial (3 intentos)
+ *   - Después de 3 fallos: guarda en pendingQueue para reintentar al reconectar
+ *   - La queue persiste en disco (blockchain-pending.json)
+ */
+import { EventEmitter } from "node:events";
+export interface PendingNullifier {
+    nullifier: string;
+    did: string;
+    zkProof: object;
+    enqueuedAt: number;
+    attempts: number;
+}
+export interface PendingAttestation {
+    issuerDid: string;
+    targetDid: string;
+    value: 1 | -1;
+    context: string;
+    signature: string;
+    enqueuedAt: number;
+    attempts: number;
+}
+export interface AnchorStats {
+    nullifiersAnchored: number;
+    attestsAnchored: number;
+    pendingNullifiers: number;
+    pendingAttests: number;
+    blockchainConnected: boolean;
+    lastAnchorTs: number;
+}
+export interface BlockchainAnchorOptions {
+    storePath: string;
+}
+export declare class BlockchainAnchor extends EventEmitter {
+    private client;
+    private connected;
+    private storePath;
+    private pendingNullifiers;
+    private pendingAttests;
+    private stats;
+    constructor(opts: BlockchainAnchorOptions);
+    /**
+     * Conecta al blockchain (Base Sepolia o mainnet).
+     * Si no hay config → modo P2P-only (sin backup blockchain).
+     */
+    connect(): Promise<boolean>;
+    /**
+     * Ancla un nullifier committed en P2P al blockchain.
+     * NO bloqueante — el usuario ya recibió su respuesta del P2P.
+     */
+    anchorNullifier(params: {
+        nullifier: string;
+        did: string;
+        documentVerified: boolean;
+        faceVerified: boolean;
+        zkProof: {
+            a: [bigint, bigint];
+            b: [[bigint, bigint], [bigint, bigint]];
+            c: [bigint, bigint];
+            inputs: [bigint, bigint];
+        };
+    }): void;
+    /**
+     * Ancla una attestation al blockchain.
+     * NO bloqueante.
+     */
+    anchorAttestation(params: {
+        issuerDid: string;
+        targetDid: string;
+        value: 1 | -1;
+        context: string;
+        signature: string;
+    }): void;
+    /**
+     * Intenta restaurar nullifiers desde blockchain cuando P2P no tiene peers.
+     * Útil cuando todos los nodos P2P están caídos pero blockchain sigue vivo.
+     *
+     * @returns Lista de nullifiers restaurados (para importar en NullifierConsensus)
+     */
+    restoreNullifersFromBlockchain(): Promise<Array<{
+        nullifier: string;
+        did: string;
+        score: number;
+    }>>;
+    /**
+     * Retorna las estadísticas del anchor.
+     */
+    getStats(): AnchorStats;
+    private anchorNullifierWithRetry;
+    private anchorAttestWithRetry;
+    private flushQueue;
+    private loadQueue;
+    private saveQueue;
+}

package/dist/blockchain/blockchain-anchor.js

@@ -0,0 +1,263 @@
+/**
+ * blockchain-anchor.ts — Backup asíncrono de datos P2P a blockchain.
+ *
+ * ARQUITECTURA HÍBRIDA:
+ * ─────────────────────────────────────────────────────────────────────────────
+ * PRIMARIO   → BFT P2P Consensus (fast, $0, real-time)
+ * BACKUP     → Base Sepolia / Base mainnet (permanent, auditable, free testnet)
+ *
+ * FLUJO NORMAL:
+ *   1. BFT P2P: PROPOSE → VOTE → COMMIT (~2s, sin gas)
+ *   2. onCommitted() → blockchainClient.registerIdentity() (async, no bloquea)
+ *   3. Si blockchain falla → P2P sigue operando normal
+ *
+ * FLUJO DE RESTAURACIÓN (nodo arranca sin peers P2P):
+ *   1. StateSyncManager no encuentra peers
+ *   2. BlockchainAnchor.restoreFromBlockchain() carga nullifiers desde on-chain
+ *   3. Nodo queda sincronizado aunque todos los peers P2P estuvieran caídos
+ *
+ * RETRY POLICY:
+ *   - Reintentos con backoff exponencial (3 intentos)
+ *   - Después de 3 fallos: guarda en pendingQueue para reintentar al reconectar
+ *   - La queue persiste en disco (blockchain-pending.json)
+ */
+import { EventEmitter } from "node:events";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { SoulprintBlockchainClient, loadBlockchainConfig, } from "./blockchain-client.js";
+// ── Constantes ────────────────────────────────────────────────────────────────
+const MAX_ATTEMPTS = 3;
+const RETRY_DELAY_MS = [0, 2000, 8000]; // backoff: 0s, 2s, 8s
+const FLUSH_INTERVAL = 60_000; // reintentar pendientes cada 60s
+// ── BlockchainAnchor ──────────────────────────────────────────────────────────
+export class BlockchainAnchor extends EventEmitter {
+    client = null;
+    connected = false;
+    storePath;
+    pendingNullifiers = [];
+    pendingAttests = [];
+    stats = {
+        nullifiersAnchored: 0,
+        attestsAnchored: 0,
+        pendingNullifiers: 0,
+        pendingAttests: 0,
+        blockchainConnected: false,
+        lastAnchorTs: 0,
+    };
+    constructor(opts) {
+        super();
+        this.storePath = opts.storePath;
+        this.loadQueue();
+    }
+    // ── Inicialización ──────────────────────────────────────────────────────────
+    /**
+     * Conecta al blockchain (Base Sepolia o mainnet).
+     * Si no hay config → modo P2P-only (sin backup blockchain).
+     */
+    async connect() {
+        const config = loadBlockchainConfig();
+        if (!config) {
+            console.log("[anchor] No blockchain config — P2P-only mode (no backup)");
+            console.log("[anchor] Set SOULPRINT_RPC_URL + SOULPRINT_PRIVATE_KEY to enable backup");
+            return false;
+        }
+        this.client = new SoulprintBlockchainClient(config);
+        this.connected = await this.client.connect();
+        this.stats.blockchainConnected = this.connected;
+        if (this.connected) {
+            console.log("[anchor] ✅ Blockchain backup enabled — Base Sepolia");
+            // Flush queue pendiente al conectar
+            await this.flushQueue();
+            // Programar flush periódico
+            setInterval(() => this.flushQueue(), FLUSH_INTERVAL);
+        }
+        return this.connected;
+    }
+    // ── Anchor P2P → Blockchain ─────────────────────────────────────────────────
+    /**
+     * Ancla un nullifier committed en P2P al blockchain.
+     * NO bloqueante — el usuario ya recibió su respuesta del P2P.
+     */
+    anchorNullifier(params) {
+        if (!this.connected || !this.client) {
+            // Guardar en queue para cuando se conecte
+            this.pendingNullifiers.push({
+                nullifier: params.nullifier,
+                did: params.did,
+                zkProof: params,
+                enqueuedAt: Date.now(),
+                attempts: 0,
+            });
+            this.saveQueue();
+            this.emit("queued", "nullifier", params.nullifier);
+            return;
+        }
+        // Fire-and-forget con retry
+        this.anchorNullifierWithRetry(params).catch(err => {
+            console.warn(`[anchor] Nullifier ${params.nullifier.slice(0, 12)}... enqueued (${err.message?.slice(0, 40)})`);
+        });
+    }
+    /**
+     * Ancla una attestation al blockchain.
+     * NO bloqueante.
+     */
+    anchorAttestation(params) {
+        if (!this.connected || !this.client) {
+            this.pendingAttests.push({
+                ...params,
+                enqueuedAt: Date.now(),
+                attempts: 0,
+            });
+            this.saveQueue();
+            this.emit("queued", "attestation", params.issuerDid);
+            return;
+        }
+        this.anchorAttestWithRetry(params).catch(err => {
+            console.warn(`[anchor] Attestation ${params.issuerDid.slice(0, 16)}→${params.targetDid.slice(0, 16)} enqueued`);
+        });
+    }
+    // ── Restauración desde blockchain ───────────────────────────────────────────
+    /**
+     * Intenta restaurar nullifiers desde blockchain cuando P2P no tiene peers.
+     * Útil cuando todos los nodos P2P están caídos pero blockchain sigue vivo.
+     *
+     * @returns Lista de nullifiers restaurados (para importar en NullifierConsensus)
+     */
+    async restoreNullifersFromBlockchain() {
+        if (!this.connected || !this.client)
+            return [];
+        console.log("[anchor] Attempting restore from blockchain...");
+        // TODO: implementar cuando el contrato tenga un getter de todos los nullifiers
+        // Por ahora el contrato solo tiene isRegistered(bytes32) y identityScore(string)
+        // En v0.4: agregar getAllNullifiers() al contrato o usar eventos
+        console.log("[anchor] Restore not yet implemented — use P2P sync");
+        return [];
+    }
+    /**
+     * Retorna las estadísticas del anchor.
+     */
+    getStats() {
+        this.stats.pendingNullifiers = this.pendingNullifiers.length;
+        this.stats.pendingAttests = this.pendingAttests.length;
+        return { ...this.stats };
+    }
+    // ── Internos ────────────────────────────────────────────────────────────────
+    async anchorNullifierWithRetry(params) {
+        let lastErr = null;
+        for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+            if (attempt > 0) {
+                await sleep(RETRY_DELAY_MS[attempt] ?? 8000);
+            }
+            try {
+                const txHash = await this.client.registerIdentity({
+                    nullifier: params.nullifier,
+                    did: params.did,
+                    documentVerified: params.documentVerified ?? true,
+                    faceVerified: params.faceVerified ?? true,
+                    zkProof: params.zkProof ?? {
+                        a: [0n, 0n],
+                        b: [[0n, 0n], [0n, 0n]],
+                        c: [0n, 0n],
+                        inputs: [BigInt(params.nullifier.replace(/^0x/, "").slice(0, 8) || "1"), 1n],
+                    },
+                });
+                if (txHash) {
+                    this.stats.nullifiersAnchored++;
+                    this.stats.lastAnchorTs = Date.now();
+                    this.emit("anchored", "nullifier", params.nullifier, txHash);
+                    console.log(`[anchor] ✅ nullifier ${params.nullifier.slice(0, 12)}... → tx ${txHash.slice(0, 12)}...`);
+                    return;
+                }
+            }
+            catch (err) {
+                lastErr = err;
+                // Nullifier ya registrado on-chain — no es un error real
+                if (err.message?.includes("NullifierAlreadyUsed")) {
+                    console.log(`[anchor] Nullifier ${params.nullifier.slice(0, 12)}... already on-chain — OK`);
+                    return;
+                }
+            }
+        }
+        // Después de 3 intentos → queue
+        this.pendingNullifiers.push({
+            nullifier: params.nullifier,
+            did: params.did,
+            zkProof: params,
+            enqueuedAt: Date.now(),
+            attempts: MAX_ATTEMPTS,
+        });
+        this.saveQueue();
+    }
+    async anchorAttestWithRetry(params) {
+        let lastErr = null;
+        for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+            if (attempt > 0)
+                await sleep(RETRY_DELAY_MS[attempt] ?? 8000);
+            try {
+                const txHash = await this.client.attest({
+                    issuerDid: params.issuerDid,
+                    targetDid: params.targetDid,
+                    value: params.value,
+                    context: params.context,
+                    signature: params.signature ?? "0x",
+                });
+                if (txHash) {
+                    this.stats.attestsAnchored++;
+                    this.stats.lastAnchorTs = Date.now();
+                    this.emit("anchored", "attestation", params.issuerDid, txHash);
+                    console.log(`[anchor] ✅ attest ${params.issuerDid.slice(0, 12)}→${params.targetDid.slice(0, 12)} → tx ${txHash.slice(0, 12)}...`);
+                    return;
+                }
+            }
+            catch (err) {
+                lastErr = err;
+                if (err.message?.includes("CooldownActive")) {
+                    console.log(`[anchor] Attestation cooldown on-chain — skipping`);
+                    return;
+                }
+            }
+        }
+        this.pendingAttests.push({ ...params, enqueuedAt: Date.now(), attempts: MAX_ATTEMPTS });
+        this.saveQueue();
+    }
+    async flushQueue() {
+        if (!this.connected || !this.client)
+            return;
+        const nullifiers = [...this.pendingNullifiers];
+        const attests = [...this.pendingAttests];
+        this.pendingNullifiers = [];
+        this.pendingAttests = [];
+        for (const p of nullifiers) {
+            await this.anchorNullifierWithRetry(p).catch(() => { });
+        }
+        for (const a of attests) {
+            await this.anchorAttestWithRetry(a).catch(() => { });
+        }
+        this.saveQueue();
+    }
+    // ── Persistencia de queue ───────────────────────────────────────────────────
+    loadQueue() {
+        const nullFile = this.storePath + "-nullifiers.json";
+        const attFile = this.storePath + "-attestations.json";
+        try {
+            if (existsSync(nullFile))
+                this.pendingNullifiers = JSON.parse(readFileSync(nullFile, "utf8"));
+            if (existsSync(attFile))
+                this.pendingAttests = JSON.parse(readFileSync(attFile, "utf8"));
+            const total = this.pendingNullifiers.length + this.pendingAttests.length;
+            if (total > 0)
+                console.log(`[anchor] Loaded ${total} pending items from queue`);
+        }
+        catch { /* queue vacía o corrupta */ }
+    }
+    saveQueue() {
+        try {
+            writeFileSync(this.storePath + "-nullifiers.json", JSON.stringify(this.pendingNullifiers, null, 2));
+            writeFileSync(this.storePath + "-attestations.json", JSON.stringify(this.pendingAttests, null, 2));
+        }
+        catch { /* non-critical */ }
+    }
+}
+// ── Helpers ────────────────────────────────────────────────────────────────────
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}

package/dist/validator.js

@@ -8,6 +8,7 @@ import { handleCredentialRoute } from "./credentials/index.js";
 import { encryptGossip, decryptGossip } from "./crypto/gossip-cipher.js";
 import { selectGossipPeers, routingStats } from "./crypto/peer-router.js";
 import { NullifierConsensus, AttestationConsensus, StateSyncManager } from "./consensus/index.js";
+import { BlockchainAnchor } from "./blockchain/blockchain-anchor.js";
 import { publishAttestationP2P, onAttestationReceived, getP2PStats, } from "./p2p.js";
 // ── Config ────────────────────────────────────────────────────────────────────
 const PORT = parseInt(process.env.SOULPRINT_PORT ?? String(PROTOCOL.DEFAULT_HTTP_PORT));
@@ -662,6 +663,40 @@ export function startValidatorNode(port = PORT) {
     }).catch(() => { });
     // Actualizar peer count en nullifierConsensus al cambiar peers
     setInterval(() => nullifierConsensus.setPeerCount(peers.length), 5_000);
+    // ── Blockchain backup (P2P primario + blockchain como backup) ─────────────
+    // P2P confirma primero → blockchain ancla async (no bloquea al usuario)
+    const anchor = new BlockchainAnchor({
+        storePath: join(NODE_DIR, "blockchain-queue"),
+    });
+    // Conectar en background (no bloquea el arranque del nodo)
+    anchor.connect().catch(() => { });
+    // Escuchar eventos del consenso y anclar async
+    nullifierConsensus.on("committed", (entry) => {
+        anchor.anchorNullifier({
+            nullifier: entry.nullifier,
+            did: entry.did,
+            documentVerified: true,
+            faceVerified: true,
+            zkProof: {
+                a: [0n, 0n],
+                b: [[0n, 0n], [0n, 0n]],
+                c: [0n, 0n],
+                inputs: [BigInt("0x" + entry.nullifier.replace(/^0x/, "").slice(0, 16).padEnd(16, "0") || "1"), 1n],
+            },
+        });
+    });
+    attestConsensus.on("attested", (entry) => {
+        anchor.anchorAttestation({
+            issuerDid: entry.issuerDid,
+            targetDid: entry.targetDid,
+            value: entry.value,
+            context: entry.context,
+            signature: entry.sig,
+        });
+    });
+    anchor.on("anchored", (type, id, txHash) => {
+        console.log(`[anchor] ${type} ${id.slice(0, 12)}... → blockchain tx ${txHash.slice(0, 12)}...`);
+    });
     // ── Credential context (para el router de credenciales) ───────────────────
     const credentialCtx = {
         nodeKeypair,
@@ -705,6 +740,10 @@ export function startValidatorNode(port = PORT) {
             return handleGetReputation(res, decodeURIComponent(cleanUrl.replace("/reputation/", "")));
         if (cleanUrl.startsWith("/nullifier/") && req.method === "GET")
             return handleNullifierCheck(res, decodeURIComponent(cleanUrl.replace("/nullifier/", "")));
+        // ── Blockchain anchor status ──────────────────────────────────────────────
+        if (cleanUrl === "/anchor/stats" && req.method === "GET") {
+            return json(res, 200, anchor.getStats());
+        }
         // ── Consensus P2P endpoints (sin EVM, sin gas) ─────────────────────────
         // GET /consensus/state-info — handshake para state-sync
         if (cleanUrl === "/consensus/state-info" && req.method === "GET") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soulprint-network",
-  "version": "0.3.0",
+  "version": "0.3.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",