shogun-core 5.2.2 → 5.3.0

package/dist/browser/shogun-core.js

@@ -149954,7 +149954,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");
@@ -150403,6 +150403,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);
@@ -150541,6 +150545,8 @@ class DataBase {
             this.gun.user().create(normalizedUsername, password, (ack) => {
                 if (ack.err) {
                     console.error(`User creation error: ${ack.err}`);
+                    // Reset auth state after failed creation to prevent blocking future operations
+                    this.resetAuthState();
                     resolve({ success: false, error: ack.err });
                 }
                 else {
@@ -150593,6 +150599,8 @@ class DataBase {
                 this.gun.user().auth(pair, (ack) => {
                     if (ack.err) {
                         console.error(`Authentication after creation failed: ${ack.err}`);
+                        // Reset auth state on error to prevent blocking future operations
+                        this.resetAuthState();
                         resolve({ success: false, error: ack.err });
                     }
                     else {
@@ -150618,6 +150626,8 @@ class DataBase {
                 this.gun.user().auth(normalizedUsername, password, (ack) => {
                     if (ack.err) {
                         console.error(`Authentication after creation failed: ${ack.err}`);
+                        // Reset auth state on error to prevent blocking future operations
+                        this.resetAuthState();
                         resolve({ success: false, error: ack.err });
                     }
                     else {
@@ -150648,13 +150658,33 @@ 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 {
             // 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
@@ -150665,6 +150695,8 @@ class DataBase {
                 createResult = await this.createNewUser(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
@@ -151279,33 +151311,134 @@ class DataBase {
         }
     }
     /**
-     * Performs authentication with Gun
+     * Resets Gun.js authentication state to allow new auth operations
      */
-    async performAuthentication(username, password, pair) {
+    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, 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 = 15000; // 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
@@ -151339,9 +151472,28 @@ class DataBase {
         try {
             const loginResult = await this.performAuthentication(username, password, pair);
             if (!loginResult.success) {
+                // Provide more specific error messages based on the error type
+                let errorMessage = `User '${username}' not found. Please check your username or register first.`;
+                if (loginResult.error) {
+                    if (loginResult.error.includes("already being created or authenticated")) {
+                        errorMessage =
+                            "Authentication is already in progress. Please wait and try again.";
+                    }
+                    else if (loginResult.error.includes("Wrong user or password")) {
+                        errorMessage =
+                            "Invalid username or password. Please check your credentials.";
+                    }
+                    else if (loginResult.error.includes("User already created")) {
+                        errorMessage =
+                            "User already exists. Please try logging in instead.";
+                    }
+                    else {
+                        errorMessage = loginResult.error;
+                    }
+                }
                 return {
                     success: false,
-                    error: `User '${username}' not found. Please check your username or register first.`,
+                    error: errorMessage,
                 };
             }
             // Add a small delay to ensure user state is properly set
@@ -151760,6 +151912,128 @@ 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);
+        }
+    }
 }
 exports.DataBase = DataBase;
 // Errors
@@ -153286,8 +153560,9 @@ const errorHandler_1 = __webpack_require__(/*! ../utils/errorHandler */ "./src/u
  * Genera automaticamente tutte le identità crypto disponibili dopo l'autenticazione SEA
  */
 class CryptoIdentityManager {
-    constructor(core) {
+    constructor(core, db) {
         this.core = core;
+        this.db = db;
         this.pgpManager = new pgp_1.PGPManager();
         this.mlsManager = new mls_1.MLSManager("default-user");
         this.sframeManager = new sframe_1.SFrameManager();
@@ -153409,7 +153684,7 @@ class CryptoIdentityManager {
             }
             // Salva su GunDB nel percorso privato dell'utente
             const saveResult = await new Promise((resolve, reject) => {
-                this.core.gun
+                this.db.gun
                     .user()
                     .get("crypto-identities")
                     .put(encryptedIdentities, (ack) => {
@@ -153429,7 +153704,7 @@ class CryptoIdentityManager {
                 name: "SHA-256",
             });
             await new Promise((resolve, reject) => {
-                this.core.gun
+                this.db.gun
                     .user()
                     .get("crypto-identities-hash")
                     .put(identitiesHash, (ack) => {
@@ -153470,7 +153745,7 @@ class CryptoIdentityManager {
             console.log(`🔍 [CryptoIdentityManager] Retrieving crypto identities for: ${username}`);
             // Recupera le identità criptate da GunDB
             const encryptedIdentities = await new Promise((resolve, reject) => {
-                this.core.gun
+                this.db.gun
                     .user()
                     .get("crypto-identities")
                     .once((data) => {
@@ -153522,7 +153797,7 @@ class CryptoIdentityManager {
     async hasStoredIdentities(username) {
         try {
             const hasIdentities = await new Promise((resolve) => {
-                this.core.gun
+                this.db.gun
                     .user()
                     .get("crypto-identities")
                     .once((data) => {
@@ -153609,7 +153884,7 @@ class CryptoIdentityManager {
                 };
             }
             // Ottieni il SEA pair dell'utente corrente
-            const userInstance = this.core.gun.user();
+            const userInstance = this.db.gun.user();
             const seaPair = userInstance?._?.sea;
             if (!seaPair) {
                 return {