shogun-core 5.2.0 → 5.2.2

package/dist/managers/AuthManager.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthManager = void 0;
+const errorHandler_1 = require("../utils/errorHandler");
+/**
+ * Manages authentication operations for ShogunCore
+ */
+class AuthManager {
+    constructor(core) {
+        this.core = core;
+    }
+    /**
+     * Check if user is logged in
+     * @returns {boolean} True if user is logged in, false otherwise
+     * @description Verifies authentication status by checking GunInstance login state
+     * and presence of authentication credentials in storage
+     */
+    isLoggedIn() {
+        return this.core.db.isLoggedIn();
+    }
+    /**
+     * Perform user logout
+     * @description Logs out the current user from GunInstance and emits logout event.
+     * If user is not authenticated, the logout operation is ignored.
+     */
+    logout() {
+        try {
+            if (!this.isLoggedIn()) {
+                return;
+            }
+            this.core.db.logout();
+            this.core.emit("auth:logout");
+        }
+        catch (error) {
+            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.AUTHENTICATION, "LOGOUT_FAILED", error instanceof Error ? error.message : "Error during logout", error);
+        }
+    }
+    /**
+     * Authenticate user with username and password
+     * @param username - Username
+     * @param password - User password
+     * @returns {Promise<AuthResult>} Promise with authentication result
+     * @description Attempts to log in user with provided credentials.
+     * Emits login event on success.
+     */
+    async login(username, password, pair) {
+        try {
+            if (!this.currentAuthMethod) {
+                this.currentAuthMethod = "password";
+            }
+            const result = await this.core.db.login(username, password, pair);
+            if (result.success) {
+                // Include SEA pair in the response
+                const seaPair = this.core.user?._?.sea;
+                if (seaPair) {
+                    result.sea = seaPair;
+                }
+                this.core.emit("auth:login", {
+                    userPub: result.userPub ?? "",
+                    method: this.currentAuthMethod === "pair"
+                        ? "password"
+                        : this.currentAuthMethod || "password",
+                });
+            }
+            else {
+                result.error = result.error || "Wrong user or password";
+            }
+            return result;
+        }
+        catch (error) {
+            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.AUTHENTICATION, "LOGIN_FAILED", error.message ?? "Unknown error during login", error);
+            return {
+                success: false,
+                error: error.message ?? "Unknown error during login",
+            };
+        }
+    }
+    /**
+     * Login with GunDB pair directly
+     * @param pair - GunDB SEA pair for authentication
+     * @returns {Promise<AuthResult>} Promise with authentication result
+     * @description Authenticates user using a GunDB pair directly.
+     * Emits login event on success.
+     */
+    async loginWithPair(username, pair) {
+        try {
+            if (!pair || !pair.pub || !pair.priv || !pair.epub || !pair.epriv) {
+                return {
+                    success: false,
+                    error: "Invalid pair structure - missing required keys",
+                };
+            }
+            // Use the new loginWithPair method from GunInstance
+            const result = await this.core.db.loginWithPair(username, pair);
+            if (result.success) {
+                // Include SEA pair in the response
+                const seaPair = this.core.user?._?.sea;
+                if (seaPair) {
+                    result.sea = seaPair;
+                }
+                this.currentAuthMethod = "pair";
+                this.core.emit("auth:login", {
+                    userPub: result.userPub ?? "",
+                    method: "pair",
+                    username,
+                });
+            }
+            else {
+                result.error =
+                    result.error || "Authentication failed with provided pair";
+            }
+            return result;
+        }
+        catch (error) {
+            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.AUTHENTICATION, "PAIR_LOGIN_FAILED", error.message ?? "Unknown error during pair login", error);
+            return {
+                success: false,
+                error: error.message ?? "Unknown error during pair login",
+            };
+        }
+    }
+    /**
+     * Register a new user with provided credentials
+     * @param username - Username
+     * @param password - Password
+     * @param email - Email (optional)
+     * @param pair - Pair of keys
+     * @returns {Promise<SignUpResult>} Registration result
+     * @description Creates a new user account with the provided credentials.
+     * Validates password requirements and emits signup event on success.
+     */
+    async signUp(username, password, pair) {
+        try {
+            if (!this.core.db) {
+                throw new Error("Database not initialized");
+            }
+            // For password-based signup, ensure password is provided
+            if (!pair && (!password || password.trim() === "")) {
+                throw new Error("Password is required for password-based signup");
+            }
+            const result = await this.core.db.signUp(username, password || "", pair);
+            if (result.success) {
+                // Update current authentication method
+                this.currentAuthMethod = pair ? "web3" : "password";
+                this.core.emit("auth:signup", {
+                    userPub: result.userPub,
+                    username,
+                    method: this.currentAuthMethod,
+                });
+                this.core.emit("debug", {
+                    action: "signup_success",
+                    userPub: result.userPub,
+                    method: this.currentAuthMethod,
+                });
+            }
+            else {
+                this.core.emit("debug", {
+                    action: "signup_failed",
+                    error: result.error,
+                    username,
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            if (typeof console !== "undefined" && console.error) {
+                console.error(`Error during registration for user ${username}:`, error);
+            }
+            this.core.emit("debug", {
+                action: "signup_error",
+                error: error instanceof Error ? error.message : String(error),
+                username,
+            });
+            return {
+                success: false,
+                error: `Registration failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    /**
+     * Set the current authentication method
+     * This is used by plugins to indicate which authentication method was used
+     * @param method The authentication method used
+     */
+    setAuthMethod(method) {
+        this.currentAuthMethod = method;
+    }
+    /**
+     * Get the current authentication method
+     * @returns The current authentication method or undefined if not set
+     */
+    getAuthMethod() {
+        return this.currentAuthMethod;
+    }
+    /**
+     * Get an authentication method plugin by type
+     * @param type The type of authentication method
+     * @returns The authentication plugin or undefined if not available
+     * This is a more modern approach to accessing authentication methods
+     */
+    getAuthenticationMethod(type) {
+        switch (type) {
+            case "webauthn":
+                return this.core.getPlugin("webauthn");
+            case "web3":
+                return this.core.getPlugin("web3");
+            case "nostr":
+                return this.core.getPlugin("nostr");
+            case "password":
+            default:
+                return {
+                    login: async (username, password) => {
+                        return await this.login(username, password);
+                    },
+                    signUp: async (username, password, confirm) => {
+                        // For password-based signup, validate password confirmation
+                        if (confirm && password !== confirm) {
+                            throw new Error("Password and confirm password do not match");
+                        }
+                        return await this.signUp(username, password);
+                    },
+                };
+        }
+    }
+}
+exports.AuthManager = AuthManager;

package/dist/managers/CoreInitializer.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreInitializer = void 0;
+const storage_1 = require("../storage/storage");
+const errorHandler_1 = require("../utils/errorHandler");
+const webauthnPlugin_1 = require("../plugins/webauthn/webauthnPlugin");
+const web3ConnectorPlugin_1 = require("../plugins/web3/web3ConnectorPlugin");
+const nostrConnectorPlugin_1 = require("../plugins/nostr/nostrConnectorPlugin");
+const zkProofPlugin_1 = require("../plugins/zkproof/zkProofPlugin");
+const gundb_1 = require("../gundb");
+/**
+ * Handles initialization of ShogunCore components
+ */
+class CoreInitializer {
+    constructor(core) {
+        this.core = core;
+    }
+    /**
+     * Initialize the Shogun SDK
+     * @param config - SDK Configuration object
+     * @description Creates a new instance of ShogunCore with the provided configuration.
+     * Initializes all required components including storage, event emitter, GunInstance connection,
+     * and plugin system.
+     */
+    async initialize(config) {
+        // Polyfill console for environments where it might be missing
+        if (typeof console === "undefined") {
+            global.console = {
+                log: () => { },
+                warn: () => { },
+                error: () => { },
+                info: () => { },
+                debug: () => { },
+            };
+        }
+        // Initialize storage
+        this.core.storage = new storage_1.ShogunStorage(config.silent);
+        // Setup error handler
+        errorHandler_1.ErrorHandler.addListener((error) => {
+            this.core.emit("error", {
+                action: error.code,
+                message: error.message,
+                type: error.type,
+            });
+        });
+        // Setup Gun instance
+        this.initializeGun(config);
+        // Setup Gun user
+        this.initializeGunUser();
+        // Setup Gun event forwarding
+        this.setupGunEventForwarding();
+        // Setup wallet derivation
+        this.setupWalletDerivation();
+        // Initialize RxJS
+        this.core.rx = new gundb_1.RxJS(this.core.gun);
+        // Register built-in plugins
+        this.registerBuiltinPlugins(config);
+        // Initialize async components
+        this.initializeDb();
+    }
+    /**
+     * Initialize Gun instance
+     */
+    // Sì, è corretto.
+    initializeGun(config) {
+        try {
+            if (config.gunInstance) {
+                console.log("Using existing Gun instance:", config.gunInstance);
+                this.core._gun = config.gunInstance;
+            }
+            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);
+            }
+            else if (config.gunInstance && config.gunOptions) {
+                throw new Error("Gun instance and gun options cannot be provided together");
+                return false;
+            }
+        }
+        catch (error) {
+            if (typeof console !== "undefined" && console.error) {
+                console.error("Error creating Gun instance:", error);
+            }
+            return false;
+        }
+        try {
+            this.core.db = new gundb_1.DataBase(this.core._gun, config.gunOptions?.scope || "", this.core);
+            return true;
+        }
+        catch (error) {
+            if (typeof console !== "undefined" && console.error) {
+                console.error("Error initializing GunInstance:", error);
+            }
+            throw new Error(`Failed to initialize GunInstance: ${error}`);
+        }
+    }
+    /**
+     * Initialize Gun user
+     */
+    initializeGunUser() {
+        try {
+            this.core._user = this.core.gun.user().recall({ sessionStorage: true });
+        }
+        catch (error) {
+            if (typeof console !== "undefined" && console.error) {
+                console.error("Error initializing Gun user:", error);
+            }
+            throw new Error(`Failed to initialize Gun user: ${error}`);
+        }
+        this.core.gun.on("auth", (user) => {
+            this.core._user = this.core.gun.user().recall({ sessionStorage: true });
+            this.core.emit("auth:login", {
+                userPub: user.pub,
+                method: "password",
+            });
+        });
+    }
+    /**
+     * Setup Gun event forwarding
+     */
+    setupGunEventForwarding() {
+        const gunEvents = ["gun:put", "gun:get", "gun:set", "gun:remove"];
+        gunEvents.forEach((eventName) => {
+            this.core.db.on(eventName, (data) => {
+                this.core.emit(eventName, data);
+            });
+        });
+        const peerEvents = [
+            "gun:peer:add",
+            "gun:peer:remove",
+            "gun:peer:connect",
+            "gun:peer:disconnect",
+        ];
+        peerEvents.forEach((eventName) => {
+            this.core.db.on(eventName, (data) => {
+                this.core.emit(eventName, data);
+            });
+        });
+    }
+    /**
+     * Setup wallet derivation
+     */
+    setupWalletDerivation() {
+        this.core.gun.on("auth", async (user) => {
+            if (!user.is)
+                return;
+            const priv = user._?.sea?.epriv;
+            const pub = user._?.sea?.epub;
+            this.core.wallets = await (0, gundb_1.derive)(priv, pub, {
+                includeSecp256k1Bitcoin: true,
+                includeSecp256k1Ethereum: true,
+            });
+        });
+    }
+    /**
+     * Register built-in plugins based on configuration
+     */
+    registerBuiltinPlugins(config) {
+        try {
+            // Register WebAuthn plugin if configuration is provided
+            if (config.webauthn) {
+                if (typeof console !== "undefined" && console.warn) {
+                    console.warn("WebAuthn plugin will be registered with provided configuration");
+                }
+                const webauthnPlugin = new webauthnPlugin_1.WebauthnPlugin();
+                if (typeof webauthnPlugin.configure === "function") {
+                    webauthnPlugin.configure(config.webauthn);
+                }
+                this.core.pluginManager.register(webauthnPlugin);
+            }
+            // Register Web3 plugin if configuration is provided
+            if (config.web3) {
+                if (typeof console !== "undefined" && console.warn) {
+                    console.warn("Web3 plugin will be registered with provided configuration");
+                }
+                const web3Plugin = new web3ConnectorPlugin_1.Web3ConnectorPlugin();
+                if (typeof web3Plugin.configure === "function") {
+                    web3Plugin.configure(config.web3);
+                }
+                this.core.pluginManager.register(web3Plugin);
+            }
+            // Register Nostr plugin if configuration is provided
+            if (config.nostr) {
+                if (typeof console !== "undefined" && console.warn) {
+                    console.warn("Nostr plugin will be registered with provided configuration");
+                }
+                const nostrPlugin = new nostrConnectorPlugin_1.NostrConnectorPlugin();
+                if (typeof nostrPlugin.configure === "function") {
+                    nostrPlugin.configure(config.nostr);
+                }
+                this.core.pluginManager.register(nostrPlugin);
+            }
+            // Register ZK-Proof plugin if configuration is provided
+            if (config.zkproof) {
+                if (typeof console !== "undefined" && console.warn) {
+                    console.warn("ZK-Proof plugin will be registered with provided configuration");
+                }
+                const zkproofPlugin = new zkProofPlugin_1.ZkProofPlugin(config.zkproof);
+                this.core.pluginManager.register(zkproofPlugin);
+            }
+        }
+        catch (error) {
+            if (typeof console !== "undefined" && console.error) {
+                console.error("Error registering builtin plugins:", error);
+            }
+        }
+    }
+    /**
+     * Initialize async components
+     */
+    initializeDb() {
+        try {
+            this.core.db.initialize();
+            this.core.emit("debug", {
+                action: "core_initialized",
+                timestamp: Date.now(),
+            });
+            return true;
+        }
+        catch (error) {
+            if (typeof console !== "undefined" && console.error) {
+                console.error("Error during Shogun Core initialization:", error);
+            }
+            return false;
+        }
+    }
+}
+exports.CoreInitializer = CoreInitializer;