shogun-core 5.2.2 → 6.0.0

package/dist/gundb/db.js

@@ -42,17 +42,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGun = exports.derive = exports.GunErrors = exports.crypto = exports.RxJS = exports.SEA = exports.DataBase = exports.Gun = void 0;
-const gun_1 = __importDefault(require("gun/gun"));
-exports.Gun = gun_1.default;
+exports.derive = exports.GunErrors = exports.crypto = exports.RxJS = exports.SEA = exports.DataBase = void 0;
 const sea_1 = __importDefault(require("gun/sea"));
 exports.SEA = sea_1.default;
-require("gun/lib/then");
-require("gun/lib/radix");
-require("gun/lib/radisk");
-require("gun/lib/store");
-require("gun/lib/rindexed");
-require("gun/lib/webrtc");
 const derive_1 = __importDefault(require("./derive"));
 exports.derive = derive_1.default;
 const errorHandler_1 = require("../utils/errorHandler");
@@ -83,11 +75,17 @@ class DataBase {
     constructor(gun, appScope = "shogun", core) {
         this.user = null;
         this.onAuthCallbacks = [];
+        // Memory leak prevention
+        this._activeTimeouts = new Set();
+        this._activeIntervals = new Set();
+        this._isDestroyed = false;
         console.log("[DB] Initializing DataBase");
         // Store core reference
         this.core = core;
         // Initialize event emitter
         this.eventEmitter = new eventEmitter_1.EventEmitter();
+        // Setup cleanup handlers
+        this.setupCleanupHandlers();
         // Validate Gun instance
         if (!gun) {
             throw new Error("Gun instance is required but was not provided");
@@ -129,7 +127,7 @@ class DataBase {
             this.node = this.gun.get(appScope);
             console.log("[DB] App scope node initialized");
             // Initialize CryptoIdentityManager
-            this._cryptoIdentityManager = new CryptoIdentityManager_1.CryptoIdentityManager(this.core);
+            this._cryptoIdentityManager = new CryptoIdentityManager_1.CryptoIdentityManager(this.core, this);
             console.log("[DB] CryptoIdentityManager initialized");
             if (sessionResult.success) {
                 console.log("[DB] Session automatically restored");
@@ -381,46 +379,26 @@ class DataBase {
         return this.navigateToPath(this.node, path);
     }
     /**
-     * Gets data at the specified path (one-time read)
-     * @param path Path to get the data from
-     * @returns Promise resolving to the data
-     */
-    async getData(path) {
-        const node = this.navigateToPath(this.node, path);
-        return new Promise((resolve, reject) => {
-            node.once((data) => {
-                resolve(data);
-            });
-        });
-    }
-    /**
-     * Puts data at the specified path
-     * @param path Path to store data
-     * @param data Data to store
-     * @returns Promise resolving to operation result
+     * Gets the Gun instance for direct operations
+     * @returns Gun instance
      */
-    async put(path, data) {
-        const node = this.navigateToPath(this.node, path);
-        return await node.put(data).then();
+    getGunInstance() {
+        return this.gun;
     }
     /**
-     * Sets data at the specified path
-     * @param path Path to store data
-     * @param data Data to store
-     * @returns Promise resolving to operation result
+     * Gets the app scope node for direct operations
+     * @returns Gun node
      */
-    async set(path, data) {
-        const node = this.navigateToPath(this.node, path);
-        return await node.set(data).then();
+    getAppNode() {
+        return this.node;
     }
     /**
-     * Removes data at the specified path
-     * @param path Path to remove
-     * @returns Promise resolving to operation result
+     * Helper method to get a node at a specific path for direct GUN operations
+     * @param path Path to the node
+     * @returns Gun node at the specified path
      */
-    async remove(path) {
-        const node = this.navigateToPath(this.node, path);
-        return await node.put(null).then();
+    getNode(path) {
+        return this.navigateToPath(this.node, path);
     }
     /**
      * Checks if a user is currently logged in
@@ -577,6 +555,10 @@ class DataBase {
             // Log out user
             try {
                 currentUser.leave();
+                // Force clear any pending authentication
+                if (currentUser._ && currentUser._.sea) {
+                    currentUser._.sea = null;
+                }
             }
             catch (gunError) {
                 console.error("Error during Gun logout:", gunError);
@@ -685,136 +667,6 @@ class DataBase {
         // Validate password strength
         return this.validatePasswordStrength(password);
     }
-    /**
-     * Creates a new user in Gun
-     */
-    async createNewUser(username, password) {
-        return new Promise((resolve) => {
-            // Validate inputs before creating user
-            if (!username ||
-                typeof username !== "string" ||
-                username.trim().length === 0) {
-                resolve({ success: false, error: "Invalid username provided" });
-                return;
-            }
-            if (!password ||
-                typeof password !== "string" ||
-                password.length === 0) {
-                resolve({ success: false, error: "Invalid password provided" });
-                return;
-            }
-            // Normalize username
-            const normalizedUsername = username.trim().toLowerCase();
-            if (normalizedUsername.length === 0) {
-                resolve({
-                    success: false,
-                    error: "Username cannot be empty",
-                });
-                return;
-            }
-            this.gun.user().create(normalizedUsername, password, (ack) => {
-                if (ack.err) {
-                    console.error(`User creation error: ${ack.err}`);
-                    resolve({ success: false, error: ack.err });
-                }
-                else {
-                    // Validate that we got a userPub from creation
-                    const userPub = ack.pub;
-                    if (!userPub ||
-                        typeof userPub !== "string" ||
-                        userPub.trim().length === 0) {
-                        console.error("User creation successful but no userPub returned:", ack);
-                        resolve({
-                            success: false,
-                            error: "User creation successful but no userPub returned",
-                        });
-                    }
-                    else {
-                        resolve({ success: true, userPub: userPub });
-                    }
-                }
-            });
-        });
-    }
-    /**
-     * Authenticates user after creation
-     */
-    async authenticateNewUser(username, password, pair) {
-        return new Promise((resolve) => {
-            // Validate inputs before authentication
-            if (!username ||
-                typeof username !== "string" ||
-                username.trim().length === 0) {
-                resolve({ success: false, error: "Invalid username provided" });
-                return;
-            }
-            // Skip password validation when using pair authentication
-            if (!pair &&
-                (!password || typeof password !== "string" || password.length === 0)) {
-                resolve({ success: false, error: "Invalid password provided" });
-                return;
-            }
-            // Normalize username to match what was used in creation
-            const normalizedUsername = username.trim().toLowerCase();
-            if (normalizedUsername.length === 0) {
-                resolve({
-                    success: false,
-                    error: "Username cannot be empty",
-                });
-                return;
-            }
-            if (pair) {
-                this.gun.user().auth(pair, (ack) => {
-                    if (ack.err) {
-                        console.error(`Authentication after creation failed: ${ack.err}`);
-                        resolve({ success: false, error: ack.err });
-                    }
-                    else {
-                        // Add a small delay to ensure user state is properly set
-                        setTimeout(() => {
-                            // Extract userPub from multiple possible sources
-                            const userPub = ack.pub || this.gun.user().is?.pub || ack.user?.pub;
-                            if (!userPub) {
-                                console.error("Authentication successful but no userPub found");
-                                resolve({
-                                    success: false,
-                                    error: "No userPub returned from authentication",
-                                });
-                            }
-                            else {
-                                resolve({ success: true, userPub: userPub });
-                            }
-                        }, 100);
-                    }
-                });
-            }
-            else {
-                this.gun.user().auth(normalizedUsername, password, (ack) => {
-                    if (ack.err) {
-                        console.error(`Authentication after creation failed: ${ack.err}`);
-                        resolve({ success: false, error: ack.err });
-                    }
-                    else {
-                        // Add a small delay to ensure user state is properly set
-                        setTimeout(() => {
-                            // Extract userPub from multiple possible sources
-                            const userPub = ack.pub || this.gun.user().is?.pub || ack.user?.pub;
-                            if (!userPub) {
-                                console.error("Authentication successful but no userPub found");
-                                resolve({
-                                    success: false,
-                                    error: "No userPub returned from authentication",
-                                });
-                            }
-                            else {
-                                resolve({ success: true, userPub: userPub });
-                            }
-                        }, 100);
-                    }
-                });
-            }
-        });
-    }
     /**
      * Signs up a new user using direct Gun authentication
      * @param username Username
@@ -822,13 +674,34 @@ class DataBase {
      * @param pair Optional SEA pair for Web3 login
      * @returns Promise resolving to signup result
      */
-    async signUp(username, password, pair) {
+    async signUp(username, password, pair, retryCount = 0, maxRetries = 3) {
         try {
+            console.log(`🔄 [SIGNUP] Attempting signup for: ${username}`);
             // Validate credentials with enhanced security
             const validation = this.validateSignupCredentials(username, password, pair);
             if (!validation.valid) {
                 return { success: false, error: validation.error };
             }
+            // Check if authentication is in progress and retry if needed
+            if (this.isAuthInProgress()) {
+                if (retryCount < maxRetries) {
+                    console.warn(`Authentication in progress during signup, retrying... (${retryCount + 1}/${maxRetries})`);
+                    this.resetAuthState();
+                    const baseDelay = 100 * Math.pow(2, retryCount);
+                    const jitter = Math.random() * 100;
+                    const delay = Math.min(baseDelay + jitter, 2000);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    return this.signUp(username, password, pair, retryCount + 1, maxRetries);
+                }
+                else {
+                    console.error("Max retries exceeded for signup due to concurrent operations");
+                    this.resetAuthState();
+                    return {
+                        success: false,
+                        error: "Signup failed after multiple retries due to concurrent operations",
+                    };
+                }
+            }
             let createResult;
             if (pair) {
                 // For Web3/plugin authentication, use pair-based creation
@@ -836,15 +709,17 @@ class DataBase {
             }
             else {
                 // For password authentication, use standard creation
-                createResult = await this.createNewUser(username, password);
+                createResult = await this.createNewUserFixed(username, password);
             }
             if (!createResult.success) {
+                // Reset auth state after failed creation to prevent blocking future operations
+                this.resetAuthState();
                 return { success: false, error: createResult.error };
             }
             // Add a small delay to ensure user is properly registered
             await new Promise((resolve) => setTimeout(resolve, 100));
             // Authenticate the newly created user
-            const authResult = await this.authenticateNewUser(username, password, pair);
+            const authResult = await this.authenticateNewUserFixed(username, password, pair);
             if (!authResult.success) {
                 return { success: false, error: authResult.error };
             }
@@ -921,6 +796,100 @@ class DataBase {
             resolve({ success: true, userPub: pair.pub });
         });
     }
+    /**
+     * Creates a new user in Gun without waiting for acknowledgment
+     */
+    async createNewUserFixed(username, password) {
+        return new Promise((resolve) => {
+            // Validate inputs before creating user
+            if (!username ||
+                typeof username !== "string" ||
+                username.trim().length === 0) {
+                resolve({ success: false, error: "Invalid username provided" });
+                return;
+            }
+            if (!password ||
+                typeof password !== "string" ||
+                password.length === 0) {
+                resolve({ success: false, error: "Invalid password provided" });
+                return;
+            }
+            // Normalize username
+            const normalizedUsername = username.trim().toLowerCase();
+            if (normalizedUsername.length === 0) {
+                resolve({
+                    success: false,
+                    error: "Username cannot be empty",
+                });
+                return;
+            }
+            console.log(`🔄 [CREATE] Creating user: ${normalizedUsername}`);
+            // Crea utente senza aspettare acknowledgment
+            this.gun.user().create(normalizedUsername, password, () => { });
+            // Aspetta che la creazione si completi
+            setTimeout(() => {
+                // Controlla se l'utente è stato creato
+                const user = this.gun.user();
+                if (user && user.is && user.is.pub) {
+                    console.log("✅ [CREATE] User created successfully");
+                    resolve({ success: true, userPub: user.is.pub });
+                }
+                else {
+                    console.log("❌ [CREATE] User creation failed");
+                    resolve({ success: false, error: "User creation failed" });
+                }
+            }, 2000); // Aspetta 2 secondi
+        });
+    }
+    /**
+     * Authenticates user after creation without waiting for acknowledgment
+     */
+    async authenticateNewUserFixed(username, password, pair) {
+        return new Promise((resolve) => {
+            // Validate inputs before authentication
+            if (!username ||
+                typeof username !== "string" ||
+                username.trim().length === 0) {
+                resolve({ success: false, error: "Invalid username provided" });
+                return;
+            }
+            // Skip password validation when using pair authentication
+            if (!pair &&
+                (!password || typeof password !== "string" || password.length === 0)) {
+                resolve({ success: false, error: "Invalid password provided" });
+                return;
+            }
+            // Normalize username to match what was used in creation
+            const normalizedUsername = username.trim().toLowerCase();
+            if (normalizedUsername.length === 0) {
+                resolve({
+                    success: false,
+                    error: "Username cannot be empty",
+                });
+                return;
+            }
+            console.log(`🔑 [AUTH] Authenticating user: ${normalizedUsername}`);
+            // Autentica senza aspettare acknowledgment
+            if (pair) {
+                this.gun.user().auth(pair);
+            }
+            else {
+                this.gun.user().auth(normalizedUsername, password);
+            }
+            // Aspetta che l'autenticazione si completi
+            setTimeout(() => {
+                const user = this.gun.user();
+                if (user && user.is && user.is.pub) {
+                    console.log("✅ [AUTH] Authentication successful");
+                    resolve({ success: true, userPub: user.is.pub });
+                }
+                else {
+                    console.log("❌ [AUTH] Authentication failed");
+                    resolve({ success: false, error: "Authentication failed" });
+                }
+            }, 2000); // Aspetta 2 secondi
+        });
+    }
     async runPostAuthOnAuthResult(username, userPub, authResult) {
         console.log(`[POSTAUTH] Starting post-auth setup for user: ${username}, userPub: ${userPub}`);
         try {
@@ -956,7 +925,7 @@ class DataBase {
             }
             console.log(`[POSTAUTH] Normalized username: ${normalizedUsername}`);
             console.log(`[POSTAUTH] Checking if user exists: ${userPub}`);
-            const existingUser = await this.gun.get(userPub).then();
+            const existingUser = this.gun.get(userPub);
             const isNewUser = !existingUser || !existingUser.alias;
             console.log(`[POSTAUTH] User is ${isNewUser ? "NEW" : "EXISTING"}: ${userPub}`);
             // Get user's encryption public key (epub) for comprehensive tracking
@@ -975,8 +944,10 @@ class DataBase {
                 };
             }
             console.log(`[POSTAUTH] User tracking setup completed successfully for: ${normalizedUsername}`);
-            // Setup crypto identities for the user
-            if (this._cryptoIdentityManager && userSea) {
+            // Setup crypto identities for the user (skip if SKIP_CRYPTO_GENERATION is set)
+            if (this._cryptoIdentityManager &&
+                userSea &&
+                !process.env.SKIP_CRYPTO_GENERATION) {
                 console.log(`[POSTAUTH] Setting up crypto identities for: ${normalizedUsername}`);
                 try {
                     const cryptoSetupResult = await this._cryptoIdentityManager.setupCryptoIdentities(normalizedUsername, userSea, false);
@@ -994,7 +965,12 @@ class DataBase {
                 }
             }
             else {
-                console.log(`ℹ️ [POSTAUTH] Skipping crypto identities setup - manager not available or no SEA pair`);
+                if (process.env.SKIP_CRYPTO_GENERATION) {
+                    console.log(`ℹ️ [POSTAUTH] Skipping crypto identities setup - SKIP_CRYPTO_GENERATION is set`);
+                }
+                else {
+                    console.log(`ℹ️ [POSTAUTH] Skipping crypto identities setup - manager not available or no SEA pair`);
+                }
             }
             const result = {
                 success: true,
@@ -1103,28 +1079,13 @@ class DataBase {
                 userPub: userPub,
                 createdAt: Date.now(),
             };
-            return new Promise((resolve) => {
-                // Add timeout to prevent hanging
-                const timeout = setTimeout(() => {
-                    console.error(`Alias index creation timeout for ${username}`);
-                    resolve(false);
-                }, 5000); // 5 second timeout
-                // Store alias mapping in a simple way
-                this.node
-                    .get("aliases")
-                    .get(username)
-                    .put(aliasData, (ack) => {
-                    clearTimeout(timeout); // Clear timeout since callback fired
-                    if (ack && ack.err) {
-                        console.error(`Error creating alias index: ${ack.err}`);
-                        resolve(false);
-                    }
-                    else {
-                        console.log(`✓ Alias index created for ${username}`);
-                        resolve(true);
-                    }
-                });
-            });
+            console.log(`🔄 [ALIAS] Creating alias index for ${username}`);
+            // Store alias mapping without waiting for acknowledgment
+            this.node.get("aliases").get(username).put(aliasData);
+            // Aspetta un momento per la scrittura
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            console.log(`✅ [ALIAS] Alias index created for ${username}`);
+            return true;
         }
         catch (error) {
             console.error(`Error creating alias index: ${error}`);
@@ -1136,20 +1097,13 @@ class DataBase {
      */
     async createUsernameMapping(username, userPub) {
         try {
-            return new Promise((resolve) => {
-                this.node
-                    .get("usernames")
-                    .get(username)
-                    .put(userPub, (ack) => {
-                    if (ack && ack.err) {
-                        console.error(`Error creating username mapping: ${ack.err}`);
-                        resolve(false);
-                    }
-                    else {
-                        resolve(true);
-                    }
-                });
-            });
+            console.log(`🔄 [USERNAME] Creating username mapping for ${username}`);
+            // Store username mapping without waiting for acknowledgment
+            this.node.get("usernames").get(username).put(userPub);
+            // Aspetta un momento per la scrittura
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            console.log(`✅ [USERNAME] Username mapping created for ${username}`);
+            return true;
         }
         catch (error) {
             console.error(`Error creating username mapping: ${error}`);
@@ -1168,20 +1122,13 @@ class DataBase {
                 registeredAt: Date.now().toString(),
                 lastSeen: Date.now().toString(),
             };
-            return new Promise((resolve) => {
-                this.node
-                    .get("users")
-                    .get(userPub)
-                    .put(userData, (ack) => {
-                    if (ack && ack.err) {
-                        console.error(`Error creating user registry: ${ack.err}`);
-                        resolve(false);
-                    }
-                    else {
-                        resolve(true);
-                    }
-                });
-            });
+            console.log(`🔄 [REGISTRY] Creating user registry for ${username}`);
+            // Store user registry without waiting for acknowledgment
+            this.node.get("users").get(userPub).put(userData);
+            // Aspetta un momento per la scrittura
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            console.log(`✅ [REGISTRY] User registry created for ${username}`);
+            return true;
         }
         catch (error) {
             console.error(`Error creating user registry: ${error}`);
@@ -1193,18 +1140,13 @@ class DataBase {
      */
     async createReverseLookup(username, userPub) {
         try {
-            const ack = await this.node
-                .get("userAliases")
-                .get(userPub)
-                .put(username)
-                .then();
-            if (ack.err) {
-                console.error(`Error creating reverse lookup: ${ack.err}`);
-                return false;
-            }
-            else {
-                return true;
-            }
+            console.log(`🔄 [REVERSE] Creating reverse lookup for ${username}`);
+            // Store reverse lookup without waiting for acknowledgment
+            this.node.get("userAliases").get(userPub).put(username);
+            // Aspetta un momento per la scrittura
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            console.log(`✅ [REVERSE] Reverse lookup created for ${username}`);
+            return true;
         }
         catch (error) {
             console.error(`Error creating reverse lookup: ${error}`);
@@ -1216,20 +1158,13 @@ class DataBase {
      */
     async createEpubIndex(epub, userPub) {
         try {
-            return new Promise((resolve) => {
-                this.node
-                    .get("epubKeys")
-                    .get(epub)
-                    .put(userPub, (ack) => {
-                    if (ack && ack.err) {
-                        console.error(`Error creating epub index: ${ack.err}`);
-                        resolve(false);
-                    }
-                    else {
-                        resolve(true);
-                    }
-                });
-            });
+            console.log(`🔄 [EPUB] Creating epub index for ${userPub}`);
+            // Store epub index without waiting for acknowledgment
+            this.node.get("epubKeys").get(epub).put(userPub);
+            // Aspetta un momento per la scrittura
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            console.log(`✅ [EPUB] Epub index created for ${userPub}`);
+            return true;
         }
         catch (error) {
             console.error(`Error creating epub index: ${error}`);
@@ -1247,17 +1182,13 @@ class DataBase {
                 registeredAt: Date.now(),
                 lastSeen: Date.now(),
             };
-            return new Promise((resolve) => {
-                this.gun.get(userPub).put(userMetadata, (ack) => {
-                    if (ack && ack.err) {
-                        console.error(`Error creating user metadata: ${ack.err}`);
-                        resolve(false);
-                    }
-                    else {
-                        resolve(true);
-                    }
-                });
-            });
+            console.log(`🔄 [METADATA] Creating user metadata for ${username}`);
+            // Store user metadata without waiting for acknowledgment
+            this.gun.get(userPub).put(userMetadata);
+            // Aspetta un momento per la scrittura
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            console.log(`✅ [METADATA] User metadata created for ${username}`);
+            return true;
         }
         catch (error) {
             console.error(`Error creating user metadata: ${error}`);
@@ -1277,7 +1208,7 @@ class DataBase {
             }
             // Method 1: Try GunDB standard alias lookup (~@alias)
             try {
-                const aliasData = await this.gun.get(`~@${normalizedAlias}`).then();
+                const aliasData = this.gun.get(`~@${normalizedAlias}`);
                 if (aliasData && aliasData["~pubKeyOfUser"]) {
                     const userPub = aliasData["~pubKeyOfUser"]["#"] || aliasData["~pubKeyOfUser"];
                     if (userPub) {
@@ -1293,10 +1224,15 @@ class DataBase {
             }
             // Method 2: Try username mapping (usernames/alias -> userPub)
             try {
-                const userPub = await this.node
-                    .get("usernames")
-                    .get(normalizedAlias)
-                    .then();
+                const userPubNode = this.node.get("usernames").get(normalizedAlias);
+                // Use once to get the actual value
+                const userPub = await new Promise((resolve) => {
+                    const timeout = setTimeout(() => resolve(null), 2000);
+                    userPubNode.once((data) => {
+                        clearTimeout(timeout);
+                        resolve(data);
+                    });
+                });
                 if (userPub) {
                     const userData = await this.getUserDataByPub(userPub);
                     if (userData) {
@@ -1326,7 +1262,7 @@ class DataBase {
             }
             // Method 1: Try user registry (users/userPub -> user data)
             try {
-                const userData = await this.node.get("users").get(userPub).then();
+                const userData = this.node.get("users").get(userPub);
                 if (userData && userData.username) {
                     return {
                         userPub: userData.userPub || userPub,
@@ -1342,7 +1278,7 @@ class DataBase {
             }
             // Method 2: Try user's own node
             try {
-                const userNodeData = await this.gun.get(userPub).then();
+                const userNodeData = this.gun.get(userPub);
                 if (userNodeData && userNodeData.username) {
                     return {
                         userPub: userPub,
@@ -1373,7 +1309,15 @@ class DataBase {
             if (!epub || typeof epub !== "string") {
                 return null;
             }
-            const userPub = await this.node.get("epubKeys").get(epub).then();
+            const userPubNode = this.node.get("epubKeys").get(epub);
+            // Use once to get the actual value
+            const userPub = await new Promise((resolve) => {
+                const timeout = setTimeout(() => resolve(null), 2000);
+                userPubNode.once((data) => {
+                    clearTimeout(timeout);
+                    resolve(data);
+                });
+            });
             return userPub || null;
         }
         catch (error) {
@@ -1391,7 +1335,15 @@ class DataBase {
             if (!userPub || typeof userPub !== "string") {
                 return null;
             }
-            const alias = await this.node.get("userAliases").get(userPub).then();
+            const aliasNode = this.node.get("userAliases").get(userPub);
+            // Use once to get the actual value
+            const alias = await new Promise((resolve) => {
+                const timeout = setTimeout(() => resolve(null), 2000);
+                aliasNode.once((data) => {
+                    clearTimeout(timeout);
+                    resolve(data);
+                });
+            });
             return alias || null;
         }
         catch (error) {
@@ -1430,19 +1382,14 @@ class DataBase {
             const timestamp = Date.now();
             // Update in user registry
             try {
-                await this.node
-                    .get("users")
-                    .get(userPub)
-                    .get("lastSeen")
-                    .put(timestamp)
-                    .then();
+                this.node.get("users").get(userPub).get("lastSeen").put(timestamp);
             }
             catch (error) {
                 console.error(`Failed to update lastSeen in user registry:`, error);
             }
             // Update in user's own node
             try {
-                await this.gun.get(userPub).get("lastSeen").put(timestamp).then();
+                this.gun.get(userPub).get("lastSeen").put(timestamp);
             }
             catch (error) {
                 console.error(`Failed to update lastSeen in user node:`, error);
@@ -1453,33 +1400,134 @@ class DataBase {
         }
     }
     /**
-     * Performs authentication with Gun
+     * Resets Gun.js authentication state to allow new auth operations
+     */
+    resetAuthState() {
+        try {
+            const currentUser = this.gun.user();
+            if (currentUser && currentUser._) {
+                // Reset the authentication flag
+                if (currentUser._.sea) {
+                    currentUser._.sea = null;
+                }
+                // Reset the ing flag that prevents concurrent operations
+                if (currentUser._.ing) {
+                    currentUser._.ing = false;
+                }
+                // Force clear any pending authentication callbacks
+                if (currentUser._.auth) {
+                    currentUser._.auth = null;
+                }
+                // Clear any pending operations
+                if (currentUser._.act) {
+                    currentUser._.act = null;
+                }
+                // Clear any pending callbacks
+                if (currentUser._.cb) {
+                    currentUser._.cb = null;
+                }
+                // Clear any pending retries
+                if (currentUser._.retries) {
+                    currentUser._.retries = 0;
+                }
+                // Clear any pending timeouts
+                if (currentUser._.timeout) {
+                    clearTimeout(currentUser._.timeout);
+                    currentUser._.timeout = null;
+                }
+            }
+            // Also try to call leave() to ensure clean state
+            try {
+                currentUser.leave();
+            }
+            catch (leaveError) {
+                // Ignore leave errors, just trying to clean up
+            }
+            // Force clear the user reference to ensure clean state
+            this.user = null;
+            console.log("Auth state reset completed");
+        }
+        catch (error) {
+            console.warn("Error resetting auth state:", error);
+        }
+    }
+    /**
+     * Performs authentication with Gun with retry mechanism
      */
-    async performAuthentication(username, password, pair) {
+    async performAuthentication(username, password, pair, retryCount = 0, maxRetries = 3) {
         return new Promise((resolve) => {
-            if (pair) {
-                this.gun.user().auth(pair, (ack) => {
-                    if (ack.err) {
-                        console.error(`Login error for ${username}: ${ack.err}`);
-                        resolve({ success: false, error: ack.err });
-                    }
-                    else {
-                        resolve({ success: true, ack });
+            // Check if there's already an authentication operation in progress
+            const currentUser = this.gun.user();
+            if (currentUser && currentUser._ && currentUser._.ing) {
+                if (retryCount < maxRetries) {
+                    console.warn(`Authentication already in progress, retrying... (${retryCount + 1}/${maxRetries})`);
+                    this.resetAuthState();
+                    // For the first retry, try to create a fresh authentication context
+                    if (retryCount === 0) {
+                        this.createFreshAuthContext();
                     }
+                    // Add exponential backoff delay with jitter
+                    const baseDelay = 200 * Math.pow(2, retryCount);
+                    const jitter = Math.random() * 200;
+                    const delay = Math.min(baseDelay + jitter, 3000);
+                    setTimeout(() => {
+                        this.performAuthentication(username, password, pair, retryCount + 1, maxRetries)
+                            .then(resolve)
+                            .catch((error) => resolve({ success: false, error: String(error) }));
+                    }, delay);
+                    return;
+                }
+                else {
+                    console.error("Max retries exceeded for authentication");
+                    this.resetAuthState();
+                    resolve({
+                        success: false,
+                        error: "Authentication failed after multiple retries",
+                    });
+                    return;
+                }
+            }
+            this.performAuthenticationInternal(username, password, pair, resolve);
+        });
+    }
+    /**
+     * Internal authentication method with timeout
+     */
+    performAuthenticationInternal(username, password, pair, resolve) {
+        let resolved = false;
+        const timeout = 30000; // 15 second timeout for individual auth attempts
+        const timeoutId = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                console.error(`Authentication timeout for ${username} after ${timeout}ms`);
+                this.resetAuthState();
+                resolve({
+                    success: false,
+                    error: `Authentication timeout after ${timeout}ms`,
                 });
             }
+        }, timeout);
+        const authCallback = (ack) => {
+            if (resolved)
+                return;
+            resolved = true;
+            clearTimeout(timeoutId);
+            if (ack.err) {
+                console.error(`Login error for ${username}: ${ack.err}`);
+                // Reset auth state on error to prevent blocking future attempts
+                this.resetAuthState();
+                resolve({ success: false, error: ack.err });
+            }
             else {
-                this.gun.user().auth(username, password, (ack) => {
-                    if (ack.err) {
-                        console.error(`Login error for ${username}: ${ack.err}`);
-                        resolve({ success: false, error: ack.err });
-                    }
-                    else {
-                        resolve({ success: true, ack });
-                    }
-                });
+                resolve({ success: true, ack });
             }
-        });
+        };
+        if (pair) {
+            this.gun.user().auth(pair, authCallback);
+        }
+        else {
+            this.gun.user().auth(username, password, authCallback);
+        }
     }
     /**
      * Builds login result object
@@ -1511,18 +1559,34 @@ class DataBase {
      */
     async login(username, password, pair) {
         try {
-            const loginResult = await this.performAuthentication(username, password, pair);
-            if (!loginResult.success) {
+            console.log(`🔑 [LOGIN] Attempting login for: ${username}`);
+            // Pulisci lo stato utente esistente
+            this.gun.user().leave();
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            // Autentica senza aspettare acknowledgment
+            if (pair) {
+                this.gun.user().auth(pair);
+            }
+            else {
+                this.gun.user().auth(username, password);
+            }
+            // Aspetta che l'autenticazione si completi
+            console.log("⏳ [LOGIN] Waiting for authentication to complete...");
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+            // Controlla se l'autenticazione è riuscita
+            const user = this.gun.user();
+            const isAuthenticated = !!user.is;
+            if (!isAuthenticated) {
+                console.log("❌ [LOGIN] Authentication failed");
                 return {
                     success: false,
                     error: `User '${username}' not found. Please check your username or register first.`,
                 };
             }
-            // Add a small delay to ensure user state is properly set
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const userPub = this.gun.user().is?.pub;
-            let alias = this.gun.user().is?.alias;
-            let userPair = this.gun.user()?._?.sea;
+            console.log("✅ [LOGIN] Authentication successful!");
+            const userPub = user?.is?.pub;
+            let alias = user?.is?.alias;
+            let userPair = user?._?.sea;
             if (!alias) {
                 alias = username;
             }
@@ -1532,7 +1596,7 @@ class DataBase {
                     error: "Authentication failed: No user pub returned.",
                 };
             }
-            // Pass the userPub to runPostAuthOnAuthResult
+            // Esegui post-authentication tasks
             try {
                 await this.runPostAuthOnAuthResult(alias, userPub, {
                     success: true,
@@ -1693,14 +1757,20 @@ class DataBase {
                 questions: JSON.stringify(securityQuestions),
                 hint: encryptedHint,
             };
-            const ack = await this.node.get(userPub)
-                .get("security")
-                .put(securityPayload)
-                .then();
-            if (ack.err) {
+            console.log(`💾 [HINT] Saving security data for user: ${username}, pub: ${userPub}`);
+            console.log(`💾 [HINT] Security payload:`, {
+                questions: securityPayload.questions,
+                hintLength: securityPayload.hint?.length || 0,
+            });
+            // Save in PUBLIC space, not user space - accessible without login
+            const ack = this.gun.get("security")
+                .get(userPub)
+                .put(securityPayload);
+            if (ack && ack.err) {
                 console.error("Error saving security data to public graph:", ack.err);
                 throw new Error(ack.err);
             }
+            console.log(`✅ [HINT] Security data saved successfully for ${username}`);
             return { success: true };
         }
         catch (error) {
@@ -1716,19 +1786,82 @@ class DataBase {
      */
     async forgotPassword(username, securityAnswers) {
         // Attempting password recovery for
+        // Add global timeout for the entire operation
+        return Promise.race([
+            this._forgotPasswordInternal(username, securityAnswers),
+            new Promise((resolve) => {
+                setTimeout(() => {
+                    console.log(`⏰ [FORGOT] Global timeout for password recovery: ${username}`);
+                    resolve({ success: false, error: "Password recovery timeout" });
+                }, 10000); // 10 second global timeout
+            }),
+        ]);
+    }
+    async _forgotPasswordInternal(username, securityAnswers) {
         try {
             // Find the user's data using direct lookup
             const normalizedUsername = username.trim().toLowerCase();
-            const userPub = (await this.node.get("usernames").get(normalizedUsername).then()) ||
-                null;
+            // Try multiple lookup methods with fallback
+            let userPub = null;
+            // Method 1: Try username mapping in app scope
+            try {
+                userPub = await new Promise((resolve) => {
+                    const timeout = setTimeout(() => {
+                        console.log(`⏰ [FORGOT] Timeout looking up user in usernames: ${username}`);
+                        resolve(null);
+                    }, 2000);
+                    this.node
+                        .get("usernames")
+                        .get(normalizedUsername)
+                        .once((data) => {
+                        clearTimeout(timeout);
+                        console.log(`🔍 [FORGOT] Username lookup result for ${username}:`, data);
+                        resolve(data);
+                    });
+                });
+            }
+            catch (error) {
+                console.log(`❌ [FORGOT] Username lookup failed: ${error}`);
+            }
+            // Method 2: Try direct user lookup if username mapping fails
             if (!userPub) {
+                console.log(`🔄 [FORGOT] Trying direct user lookup for: ${username}`);
+                try {
+                    // Try to find user by searching in the users registry
+                    const usersNode = this.node.get("users");
+                    // This is a simplified approach - in a real implementation you'd need to iterate
+                    // For now, we'll try to get the userPub from the current user if available
+                    const currentUser = this.getCurrentUser();
+                    if (currentUser && currentUser.pub) {
+                        console.log(`🔍 [FORGOT] Using current user pub as fallback: ${currentUser.pub}`);
+                        userPub = currentUser.pub;
+                    }
+                }
+                catch (error) {
+                    console.log(`❌ [FORGOT] Direct user lookup failed: ${error}`);
+                }
+            }
+            if (!userPub) {
+                console.log(`❌ [FORGOT] User not found: ${username}`);
                 return { success: false, error: "User not found" };
             }
-            // Access the user's security data directly from their public key node
-            const securityData = await this.node.get(userPub)
-                .get("security")
-                .then();
+            // Access the user's security data from PUBLIC space (not user space)
+            const securityDataNode = this.gun.get("security").get(userPub);
+            console.log(`🔍 [FORGOT] Looking for security data for user: ${username}, pub: ${userPub}`);
+            // Use once to get the actual value
+            const securityData = await new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    console.log(`⏰ [FORGOT] Timeout waiting for security data for ${username} (3s)`);
+                    resolve(null);
+                }, 3000); // Reduced timeout to 3 seconds
+                securityDataNode.once((data) => {
+                    clearTimeout(timeout);
+                    console.log(`📊 [FORGOT] Security data received for ${username}:`, data);
+                    resolve(data);
+                });
+            });
             if (!securityData || !securityData.hint) {
+                console.log(`❌ [FORGOT] No security data or hint found for ${username}`);
                 return {
                     success: false,
                     error: "No password hint found",
@@ -1790,6 +1923,107 @@ class DataBase {
             return { success: false, error: String(error) };
         }
     }
+    /**
+     * Recovers password hint using security question answers and userPub directly
+     * @param userPub User's public key
+     * @param securityAnswers Array of answers to security questions
+     * @returns Promise resolving with the password hint
+     */
+    async forgotPasswordByPub(userPub, securityAnswers) {
+        // Add global timeout for the entire operation
+        return Promise.race([
+            this._forgotPasswordByPubInternal(userPub, securityAnswers),
+            new Promise((resolve) => {
+                setTimeout(() => {
+                    console.log(`⏰ [FORGOT] Global timeout for password recovery by pub: ${userPub}`);
+                    resolve({ success: false, error: "Password recovery timeout" });
+                }, 10000); // 10 second global timeout
+            }),
+        ]);
+    }
+    async _forgotPasswordByPubInternal(userPub, securityAnswers) {
+        try {
+            if (!userPub || typeof userPub !== "string") {
+                return { success: false, error: "Invalid userPub provided" };
+            }
+            // Access the user's security data from PUBLIC space (not user space)
+            const securityDataNode = this.gun.get("security").get(userPub);
+            console.log(`🔍 [FORGOT] Looking for security data for userPub: ${userPub}`);
+            // Use once to get the actual value
+            const securityData = await new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    console.log(`⏰ [FORGOT] Timeout waiting for security data for userPub: ${userPub} (3s)`);
+                    resolve(null);
+                }, 3000);
+                securityDataNode.once((data) => {
+                    clearTimeout(timeout);
+                    console.log(`📊 [FORGOT] Security data received for userPub: ${userPub}:`, data);
+                    resolve(data);
+                });
+            });
+            if (!securityData || !securityData.hint) {
+                console.log(`❌ [FORGOT] No security data or hint found for userPub: ${userPub}`);
+                return {
+                    success: false,
+                    error: "No password hint found",
+                };
+            }
+            // Generate hash from security answers
+            const answersText = securityAnswers.join("|");
+            let proofOfWork;
+            try {
+                // Use SEA directly if available
+                if (sea_1.default && sea_1.default.work) {
+                    proofOfWork = await sea_1.default.work(answersText, null, null, {
+                        name: "SHA-256",
+                    });
+                }
+                else if (this.crypto && this.crypto.hashText) {
+                    proofOfWork = await this.crypto.hashText(answersText);
+                }
+                else {
+                    throw new Error("Cryptographic functions not available");
+                }
+                if (!proofOfWork) {
+                    throw new Error("Failed to generate hash");
+                }
+            }
+            catch (hashError) {
+                console.error("Error generating hash:", hashError);
+                return { success: false, error: "Failed to generate security hash" };
+            }
+            // Decrypt the password hint with the proof of work
+            let hint;
+            try {
+                if (sea_1.default && sea_1.default.decrypt) {
+                    hint = await sea_1.default.decrypt(securityData.hint, proofOfWork);
+                }
+                else if (this.crypto && this.crypto.decrypt) {
+                    hint = await this.crypto.decrypt(securityData.hint, proofOfWork);
+                }
+                else {
+                    throw new Error("Decryption functions not available");
+                }
+            }
+            catch (decryptError) {
+                return {
+                    success: false,
+                    error: "Incorrect answers to security questions",
+                };
+            }
+            if (hint === undefined) {
+                return {
+                    success: false,
+                    error: "Incorrect answers to security questions",
+                };
+            }
+            return { success: true, hint: hint };
+        }
+        catch (error) {
+            console.error("Error recovering password hint by pub:", error);
+            return { success: false, error: String(error) };
+        }
+    }
     /**
      * Adds an event listener
      * @param event Event name
@@ -1934,13 +2168,220 @@ class DataBase {
     isAuthenticated() {
         return this.user?.is?.pub ? true : false;
     }
+    /**
+     * Check if an authentication operation is currently in progress
+     */
+    isAuthInProgress() {
+        try {
+            const currentUser = this.gun.user();
+            return !!(currentUser && currentUser._ && currentUser._.ing);
+        }
+        catch (error) {
+            console.warn("Error checking auth progress:", error);
+            return false;
+        }
+    }
+    /**
+     * Force reset authentication state (useful for debugging or recovery)
+     */
+    forceResetAuthState() {
+        this.resetAuthState();
+    }
+    /**
+     * Aggressive cleanup for problematic users
+     * This method performs a complete reset of all authentication state
+     */
+    aggressiveAuthCleanup() {
+        try {
+            console.log("🧹 Performing aggressive auth cleanup...");
+            // Reset all auth state
+            this.resetAuthState();
+            // Clear all Gun.js internal state
+            const currentUser = this.gun.user();
+            if (currentUser && currentUser._) {
+                // Clear all possible internal flags
+                const internalState = currentUser._;
+                Object.keys(internalState).forEach((key) => {
+                    if (typeof internalState[key] === "boolean") {
+                        internalState[key] = false;
+                    }
+                    else if (typeof internalState[key] === "object" &&
+                        internalState[key] !== null) {
+                        if (key === "sea" ||
+                            key === "auth" ||
+                            key === "act" ||
+                            key === "cb") {
+                            internalState[key] = null;
+                        }
+                    }
+                });
+            }
+            // Force logout
+            try {
+                currentUser.leave();
+            }
+            catch (error) {
+                // Ignore errors
+            }
+            // Clear user reference
+            this.user = null;
+            // Clear all session storage
+            if (typeof sessionStorage !== "undefined") {
+                try {
+                    const keys = Object.keys(sessionStorage);
+                    keys.forEach((key) => {
+                        if (key.includes("gun") ||
+                            key.includes("user") ||
+                            key.includes("auth")) {
+                            sessionStorage.removeItem(key);
+                        }
+                    });
+                }
+                catch (error) {
+                    // Ignore errors
+                }
+            }
+            // Clear all local storage
+            if (typeof localStorage !== "undefined") {
+                try {
+                    const keys = Object.keys(localStorage);
+                    keys.forEach((key) => {
+                        if (key.includes("gun") ||
+                            key.includes("user") ||
+                            key.includes("auth")) {
+                            localStorage.removeItem(key);
+                        }
+                    });
+                }
+                catch (error) {
+                    // Ignore errors
+                }
+            }
+            console.log("✓ Aggressive auth cleanup completed");
+        }
+        catch (error) {
+            console.error("Error during aggressive cleanup:", error);
+        }
+    }
+    /**
+     * Creates a completely fresh authentication context
+     * This is a more aggressive approach when normal reset doesn't work
+     */
+    createFreshAuthContext() {
+        try {
+            // Reset all auth state
+            this.resetAuthState();
+            // Create a completely new user instance
+            const freshUser = this.gun.user();
+            this.user = freshUser;
+            // Clear any cached authentication data
+            if (typeof sessionStorage !== "undefined") {
+                try {
+                    sessionStorage.removeItem("gunSessionData");
+                    sessionStorage.removeItem("gunUserData");
+                }
+                catch (error) {
+                    console.warn("Error clearing session storage:", error);
+                }
+            }
+            console.log("Fresh authentication context created");
+        }
+        catch (error) {
+            console.error("Error creating fresh auth context:", error);
+        }
+    }
+    /**
+     * Setup cleanup handlers for memory leak prevention
+     */
+    setupCleanupHandlers() {
+        // Handle process cleanup
+        if (typeof process !== "undefined") {
+            process.on("SIGINT", () => this.destroy());
+            process.on("SIGTERM", () => this.destroy());
+            process.on("exit", () => this.destroy());
+        }
+    }
+    /**
+     * Safe interval wrapper that tracks intervals for cleanup
+     */
+    safeInterval(callback, delay) {
+        if (this._isDestroyed) {
+            return setInterval(() => { }, 0);
+        }
+        const interval = setInterval(() => {
+            if (!this._isDestroyed) {
+                callback();
+            }
+        }, delay);
+        this._activeIntervals.add(interval);
+        return interval;
+    }
+    /**
+     * Clear a specific timeout
+     */
+    clearSafeTimeout(timeout) {
+        clearTimeout(timeout);
+        this._activeTimeouts.delete(timeout);
+    }
+    /**
+     * Clear a specific interval
+     */
+    clearSafeInterval(interval) {
+        clearInterval(interval);
+        this._activeIntervals.delete(interval);
+    }
+    /**
+     * Destroy the database instance and clean up all resources
+     */
+    destroy() {
+        if (this._isDestroyed) {
+            return;
+        }
+        console.log("[DB] Destroying DataBase instance...");
+        this._isDestroyed = true;
+        // Clear all timeouts
+        this._activeTimeouts.forEach((timeout) => {
+            clearTimeout(timeout);
+        });
+        this._activeTimeouts.clear();
+        // Clear all intervals
+        this._activeIntervals.forEach((interval) => {
+            clearInterval(interval);
+        });
+        this._activeIntervals.clear();
+        // Clear event listeners
+        this.eventEmitter.removeAllListeners();
+        // Clear auth callbacks
+        this.onAuthCallbacks.length = 0;
+        // Clear Gun user
+        if (this.user) {
+            try {
+                this.user.leave();
+            }
+            catch (error) {
+                console.warn("Error during user leave:", error);
+            }
+            this.user = null;
+        }
+        // Clear Gun instance references
+        if (this.gun) {
+            try {
+                // Clear any Gun event listeners if available
+                if (typeof this.gun.off === "function") {
+                    this.gun.off();
+                }
+            }
+            catch (error) {
+                console.warn("Error clearing Gun listeners:", error);
+            }
+        }
+        // Clear other references
+        this._rxjs = undefined;
+        this._cryptoIdentityManager = undefined;
+        this.core = undefined;
+        console.log("[DB] DataBase instance destroyed");
+    }
 }
 exports.DataBase = DataBase;
 // Errors
 DataBase.Errors = GunErrors;
-const createGun = (config) => {
-    const gunInstance = (0, gun_1.default)(config);
-    return gunInstance;
-};
-exports.createGun = createGun;
-exports.default = gun_1.default;