shogun-core 5.2.2 → 6.0.0

package/dist/browser/shogun-core.js

@@ -96755,9 +96755,15 @@ var AbstractRelay = class {
   publishTimeout = 4400;
   pingFrequency = 2e4;
   pingTimeout = 2e4;
+  resubscribeBackoff = [1e4, 1e4, 1e4, 2e4, 2e4, 3e4, 6e4];
   openSubs = /* @__PURE__ */ new Map();
   enablePing;
+  enableReconnect;
   connectionTimeoutHandle;
+  reconnectTimeoutHandle;
+  pingTimeoutHandle;
+  reconnectAttempts = 0;
+  closedIntentionally = false;
   connectionPromise;
   openCountRequests = /* @__PURE__ */ new Map();
   openEventPublishes = /* @__PURE__ */ new Map();
@@ -96774,6 +96780,7 @@ var AbstractRelay = class {
     this.verifyEvent = opts.verifyEvent;
     this._WebSocket = opts.websocketImplementation || WebSocket;
     this.enablePing = opts.enablePing;
+    this.enableReconnect = opts.enableReconnect || false;
   }
   static async connect(url, opts) {
     const relay = new AbstractRelay(url, opts);
@@ -96797,6 +96804,32 @@ var AbstractRelay = class {
   get connected() {
     return this._connected;
   }
+  async reconnect() {
+    const backoff = this.resubscribeBackoff[Math.min(this.reconnectAttempts, this.resubscribeBackoff.length - 1)];
+    this.reconnectAttempts++;
+    this.reconnectTimeoutHandle = setTimeout(async () => {
+      try {
+        await this.connect();
+      } catch (err) {
+      }
+    }, backoff);
+  }
+  handleHardClose(reason) {
+    if (this.pingTimeoutHandle) {
+      clearTimeout(this.pingTimeoutHandle);
+      this.pingTimeoutHandle = void 0;
+    }
+    this._connected = false;
+    this.connectionPromise = void 0;
+    const wasIntentional = this.closedIntentionally;
+    this.closedIntentionally = false;
+    this.onclose?.();
+    if (this.enableReconnect && !wasIntentional) {
+      this.reconnect();
+    } else {
+      this.closeAllSubscriptions(reason);
+    }
+  }
   async connect() {
     if (this.connectionPromise)
       return this.connectionPromise;
@@ -96817,8 +96850,20 @@ var AbstractRelay = class {
         return;
       }
       this.ws.onopen = () => {
+        if (this.reconnectTimeoutHandle) {
+          clearTimeout(this.reconnectTimeoutHandle);
+          this.reconnectTimeoutHandle = void 0;
+        }
         clearTimeout(this.connectionTimeoutHandle);
         this._connected = true;
+        this.reconnectAttempts = 0;
+        for (const sub of this.openSubs.values()) {
+          sub.eosed = false;
+          if (typeof this.enableReconnect === "function") {
+            sub.filters = this.enableReconnect(sub.filters);
+          }
+          sub.fire();
+        }
         if (this.enablePing) {
           this.pingpong();
         }
@@ -96827,28 +96872,22 @@ var AbstractRelay = class {
       this.ws.onerror = (ev) => {
         clearTimeout(this.connectionTimeoutHandle);
         reject(ev.message || "websocket error");
-        this._connected = false;
-        this.connectionPromise = void 0;
-        this.onclose?.();
-        this.closeAllSubscriptions("relay connection errored");
+        this.handleHardClose("relay connection errored");
       };
       this.ws.onclose = (ev) => {
         clearTimeout(this.connectionTimeoutHandle);
         reject(ev.message || "websocket closed");
-        this._connected = false;
-        this.connectionPromise = void 0;
-        this.onclose?.();
-        this.closeAllSubscriptions("relay connection closed");
+        this.handleHardClose("relay connection closed");
       };
       this.ws.onmessage = this._onmessage.bind(this);
     });
     return this.connectionPromise;
   }
-  async waitForPingPong() {
-    return new Promise((res, err) => {
+  waitForPingPong() {
+    return new Promise((resolve) => {
       ;
-      this.ws && this.ws.on && this.ws.on("pong", () => res(true)) || err("ws can't listen for pong");
-      this.ws && this.ws.ping && this.ws.ping();
+      this.ws.once("pong", () => resolve(true));
+      this.ws.ping();
     });
   }
   async waitForDummyReq() {
@@ -96865,16 +96904,15 @@ var AbstractRelay = class {
   async pingpong() {
     if (this.ws?.readyState === 1) {
       const result = await Promise.any([
-        this.ws && this.ws.ping && this.ws.on ? this.waitForPingPong() : this.waitForDummyReq(),
+        this.ws && this.ws.ping && this.ws.once ? this.waitForPingPong() : this.waitForDummyReq(),
         new Promise((res) => setTimeout(() => res(false), this.pingTimeout))
       ]);
       if (result) {
-        setTimeout(() => this.pingpong(), this.pingFrequency);
+        this.pingTimeoutHandle = setTimeout(() => this.pingpong(), this.pingFrequency);
       } else {
-        this.closeAllSubscriptions("pingpong timed out");
-        this._connected = false;
-        this.onclose?.();
-        this.ws?.close();
+        if (this.ws?.readyState === this._WebSocket.OPEN) {
+          this.ws?.close();
+        }
       }
     }
   }
@@ -97037,10 +97075,21 @@ var AbstractRelay = class {
     return subscription;
   }
   close() {
+    this.closedIntentionally = true;
+    if (this.reconnectTimeoutHandle) {
+      clearTimeout(this.reconnectTimeoutHandle);
+      this.reconnectTimeoutHandle = void 0;
+    }
+    if (this.pingTimeoutHandle) {
+      clearTimeout(this.pingTimeoutHandle);
+      this.pingTimeoutHandle = void 0;
+    }
     this.closeAllSubscriptions("relay connection closed by us");
     this._connected = false;
     this.onclose?.();
-    this.ws?.close();
+    if (this.ws?.readyState === this._WebSocket.OPEN) {
+      this.ws?.close();
+    }
   }
   _onmessage(ev) {
     this.incomingMessageQueue.enqueue(ev.data);
@@ -97113,11 +97162,11 @@ try {
 } catch {
 }
 var Relay = class extends AbstractRelay {
-  constructor(url) {
-    super(url, { verifyEvent, websocketImplementation: _WebSocket });
+  constructor(url, options) {
+    super(url, { verifyEvent, websocketImplementation: _WebSocket, ...options });
   }
-  static async connect(url) {
-    const relay = new Relay(url);
+  static async connect(url, options) {
+    const relay = new Relay(url, options);
     await relay.connect();
     return relay;
   }
@@ -97130,12 +97179,14 @@ var AbstractSimplePool = class {
   trackRelays = false;
   verifyEvent;
   enablePing;
+  enableReconnect;
   trustedRelayURLs = /* @__PURE__ */ new Set();
   _WebSocket;
   constructor(opts) {
     this.verifyEvent = opts.verifyEvent;
     this._WebSocket = opts.websocketImplementation;
     this.enablePing = opts.enablePing;
+    this.enableReconnect = opts.enableReconnect;
   }
   async ensureRelay(url, params) {
     url = normalizeURL(url);
@@ -97144,10 +97195,13 @@ var AbstractSimplePool = class {
       relay = new AbstractRelay(url, {
         verifyEvent: this.trustedRelayURLs.has(url) ? alwaysTrue : this.verifyEvent,
         websocketImplementation: this._WebSocket,
-        enablePing: this.enablePing
+        enablePing: this.enablePing,
+        enableReconnect: this.enableReconnect
       });
       relay.onclose = () => {
-        this.relays.delete(url);
+        if (relay && !relay.enableReconnect) {
+          this.relays.delete(url);
+        }
       };
       if (params?.connectionTimeout)
         relay.connectionTimeout = params.connectionTimeout;
@@ -98642,13 +98696,13 @@ async function getZapEndpoint(metadata) {
   try {
     let lnurl = "";
     let { lud06, lud16 } = JSON.parse(metadata.content);
-    if (lud06) {
+    if (lud16) {
+      let [name, domain] = lud16.split("@");
+      lnurl = new URL(`/.well-known/lnurlp/${name}`, `https://${domain}`).toString();
+    } else if (lud06) {
       let { words } = import_base4.bech32.decode(lud06, 1e3);
       let data = import_base4.bech32.fromWords(words);
       lnurl = utf8Decoder.decode(data);
-    } else if (lud16) {
-      let [name, domain] = lud16.split("@");
-      lnurl = new URL(`/.well-known/lnurlp/${name}`, `https://${domain}`).toString();
     } else {
       return null;
     }
@@ -145094,38 +145148,101 @@ module.exports = function whichTypedArray(value) {
 /*!*****************************************!*\
   !*** ./src/config/simplified-config.ts ***!
   \*****************************************/
-/***/ ((__unused_webpack_module, exports) => {
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 
 /**
  * Simplified configuration options to reduce complexity
  * Provides sensible defaults and easy-to-use presets
+ *
+ * NOTE: This file is deprecated. ShogunCore now requires an existing Gun instance.
+ * Use the examples in the examples/ directory for proper usage.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.QuickConfig = exports.ConfigHelpers = exports.ShogunConfigBuilder = exports.ShogunPresets = void 0;
+exports.QuickConfig = exports.ConfigHelpers = exports.ShogunConfigBuilder = exports.ShogunPresets = exports.GunInstanceHelpers = void 0;
+const gun_1 = __importDefault(__webpack_require__(/*! gun/gun */ "./node_modules/gun/gun.js"));
+__webpack_require__(/*! gun/lib/then */ "./node_modules/gun/lib/then.js");
+__webpack_require__(/*! gun/lib/radix */ "./node_modules/gun/lib/radix.js");
+__webpack_require__(/*! gun/lib/radisk */ "./node_modules/gun/lib/radisk.js");
+__webpack_require__(/*! gun/lib/store */ "./node_modules/gun/lib/store.js");
+__webpack_require__(/*! gun/lib/rindexed */ "./node_modules/gun/lib/rindexed.js");
+__webpack_require__(/*! gun/lib/webrtc */ "./node_modules/gun/lib/webrtc.js");
+/**
+ * Helper functions to create Gun instances with common configurations
+ * These functions create Gun instances that can be passed to ShogunCore
+ */
+exports.GunInstanceHelpers = {
+    /**
+     * Create a minimal Gun instance for simple apps
+     */
+    minimal: () => (0, gun_1.default)({
+        peers: ["https://shogunnode.scobrudot.dev/gun"],
+        localStorage: true,
+    }),
+    /**
+     * Create a development Gun instance with local storage
+     */
+    development: () => (0, gun_1.default)({
+        peers: ["https://shogunnode.scobrudot.dev/gun"],
+        localStorage: true,
+        radisk: false,
+    }),
+    /**
+     * Create a production Gun instance with multiple peers
+     */
+    production: (customPeers) => (0, gun_1.default)({
+        peers: customPeers || [
+            "https://shogunnode.scobrudot.dev/gun",
+            "https://peer.wallie.io/gun",
+        ],
+        localStorage: true,
+        radisk: true,
+    }),
+    /**
+     * Create an offline-first Gun instance
+     */
+    offline: () => (0, gun_1.default)({
+        peers: [],
+        localStorage: true,
+        radisk: true,
+    }),
+    /**
+     * Create a Gun instance for Web3-enabled apps
+     */
+    web3: () => (0, gun_1.default)({
+        peers: ["https://shogunnode.scobrudot.dev/gun"],
+        localStorage: true,
+    }),
+    /**
+     * Create a Gun instance for WebAuthn-enabled apps
+     */
+    webauthn: () => (0, gun_1.default)({
+        peers: ["https://shogunnode.scobrudot.dev/gun"],
+        localStorage: true,
+    }),
+};
 /**
  * Preset configurations for common use cases
+ * @deprecated Use GunInstanceHelpers to create Gun instances and pass them to ShogunCore
  */
 exports.ShogunPresets = {
     /**
      * Minimal configuration for simple apps
+     * @deprecated Use GunInstanceHelpers.minimal() instead
      */
     minimal: () => ({
-        gunOptions: {
-            peers: ["https://relay.shogun-eco.xyz/gun"],
-            localStorage: true,
-        },
+        gunInstance: exports.GunInstanceHelpers.minimal(),
     }),
     /**
      * Development configuration with local storage
+     * @deprecated Use GunInstanceHelpers.development() instead
      */
     development: () => ({
-        gunOptions: {
-            peers: ["https://relay.shogun-eco.xyz/gun"],
-            localStorage: true,
-            radisk: false,
-        },
+        gunInstance: exports.GunInstanceHelpers.development(),
         timeouts: {
             login: 5000,
             signup: 5000,
@@ -145134,16 +145251,10 @@ exports.ShogunPresets = {
     }),
     /**
      * Production configuration with multiple peers
+     * @deprecated Use GunInstanceHelpers.production() instead
      */
     production: (customPeers) => ({
-        gunOptions: {
-            peers: customPeers || [
-                "https://relay.shogun-eco.xyz/gun",
-                "https://peer.wallie.io/gun",
-            ],
-            localStorage: true,
-            radisk: true,
-        },
+        gunInstance: exports.GunInstanceHelpers.production(customPeers),
         timeouts: {
             login: 10000,
             signup: 10000,
@@ -145152,62 +145263,59 @@ exports.ShogunPresets = {
     }),
     /**
      * Offline-first configuration
+     * @deprecated Use GunInstanceHelpers.offline() instead
      */
     offline: () => ({
-        gunOptions: {
-            peers: [],
-            localStorage: true,
-            radisk: true,
-        },
+        gunInstance: exports.GunInstanceHelpers.offline(),
     }),
     /**
      * Web3-enabled configuration
+     * @deprecated Use GunInstanceHelpers.web3() instead
      */
     web3: () => ({
-        gunOptions: {
-            peers: ["https://relay.shogun-eco.xyz/gun"],
-            localStorage: true,
-        },
+        gunInstance: exports.GunInstanceHelpers.web3(),
         web3: {
             enabled: true,
         },
     }),
     /**
      * WebAuthn-enabled configuration
+     * @deprecated Use GunInstanceHelpers.webauthn() instead
      */
     webauthn: () => ({
-        gunOptions: {
-            peers: ["https://relay.shogun-eco.xyz/gun"],
-            localStorage: true,
-        },
+        gunInstance: exports.GunInstanceHelpers.webauthn(),
         webauthn: {
             enabled: true,
             rpName: "My Shogun App",
-            rpId: window.location.hostname,
+            rpId:  true ? window.location.hostname : 0,
         },
     }),
 };
 /**
  * Configuration builder for custom setups
+ * @deprecated Use GunInstanceHelpers to create Gun instances and pass them to ShogunCore
  */
 class ShogunConfigBuilder {
     constructor() {
         this.config = {};
+        this.gunOptions = {};
     }
     /**
-     * Set Gun options
+     * Set Gun options (deprecated - use GunInstanceHelpers instead)
+     * @deprecated Use GunInstanceHelpers to create Gun instances
      */
-    gunOptions(options) {
-        this.config.gunOptions = { ...this.config.gunOptions, ...options };
+    setGunOptions(options) {
+        this.gunOptions = { ...this.gunOptions, ...options };
         return this;
     }
     /**
-     * Add peers
+     * Add peers (deprecated - use GunInstanceHelpers instead)
+     * @deprecated Use GunInstanceHelpers to create Gun instances
      */
     peers(peerList) {
-        this.config.gunOptions = {
-            ...this.config.gunOptions,
-            peers: [...(this.config.gunOptions?.peers || []), ...peerList],
+        this.gunOptions = {
+            ...this.gunOptions,
+            peers: [...(this.gunOptions?.peers || []), ...peerList],
         };
         return this;
     }
@@ -145245,18 +145353,24 @@ class ShogunConfigBuilder {
     }
     /**
      * Build the final configuration
+     * @deprecated Use GunInstanceHelpers to create Gun instances and pass them to ShogunCore
      */
     build() {
-        return this.config;
+        return {
+            ...this.config,
+            gunInstance: (0, gun_1.default)(this.gunOptions),
+        };
     }
 }
 exports.ShogunConfigBuilder = ShogunConfigBuilder;
 /**
  * Helper functions for common configuration patterns
+ * @deprecated Use GunInstanceHelpers to create Gun instances and pass them to ShogunCore
  */
 exports.ConfigHelpers = {
     /**
      * Create a configuration for a specific environment
+     * @deprecated Use GunInstanceHelpers instead
      */
     forEnvironment(env) {
         switch (env) {
@@ -145272,12 +145386,14 @@ exports.ConfigHelpers = {
     },
     /**
      * Create a configuration with custom peers
+     * @deprecated Use GunInstanceHelpers.production(peers) instead
      */
     withPeers(peers) {
         return exports.ShogunPresets.production(peers);
     },
     /**
      * Create a configuration for a specific use case
+     * @deprecated Use GunInstanceHelpers instead
      */
     forUseCase(useCase) {
         const baseConfig = exports.ShogunPresets.production();
@@ -145310,26 +145426,32 @@ exports.ConfigHelpers = {
 };
 /**
  * Quick configuration functions
+ * @deprecated Use GunInstanceHelpers to create Gun instances and pass them to ShogunCore
  */
 exports.QuickConfig = {
     /**
      * Minimal setup for quick testing
+     * @deprecated Use GunInstanceHelpers.minimal() instead
      */
     test: () => exports.ShogunPresets.minimal(),
     /**
      * Standard setup for most apps
+     * @deprecated Use GunInstanceHelpers.production() instead
      */
     standard: () => exports.ShogunPresets.production(),
     /**
      * Setup with WebAuthn for secure apps
+     * @deprecated Use GunInstanceHelpers.webauthn() instead
      */
     secure: () => exports.ShogunPresets.webauthn(),
     /**
      * Setup with Web3 for crypto apps
+     * @deprecated Use GunInstanceHelpers.web3() instead
      */
     crypto: () => exports.ShogunPresets.web3(),
     /**
      * Offline setup for local development
+     * @deprecated Use GunInstanceHelpers.offline() instead
      */
     local: () => exports.ShogunPresets.offline(),
 };
@@ -146898,7 +147020,9 @@ class MLSManager {
             console.group("🔍 [MLS Debug] Commit Structure");
             console.log("commitResult keys:", Object.keys(commitResult));
             console.log("commit:", commitResult.commit);
-            console.log("commit.privateMessage:", commitResult.commit?.privateMessage);
+            if (commitResult.commit?.wireformat === "mls_private_message") {
+                console.log("commit.privateMessage:", commitResult.commit.privateMessage);
+            }
             console.groupEnd();
             // RFC 9420 Section 11.2: Commit Distribution
             // ⚠️ IMPORTANT: The returned commit MUST be sent to all existing group members
@@ -146962,8 +147086,8 @@ class MLSManager {
                     else {
                         console.log(`  Node ${i}:`, {
                             type: typeof node,
-                            isObject: typeof node === "object",
-                            hasNodeType: node && typeof node === "object" && "nodeType" in node,
+                            isObject: typeof node === "object" && node !== null,
+                            hasNodeType: typeof node === "object" && node !== null && "nodeType" in node,
                             nodeType: node?.nodeType,
                             keys: node && typeof node === "object"
                                 ? Object.keys(node).slice(0, 5)
@@ -147040,10 +147164,11 @@ class MLSManager {
             }
             // Decode the message
             const decoded = (0, ts_mls_1.decodeMlsMessage)(envelope.ciphertext, 0);
-            if (!decoded) {
+            if (!decoded || decoded.length === 0) {
+                // Changed from 0n to 0 to fix type error
                 throw new Error("Failed to decode message");
             }
-            const [decodedMessage] = decoded;
+            const decodedMessage = decoded[0];
             if (decodedMessage.wireformat !== "mls_private_message") {
                 throw new Error("Expected private message");
             }
@@ -147149,7 +147274,7 @@ class MLSManager {
         }
         catch (error) {
             console.error("❌ [MLS] Failed to process commit:", error);
-            console.error("❌ [MLS Debug] Error details:", error instanceof Error ? error.stack : "No stack trace");
+            console.error("❌ [MLS Debug] Error details:", error instanceof Error ? error.stack : String(error));
             console.error("❌ [MLS Debug] Error message:", error instanceof Error ? error.message : String(error));
             throw new Error(`Commit processing failed: ${error instanceof Error ? error.message : String(error)}`);
         }
@@ -147169,7 +147294,7 @@ class MLSManager {
             const removeProposals = memberIndices.map((index) => ({
                 proposalType: "remove",
                 remove: {
-                    removed: index, // ts-mls expects number, not BigInt
+                    removed: index, // Changed from BigInt(index) to number
                 },
             }));
             // Create commit with remove proposals
@@ -147177,11 +147302,21 @@ class MLSManager {
             // Update group state
             this.groups.set(groupId, commitResult.newState);
             // Encode the commit
-            const encodedCommit = (0, ts_mls_1.encodeMlsMessage)({
-                publicMessage: commitResult.publicMessage,
-                wireformat: "mls_public_message",
-                version: "mls10",
-            });
+            let encodedCommit;
+            if (commitResult.commit &&
+                commitResult.commit.wireformat === "mls_public_message") {
+                encodedCommit = (0, ts_mls_1.encodeMlsMessage)({
+                    publicMessage: commitResult.commit
+                        .publicMessage,
+                    wireformat: "mls_public_message",
+                    version: "mls10",
+                });
+            }
+            else {
+                // Fallback or error handling if not a public message
+                // For now, we'll assume it should be public for remove operation.
+                throw new Error("Commit result does not contain a public message for encoding.");
+            }
             console.log("✅ [MLS] Members removed");
             return encodedCommit;
         }
@@ -147274,9 +147409,15 @@ class MLSManager {
                 const node = state.ratchetTree[i];
                 if (node &&
                     node.nodeType === "leaf" &&
-                    node.leaf?.credential) {
-                    const identity = new TextDecoder().decode(node.leaf.credential.identity);
-                    members.push(identity);
+                    node.leaf.credential) {
+                    const credential = node.leaf.credential;
+                    if (credential.credentialType === "basic" && credential.identity) {
+                        const identity = new TextDecoder().decode(credential.identity);
+                        members.push(identity);
+                    }
+                    else {
+                        console.warn("Skipping credential without basic identity:", credential);
+                    }
                 }
             }
         }
@@ -148181,6 +148322,13 @@ class SFrameManager {
             throw new Error(`SFrame key derivation failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Set a shared SFrame key (e.g., from another member)
+     */
+    async setSharedKey(sframeKey) {
+        this.keys.set(sframeKey.keyId, sframeKey);
+        console.log(`✅ [SFrame] Shared key ${sframeKey.keyId} set.`);
+    }
     /**
      * Set the active encryption key
      */
@@ -148226,11 +148374,9 @@ class SFrameManager {
                 tagLength: 128, // 128-bit authentication tag
             }, sframeKey.key, frameData);
             // RFC 9605: SFrame format = header + ciphertext (IV is derived, not transmitted)
-            // Note: We include IV for now for simplicity, but RFC specifies deriving it from counter
-            const encrypted = new Uint8Array(header.length + iv.length + ciphertext.byteLength);
+            const encrypted = new Uint8Array(header.length + ciphertext.byteLength);
             encrypted.set(header, 0);
-            encrypted.set(iv, header.length);
-            encrypted.set(new Uint8Array(ciphertext), header.length + iv.length);
+            encrypted.set(new Uint8Array(ciphertext), header.length);
             // Increment frame counter
             this.frameCounter++;
             return encrypted;
@@ -148255,20 +148401,17 @@ class SFrameManager {
             if (!sframeKey) {
                 throw new Error(`SFrame key ${keyId} not found`);
             }
-            // Extract IV (12 bytes after header)
-            const iv = encryptedFrame.slice(5, 17);
-            // RFC 9605: Verify IV derivation (optional check for debugging)
-            // Reconstruct expected IV from frame count and salt
+            // RFC 9605: IV is derived from frame count and salt (not transmitted)
             const counterBytes = new Uint8Array(12);
             const counterView = new DataView(counterBytes.buffer);
             counterView.setUint32(4, Math.floor(frameCount / 0x100000000), false);
             counterView.setUint32(8, frameCount & 0xffffffff, false);
-            const expectedIV = new Uint8Array(12);
+            const iv = new Uint8Array(12);
             for (let i = 0; i < 12; i++) {
-                expectedIV[i] = sframeKey.salt[i] ^ counterBytes[i];
+                iv[i] = sframeKey.salt[i] ^ counterBytes[i];
             }
             // Extract ciphertext (rest of the data)
-            const ciphertext = encryptedFrame.slice(17);
+            const ciphertext = encryptedFrame.slice(header.length);
             // Decrypt the frame with header authentication (RFC 9605 Section 4.3)
             const plaintext = await crypto.subtle.decrypt({
                 name: "AES-GCM",
@@ -149170,7 +149313,8 @@ class SimpleGunAPI {
         console.warn("DEPRECATED: putArray() is unreliable with GunDB. Use direct GunDB operations instead.");
         try {
             const indexed = this.arrayToIndexedObject(arr);
-            await this.db.put(path, indexed);
+            const node = this.db.getNode(path);
+            node.put(indexed);
             return true;
         }
         catch (error) {
@@ -149187,7 +149331,14 @@ class SimpleGunAPI {
     async getArray(path) {
         console.warn("DEPRECATED: getArray() is unreliable with GunDB. Use direct GunDB operations instead.");
         try {
-            const indexedObj = await this.db.getData(path);
+            const node = this.db.getNode(path);
+            const indexedObj = await new Promise((resolve) => {
+                const timeout = setTimeout(() => resolve(null), 2000);
+                node.once((data) => {
+                    clearTimeout(timeout);
+                    resolve(data);
+                });
+            });
             return this.indexedObjectToArray(indexedObj);
         }
         catch (error) {
@@ -149472,19 +149623,12 @@ class QuickStart {
 }
 exports.QuickStart = QuickStart;
 /**
- * Auto Quick Start helper - creates a simple API with automatic Gun instance creation
- * No need to pass a Gun instance, it creates one automatically
+ * Auto Quick Start helper - creates a simple API with an existing Gun instance
+ * Requires a Gun instance to be passed in
  */
 class AutoQuickStart {
-    constructor(config) {
-        const gunConfig = {
-            peers: config?.peers || [],
-            ...config,
-        };
-        // Remove appScope from gunConfig as it's not a Gun configuration option
-        delete gunConfig.appScope;
-        this.gunInstance = (0, db_1.createGun)(gunConfig);
-        const appScope = config?.appScope || "shogun";
+    constructor(gunInstance, appScope = "shogun") {
+        this.gunInstance = gunInstance;
         this.db = new db_1.DataBase(this.gunInstance, appScope);
         this.simpleAPI = new SimpleGunAPI(this.db);
     }
@@ -149513,10 +149657,10 @@ function quickStart(gunInstance, appScope) {
     return new QuickStart(gunInstance, appScope);
 }
 /**
- * Global helper for auto quick setup - creates Gun instance automatically
+ * Global helper for auto quick setup - requires existing Gun instance
  */
-function autoQuickStart(config) {
-    return new AutoQuickStart(config);
+function autoQuickStart(gunInstance, appScope = "shogun") {
+    return new AutoQuickStart(gunInstance, appScope);
 }
 
 
@@ -149823,6 +149967,7 @@ function randomUUID() {
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
+/* provided dependency */ var process = __webpack_require__(/*! process/browser */ "./node_modules/process/browser.js");
 
 /**
  * GunDB class with enhanced features:
@@ -149867,17 +150012,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(__webpack_require__(/*! gun/gun */ "./node_modules/gun/gun.js"));
-exports.Gun = gun_1.default;
+exports.derive = exports.GunErrors = exports.crypto = exports.RxJS = exports.SEA = exports.DataBase = void 0;
 const sea_1 = __importDefault(__webpack_require__(/*! gun/sea */ "./node_modules/gun/sea.js"));
 exports.SEA = sea_1.default;
-__webpack_require__(/*! gun/lib/then */ "./node_modules/gun/lib/then.js");
-__webpack_require__(/*! gun/lib/radix */ "./node_modules/gun/lib/radix.js");
-__webpack_require__(/*! gun/lib/radisk */ "./node_modules/gun/lib/radisk.js");
-__webpack_require__(/*! gun/lib/store */ "./node_modules/gun/lib/store.js");
-__webpack_require__(/*! gun/lib/rindexed */ "./node_modules/gun/lib/rindexed.js");
-__webpack_require__(/*! gun/lib/webrtc */ "./node_modules/gun/lib/webrtc.js");
 const derive_1 = __importDefault(__webpack_require__(/*! ./derive */ "./src/gundb/derive.ts"));
 exports.derive = derive_1.default;
 const errorHandler_1 = __webpack_require__(/*! ../utils/errorHandler */ "./src/utils/errorHandler.ts");
@@ -149908,11 +150045,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");
@@ -149954,7 +150097,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");
@@ -150206,46 +150349,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
@@ -150403,6 +150526,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);
@@ -150511,136 +150638,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
@@ -150648,13 +150645,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
@@ -150662,15 +150680,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 };
             }
@@ -150747,6 +150767,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 {
@@ -150782,7 +150896,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
@@ -150801,8 +150915,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);
@@ -150820,7 +150936,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,
@@ -150929,28 +151050,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}`);
@@ -150962,20 +151068,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}`);
@@ -150994,20 +151093,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}`);
@@ -151019,18 +151111,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}`);
@@ -151042,20 +151129,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}`);
@@ -151073,17 +151153,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}`);
@@ -151103,7 +151179,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) {
@@ -151119,10 +151195,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) {
@@ -151152,7 +151233,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,
@@ -151168,7 +151249,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,
@@ -151199,7 +151280,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) {
@@ -151217,7 +151306,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) {
@@ -151256,19 +151353,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);
@@ -151279,33 +151371,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 = 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
@@ -151337,18 +151530,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;
             }
@@ -151358,7 +151567,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,
@@ -151519,14 +151728,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) {
@@ -151542,19 +151757,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",
@@ -151616,6 +151894,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
@@ -151760,16 +152139,223 @@ 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;
 
 
 /***/ }),
@@ -152654,10 +153240,10 @@ Object.defineProperty(exports, "quickStart", ({ enumerable: true, get: function
 Object.defineProperty(exports, "createSimpleAPI", ({ enumerable: true, get: function () { return gundb_1.createSimpleAPI; } }));
 Object.defineProperty(exports, "AutoQuickStart", ({ enumerable: true, get: function () { return gundb_1.AutoQuickStart; } }));
 Object.defineProperty(exports, "autoQuickStart", ({ enumerable: true, get: function () { return gundb_1.autoQuickStart; } }));
-const db_2 = __webpack_require__(/*! ./gundb/db */ "./src/gundb/db.ts");
-Object.defineProperty(exports, "SEA", ({ enumerable: true, get: function () { return db_2.SEA; } }));
-const db_3 = __importDefault(__webpack_require__(/*! ./gundb/db */ "./src/gundb/db.ts"));
-exports.Gun = db_3.default;
+const gun_1 = __importDefault(__webpack_require__(/*! gun */ "./node_modules/gun/gun.js"));
+exports.Gun = gun_1.default;
+const sea_1 = __importDefault(__webpack_require__(/*! gun/sea */ "./node_modules/gun/sea.js"));
+exports.SEA = sea_1.default;
 __exportStar(__webpack_require__(/*! ./utils/errorHandler */ "./src/utils/errorHandler.ts"), exports);
 __exportStar(__webpack_require__(/*! ./plugins */ "./src/plugins/index.ts"), exports);
 __exportStar(__webpack_require__(/*! ./interfaces/shogun */ "./src/interfaces/shogun.ts"), exports);
@@ -153086,38 +153672,43 @@ class CoreInitializer {
     /**
      * Initialize Gun instance
      */
-    // Sì, è corretto.
     initializeGun(config) {
         try {
-            if (config.gunInstance) {
-                console.log("Using existing Gun instance:", config.gunInstance);
-                this.core._gun = config.gunInstance;
+            if (!config.gunInstance) {
+                throw new Error("Gun instance is required but was not provided");
             }
-            else if (config.gunOptions && config.gunInstance === undefined) {
-                console.log("Creating Gun instance with config:", config.gunOptions);
-                this.core._gun = (0, gundb_1.createGun)(config.gunOptions);
+            // Validate Gun instance
+            if (typeof config.gunInstance !== "object") {
+                throw new Error(`Gun instance must be an object, received: ${typeof config.gunInstance}`);
             }
-            else if (config.gunInstance && config.gunOptions) {
-                throw new Error("Gun instance and gun options cannot be provided together");
-                // removed by dead control flow
-
+            if (typeof config.gunInstance.user !== "function") {
+                throw new Error(`Gun instance is invalid: gun.user is not a function. Received gun.user type: ${typeof config.gunInstance.user}`);
             }
+            if (typeof config.gunInstance.get !== "function") {
+                throw new Error(`Gun instance is invalid: gun.get is not a function. Received gun.get type: ${typeof config.gunInstance.get}`);
+            }
+            if (typeof config.gunInstance.on !== "function") {
+                throw new Error(`Gun instance is invalid: gun.on is not a function. Received gun.on type: ${typeof config.gunInstance.on}`);
+            }
+            console.log("Using provided Gun instance:", config.gunInstance);
+            this.core._gun = config.gunInstance;
         }
         catch (error) {
             if (typeof console !== "undefined" && console.error) {
-                console.error("Error creating Gun instance:", error);
+                console.error("Error validating Gun instance:", error);
             }
-            return false;
+            throw new Error(`Failed to validate Gun instance: ${error}`);
         }
         try {
-            this.core.db = new gundb_1.DataBase(this.core._gun, config.gunOptions?.scope || "", this.core);
+            this.core.db = new gundb_1.DataBase(this.core._gun, "shogun", // Default app scope
+            this.core);
             return true;
         }
         catch (error) {
             if (typeof console !== "undefined" && console.error) {
-                console.error("Error initializing GunInstance:", error);
+                console.error("Error initializing DataBase:", error);
             }
-            throw new Error(`Failed to initialize GunInstance: ${error}`);
+            throw new Error(`Failed to initialize DataBase: ${error}`);
         }
     }
     /**
@@ -153286,8 +153877,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 || core.db; // Use core.db if db not provided
         this.pgpManager = new pgp_1.PGPManager();
         this.mlsManager = new mls_1.MLSManager("default-user");
         this.sframeManager = new sframe_1.SFrameManager();
@@ -153374,6 +153966,11 @@ class CryptoIdentityManager {
                 console.error(`❌ [${username}] SFrame key generation failed:`, error);
             }
             console.log(`✅ [CryptoIdentityManager] All crypto identities generated for: ${username}`);
+            // Force garbage collection after generation
+            if (typeof __webpack_require__.g !== "undefined" && __webpack_require__.g.gc) {
+                __webpack_require__.g.gc();
+                console.log(`🧹 [${username}] Forced garbage collection after identity generation`);
+            }
             return {
                 success: true,
                 identities,
@@ -153409,41 +154006,76 @@ class CryptoIdentityManager {
             }
             // Salva su GunDB nel percorso privato dell'utente
             const saveResult = await new Promise((resolve, reject) => {
-                this.core.gun
-                    .user()
-                    .get("crypto-identities")
-                    .put(encryptedIdentities, (ack) => {
-                    if (ack.err) {
-                        console.error(`❌ [${username}] Failed to save identities:`, ack.err);
-                        reject(new Error(ack.err));
-                    }
-                    else {
-                        console.log(`✅ [${username}] Crypto identities saved successfully`);
-                        savedKeys.push("crypto-identities");
-                        resolve(true);
-                    }
-                });
+                const timeout = setTimeout(() => {
+                    console.warn(`⚠️ [${username}] Save identities timeout after 5 seconds, continuing anyway`);
+                    savedKeys.push("crypto-identities");
+                    resolve(true); // Resolve anyway to not block the process
+                }, 5000); // 5 second timeout
+                try {
+                    this.db.gun
+                        .user()
+                        .get("crypto-identities")
+                        .put(encryptedIdentities, (ack) => {
+                        clearTimeout(timeout);
+                        if (ack && ack.err) {
+                            console.error(`❌ [${username}] Failed to save identities:`, ack.err);
+                            reject(new Error(ack.err));
+                        }
+                        else {
+                            console.log(`✅ [${username}] Crypto identities saved successfully`);
+                            savedKeys.push("crypto-identities");
+                            resolve(true);
+                        }
+                    });
+                }
+                catch (putError) {
+                    clearTimeout(timeout);
+                    console.error(`❌ [${username}] Error during put operation:`, putError);
+                    // Don't reject, just resolve to not block - Gun might save eventually
+                    savedKeys.push("crypto-identities");
+                    resolve(true);
+                }
             });
             // Salva anche una copia di backup nel percorso pubblico (solo hash per verifica)
             const identitiesHash = await sea_1.default.work(identitiesJson, null, null, {
                 name: "SHA-256",
             });
             await new Promise((resolve, reject) => {
-                this.core.gun
-                    .user()
-                    .get("crypto-identities-hash")
-                    .put(identitiesHash, (ack) => {
-                    if (ack.err) {
-                        console.error(`❌ [${username}] Failed to save identities hash:`, ack.err);
-                        reject(new Error(ack.err));
-                    }
-                    else {
-                        console.log(`✅ [${username}] Crypto identities hash saved`);
-                        savedKeys.push("crypto-identities-hash");
-                        resolve(true);
-                    }
-                });
+                const timeout = setTimeout(() => {
+                    console.warn(`⚠️ [${username}] Save identities hash timeout after 5 seconds, continuing anyway`);
+                    savedKeys.push("crypto-identities-hash");
+                    resolve(true); // Resolve anyway to not block the process
+                }, 5000); // 5 second timeout
+                try {
+                    this.db.gun
+                        .user()
+                        .get("crypto-identities-hash")
+                        .put(identitiesHash, (ack) => {
+                        clearTimeout(timeout);
+                        if (ack && ack.err) {
+                            console.error(`❌ [${username}] Failed to save identities hash:`, ack.err);
+                            reject(new Error(ack.err));
+                        }
+                        else {
+                            console.log(`✅ [${username}] Crypto identities hash saved`);
+                            savedKeys.push("crypto-identities-hash");
+                            resolve(true);
+                        }
+                    });
+                }
+                catch (putError) {
+                    clearTimeout(timeout);
+                    console.error(`❌ [${username}] Error during hash put operation:`, putError);
+                    // Don't reject, just resolve to not block - Gun might save eventually
+                    savedKeys.push("crypto-identities-hash");
+                    resolve(true);
+                }
             });
+            // Force garbage collection after saving
+            if (typeof __webpack_require__.g !== "undefined" && __webpack_require__.g.gc) {
+                __webpack_require__.g.gc();
+                console.log(`🧹 [${username}] Forced garbage collection after saving identities`);
+            }
             return {
                 success: true,
                 savedKeys,
@@ -153470,7 +154102,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 +154154,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 +154241,13 @@ class CryptoIdentityManager {
                 };
             }
             // Ottieni il SEA pair dell'utente corrente
-            const userInstance = this.core.gun.user();
+            if (!this.db || !this.db.gun) {
+                return {
+                    success: false,
+                    error: "Database not available",
+                };
+            }
+            const userInstance = this.db.gun.user();
             const seaPair = userInstance?._?.sea;
             if (!seaPair) {
                 return {
@@ -158640,7 +159278,10 @@ class ZkCredentials {
             const externalNullifier = BigInt(ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(credentialData.type)));
             // Generate ZK proof
             // Note: This requires circuit files to be available
-            const fullProof = await (0, proof_1.generateProof)(identity, group, signalBigInt, externalNullifier);
+            const fullProof = await (0, proof_1.generateProof)(identity, group, signalBigInt, externalNullifier, {
+                wasmFilePath: "./circuits/semaphore/20/semaphore.wasm",
+                zkeyFilePath: "./circuits/semaphore/20/semaphore.zkey",
+            });
             return {
                 type: credentialData.type,
                 claim: credentialData.claim,