shogun-core 3.0.3 → 3.0.4

package/dist/gundb/db.js

@@ -1,1833 +0,0 @@
-/**
- * GunDB class with enhanced features:
- * - Dynamic peer linking
- * - Support for remove/unset operations
- * - Direct authentication through Gun.user()
- */
-import Gun from "gun/gun";
-import SEA from "gun/sea";
-import "gun/lib/then";
-import "gun/lib/radix";
-import "gun/lib/radisk";
-import "gun/lib/store";
-import "gun/lib/rindexed";
-import "gun/lib/webrtc";
-import "gun/lib/wire";
-import "gun/lib/axe";
-import { restrictedPut } from "./restricted-put";
-import derive from "./derive";
-import { ErrorHandler, ErrorType } from "../utils/errorHandler";
-import { EventEmitter } from "../utils/eventEmitter";
-import { RxJS } from "./rxjs";
-import * as GunErrors from "./errors";
-import * as crypto from "./crypto";
-/**
- * Configuration constants for timeouts and security
- */
-const CONFIG = {
-    TIMEOUTS: {
-        USER_DATA_OPERATION: 5000,
-    },
-    PASSWORD: {
-        MIN_LENGTH: 8,
-        REQUIRE_UPPERCASE: false,
-        REQUIRE_LOWERCASE: false,
-        REQUIRE_NUMBERS: false,
-        REQUIRE_SPECIAL_CHARS: false,
-    },
-};
-class DataBase {
-    gun;
-    user = null;
-    crypto;
-    sea;
-    node;
-    onAuthCallbacks = [];
-    eventEmitter;
-    // Integrated modules
-    _rxjs;
-    constructor(gun, appScope = "shogun") {
-        // Initialize event emitter
-        this.eventEmitter = new EventEmitter();
-        // Validate Gun instance
-        if (!gun) {
-            throw new Error("Gun instance is required but was not provided");
-        }
-        if (typeof gun !== "object") {
-            throw new Error(`Gun instance must be an object, received: ${typeof gun}`);
-        }
-        if (typeof gun.user !== "function") {
-            throw new Error(`Gun instance is invalid: gun.user is not a function. Received gun.user type: ${typeof gun.user}`);
-        }
-        if (typeof gun.get !== "function") {
-            throw new Error(`Gun instance is invalid: gun.get is not a function. Received gun.get type: ${typeof gun.get}`);
-        }
-        if (typeof gun.on !== "function") {
-            throw new Error(`Gun instance is invalid: gun.on is not a function. Received gun.on type: ${typeof gun.on}`);
-        }
-        this.gun = gun;
-        this.user = this.gun.user().recall({ sessionStorage: true });
-        this.subscribeToAuthEvents();
-        this.crypto = crypto;
-        this.sea = SEA;
-        this.node = null;
-    }
-    /**
-     * Initialize the GunInstance asynchronously
-     * This method should be called after construction to perform async operations
-     */
-    async initialize(appScope = "shogun") {
-        try {
-            const sessionResult = this.restoreSession();
-            this.node = this.gun.get(appScope);
-            if (sessionResult.success) {
-                // Session automatically restored
-            }
-            else {
-                // No previous session to restore
-            }
-        }
-        catch (error) {
-            console.error("Error during automatic session restoration:", error);
-        }
-    }
-    subscribeToAuthEvents() {
-        this.gun.on("auth", (ack) => {
-            // Auth event received
-            if (ack.err) {
-                ErrorHandler.handle(ErrorType.GUN, "AUTH_EVENT_ERROR", ack.err, new Error(ack.err));
-            }
-            else {
-                this.notifyAuthListeners(ack.sea?.pub || "");
-            }
-        });
-    }
-    notifyAuthListeners(pub) {
-        const user = this.gun.user();
-        this.onAuthCallbacks.forEach((cb) => cb(user));
-    }
-    /**
-     * Adds a new peer to the network
-     * @param peer URL of the peer to add
-     */
-    addPeer(peer) {
-        this.gun.opt({ peers: [peer] });
-        console.log(`Added new peer: ${peer}`);
-    }
-    /**
-     * Removes a peer from the network
-     * @param peer URL of the peer to remove
-     */
-    removePeer(peer) {
-        try {
-            // Get current peers from Gun instance
-            const gunOpts = this.gun._.opt;
-            if (gunOpts && gunOpts.peers) {
-                // Remove the peer from the peers object
-                delete gunOpts.peers[peer];
-                // Also try to close the connection if it exists
-                const peerConnection = gunOpts.peers[peer];
-                if (peerConnection && typeof peerConnection.close === "function") {
-                    peerConnection.close();
-                }
-                console.log(`Removed peer: ${peer}`);
-            }
-            else {
-                console.log(`Peer not found in current connections: ${peer}`);
-            }
-        }
-        catch (error) {
-            console.error(`Error removing peer ${peer}:`, error);
-        }
-    }
-    /**
-     * Gets the list of currently connected peers
-     * @returns Array of peer URLs
-     */
-    getCurrentPeers() {
-        try {
-            const gunOpts = this.gun._.opt;
-            if (gunOpts && gunOpts.peers) {
-                return Object.keys(gunOpts.peers).filter((peer) => {
-                    const peerObj = gunOpts.peers[peer];
-                    // Check if peer is actually connected (not just configured)
-                    return peerObj && peerObj.wire && peerObj.wire.hied !== "bye";
-                });
-            }
-            return [];
-        }
-        catch (error) {
-            console.error("Error getting current peers:", error);
-            return [];
-        }
-    }
-    /**
-     * Gets the list of all configured peers (connected and disconnected)
-     * @returns Array of peer URLs
-     */
-    getAllConfiguredPeers() {
-        try {
-            const gunOpts = this.gun._.opt;
-            if (gunOpts && gunOpts.peers) {
-                return Object.keys(gunOpts.peers);
-            }
-            return [];
-        }
-        catch (error) {
-            console.error("Error getting configured peers:", error);
-            return [];
-        }
-    }
-    /**
-     * Gets detailed information about all peers
-     * @returns Object with peer information
-     */
-    getPeerInfo() {
-        try {
-            const gunOpts = this.gun._.opt;
-            const peerInfo = {};
-            if (gunOpts && gunOpts.peers) {
-                Object.keys(gunOpts.peers).forEach((peer) => {
-                    const peerObj = gunOpts.peers[peer];
-                    const isConnected = peerObj && peerObj.wire && peerObj.wire.hied !== "bye";
-                    const status = isConnected
-                        ? "connected"
-                        : peerObj && peerObj.wire
-                            ? "disconnected"
-                            : "not_initialized";
-                    peerInfo[peer] = {
-                        connected: isConnected,
-                        status: status,
-                    };
-                });
-            }
-            return peerInfo;
-        }
-        catch (error) {
-            console.error("Error getting peer info:", error);
-            return {};
-        }
-    }
-    /**
-     * Reconnects to a specific peer
-     * @param peer URL of the peer to reconnect
-     */
-    reconnectToPeer(peer) {
-        try {
-            // First remove the peer
-            this.removePeer(peer);
-            // Add it back immediately instead of with timeout
-            this.addPeer(peer);
-            console.log(`Reconnected to peer: ${peer}`);
-        }
-        catch (error) {
-            console.error(`Error reconnecting to peer ${peer}:`, error);
-        }
-    }
-    /**
-     * Clears all peers and optionally adds new ones
-     * @param newPeers Optional array of new peers to add
-     */
-    resetPeers(newPeers) {
-        try {
-            const gunOpts = this.gun._.opt;
-            if (gunOpts && gunOpts.peers) {
-                // Clear all existing peers
-                Object.keys(gunOpts.peers).forEach((peer) => {
-                    this.removePeer(peer);
-                });
-                // Add new peers if provided
-                if (newPeers && newPeers.length > 0) {
-                    newPeers.forEach((peer) => {
-                        this.addPeer(peer);
-                    });
-                }
-                console.log(`Gun database reset with ${newPeers ? newPeers.length : 0} peers: ${newPeers ? newPeers.join(", ") : "none"}`);
-            }
-        }
-        catch (error) {
-            console.error("Error resetting peers:", error);
-        }
-    }
-    /**
-     * Registers an authentication callback
-     * @param callback Function to call on auth events
-     * @returns Function to unsubscribe the callback
-     */
-    onAuth(callback) {
-        this.onAuthCallbacks.push(callback);
-        const user = this.gun.user();
-        if (user && user.is)
-            callback(user);
-        return () => {
-            const i = this.onAuthCallbacks.indexOf(callback);
-            if (i !== -1)
-                this.onAuthCallbacks.splice(i, 1);
-        };
-    }
-    /**
-     * Helper method to navigate to a nested path by splitting and chaining .get() calls
-     * @param node Starting Gun node
-     * @param path Path string (e.g., "test/data/marco")
-     * @returns Gun node at the specified path
-     */
-    navigateToPath(node, path) {
-        if (!path || typeof path !== "string")
-            return node;
-        // Sanitize path to remove any control characters or invalid characters
-        const sanitizedPath = path
-            .replace(/[\x00-\x1F\x7F]/g, "") // Remove control characters
-            .replace(/[^\w\-._/]/g, "") // Only allow alphanumeric, hyphens, dots, underscores, and slashes
-            .trim();
-        if (!sanitizedPath)
-            return node;
-        // Split path by '/' and filter out empty segments
-        const pathSegments = sanitizedPath
-            .split("/")
-            .filter((segment) => segment.length > 0)
-            .map((segment) => segment.trim())
-            .filter((segment) => segment.length > 0);
-        // Chain .get() calls for each path segment
-        return pathSegments.reduce((currentNode, segment) => {
-            return currentNode.get(segment);
-        }, node);
-    }
-    /**
-     * Gets the Gun instance
-     * @returns Gun instance
-     */
-    getGun() {
-        return this.gun;
-    }
-    /**
-     * Gets the current user
-     * @returns Current user object or null
-     */
-    getCurrentUser() {
-        try {
-            const user = this.gun.user();
-            const pub = user?.is?.pub;
-            return pub ? { pub, user } : null;
-        }
-        catch (error) {
-            console.error("Error getting current user:", error);
-            return null;
-        }
-    }
-    /**
-     * Gets the current user instance
-     * @returns User instance
-     */
-    getUser() {
-        return this.gun.user();
-    }
-    /**
-     * Gets a node at the specified path
-     * @param path Path to the node
-     * @returns Gun node
-     */
-    get(path) {
-        return this.navigateToPath(this.gun, 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 = await this.navigateToPath(this.gun, path).then();
-        return node;
-    }
-    /**
-     * Puts data at the specified path
-     * @param path Path to store data
-     * @param data Data to store
-     * @returns Promise resolving to operation result
-     */
-    async put(path, data) {
-        const ack = await this.navigateToPath(this.gun, path).put(data).then();
-        const result = ack.err
-            ? { success: false, error: ack.err }
-            : { success: true };
-        return result;
-    }
-    /**
-     * Sets data at the specified path
-     * @param path Path to store data
-     * @param data Data to store
-     * @returns Promise resolving to operation result
-     */
-    async set(path, data) {
-        const ack = await this.navigateToPath(this.gun, path).set(data).then();
-        const result = ack.err
-            ? { success: false, error: ack.err }
-            : { success: true };
-        return result;
-    }
-    /**
-     * Removes data at the specified path
-     * @param path Path to remove
-     * @returns Promise resolving to operation result
-     */
-    async remove(path) {
-        const ack = await this.navigateToPath(this.gun, path).put(null).then();
-        const result = ack.err
-            ? { success: false, error: ack.err }
-            : { success: true };
-        return result;
-    }
-    /**
-     * Checks if a user is currently logged in
-     * @returns True if logged in
-     */
-    isLoggedIn() {
-        try {
-            const user = this.gun.user();
-            return !!(user && user.is && user.is.pub);
-        }
-        catch (error) {
-            console.error("Error checking login status:", error);
-            return false;
-        }
-    }
-    /**
-     * Attempts to restore user session from local storage
-     * @returns Promise resolving to session restoration result
-     */
-    restoreSession() {
-        try {
-            if (typeof localStorage === "undefined") {
-                return { success: false, error: "localStorage not available" };
-            }
-            const sessionInfo = localStorage.getItem("gun/session");
-            const pairInfo = localStorage.getItem("gun/pair");
-            if (!sessionInfo || !pairInfo) {
-                // No saved session found
-                return { success: false, error: "No saved session" };
-            }
-            let session, pair;
-            try {
-                session = JSON.parse(sessionInfo);
-                pair = JSON.parse(pairInfo);
-            }
-            catch (parseError) {
-                console.error("Error parsing session data:", parseError);
-                // Clear corrupted data
-                localStorage.removeItem("gun/session");
-                localStorage.removeItem("gun/pair");
-                return { success: false, error: "Corrupted session data" };
-            }
-            // Validate session data structure
-            if (!session.username || !session.pair || !session.userPub) {
-                // Invalid session data, clearing storage
-                localStorage.removeItem("gun/session");
-                localStorage.removeItem("gun/pair");
-                return { success: false, error: "Incomplete session data" };
-            }
-            // Check if session is expired
-            if (session.expiresAt && Date.now() > session.expiresAt) {
-                // Session expired, clearing storage
-                localStorage.removeItem("gun/session");
-                localStorage.removeItem("gun/pair");
-                return { success: false, error: "Session expired" };
-            }
-            // Attempt to restore user session
-            try {
-                const userInstance = this.gun.user();
-                if (!userInstance) {
-                    console.error("Gun user instance not available");
-                    localStorage.removeItem("gun/session");
-                    localStorage.removeItem("gun/pair");
-                    return { success: false, error: "Gun user instance not available" };
-                }
-                // Set the user pair
-                try {
-                    userInstance._ = { ...userInstance._, sea: session.pair };
-                }
-                catch (pairError) {
-                    console.error("Error setting user pair:", pairError);
-                }
-                // Attempt to recall user session
-                try {
-                    const recallResult = userInstance.recall({ sessionStorage: true });
-                    // console.log("recallResult", recallResult);
-                }
-                catch (recallError) {
-                    console.error("Error during recall:", recallError);
-                }
-                // Verify session restoration success
-                if (userInstance.is && userInstance.is.pub === session.userPub) {
-                    this.user = userInstance;
-                    // Session restored successfully for user
-                    return {
-                        success: true,
-                        userPub: session.userPub,
-                    };
-                }
-                else {
-                    // Session restoration verification failed
-                    localStorage.removeItem("gun/session");
-                    localStorage.removeItem("gun/pair");
-                    return { success: false, error: "Session verification failed" };
-                }
-            }
-            catch (error) {
-                console.error(`Error restoring session: ${error}`);
-                return {
-                    success: false,
-                    error: `Session restoration failed: ${error}`,
-                };
-            }
-        }
-        catch (mainError) {
-            console.error(`Error in restoreSession: ${mainError}`);
-            return {
-                success: false,
-                error: `Session restoration failed: ${mainError}`,
-            };
-        }
-        return { success: false, error: "No session data available" };
-    }
-    logout() {
-        try {
-            const currentUser = this.gun.user();
-            if (!currentUser || !currentUser.is) {
-                console.log("No user logged in, skipping logout");
-                return;
-            }
-            // Log out user
-            try {
-                currentUser.leave();
-            }
-            catch (gunError) {
-                console.error("Error during Gun logout:", gunError);
-            }
-            // Clear user reference
-            this.user = null;
-            // Clear local session data
-            try {
-                // Clear session data if needed
-            }
-            catch (error) {
-                console.error("Error clearing local session data:", error);
-            }
-            // Clear session storage
-            try {
-                if (typeof sessionStorage !== "undefined") {
-                    sessionStorage.removeItem("gunSessionData");
-                    // Session storage cleared
-                }
-            }
-            catch (error) {
-                console.error("Error clearing session storage:", error);
-            }
-            // Logout completed successfully
-        }
-        catch (error) {
-            console.error("Error during logout:", error);
-        }
-    }
-    /**
-     * Accesses the RxJS module for reactive programming
-     * @returns GunRxJS instance
-     */
-    rx() {
-        if (!this._rxjs) {
-            this._rxjs = new RxJS(this.gun);
-        }
-        return this._rxjs;
-    }
-    /**
-     * Validates password strength according to security requirements
-     */
-    validatePasswordStrength(password) {
-        if (password.length < CONFIG.PASSWORD.MIN_LENGTH) {
-            return {
-                valid: false,
-                error: `Password must be at least ${CONFIG.PASSWORD.MIN_LENGTH} characters long`,
-            };
-        }
-        const validations = [];
-        if (CONFIG.PASSWORD.REQUIRE_UPPERCASE && !/[A-Z]/.test(password)) {
-            validations.push("uppercase letter");
-        }
-        if (CONFIG.PASSWORD.REQUIRE_LOWERCASE && !/[a-z]/.test(password)) {
-            validations.push("lowercase letter");
-        }
-        if (CONFIG.PASSWORD.REQUIRE_NUMBERS && !/\d/.test(password)) {
-            validations.push("number");
-        }
-        if (CONFIG.PASSWORD.REQUIRE_SPECIAL_CHARS &&
-            !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
-            validations.push("special character");
-        }
-        if (validations.length > 0) {
-            return {
-                valid: false,
-                error: `Password must contain at least one: ${validations.join(", ")}`,
-            };
-        }
-        return { valid: true };
-    }
-    /**
-     * Validates signup credentials with enhanced security
-     */
-    validateSignupCredentials(username, password, pair) {
-        // Validate username
-        if (!username || username.length < 1) {
-            return {
-                valid: false,
-                error: "Username must be more than 0 characters long!",
-            };
-        }
-        // Validate username format (alphanumeric and some special chars only)
-        if (!/^[a-zA-Z0-9._-]+$/.test(username)) {
-            return {
-                valid: false,
-                error: "Username can only contain letters, numbers, dots, underscores, and hyphens",
-            };
-        }
-        // If using pair authentication, skip password validation
-        if (pair) {
-            if (!pair.pub ||
-                !pair.priv ||
-                !pair.epub ||
-                !pair.epriv) {
-                return {
-                    valid: false,
-                    error: "Invalid pair provided",
-                };
-            }
-            if (!pair.pub || !pair.priv || !pair.epub || !pair.epriv) {
-                return {
-                    valid: false,
-                    error: "Invalid pair provided",
-                };
-            }
-            return { valid: true };
-        }
-        // 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 {
-                        console.log(`User created successfully with userPub: ${userPub}`);
-                        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) => {
-                    console.log(`Pair authentication after creation result:`, 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;
-                            console.log(`Extracted userPub after pair auth: ${userPub}`);
-                            console.log(`User object after pair auth:`, this.gun.user());
-                            console.log(`User.is after pair auth:`, this.gun.user().is);
-                            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) => {
-                    console.log(`Password authentication after creation result:`, 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;
-                            console.log(`Extracted userPub after password auth: ${userPub}`);
-                            console.log(`User object after password auth:`, this.gun.user());
-                            console.log(`User.is after password auth:`, this.gun.user().is);
-                            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
-     * @param password Password
-     * @param pair Optional SEA pair for Web3 login
-     * @returns Promise resolving to signup result
-     */
-    async signUp(username, password, pair) {
-        try {
-            // Validate credentials with enhanced security
-            const validation = this.validateSignupCredentials(username, password, pair);
-            if (!validation.valid) {
-                return { success: false, error: validation.error };
-            }
-            let createResult;
-            if (pair) {
-                // For Web3/plugin authentication, use pair-based creation
-                createResult = await this.createNewUserWithPair(username, pair);
-            }
-            else {
-                // For password authentication, use standard creation
-                createResult = await this.createNewUser(username, password);
-            }
-            if (!createResult.success) {
-                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);
-            if (!authResult.success) {
-                return { success: false, error: authResult.error };
-            }
-            // Validate that we have a userPub
-            if (!authResult.userPub ||
-                typeof authResult.userPub !== "string" ||
-                authResult.userPub.trim().length === 0) {
-                console.error("Authentication successful but no valid userPub returned:", authResult);
-                return {
-                    success: false,
-                    error: "Authentication successful but no valid userPub returned",
-                };
-            }
-            // Set the user instance
-            this.user = this.gun.user();
-            // Run post-authentication tasks
-            try {
-                console.log(`Running post-auth setup with userPub: ${authResult.userPub}`);
-                const postAuthResult = await this.runPostAuthOnAuthResult(username, authResult.userPub, authResult);
-                // Return the post-auth result which includes the complete user data
-                return postAuthResult;
-            }
-            catch (postAuthError) {
-                console.error(`Post-auth error: ${postAuthError}`);
-                // Even if post-auth fails, the user was created and authenticated successfully
-                return {
-                    success: true,
-                    userPub: authResult.userPub,
-                    username: username,
-                    isNewUser: true,
-                    sea: this.gun.user()?._?.sea
-                        ? {
-                            pub: this.gun.user()._?.sea.pub,
-                            priv: this.gun.user()._?.sea.priv,
-                            epub: this.gun.user()._?.sea.epub,
-                            epriv: this.gun.user()._?.sea.epriv,
-                        }
-                        : undefined,
-                };
-            }
-        }
-        catch (error) {
-            console.error(`Exception during signup for ${username}: ${error}`);
-            return { success: false, error: `Signup failed: ${error}` };
-        }
-    }
-    /**
-     * Creates a new user in Gun with pair-based authentication (for Web3/plugins)
-     */
-    async createNewUserWithPair(username, pair) {
-        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 (!pair || !pair.pub || !pair.priv) {
-                resolve({ success: false, error: "Invalid pair provided" });
-                return;
-            }
-            // Normalize username
-            const normalizedUsername = username.trim().toLowerCase();
-            if (normalizedUsername.length === 0) {
-                resolve({
-                    success: false,
-                    error: "Username cannot be empty",
-                });
-                return;
-            }
-            // For pair-based authentication, we don't need to call gun.user().create()
-            // because the pair already contains the cryptographic credentials
-            // We just need to validate that the pair is valid and return success
-            console.log(`User created successfully with pair for: ${normalizedUsername}`);
-            resolve({ success: true, userPub: pair.pub });
-        });
-    }
-    async runPostAuthOnAuthResult(username, userPub, authResult) {
-        // Setting up user profile after authentication
-        try {
-            // Validate required parameters
-            if (!username ||
-                typeof username !== "string" ||
-                username.trim().length === 0) {
-                throw new Error("Invalid username provided");
-            }
-            if (!userPub ||
-                typeof userPub !== "string" ||
-                userPub.trim().length === 0) {
-                console.error("Invalid userPub provided:", {
-                    userPub,
-                    type: typeof userPub,
-                    authResult,
-                });
-                throw new Error("Invalid userPub provided");
-            }
-            // Additional validation for userPub format
-            if (!userPub.includes(".") || userPub.length < 10) {
-                console.error("Invalid userPub format:", userPub);
-                throw new Error("Invalid userPub format");
-            }
-            // Normalize username to prevent path issues
-            const normalizedUsername = username.trim().toLowerCase();
-            if (normalizedUsername.length === 0) {
-                throw new Error("Username cannot be empty");
-            }
-            console.log(`Setting up user profile for ${normalizedUsername} with userPub: ${userPub}`);
-            const existingUser = await this.gun.get(userPub).once().then();
-            const isNewUser = !existingUser || !existingUser.username;
-            // Get user's encryption public key (epub) for comprehensive tracking
-            const userInstance = this.gun.user();
-            const userSea = userInstance?._?.sea;
-            const epub = userSea?.epub || null;
-            // Enhanced user tracking system
-            await this.setupComprehensiveUserTracking(normalizedUsername, userPub, epub, isNewUser);
-            return {
-                success: true,
-                userPub: userPub,
-                username: normalizedUsername,
-                isNewUser: isNewUser,
-                // Get the SEA pair from the user object
-                sea: userSea
-                    ? {
-                        pub: userSea.pub,
-                        priv: userSea.priv,
-                        epub: userSea.epub,
-                        epriv: userSea.epriv,
-                    }
-                    : undefined,
-            };
-        }
-        catch (error) {
-            console.error(`Error in post-authentication setup: ${error}`);
-            return {
-                success: false,
-                error: `Post-authentication setup failed: ${error}`,
-            };
-        }
-    }
-    /**
-     * Sets up comprehensive user tracking system for agile user lookup
-     * Creates multiple indexes for efficient user discovery
-     */
-    async setupComprehensiveUserTracking(username, userPub, epub, isNewUser) {
-        try {
-            // 1. Create alias index: ~@alias -> userPub (for GunDB compatibility)
-            await this.createAliasIndex(username, userPub);
-            // 2. Create username mapping: usernames/alias -> userPub
-            await this.createUsernameMapping(username, userPub);
-            // 3. Create user registry: users/userPub -> user data
-            await this.createUserRegistry(username, userPub, epub);
-            // 4. Create reverse lookup: userPub -> alias
-            await this.createReverseLookup(username, userPub);
-            // 5. Create epub index: epubKeys/epub -> userPub (for encryption lookups)
-            if (epub) {
-                await this.createEpubIndex(epub, userPub);
-            }
-            // 6. Create user metadata in user's own node
-            await this.createUserMetadata(username, userPub, epub);
-            console.log(`Comprehensive user tracking setup completed for ${username}`);
-        }
-        catch (error) {
-            console.error(`Error in comprehensive user tracking setup: ${error}`);
-            // Don't throw - continue with other operations
-        }
-    }
-    /**
-     * Creates alias index following GunDB pattern: ~@alias -> userPub
-     */
-    async createAliasIndex(username, userPub) {
-        try {
-            const aliasNode = this.gun.get(`~@${username}`);
-            // For Gun.js alias validation to pass, the data must be exactly equal to the key
-            // The key is `~@${username}`, so we store that as the data
-            const ack = await aliasNode.put(`~@${username}`).then();
-            if (ack.err) {
-                console.error(`Error creating alias index: ${ack.err}`);
-            }
-            else {
-                console.log(`Alias index created: ~@${username} -> ${userPub}`);
-            }
-        }
-        catch (error) {
-            console.error(`Error creating alias index: ${error}`);
-        }
-    }
-    /**
-     * Creates username mapping: usernames/alias -> userPub
-     */
-    async createUsernameMapping(username, userPub) {
-        try {
-            const ack = await this.node
-                .get("usernames")
-                .get(username)
-                .put(userPub)
-                .then();
-            if (ack.err) {
-                console.error(`Error creating username mapping: ${ack.err}`);
-            }
-            else {
-                console.log(`Username mapping created: ${username} -> ${userPub}`);
-            }
-        }
-        catch (error) {
-            console.error(`Error creating username mapping: ${error}`);
-        }
-    }
-    /**
-     * Creates user registry: users/userPub -> user data
-     */
-    async createUserRegistry(username, userPub, epub) {
-        try {
-            const userData = {
-                username: username,
-                userPub: userPub,
-                epub: epub,
-                registeredAt: Date.now(),
-                lastSeen: Date.now(),
-            };
-            const ack = await this.node
-                .get("users")
-                .get(userPub)
-                .put(userData)
-                .then();
-            if (ack.err) {
-                console.error(`Error creating user registry: ${ack.err}`);
-            }
-            else {
-                console.log(`User registry created: ${userPub}`);
-            }
-        }
-        catch (error) {
-            console.error(`Error creating user registry: ${error}`);
-        }
-    }
-    /**
-     * Creates reverse lookup: userPub -> alias
-     */
-    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}`);
-            }
-            else {
-                console.log(`Reverse lookup created: ${userPub} -> ${username}`);
-            }
-        }
-        catch (error) {
-            console.error(`Error creating reverse lookup: ${error}`);
-        }
-    }
-    /**
-     * Creates epub index: epubKeys/epub -> userPub
-     */
-    async createEpubIndex(epub, userPub) {
-        try {
-            const ack = await this.node.get("epubKeys").get(epub).put(userPub).then();
-            if (ack.err) {
-                console.error(`Error creating epub index: ${ack.err}`);
-            }
-            else {
-                console.log(`Epub index created: ${epub} -> ${userPub}`);
-            }
-        }
-        catch (error) {
-            console.error(`Error creating epub index: ${error}`);
-        }
-    }
-    /**
-     * Creates user metadata in user's own node
-     */
-    async createUserMetadata(username, userPub, epub) {
-        try {
-            const userMetadata = {
-                username: username,
-                epub: epub,
-                registeredAt: Date.now(),
-                lastSeen: Date.now(),
-            };
-            const ack = await this.gun.get(userPub).put(userMetadata).then();
-            if (ack.err) {
-                console.error(`Error creating user metadata: ${ack.err}`);
-            }
-            else {
-                console.log(`User metadata created for ${userPub}`);
-            }
-        }
-        catch (error) {
-            console.error(`Error creating user metadata: ${error}`);
-        }
-    }
-    /**
-     * Gets user information by alias using the comprehensive tracking system
-     * @param alias Username/alias to lookup
-     * @returns Promise resolving to user information or null if not found
-     */
-    async getUserByAlias(alias) {
-        try {
-            const normalizedAlias = alias.trim().toLowerCase();
-            if (!normalizedAlias) {
-                return null;
-            }
-            // Method 1: Try GunDB standard alias lookup (~@alias)
-            try {
-                const aliasData = await this.gun
-                    .get(`~@${normalizedAlias}`)
-                    .once()
-                    .then();
-                if (aliasData && aliasData["~pubKeyOfUser"]) {
-                    const userPub = aliasData["~pubKeyOfUser"]["#"] || aliasData["~pubKeyOfUser"];
-                    if (userPub) {
-                        const userData = await this.getUserDataByPub(userPub);
-                        if (userData) {
-                            return userData;
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                console.log(`GunDB alias lookup failed for ${normalizedAlias}:`, error);
-            }
-            // Method 2: Try username mapping (usernames/alias -> userPub)
-            try {
-                const userPub = await this.node
-                    .get("usernames")
-                    .get(normalizedAlias)
-                    .once()
-                    .then();
-                if (userPub) {
-                    const userData = await this.getUserDataByPub(userPub);
-                    if (userData) {
-                        return userData;
-                    }
-                }
-            }
-            catch (error) {
-                console.log(`Username mapping lookup failed for ${normalizedAlias}:`, error);
-            }
-            return null;
-        }
-        catch (error) {
-            console.error(`Error looking up user by alias ${alias}:`, error);
-            return null;
-        }
-    }
-    /**
-     * Gets user information by public key
-     * @param userPub User's public key
-     * @returns Promise resolving to user information or null if not found
-     */
-    async getUserDataByPub(userPub) {
-        try {
-            if (!userPub || typeof userPub !== "string") {
-                return null;
-            }
-            // Method 1: Try user registry (users/userPub -> user data)
-            try {
-                const userData = await this.node
-                    .get("users")
-                    .get(userPub)
-                    .once()
-                    .then();
-                if (userData && userData.username) {
-                    return {
-                        userPub: userData.userPub || userPub,
-                        epub: userData.epub || null,
-                        username: userData.username,
-                        registeredAt: userData.registeredAt || 0,
-                        lastSeen: userData.lastSeen || 0,
-                    };
-                }
-            }
-            catch (error) {
-                console.log(`User registry lookup failed for ${userPub}:`, error);
-            }
-            // Method 2: Try user's own node
-            try {
-                const userNodeData = await this.gun.get(userPub).once().then();
-                if (userNodeData && userNodeData.username) {
-                    return {
-                        userPub: userPub,
-                        epub: userNodeData.epub || null,
-                        username: userNodeData.username,
-                        registeredAt: userNodeData.registeredAt || 0,
-                        lastSeen: userNodeData.lastSeen || 0,
-                    };
-                }
-            }
-            catch (error) {
-                console.log(`User node lookup failed for ${userPub}:`, error);
-            }
-            return null;
-        }
-        catch (error) {
-            console.error(`Error looking up user data by pub ${userPub}:`, error);
-            return null;
-        }
-    }
-    /**
-     * Gets user public key by encryption public key (epub)
-     * @param epub User's encryption public key
-     * @returns Promise resolving to user public key or null if not found
-     */
-    async getUserPubByEpub(epub) {
-        try {
-            if (!epub || typeof epub !== "string") {
-                return null;
-            }
-            const userPub = await this.node.get("epubKeys").get(epub).once().then();
-            return userPub || null;
-        }
-        catch (error) {
-            console.error(`Error looking up user pub by epub ${epub}:`, error);
-            return null;
-        }
-    }
-    /**
-     * Gets user alias by public key
-     * @param userPub User's public key
-     * @returns Promise resolving to user alias or null if not found
-     */
-    async getUserAliasByPub(userPub) {
-        try {
-            if (!userPub || typeof userPub !== "string") {
-                return null;
-            }
-            const alias = await this.node
-                .get("userAliases")
-                .get(userPub)
-                .once()
-                .then();
-            return alias || null;
-        }
-        catch (error) {
-            console.error(`Error looking up user alias by pub ${userPub}:`, error);
-            return null;
-        }
-    }
-    /**
-     * Gets all registered users (for admin purposes)
-     * @returns Promise resolving to array of user information
-     */
-    async getAllRegisteredUsers() {
-        try {
-            const users = [];
-            // Get all users from the users registry
-            const usersNode = this.node.get("users");
-            // Note: This is a simplified approach. In a real implementation,
-            // you might want to use Gun's map functionality or iterate through
-            // known user public keys
-            return users;
-        }
-        catch (error) {
-            console.error(`Error getting all registered users:`, error);
-            return [];
-        }
-    }
-    /**
-     * Updates user's last seen timestamp
-     * @param userPub User's public key
-     */
-    async updateUserLastSeen(userPub) {
-        try {
-            if (!userPub || typeof userPub !== "string") {
-                return;
-            }
-            const timestamp = Date.now();
-            // Update in user registry
-            try {
-                await this.node
-                    .get("users")
-                    .get(userPub)
-                    .get("lastSeen")
-                    .put(timestamp)
-                    .then();
-            }
-            catch (error) {
-                console.log(`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();
-            }
-            catch (error) {
-                console.log(`Failed to update lastSeen in user node:`, error);
-            }
-        }
-        catch (error) {
-            console.error(`Error updating user last seen for ${userPub}:`, error);
-        }
-    }
-    /**
-     * Performs authentication with Gun
-     */
-    async performAuthentication(username, password, pair) {
-        return new Promise((resolve) => {
-            console.log(`Attempting authentication for user: ${username}`);
-            if (pair) {
-                this.gun.user().auth(pair, (ack) => {
-                    console.log(`Pair authentication result:`, ack);
-                    if (ack.err) {
-                        console.error(`Login error for ${username}: ${ack.err}`);
-                        resolve({ success: false, error: ack.err });
-                    }
-                    else {
-                        resolve({ success: true, ack });
-                    }
-                });
-            }
-            else {
-                this.gun.user().auth(username, password, (ack) => {
-                    console.log(`Password authentication result:`, ack);
-                    if (ack.err) {
-                        console.error(`Login error for ${username}: ${ack.err}`);
-                        resolve({ success: false, error: ack.err });
-                    }
-                    else {
-                        resolve({ success: true, ack });
-                    }
-                });
-            }
-        });
-    }
-    /**
-     * Builds login result object
-     */
-    buildLoginResult(username, userPub) {
-        // Get the SEA pair from the user object
-        const seaPair = this.gun.user()?._?.sea;
-        return {
-            success: true,
-            userPub,
-            username,
-            // Include SEA pair for consistency with AuthResult interface
-            sea: seaPair
-                ? {
-                    pub: seaPair.pub,
-                    priv: seaPair.priv,
-                    epub: seaPair.epub,
-                    epriv: seaPair.epriv,
-                }
-                : undefined,
-        };
-    }
-    async login(username, password, pair) {
-        try {
-            const loginResult = await this.performAuthentication(username, password, pair);
-            if (!loginResult.success) {
-                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;
-            console.log(`Login authentication successful, extracted userPub: ${userPub}`);
-            console.log(`User object:`, this.gun.user());
-            console.log(`User.is:`, this.gun.user().is);
-            if (!userPub) {
-                return {
-                    success: false,
-                    error: "Authentication failed: No user pub returned.",
-                };
-            }
-            // Pass the userPub to runPostAuthOnAuthResult
-            try {
-                await this.runPostAuthOnAuthResult(username, userPub, {
-                    success: true,
-                    userPub: userPub,
-                });
-            }
-            catch (postAuthError) {
-                console.error(`Post-auth error during login: ${postAuthError}`);
-                // Continue with login even if post-auth fails
-            }
-            // Update user's last seen timestamp
-            try {
-                await this.updateUserLastSeen(userPub);
-            }
-            catch (lastSeenError) {
-                console.error(`Error updating last seen: ${lastSeenError}`);
-                // Continue with login even if last seen update fails
-            }
-            // Save credentials for future sessions
-            try {
-                const userInfo = {
-                    username,
-                    pair: pair ?? null,
-                    userPub: userPub,
-                };
-                this.saveCredentials(userInfo);
-            }
-            catch (saveError) {
-                console.error(`Error saving credentials:`, saveError);
-            }
-            return this.buildLoginResult(username, userPub);
-        }
-        catch (error) {
-            console.error(`Exception during login for ${username}: ${error}`);
-            return { success: false, error: String(error) };
-        }
-    }
-    /**
-     * Encrypts session data before storage
-     */
-    async encryptSessionData(data) {
-        try {
-            // Use a derived key from device fingerprint for encryption
-            const deviceInfo = navigator.userAgent +
-                (typeof screen !== "undefined"
-                    ? screen.width + "x" + screen.height
-                    : "");
-            const encryptionKey = await SEA.work(deviceInfo, null, null, {
-                name: "SHA-256",
-            });
-            if (!encryptionKey) {
-                throw new Error("Failed to generate encryption key");
-            }
-            const encryptedData = await SEA.encrypt(JSON.stringify(data), encryptionKey);
-            if (!encryptedData) {
-                throw new Error("Failed to encrypt session data");
-            }
-            return encryptedData;
-        }
-        catch (error) {
-            console.error("Error encrypting session data:", error);
-            throw error;
-        }
-    }
-    /**
-     * Decrypts session data from storage
-     */
-    async decryptSessionData(encryptedData) {
-        try {
-            // Use the same device fingerprint for decryption
-            const deviceInfo = navigator.userAgent +
-                (typeof screen !== "undefined"
-                    ? screen.width + "x" + screen.height
-                    : "");
-            const encryptionKey = await SEA.work(deviceInfo, null, null, {
-                name: "SHA-256",
-            });
-            if (!encryptionKey) {
-                throw new Error("Failed to generate decryption key");
-            }
-            const decryptedData = await SEA.decrypt(encryptedData, encryptionKey);
-            if (decryptedData === undefined) {
-                throw new Error("Failed to decrypt session data");
-            }
-            return JSON.parse(decryptedData);
-        }
-        catch (error) {
-            console.error("Error decrypting session data:", error);
-            throw error;
-        }
-    }
-    saveCredentials(userInfo) {
-        try {
-            const sessionInfo = {
-                username: userInfo.username,
-                pair: userInfo.pair,
-                userPub: userInfo.userPub,
-                timestamp: Date.now(),
-                expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000, // 7 days
-            };
-            if (typeof sessionStorage !== "undefined") {
-                // Encrypt session data before storage
-                this.encryptSessionData(sessionInfo)
-                    .then((encryptedData) => {
-                    sessionStorage.setItem("gunSessionData", encryptedData);
-                })
-                    .catch((error) => {
-                    console.error("Failed to encrypt and save session data:", error);
-                    // Fallback to unencrypted storage (less secure)
-                    sessionStorage.setItem("gunSessionData", JSON.stringify(sessionInfo));
-                });
-            }
-        }
-        catch (error) {
-            console.error(`Error saving credentials: ${error}`);
-        }
-    }
-    /**
-     * Sets up security questions and password hint
-     * @param username Username
-     * @param password Current password
-     * @param hint Password hint
-     * @param securityQuestions Array of security questions
-     * @param securityAnswers Array of answers to security questions
-     * @returns Promise resolving with the operation result
-     */
-    async setPasswordHintWithSecurity(username, password, hint, securityQuestions, securityAnswers) {
-        // Setting password hint for
-        // Verify that the user is authenticated with password
-        const loginResult = await this.login(username, password);
-        if (!loginResult.success) {
-            return { success: false, error: "Authentication failed" };
-        }
-        // Check if user was authenticated with password (not with other methods)
-        const currentUser = this.getCurrentUser();
-        if (!currentUser || !currentUser.pub) {
-            return { success: false, error: "User not authenticated" };
-        }
-        try {
-            // Generate a proof of work from security question answers
-            const answersText = securityAnswers.join("|");
-            let proofOfWork;
-            try {
-                // Use SEA directly if available
-                if (SEA && SEA.work) {
-                    proofOfWork = await SEA.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" };
-            }
-            // Encrypt the password hint with the proof of work
-            let encryptedHint;
-            try {
-                if (SEA && SEA.encrypt) {
-                    encryptedHint = await SEA.encrypt(hint, proofOfWork);
-                }
-                else if (this.crypto && this.crypto.encrypt) {
-                    encryptedHint = await this.crypto.encrypt(hint, proofOfWork);
-                }
-                else {
-                    throw new Error("Encryption functions not available");
-                }
-                if (!encryptedHint) {
-                    throw new Error("Failed to encrypt hint");
-                }
-            }
-            catch (encryptError) {
-                console.error("Error encrypting hint:", encryptError);
-                return { success: false, error: "Failed to encrypt password hint" };
-            }
-            // Save to the public graph, readable by anyone but only decryptable with the right answers.
-            const userPub = currentUser.pub;
-            const securityPayload = {
-                questions: JSON.stringify(securityQuestions),
-                hint: encryptedHint,
-            };
-            const ack = await this.node.get(userPub)
-                .get("security")
-                .put(securityPayload)
-                .then();
-            if (ack.err) {
-                console.error("Error saving security data to public graph:", ack.err);
-                throw new Error(ack.err);
-            }
-            return { success: true };
-        }
-        catch (error) {
-            console.error("Error setting password hint:", error);
-            return { success: false, error: String(error) };
-        }
-    }
-    /**
-     * Recovers password hint using security question answers
-     * @param username Username
-     * @param securityAnswers Array of answers to security questions
-     * @returns Promise resolving with the password hint
-     */
-    async forgotPassword(username, securityAnswers) {
-        // Attempting password recovery for
-        try {
-            // Find the user's data using direct lookup
-            const normalizedUsername = username.trim().toLowerCase();
-            const userPub = (await this.node
-                .get("usernames")
-                .get(normalizedUsername)
-                .once()
-                .then()) || null;
-            if (!userPub) {
-                return { success: false, error: "User not found" };
-            }
-            // console.log(`Found user public key for password recovery: ${userPub}`);
-            // Access the user's security data directly from their public key node
-            const securityData = await this.node.get(userPub)
-                .get("security")
-                .once()
-                .then();
-            if (!securityData || !securityData.hint) {
-                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 && SEA.work) {
-                    proofOfWork = await SEA.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 && SEA.decrypt) {
-                    hint = await SEA.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:", error);
-            return { success: false, error: String(error) };
-        }
-    }
-    /**
-     * Saves user data at the specified path
-     * @param path Path to save the data (supports nested paths like "test/data/marco")
-     * @param data Data to save
-     * @returns Promise that resolves when the data is saved
-     */
-    async putUserData(path, data) {
-        const user = this.gun.user();
-        if (!user.is) {
-            throw new Error("User not authenticated");
-        }
-        const ack = await this.navigateToPath(user, path).put(data).then();
-        if (ack.err) {
-            throw new Error(ack.err);
-        }
-    }
-    /**
-     * Gets user data from the specified path
-     * @param path Path to get the data from (supports nested paths like "test/data/marco")
-     * @returns Promise that resolves with the data
-     */
-    async getUserData(path) {
-        // Validazione del path
-        if (!path || typeof path !== "string") {
-            throw new Error("Path must be a non-empty string");
-        }
-        const user = this.gun.user();
-        if (!user.is) {
-            throw new Error("User not authenticated");
-        }
-        try {
-            const data = await this.navigateToPath(user, path).once().then();
-            // Gestisci i riferimenti GunDB
-            if (data && typeof data === "object" && data["#"]) {
-                // È un riferimento GunDB, carica i dati effettivi
-                const referencePath = data["#"];
-                const actualData = await this.navigateToPath(this.gun, referencePath)
-                    .once()
-                    .then();
-                return actualData;
-            }
-            else {
-                // Dati diretti, restituisci così come sono
-                return data;
-            }
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : "Unknown error";
-            throw new Error(errorMsg);
-        }
-    }
-    // Errors
-    static Errors = GunErrors;
-    /**
-     * Adds an event listener
-     * @param event Event name
-     * @param listener Event listener function
-     */
-    on(event, listener) {
-        this.eventEmitter.on(event, listener);
-    }
-    /**
-     * Removes an event listener
-     * @param event Event name
-     * @param listener Event listener function
-     */
-    off(event, listener) {
-        this.eventEmitter.off(event, listener);
-    }
-    /**
-     * Adds a one-time event listener
-     * @param event Event name
-     * @param listener Event listener function
-     */
-    once(event, listener) {
-        this.eventEmitter.once(event, listener);
-    }
-    /**
-     * Emits an event
-     * @param event Event name
-     * @param data Event data
-     */
-    emit(event, data) {
-        return this.eventEmitter.emit(event, data);
-    }
-    /**
-     * Recall user session
-     */
-    recall() {
-        if (this.user) {
-            this.user.recall({ sessionStorage: true });
-        }
-    }
-    /**
-     * Leave user session
-     */
-    leave() {
-        if (this.user) {
-            this.user.leave();
-        }
-    }
-    /**
-     * Set user data
-     */
-    setUserData(data) {
-        if (this.user) {
-            this.user.put(data);
-        }
-    }
-    /**
-     * Set password hint
-     */
-    setPasswordHint(hint) {
-        if (this.user) {
-            try {
-                this.user.get("passwordHint").put(hint);
-            }
-            catch (error) {
-                // Handle case where user.get returns undefined
-                console.warn("Could not set password hint:", error);
-            }
-        }
-    }
-    /**
-     * Get password hint
-     */
-    getPasswordHint() {
-        if (this.user) {
-            // Access passwordHint from user data, not from is object
-            return this.user.passwordHint || null;
-        }
-        return null;
-    }
-    /**
-     * Save session to storage
-     */
-    saveSession(session) {
-        if (this.user) {
-            this.user.recall({ sessionStorage: true });
-        }
-    }
-    /**
-     * Load session from storage
-     */
-    loadSession() {
-        if (this.user) {
-            return this.user.recall({ sessionStorage: true });
-        }
-        return null;
-    }
-    /**
-     * Clear session
-     */
-    clearSession() {
-        if (this.user) {
-            this.user.leave();
-        }
-    }
-    /**
-     * Get app scope
-     */
-    getAppScope() {
-        return this.node?._?.soul || "shogun";
-    }
-    /**
-     * Get user public key
-     */
-    getUserPub() {
-        if (this.user) {
-            return this.user.is?.pub || null;
-        }
-        return null;
-    }
-    /**
-     * Check if user is authenticated
-     */
-    isAuthenticated() {
-        return this.user?.is?.pub ? true : false;
-    }
-}
-const createGun = (config) => {
-    console.log("Creating Gun instance with config:", config);
-    console.log("Config peers:", config?.peers);
-    const gunInstance = new Gun(config);
-    console.log("Created Gun instance:", gunInstance);
-    console.log("Gun instance opt after creation:", gunInstance?.opt);
-    return gunInstance;
-};
-export { Gun, DataBase, SEA, RxJS, crypto, GunErrors, derive, restrictedPut, createGun, };
-export default Gun;