shogun-core 3.1.0 → 3.2.0

package/dist/browser/shogun-core.js

@@ -98485,6 +98485,1463 @@ module.exports = function whichTypedArray(value) {
 };
 
 
+/***/ }),
+
+/***/ "./ship/examples/messenger-cli.ts":
+/*!****************************************!*\
+  !*** ./ship/examples/messenger-cli.ts ***!
+  \****************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+/* provided dependency */ var process = __webpack_require__(/*! process/browser */ "./node_modules/process/browser.js");
+/* provided dependency */ var Buffer = __webpack_require__(/*! buffer */ "./node_modules/buffer/index.js")["Buffer"];
+//#!/usr/bin/env node
+
+/**
+ * Shogun Chat - CLI Interface
+ *
+ * End-to-end encrypted decentralized chat
+ * Simple and functional CLI interface
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MessengerCLI = void 0;
+const SHIP_01_1 = __webpack_require__(/*! ../implementation/SHIP_01 */ "./ship/implementation/SHIP_01.ts");
+// Only import readline in Node.js environment
+let readline;
+try {
+    if (false) // removed by dead control flow
+{}
+}
+catch (e) {
+    // Browser environment - readline not available
+}
+// ============================================================================
+// COLORS
+// ============================================================================
+const colors = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+    gray: "\x1b[90m",
+};
+const c = (color, text) => `${colors[color]}${text}${colors.reset}`;
+// ============================================================================
+// CHAT CLI
+// ============================================================================
+class MessengerCLI {
+    constructor() {
+        this.currentUser = "";
+        this.recipient = "";
+        this.derivedAddress = "";
+        this.isAuthenticated = false;
+        // Initialize app in all environments (needed for TypeScript)
+        this.app = new SHIP_01_1.SHIP_01({
+            gunOptions: {
+                peers: [
+                    "https://v5g5jseqhgkp43lppgregcfbvi.srv.us/gun",
+                    "https://relay.shogun-eco.xyz/gun",
+                    "https://peer.wallie.io/gun",
+                ],
+                radisk: false,
+                localStorage: false,
+                multicast: false, // Disabilita multicast per evitare blocchi
+                wire: false,
+                axe: false,
+            },
+        });
+        // Don't initialize readline in browser environment
+        if (true) {
+            console.warn('MessengerCLI is designed for Node.js CLI usage only');
+            return;
+        }
+        // removed by dead control flow
+
+        // removed by dead control flow
+
+    }
+    // ========================================================================
+    // SETUP
+    // ========================================================================
+    setupHandlers() {
+        this.rl.on("line", async (line) => {
+            const input = line.trim();
+            if (!input) {
+                this.rl.prompt();
+                return;
+            }
+            if (input.startsWith("/")) {
+                await this.handleCommand(input);
+            }
+            else {
+                await this.sendMessage(input);
+            }
+            this.rl.prompt();
+        });
+        this.rl.on("close", () => {
+            console.log("\n" + c("yellow", "👋 Arrivederci!"));
+            process.exit(0);
+        });
+        // Ctrl+C handler
+        process.on("SIGINT", () => {
+            this.rl.close();
+        });
+    }
+    // ========================================================================
+    // UTILITIES
+    // ========================================================================
+    async withTimeout(promise, timeoutMs, errorMessage) {
+        return Promise.race([
+            promise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs)),
+        ]);
+    }
+    // ========================================================================
+    // AUTH
+    // ========================================================================
+    async login(username, password) {
+        console.log(c("cyan", "🔐 Login in corso..."));
+        // Loading indicator
+        const loadingInterval = setInterval(() => {
+            process.stdout.write(c("gray", "."));
+        }, 500);
+        try {
+            // Prova login con timeout
+            let result = await this.withTimeout(this.app.login(username, password), 15000, "Login timeout - verifica connessione ai peers");
+            clearInterval(loadingInterval);
+            console.log(""); // Nuova linea dopo i dots
+            // Se fallisce, prova signup
+            if (!result.success) {
+                console.log(c("yellow", "📝 Utente non trovato, creazione in corso..."));
+                const signupResult = await this.app.signup(username, password);
+                if (signupResult.success) {
+                    // Aspetta un momento per evitare race condition
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    // Riprova login
+                    result = await this.app.login(username, password);
+                }
+                else {
+                    console.log(c("red", `❌ Signup fallito: ${signupResult.error}`));
+                    return false;
+                }
+            }
+            if (result.success) {
+                this.currentUser = username;
+                this.derivedAddress = result.derivedAddress || "";
+                this.isAuthenticated = true;
+                console.log("");
+                console.log(c("green", "✅ Login effettuato!"));
+                console.log(c("gray", `   Username: ${c("bold", username)}`));
+                console.log(c("gray", `   Public Key: ${result.userPub?.substring(0, 40)}...`));
+                console.log(c("gray", `   Derived Address: ${c("cyan", result.derivedAddress || "")}`));
+                console.log("");
+                console.log(c("yellow", "📢 Pubblicazione chiave pubblica..."));
+                await this.app.publishPublicKey();
+                // Aspetta che la chiave sia sincronizzata
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+                console.log(c("green", "✅ Chiave pubblicata su GunDB"));
+                console.log("");
+                // Ascolta messaggi
+                await this.app.listenForMessages((msg) => {
+                    this.onMessageReceived(msg);
+                });
+                console.log(c("cyan", "💬 Chat pronta! Scrivi /help per i comandi disponibili"));
+                console.log("");
+                return true;
+            }
+            else {
+                console.log(c("red", `❌ Login fallito: ${result.error}`));
+                return false;
+            }
+        }
+        catch (error) {
+            clearInterval(loadingInterval);
+            console.log("");
+            console.log(c("red", `❌ Errore: ${error.message}`));
+            return false;
+        }
+        finally {
+            clearInterval(loadingInterval);
+        }
+    }
+    // ========================================================================
+    // MESSAGING
+    // ========================================================================
+    async sendMessage(content) {
+        if (!this.isAuthenticated) {
+            console.log(c("red", "❌ Non autenticato. Usa /login"));
+            return;
+        }
+        if (!this.recipient) {
+            console.log(c("yellow", "⚠️  Nessun destinatario. Usa /to <username>"));
+            return;
+        }
+        try {
+            const result = await this.app.sendMessage(this.recipient, content);
+            if (result.success) {
+                const time = new Date().toLocaleTimeString();
+                console.log(c("gray", `[${time}]`) +
+                    " " +
+                    c("green", `${this.currentUser}:`) +
+                    " " +
+                    content);
+            }
+            else {
+                console.log(c("red", `❌ Errore invio: ${result.error}`));
+            }
+        }
+        catch (error) {
+            console.log(c("red", `❌ Errore: ${error.message}`));
+        }
+    }
+    onMessageReceived(message) {
+        const time = new Date(message.timestamp).toLocaleTimeString();
+        const fromUser = message.from.substring(0, 10) + "...";
+        console.log("");
+        console.log(c("cyan", "📨 Nuovo messaggio!"));
+        console.log(c("gray", `[${time}]`) +
+            " " +
+            c("cyan", `${fromUser}:`) +
+            " " +
+            message.content);
+        console.log("");
+        this.rl.prompt();
+    }
+    // ========================================================================
+    // KEY PAIR MANAGEMENT
+    // ========================================================================
+    async exportKeyPair() {
+        try {
+            // Ottieni il SEA pair completo
+            const seaPair = this.app["shogun"].db.gun.user()?._?.sea;
+            if (!seaPair) {
+                console.log(c("red", "❌ Impossibile accedere al SEA pair"));
+                return;
+            }
+            // Crea export object
+            const exportData = {
+                pub: seaPair.pub,
+                priv: seaPair.priv,
+                epub: seaPair.epub,
+                epriv: seaPair.epriv,
+                alias: this.currentUser,
+                exportedAt: Date.now()
+            };
+            // Converti in base64 per facilità di copia
+            const jsonString = JSON.stringify(exportData);
+            const base64 = Buffer.from(jsonString).toString('base64');
+            console.log("");
+            console.log(c("green", "✅ KEY PAIR ESPORTATO"));
+            console.log(c("yellow", "═".repeat(60)));
+            console.log("");
+            console.log(c("bold", "🔑 SEA PAIR (Base64):"));
+            console.log("");
+            console.log(c("cyan", base64));
+            console.log("");
+            console.log(c("yellow", "═".repeat(60)));
+            console.log("");
+            console.log(c("gray", "💾 SALVA QUESTO KEY PAIR IN UN LUOGO SICURO!"));
+            console.log(c("gray", "   Puoi usarlo per:"));
+            console.log(c("gray", "   - Fare login: /login-pair <keypair>"));
+            console.log(c("gray", "   - Importare: /import <keypair>"));
+            console.log(c("gray", "   - Backup della tua identità"));
+            console.log("");
+            console.log(c("red", "⚠️  NON CONDIVIDERE MAI QUESTO KEY PAIR!"));
+            console.log(c("red", "   Contiene le tue chiavi private!"));
+            console.log("");
+            // Salva anche su file (opzionale)
+            const fs = await __webpack_require__.e(/*! import() */ "_e6ae").then(__webpack_require__.t.bind(__webpack_require__, /*! fs */ "?e6ae", 23));
+            const filename = `shogun-keypair-${this.currentUser}-${Date.now()}.txt`;
+            fs.writeFileSync(filename, base64);
+            console.log(c("green", `💾 Key pair salvato anche in: ${filename}`));
+            console.log("");
+        }
+        catch (error) {
+            console.log(c("red", `❌ Errore export: ${error.message}`));
+        }
+    }
+    async importKeyPair(base64KeyPair) {
+        try {
+            // Decodifica da base64
+            const jsonString = Buffer.from(base64KeyPair, 'base64').toString('utf-8');
+            const keyPairData = JSON.parse(jsonString);
+            // Verifica che abbia tutti i campi necessari
+            if (!keyPairData.pub || !keyPairData.priv || !keyPairData.epub || !keyPairData.epriv) {
+                console.log(c("red", "❌ Key pair invalido. Mancano campi obbligatori."));
+                return;
+            }
+            console.log(c("cyan", "📥 Key pair importato con successo!"));
+            console.log(c("gray", `   Utente: ${keyPairData.alias || 'unknown'}`));
+            console.log(c("gray", `   Public Key: ${keyPairData.pub.substring(0, 30)}...`));
+            console.log("");
+            console.log(c("yellow", "💡 Usa /login-pair <keypair> per fare login"));
+            console.log("");
+        }
+        catch (error) {
+            console.log(c("red", `❌ Errore import: ${error.message}`));
+            console.log(c("gray", "   Verifica che il key pair sia valido"));
+        }
+    }
+    async loginWithPair(base64KeyPair) {
+        console.log(c("cyan", "🔐 Login con key pair..."));
+        const loadingInterval = setInterval(() => {
+            process.stdout.write(c("gray", "."));
+        }, 500);
+        try {
+            // Decodifica key pair
+            const jsonString = Buffer.from(base64KeyPair, 'base64').toString('utf-8');
+            const keyPairData = JSON.parse(jsonString);
+            // Verifica validità
+            if (!keyPairData.pub || !keyPairData.priv || !keyPairData.epub || !keyPairData.epriv) {
+                throw new Error("Key pair invalido");
+            }
+            // Crea SEA pair object
+            const seaPair = {
+                pub: keyPairData.pub,
+                priv: keyPairData.priv,
+                epub: keyPairData.epub,
+                epriv: keyPairData.epriv
+            };
+            // Login con pair
+            const result = await this.withTimeout(this.app["shogun"].loginWithPair(seaPair), 15000, "Login timeout");
+            clearInterval(loadingInterval);
+            console.log("");
+            if (result.success) {
+                this.currentUser = keyPairData.alias || result.username || 'unknown';
+                this.derivedAddress = await this.app.deriveEthereumAddress(seaPair.pub);
+                this.isAuthenticated = true;
+                console.log("");
+                console.log(c("green", "✅ Login con key pair effettuato!"));
+                console.log(c("gray", `   Username: ${c("bold", this.currentUser)}`));
+                console.log(c("gray", `   Public Key: ${seaPair.pub.substring(0, 40)}...`));
+                console.log(c("gray", `   Derived Address: ${c("cyan", this.derivedAddress)}`));
+                console.log("");
+                console.log(c("yellow", "📢 Pubblicazione chiave pubblica..."));
+                await this.app.publishPublicKey();
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+                console.log(c("green", "✅ Chiave pubblicata su GunDB"));
+                console.log("");
+                // Ascolta messaggi
+                await this.app.listenForMessages((msg) => {
+                    this.onMessageReceived(msg);
+                });
+                console.log(c("cyan", "💬 Chat pronta!"));
+                console.log("");
+                this.updatePrompt();
+            }
+            else {
+                console.log(c("red", `❌ Login fallito: ${result.error}`));
+            }
+        }
+        catch (error) {
+            clearInterval(loadingInterval);
+            console.log("");
+            console.log(c("red", `❌ Errore: ${error.message}`));
+        }
+        finally {
+            clearInterval(loadingInterval);
+        }
+    }
+    async wipeAllMessages() {
+        console.log("");
+        console.log(c("yellow", "⚠️  ATTENZIONE: Stai per cancellare TUTTI i messaggi dal nodo GunDB"));
+        console.log(c("yellow", "   Questa operazione è IRREVERSIBILE!"));
+        console.log("");
+        // Conferma
+        this.rl.question(c("red", "Sei sicuro? Scrivi 'CONFERMA' per procedere: "), (answer) => {
+            if (answer.trim() === "CONFERMA") {
+                console.log(c("yellow", "🗑️  Cancellazione messaggi in corso..."));
+                // Ottieni tutti i messaggi
+                this.app["shogun"].db.gun.get("messages").once((allMessages) => {
+                    if (allMessages && typeof allMessages === 'object') {
+                        let count = 0;
+                        // Cancella ogni messaggio
+                        for (const [messageId, data] of Object.entries(allMessages)) {
+                            if (typeof data === "object" && data !== null && messageId !== '_') {
+                                this.app["shogun"].db.gun.get("messages").get(messageId).put(null);
+                                count++;
+                            }
+                        }
+                        console.log(c("green", `✅ ${count} messaggi cancellati dal nodo GunDB`));
+                    }
+                    else {
+                        console.log(c("gray", "ℹ️  Nessun messaggio da cancellare"));
+                    }
+                    console.log("");
+                    this.rl.prompt();
+                });
+            }
+            else {
+                console.log(c("gray", "❌ Cancellazione annullata"));
+                console.log("");
+                this.rl.prompt();
+            }
+        });
+    }
+    // ========================================================================
+    // COMMANDS
+    // ========================================================================
+    async handleCommand(cmd) {
+        const parts = cmd.split(" ");
+        const command = parts[0].toLowerCase();
+        const args = parts.slice(1);
+        switch (command) {
+            case "/login":
+                if (args.length >= 2) {
+                    const [username, password] = args;
+                    await this.login(username, password);
+                    this.updatePrompt();
+                }
+                else {
+                    console.log(c("yellow", "⚠️  Uso: /login <username> <password>"));
+                }
+                break;
+            case "/to":
+            case "/chat":
+                if (!this.isAuthenticated) {
+                    console.log(c("red", "❌ Prima fai login: /login <username> <password>"));
+                    break;
+                }
+                if (args[0]) {
+                    this.recipient = args[0];
+                    console.log(c("cyan", `💬 Chattando con ${c("bold", this.recipient)}`));
+                    // Carica storico
+                    const history = await this.app.getMessageHistory(this.recipient);
+                    if (history.length > 0) {
+                        console.log(c("gray", `\n📚 Storico conversazione (${history.length} messaggi):\n`));
+                        history.forEach((msg, i) => {
+                            const time = new Date(msg.timestamp).toLocaleTimeString();
+                            const isMe = msg.from === this.currentUser;
+                            const from = isMe ? this.currentUser : this.recipient;
+                            const color = isMe ? "green" : "cyan";
+                            console.log(c("gray", `[${time}]`) +
+                                " " +
+                                c(color, `${from}:`) +
+                                " " +
+                                msg.content);
+                        });
+                        console.log("");
+                    }
+                    this.updatePrompt();
+                }
+                else {
+                    console.log(c("yellow", "⚠️  Uso: /to <username>"));
+                }
+                break;
+            case "/help":
+                this.showHelp();
+                break;
+            case "/clear":
+                console.clear();
+                this.showHeader();
+                break;
+            case "/status":
+                this.showStatus();
+                break;
+            case "/logout":
+                this.app.logout();
+                this.isAuthenticated = false;
+                this.currentUser = "";
+                this.recipient = "";
+                console.log(c("yellow", "👋 Disconnesso"));
+                this.updatePrompt();
+                break;
+            case "/export":
+            case "/backup":
+                if (!this.isAuthenticated) {
+                    console.log(c("red", "❌ Prima fai login"));
+                    break;
+                }
+                await this.exportKeyPair();
+                break;
+            case "/import":
+            case "/restore":
+                if (args[0]) {
+                    await this.importKeyPair(args[0]);
+                }
+                else {
+                    console.log(c("yellow", "⚠️  Uso: /import <keypair-json-base64>"));
+                }
+                break;
+            case "/login-pair":
+                if (args[0]) {
+                    await this.loginWithPair(args[0]);
+                }
+                else {
+                    console.log(c("yellow", "⚠️  Uso: /login-pair <keypair-json-base64>"));
+                }
+                break;
+            case "/wipe":
+            case "/delete-all":
+                if (!this.isAuthenticated) {
+                    console.log(c("red", "❌ Prima fai login"));
+                    break;
+                }
+                await this.wipeAllMessages();
+                break;
+            case "/exit":
+            case "/quit":
+                this.rl.close();
+                break;
+            default:
+                console.log(c("red", `❌ Comando sconosciuto: ${command}`));
+                console.log(c("gray", "   Scrivi /help per aiuto"));
+        }
+    }
+    showHelp() {
+        console.log("");
+        console.log(c("bold", c("cyan", "📖 COMANDI DISPONIBILI")));
+        console.log("");
+        console.log(c("bold", "AUTENTICAZIONE:"));
+        console.log("  " + c("bold", "/login <user> <pass>") + "  - Login/Signup con password");
+        console.log("  " + c("bold", "/login-pair <keypair>") + "  - Login con SEA key pair");
+        console.log("");
+        console.log(c("bold", "MESSAGGISTICA:"));
+        console.log("  " + c("bold", "/to <username>") + "        - Inizia chat con un utente");
+        console.log("");
+        console.log(c("bold", "KEY MANAGEMENT:"));
+        console.log("  " + c("bold", "/export") + "                - Esporta il tuo key pair (backup)");
+        console.log("  " + c("bold", "/import <keypair>") + "     - Mostra info su key pair");
+        console.log("");
+        console.log(c("bold", "UTILITÀ:"));
+        console.log("  " + c("bold", "/help") + "                 - Mostra questo aiuto");
+        console.log("  " + c("bold", "/status") + "               - Mostra stato connessione");
+        console.log("  " + c("bold", "/clear") + "                - Pulisci schermo");
+        console.log("  " + c("bold", "/wipe") + "                 - Cancella TUTTI i messaggi (⚠️)");
+        console.log("  " + c("bold", "/logout") + "               - Disconnetti");
+        console.log("  " + c("bold", "/exit") + "                 - Esci dall'app");
+        console.log("");
+        console.log(c("bold", c("green", "🔐 SICUREZZA")));
+        console.log("");
+        console.log("  ✅ Crittografia end-to-end (ECDH + AES-GCM)");
+        console.log("  ✅ Storage decentralizzato P2P (GunDB)");
+        console.log("  ✅ Nessun server può leggere i messaggi");
+        console.log("  ✅ Key pair portabile (export/import)");
+        console.log("  ✅ Zero costi, completamente gratis");
+        console.log("");
+        console.log(c("bold", c("yellow", "💡 ESEMPI")));
+        console.log("");
+        console.log("  " + c("gray", "# Login normale"));
+        console.log("  " + c("gray", "/login alice password123"));
+        console.log("");
+        console.log("  " + c("gray", "# Export key pair (backup)"));
+        console.log("  " + c("gray", "/export"));
+        console.log("");
+        console.log("  " + c("gray", "# Login con key pair (no password)"));
+        console.log("  " + c("gray", "/login-pair eyJwdWIiOiIuLi4ifQ=="));
+        console.log("");
+        console.log("  " + c("gray", "# Chattare"));
+        console.log("  " + c("gray", "/to bob"));
+        console.log("  " + c("gray", "Ciao Bob! Come stai?"));
+        console.log("");
+    }
+    showStatus() {
+        console.log("");
+        console.log(c("bold", c("cyan", "📊 STATO SISTEMA")));
+        console.log("");
+        console.log("  " + c("gray", "Utente:") + " " + c("green", this.currentUser));
+        console.log("  " +
+            c("gray", "Destinatario:") +
+            " " +
+            c("yellow", this.recipient || "(nessuno)"));
+        console.log("  " + c("gray", "Address:") + " " + c("cyan", this.derivedAddress));
+        console.log("  " +
+            c("gray", "Autenticato:") +
+            " " +
+            (this.isAuthenticated ? c("green", "✅ Sì") : c("red", "❌ No")));
+        console.log("");
+    }
+    showHeader() {
+        console.log("");
+        console.log(c("bold", c("cyan", "═══════════════════════════════════════════════════════")));
+        console.log(c("bold", c("cyan", "       🗡️  SHOGUN CHAT - Decentralized E2E Messaging")));
+        console.log(c("bold", c("cyan", "═══════════════════════════════════════════════════════")));
+        console.log("");
+        console.log(c("gray", "  Powered by Shogun Core + GunDB"));
+        console.log(c("gray", "  Zero-cost encrypted messaging over P2P network"));
+        console.log("");
+    }
+    updatePrompt() {
+        let prompt = "";
+        if (this.recipient) {
+            prompt =
+                c("green", `[${this.currentUser}]`) +
+                    c("white", " → ") +
+                    c("yellow", this.recipient) +
+                    c("green", " ➤ ");
+        }
+        else if (this.currentUser) {
+            prompt = c("green", `[${this.currentUser}]`) + c("green", " ➤ ");
+        }
+        else {
+            prompt = c("gray", "➤ ");
+        }
+        this.rl.setPrompt(prompt);
+    }
+    // ========================================================================
+    // START
+    // ========================================================================
+    async start() {
+        this.showHeader();
+        const args = process.argv.slice(2);
+        if (args.length >= 2) {
+            // Auto-login
+            const [username, password] = args;
+            const success = await this.login(username, password);
+            if (success) {
+                this.updatePrompt();
+                this.rl.prompt();
+            }
+            else {
+                console.log(c("red", "❌ Auto-login fallito"));
+                this.rl.close();
+            }
+        }
+        else {
+            // Login manuale
+            console.log(c("cyan", "💡 Comandi disponibili:"));
+            console.log(c("yellow", "   /login <username> <password>") +
+                c("gray", " - Login o crea account"));
+            console.log(c("yellow", "   /help") +
+                c("gray", "                       - Mostra tutti i comandi"));
+            console.log("");
+            console.log(c("gray", "   Oppure avvia con: yarn chat <username> <password>"));
+            console.log("");
+            this.updatePrompt();
+            this.rl.prompt();
+        }
+    }
+}
+exports.MessengerCLI = MessengerCLI;
+// ============================================================================
+// MAIN
+// ============================================================================
+const cli = new MessengerCLI();
+cli.start().catch(console.error);
+
+
+/***/ }),
+
+/***/ "./ship/implementation/SHIP_01.ts":
+/*!****************************************!*\
+  !*** ./ship/implementation/SHIP_01.ts ***!
+  \****************************************/
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* module decorator */ module = __webpack_require__.nmd(module);
+
+/**
+ * Esempio Pratico: Messaggistica Decentralizzata con Shogun Core
+ *
+ * Questo esempio mostra come creare un sistema di messaggistica sicuro usando:
+ * - Shogun Core per autenticazione (username/password)
+ * - GunDB per storage decentralizzato P2P
+ * - SEA (Security, Encryption, Authorization) per crittografia
+ *
+ * Vantaggi:
+ * ✅ Completamente decentralizzato (no server centrale)
+ * ✅ Zero costi (no blockchain, no gas fees)
+ * ✅ Real-time messaging
+ * ✅ Offline-first
+ * ✅ End-to-end encryption
+ *
+ * Note sull'ERC7627:
+ * L'EIP era un template concettuale. Questo esempio implementa
+ * solo la parte GunDB/Shogun Core senza interazione blockchain.
+ * La funzione deriveEthereumAddress() rimane come utility per derivare
+ * un address Ethereum dalla chiave GunDB se necessario in futuro.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SHIP_01 = void 0;
+const core_1 = __webpack_require__(/*! ../../src/core */ "./src/core.ts");
+const ethers_1 = __webpack_require__(/*! ethers */ "./node_modules/ethers/lib.commonjs/index.js");
+const derive_1 = __importDefault(__webpack_require__(/*! ../../src/gundb/derive */ "./src/gundb/derive.ts"));
+// ============================================================================
+// 1. SETUP: Inizializzazione del Sistema Completo
+// ============================================================================
+/**
+ * Classe per messaggistica sicura con Shogun Core
+ * Implementa l'interfaccia ISHIP_01
+ * Usa solo GunDB per storage decentralizzato (no blockchain)
+ */
+class SHIP_01 {
+    constructor(shogunConfig) {
+        // Inizializza Shogun Core
+        this.shogun = new core_1.ShogunCore(shogunConfig);
+    }
+    // ========================================================================
+    // 2. AUTENTICAZIONE: Username e Password
+    // ========================================================================
+    /**
+     * Registra un nuovo utente
+     */
+    async signup(username, password) {
+        try {
+            // Registra con Shogun Core (crea SEA pair automaticamente)
+            const signupResult = await this.shogun.signUp(username, password);
+            if (!signupResult.success) {
+                return {
+                    success: false,
+                    error: signupResult.error || "Signup failed"
+                };
+            }
+            console.log("✅ Utente registrato");
+            console.log(`   Username: ${username}`);
+            console.log(`   GunDB Public Key: ${signupResult.pub}`);
+            // Opzionale: deriva address Ethereum dalla chiave GunDB
+            const derivedAddress = signupResult.pub
+                ? await this.deriveEthereumAddress(signupResult.pub)
+                : undefined;
+            if (derivedAddress) {
+                console.log(`   Derived Address: ${derivedAddress}`);
+            }
+            return {
+                success: true,
+                userPub: signupResult.pub,
+                derivedAddress
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Login con username e password
+     */
+    async login(username, password) {
+        try {
+            // Login con Shogun Core
+            const loginResult = await this.shogun.login(username, password);
+            if (!loginResult.success) {
+                return {
+                    success: false,
+                    error: loginResult.error || "Login failed"
+                };
+            }
+            console.log("✅ Login effettuato");
+            console.log(`   Username: ${username}`);
+            console.log(`   GunDB Public Key: ${loginResult.userPub}`);
+            // Opzionale: deriva address Ethereum dalla chiave GunDB
+            const derivedAddress = loginResult.userPub
+                ? await this.deriveEthereumAddress(loginResult.userPub)
+                : undefined;
+            if (derivedAddress) {
+                console.log(`   Derived Address: ${derivedAddress}`);
+            }
+            return {
+                success: true,
+                userPub: loginResult.userPub,
+                derivedAddress
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Login con SEA Key Pair
+     *
+     * Autenticazione diretta usando un key pair esportato.
+     * Utile per:
+     * - Recupero account senza password
+     * - Portabilità tra dispositivi
+     * - Backup dell'identità
+     */
+    async loginWithPair(seaPair) {
+        try {
+            console.log("🔐 Login con key pair...");
+            // Autentica con GunDB usando il pair
+            const authResult = await new Promise((resolve) => {
+                this.shogun.db.gun.user().auth(seaPair, (ack) => {
+                    if (ack.err) {
+                        resolve({
+                            success: false,
+                            error: ack.err,
+                        });
+                    }
+                    else {
+                        resolve({
+                            success: true,
+                            userPub: seaPair.pub,
+                        });
+                    }
+                });
+            });
+            if (!authResult.success) {
+                console.log("❌ Login fallito:", authResult.error);
+                return authResult;
+            }
+            // Opzionale: deriva address Ethereum dalla chiave GunDB
+            const derivedAddress = await this.deriveEthereumAddress(seaPair.pub);
+            console.log("✅ Login effettuato");
+            console.log(`   GunDB Public Key: ${seaPair.pub}`);
+            console.log(`   Derived Address: ${derivedAddress}`);
+            return {
+                success: true,
+                userPub: authResult.userPub,
+                derivedAddress
+            };
+        }
+        catch (error) {
+            console.error("❌ Errore login con pair:", error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+        }
+    }
+    /**
+     * Logout
+     */
+    logout() {
+        this.shogun.logout();
+        console.log("👋 Logout effettuato");
+    }
+    /**
+     * Verifica se l'utente è autenticato
+     */
+    isLoggedIn() {
+        return this.shogun.isLoggedIn();
+    }
+    // ========================================================================
+    // 3. GESTIONE CHIAVI PUBBLICHE: Salva su GunDB
+    // ========================================================================
+    /**
+     * Salva la chiave pubblica dell'utente su GunDB
+     * Questo permette ad altri di trovare la tua chiave per criptare messaggi
+     */
+    async publishPublicKey() {
+        try {
+            if (!this.isLoggedIn()) {
+                return { success: false, error: "Not logged in" };
+            }
+            // Ottieni il SEA pair dell'utente corrente
+            const currentUser = this.shogun.db.user;
+            if (!currentUser || !currentUser.is) {
+                return { success: false, error: "No user session" };
+            }
+            // Salva chiave pubblica sul nodo globale usando il userPub come chiave
+            // Questo permette ad altri di trovarla facilmente
+            const userPub = currentUser.is.pub;
+            await this.shogun.db.gun.get(userPub).put({
+                pub: currentUser.is.pub,
+                epub: currentUser.is.epub,
+                algorithm: "ECDSA",
+                timestamp: Date.now().toString()
+            }).then();
+            console.log(`📝 Chiave pubblica pubblicata su GunDB`);
+            return { success: true };
+        }
+        catch (error) {
+            console.error("❌ Errore pubblicazione chiave:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    // ========================================================================
+    // 4. INVIO MESSAGGI: Solo GunDB
+    // ========================================================================
+    /**
+     * Invia un messaggio crittografato a un altro utente
+     */
+    async sendMessage(recipientUsername, message) {
+        try {
+            if (!this.isLoggedIn()) {
+                return { success: false, error: "Not logged in" };
+            }
+            const currentUser = this.shogun.db.user;
+            if (!currentUser || !currentUser.is) {
+                return { success: false, error: "No user session" };
+            }
+            // 1. Ottieni la chiave pubblica del destinatario
+            const recipientKey = await this.getRecipientPublicKey(recipientUsername);
+            if (!recipientKey) {
+                return {
+                    success: false,
+                    error: `Recipient ${recipientUsername} has not published their public key`
+                };
+            }
+            // 2. Ottieni il SEA pair completo (include chiavi private)
+            const senderPair = this.shogun.db.gun.user()?._?.sea;
+            if (!senderPair) {
+                return { success: false, error: "Cannot access SEA pair" };
+            }
+            // 3. Cripta il messaggio usando SEA.secret + SEA.encrypt (ECDH)
+            const encryptedMessage = await this.shogun.db.crypto.encFor(message, senderPair, // sender pair completo
+            { epub: recipientKey.epub } // recipient public encryption key
+            );
+            // 4. Genera ID messaggio
+            const messageId = this.generateMessageId();
+            const senderPub = currentUser.is.pub;
+            // 5. Salva messaggio crittografato su GunDB
+            const messageData = {
+                from: senderPub,
+                to: recipientUsername,
+                content: encryptedMessage, // Contenuto crittografato!
+                timestamp: Date.now().toString(),
+                messageId: messageId
+            };
+            // Salva sul nodo globale 'messages' per permettere il listener
+            await this.shogun.db.gun.get('messages').get(messageId).put(messageData).then();
+            console.log(`✅ Messaggio salvato: ${messageId}`);
+            return {
+                success: true,
+                messageId: messageId
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Ottiene la chiave pubblica di un utente da GunDB
+     */
+    async getRecipientPublicKey(username) {
+        try {
+            // Prima trova l'utente dal username
+            const userData = await this.shogun.db.getUserByAlias(username);
+            if (!userData || !userData.userPub) {
+                console.error(`❌ User ${username} not found`);
+                return null;
+            }
+            const userPub = userData.userPub;
+            // Le chiavi sono salvate direttamente sul nodo userPub
+            const publicKeyData = await this.shogun.db.gun.get(userPub).then();
+            if (publicKeyData && publicKeyData.epub && publicKeyData.pub) {
+                return {
+                    pub: publicKeyData.pub,
+                    epub: publicKeyData.epub
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.error("❌ Errore recupero chiave pubblica:", error);
+            return null;
+        }
+    }
+    // ========================================================================
+    // 5. RICEZIONE MESSAGGI: Ascolta GunDB in real-time
+    // ========================================================================
+    /**
+     * Ascolta messaggi crittografati in arrivo su GunDB
+     */
+    async listenForMessages(onMessage) {
+        if (!this.isLoggedIn()) {
+            console.error("❌ Non autenticato");
+            return;
+        }
+        const currentUser = this.shogun.db.user;
+        if (!currentUser || !currentUser.is) {
+            console.error("❌ Nessuna sessione utente");
+            return;
+        }
+        const userPub = currentUser.is.pub;
+        // Ottieni username dell'utente corrente
+        const username = currentUser.is.alias;
+        // Set per tracciare messaggi già ricevuti (evita duplicati)
+        const receivedMessages = new Set();
+        // Ascolta messaggi in tempo reale su GunDB
+        this.shogun.db.gun
+            .get(`messages`)
+            .map()
+            .on(async (data, key) => {
+            // Filtra solo i messaggi destinati a questo utente (per username)
+            if (data && data.to === username && data.from && data.content && data.messageId) {
+                // Evita duplicati (GunDB può emettere più volte)
+                if (receivedMessages.has(data.messageId)) {
+                    return;
+                }
+                receivedMessages.add(data.messageId);
+                try {
+                    // Decripta il messaggio
+                    const decryptedContent = await this.decryptMessage(data.content, data.from);
+                    onMessage({
+                        from: data.from,
+                        content: decryptedContent,
+                        timestamp: parseInt(data.timestamp)
+                    });
+                }
+                catch (error) {
+                    console.error("❌ Errore decrittazione messaggio:", error);
+                }
+            }
+        });
+        console.log(`👂 In ascolto di messaggi per ${username} (${userPub.substring(0, 10)}...)`);
+    }
+    /**
+     * Decripta un messaggio usando SEA.secret + SEA.decrypt (ECDH)
+     */
+    async decryptMessage(encryptedContent, senderPub) {
+        // Ottieni il SEA pair completo del destinatario (noi)
+        const receiverPair = this.shogun.db.gun.user()?._?.sea;
+        if (!receiverPair) {
+            throw new Error("Cannot access SEA pair");
+        }
+        // Ottieni epub del mittente
+        const senderKey = await this.getPublicKeyByPub(senderPub);
+        if (!senderKey) {
+            throw new Error("Sender public key not found");
+        }
+        // Decripta usando SEA.secret + SEA.decrypt (ECDH)
+        const decrypted = await this.shogun.db.crypto.decFrom(encryptedContent, { epub: senderKey.epub }, // sender's public encryption key
+        receiverPair // receiver's pair completo
+        );
+        return decrypted;
+    }
+    /**
+     * Ottiene la chiave pubblica di un utente dalla sua pub key
+     */
+    async getPublicKeyByPub(userPub) {
+        try {
+            // Le chiavi sono salvate direttamente sul nodo userPub
+            const publicKeyData = await this.shogun.db.gun.get(userPub).then();
+            if (publicKeyData && publicKeyData.epub && publicKeyData.pub) {
+                return {
+                    pub: publicKeyData.pub,
+                    epub: publicKeyData.epub
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.error("❌ Errore recupero chiave:", error);
+            return null;
+        }
+    }
+    // ========================================================================
+    // 6. RECUPERO STORICO: Query messaggi passati
+    // ========================================================================
+    /**
+     * Recupera lo storico dei messaggi crittografati con un utente
+     */
+    async getMessageHistory(withUsername) {
+        if (!this.isLoggedIn()) {
+            console.error("❌ Non autenticato");
+            return [];
+        }
+        const currentUser = this.shogun.db.user;
+        if (!currentUser || !currentUser.is) {
+            console.error("❌ Nessuna sessione utente");
+            return [];
+        }
+        const userPub = currentUser.is.pub;
+        const username = currentUser.is.alias;
+        const allMessages = [];
+        // Ottieni il userPub dell'altro utente
+        const otherUserData = await this.shogun.db.getUserByAlias(withUsername);
+        const otherUserPub = otherUserData?.userPub;
+        // Recupera tutti i messaggi dal nodo 'messages' e filtra
+        const allMessagesNode = await this.shogun.db.gun.get('messages').then();
+        if (allMessagesNode) {
+            for (const [messageId, data] of Object.entries(allMessagesNode)) {
+                if (typeof data === 'object' && data !== null) {
+                    const msgData = data;
+                    // Filtra messaggi tra questo utente e withUsername
+                    // Messaggi inviati da me a loro
+                    const isSentToTarget = msgData.from === userPub && msgData.to === withUsername;
+                    // Messaggi ricevuti da loro
+                    const isReceivedFromTarget = msgData.to === username &&
+                        (msgData.from === otherUserPub ||
+                            msgData.from);
+                    if ((isSentToTarget || isReceivedFromTarget) && msgData.content && msgData.messageId) {
+                        try {
+                            // Decripta ogni messaggio
+                            const decryptedContent = await this.decryptMessage(msgData.content, msgData.from);
+                            allMessages.push({
+                                from: msgData.from,
+                                to: msgData.to,
+                                content: decryptedContent,
+                                timestamp: parseInt(msgData.timestamp)
+                            });
+                        }
+                        catch (error) {
+                            console.error(`❌ Errore decrittazione messaggio ${messageId}:`, error);
+                            // Salta messaggi che non possono essere decriptati
+                        }
+                    }
+                }
+            }
+        }
+        // Ordina per timestamp
+        return allMessages.sort((a, b) => a.timestamp - b.timestamp);
+    }
+    // ========================================================================
+    // 7. UTILITY FUNCTIONS
+    // ========================================================================
+    /**
+     * Converte la chiave pubblica di GunDB in address Ethereum
+     * Usa la chiave privata SEA come seed per derivazione deterministica
+     *
+     * Questo garantisce che:
+     * - Stesso SEA pair → stesso address Ethereum
+     * - Derivazione cryptografica sicura
+     * - Identità unificata tra GunDB e blockchain
+     */
+    async deriveEthereumAddress(publicKey) {
+        try {
+            // Ottieni il SEA pair completo
+            const seaPair = this.shogun.db.gun.user()?._?.sea;
+            if (!seaPair || !seaPair.priv) {
+                throw new Error("Cannot access SEA pair");
+            }
+            // Usa la chiave privata SEA come seed per derive
+            // Questo è MOLTO più sicuro e deterministico del username!
+            const derived = await (0, derive_1.default)(seaPair.priv, null, {
+                includeSecp256k1Ethereum: true,
+                includeP256: false,
+                includeSecp256k1Bitcoin: false
+            });
+            return derived.secp256k1Ethereum.address;
+        }
+        catch (error) {
+            console.error("❌ Errore derivazione address:", error);
+            // Fallback: hash della chiave pubblica
+            const fallbackKey = publicKey || "unknown";
+            const hash = ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(fallbackKey));
+            return ethers_1.ethers.getAddress('0x' + hash.slice(-40));
+        }
+    }
+    /**
+     * Genera ID messaggio univoco
+     */
+    generateMessageId() {
+        return ethers_1.ethers.hexlify(ethers_1.ethers.randomBytes(16));
+    }
+}
+exports.SHIP_01 = SHIP_01;
+// ============================================================================
+// 8. ESEMPIO D'USO COMPLETO
+// ============================================================================
+// async function main() {
+//     console.log("🚀 Secure Messaging App - Shogun Core + GunDB\n");
+//     // 1. Inizializza il sistema
+//     const app = new SHIP_01({
+//         gunOptions: {
+//             peers: ["https://relay.shogun-eco.xyz/gun","https://v5g5jseqhgkp43lppgregcfbvi.srv.us/gun","https://peer.wallie.io/gun"],
+//             radisk: false,
+//             localStorage:false,
+//         }
+//     });
+//     // 2. Signup (prima volta)
+//     console.log("📝 Registrazione nuovo utente...");
+//     const signupResult = await app.signup("alice", "password123");
+//     if (!signupResult.success) {
+//         console.log("ℹ️  Utente già esistente, procedo con login");
+//     } else {
+//         console.log("✅ Utente registrato!");
+//         console.log(`   Username: alice`);
+//         console.log(`   Public Key: ${signupResult.userPub}`);
+//         console.log(`   Derived Address: ${signupResult.derivedAddress}\n`);
+//     }
+//     // 3. Login
+//     console.log("🔐 Login...");
+//     const loginResult = await app.login("alice", "password123");
+//     if (!loginResult.success) {
+//         console.error("❌ Login fallito:", loginResult.error);
+//         return;
+//     }
+//     console.log("✅ Login effettuato!");
+//     console.log(`   - Autenticazione: Shogun Core (Username/Password)`);
+//     console.log(`   - Storage: GunDB decentralizzato P2P\n`);
+//     // 4. Pubblica chiave pubblica
+//     console.log("📢 Pubblicazione chiave pubblica...");
+//     await app.publishPublicKey();
+//     // 5. Ascolta messaggi in arrivo
+//     console.log("\n👂 In ascolto di messaggi...\n");
+//     await app.listenForMessages((message) => {
+//         console.log(`📨 Nuovo messaggio da ${message.from.substring(0, 10)}...:`);
+//         console.log(`   Contenuto: ${message.content}`);
+//         console.log(`   Timestamp: ${new Date(message.timestamp).toLocaleString()}\n`);
+//     });
+//     // 6. Invia un messaggio
+//     const recipientUsername = "bob";
+//     console.log(`📤 Invio messaggio a ${recipientUsername}...`);
+//     const result = await app.sendMessage(
+//         recipientUsername,
+//         "Hello Bob! This is a secure message using Shogun Core"
+//     );
+//     if (result.success) {
+//         console.log("✅ Messaggio inviato!");
+//         console.log(`   Message ID: ${result.messageId}`);
+//         console.log(`   Storage: GunDB P2P (gratis!)`);
+//     }
+//     // 7. Recupera storico conversazione
+//     console.log("\n📚 Recupero storico messaggi...");
+//     const history = await app.getMessageHistory(recipientUsername);
+//     console.log(`\n💬 Conversazione con ${recipientUsername} (${history.length} messaggi):`);
+//     history.forEach((msg, i) => {
+//         const isMe = msg.from === loginResult.userPub;
+//         console.log(`${i + 1}. ${isMe ? 'Tu' : 'Loro'}: ${msg.content}`);
+//     });
+// }
+// ============================================================================
+// 9. VANTAGGI DELL'ARCHITETTURA
+// ============================================================================
+/**
+ * VANTAGGI DI QUESTA ARCHITETTURA:
+ *
+ * 1. SEMPLICITÀ:
+ *    - Solo username/password (nessun wallet necessario)
+ *    - Nessun gas fee o transazioni blockchain
+ *    - Setup in pochi secondi
+ *
+ * 2. DECENTRALIZZAZIONE COMPLETA:
+ *    - Storage P2P su GunDB
+ *    - Nessun server centrale
+ *    - Censorship resistant
+ *    - User sovereignty
+ *
+ * 3. COSTI ZERO:
+ *    - Nessun costo per messaggi
+ *    - Nessun costo per storage
+ *    - Completamente gratis
+ *
+ * 4. END-TO-END ENCRYPTION:
+ *    - Messaggi crittografati con ECDH (Elliptic Curve Diffie-Hellman)
+ *    - SEA.secret deriva shared secret da epub (encryption public key)
+ *    - SEA.encrypt cripta con AES-GCM
+ *    - Solo mittente e destinatario possono leggere i messaggi
+ *    - Nessun server o relay può leggere il contenuto
+ *
+ * 5. IDENTITÀ DECENTRALIZZATA:
+ *    - Chiave pubblica GunDB come identità
+ *    - Può essere derivata in address Ethereum se necessario
+ *    - Portabile tra diverse applicazioni
+ *
+ * 6. REAL-TIME:
+ *    - Messaggi in tempo reale
+ *    - Sincronizzazione automatica
+ *    - Listener reattivi
+ *
+ * 7. OFFLINE-FIRST:
+ *    - Funziona anche offline
+ *    - Sincronizzazione automatica al riconnect
+ *    - GunDB gestisce conflitti automaticamente
+ *
+ * COME FUNZIONA LA CRITTOGRAFIA:
+ *
+ * 1. SETUP - Ogni utente ha un SEA pair:
+ *    - pub: chiave pubblica di signing
+ *    - priv: chiave privata di signing
+ *    - epub: chiave pubblica di encryption (per ECDH)
+ *    - epriv: chiave privata di encryption (per ECDH)
+ *
+ * 2. PUBBLICAZIONE CHIAVI:
+ *    - Ogni utente pubblica il suo epub su GunDB
+ *    - Altri possono trovarlo per criptare messaggi
+ *
+ * 3. INVIO MESSAGGIO (Alice → Bob):
+ *    a) Alice ottiene l'epub di Bob da GunDB
+ *    b) SEA.secret(bob.epub, alice.pair) → shared_secret (ECDH)
+ *    c) SEA.encrypt(message, shared_secret) → encrypted_message
+ *    d) Alice salva encrypted_message su GunDB
+ *
+ * 4. RICEZIONE MESSAGGIO (Bob riceve):
+ *    a) Bob legge encrypted_message da GunDB
+ *    b) Bob ottiene l'epub di Alice
+ *    c) SEA.secret(alice.epub, bob.pair) → shared_secret (stesso!)
+ *    d) SEA.decrypt(encrypted_message, shared_secret) → message
+ *
+ * 5. SICUREZZA:
+ *    - Shared secret derivato con ECDH (mai trasmesso)
+ *    - Solo Alice e Bob possono derivare lo stesso secret
+ *    - Messaggi crittografati con AES-256-GCM
+ *    - Forward secrecy se chiavi sono ruotate
+ *
+ * Esempio tecnico:
+ * Alice.epub + Bob.epriv → shared_secret_AB
+ * Bob.epub + Alice.epriv → shared_secret_AB (stesso!)
+ *
+ * Vantaggi:
+ * ✅ End-to-end encryption
+ * ✅ Perfect forward secrecy (con key rotation)
+ * ✅ Nessun server può leggere i messaggi
+ * ✅ Standard crittografico (ECDH + AES-GCM)
+ * ✅ Una sola chiave privata da gestire
+ * ✅ Address Ethereum derivabile (interoperabilità)
+ */
+// ============================================================================
+// 10. TEST COMPLETO: Alice e Bob si scambiano messaggi
+// ============================================================================
+/**
+ * Test completo che simula Alice e Bob che si scambiano messaggi CRITTOGRAFATI
+ *
+ * CRITTOGRAFIA END-TO-END:
+ * - Ogni messaggio è crittografato con ECDH (Elliptic Curve Diffie-Hellman)
+ * - Solo mittente e destinatario possono leggere i messaggi
+ * - I relay GunDB vedono solo dati crittografati
+ *
+ * FLOW:
+ * 1. Alice e Bob pubblicano le loro chiavi pubbliche (epub)
+ * 2. Alice vuole inviare a Bob:
+ *    - Ottiene bob.epub da GunDB
+ *    - SEA.secret(bob.epub, alice.pair) → shared_secret
+ *    - SEA.encrypt(message, shared_secret) → encrypted
+ *    - Salva encrypted su GunDB
+ * 3. Bob riceve:
+ *    - Legge encrypted da GunDB
+ *    - Ottiene alice.epub
+ *    - SEA.secret(alice.epub, bob.pair) → shared_secret (stesso!)
+ *    - SEA.decrypt(encrypted, shared_secret) → message
+ */
+async function testAliceAndBob() {
+    console.log("🧪 TEST: Alice e Bob - Conversazione Crittografata E2E\n");
+    console.log("=".repeat(60));
+    // Setup Alice
+    console.log("\n👩 ALICE - Setup");
+    console.log("-".repeat(60));
+    const alice = new SHIP_01({
+        gunOptions: {
+            peers: ["https://peer.wallie.io/gun"],
+            radisk: true,
+        },
+    });
+    // Alice signup/login
+    await alice.signup("alice", "password123");
+    const aliceLogin = await alice.login("alice", "password123");
+    if (!aliceLogin.success) {
+        console.error("❌ Alice login failed");
+        return;
+    }
+    await alice.publishPublicKey();
+    // Aspetta che la chiave sia sincronizzata
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    // Setup Bob
+    console.log("\n👨 BOB - Setup");
+    console.log("-".repeat(60));
+    const bob = new SHIP_01({
+        gunOptions: {
+            peers: ["https://peer.wallie.io/gun"],
+            radisk: true
+        },
+    });
+    // Bob signup/login
+    await bob.signup("bob", "password456");
+    const bobLogin = await bob.login("bob", "password456");
+    if (!bobLogin.success) {
+        console.error("❌ Bob login failed");
+        return;
+    }
+    await bob.publishPublicKey();
+    // Aspetta che la chiave sia sincronizzata
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    console.log("\n" + "=".repeat(60));
+    console.log("💬 CONVERSAZIONE");
+    console.log("=".repeat(60));
+    // Alice e Bob ascoltano messaggi
+    let aliceMessages = [];
+    let bobMessages = [];
+    await alice.listenForMessages((msg) => {
+        aliceMessages.push(msg);
+        console.log(`\n[Alice riceve] 📨`);
+        console.log(`   Da: ${msg.from.substring(0, 10)}...`);
+        console.log(`   Messaggio: "${msg.content}"`);
+        console.log(`   Timestamp: ${new Date(msg.timestamp).toLocaleTimeString()}`);
+    });
+    await bob.listenForMessages((msg) => {
+        bobMessages.push(msg);
+        console.log(`\n[Bob riceve] 📨`);
+        console.log(`   Da: ${msg.from.substring(0, 10)}...`);
+        console.log(`   Messaggio: "${msg.content}"`);
+        console.log(`   Timestamp: ${new Date(msg.timestamp).toLocaleTimeString()}`);
+    });
+    // Aspetta che i listener siano pronti
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    // Alice invia messaggio a Bob
+    console.log("\n[Alice invia] 📤");
+    const msg1 = await alice.sendMessage("bob", "Ciao Bob! Come stai? 👋");
+    console.log(`   ✅ Inviato: "${msg1.messageId}"`);
+    // Aspetta che Bob riceva
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    // Bob risponde ad Alice
+    console.log("\n[Bob invia] 📤");
+    const msg2 = await bob.sendMessage("alice", "Ciao Alice! Tutto bene, grazie! Tu? 😊");
+    console.log(`   ✅ Inviato: "${msg2.messageId}"`);
+    // Aspetta che Alice riceva
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    // Alice risponde
+    console.log("\n[Alice invia] 📤");
+    const msg3 = await alice.sendMessage("bob", "Anch'io benissimo! Questo sistema di messaggistica è fantastico! 🚀");
+    console.log(`   ✅ Inviato: "${msg3.messageId}"`);
+    // Aspetta che Bob riceva
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    // Bob conclude
+    console.log("\n[Bob invia] 📤");
+    const msg4 = await bob.sendMessage("alice", "Vero! Zero costi, decentralizzato e veloce! 💪");
+    console.log(`   ✅ Inviato: "${msg4.messageId}"`);
+    // Aspetta finale
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    // Mostra statistiche
+    console.log("\n" + "=".repeat(60));
+    console.log("📊 STATISTICHE FINALI");
+    console.log("=".repeat(60));
+    console.log(`\n👩 Alice:`);
+    console.log(`   - Messaggi inviati: 2`);
+    console.log(`   - Messaggi ricevuti: ${aliceMessages.length}`);
+    console.log(`   - Public Key: ${aliceLogin.userPub?.substring(0, 20)}...`);
+    console.log(`   - Derived Address: ${aliceLogin.derivedAddress}`);
+    console.log(`\n👨 Bob:`);
+    console.log(`   - Messaggi inviati: 2`);
+    console.log(`   - Messaggi ricevuti: ${bobMessages.length}`);
+    console.log(`   - Public Key: ${bobLogin.userPub?.substring(0, 20)}...`);
+    console.log(`   - Derived Address: ${bobLogin.derivedAddress}`);
+    // Recupera storico
+    console.log("\n" + "=".repeat(60));
+    console.log("📚 STORICO CONVERSAZIONE");
+    console.log("=".repeat(60));
+    const aliceHistory = await alice.getMessageHistory("bob");
+    console.log(`\n👩 Storico di Alice con Bob (${aliceHistory.length} messaggi):`);
+    aliceHistory.forEach((msg, i) => {
+        const sender = msg.from === aliceLogin.userPub ? "Alice" : "Bob";
+        console.log(`   ${i + 1}. [${sender}]: ${msg.content}`);
+    });
+    const bobHistory = await bob.getMessageHistory("alice");
+    console.log(`\n👨 Storico di Bob con Alice (${bobHistory.length} messaggi):`);
+    bobHistory.forEach((msg, i) => {
+        const sender = msg.from === bobLogin.userPub ? "Bob" : "Alice";
+        console.log(`   ${i + 1}. [${sender}]: ${msg.content}`);
+    });
+    // Riepilogo finale
+    console.log("\n" + "=".repeat(60));
+    console.log("✅ TEST COMPLETATO CON SUCCESSO!");
+    console.log("=".repeat(60));
+    console.log("\n📝 Riepilogo:");
+    console.log("   ✅ 2 utenti registrati (Alice, Bob)");
+    console.log("   ✅ 4 messaggi scambiati");
+    console.log("   ✅ Messaggi ricevuti in real-time");
+    console.log("   ✅ Storico recuperato correttamente");
+    console.log("   ✅ Storage: GunDB P2P (gratis!)");
+    console.log("   ✅ Costi: $0.00");
+    console.log("\n🎉 Sistema di messaggistica decentralizzato funzionante!\n");
+}
+// Esegui esempio o test
+if (__webpack_require__.c[__webpack_require__.s] === module) {
+    // Scegli quale eseguire decommentando una delle due righe:
+    // main().catch(console.error);  // Esempio singolo utente
+    testAliceAndBob().catch(console.error); // Test completo Alice & Bob
+}
+
+
 /***/ }),
 
 /***/ "./src/config/simplified-config.ts":
@@ -101230,8 +102687,8 @@ class DataBase {
                 username: username,
                 userPub: userPub,
                 epub: epub,
-                registeredAt: Date.now(),
-                lastSeen: Date.now(),
+                registeredAt: Date.now().toString(),
+                lastSeen: Date.now().toString(),
             };
             const ack = await this.node
                 .get("users")
@@ -102820,7 +104277,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.autoQuickStart = exports.AutoQuickStart = exports.createSimpleAPI = exports.quickStart = exports.QuickStart = exports.SimpleGunAPI = exports.DataBase = exports.GunErrors = exports.derive = exports.crypto = exports.RxJS = exports.SEA = exports.ShogunCore = exports.Gun = void 0;
+exports.autoQuickStart = exports.AutoQuickStart = exports.createSimpleAPI = exports.quickStart = exports.QuickStart = exports.SimpleGunAPI = exports.DataBase = exports.GunErrors = exports.derive = exports.crypto = exports.RxJS = exports.SEA = exports.ShogunCore = exports.Gun = exports.MessengerCLI = exports.SHIP_01 = void 0;
 const core_1 = __webpack_require__(/*! ./core */ "./src/core.ts");
 Object.defineProperty(exports, "ShogunCore", ({ enumerable: true, get: function () { return core_1.ShogunCore; } }));
 const db_1 = __webpack_require__(/*! ./gundb/db */ "./src/gundb/db.ts");
@@ -102844,8 +104301,13 @@ exports.Gun = db_3.default;
 __exportStar(__webpack_require__(/*! ./utils/errorHandler */ "./src/utils/errorHandler.ts"), exports);
 __exportStar(__webpack_require__(/*! ./plugins */ "./src/plugins/index.ts"), exports);
 __exportStar(__webpack_require__(/*! ./interfaces/shogun */ "./src/interfaces/shogun.ts"), exports);
-// Export simplified configuration
 __exportStar(__webpack_require__(/*! ./config/simplified-config */ "./src/config/simplified-config.ts"), exports);
+var SHIP_01_1 = __webpack_require__(/*! ../ship/implementation/SHIP_01 */ "./ship/implementation/SHIP_01.ts");
+Object.defineProperty(exports, "SHIP_01", ({ enumerable: true, get: function () { return SHIP_01_1.SHIP_01; } }));
+// Export MessengerCLI only in Node.js environment (not browser)
+// This prevents "readline is not a function" errors in browser builds
+var messenger_cli_1 = __webpack_require__(/*! ../ship/examples/messenger-cli */ "./ship/examples/messenger-cli.ts");
+Object.defineProperty(exports, "MessengerCLI", ({ enumerable: true, get: function () { return messenger_cli_1.MessengerCLI; } }));
 
 
 /***/ }),
@@ -109640,7 +111102,43 @@ function generateDeterministicPassword(salt) {
 /******/ 		return module.exports;
 /******/ 	}
 /******/ 	
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = __webpack_modules__;
+/******/ 	
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = __webpack_module_cache__;
+/******/ 	
 /************************************************************************/
+/******/ 	/* webpack/runtime/create fake namespace object */
+/******/ 	(() => {
+/******/ 		var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);
+/******/ 		var leafPrototypes;
+/******/ 		// create a fake namespace object
+/******/ 		// mode & 1: value is a module id, require it
+/******/ 		// mode & 2: merge all properties of value into the ns
+/******/ 		// mode & 4: return value when already ns object
+/******/ 		// mode & 16: return value when it's Promise-like
+/******/ 		// mode & 8|1: behave like require
+/******/ 		__webpack_require__.t = function(value, mode) {
+/******/ 			if(mode & 1) value = this(value);
+/******/ 			if(mode & 8) return value;
+/******/ 			if(typeof value === 'object' && value) {
+/******/ 				if((mode & 4) && value.__esModule) return value;
+/******/ 				if((mode & 16) && typeof value.then === 'function') return value;
+/******/ 			}
+/******/ 			var ns = Object.create(null);
+/******/ 			__webpack_require__.r(ns);
+/******/ 			var def = {};
+/******/ 			leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
+/******/ 			for(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {
+/******/ 				Object.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));
+/******/ 			}
+/******/ 			def['default'] = () => (value);
+/******/ 			__webpack_require__.d(ns, def);
+/******/ 			return ns;
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/define property getters */
 /******/ 	(() => {
 /******/ 		// define getter functions for harmony exports
@@ -109653,6 +111151,28 @@ function generateDeterministicPassword(salt) {
 /******/ 		};
 /******/ 	})();
 /******/ 	
+/******/ 	/* webpack/runtime/ensure chunk */
+/******/ 	(() => {
+/******/ 		__webpack_require__.f = {};
+/******/ 		// This file contains only the entry chunk.
+/******/ 		// The chunk loading function for additional chunks
+/******/ 		__webpack_require__.e = (chunkId) => {
+/******/ 			return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
+/******/ 				__webpack_require__.f[key](chunkId, promises);
+/******/ 				return promises;
+/******/ 			}, []));
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/get javascript chunk filename */
+/******/ 	(() => {
+/******/ 		// This function allow to reference async chunks
+/******/ 		__webpack_require__.u = (chunkId) => {
+/******/ 			// return url for filenames based on template
+/******/ 			return "" + chunkId + ".shogun-core.js";
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/global */
 /******/ 	(() => {
 /******/ 		__webpack_require__.g = (function() {
@@ -109670,6 +111190,52 @@ function generateDeterministicPassword(salt) {
 /******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 /******/ 	})();
 /******/ 	
+/******/ 	/* webpack/runtime/load script */
+/******/ 	(() => {
+/******/ 		var inProgress = {};
+/******/ 		var dataWebpackPrefix = "ShogunCore:";
+/******/ 		// loadScript function to load a script via script tag
+/******/ 		__webpack_require__.l = (url, done, key, chunkId) => {
+/******/ 			if(inProgress[url]) { inProgress[url].push(done); return; }
+/******/ 			var script, needAttach;
+/******/ 			if(key !== undefined) {
+/******/ 				var scripts = document.getElementsByTagName("script");
+/******/ 				for(var i = 0; i < scripts.length; i++) {
+/******/ 					var s = scripts[i];
+/******/ 					if(s.getAttribute("src") == url || s.getAttribute("data-webpack") == dataWebpackPrefix + key) { script = s; break; }
+/******/ 				}
+/******/ 			}
+/******/ 			if(!script) {
+/******/ 				needAttach = true;
+/******/ 				script = document.createElement('script');
+/******/ 		
+/******/ 				script.charset = 'utf-8';
+/******/ 				script.timeout = 120;
+/******/ 				if (__webpack_require__.nc) {
+/******/ 					script.setAttribute("nonce", __webpack_require__.nc);
+/******/ 				}
+/******/ 				script.setAttribute("data-webpack", dataWebpackPrefix + key);
+/******/ 		
+/******/ 				script.src = url;
+/******/ 			}
+/******/ 			inProgress[url] = [done];
+/******/ 			var onScriptComplete = (prev, event) => {
+/******/ 				// avoid mem leaks in IE.
+/******/ 				script.onerror = script.onload = null;
+/******/ 				clearTimeout(timeout);
+/******/ 				var doneFns = inProgress[url];
+/******/ 				delete inProgress[url];
+/******/ 				script.parentNode && script.parentNode.removeChild(script);
+/******/ 				doneFns && doneFns.forEach((fn) => (fn(event)));
+/******/ 				if(prev) return prev(event);
+/******/ 			}
+/******/ 			var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);
+/******/ 			script.onerror = onScriptComplete.bind(null, script.onerror);
+/******/ 			script.onload = onScriptComplete.bind(null, script.onload);
+/******/ 			needAttach && document.head.appendChild(script);
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/make namespace object */
 /******/ 	(() => {
 /******/ 		// define __esModule on exports
@@ -109690,12 +111256,125 @@ function generateDeterministicPassword(salt) {
 /******/ 		};
 /******/ 	})();
 /******/ 	
+/******/ 	/* webpack/runtime/publicPath */
+/******/ 	(() => {
+/******/ 		var scriptUrl;
+/******/ 		if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
+/******/ 		var document = __webpack_require__.g.document;
+/******/ 		if (!scriptUrl && document) {
+/******/ 			if (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT')
+/******/ 				scriptUrl = document.currentScript.src;
+/******/ 			if (!scriptUrl) {
+/******/ 				var scripts = document.getElementsByTagName("script");
+/******/ 				if(scripts.length) {
+/******/ 					var i = scripts.length - 1;
+/******/ 					while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;
+/******/ 				}
+/******/ 			}
+/******/ 		}
+/******/ 		// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration
+/******/ 		// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.
+/******/ 		if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
+/******/ 		scriptUrl = scriptUrl.replace(/^blob:/, "").replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
+/******/ 		__webpack_require__.p = scriptUrl;
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/jsonp chunk loading */
+/******/ 	(() => {
+/******/ 		// no baseURI
+/******/ 		
+/******/ 		// object to store loaded and loading chunks
+/******/ 		// undefined = chunk not loaded, null = chunk preloaded/prefetched
+/******/ 		// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
+/******/ 		var installedChunks = {
+/******/ 			"main": 0
+/******/ 		};
+/******/ 		
+/******/ 		__webpack_require__.f.j = (chunkId, promises) => {
+/******/ 				// JSONP chunk loading for javascript
+/******/ 				var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;
+/******/ 				if(installedChunkData !== 0) { // 0 means "already installed".
+/******/ 		
+/******/ 					// a Promise means "currently loading".
+/******/ 					if(installedChunkData) {
+/******/ 						promises.push(installedChunkData[2]);
+/******/ 					} else {
+/******/ 						if(true) { // all chunks have JS
+/******/ 							// setup Promise in chunk cache
+/******/ 							var promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));
+/******/ 							promises.push(installedChunkData[2] = promise);
+/******/ 		
+/******/ 							// start chunk loading
+/******/ 							var url = __webpack_require__.p + __webpack_require__.u(chunkId);
+/******/ 							// create error before stack unwound to get useful stacktrace later
+/******/ 							var error = new Error();
+/******/ 							var loadingEnded = (event) => {
+/******/ 								if(__webpack_require__.o(installedChunks, chunkId)) {
+/******/ 									installedChunkData = installedChunks[chunkId];
+/******/ 									if(installedChunkData !== 0) installedChunks[chunkId] = undefined;
+/******/ 									if(installedChunkData) {
+/******/ 										var errorType = event && (event.type === 'load' ? 'missing' : event.type);
+/******/ 										var realSrc = event && event.target && event.target.src;
+/******/ 										error.message = 'Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')';
+/******/ 										error.name = 'ChunkLoadError';
+/******/ 										error.type = errorType;
+/******/ 										error.request = realSrc;
+/******/ 										installedChunkData[1](error);
+/******/ 									}
+/******/ 								}
+/******/ 							};
+/******/ 							__webpack_require__.l(url, loadingEnded, "chunk-" + chunkId, chunkId);
+/******/ 						}
+/******/ 					}
+/******/ 				}
+/******/ 		};
+/******/ 		
+/******/ 		// no prefetching
+/******/ 		
+/******/ 		// no preloaded
+/******/ 		
+/******/ 		// no HMR
+/******/ 		
+/******/ 		// no HMR manifest
+/******/ 		
+/******/ 		// no on chunks loaded
+/******/ 		
+/******/ 		// install a JSONP callback for chunk loading
+/******/ 		var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
+/******/ 			var [chunkIds, moreModules, runtime] = data;
+/******/ 			// add "moreModules" to the modules object,
+/******/ 			// then flag all "chunkIds" as loaded and fire callback
+/******/ 			var moduleId, chunkId, i = 0;
+/******/ 			if(chunkIds.some((id) => (installedChunks[id] !== 0))) {
+/******/ 				for(moduleId in moreModules) {
+/******/ 					if(__webpack_require__.o(moreModules, moduleId)) {
+/******/ 						__webpack_require__.m[moduleId] = moreModules[moduleId];
+/******/ 					}
+/******/ 				}
+/******/ 				if(runtime) var result = runtime(__webpack_require__);
+/******/ 			}
+/******/ 			if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
+/******/ 			for(;i < chunkIds.length; i++) {
+/******/ 				chunkId = chunkIds[i];
+/******/ 				if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
+/******/ 					installedChunks[chunkId][0]();
+/******/ 				}
+/******/ 				installedChunks[chunkId] = 0;
+/******/ 			}
+/******/ 		
+/******/ 		}
+/******/ 		
+/******/ 		var chunkLoadingGlobal = this["webpackChunkShogunCore"] = this["webpackChunkShogunCore"] || [];
+/******/ 		chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
+/******/ 		chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
+/******/ 	})();
+/******/ 	
 /************************************************************************/
 /******/ 	
+/******/ 	// module cache are used so entry inlining is disabled
 /******/ 	// startup
 /******/ 	// Load entry module and return exports
-/******/ 	// This entry module is referenced by other modules so it can't be inlined
-/******/ 	var __webpack_exports__ = __webpack_require__("./src/index.ts");
+/******/ 	var __webpack_exports__ = __webpack_require__(__webpack_require__.s = "./src/index.ts");
 /******/ 	
 /******/ 	return __webpack_exports__;
 /******/ })()