shogun-core 5.2.2 → 6.0.0

package/dist/examples/mls-multi-member.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * MLS Working Multi-Member Test
+ * Usa l'approccio corretto basato sull'implementazione funzionante
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testMLSWorkingMultiMembers = testMLSWorkingMultiMembers;
+const crypto_1 = require("../crypto");
+async function testMLSWorkingMultiMembers() {
+    console.log("🚀 Starting MLS Working Multi-Member Test");
+    console.log("=".repeat(50));
+    const members = ["alice", "bob", "charlie", "david", "eve"];
+    const managers = new Map();
+    try {
+        // Step 1: Initialize all managers
+        console.log("\n📋 Step 1: Initializing all managers");
+        for (const memberId of members) {
+            const manager = new crypto_1.MLSManager(memberId);
+            await manager.initialize();
+            managers.set(memberId, manager);
+            console.log(`✅ ${memberId} initialized`);
+        }
+        // Step 2: Alice creates group
+        console.log("\n📋 Step 2: Creating group");
+        const groupId = "working-multi-member-group";
+        const alice = managers.get("alice");
+        await alice.createGroup(groupId);
+        console.log("✅ Group created by Alice");
+        // Step 3: Add all members at once (this is the key!)
+        console.log("\n📋 Step 3: Adding all members at once");
+        const otherMembers = members.slice(1); // bob, charlie, david, eve
+        const keyPackages = otherMembers.map((id) => managers.get(id).getKeyPackage());
+        console.log(`➕ Adding ${otherMembers.length} members: ${otherMembers.join(", ")}`);
+        const addResult = await alice.addMembers(groupId, keyPackages);
+        console.log("✅ All members added by Alice");
+        // Step 4: All other members join via welcome
+        console.log("\n📋 Step 4: All members join via welcome");
+        for (const memberId of otherMembers) {
+            const manager = managers.get(memberId);
+            await manager.processWelcome(addResult.welcome, addResult.ratchetTree);
+            console.log(`✅ ${memberId} joined group`);
+        }
+        // Step 5: Verify synchronization
+        console.log("\n📋 Step 5: Verifying synchronization");
+        const epochInfos = new Map();
+        for (const memberId of members) {
+            const info = await managers.get(memberId).getGroupKeyInfo(groupId);
+            epochInfos.set(memberId, info?.epoch);
+        }
+        console.log("📊 Epoch verification:");
+        for (const [memberId, epoch] of epochInfos) {
+            console.log(`  ${memberId}: ${epoch}`);
+        }
+        const epochs = Array.from(epochInfos.values());
+        const allSameEpoch = epochs.every((epoch) => epoch === epochs[0]);
+        if (!allSameEpoch) {
+            console.log(`❌ CRITICAL: Members at different epochs - aborting test`);
+            return;
+        }
+        console.log(`✅ All ${members.length} members synchronized at epoch ${epochs[0]}`);
+        // Step 6: Test message exchange
+        console.log("\n📋 Step 6: Testing message exchange");
+        // Each member sends a message
+        for (const senderId of members) {
+            console.log(`\n💬 ${senderId} sending message...`);
+            const sender = managers.get(senderId);
+            const message = `Hello from ${senderId} to everyone!`;
+            const envelope = await sender.encryptMessage(groupId, message);
+            console.log(`✅ ${senderId} encrypted message`);
+            // All members decrypt the message
+            let successCount = 0;
+            for (const [memberId, manager] of managers) {
+                if (memberId === senderId) {
+                    console.log(`✅ ${memberId} (sender) does not need to decrypt their own message.`);
+                    successCount++;
+                    continue;
+                }
+                try {
+                    const decrypted = await manager.decryptMessage(envelope);
+                    console.log(`✅ ${memberId} decrypted: "${decrypted}"`);
+                    successCount++;
+                }
+                catch (error) {
+                    console.error(`❌ ${memberId} failed to decrypt:`, error);
+                }
+            }
+            if (successCount === members.length) {
+                console.log(`🎉 All ${members.length} members successfully decrypted ${senderId}'s message`);
+            }
+            else {
+                console.log(`⚠️ Only ${successCount}/${members.length} members could decrypt ${senderId}'s message`);
+            }
+        }
+        // Step 7: Test key rotation
+        console.log("\n📋 Step 7: Testing key rotation");
+        const initiator = managers.get("alice");
+        console.log("🔄 Alice initiating key rotation...");
+        const updateCommit = await initiator.updateKey(groupId);
+        console.log("✅ Key rotation commit created");
+        // All members process the update commit
+        for (const [memberId, manager] of managers) {
+            if (memberId === initiator.getUserId()) {
+                console.log(`✅ ${memberId} (initiator) already processed key rotation.`);
+                continue;
+            }
+            try {
+                await manager.processCommit(groupId, updateCommit);
+                console.log(`✅ ${memberId} processed key rotation`);
+            }
+            catch (error) {
+                console.error(`❌ ${memberId} failed to process key rotation:`, error);
+            }
+        }
+        // Step 8: Test messages after key rotation
+        console.log("\n📋 Step 8: Testing messages after key rotation");
+        const testMessage = "This message is sent after key rotation!";
+        const aliceEnvelope = await alice.encryptMessage(groupId, testMessage);
+        let postRotationSuccess = 0;
+        for (const [memberId, manager] of managers) {
+            if (memberId === alice.getUserId()) {
+                console.log(`✅ ${memberId} (sender) does not need to decrypt their own message after rotation.`);
+                postRotationSuccess++;
+                continue;
+            }
+            try {
+                const decrypted = await manager.decryptMessage(aliceEnvelope);
+                console.log(`✅ ${memberId} decrypted after rotation: "${decrypted}"`);
+                postRotationSuccess++;
+            }
+            catch (error) {
+                console.error(`❌ ${memberId} failed to decrypt after rotation:`, error);
+            }
+        }
+        console.log("\n🎉 MLS Working Multi-Member Test completed!");
+        console.log(`✅ Group creation with ${members.length} members`);
+        console.log(`✅ Bidirectional encrypted messaging`);
+        console.log(`✅ Key rotation and forward secrecy`);
+        console.log(`✅ All members can send and receive messages`);
+        // Cleanup
+        console.log("\n📋 Cleanup");
+        for (const [memberId, manager] of managers) {
+            await manager.destroy();
+            console.log(`✅ ${memberId} destroyed`);
+        }
+    }
+    catch (error) {
+        console.error("❌ Test failed:", error);
+    }
+}
+// Run the test
+if (require.main === module) {
+    testMLSWorkingMultiMembers().catch(console.error);
+}

