shogun-core 5.2.2 → 6.0.0

package/dist/index.js

@@ -34,10 +34,10 @@ Object.defineProperty(exports, "quickStart", { enumerable: true, get: function (
 Object.defineProperty(exports, "createSimpleAPI", { enumerable: true, get: function () { return gundb_1.createSimpleAPI; } });
 Object.defineProperty(exports, "AutoQuickStart", { enumerable: true, get: function () { return gundb_1.AutoQuickStart; } });
 Object.defineProperty(exports, "autoQuickStart", { enumerable: true, get: function () { return gundb_1.autoQuickStart; } });
-const db_2 = require("./gundb/db");
-Object.defineProperty(exports, "SEA", { enumerable: true, get: function () { return db_2.SEA; } });
-const db_3 = __importDefault(require("./gundb/db"));
-exports.Gun = db_3.default;
+const gun_1 = __importDefault(require("gun"));
+exports.Gun = gun_1.default;
+const sea_1 = __importDefault(require("gun/sea"));
+exports.SEA = sea_1.default;
 __exportStar(require("./utils/errorHandler"), exports);
 __exportStar(require("./plugins"), exports);
 __exportStar(require("./interfaces/shogun"), exports);

package/dist/managers/CoreInitializer.js

@@ -61,37 +61,43 @@ class CoreInitializer {
     /**
      * Initialize Gun instance
      */
-    // Sì, è corretto.
     initializeGun(config) {
         try {
-            if (config.gunInstance) {
-                console.log("Using existing Gun instance:", config.gunInstance);
-                this.core._gun = config.gunInstance;
+            if (!config.gunInstance) {
+                throw new Error("Gun instance is required but was not provided");
             }
-            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);
+            // Validate Gun instance
+            if (typeof config.gunInstance !== "object") {
+                throw new Error(`Gun instance must be an object, received: ${typeof config.gunInstance}`);
             }
-            else if (config.gunInstance && config.gunOptions) {
-                throw new Error("Gun instance and gun options cannot be provided together");
-                return false;
+            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 creating Gun instance:", error);
+                console.error("Error validating Gun instance:", error);
             }
-            return false;
+            throw new Error(`Failed to validate Gun instance: ${error}`);
         }
         try {
-            this.core.db = new gundb_1.DataBase(this.core._gun, config.gunOptions?.scope || "", this.core);
+            this.core.db = new gundb_1.DataBase(this.core._gun, "shogun", // Default app scope
+            this.core);
             return true;
         }
         catch (error) {
             if (typeof console !== "undefined" && console.error) {
-                console.error("Error initializing GunInstance:", error);
+                console.error("Error initializing DataBase:", error);
             }
-            throw new Error(`Failed to initialize GunInstance: ${error}`);
+            throw new Error(`Failed to initialize DataBase: ${error}`);
         }
     }
     /**

package/dist/managers/CryptoIdentityManager.js

@@ -21,8 +21,9 @@ const errorHandler_1 = require("../utils/errorHandler");
  * Genera automaticamente tutte le identità crypto disponibili dopo l'autenticazione SEA
  */
 class CryptoIdentityManager {
-    constructor(core) {
+    constructor(core, db) {
         this.core = core;
+        this.db = db || core.db; // Use core.db if db not provided
         this.pgpManager = new pgp_1.PGPManager();
         this.mlsManager = new mls_1.MLSManager("default-user");
         this.sframeManager = new sframe_1.SFrameManager();
@@ -109,6 +110,11 @@ class CryptoIdentityManager {
                 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,
@@ -144,41 +150,76 @@ class CryptoIdentityManager {
             }
             // Salva su GunDB nel percorso privato dell'utente
             const saveResult = await new Promise((resolve, reject) => {
-                this.core.gun
-                    .user()
-                    .get("crypto-identities")
-                    .put(encryptedIdentities, (ack) => {
-                    if (ack.err) {
-                        console.error(`❌ [${username}] Failed to save identities:`, ack.err);
-                        reject(new Error(ack.err));
-                    }
-                    else {
-                        console.log(`✅ [${username}] Crypto identities saved successfully`);
-                        savedKeys.push("crypto-identities");
-                        resolve(true);
-                    }
-                });
+                const timeout = setTimeout(() => {
+                    console.warn(`⚠️ [${username}] Save identities timeout after 5 seconds, continuing anyway`);
+                    savedKeys.push("crypto-identities");
+                    resolve(true); // Resolve anyway to not block the process
+                }, 5000); // 5 second timeout
+                try {
+                    this.db.gun
+                        .user()
+                        .get("crypto-identities")
+                        .put(encryptedIdentities, (ack) => {
+                        clearTimeout(timeout);
+                        if (ack && ack.err) {
+                            console.error(`❌ [${username}] Failed to save identities:`, ack.err);
+                            reject(new Error(ack.err));
+                        }
+                        else {
+                            console.log(`✅ [${username}] Crypto identities saved successfully`);
+                            savedKeys.push("crypto-identities");
+                            resolve(true);
+                        }
+                    });
+                }
+                catch (putError) {
+                    clearTimeout(timeout);
+                    console.error(`❌ [${username}] Error during put operation:`, putError);
+                    // Don't reject, just resolve to not block - Gun might save eventually
+                    savedKeys.push("crypto-identities");
+                    resolve(true);
+                }
             });
             // Salva anche una copia di backup nel percorso pubblico (solo hash per verifica)
             const identitiesHash = await sea_1.default.work(identitiesJson, null, null, {
                 name: "SHA-256",
             });
             await new Promise((resolve, reject) => {
-                this.core.gun
-                    .user()
-                    .get("crypto-identities-hash")
-                    .put(identitiesHash, (ack) => {
-                    if (ack.err) {
-                        console.error(`❌ [${username}] Failed to save identities hash:`, ack.err);
-                        reject(new Error(ack.err));
-                    }
-                    else {
-                        console.log(`✅ [${username}] Crypto identities hash saved`);
-                        savedKeys.push("crypto-identities-hash");
-                        resolve(true);
-                    }
-                });
+                const timeout = setTimeout(() => {
+                    console.warn(`⚠️ [${username}] Save identities hash timeout after 5 seconds, continuing anyway`);
+                    savedKeys.push("crypto-identities-hash");
+                    resolve(true); // Resolve anyway to not block the process
+                }, 5000); // 5 second timeout
+                try {
+                    this.db.gun
+                        .user()
+                        .get("crypto-identities-hash")
+                        .put(identitiesHash, (ack) => {
+                        clearTimeout(timeout);
+                        if (ack && ack.err) {
+                            console.error(`❌ [${username}] Failed to save identities hash:`, ack.err);
+                            reject(new Error(ack.err));
+                        }
+                        else {
+                            console.log(`✅ [${username}] Crypto identities hash saved`);
+                            savedKeys.push("crypto-identities-hash");
+                            resolve(true);
+                        }
+                    });
+                }
+                catch (putError) {
+                    clearTimeout(timeout);
+                    console.error(`❌ [${username}] Error during hash put operation:`, putError);
+                    // Don't reject, just resolve to not block - Gun might save eventually
+                    savedKeys.push("crypto-identities-hash");
+                    resolve(true);
+                }
             });
+            // Force garbage collection after saving
+            if (typeof global !== "undefined" && global.gc) {
+                global.gc();
+                console.log(`🧹 [${username}] Forced garbage collection after saving identities`);
+            }
             return {
                 success: true,
                 savedKeys,
@@ -205,7 +246,7 @@ class CryptoIdentityManager {
             console.log(`🔍 [CryptoIdentityManager] Retrieving crypto identities for: ${username}`);
             // Recupera le identità criptate da GunDB
             const encryptedIdentities = await new Promise((resolve, reject) => {
-                this.core.gun
+                this.db.gun
                     .user()
                     .get("crypto-identities")
                     .once((data) => {
@@ -257,7 +298,7 @@ class CryptoIdentityManager {
     async hasStoredIdentities(username) {
         try {
             const hasIdentities = await new Promise((resolve) => {
-                this.core.gun
+                this.db.gun
                     .user()
                     .get("crypto-identities")
                     .once((data) => {
@@ -344,7 +385,13 @@ class CryptoIdentityManager {
                 };
             }
             // Ottieni il SEA pair dell'utente corrente
-            const userInstance = this.core.gun.user();
+            if (!this.db || !this.db.gun) {
+                return {
+                    success: false,
+                    error: "Database not available",
+                };
+            }
+            const userInstance = this.db.gun.user();
             const seaPair = userInstance?._?.sea;
             if (!seaPair) {
                 return {

package/dist/plugins/zkproof/zkCredentials.js

@@ -78,7 +78,10 @@ class ZkCredentials {
             const externalNullifier = BigInt(ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(credentialData.type)));
             // Generate ZK proof
             // Note: This requires circuit files to be available
-            const fullProof = await (0, proof_1.generateProof)(identity, group, signalBigInt, externalNullifier);
+            const fullProof = await (0, proof_1.generateProof)(identity, group, signalBigInt, externalNullifier, {
+                wasmFilePath: "./circuits/semaphore/20/semaphore.wasm",
+                zkeyFilePath: "./circuits/semaphore/20/semaphore.zkey",
+            });
             return {
                 type: credentialData.type,
                 claim: credentialData.claim,

package/dist/types/config/simplified-config.d.ts

@@ -1,48 +1,98 @@
 /**
  * Simplified configuration options to reduce complexity
  * Provides sensible defaults and easy-to-use presets
+ *
+ * NOTE: This file is deprecated. ShogunCore now requires an existing Gun instance.
+ * Use the examples in the examples/ directory for proper usage.
  */
 import { ShogunCoreConfig } from "../interfaces/shogun";
+import "gun/lib/then";
+import "gun/lib/radix";
+import "gun/lib/radisk";
+import "gun/lib/store";
+import "gun/lib/rindexed";
+import "gun/lib/webrtc";
+/**
+ * Helper functions to create Gun instances with common configurations
+ * These functions create Gun instances that can be passed to ShogunCore
+ */
+export declare const GunInstanceHelpers: {
+    /**
+     * Create a minimal Gun instance for simple apps
+     */
+    minimal: () => import("gun").IGunInstance<any>;
+    /**
+     * Create a development Gun instance with local storage
+     */
+    development: () => import("gun").IGunInstance<any>;
+    /**
+     * Create a production Gun instance with multiple peers
+     */
+    production: (customPeers?: string[]) => import("gun").IGunInstance<any>;
+    /**
+     * Create an offline-first Gun instance
+     */
+    offline: () => import("gun").IGunInstance<any>;
+    /**
+     * Create a Gun instance for Web3-enabled apps
+     */
+    web3: () => import("gun").IGunInstance<any>;
+    /**
+     * Create a Gun instance for WebAuthn-enabled apps
+     */
+    webauthn: () => import("gun").IGunInstance<any>;
+};
 /**
  * Preset configurations for common use cases
+ * @deprecated Use GunInstanceHelpers to create Gun instances and pass them to ShogunCore
  */
 export declare const ShogunPresets: {
     /**
      * Minimal configuration for simple apps
+     * @deprecated Use GunInstanceHelpers.minimal() instead
      */
     minimal: () => ShogunCoreConfig;
     /**
      * Development configuration with local storage
+     * @deprecated Use GunInstanceHelpers.development() instead
      */
     development: () => ShogunCoreConfig;
     /**
      * Production configuration with multiple peers
+     * @deprecated Use GunInstanceHelpers.production() instead
      */
     production: (customPeers?: string[]) => ShogunCoreConfig;
     /**
      * Offline-first configuration
+     * @deprecated Use GunInstanceHelpers.offline() instead
      */
     offline: () => ShogunCoreConfig;
     /**
      * Web3-enabled configuration
+     * @deprecated Use GunInstanceHelpers.web3() instead
      */
     web3: () => ShogunCoreConfig;
     /**
      * WebAuthn-enabled configuration
+     * @deprecated Use GunInstanceHelpers.webauthn() instead
      */
     webauthn: () => ShogunCoreConfig;
 };
 /**
  * Configuration builder for custom setups
+ * @deprecated Use GunInstanceHelpers to create Gun instances and pass them to ShogunCore
  */
 export declare class ShogunConfigBuilder {
     private config;
+    private gunOptions;
     /**
-     * Set Gun options
+     * Set Gun options (deprecated - use GunInstanceHelpers instead)
+     * @deprecated Use GunInstanceHelpers to create Gun instances
      */
-    gunOptions(options: any): this;
+    setGunOptions(options: any): this;
     /**
-     * Add peers
+     * Add peers (deprecated - use GunInstanceHelpers instead)
+     * @deprecated Use GunInstanceHelpers to create Gun instances
      */
     peers(peerList: string[]): this;
     /**
@@ -67,48 +117,59 @@ export declare class ShogunConfigBuilder {
     }): this;
     /**
      * Build the final configuration
+     * @deprecated Use GunInstanceHelpers to create Gun instances and pass them to ShogunCore
      */
     build(): ShogunCoreConfig;
 }
 /**
  * Helper functions for common configuration patterns
+ * @deprecated Use GunInstanceHelpers to create Gun instances and pass them to ShogunCore
  */
 export declare const ConfigHelpers: {
     /**
      * Create a configuration for a specific environment
+     * @deprecated Use GunInstanceHelpers instead
      */
     forEnvironment(env: "development" | "production" | "test"): ShogunCoreConfig;
     /**
      * Create a configuration with custom peers
+     * @deprecated Use GunInstanceHelpers.production(peers) instead
      */
     withPeers(peers: string[]): ShogunCoreConfig;
     /**
      * Create a configuration for a specific use case
+     * @deprecated Use GunInstanceHelpers instead
      */
     forUseCase(useCase: "chat" | "social" | "gaming" | "finance"): ShogunCoreConfig;
 };
 /**
  * Quick configuration functions
+ * @deprecated Use GunInstanceHelpers to create Gun instances and pass them to ShogunCore
  */
 export declare const QuickConfig: {
     /**
      * Minimal setup for quick testing
+     * @deprecated Use GunInstanceHelpers.minimal() instead
      */
     test: () => ShogunCoreConfig;
     /**
      * Standard setup for most apps
+     * @deprecated Use GunInstanceHelpers.production() instead
      */
     standard: () => ShogunCoreConfig;
     /**
      * Setup with WebAuthn for secure apps
+     * @deprecated Use GunInstanceHelpers.webauthn() instead
      */
     secure: () => ShogunCoreConfig;
     /**
      * Setup with Web3 for crypto apps
+     * @deprecated Use GunInstanceHelpers.web3() instead
      */
     crypto: () => ShogunCoreConfig;
     /**
      * Offline setup for local development
+     * @deprecated Use GunInstanceHelpers.offline() instead
      */
     local: () => ShogunCoreConfig;
 };

package/dist/types/crypto/sframe.d.ts

@@ -38,6 +38,10 @@ export declare class SFrameManager {
      * RFC 9605 Section 5.2: MLS-based key management
      */
     deriveKeyFromMLSSecret(mlsSecret: ArrayBuffer, keyId: number, context?: string): Promise<SFrameKey>;
+    /**
+     * Set a shared SFrame key (e.g., from another member)
+     */
+    setSharedKey(sframeKey: SFrameKey): Promise<void>;
     /**
      * Set the active encryption key
      */

package/dist/types/examples/mls-3-member-test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MLS 3-Member Test
+ * Test specifico per gruppi di 3 membri
+ */
+declare function testMLS3Members(): Promise<void>;
+export { testMLS3Members };

package/dist/types/examples/mls-multi-member.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MLS Working Multi-Member Test
+ * Usa l'approccio corretto basato sull'implementazione funzionante
+ */
+declare function testMLSWorkingMultiMembers(): Promise<void>;
+export { testMLSWorkingMultiMembers };

package/dist/types/examples/mls-simple-test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Simple MLS Test
+ * Minimal test to verify MLS functionality
+ */
+declare function testMLS(): Promise<void>;
+export { testMLS };

package/dist/types/examples/shogun-core-example.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ShogunCore Example with Existing Gun Instance
+ *
+ * This example shows how to use ShogunCore with an existing Gun instance.
+ * ShogunCore now requires an existing Gun instance to be passed in.
+ */
+declare function shogunCoreExample(): Promise<void>;
+export { shogunCoreExample };

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

@@ -9,6 +9,7 @@
  * - High-level user data helpers (profile, settings, collections)
  */
 import { DataBase } from "./db";
+import { IGunInstance } from "gun/types";
 /**
  * Simple API wrapper that provides high-level helper methods.
  * For basic operations, use the DataBase instance directly via the `database` property.
@@ -154,18 +155,14 @@ export declare class QuickStart {
     get database(): DataBase;
 }
 /**
- * Auto Quick Start helper - creates a simple API with automatic Gun instance creation
- * No need to pass a Gun instance, it creates one automatically
+ * Auto Quick Start helper - creates a simple API with an existing Gun instance
+ * Requires a Gun instance to be passed in
  */
 export declare class AutoQuickStart {
     private db;
     private simpleAPI;
     private gunInstance;
-    constructor(config?: {
-        peers?: string[];
-        appScope?: string;
-        [key: string]: any;
-    });
+    constructor(gunInstance: IGunInstance, appScope?: string);
     init(): Promise<void>;
     get api(): SimpleGunAPI;
     get database(): DataBase;
@@ -176,10 +173,6 @@ export declare class AutoQuickStart {
  */
 export declare function quickStart(gunInstance: any, appScope?: string): QuickStart;
 /**
- * Global helper for auto quick setup - creates Gun instance automatically
+ * Global helper for auto quick setup - requires existing Gun instance
  */
-export declare function autoQuickStart(config?: {
-    peers?: string[];
-    appScope?: string;
-    [key: string]: any;
-}): AutoQuickStart;
+export declare function autoQuickStart(gunInstance: IGunInstance, appScope?: string): AutoQuickStart;