shogun-core 3.2.2 → 3.3.0

package/dist/ship/implementation/SHIP_01.js

@@ -1,446 +1,229 @@
 "use strict";
 /**
- * Esempio Pratico: Messaggistica Decentralizzata con Shogun Core
+ * SHIP-01: Decentralized Encrypted Messaging Implementation
  *
- * 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
+ * Messaggistica decentralizzata E2E che dipende da SHIP-00 per l'identità.
  *
- * Vantaggi:
- * ✅ Completamente decentralizzato (no server centrale)
- * ✅ Zero costi (no blockchain, no gas fees)
- * ✅ Real-time messaging
- * ✅ Offline-first
- * ✅ End-to-end encryption
+ * Dipendenze:
+ * - SHIP-00 (Identity & Authentication) - per gestione utenti e chiavi
+ * - GunDB - per storage decentralizzato P2P
+ * - SEA - per crittografia ECDH + AES-GCM
  *
- * 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.
+ * Vantaggi dell'architettura modulare:
+ * ✅ Separazione delle responsabilità (Identity vs Messaging)
+ * ✅ Riusabilità di SHIP-00 in altre applicazioni
+ * ✅ Testing più semplice e isolato
+ * ✅ Manutenibilità migliorata
  */
-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
+// IMPLEMENTATION
 // ============================================================================
 /**
- * Classe per messaggistica sicura con Shogun Core
- * Implementa l'interfaccia ISHIP_01
- * Usa solo GunDB per storage decentralizzato (no blockchain)
+ * SHIP-01 Reference Implementation
+ *
+ * Questa implementazione dipende da ISHIP_00 per tutte le operazioni di identità.
+ * Si concentra esclusivamente sulla logica di messaggistica.
  */
 class SHIP_01 {
-    constructor(shogunConfig) {
-        // Inizializza Shogun Core
-        this.shogun = new core_1.ShogunCore(shogunConfig);
-    }
-    // ========================================================================
-    // 2. AUTENTICAZIONE: Username e Password
-    // ========================================================================
     /**
-     * Registra un nuovo utente
+     * Constructor
+     * @param identity ISHIP_00 instance for identity operations
      */
-    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
-            };
+    constructor(identity) {
+        if (!identity.isLoggedIn()) {
+            throw new Error("User must be authenticated via SHIP-00 before using SHIP-01");
         }
+        this.identity = identity;
+        console.log("✅ SHIP-01 initialized with authenticated identity");
     }
     /**
-     * Login con username e password
+     * Get identity provider
      */
-    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();
+    getIdentity() {
+        return this.identity;
     }
     // ========================================================================
-    // 3. GESTIONE CHIAVI PUBBLICHE: Salva su GunDB
+    // MESSAGING - Send
     // ========================================================================
     /**
-     * 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
+     * Send encrypted message to a user
+     * Uses identity provider (SHIP-00) to get keys
      */
     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" };
+            // Verify authentication
+            if (!this.identity.isLoggedIn()) {
+                return { success: false, error: "Not authenticated" };
             }
