shogun-core 5.2.0 → 5.2.2

package/dist/managers/PluginManager.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = void 0;
+/**
+ * Manages plugin registration, validation, and lifecycle
+ */
+class PluginManager {
+    constructor(core) {
+        this.plugins = new Map();
+        this.core = core;
+    }
+    /**
+     * Register a plugin with the Shogun SDK
+     * @param plugin Plugin instance to register
+     * @throws Error if a plugin with the same name is already registered
+     */
+    register(plugin) {
+        try {
+            if (!plugin.name) {
+                if (typeof console !== "undefined" && console.error) {
+                    console.error("Plugin registration failed: Plugin must have a name");
+                }
+                return;
+            }
+            if (this.plugins.has(plugin.name)) {
+                if (typeof console !== "undefined" && console.warn) {
+                    console.warn(`Plugin "${plugin.name}" is already registered. Skipping.`);
+                }
+                return;
+            }
+            // Initialize plugin with core instance
+            plugin.initialize(this.core);
+            this.plugins.set(plugin.name, plugin);
+            this.core.emit("plugin:registered", {
+                name: plugin.name,
+                version: plugin.version || "unknown",
+                category: plugin._category || "unknown",
+            });
+        }
+        catch (error) {
+            if (typeof console !== "undefined" && console.error) {
+                console.error(`Error registering plugin "${plugin.name}":`, error);
+            }
+        }
+    }
+    /**
+     * Unregister a plugin from the Shogun SDK
+     * @param name Name of the plugin to unregister
+     */
+    unregister(name) {
+        try {
+            const plugin = this.plugins.get(name);
+            if (!plugin) {
+                if (typeof console !== "undefined" && console.warn) {
+                    console.warn(`Plugin "${name}" not found for unregistration`);
+                }
+                return false;
+            }
+            // Destroy plugin if it has a destroy method
+            if (typeof plugin.destroy === "function") {
+                try {
+                    plugin.destroy();
+                }
+                catch (destroyError) {
+                    if (typeof console !== "undefined" && console.error) {
+                        console.error(`Error destroying plugin "${name}":`, destroyError);
+                    }
+                }
+            }
+            this.plugins.delete(name);
+            this.core.emit("plugin:unregistered", {
+                name: plugin.name,
+            });
+            return true;
+        }
+        catch (error) {
+            if (typeof console !== "undefined" && console.error) {
+                console.error(`Error unregistering plugin "${name}":`, error);
+            }
+            return false;
+        }
+    }
+    /**
+     * Retrieve a registered plugin by name
+     * @param name Name of the plugin
+     * @returns The requested plugin or undefined if not found
+     * @template T Type of the plugin or its public interface
+     */
+    getPlugin(name) {
+        if (!name || typeof name !== "string") {
+            if (typeof console !== "undefined" && console.warn) {
+                console.warn("Invalid plugin name provided to getPlugin");
+            }
+            return undefined;
+        }
+        const plugin = this.plugins.get(name);
+        if (!plugin) {
+            if (typeof console !== "undefined" && console.warn) {
+                console.warn(`Plugin "${name}" not found`);
+            }
+            return undefined;
+        }
+        return plugin;
+    }
+    /**
+     * Get information about all registered plugins
+     * @returns Array of plugin information objects
+     */
+    getPluginsInfo() {
+        const pluginsInfo = [];
+        this.plugins.forEach((plugin) => {
+            pluginsInfo.push({
+                name: plugin.name,
+                version: plugin.version || "unknown",
+                category: plugin._category,
+                description: plugin.description,
+            });
+        });
+        return pluginsInfo;
+    }
+    /**
+     * Get the total number of registered plugins
+     * @returns Number of registered plugins
+     */
+    getPluginCount() {
+        return this.plugins.size;
+    }
+    /**
+     * Check if all plugins are properly initialized
+     * @returns Object with initialization status for each plugin
+     */
+    getPluginsInitializationStatus() {
+        const status = {};
+        this.plugins.forEach((plugin, name) => {
+            try {
+                // Verifica se il plugin ha un metodo per controllare l'inizializzazione
+                if (typeof plugin.assertInitialized === "function") {
+                    plugin.assertInitialized();
+                    status[name] = { initialized: true };
+                }
+                else {
+                    // Fallback: verifica se il plugin ha un riferimento al core
+                    status[name] = {
+                        initialized: !!plugin.core,
+                        error: !plugin.core
+                            ? "No core reference found"
+                            : undefined,
+                    };
+                }
+            }
+            catch (error) {
+                status[name] = {
+                    initialized: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+        return status;
+    }
+    /**
+     * Validate plugin system integrity
+     * @returns Object with validation results
+     */
+    validatePluginSystem() {
+        const status = this.getPluginsInitializationStatus();
+        const totalPlugins = Object.keys(status).length;
+        const initializedPlugins = Object.values(status).filter((s) => s.initialized).length;
+        const failedPlugins = Object.entries(status)
+            .filter(([_, s]) => !s.initialized)
+            .map(([name, _]) => name);
+        const warnings = [];
+        if (totalPlugins === 0) {
+            warnings.push("No plugins registered");
+        }
+        if (failedPlugins.length > 0) {
+            warnings.push(`Failed plugins: ${failedPlugins.join(", ")}`);
+        }
+        return {
+            totalPlugins,
+            initializedPlugins,
+            failedPlugins,
+            warnings,
+        };
+    }
+    /**
+     * Attempt to reinitialize failed plugins
+     * @returns Object with reinitialization results
+     */
+    reinitializeFailedPlugins() {
+        const status = this.getPluginsInitializationStatus();
+        const failedPlugins = Object.entries(status)
+            .filter(([_, s]) => !s.initialized)
+            .map(([name, _]) => name);
+        const success = [];
+        const failed = [];
+        failedPlugins.forEach((pluginName) => {
+            try {
+                const plugin = this.plugins.get(pluginName);
+                if (!plugin) {
+                    failed.push({ name: pluginName, error: "Plugin not found" });
+                    return;
+                }
+                // Reinizializza il plugin
+                plugin.initialize(this.core);
+                success.push(pluginName);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                failed.push({ name: pluginName, error: errorMessage });
+                if (typeof console !== "undefined" && console.error) {
+                    console.error(`[PluginManager] Failed to reinitialize plugin ${pluginName}:`, error);
+                }
+            }
+        });
+        return { success, failed };
+    }
+    /**
+     * Check plugin compatibility with current ShogunCore version
+     * @returns Object with compatibility information
+     */
+    checkPluginCompatibility() {
+        const compatible = [];
+        const incompatible = [];
+        const unknown = [];
+        this.plugins.forEach((plugin) => {
+            const pluginInfo = {
+                name: plugin.name,
+                version: plugin.version || "unknown",
+            };
+            // Verifica se il plugin ha informazioni di compatibilità
+            if (typeof plugin.getCompatibilityInfo === "function") {
+                try {
+                    const compatibilityInfo = plugin.getCompatibilityInfo();
+                    if (compatibilityInfo && compatibilityInfo.compatible) {
+                        compatible.push(pluginInfo);
+                    }
+                    else {
+                        incompatible.push({
+                            ...pluginInfo,
+                            reason: compatibilityInfo?.reason || "Unknown compatibility issue",
+                        });
+                    }
+                }
+                catch (error) {
+                    unknown.push(pluginInfo);
+                }
+            }
+            else {
+                // Se non ha informazioni di compatibilità, considera sconosciuto
+                unknown.push(pluginInfo);
+            }
+        });
+        return { compatible, incompatible, unknown };
+    }
+    /**
+     * Get comprehensive debug information about the plugin system
+     * @returns Complete plugin system debug information
+     */
+    getPluginSystemDebugInfo() {
+        const pluginsInfo = this.getPluginsInfo();
+        const initializationStatus = this.getPluginsInitializationStatus();
+        const plugins = pluginsInfo.map((info) => ({
+            ...info,
+            initialized: initializationStatus[info.name]?.initialized || false,
+            error: initializationStatus[info.name]?.error,
+        }));
+        return {
+            shogunCoreVersion: "^1.6.6",
+            totalPlugins: this.getPluginCount(),
+            plugins,
+            initializationStatus,
+            validation: this.validatePluginSystem(),
+            compatibility: this.checkPluginCompatibility(),
+        };
+    }
+    /**
+     * Check if a plugin is registered
+     * @param name Name of the plugin to check
+     * @returns true if the plugin is registered, false otherwise
+     */
+    hasPlugin(name) {
+        return this.plugins.has(name);
+    }
+    /**
+     * Get all plugins of a specific category
+     * @param category Category of plugins to filter
+     * @returns Array of plugins in the specified category
+     */
+    getPluginsByCategory(category) {
+        const result = [];
+        this.plugins.forEach((plugin) => {
+            if (plugin._category === category) {
+                result.push(plugin);
+            }
+        });
+        return result;
+    }
+}
+exports.PluginManager = PluginManager;

package/dist/plugins/base.js

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

package/dist/plugins/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartWalletPlugin = exports.CredentialType = exports.ZkCredentials = exports.ZkProofPlugin = exports.ZkProofConnector = exports.NostrConnectorPlugin = exports.NostrConnector = exports.Web3ConnectorPlugin = exports.Web3Connector = exports.WebauthnPlugin = exports.Webauthn = exports.BasePlugin = void 0;
+// Base plugin interface and types
+var base_1 = require("./base");
+Object.defineProperty(exports, "BasePlugin", { enumerable: true, get: function () { return base_1.BasePlugin; } });
+// WebAuthn plugin exports
+var webauthn_1 = require("./webauthn/webauthn");
+Object.defineProperty(exports, "Webauthn", { enumerable: true, get: function () { return webauthn_1.Webauthn; } });
+var webauthnPlugin_1 = require("./webauthn/webauthnPlugin");
+Object.defineProperty(exports, "WebauthnPlugin", { enumerable: true, get: function () { return webauthnPlugin_1.WebauthnPlugin; } });
+// Ethereum plugin exports
+var web3Connector_1 = require("./web3/web3Connector");
+Object.defineProperty(exports, "Web3Connector", { enumerable: true, get: function () { return web3Connector_1.Web3Connector; } });
+var web3ConnectorPlugin_1 = require("./web3/web3ConnectorPlugin");
+Object.defineProperty(exports, "Web3ConnectorPlugin", { enumerable: true, get: function () { return web3ConnectorPlugin_1.Web3ConnectorPlugin; } });
+// Bitcoin plugin exports
+var nostrConnector_1 = require("./nostr/nostrConnector");
+Object.defineProperty(exports, "NostrConnector", { enumerable: true, get: function () { return nostrConnector_1.NostrConnector; } });
+var nostrConnectorPlugin_1 = require("./nostr/nostrConnectorPlugin");
+Object.defineProperty(exports, "NostrConnectorPlugin", { enumerable: true, get: function () { return nostrConnectorPlugin_1.NostrConnectorPlugin; } });
+// ZK-Proof plugin exports
+var zkProofConnector_1 = require("./zkproof/zkProofConnector");
+Object.defineProperty(exports, "ZkProofConnector", { enumerable: true, get: function () { return zkProofConnector_1.ZkProofConnector; } });
+var zkProofPlugin_1 = require("./zkproof/zkProofPlugin");
+Object.defineProperty(exports, "ZkProofPlugin", { enumerable: true, get: function () { return zkProofPlugin_1.ZkProofPlugin; } });
+var zkCredentials_1 = require("./zkproof/zkCredentials");
+Object.defineProperty(exports, "ZkCredentials", { enumerable: true, get: function () { return zkCredentials_1.ZkCredentials; } });
+Object.defineProperty(exports, "CredentialType", { enumerable: true, get: function () { return zkCredentials_1.CredentialType; } });
+// Smart Wallet plugin exports
+var smartWalletPlugin_1 = require("./smartwallet/smartWalletPlugin");
+Object.defineProperty(exports, "SmartWalletPlugin", { enumerable: true, get: function () { return smartWalletPlugin_1.SmartWalletPlugin; } });

package/dist/plugins/nostr/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./nostrConnectorPlugin"), exports);
+__exportStar(require("./nostrConnector"), exports);
+__exportStar(require("./nostrSigner"), exports);
+__exportStar(require("./types"), exports);