shogun-core 3.2.3 → 3.3.1

package/dist/ship/implementation/SHIP_01.js

@@ -1,650 +0,0 @@
-"use strict";
-/**
- * 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 = require("../../src/core");
-const ethers_1 = require("ethers");
-const derive_1 = __importDefault(require("../../src/gundb/derive"));
-// ============================================================================
-// 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(SHIP_01.NODES.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(SHIP_01.NODES.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;
-        // Use .map() instead of .then() to iterate all messages
-        return new Promise((resolve) => {
-            const messages = [];
-            let messageCount = 0;
-            this.shogun.db.gun
-                .get(SHIP_01.NODES.MESSAGES)
-                .map()
-                .once(async (msgData, messageId) => {
-                // Skip metadata fields
-                if (!msgData || typeof msgData !== "object" || messageId === "_") {
-                    return;
-                }
-                messageCount++;
-                try {
-                    // Check if message is part of this conversation
-                    // Fixed: Handle both username and userPub in matching
-                    const isSentToTarget = msgData.from === userPub &&
-                        (msgData.to === withUsername || msgData.to === otherUserPub);
-                    const isReceivedFromTarget = (msgData.to === username || msgData.to === userPub) &&
-                        msgData.from === otherUserPub;
-                    if (isSentToTarget || isReceivedFromTarget) {
-                        // Decrypt message
-                        const decryptedContent = await this.decryptMessage(msgData.content, msgData.from);
-                        messages.push({
-                            from: msgData.from,
-                            to: msgData.to,
-                            content: decryptedContent,
-                            timestamp: parseInt(msgData.timestamp),
-                        });
-                    }
-                }
-                catch (error) {
-                    // Silent error - message couldn't be decrypted
-                }
-            });
-            // Wait a bit for GunDB to return all messages, then resolve
-            setTimeout(() => {
-                const sorted = messages.sort((a, b) => a.timestamp - b.timestamp);
-                resolve(sorted);
-            }, 2000);
-        });
-    }
-    // ========================================================================
-    // 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;
-// GunDB Node Names - Constants for clarity
-SHIP_01.NODES = {
-    MESSAGES: "messages",
-    USERS: "users",
-    PUBLIC_KEYS: "publicKeys",
-};
-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 (require.main === module) {
-    testAliceAndBob().catch(console.error); // Test completo Alice & Bob
-}