shogun-core 6.2.3 → 6.3.0

package/dist/managers/AuthManager.js

@@ -1,226 +0,0 @@
-"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

@@ -1,250 +0,0 @@
-"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 db_1 = require("../gundb/db");
-/**
- * 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 db_1.RxJS(this.core.gun);
-        // Register built-in plugins
-        this.registerBuiltinPlugins(config);
-        // Initialize async components
-        this.initializeDb();
-    }
-    /**
-     * Initialize Gun instance
-     */
-    initializeGun(config) {
-        try {
-            if (!config.gunInstance) {
-                throw new Error("Gun instance is required but was not provided");
-            }
-            // Validate Gun instance
-            if (typeof config.gunInstance !== "object") {
-                throw new Error(`Gun instance must be an object, received: ${typeof config.gunInstance}`);
-            }
-            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 validating Gun instance:", error);
-            }
-            throw new Error(`Failed to validate Gun instance: ${error}`);
-        }
-        try {
-            // Get SEA from Gun instance or global
-            let sea = this.core._gun.SEA || null;
-            if (!sea) {
-                // Try to find SEA in various global locations
-                if (typeof window !== "undefined" &&
-                    window.Gun &&
-                    window.Gun.SEA) {
-                    sea = window.Gun.SEA;
-                }
-                else if (globalThis.Gun && globalThis.Gun.SEA) {
-                    sea = globalThis.Gun.SEA;
-                }
-                else if (global.Gun && global.Gun.SEA) {
-                    sea = global.Gun.SEA;
-                }
-            }
-            this.core.db = new db_1.DataBase(this.core._gun, "shogun", // Default app scope
-            this.core, sea);
-            return true;
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error("Error initializing DataBase:", error);
-            }
-            throw new Error(`Failed to initialize DataBase: ${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, db_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;

package/dist/managers/CryptoIdentityManager.js

@@ -1,138 +0,0 @@
-"use strict";
-/**
- * CryptoIdentityManager - Wrapper per la generazione delle identità crypto
- * Genera tutte le identità crypto disponibili. Il salvataggio sarà gestito lato frontend.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CryptoIdentityManager = void 0;
-const asymmetric_1 = require("../crypto/asymmetric");
-const symmetric_1 = require("../crypto/symmetric");
-const signal_protocol_1 = require("../crypto/signal-protocol");
-const pgp_1 = require("../crypto/pgp");
-const mls_1 = require("../crypto/mls");
-const sframe_1 = require("../crypto/sframe");
-const errorHandler_1 = require("../utils/errorHandler");
-/**
- * Manager per la generazione delle identità crypto
- * Genera tutte le identità crypto disponibili. Il salvataggio sarà gestito lato frontend.
- */
-class CryptoIdentityManager {
-    constructor() {
-        this.pgpManager = new pgp_1.PGPManager();
-        this.mlsManager = new mls_1.MLSManager("default-user");
-        this.sframeManager = new sframe_1.SFrameManager();
-        // Inizializza PGP Manager
-        this.pgpManager.initialize().catch((error) => {
-            console.warn("PGP Manager initialization failed:", error);
-        });
-    }
-    /**
-     * Genera tutte le identità crypto disponibili per un utente
-     * @param username - Nome utente
-     * @param seaPair - Coppia di chiavi SEA dell'utente
-     * @returns Promise con le identità generate
-     */
-    async generateAllIdentities(username, seaPair) {
-        try {
-            console.log(`🔐 [CryptoIdentityManager] Generating crypto identities for: ${username}`);
-            const identities = {
-                createdAt: Date.now(),
-                version: "1.0.0",
-            };
-            // 1. Genera coppia di chiavi RSA-4096
-            console.log(`🔑 [${username}] Generating RSA key pair...`);
-            try {
-                identities.rsa = await (0, asymmetric_1.generateKeyPair)();
-                console.log(`✅ [${username}] RSA key pair generated`);
-            }
-            catch (error) {
-                console.error(`❌ [${username}] RSA key generation failed:`, error);
-            }
-            // 2. Genera chiave simmetrica AES-256
-            console.log(`🔑 [${username}] Generating AES symmetric key...`);
-            try {
-                identities.aes = await (0, symmetric_1.generateSymmetricKey)();
-                console.log(`✅ [${username}] AES symmetric key generated`);
-            }
-            catch (error) {
-                console.error(`❌ [${username}] AES key generation failed:`, error);
-            }
-            // 3. Genera identità Signal Protocol
-            console.log(`🔑 [${username}] Generating Signal Protocol identity...`);
-            try {
-                identities.signal = await (0, signal_protocol_1.initializeSignalUser)(username);
-                console.log(`✅ [${username}] Signal Protocol identity generated`);
-            }
-            catch (error) {
-                console.error(`❌ [${username}] Signal Protocol generation failed:`, error);
-            }
-            // 4. Genera coppia di chiavi PGP
-            console.log(`🔑 [${username}] Generating PGP key pair...`);
-            try {
-                identities.pgp = await this.pgpManager.generateKeyPair(username, `${username}@example.com`);
-                console.log(`✅ [${username}] PGP key pair generated`);
-            }
-            catch (error) {
-                console.error(`❌ [${username}] PGP key generation failed:`, error);
-            }
-            // 5. Inizializza MLS Manager e crea gruppo
-            console.log(`🔑 [${username}] Initializing MLS group...`);
-            try {
-                await this.mlsManager.initialize();
-                const groupId = `group_${username}_${Date.now()}`;
-                const groupInfo = await this.mlsManager.createGroup(groupId);
-                // Skip adding members for now due to MLS library issues
-                // await this.mlsManager.addMembers(groupId, [username]);
-                identities.mls = {
-                    groupId: groupInfo.groupId.toString(),
-                    memberId: username,
-                };
-                console.log(`✅ [${username}] MLS group created: ${groupId}`);
-            }
-            catch (error) {
-                console.error(`❌ [${username}] MLS initialization failed:`, error);
-            }
-            // 6. Genera chiave SFrame
-            console.log(`🔑 [${username}] Generating SFrame key...`);
-            try {
-                await this.sframeManager.initialize();
-                const sframeKey = await this.sframeManager.generateKey(1);
-                identities.sframe = { keyId: sframeKey.keyId };
-                console.log(`✅ [${username}] SFrame key generated: ${sframeKey.keyId}`);
-            }
-            catch (error) {
-                console.error(`❌ [${username}] SFrame key generation failed:`, error);
-            }
-            console.log(`✅ [CryptoIdentityManager] All crypto identities generated for: ${username}`);
-            // Force garbage collection after generation
-            if (typeof global !== "undefined" && global.gc) {
-                global.gc();
-                console.log(`🧹 [${username}] Forced garbage collection after identity generation`);
-            }
-            return {
-                success: true,
-                identities,
-            };
-        }
-        catch (error) {
-            console.error(`❌ [CryptoIdentityManager] Identity generation failed:`, error);
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.ENCRYPTION, "IDENTITY_GENERATION_FAILED", error.message ?? "Failed to generate crypto identities", error);
-            return {
-                success: false,
-                error: error.message ?? "Failed to generate crypto identities",
-            };
-        }
-    }
-    /**
-     * Genera le identità crypto per un utente
-     * Wrapper che chiama generateAllIdentities (mantenuto per compatibilità)
-     * @param username - Nome utente
-     * @param seaPair - Coppia di chiavi SEA dell'utente (opzionale, non più utilizzato ma mantenuto per compatibilità)
-     * @param forceRegenerate - Ignorato, genera sempre nuove identità
-     * @returns Promise con le identità generate
-     */
-    async setupCryptoIdentities(username, seaPair, forceRegenerate = false) {
-        return this.generateAllIdentities(username, seaPair);
-    }
-}
-exports.CryptoIdentityManager = CryptoIdentityManager;

package/dist/plugins/base.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BasePlugin = void 0;
-const eventEmitter_1 = require("../utils/eventEmitter");
-/**
- * Classe base per tutti i plugin di ShogunCore
- * Fornisce funzionalità comuni e implementazione base dell'interfaccia ShogunPlugin
- */
-class BasePlugin extends eventEmitter_1.EventEmitter {
-    constructor() {
-        super(...arguments);
-        /** Riferimento all'istanza di ShogunCore */
-        this.core = null;
-    }
-    /**
-     * Inizializza il plugin con un'istanza di ShogunCore
-     * @param core Istanza di ShogunCore
-     */
-    initialize(core) {
-        this.core = core;
-    }
-    /**
-     * Distrugge il plugin e libera le risorse
-     */
-    destroy() {
-        try {
-            // Emetti evento di distruzione
-            this.emit("destroyed", {
-                name: this.name,
-                version: this.version,
-            });
-            this.core = null;
-        }
-        catch (error) {
-            console.error(`[${this.name}] Error during plugin destruction:`, error);
-        }
-    }
-    /**
-     * Verifica che il plugin sia stato inizializzato prima di usare il core
-     * @throws Error se il plugin non è stato inizializzato
-     * @returns L'istanza di ShogunCore non null
-     */
-    assertInitialized() {
-        if (!this.core) {
-            throw new Error(`Plugin ${this.name} not initialized`);
-        }
-        return this.core;
-    }
-}
-exports.BasePlugin = BasePlugin;