-            // 1. Ottieni la chiave pubblica del destinatario
-            const recipientKey = await this.getRecipientPublicKey(recipientUsername);
+            // 1. Get recipient's public key from SHIP-00
+            const recipientKey = await this.identity.getPublicKey(recipientUsername);
             if (!recipientKey) {
                 return {
                     success: false,
-                    error: `Recipient ${recipientUsername} has not published their public key`
+                    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;
+            // 2. Get sender's key pair from SHIP-00
+            const senderPair = this.identity.getKeyPair();
             if (!senderPair) {
-                return { success: false, error: "Cannot access SEA pair" };
+                return { success: false, error: "Cannot access sender key pair" };
+            }
+            // 3. Get current user from SHIP-00
+            const currentUser = this.identity.getCurrentUser();
+            if (!currentUser) {
+                return { success: false, error: "No current user" };
+            }
+            // 4. Access GunDB through identity provider
+            const shogun = this.identity.getShogun();
+            if (!shogun || !shogun.db) {
+                return { success: false, error: "Cannot access ShogunCore" };
             }
-            // 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 gun = shogun.db.gun;
+            const crypto = shogun.db.crypto;
+            if (!gun || !crypto) {
+                return { success: false, error: "Cannot access GunDB or crypto" };
+            }
+            // 5. Encrypt message using ECDH
+            const encryptedMessage = await crypto.encFor(message, senderPair, { epub: recipientKey.epub });
+            // 6. Generate message ID
             const messageId = this.generateMessageId();
-            const senderPub = currentUser.is.pub;
-            // 5. Salva messaggio crittografato su GunDB
+            // 7. Save encrypted message on GunDB
             const messageData = {
-                from: senderPub,
+                from: currentUser.pub,
                 to: recipientUsername,
-                content: encryptedMessage, // Contenuto crittografato!
+                content: encryptedMessage,
                 timestamp: Date.now().toString(),
-                messageId: messageId
+                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}`);
+            await gun
+                .get(SHIP_01.NODES.MESSAGES)
+                .get(messageId)
+                .put(messageData)
+                .then();
+            console.log(`✅ Message sent: ${messageId}`);
             return {
                 success: true,
-                messageId: messageId
+                messageId: messageId,
             };
         }
         catch (error) {
+            console.error("❌ Error sending message:", error);
             return {
                 success: false,
-                error: error.message
+                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
+    // MESSAGING - Listen
     // ========================================================================
     /**
-     * Ascolta messaggi crittografati in arrivo su GunDB
+     * Listen for incoming encrypted messages
+     * Uses identity provider (SHIP-00) to decrypt messages
      */
     async listenForMessages(onMessage) {
-        if (!this.isLoggedIn()) {
-            console.error("❌ Non autenticato");
+        if (!this.identity.isLoggedIn()) {
+            console.error("❌ Not authenticated");
+            return;
+        }
+        // Get current user from SHIP-00
+        const currentUser = this.identity.getCurrentUser();
+        if (!currentUser || !currentUser.alias) {
+            console.error("❌ No current user");
             return;
         }
-        const currentUser = this.shogun.db.user;
-        if (!currentUser || !currentUser.is) {
-            console.error("❌ Nessuna sessione utente");
+        const username = currentUser.alias;
+        // Access GunDB
+        const shogun = this.identity.getShogun();
+        const gun = shogun?.db?.gun;
+        if (!gun) {
+            console.error("❌ Cannot access GunDB");
             return;
         }
-        const userPub = currentUser.is.pub;
-        // Ottieni username dell'utente corrente
-        const username = currentUser.is.alias;
-        // Set per tracciare messaggi già ricevuti (evita duplicati)
+        // Track received messages to avoid duplicates
         const receivedMessages = new Set();
-        // Ascolta messaggi in tempo reale su GunDB
-        this.shogun.db.gun
+        // Listen for messages in real-time
+        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)
+            // Filter messages for this user
+            if (data &&
+                data.to === username &&
+                data.from &&
+                data.content &&
+                data.messageId) {
+                // Avoid duplicates
                 if (receivedMessages.has(data.messageId)) {
                     return;
                 }
                 receivedMessages.add(data.messageId);
                 try {
-                    // Decripta il messaggio
+                    // Decrypt message using SHIP-00
                     const decryptedContent = await this.decryptMessage(data.content, data.from);
                     onMessage({
                         from: data.from,
                         content: decryptedContent,
-                        timestamp: parseInt(data.timestamp)
+                        timestamp: parseInt(data.timestamp),
                     });
                 }
                 catch (error) {
-                    console.error("❌ Errore decrittazione messaggio:", error);
+                    console.error("❌ Error decrypting message:", 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;
-        }
+        console.log(`👂 Listening for messages to ${username}...`);
     }
     // ========================================================================
-    // 6. RECUPERO STORICO: Query messaggi passati
+    // MESSAGING - History
     // ========================================================================
     /**
-     * Recupera lo storico dei messaggi crittografati con un utente
+     * Get message history with a user
+     * Uses identity provider (SHIP-00) to decrypt messages
      */
     async getMessageHistory(withUsername) {
-        if (!this.isLoggedIn()) {
-            console.error("❌ Non autenticato");
+        if (!this.identity.isLoggedIn()) {
+            console.error("❌ Not authenticated");
             return [];
         }
-        const currentUser = this.shogun.db.user;
-        if (!currentUser || !currentUser.is) {
-            console.error("❌ Nessuna sessione utente");
+        // Get current user from SHIP-00
+        const currentUser = this.identity.getCurrentUser();
+        if (!currentUser || !currentUser.alias) {
+            console.error("❌ No current user");
             return [];
         }
-        const userPub = currentUser.is.pub;
-        const username = currentUser.is.alias;
-        const allMessages = [];
-        console.log(`[SHIP-01] Getting history between ${username} (${userPub.substring(0, 20)}...) and ${withUsername}`);
-        // Ottieni il userPub dell'altro utente
-        const otherUserData = await this.shogun.db.getUserByAlias(withUsername);
+        const username = currentUser.alias;
+        const userPub = currentUser.pub;
+        // Get other user's public key from SHIP-00
+        const otherUserData = await this.identity.getUserByAlias(withUsername);
         const otherUserPub = otherUserData?.userPub;
-        console.log(`[SHIP-01] Other user pub: ${otherUserPub?.substring(0, 20) || 'not found'}...`);
-        // Use .map() instead of .then() to iterate all messages
+        // Access GunDB
+        const shogun = this.identity.getShogun();
+        const gun = shogun?.db?.gun;
+        if (!gun) {
+            console.error("❌ Cannot access GunDB");
+            return [];
+        }
+        // Get all messages and filter
         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 === '_') {
+            gun
+                .get(SHIP_01.NODES.MESSAGES)
+                .map()
+                .once(async (msgData, messageId) => {
+                // Skip metadata
+                if (!msgData || typeof msgData !== "object" || messageId === "_") {
                     return;
                 }
-                messageCount++;
-                console.log(`[SHIP-01] Checking message ${messageId}:`, {
-                    from: msgData.from?.substring(0, 20),
-                    to: msgData.to,
-                    hasContent: !!msgData.content
-                });
                 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;
-                    console.log(`[SHIP-01] Message ${messageId} match:`, {
-                        isSentToTarget,
-                        isReceivedFromTarget,
-                        fromMatch: msgData.from === userPub,
-                        toMatch: msgData.to === withUsername,
-                        receivedToMatch: msgData.to === username,
-                        receivedFromMatch: msgData.from === otherUserPub
-                    });
+                    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);
@@ -448,381 +231,203 @@ class SHIP_01 {
                             from: msgData.from,
                             to: msgData.to,
                             content: decryptedContent,
-                            timestamp: parseInt(msgData.timestamp)
+                            timestamp: parseInt(msgData.timestamp),
                         });
-                        console.log(`[SHIP-01] ✅ Decrypted message from ${msgData.from.substring(0, 20)}...`);
                     }
                 }
                 catch (error) {
-                    console.error(`[SHIP-01] ❌ Error processing message ${messageId}:`, error);
+                    // Silent error - message couldn't be decrypted
                 }
             });
-            // Wait a bit for GunDB to return all messages, then resolve
+            // Wait for GunDB to return all messages, then resolve
             setTimeout(() => {
-                console.log(`[SHIP-01] Found ${messages.length} messages out of ${messageCount} total`);
                 const sorted = messages.sort((a, b) => a.timestamp - b.timestamp);
                 resolve(sorted);
             }, 2000);
         });
     }
     // ========================================================================
-    // 7. UTILITY FUNCTIONS
+    // PRIVATE HELPERS
     // ========================================================================
     /**
-     * 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
+     * Decrypt a message using ECDH
+     * Uses identity provider (SHIP-00) to get keys
      */
-    async deriveEthereumAddress(publicKey) {
+    async decryptMessage(encryptedContent, senderPub) {
+        // Get receiver's key pair from SHIP-00
+        const receiverPair = this.identity.getKeyPair();
+        if (!receiverPair) {
+            throw new Error("Cannot access receiver key pair");
+        }
+        // Get sender's public key
+        const senderKeyData = await this.getPublicKeyByPub(senderPub);
+        if (!senderKeyData) {
+            throw new Error("Sender public key not found");
+        }
+        // Access crypto
+        const shogun = this.identity.getShogun();
+        const crypto = shogun?.db?.crypto;
+        if (!crypto) {
+            throw new Error("Cannot access crypto");
+        }
+        // Decrypt using ECDH
+        const decrypted = await crypto.decFrom(encryptedContent, { epub: senderKeyData.epub }, receiverPair);
+        return decrypted;
+    }
+    /**
+     * Get public key by pub key
+     * Uses identity provider internally
+     */
+    async getPublicKeyByPub(userPub) {
         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");
+            // Access GunDB
+            const shogun = this.identity.getShogun();
+            const gun = shogun?.db?.gun;
+            if (!gun) {
+                return null;
             }
-            // 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;
+            const publicKeyData = await gun.get(userPub).then();
+            if (publicKeyData && publicKeyData.epub && publicKeyData.pub) {
+                return {
+                    pub: publicKeyData.pub,
+                    epub: publicKeyData.epub,
+                };
+            }
+            return null;
         }
         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));
+            console.error("❌ Error getting public key:", error);
+            return null;
         }
     }
     /**
-     * Genera ID messaggio univoco
+     * Generate unique message ID
      */
     generateMessageId() {
         return ethers_1.ethers.hexlify(ethers_1.ethers.randomBytes(16));
     }
+    // ========================================================================
+    // TOKEN-BASED MESSAGING (Channels/Groups)
+    // ========================================================================
+    /**
+     * Send message encrypted with shared token/password
+     * Useful for group chats, channels, broadcast messages
+     */
+    async sendMessageWithToken(token, message, channel) {
+        try {
+            // Verify authentication
+            if (!this.identity.isLoggedIn()) {
+                return { success: false, error: "Not authenticated" };
+            }
+            // Get current user
+            const currentUser = this.identity.getCurrentUser();
+            if (!currentUser) {
+                return { success: false, error: "No current user" };
+            }
+            // Access crypto and GunDB
+            const shogun = this.identity.getShogun();
+            const crypto = shogun?.db?.crypto;
+            const gun = shogun?.db?.gun;
+            if (!crypto || !gun) {
+                return { success: false, error: "Cannot access crypto or GunDB" };
+            }
+            // Hash token for key derivation (more secure)
+            const hashedToken = await crypto.hashText(token);
+            // Encrypt message with hashed token
+            const encryptedMessage = await crypto.encrypt(message, hashedToken);
+            // Generate message ID
+            const messageId = this.generateMessageId();
+            // Save encrypted message
+            const messageData = {
+                from: currentUser.pub,
+                content: encryptedMessage,
+                channel: channel || "default",
+                timestamp: Date.now().toString(),
+                messageId: messageId,
+                type: "token", // Mark as token-encrypted
+            };
+            await gun
+                .get(SHIP_01.NODES.TOKEN_MESSAGES)
+                .get(messageId)
+                .put(messageData)
+                .then();
+            console.log(`✅ Token message sent: ${messageId} (channel: ${channel || "default"})`);
+            return {
+                success: true,
+                messageId: messageId,
+            };
+        }
+        catch (error) {
+            console.error("❌ Error sending token message:", error);
+            return {
+                success: false,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Listen for token-encrypted messages
+     * Automatically decrypts with provided token
+     */
+    async listenForTokenMessages(token, onMessage, channel) {
+        if (!this.identity.isLoggedIn()) {
+            console.error("❌ Not authenticated");
+            return;
+        }
+        // Access GunDB and crypto
+        const shogun = this.identity.getShogun();
+        const gun = shogun?.db?.gun;
+        const crypto = shogun?.db?.crypto;
+        if (!gun || !crypto) {
+            console.error("❌ Cannot access GunDB or crypto");
+            return;
+        }
+        // Hash token for decryption
+        const hashedToken = await crypto.hashText(token);
+        // Track received messages to avoid duplicates
+        const receivedMessages = new Set();
+        // Listen for token messages in real-time
+        gun
+            .get(SHIP_01.NODES.TOKEN_MESSAGES)
+            .map()
+            .on(async (data, key) => {
+            // Filter by channel if specified
+            if (channel && data?.channel !== channel) {
+                return;
+            }
+            // Validate data
+            if (data &&
+                data.type === "token" &&
+                data.from &&
+                data.content &&
+                data.messageId) {
+                // Avoid duplicates
+                if (receivedMessages.has(data.messageId)) {
+                    return;
+                }
+                receivedMessages.add(data.messageId);
+                try {
+                    // Decrypt message with hashed token
+                    const decryptedContent = await crypto.decrypt(data.content, hashedToken);
+                    onMessage({
+                        from: data.from,
+                        content: decryptedContent,
+                        channel: data.channel,
+                        timestamp: parseInt(data.timestamp),
+                    });
+                }
+                catch (error) {
+                    // Silently skip messages that can't be decrypted
+                    // (wrong token or corrupted data)
+                }
+            }
+        });
+        console.log(`👂 Listening for token messages (channel: ${channel || "all"})...`);
+    }
 }
 exports.SHIP_01 = SHIP_01;
-// GunDB Node Names - Constants for clarity
+// GunDB Node Names for messaging
 SHIP_01.NODES = {
-    MESSAGES: 'messages',
-    USERS: 'users',
-    PUBLIC_KEYS: 'publicKeys'
+    MESSAGES: "messages",
+    TOKEN_MESSAGES: "token_messages", // Token-encrypted messages (channels/groups)
 };
-// ============================================================================
-// 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 (require.main === module) {
-    // Scegli quale eseguire decommentando una delle due righe:
-    // main().catch(console.error);  // Esempio singolo utente
-    testAliceAndBob().catch(console.error); // Test completo Alice & Bob
-}