shogun-core 3.0.0 → 3.0.2

package/dist/core.js

@@ -16,7 +16,7 @@ import { CoreInitializer } from "./managers/CoreInitializer";
  * @since 2.0.0
  */
 export class ShogunCore {
-    static API_VERSION = "^1.6.6";
+    static API_VERSION = "^3.0.1";
     db;
     storage;
     provider;

package/dist/gundb/db.js

@@ -951,11 +951,9 @@ class DataBase {
     async createAliasIndex(username, userPub) {
         try {
             const aliasNode = this.gun.get(`~@${username}`);
-            const ack = await aliasNode
-                .put({
-                "~pubKeyOfUser": this.gun.get(userPub),
-            })
-                .then();
+            // 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}`);
             }
@@ -1824,7 +1822,12 @@ class DataBase {
     }
 }
 const createGun = (config) => {
-    return new Gun(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;

package/dist/gundb/index.js

@@ -1,6 +1,6 @@
 // Export the main class
 export * from "./db";
 // Export improved types
-export * from "./improved-types";
+export * from "./types";
 // Export simplified API
 export * from "./simple-api";

package/dist/managers/CoreInitializer.js

@@ -50,7 +50,7 @@ export class CoreInitializer {
         // Setup wallet derivation
         this.setupWalletDerivation();
         // Initialize RxJS
-        this.core.rx = new RxJS(this.core._gun);
+        this.core.rx = new RxJS(this.core.gun);
         // Register built-in plugins
         this.registerBuiltinPlugins(config);
         // Initialize async components
@@ -60,15 +60,25 @@ export class CoreInitializer {
      * Initialize Gun instance
      */
     async initializeGun(config) {
+        console.log("Initialize Gun instance", config);
         if (config.gunOptions.authToken) {
             restrictedPut(Gun, config.gunOptions.authToken);
         }
         try {
-            if (config.gunInstance) {
+            if (config.gunInstance && config.gunInstance instanceof Gun) {
+                console.log("config.gunInstance", config.gunInstance);
                 this.core._gun = config.gunInstance;
             }
             else {
+                console.log("config.gunOptions", config.gunOptions);
                 this.core._gun = createGun(config.gunOptions);
+                // Explicitly apply peers configuration if not already set
+                if (config.gunOptions?.peers &&
+                    Array.isArray(config.gunOptions.peers)) {
+                    console.log("Applying peers configuration:", config.gunOptions.peers);
+                    this.core._gun.opt({ peers: config.gunOptions.peers });
+                    console.log("Peers after explicit application:", this.core._gun?.opt?.peers);
+                }
             }
         }
         catch (error) {
@@ -78,7 +88,8 @@ export class CoreInitializer {
             throw new Error(`Failed to create Gun instance: ${error}`);
         }
         try {
-            this.core.db = new DataBase(this.core._gun, config.gunOptions.scope || "");
+            console.log("Initialize Gun instance", this.core.gun);
+            this.core.db = new DataBase(this.core.gun, config.gunOptions.scope || "");
             this.core._gun = this.core.db.gun;
         }
         catch (error) {
@@ -93,9 +104,7 @@ export class CoreInitializer {
      */
     async initializeGunUser() {
         try {
-            this.core._user = this.core._gun
-                .user()
-                .recall({ sessionStorage: true });
+            this.core.user = this.core.gun.user().recall({ sessionStorage: true });
         }
         catch (error) {
             if (typeof console !== "undefined" && console.error) {
@@ -103,10 +112,8 @@ export class CoreInitializer {
             }
             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.gun.on("auth", (user) => {
+            this.core.user = this.core.gun.user().recall({ sessionStorage: true });
             this.core.emit("auth:login", {
                 userPub: user.pub,
                 method: "password",
@@ -139,7 +146,7 @@ export class CoreInitializer {
      * Setup wallet derivation
      */
     setupWalletDerivation() {
-        this.core._gun.on("auth", async (user) => {
+        this.core.gun.on("auth", async (user) => {
             if (!user)
                 return;
             const priv = user._?.sea?.epriv;

package/dist/types/core.d.ts

@@ -6,6 +6,7 @@ import { ethers } from "ethers";
 import { ShogunPlugin } from "./interfaces/plugin";
 import { ISEAPair } from "gun";
 import { DataBase, RxJS, GunInstance, GunUserInstance } from "./gundb";
+import { PluginManager } from "./managers/PluginManager";
 /**
  * Main ShogunCore class - implements the IShogunCore interface
  *
@@ -18,16 +19,16 @@ import { DataBase, RxJS, GunInstance, GunUserInstance } from "./gundb";
  * @since 2.0.0
  */
 export declare class ShogunCore implements IShogunCore {
-    static readonly API_VERSION = "^1.6.6";
+    static readonly API_VERSION = "^3.0.1";
     db: DataBase;
     storage: ShogunStorage;
     provider?: ethers.Provider;
     config: ShogunCoreConfig;
     rx: RxJS;
-    private _gun;
-    private _user;
+    _gun: GunInstance;
+    _user: GunUserInstance | null;
     wallets: Wallets | undefined;
-    private pluginManager;
+    pluginManager: PluginManager;
     private authManager;
     private eventManager;
     private coreInitializer;
@@ -197,7 +198,10 @@ export declare class ShogunCore implements IShogunCore {
      * @returns The authentication plugin or undefined if not available
      * This is a more modern approach to accessing authentication methods
      */
-    getAuthenticationMethod(type: AuthMethod): unknown;
+    getAuthenticationMethod(type: AuthMethod): ShogunPlugin | {
+        login: (username: string, password: string) => Promise<AuthResult>;
+        signUp: (username: string, password: string, confirm?: string) => Promise<SignUpResult>;
+    } | undefined;
     /**
      * Retrieve recent errors logged by the system
      * @param count - Number of errors to retrieve (default: 10)

package/dist/types/gundb/db.d.ts

@@ -5,7 +5,7 @@
  * - Direct authentication through Gun.user()
  */
 import type { GunUser, UserInfo, AuthCallback, GunData, EventData, EventListener, GunOperationResult } from "./types";
-import type { GunInstance, GunUserInstance, GunChain } from "./improved-types";
+import type { GunInstance, GunUserInstance, GunChain } from "./types";
 import type { AuthResult, SignUpResult } from "../interfaces/shogun";
 import Gun from "gun/gun";
 import SEA from "gun/sea";
@@ -19,7 +19,7 @@ import "gun/lib/wire";
 import "gun/lib/axe";
 import { restrictedPut } from "./restricted-put";
 import derive, { DeriveOptions } from "./derive";
-import type { IGunInstance, ISEAPair } from "gun/types";
+import type { ISEAPair } from "gun/types";
 import { GunDataEventData, GunPeerEventData } from "../interfaces/events";
 import { RxJS } from "./rxjs";
 import * as GunErrors from "./errors";
@@ -396,7 +396,7 @@ declare class DataBase {
      */
     isAuthenticated(): boolean;
 }
-declare const createGun: (config: any) => IGunInstance<any>;
+declare const createGun: (config: any) => import("gun").IGunInstance<any>;
 export { Gun, DataBase, SEA, RxJS, crypto, GunErrors, derive, restrictedPut, createGun, };
 export default Gun;
 export type { IGunUserInstance, IGunInstance, IGunChain } from "gun/types";

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

@@ -1,3 +1,3 @@
 export * from "./db";
-export * from "./improved-types";
+export * from "./types";
 export * from "./simple-api";

package/dist/types/gundb/rxjs.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from "rxjs";
-import { GunInstance, GunUserInstance } from "./improved-types";
+import { GunInstance, GunUserInstance } from "./types";
 /**
  * RxJS Integration for GunDB
  * Provides reactive programming capabilities for GunDB data

package/dist/types/gundb/types.d.ts

@@ -1,7 +1,6 @@
 /**
  * Type definitions for GunDB to replace 'any' usage
  */
-import type { IGunUserInstance, IGunInstance } from "gun/types";
 export type GunType = (config?: any) => IGunInstance<any>;
 export type SEAType = any;
 export type GunUser = IGunUserInstance<any>;
@@ -156,3 +155,110 @@ export interface GunOperationResult {
     success: boolean;
     error?: string;
 }
+/**
+ * Improved type definitions to reduce 'any' usage while maintaining GunDB compatibility
+ */
+import type { IGunUserInstance, IGunInstance, IGunChain, ISEAPair } from "gun/types";
+export type GunInstance = IGunInstance<any>;
+export type GunUserInstance = IGunUserInstance<any>;
+export type GunChain = IGunChain<any, IGunInstance<any>, IGunInstance<any>, string>;
+export interface GunAckCallback {
+    (ack: {
+        err?: string;
+        ok?: number;
+        pub?: string;
+    }): void;
+}
+export interface TypedGunOperationResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    ack?: {
+        err?: string;
+        ok?: number;
+        pub?: string;
+    };
+}
+export interface TypedUserInfo {
+    pub: string;
+    alias?: string;
+    timestamp?: number;
+    user?: GunUserInstance;
+    metadata?: Record<string, unknown>;
+}
+export interface TypedAuthCallback {
+    (user: GunUserInstance): void;
+}
+export interface TypedAuthResult {
+    success: boolean;
+    userPub?: string;
+    username?: string;
+    error?: string;
+    ack?: {
+        err?: string;
+        ok?: number;
+        pub?: string;
+        sea?: ISEAPair;
+    };
+    sea?: ISEAPair;
+}
+export interface TypedGunConfig {
+    peers?: string[];
+    localStorage?: boolean;
+    radisk?: boolean;
+    file?: string;
+    uuid?: () => string;
+    [key: string]: unknown;
+}
+export interface TypedEventData {
+    type: string;
+    data: unknown;
+    timestamp: number;
+    source?: string;
+}
+export type GunPath = string | string[];
+export interface PathOperation<T = unknown> {
+    path: GunPath;
+    data?: T;
+    callback?: GunAckCallback;
+}
+export interface TypedRxJSObservable<T = unknown> {
+    subscribe: (observer: {
+        next: (value: T) => void;
+        error?: (error: Error) => void;
+        complete?: () => void;
+    }) => {
+        unsubscribe: () => void;
+    };
+}
+export interface TypedPluginConfig {
+    name: string;
+    version: string;
+    enabled: boolean;
+    config?: Record<string, unknown>;
+}
+export interface TypedStorageData {
+    key: string;
+    value: unknown;
+    timestamp: number;
+    ttl?: number;
+}
+export interface TypedGunError extends Error {
+    code?: string;
+    type: "GUN_ERROR" | "AUTH_ERROR" | "NETWORK_ERROR" | "VALIDATION_ERROR";
+    context?: Record<string, unknown>;
+}
+export type GunOperation = "get" | "put" | "set" | "remove" | "once" | "on" | "off";
+export type GunAuthMethod = "password" | "pair" | "webauthn" | "web3" | "nostr";
+export interface TypedGunWrapper<T = Record<string, unknown>> {
+    gun: GunInstance;
+    user: GunUserInstance | null;
+    get(path: GunPath): Promise<T>;
+    put(path: GunPath, data: T): Promise<TypedGunOperationResult<T>>;
+    set(path: GunPath, data: T): Promise<TypedGunOperationResult<T>>;
+    remove(path: GunPath): Promise<TypedGunOperationResult>;
+    getUserData(path: string): Promise<T>;
+    putUserData(path: string, data: T): Promise<void>;
+    login(username: string, password: string): Promise<TypedAuthResult>;
+    signUp(username: string, password: string): Promise<TypedAuthResult>;
+}

package/dist/types/interfaces/plugin.d.ts

@@ -42,7 +42,7 @@ export interface PluginManager {
      * @returns Il plugin richiesto o undefined se non trovato
      * @template T Tipo del plugin o dell'interfaccia pubblica del plugin
      */
-    getPlugin<T>(name: string): T | undefined;
+    getPlugin<T = ShogunPlugin>(name: string): T | undefined;
     /**
      * Verifica se un plugin è registrato
      * @param name Nome del plugin da verificare
@@ -55,4 +55,108 @@ export interface PluginManager {
      * @returns Array di plugin della categoria specificata
      */
     getPluginsByCategory(category: PluginCategory): ShogunPlugin[];
+    /**
+     * Ottiene informazioni su tutti i plugin registrati
+     * @returns Array di oggetti con informazioni sui plugin
+     */
+    getPluginsInfo(): Array<{
+        name: string;
+        version: string;
+        category?: PluginCategory;
+        description?: string;
+    }>;
+    /**
+     * Ottiene il numero totale di plugin registrati
+     * @returns Numero di plugin registrati
+     */
+    getPluginCount(): number;
+    /**
+     * Verifica se tutti i plugin sono inizializzati correttamente
+     * @returns Oggetto con stato di inizializzazione per ogni plugin
+     */
+    getPluginsInitializationStatus(): Record<string, {
+        initialized: boolean;
+        error?: string;
+    }>;
+    /**
+     * Valida l'integrità del sistema di plugin
+     * @returns Oggetto con risultati della validazione
+     */
+    validatePluginSystem(): {
+        totalPlugins: number;
+        initializedPlugins: number;
+        failedPlugins: string[];
+        warnings: string[];
+    };
+    /**
+     * Tenta di reinizializzare i plugin falliti
+     * @returns Oggetto con risultati della reinizializzazione
+     */
+    reinitializeFailedPlugins(): {
+        success: string[];
+        failed: Array<{
+            name: string;
+            error: string;
+        }>;
+    };
+    /**
+     * Verifica la compatibilità dei plugin con la versione corrente di ShogunCore
+     * @returns Oggetto con informazioni sulla compatibilità
+     */
+    checkPluginCompatibility(): {
+        compatible: Array<{
+            name: string;
+            version: string;
+        }>;
+        incompatible: Array<{
+            name: string;
+            version: string;
+            reason: string;
+        }>;
+        unknown: Array<{
+            name: string;
+            version: string;
+        }>;
+    };
+    /**
+     * Ottiene informazioni complete di debug sul sistema di plugin
+     * @returns Informazioni complete di debug del sistema di plugin
+     */
+    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;
+            }>;
+        };
+    };
 }

package/dist/types/interfaces/shogun.d.ts

@@ -1,4 +1,4 @@
-import { GunInstance, GunUserInstance } from "../gundb/improved-types";
+import { GunInstance, GunUserInstance } from "../gundb/types";
 import { ISEAPair } from "gun";
 import { ethers } from "ethers";
 import { ShogunError } from "../utils/errorHandler";
@@ -6,6 +6,7 @@ import { DataBase } from "../gundb/db";
 import { RxJS } from "../gundb/rxjs";
 import { ShogunPlugin, PluginManager } from "./plugin";
 import { ShogunStorage } from "../storage/storage";
+import { ShogunEventMap } from "./events";
 /**
  * Standard plugin categories in ShogunCore
  */
@@ -114,6 +115,7 @@ export interface SignUpResult {
 }
 export interface IShogunCore extends PluginManager {
     gun: GunInstance;
+    _gun: GunInstance;
     user: GunUserInstance | null;
     db: DataBase;
     rx: RxJS;
@@ -121,21 +123,28 @@ export interface IShogunCore extends PluginManager {
     config: ShogunCoreConfig;
     provider?: ethers.Provider;
     signer?: ethers.Signer;
-    on(eventName: string | symbol, listener: (...args: any[]) => void): any;
-    off(eventName: string | symbol, listener: (...args: any[]) => void): any;
-    once(eventName: string | symbol, listener: (...args: any[]) => void): any;
-    removeAllListeners(eventName?: string | symbol): any;
-    emit(eventName: string | symbol, ...args: any[]): boolean;
+    wallets?: Wallets;
+    pluginManager: any;
+    on<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
+    off<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
+    once<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
+    removeAllListeners(eventName?: string | symbol): this;
+    emit<K extends keyof ShogunEventMap>(eventName: K, data?: ShogunEventMap[K] extends void ? never : ShogunEventMap[K]): boolean;
     getRecentErrors(count?: number): ShogunError[];
-    login(username: string, password: string): Promise<AuthResult>;
+    login(username: string, password: string, pair?: ISEAPair | null): Promise<AuthResult>;
+    loginWithPair(pair: ISEAPair): Promise<AuthResult>;
     signUp(username: string, password?: string, pair?: ISEAPair | null): Promise<SignUpResult>;
     getAuthenticationMethod(type: AuthMethod): any;
+    setAuthMethod(method: AuthMethod): void;
+    getAuthMethod(): AuthMethod | undefined;
     getCurrentUser(): {
         pub: string;
         user?: any;
     } | null;
+    getIsLoggedIn(): boolean;
     logout(): void;
     isLoggedIn(): boolean;
+    saveCredentials(credentials: any): Promise<void>;
 }
 /**
  * WebAuthn configuration

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

@@ -65,5 +65,8 @@ export declare class AuthManager {
      * @returns The authentication plugin or undefined if not available
      * This is a more modern approach to accessing authentication methods
      */
-    getAuthenticationMethod(type: AuthMethod): unknown;
+    getAuthenticationMethod(type: AuthMethod): import("..").ShogunPlugin | {
+        login: (username: string, password: string) => Promise<AuthResult>;
+        signUp: (username: string, password: string, confirm?: string) => Promise<SignUpResult>;
+    } | undefined;
 }

package/package.json

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

package/dist/gundb/improved-types.js

@@ -1,4 +0,0 @@
-/**
- * Improved type definitions to reduce 'any' usage while maintaining GunDB compatibility
- */
-export {};

package/dist/types/gundb/improved-types.d.ts

@@ -1,123 +0,0 @@
-/**
- * Improved type definitions to reduce 'any' usage while maintaining GunDB compatibility
- */
-import type { IGunUserInstance, IGunInstance, IGunChain, ISEAPair } from "gun/types";
-export type GunInstance = IGunInstance<any>;
-export type GunUserInstance = IGunUserInstance<any>;
-export type GunChain = IGunChain<any, IGunInstance<any>, IGunInstance<any>, string>;
-export interface GunData {
-    [key: string]: unknown;
-}
-export interface GunNodeData {
-    [key: string]: unknown;
-    _?: {
-        "#": string;
-        ">": Record<string, number>;
-    };
-}
-export interface GunAckCallback {
-    (ack: {
-        err?: string;
-        ok?: number;
-        pub?: string;
-    }): void;
-}
-export interface GunDataCallback<T = unknown> {
-    (data: T, key: string): void;
-}
-export interface GunMapCallback<T = unknown> {
-    (data: T, key: string): void;
-}
-export interface TypedGunOperationResult<T = unknown> {
-    success: boolean;
-    data?: T;
-    error?: string;
-    ack?: {
-        err?: string;
-        ok?: number;
-        pub?: string;
-    };
-}
-export interface TypedUserInfo {
-    pub: string;
-    alias?: string;
-    timestamp?: number;
-    user?: GunUserInstance;
-    metadata?: Record<string, unknown>;
-}
-export interface TypedAuthCallback {
-    (user: GunUserInstance): void;
-}
-export interface TypedAuthResult {
-    success: boolean;
-    userPub?: string;
-    username?: string;
-    error?: string;
-    ack?: {
-        err?: string;
-        ok?: number;
-        pub?: string;
-        sea?: ISEAPair;
-    };
-    sea?: ISEAPair;
-}
-export interface TypedGunConfig {
-    peers?: string[];
-    localStorage?: boolean;
-    radisk?: boolean;
-    file?: string;
-    uuid?: () => string;
-    [key: string]: unknown;
-}
-export interface TypedEventData {
-    type: string;
-    data: unknown;
-    timestamp: number;
-    source?: string;
-}
-export type GunPath = string | string[];
-export interface PathOperation<T = unknown> {
-    path: GunPath;
-    data?: T;
-    callback?: GunAckCallback;
-}
-export interface TypedRxJSObservable<T = unknown> {
-    subscribe: (observer: {
-        next: (value: T) => void;
-        error?: (error: Error) => void;
-        complete?: () => void;
-    }) => {
-        unsubscribe: () => void;
-    };
-}
-export interface TypedPluginConfig {
-    name: string;
-    version: string;
-    enabled: boolean;
-    config?: Record<string, unknown>;
-}
-export interface TypedStorageData {
-    key: string;
-    value: unknown;
-    timestamp: number;
-    ttl?: number;
-}
-export interface TypedGunError extends Error {
-    code?: string;
-    type: "GUN_ERROR" | "AUTH_ERROR" | "NETWORK_ERROR" | "VALIDATION_ERROR";
-    context?: Record<string, unknown>;
-}
-export type GunOperation = "get" | "put" | "set" | "remove" | "once" | "on" | "off";
-export type GunAuthMethod = "password" | "pair" | "webauthn" | "web3" | "nostr";
-export interface TypedGunWrapper<T = Record<string, unknown>> {
-    gun: GunInstance;
-    user: GunUserInstance | null;
-    get(path: GunPath): Promise<T>;
-    put(path: GunPath, data: T): Promise<TypedGunOperationResult<T>>;
-    set(path: GunPath, data: T): Promise<TypedGunOperationResult<T>>;
-    remove(path: GunPath): Promise<TypedGunOperationResult>;
-    getUserData(path: string): Promise<T>;
-    putUserData(path: string, data: T): Promise<void>;
-    login(username: string, password: string): Promise<TypedAuthResult>;
-    signUp(username: string, password: string): Promise<TypedAuthResult>;
-}