package/dist/examples/mls-sframe-test.js

@@ -39,18 +39,19 @@ async function testMLS() {
         const charlieWelcome = await charlieManager.processWelcome(addResult.welcome, addResult.ratchetTree);
         console.log("✅ Charlie joined group:", charlieWelcome);
         // Alice processes the commit to update her state
-        await aliceManager.processCommit("test-group", addResult.commit);
-        console.log("✅ Alice processed commit");
+        // Alice doesn't need to process the commit - her state is already updated by addMembers()
+        console.log("✅ Alice already synchronized after adding members (state updated by addMembers)");
         // Test messaging
         const message1 = await aliceManager.encryptMessage("test-group", "Hello MLS group!");
         console.log("✅ Message encrypted");
-        const decrypted1 = await aliceManager.decryptMessage(message1);
-        console.log("✅ Message decrypted:", decrypted1);
+        // Alice doesn't need to decrypt her own message, as her state is already updated
+        console.log("✅ Alice (sender) does not need to decrypt her own message.");
         // Test key rotation
         const updateCommit = await aliceManager.updateKey("test-group");
         console.log("✅ Key rotation performed");
         // Process update commit for all members
-        await aliceManager.processCommit("test-group", updateCommit);
+        // Alice doesn't need to process the commit for key rotation - her state is already updated by updateKey()
+        console.log("✅ Alice already synchronized after key rotation (state updated by updateKey)");
         await bobManager.processCommit("test-group", updateCommit);
         await charlieManager.processCommit("test-group", updateCommit);
         console.log("✅ All members processed key rotation");
@@ -89,12 +90,13 @@ async function testSFrame() {
         await aliceManager.initialize();
         await bobManager.initialize();
         console.log("✅ SFrame managers initialized");
-        // Export Alice's key for Bob
-        const aliceKey = await aliceManager.generateKey(0);
-        await bobManager.generateKey(0);
-        // Set Bob to use Alice's key for decryption
+        // Alice generates key and shares with Bob
+        const aliceSFrameKey = await aliceManager.generateKey(0);
+        // Bob uses Alice's key
+        await bobManager.setSharedKey(aliceSFrameKey);
+        // Set active key for both
+        aliceManager.setActiveKey(0);
         bobManager.setActiveKey(0);
-        console.log("✅ Key shared between Alice and Bob");
         // Simulate media frames
         const testFrames = [
             new TextEncoder().encode("Video Frame 1: Hello World!"),
@@ -175,7 +177,8 @@ async function testMLSSFrameIntegration() {
         }
         const addResult = await aliceMLS.addMembers("media-group", [bobKeyPackage]);
         await bobMLS.processWelcome(addResult.welcome, addResult.ratchetTree);
-        await aliceMLS.processCommit("media-group", addResult.commit);
+        // Alice doesn't need to process the commit - her state is already updated by addMembers()
+        console.log("✅ Alice already synchronized after adding members (state updated by addMembers)");
         console.log("✅ MLS group established");
         // Create SFrame managers
         const aliceSFrame = new crypto_1.SFrameManager();

package/dist/examples/mls-simple-test.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Simple MLS Test
+ * Minimal test to verify MLS functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testMLS = testMLS;
+const crypto_1 = require("../crypto");
+async function testMLS() {
+    console.log("🚀 Starting Simple MLS Test");
+    console.log("=".repeat(50));
+    try {
+        // Create managers
+        const alice = new crypto_1.MLSManager("alice");
+        const bob = new crypto_1.MLSManager("bob");
+        // Initialize
+        await alice.initialize();
+        await bob.initialize();
+        console.log("✅ Managers initialized");
+        // Alice creates group
+        const groupId = "test-group";
+        await alice.createGroup(groupId);
+        console.log("✅ Group created");
+        // Add Bob
+        const bobKeyPackage = bob.getKeyPackage();
+        const addResult = await alice.addMembers(groupId, [bobKeyPackage]);
+        console.log("✅ Members added");
+        // Bob joins via welcome
+        await bob.processWelcome(addResult.welcome, addResult.ratchetTree);
+        console.log("✅ Bob joined group");
+        // Test message exchange
+        console.log("\n📋 Testing message exchange");
+        // Alice sends message
+        const envelope1 = await alice.encryptMessage(groupId, "Hello from Alice!");
+        console.log("✅ Alice encrypted message");
+        // Bob decrypts
+        const decrypted1 = await bob.decryptMessage(envelope1);
+        console.log(`✅ Bob decrypted: "${decrypted1}"`);
+        // Bob sends message
+        const envelope2 = await bob.encryptMessage(groupId, "Hello from Bob!");
+        console.log("✅ Bob encrypted message");
+        // Alice decrypts
+        const decrypted2 = await alice.decryptMessage(envelope2);
+        console.log(`✅ Alice decrypted: "${decrypted2}"`);
+        console.log("\n🎉 Simple MLS Test completed successfully!");
+        // Cleanup
+        await alice.destroy();
+        await bob.destroy();
+        console.log("✅ Cleanup completed");
+    }
+    catch (error) {
+        console.error("❌ Test failed:", error);
+    }
+}
+// Run the test
+if (require.main === module) {
+    testMLS().catch(console.error);
+}

package/dist/examples/shogun-core-example.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * 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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shogunCoreExample = shogunCoreExample;
+const gun_1 = __importDefault(require("gun"));
+const core_1 = require("../core");
+async function shogunCoreExample() {
+    console.log("🚀 ShogunCore Example with Existing Gun Instance\n");
+    // === STEP 1: CREATE GUN INSTANCE ===
+    console.log("📦 === CREATING GUN INSTANCE ===\n");
+    const gunInstance = (0, gun_1.default)({
+        peers: ["https://peer.wallie.io/gun", "https://gunjs.herokuapp.com/gun"],
+        radisk: false,
+        localStorage: false,
+    });
+    console.log("✓ Gun instance created");
+    // === STEP 2: INITIALIZE SHOGUN CORE ===
+    console.log("\n🔧 === INITIALIZING SHOGUN CORE ===\n");
+    const shogun = new core_1.ShogunCore({
+        gunInstance: gunInstance, // Required: existing Gun instance
+        webauthn: {
+            enabled: true,
+            rpName: "ShogunCore Example",
+        },
+        web3: {
+            enabled: true,
+        },
+        silent: false, // Enable console logs
+    });
+    console.log("✓ ShogunCore initialized with existing Gun instance");
+    // === STEP 3: USE SHOGUN CORE ===
+    console.log("\n🎯 === USING SHOGUN CORE ===\n");
+    // Access the database
+    const db = shogun.db;
+    console.log("Database available:", !!db);
+    // Check if user is logged in
+    const isLoggedIn = shogun.isLoggedIn();
+    console.log("User logged in:", isLoggedIn);
+    // Example: Sign up a new user
+    console.log("\n--- Sign Up Example ---");
+    const username = `testuser_${Date.now()}`;
+    const password = "testpass123";
+    try {
+        const signupResult = await shogun.signUp(username, password);
+        if (signupResult.success) {
+            console.log("✓ User signed up successfully:", signupResult.username);
+        }
+        else {
+            console.log("❌ Sign up failed:", signupResult.error);
+        }
+    }
+    catch (error) {
+        console.log("❌ Sign up error:", error);
+    }
+    // Example: Login
+    console.log("\n--- Login Example ---");
+    try {
+        const loginResult = await shogun.login(username, password);
+        if (loginResult.success) {
+            console.log("✓ User logged in successfully:", loginResult.username);
+        }
+        else {
+            console.log("❌ Login failed:", loginResult.error);
+        }
+    }
+    catch (error) {
+        console.log("❌ Login error:", error);
+    }
+    // Example: Check current user
+    console.log("\n--- Current User ---");
+    const currentUser = shogun.getCurrentUser();
+    console.log("Current user:", currentUser);
+    // Example: Logout
+    console.log("\n--- Logout Example ---");
+    shogun.logout();
+    console.log("✓ User logged out");
+    console.log("\n🎉 Example completed successfully!");
+}
+// Run the example
+if (require.main === module) {
+    shogunCoreExample().catch(console.error);
+}

package/dist/examples/zkproof-credentials-example.js

@@ -5,12 +5,16 @@
  * This demonstrates how to use ZK-Proof for proving attributes
  * about documents and identity without revealing sensitive data
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ageVerificationExample = ageVerificationExample;
 exports.citizenshipExample = citizenshipExample;
 exports.educationExample = educationExample;
 exports.incomeExample = incomeExample;
 exports.customCredentialExample = customCredentialExample;
+const gun_1 = __importDefault(require("gun"));
 const core_1 = require("../core");
 const zkCredentials_1 = require("../plugins/zkproof/zkCredentials");
 const identity_1 = require("@semaphore-protocol/identity");
@@ -18,7 +22,7 @@ const identity_1 = require("@semaphore-protocol/identity");
 async function ageVerificationExample() {
     console.log("=== Age Verification Example ===\n");
     const shogun = new core_1.ShogunCore({
-        gunOptions: { peers: ["https://peer.wallie.io/gun"] },
+        gunInstance: (0, gun_1.default)({ peers: ["https://peer.wallie.io/gun"] }),
         zkproof: { enabled: true },
     });
     await new Promise((resolve) => setTimeout(resolve, 100));
@@ -58,7 +62,7 @@ async function ageVerificationExample() {
 async function citizenshipExample() {
     console.log("\n=== Citizenship Verification Example ===\n");
     const shogun = new core_1.ShogunCore({
-        gunOptions: { peers: ["https://peer.wallie.io/gun"] },
+        gunInstance: (0, gun_1.default)({ peers: ["https://peer.wallie.io/gun"] }),
         zkproof: { enabled: true },
     });
     await new Promise((resolve) => setTimeout(resolve, 100));
@@ -87,7 +91,7 @@ async function citizenshipExample() {
 async function educationExample() {
     console.log("\n=== Education Credential Example ===\n");
     const shogun = new core_1.ShogunCore({
-        gunOptions: { peers: ["https://peer.wallie.io/gun"] },
+        gunInstance: (0, gun_1.default)({ peers: ["https://peer.wallie.io/gun"] }),
         zkproof: { enabled: true },
     });
     await new Promise((resolve) => setTimeout(resolve, 100));
@@ -119,7 +123,7 @@ async function educationExample() {
 async function incomeExample() {
     console.log("\n=== Income Verification Example ===\n");
     const shogun = new core_1.ShogunCore({
-        gunOptions: { peers: ["https://peer.wallie.io/gun"] },
+        gunInstance: (0, gun_1.default)({ peers: ["https://peer.wallie.io/gun"] }),
         zkproof: { enabled: true },
     });
     await new Promise((resolve) => setTimeout(resolve, 100));
@@ -150,7 +154,7 @@ async function incomeExample() {
 async function customCredentialExample() {
     console.log("\n=== Custom Credential Example ===\n");
     const shogun = new core_1.ShogunCore({
-        gunOptions: { peers: ["https://peer.wallie.io/gun"] },
+        gunInstance: (0, gun_1.default)({ peers: ["https://peer.wallie.io/gun"] }),
         zkproof: { enabled: true },
     });
     await new Promise((resolve) => setTimeout(resolve, 100));

package/dist/examples/zkproof-example.js

@@ -5,20 +5,24 @@
  * This example demonstrates how to use the ZK-Proof plugin with Shogun Core
  * for privacy-preserving authentication using Semaphore protocol.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.basicExample = basicExample;
 exports.deterministicExample = deterministicExample;
 exports.proofExample = proofExample;
 exports.multiDeviceExample = multiDeviceExample;
+const gun_1 = __importDefault(require("gun"));
 const core_1 = require("../core");
 // Example 1: Basic ZK-Proof signup and login
 async function basicExample() {
     console.log("=== Basic ZK-Proof Authentication Example ===\n");
     // Initialize Shogun with ZK-Proof plugin
     const shogun = new core_1.ShogunCore({
-        gunOptions: {
+        gunInstance: (0, gun_1.default)({
             peers: ["https://peer.wallie.io/gun"],
-        },
+        }),
         zkproof: {
             enabled: true,
             defaultGroupId: "my-app-users",
@@ -67,9 +71,9 @@ async function basicExample() {
 async function deterministicExample() {
     console.log("\n=== Deterministic ZK Identity Example ===\n");
     const shogun = new core_1.ShogunCore({
-        gunOptions: {
+        gunInstance: (0, gun_1.default)({
             peers: ["https://peer.wallie.io/gun"],
-        },
+        }),
         zkproof: {
             enabled: true,
             deterministic: true,
@@ -99,9 +103,9 @@ async function deterministicExample() {
 async function proofExample() {
     console.log("\n=== ZK Proof Generation & Verification Example ===\n");
     const shogun = new core_1.ShogunCore({
-        gunOptions: {
+        gunInstance: (0, gun_1.default)({
             peers: ["https://peer.wallie.io/gun"],
-        },
+        }),
         zkproof: {
             enabled: true,
             defaultGroupId: "proof-demo-group",
@@ -148,9 +152,9 @@ async function multiDeviceExample() {
     // Device 1: Create account
     console.log("📱 DEVICE 1: Creating account...");
     const shogun1 = new core_1.ShogunCore({
-        gunOptions: {
+        gunInstance: (0, gun_1.default)({
             peers: ["https://peer.wallie.io/gun"],
-        },
+        }),
         zkproof: { enabled: true },
     });
     // Wait for plugin initialization
@@ -165,9 +169,9 @@ async function multiDeviceExample() {
     // Device 2: Import account
     console.log("\n💻 DEVICE 2: Importing account with trapdoor...");
     const shogun2 = new core_1.ShogunCore({
-        gunOptions: {
+        gunInstance: (0, gun_1.default)({
             peers: ["https://peer.wallie.io/gun"],
-        },
+        }),
         zkproof: { enabled: true },
     });
     // Wait for plugin initialization

package/dist/gundb/api.js

@@ -85,7 +85,8 @@ class SimpleGunAPI {
         console.warn("DEPRECATED: putArray() is unreliable with GunDB. Use direct GunDB operations instead.");
         try {
             const indexed = this.arrayToIndexedObject(arr);
-            await this.db.put(path, indexed);
+            const node = this.db.getNode(path);
+            node.put(indexed);
             return true;
         }
         catch (error) {
@@ -102,7 +103,14 @@ class SimpleGunAPI {
     async getArray(path) {
         console.warn("DEPRECATED: getArray() is unreliable with GunDB. Use direct GunDB operations instead.");
         try {
-            const indexedObj = await this.db.getData(path);
+            const node = this.db.getNode(path);
+            const indexedObj = await new Promise((resolve) => {
+                const timeout = setTimeout(() => resolve(null), 2000);
+                node.once((data) => {
+                    clearTimeout(timeout);
+                    resolve(data);
+                });
+            });
             return this.indexedObjectToArray(indexedObj);
         }
         catch (error) {
@@ -387,19 +395,12 @@ class QuickStart {
 }
 exports.QuickStart = QuickStart;
 /**
- * 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
  */
 class AutoQuickStart {
-    constructor(config) {
-        const gunConfig = {
-            peers: config?.peers || [],
-            ...config,
-        };
-        // Remove appScope from gunConfig as it's not a Gun configuration option
-        delete gunConfig.appScope;
-        this.gunInstance = (0, db_1.createGun)(gunConfig);
-        const appScope = config?.appScope || "shogun";
+    constructor(gunInstance, appScope = "shogun") {
+        this.gunInstance = gunInstance;
         this.db = new db_1.DataBase(this.gunInstance, appScope);
         this.simpleAPI = new SimpleGunAPI(this.db);
     }
@@ -428,8 +429,8 @@ function quickStart(gunInstance, appScope) {
     return new QuickStart(gunInstance, appScope);
 }
 /**
- * Global helper for auto quick setup - creates Gun instance automatically
+ * Global helper for auto quick setup - requires existing Gun instance
  */
-function autoQuickStart(config) {
-    return new AutoQuickStart(config);
+function autoQuickStart(gunInstance, appScope = "shogun") {
+    return new AutoQuickStart(gunInstance, appScope);
 }