shogun-core 3.2.3 → 3.3.0

package/dist/ship/implementation/SHIP_01.js

@@ -1,351 +1,168 @@
 "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
-     */
-    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à
+     * Constructor
+     * @param identity ISHIP_00 instance for identity operations
      */
-    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",
-            };
+    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");
     }
     /**
-     * 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
+     * Get identity provider
      */
-    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 };
-        }
+    getIdentity() {
+        return this.identity;
     }
     // ========================================================================
-    // 4. INVIO MESSAGGI: Solo GunDB
+    // MESSAGING - Send
     // ========================================================================
     /**
-     * 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`,
                 };
             }
-            // 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" };
+            }
+            const gun = shogun.db.gun;
+            const crypto = shogun.db.crypto;
+            if (!gun || !crypto) {
+                return { success: false, error: "Cannot access GunDB or crypto" };
             }
-            // 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
+            // 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,
             };
-            // Salva sul nodo globale 'messages' per permettere il listener
-            await this.shogun.db.gun
+            await gun
                 .get(SHIP_01.NODES.MESSAGES)
                 .get(messageId)
                 .put(messageData)
                 .then();
-            console.log(`✅ Messaggio salvato: ${messageId}`);
+            console.log(`✅ Message sent: ${messageId}`);
             return {
                 success: true,
                 messageId: messageId,
             };
         }
         catch (error) {
+            console.error("❌ Error sending message:", 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
+    // 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;
         }
-        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;
-        // Ottieni username dell'utente corrente
-        const username = currentUser.is.alias;
-        // Set per tracciare messaggi già ricevuti (evita duplicati)
+        const username = currentUser.alias;
+        // Access GunDB
+        const shogun = this.identity.getShogun();
+        const gun = shogun?.db?.gun;
+        if (!gun) {
+            console.error("❌ Cannot access GunDB");
+            return;
+        }
+        // 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)
+            // Filter messages for this user
             if (data &&
                 data.to === username &&
                 data.from &&
                 data.content &&
                 data.messageId) {
-                // Evita duplicati (GunDB può emettere più volte)
+                // 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,
@@ -354,90 +171,55 @@ class SHIP_01 {
                     });
                 }
                 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 = [];
-        // 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;
-        // 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
+            gun
                 .get(SHIP_01.NODES.MESSAGES)
                 .map()
                 .once(async (msgData, messageId) => {
-                // Skip metadata fields
+                // Skip metadata
                 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) &&
@@ -457,7 +239,7 @@ class SHIP_01 {
                     // 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(() => {
                 const sorted = messages.sort((a, b) => a.timestamp - b.timestamp);
                 resolve(sorted);
@@ -465,186 +247,187 @@ class SHIP_01 {
         });
     }
     // ========================================================================
-    // 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 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 deriveEthereumAddress(publicKey) {
+    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",
+    TOKEN_MESSAGES: "token_messages", // Token-encrypted messages (channels/groups)
 };
-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
-}