shogun-core 2.0.3 → 3.0.0

package/dist/types/{types → interfaces}/shogun.d.ts

@@ -1,4 +1,5 @@
-import { IGunInstance } from "gun/types";
+import { GunInstance, GunUserInstance } from "../gundb/improved-types";
+import { ISEAPair } from "gun";
 import { ethers } from "ethers";
 import { ShogunError } from "../utils/errorHandler";
 import { DataBase } from "../gundb/db";
@@ -37,7 +38,7 @@ export declare enum CorePlugins {
     /** OAuth plugin */
     OAuth = "oauth"
 }
-export type AuthMethod = "password" | "webauthn" | "web3" | "nostr" | "oauth" | "bitcoin" | "pair";
+export type AuthMethod = "password" | "webauthn" | "web3" | "nostr" | "oauth" | "pair";
 export interface AuthResult {
     success: boolean;
     error?: string;
@@ -112,7 +113,8 @@ export interface SignUpResult {
     };
 }
 export interface IShogunCore extends PluginManager {
-    gun: IGunInstance<any>;
+    gun: GunInstance;
+    user: GunUserInstance | null;
     db: DataBase;
     rx: RxJS;
     storage: ShogunStorage;
@@ -126,7 +128,7 @@ export interface IShogunCore extends PluginManager {
     emit(eventName: string | symbol, ...args: any[]): boolean;
     getRecentErrors(count?: number): ShogunError[];
     login(username: string, password: string): Promise<AuthResult>;
-    signUp(username: string, password: string, passwordConfirmation?: string): Promise<SignUpResult>;
+    signUp(username: string, password?: string, pair?: ISEAPair | null): Promise<SignUpResult>;
     getAuthenticationMethod(type: AuthMethod): any;
     getCurrentUser(): {
         pub: string;
@@ -150,12 +152,8 @@ export interface WebauthnConfig {
  * Shogun SDK configuration
  */
 export interface ShogunCoreConfig {
-    gunInstance?: IGunInstance<any>;
-    authToken?: string;
-    scope?: string;
-    peers?: string[];
-    localStorage?: boolean;
-    radisk?: boolean;
+    gunInstance?: GunInstance;
+    gunOptions?: any;
     webauthn?: WebauthnConfig;
     web3?: {
         enabled?: boolean;

package/dist/types/managers/AuthManager.d.ts

@@ -0,0 +1,69 @@
+import { IShogunCore, AuthResult, SignUpResult, AuthMethod } from "../interfaces/shogun";
+import { ISEAPair } from "gun";
+/**
+ * Manages authentication operations for ShogunCore
+ */
+export declare class AuthManager {
+    private core;
+    private currentAuthMethod?;
+    constructor(core: IShogunCore);
+    /**
+     * 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(): boolean;
+    /**
+     * 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(): void;
+    /**
+     * 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.
+     */
+    login(username: string, password: string, pair?: ISEAPair | null): Promise<AuthResult>;
+    /**
+     * 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.
+     */
+    loginWithPair(pair: ISEAPair): Promise<AuthResult>;
+    /**
+     * 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.
+     */
+    signUp(username: string, password?: string, pair?: ISEAPair | null): Promise<SignUpResult>;
+    /**
+     * 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: AuthMethod): void;
+    /**
+     * Get the current authentication method
+     * @returns The current authentication method or undefined if not set
+     */
+    getAuthMethod(): AuthMethod | undefined;
+    /**
+     * 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: AuthMethod): unknown;
+}

package/dist/types/managers/CoreInitializer.d.ts

@@ -0,0 +1,40 @@
+import { IShogunCore, ShogunCoreConfig } from "../interfaces/shogun";
+/**
+ * Handles initialization of ShogunCore components
+ */
+export declare class CoreInitializer {
+    private core;
+    constructor(core: IShogunCore);
+    /**
+     * 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.
+     */
+    initialize(config: ShogunCoreConfig): Promise<void>;
+    /**
+     * Initialize Gun instance
+     */
+    private initializeGun;
+    /**
+     * Initialize Gun user
+     */
+    private initializeGunUser;
+    /**
+     * Setup Gun event forwarding
+     */
+    private setupGunEventForwarding;
+    /**
+     * Setup wallet derivation
+     */
+    private setupWalletDerivation;
+    /**
+     * Register built-in plugins based on configuration
+     */
+    private registerBuiltinPlugins;
+    /**
+     * Initialize async components
+     */
+    private initializeAsync;
+}

package/dist/types/managers/EventManager.d.ts

@@ -0,0 +1,49 @@
+import { ShogunEventEmitter, ShogunEventMap } from "../interfaces/events";
+/**
+ * Manages event operations for ShogunCore
+ */
+export declare class EventManager {
+    private eventEmitter;
+    constructor();
+    /**
+     * Emits an event through the core's event emitter.
+     * Plugins should use this method to emit events instead of accessing the private eventEmitter directly.
+     * @param eventName The name of the event to emit.
+     * @param data The data to pass with the event.
+     * @returns {boolean} Indicates if the event had listeners.
+     */
+    emit<K extends keyof ShogunEventMap>(eventName: K, data?: ShogunEventMap[K] extends void ? never : ShogunEventMap[K]): boolean;
+    /**
+     * Add an event listener
+     * @param eventName The name of the event to listen for
+     * @param listener The callback function to execute when the event is emitted
+     * @returns {this} Returns this instance for method chaining
+     */
+    on<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
+    /**
+     * Add a one-time event listener
+     * @param eventName The name of the event to listen for
+     * @param listener The callback function to execute when the event is emitted
+     * @returns {this} Returns this instance for method chaining
+     */
+    once<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
+    /**
+     * Remove an event listener
+     * @param eventName The name of the event to stop listening for
+     * @param listener The callback function to remove
+     * @returns {this} Returns this instance for method chaining
+     */
+    off<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
+    /**
+     * Remove all listeners for a specific event or all events
+     * @param eventName Optional. The name of the event to remove listeners for.
+     * If not provided, all listeners for all events are removed.
+     * @returns {this} Returns this instance for method chaining
+     */
+    removeAllListeners(eventName?: string | symbol): this;
+    /**
+     * Get the underlying event emitter instance
+     * @returns The ShogunEventEmitter instance
+     */
+    getEventEmitter(): ShogunEventEmitter;
+}

package/dist/types/managers/PluginManager.d.ts

@@ -0,0 +1,145 @@
+import { ShogunPlugin } from "../interfaces/plugin";
+import { PluginCategory } from "../interfaces/shogun";
+import { IShogunCore } from "../interfaces/shogun";
+/**
+ * Manages plugin registration, validation, and lifecycle
+ */
+export declare class PluginManager {
+    private plugins;
+    private core;
+    constructor(core: IShogunCore);
+    /**
+     * 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: ShogunPlugin): void;
+    /**
+     * Unregister a plugin from the Shogun SDK
+     * @param name Name of the plugin to unregister
+     */
+    unregister(name: string): boolean;
+    /**
+     * 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<T = ShogunPlugin>(name: string): T | undefined;
+    /**
+     * Get information about all registered plugins
+     * @returns Array of plugin information objects
+     */
+    getPluginsInfo(): Array<{
+        name: string;
+        version: string;
+        category?: PluginCategory;
+        description?: string;
+    }>;
+    /**
+     * Get the total number of registered plugins
+     * @returns Number of registered plugins
+     */
+    getPluginCount(): number;
+    /**
+     * Check if all plugins are properly initialized
+     * @returns Object with initialization status for each plugin
+     */
+    getPluginsInitializationStatus(): Record<string, {
+        initialized: boolean;
+        error?: string;
+    }>;
+    /**
+     * Validate plugin system integrity
+     * @returns Object with validation results
+     */
+    validatePluginSystem(): {
+        totalPlugins: number;
+        initializedPlugins: number;
+        failedPlugins: string[];
+        warnings: string[];
+    };
+    /**
+     * Attempt to reinitialize failed plugins
+     * @returns Object with reinitialization results
+     */
+    reinitializeFailedPlugins(): {
+        success: string[];
+        failed: Array<{
+            name: string;
+            error: string;
+        }>;
+    };
+    /**
+     * Check plugin compatibility with current ShogunCore version
+     * @returns Object with compatibility information
+     */
+    checkPluginCompatibility(): {
+        compatible: Array<{
+            name: string;
+            version: string;
+        }>;
+        incompatible: Array<{
+            name: string;
+            version: string;
+            reason: string;
+        }>;
+        unknown: Array<{
+            name: string;
+            version: string;
+        }>;
+    };
+    /**
+     * Get comprehensive debug information about the plugin system
+     * @returns Complete plugin system debug information
+     */
+    getPluginSystemDebugInfo(): {
+        shogunCoreVersion: string;
+        totalPlugins: number;
+        plugins: Array<{
+            name: string;
+            version: string;
+            category?: PluginCategory;
+            description?: string;
+            initialized: boolean;
+            error?: string;
+        }>;
+        initializationStatus: Record<string, {
+            initialized: boolean;
+            error?: string;
+        }>;
+        validation: {
+            totalPlugins: number;
+            initializedPlugins: number;
+            failedPlugins: string[];
+            warnings: string[];
+        };
+        compatibility: {
+            compatible: Array<{
+                name: string;
+                version: string;
+            }>;
+            incompatible: Array<{
+                name: string;
+                version: string;
+                reason: string;
+            }>;
+            unknown: Array<{
+                name: string;
+                version: string;
+            }>;
+        };
+    };
+    /**
+     * 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: string): boolean;
+    /**
+     * Get all plugins of a specific category
+     * @param category Category of plugins to filter
+     * @returns Array of plugins in the specified category
+     */
+    getPluginsByCategory(category: PluginCategory): ShogunPlugin[];
+}

package/dist/types/migration-test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Migration test file to verify that the refactored ShogunCore
+ * maintains the same public API as the original implementation
+ */
+/**
+ * Test function to verify API compatibility
+ */
+export declare function testApiCompatibility(): void;
+/**
+ * Test that the refactored implementation maintains the same static properties
+ */
+export declare function testStaticProperties(): void;
+/**
+ * Run all compatibility tests
+ */
+export declare function runCompatibilityTests(): void;

package/dist/types/plugins/base.d.ts

@@ -1,6 +1,6 @@
 import { ShogunCore } from "../core";
-import { ShogunPlugin } from "../types/plugin";
-import { PluginCategory } from "../types/shogun";
+import { ShogunPlugin } from "../interfaces/plugin";
+import { PluginCategory } from "../interfaces/shogun";
 import { EventEmitter } from "../utils/eventEmitter";
 /**
  * Classe base per tutti i plugin di ShogunCore

package/dist/types/plugins/index.d.ts

@@ -1,5 +1,5 @@
 export { BasePlugin } from "./base";
-export type { ShogunPlugin, PluginManager } from "../types/plugin";
+export type { ShogunPlugin, PluginManager } from "../interfaces/plugin";
 export { Webauthn } from "./webauthn/webauthn";
 export { WebauthnPlugin } from "./webauthn/webauthnPlugin";
 export type { WebauthnPluginInterface } from "./webauthn/types";

package/dist/types/plugins/nostr/nostrConnectorPlugin.d.ts

@@ -2,7 +2,7 @@ import { BasePlugin } from "../base";
 import { ShogunCore } from "../../core";
 import { NostrSigningCredential } from "./nostrSigner";
 import { NostrConnectorCredentials, ConnectionResult, NostrConnectorPluginInterface } from "./types";
-import { AuthResult, SignUpResult } from "../../types/shogun";
+import { AuthResult, SignUpResult } from "../../interfaces/shogun";
 /**
  * Plugin for managing Bitcoin wallet functionality in ShogunCore
  * Supports Alby, Nostr extensions, or direct key management

package/dist/types/plugins/nostr/types.d.ts

@@ -1,5 +1,5 @@
-import { BaseConfig, BaseResult, BaseCacheEntry } from "../../types/common";
-import { AuthResult, SignUpResult } from "../../types/shogun";
+import { BaseConfig, BaseResult, BaseCacheEntry } from "../../interfaces/common";
+import { AuthResult, SignUpResult } from "../../interfaces/shogun";
 /**
  * Result of connection attempt
  */

package/dist/types/plugins/oauth/oauthPlugin.d.ts

@@ -1,7 +1,7 @@
 import { BasePlugin } from "../base";
 import { ShogunCore } from "../../core";
 import { OAuthPluginInterface, OAuthConfig, OAuthProvider, OAuthConnectionResult, OAuthCredentials, OAuthUserInfo } from "./types";
-import { AuthResult, SignUpResult } from "../../types/shogun";
+import { AuthResult, SignUpResult } from "../../interfaces/shogun";
 /**
  * OAuth Plugin for ShogunCore
  * Provides authentication with external OAuth providers

package/dist/types/plugins/oauth/types.d.ts

@@ -1,5 +1,5 @@
-import { BaseConfig, BaseResult, BaseCacheEntry } from "../../types/common";
-import { AuthResult, SignUpResult } from "../../types/shogun";
+import { BaseConfig, BaseResult, BaseCacheEntry } from "../../interfaces/common";
+import { AuthResult, SignUpResult } from "../../interfaces/shogun";
 /**
  * Supported OAuth providers
  */

package/dist/types/plugins/web3/types.d.ts

@@ -1,6 +1,6 @@
 import { ISEAPair } from "gun";
-import { BaseConfig, BaseResult, BaseCacheEntry } from "../../types/common";
-import { AuthResult, SignUpResult } from "../../types/shogun";
+import { BaseConfig, BaseResult, BaseCacheEntry } from "../../interfaces/common";
+import { AuthResult, SignUpResult } from "../../interfaces/shogun";
 /**
  * Result of connection attempt
  */

package/dist/types/plugins/web3/web3ConnectorPlugin.d.ts

@@ -3,7 +3,7 @@ import { ShogunCore } from "../../core";
 import { Web3SigningCredential } from "./web3Signer";
 import { ConnectionResult, Web3ConnectorPluginInterface } from "./types";
 import { ethers } from "ethers";
-import { AuthResult, SignUpResult } from "../../types/shogun";
+import { AuthResult, SignUpResult } from "../../interfaces/shogun";
 import { ISEAPair } from "gun";
 /**
  * Plugin per la gestione delle funzionalità Web3 in ShogunCore

package/dist/types/plugins/webauthn/types.d.ts

@@ -1,5 +1,5 @@
-import { AuthResult, SignUpResult } from "../../types/shogun";
-import { BaseEvent, BaseConfig, BaseDeviceInfo, BaseResult, BaseAuthResult } from "../../types/common";
+import { AuthResult, SignUpResult } from "../../interfaces/shogun";
+import { BaseEvent, BaseConfig, BaseDeviceInfo, BaseResult, BaseAuthResult } from "../../interfaces/common";
 /**
  * WebAuthn types definitions
  */

package/dist/types/plugins/webauthn/webauthnPlugin.d.ts

@@ -2,7 +2,7 @@ import { BasePlugin } from "../base";
 import { ShogunCore } from "../../core";
 import { WebAuthnSigningCredential } from "./webauthnSigner";
 import { WebAuthnCredentials, CredentialResult, WebauthnPluginInterface, WebAuthnUniformCredentials } from "./types";
-import { AuthResult, SignUpResult } from "../../types/shogun";
+import { AuthResult, SignUpResult } from "../../interfaces/shogun";
 /**
  * Plugin per la gestione delle funzionalità WebAuthn in ShogunCore
  */

package/dist/types/utils/errorHandler.d.ts

@@ -1,4 +1,4 @@
-import { LogLevel } from "../types/common";
+import { LogLevel } from "../interfaces/common";
 /**
  * Types of errors that can occur in the application
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shogun-core",
-  "version": "2.0.3",
+  "version": "3.0.0",
   "description": "SHOGUN CORE - Core library for Shogun Ecosystem",
   "main": "./dist/index.js",
   "module": "./dist/index.js",