shogun-core 5.2.0 → 5.2.2

package/dist/examples/pgp-example.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * PGP Example - Simple and Immediate
+ * Demonstrates basic PGP functionality:
+ * - Key generation
+ * - Message encryption/decryption
+ * - Digital signing
+ * - Signature verification
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simplePGPExample = simplePGPExample;
+exports.advancedPGPExample = advancedPGPExample;
+exports.runAllPGPExamples = runAllPGPExamples;
+const crypto_1 = require("../crypto");
+// Simple PGP usage example
+async function simplePGPExample() {
+    try {
+        console.log("🔐 Starting Simple PGP Example");
+        console.log("=".repeat(40));
+        // Method 1: Using factory functions (simplest)
+        console.log("\n📋 Method 1: Factory Functions");
+        // Generate key pairs
+        const aliceKeys = await (0, crypto_1.generatePGPKeyPair)("Alice", "alice@example.com", "alice123");
+        const bobKeys = await (0, crypto_1.generatePGPKeyPair)("Bob", "bob@example.com", "bob123");
+        console.log("✅ Key pairs generated");
+        console.log("Alice Key ID:", aliceKeys.keyId);
+        console.log("Bob Key ID:", bobKeys.keyId);
+        // Encrypt message from Alice to Bob
+        const message = "Hello Bob! This is a secret message from Alice. 🔐";
+        const encrypted = await (0, crypto_1.encryptPGPMessage)(message, bobKeys.publicKey);
+        console.log("✅ Message encrypted");
+        console.log("Encrypted message length:", encrypted.message.length);
+        // Bob decrypts the message
+        const decrypted = await (0, crypto_1.decryptPGPMessage)(encrypted.message, bobKeys.privateKey, "bob123");
+        console.log("✅ Message decrypted");
+        console.log("Original message:", message);
+        console.log("Decrypted message:", decrypted);
+        console.log("Messages match:", message === decrypted);
+        // Alice signs a message
+        const signedMessage = "This is a signed message from Alice. ✍️";
+        const signature = await (0, crypto_1.signPGPMessage)(signedMessage, aliceKeys.privateKey, "alice123");
+        console.log("✅ Message signed");
+        console.log("Signature length:", signature.signature.length);
+        // Bob verifies Alice's signature
+        const verification = await (0, crypto_1.verifyPGPSignature)(signedMessage, signature.signature, aliceKeys.publicKey);
+        console.log("✅ Signature verified");
+        console.log("Signature valid:", verification.valid);
+        console.log("\n🎉 Simple PGP Example completed successfully!");
+        return {
+            success: true,
+            messageDecrypted: message === decrypted,
+            signatureValid: verification.valid,
+        };
+    }
+    catch (error) {
+        console.error("❌ Simple PGP Example failed:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+// Advanced PGP usage with manager
+async function advancedPGPExample() {
+    let manager;
+    try {
+        console.log("\n🔐 Starting Advanced PGP Example");
+        console.log("=".repeat(40));
+        // Method 2: Using PGPManager (more control)
+        manager = await (0, crypto_1.createPGPManager)();
+        console.log("✅ PGP Manager created");
+        // Generate multiple key pairs
+        const users = [
+            { name: "Alice", email: "alice@example.com", passphrase: "alice123" },
+            { name: "Bob", email: "bob@example.com", passphrase: "bob123" },
+            {
+                name: "Charlie",
+                email: "charlie@example.com",
+                passphrase: "charlie123",
+            },
+        ];
+        const userKeys = new Map();
+        for (const user of users) {
+            const keys = await manager.generateKeyPair(user.name, user.email, user.passphrase);
+            userKeys.set(user.name, keys);
+            console.log(`✅ ${user.name} key pair generated: ${keys.keyId}`);
+        }
+        // Test group messaging (Alice sends to Bob and Charlie)
+        console.log("\n📧 Group Messaging Test");
+        const groupMessage = "Hello everyone! This is a group message from Alice. 👥";
+        // Encrypt for Bob
+        const encryptedForBob = await manager.encryptMessage(groupMessage, userKeys.get("Bob").publicKey, userKeys.get("Alice").privateKey, // Alice signs
+        "alice123");
+        // Encrypt for Charlie
+        const encryptedForCharlie = await manager.encryptMessage(groupMessage, userKeys.get("Charlie").publicKey, userKeys.get("Alice").privateKey, // Alice signs
+        "alice123");
+        console.log("✅ Messages encrypted for Bob and Charlie");
+        // Bob decrypts
+        const bobDecrypted = await manager.decryptMessage(encryptedForBob.message, userKeys.get("Bob").privateKey, "bob123");
+        // Charlie decrypts
+        const charlieDecrypted = await manager.decryptMessage(encryptedForCharlie.message, userKeys.get("Charlie").privateKey, "charlie123");
+        console.log("✅ Messages decrypted by Bob and Charlie");
+        console.log("Bob received:", bobDecrypted);
+        console.log("Charlie received:", charlieDecrypted);
+        // Test key information
+        console.log("\n🔍 Key Information");
+        for (const [name, keys] of userKeys) {
+            const keyInfo = await manager.getKeyInfo(keys.publicKey);
+            console.log(`${name}:`, {
+                keyId: keyInfo.keyId,
+                fingerprint: keyInfo.fingerprint,
+                algorithm: keyInfo.algorithm,
+                created: keyInfo.created,
+                isPrivate: keyInfo.isPrivate,
+                isPublic: keyInfo.isPublic,
+            });
+        }
+        // Test key export/import
+        console.log("\n📤 Key Export/Import Test");
+        const aliceKeyArmored = await manager.exportKey(userKeys.get("Alice").publicKey, "armored");
+        const aliceKeyBinary = await manager.exportKey(userKeys.get("Alice").publicKey, "binary");
+        console.log("✅ Alice's key exported in armored and binary formats");
+        console.log("Armored length:", aliceKeyArmored.length);
+        console.log("Binary length:", aliceKeyBinary.length);
+        // Import the binary key back
+        const importedKey = await manager.importKey(aliceKeyBinary, "binary");
+        console.log("✅ Key imported from binary format");
+        console.log("Imported key matches original:", importedKey === userKeys.get("Alice").publicKey);
+        console.log("\n🎉 Advanced PGP Example completed successfully!");
+        return {
+            success: true,
+            groupMessaging: true,
+            keyManagement: true,
+            exportImport: true,
+        };
+    }
+    catch (error) {
+        console.error("❌ Advanced PGP Example failed:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+    finally {
+        // Clean up
+        if (typeof manager !== "undefined") {
+            manager.destroy();
+        }
+    }
+}
+// Run all examples
+async function runAllPGPExamples() {
+    console.log("🚀 Running All PGP Examples");
+    console.log("=".repeat(50));
+    // Example 1: Simple usage
+    console.log("\n=== Example 1: Simple PGP Usage ===");
+    const simpleResult = await simplePGPExample();
+    // Example 2: Advanced usage
+    console.log("\n=== Example 2: Advanced PGP Usage ===");
+    const advancedResult = await advancedPGPExample();
+    // Example 3: Full demonstration
+    console.log("\n=== Example 3: Full PGP Demonstration ===");
+    const demoResult = await (0, crypto_1.demonstratePGP)();
+    console.log("\n📊 Final Results:");
+    console.log("Simple PGP:", simpleResult.success ? "✅ PASSED" : "❌ FAILED");
+    console.log("Advanced PGP:", advancedResult.success ? "✅ PASSED" : "❌ FAILED");
+    console.log("Full Demo:", demoResult.success ? "✅ PASSED" : "❌ FAILED");
+    const allPassed = simpleResult.success && advancedResult.success && demoResult.success;
+    if (allPassed) {
+        console.log("\n🎉 All PGP examples completed successfully!");
+        console.log("🔐 PGP Features Demonstrated:");
+        console.log("  ✅ Key generation (RSA 4096-bit)");
+        console.log("  ✅ Message encryption/decryption");
+        console.log("  ✅ Digital signing and verification");
+        console.log("  ✅ Key management and information");
+        console.log("  ✅ Key export/import (armored/binary)");
+        console.log("  ✅ Group messaging with signing");
+        console.log("  ✅ OpenPGP standard compliance");
+    }
+    else {
+        console.log("\n❌ Some PGP examples failed");
+    }
+    return {
+        simple: simpleResult,
+        advanced: advancedResult,
+        demo: demoResult,
+        allPassed,
+    };
+}
+// Run the examples
+if (require.main === module) {
+    runAllPGPExamples()
+        .then((result) => {
+        console.log("\n📊 Final Test Summary:");
+        console.log(JSON.stringify(result, null, 2));
+    })
+        .catch((error) => {
+        console.error("💥 PGP examples execution failed:", error);
+    });
+}

package/dist/examples/quick-auth-test.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Quick Auth Test Script
+ *
+ * Simple script to quickly test signup and login functionality
+ * Run this to verify that the authentication system is working
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quickAuthTest = quickAuthTest;
+const api_1 = require("../gundb/api");
+async function quickAuthTest() {
+    console.log("🚀 Quick Authentication Test\n");
+    // Initialize ShogunCore
+    const quickStart = new api_1.AutoQuickStart({
+        peers: ["https://peer.wallie.io/gun"],
+        appScope: "quick-test",
+    });
+    try {
+        await quickStart.init();
+        console.log("✓ ShogunCore initialized");
+    }
+    catch (error) {
+        console.error("❌ Initialization failed:", error);
+        return;
+    }
+    const db = quickStart.api.database;
+    const username = `quicktest_${Date.now()}`;
+    const password = "testpass123";
+    console.log(`Testing with username: ${username}\n`);
+    // Test signup
+    console.log("🔄 Testing signup...");
+    const signupResult = await db.signUp(username, password);
+    if (signupResult.success) {
+        console.log("✓ Signup successful");
+    }
+    else {
+        console.error("❌ Signup failed:", signupResult.error);
+        return;
+    }
+    // Test login
+    console.log("🔄 Testing login...");
+    const loginResult = await db.login(username, password);
+    if (loginResult.success) {
+        console.log("✓ Login successful");
+        console.log("✓ User is logged in:", db.isLoggedIn());
+    }
+    else {
+        console.error("❌ Login failed:", loginResult.error);
+        return;
+    }
+    // Test logout
+    console.log("🔄 Testing logout...");
+    db.logout();
+    console.log("✓ Logout completed");
+    console.log("✓ User is logged out:", !db.isLoggedIn());
+    console.log("\n✅ All tests passed! Authentication system is working correctly.");
+}
+// Run the test
+if (require.main === module) {
+    quickAuthTest().catch(console.error);
+}

package/dist/examples/random-generation-test.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Random Generation test
+const crypto_1 = require("../crypto");
+// Test Random Generation
+async function testRandomGeneration() {
+    try {
+        console.log("🎲 Starting Random Generation test...");
+        // Test 1: Basic random string generation
+        console.log("\n1. Testing basic random string generation...");
+        const randomStr = (0, crypto_1.generateRandomString)(16, "test-");
+        console.log("✅ Random string:", randomStr);
+        // Test 2: Random bytes
+        console.log("\n2. Testing random bytes...");
+        const bytes = (0, crypto_1.randomBytes)(8);
+        console.log("✅ Random bytes:", Array.from(bytes)
+            .map((b) => b.toString(16).padStart(2, "0"))
+            .join(""));
+        // Test 3: Random integer
+        console.log("\n3. Testing random integer...");
+        const randomNum = (0, crypto_1.randomInt)(1, 100);
+        console.log("✅ Random integer (1-100):", randomNum);
+        // Test 4: Random float
+        console.log("\n4. Testing random float...");
+        const randomFloatVal = (0, crypto_1.randomFloat)();
+        console.log("✅ Random float:", randomFloatVal);
+        // Test 5: Random boolean
+        console.log("\n5. Testing random boolean...");
+        const randomBoolVal = (0, crypto_1.randomBool)();
+        console.log("✅ Random boolean:", randomBoolVal);
+        // Test 6: Random UUID
+        console.log("\n6. Testing random UUID...");
+        const uuid = (0, crypto_1.randomUUID)();
+        console.log("✅ Random UUID:", uuid);
+        // Test 7: Deterministic random
+        console.log("\n7. Testing deterministic random...");
+        const detRandom = (0, crypto_1.createDeterministicRandom)("test-seed");
+        const detInt1 = detRandom.integer(1, 100);
+        const detInt2 = detRandom.integer(1, 100);
+        const detFloat = detRandom.floating(0, 1, 4);
+        const detBool = detRandom.bool();
+        const detString = detRandom.string(10);
+        const detGuid = detRandom.guid();
+        console.log("✅ Deterministic integer 1:", detInt1);
+        console.log("✅ Deterministic integer 2:", detInt2);
+        console.log("✅ Deterministic float:", detFloat);
+        console.log("✅ Deterministic boolean:", detBool);
+        console.log("✅ Deterministic string:", detString);
+        console.log("✅ Deterministic GUID:", detGuid);
+        // Test 8: Chance.js compatibility
+        console.log("\n8. Testing Chance.js compatibility...");
+        const chanceInstance = (0, crypto_1.chance)("chance-seed");
+        const chanceInt = chanceInstance.integer(1, 50);
+        const chanceFloat = chanceInstance.floating(0, 10, 2);
+        const chanceBool = chanceInstance.bool();
+        console.log("✅ Chance integer:", chanceInt);
+        console.log("✅ Chance float:", chanceFloat);
+        console.log("✅ Chance boolean:", chanceBool);
+        // Test 9: Array utilities
+        console.log("\n9. Testing array utilities...");
+        const testArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        const choice = (0, crypto_1.randomChoice)(testArray);
+        const shuffled = (0, crypto_1.randomShuffle)(testArray);
+        console.log("✅ Random choice from array:", choice);
+        console.log("✅ Shuffled array:", shuffled);
+        // Test 10: Random color
+        console.log("\n10. Testing random color...");
+        const color = (0, crypto_1.randomColor)();
+        console.log("✅ Random color:", color);
+        // Test 11: Random password
+        console.log("\n11. Testing random password...");
+        const password = (0, crypto_1.randomPassword)({
+            length: 16,
+            includeUppercase: true,
+            includeLowercase: true,
+            includeNumbers: true,
+            includeSymbols: true,
+            excludeSimilar: true,
+        });
+        console.log("✅ Random password:", password);
+        // Test 12: Random seed phrase
+        console.log("\n12. Testing random seed phrase...");
+        const seedPhrase = (0, crypto_1.randomSeedPhrase)(12);
+        console.log("✅ Random seed phrase:", seedPhrase.join(" "));
+        // Test 13: Deterministic consistency
+        console.log("\n13. Testing deterministic consistency...");
+        const det1 = (0, crypto_1.createDeterministicRandom)("consistency-test");
+        const det2 = (0, crypto_1.createDeterministicRandom)("consistency-test");
+        const val1_1 = det1.integer(1, 100);
+        const val1_2 = det1.integer(1, 100);
+        const val2_1 = det2.integer(1, 100);
+        const val2_2 = det2.integer(1, 100);
+        console.log("✅ Deterministic consistency test:");
+        console.log("  Same seed, first value:", val1_1 === val2_1 ? "✅ MATCH" : "❌ MISMATCH");
+        console.log("  Same seed, second value:", val1_2 === val2_2 ? "✅ MATCH" : "❌ MISMATCH");
+        console.log("\n🎉 All Random Generation tests completed successfully!");
+        return {
+            success: true,
+            tests: {
+                randomString: randomStr,
+                randomBytes: Array.from(bytes)
+                    .map((b) => b.toString(16).padStart(2, "0"))
+                    .join(""),
+                randomInt: randomNum,
+                randomFloat: randomFloatVal,
+                randomBool: randomBoolVal,
+                randomUUID: uuid,
+                deterministic: {
+                    int1: detInt1,
+                    int2: detInt2,
+                    float: detFloat,
+                    bool: detBool,
+                    string: detString,
+                    guid: detGuid,
+                },
+                chance: {
+                    int: chanceInt,
+                    float: chanceFloat,
+                    bool: chanceBool,
+                },
+                arrayUtils: {
+                    choice,
+                    shuffledLength: shuffled.length,
+                },
+                color,
+                password,
+                seedPhrase: seedPhrase.join(" "),
+                consistency: {
+                    firstMatch: val1_1 === val2_1,
+                    secondMatch: val1_2 === val2_2,
+                },
+            },
+        };
+    }
+    catch (error) {
+        console.error("❌ Random Generation test error:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+// Run the test
+testRandomGeneration()
+    .then((result) => {
+    console.log("\n📊 Final Result:");
+    console.log(JSON.stringify(result, null, 2));
+})
+    .catch((error) => {
+    console.error("💥 Test execution failed:", error);
+});

package/dist/examples/signal-protocol-test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Signal Protocol test
+const crypto_1 = require("../crypto");
+// Test Signal Protocol
+async function testSignalProtocol() {
+    try {
+        console.log("📡 Starting Signal Protocol test...");
+        const result = await (0, crypto_1.demonstrateSignalProtocol)();
+        if (result.success) {
+            console.log("✅ Signal Protocol test successful!");
+            console.log("Alice and Bob have the same secret:", result.aliceSecret === result.bobSecret);
+            console.log("One-time prekey used:", result.usedOneTimePrekey);
+            console.log("Alice secret (first 20 chars):", result.aliceSecret.substring(0, 20) + "...");
+            console.log("Bob secret (first 20 chars):", result.bobSecret.substring(0, 20) + "...");
+        }
+        else {
+            console.log("❌ Signal Protocol test failed");
+        }
+        return result;
+    }
+    catch (error) {
+        console.error("❌ Signal Protocol test error:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+// Run the test
+testSignalProtocol()
+    .then((result) => {
+    console.log("\n📊 Signal Protocol Result:");
+    console.log(JSON.stringify(result, null, 2));
+})
+    .catch((error) => {
+    console.error("💥 Signal Protocol test execution failed:", error);
+});

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

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Example showing how to use the simplified ShogunCore API
+ *
+ * The API has been streamlined:
+ * - AutoQuickStart: Quick initialization helper
+ * - api.database: Direct access to DataBase for basic operations (get, put, set, remove, auth)
+ * - api helper methods: High-level helpers for profile, settings, collections, and array utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleAPITest = simpleAPITest;
+const api_1 = require("../gundb/api");
+async function simpleAPITest() {
+    console.log("🚀 ShogunCore Simplified API Example\n");
+    // === QUICK START ===
+    console.log("📦 === INITIALIZATION ===\n");
+    // Use AutoQuickStart for easy setup
+    const quickStart = new api_1.AutoQuickStart({
+        peers: ["https://peer.wallie.io/gun"],
+        appScope: "simple-test",
+    });
+    await quickStart.init();
+    // Access the API and database
+    const api = quickStart.api;
+    const db = api.database; // Direct access to DataBase for basic operations
+    console.log("Initialized successfully!");
+    console.log("- api: provides helper methods");
+    console.log("- db (api.database): provides full DataBase functionality\n");
+    // === BASIC OPERATIONS (via database) ===
+    console.log("💾 === BASIC OPERATIONS (use api.database) ===\n");
+    const testData = { message: "Hello World", timestamp: Date.now() };
+    // Use db for basic operations
+    await db.put("global/data", testData);
+    console.log("✓ Saved data with db.put()");
+    const retrieved = await db.getData("global/data");
+    console.log("✓ Retrieved data with db.getData():", retrieved);
+    await db.remove("global/data");
+    console.log("✓ Removed data with db.remove()\n");
+    // === AUTHENTICATION (via database) ===
+    console.log("🔐 === AUTHENTICATION (use api.database) ===\n");
+    const username = "testuser_" + Date.now();
+    const password = "testpass123";
+    const signupResult = await db.signUp(username, password);
+    console.log("✓ Signup:", signupResult.success ? "Success" : "Failed");
+    if (signupResult.success) {
+        const loginResult = await db.login(username, password);
+        console.log("✓ Login:", loginResult.success ? "Success" : "Failed");
+        if (loginResult.success) {
+            console.log("✓ Current user:", db.getCurrentUser()?.alias, "\n");
+            // === HELPER METHODS (via api) ===
+            console.log("⭐ === HELPER METHODS (use api helpers) ===\n");
+            // Profile helper
+            await api.updateProfile({
+                name: "Test User",
+                email: "test@example.com",
+                bio: "Testing the simplified API",
+            });
+            console.log("✓ Profile updated with api.updateProfile()");
+            const profile = await api.getProfile();
+            console.log("✓ Profile retrieved:", profile);
+            // Settings helper
+            await api.saveSettings({
+                theme: "dark",
+                language: "en",
+                notifications: true,
+            });
+            console.log("✓ Settings saved with api.saveSettings()");
+            const settings = await api.getSettings();
+            console.log("✓ Settings retrieved:", settings);
+            // Collections helper
+            await api.createCollection("favorites", {
+                item1: { id: "item1", title: "First Item" },
+                item2: { id: "item2", title: "Second Item" },
+            });
+            console.log("✓ Collection created with api.createCollection()");
+            await api.addToCollection("favorites", "item3", {
+                id: "item3",
+                title: "Third Item",
+            });
+            console.log("✓ Item added with api.addToCollection()");
+            const collection = await api.getCollection("favorites");
+            console.log("✓ Collection retrieved:", collection);
+            // === ARRAY UTILITIES ===
+            console.log("\n🔧 === ARRAY UTILITIES ===\n");
+            const items = [
+                { id: "1", name: "Item 1", value: 100 },
+                { id: "2", name: "Item 2", value: 200 },
+                { id: "3", name: "Item 3", value: 300 },
+            ];
+            // Convert array to GunDB-friendly indexed object
+            const indexed = api.arrayToIndexedObject(items);
+            console.log("✓ Array converted to indexed object:", indexed);
+            // Convert back to array
+            const restored = api.indexedObjectToArray(indexed);
+            console.log("✓ Indexed object converted back to array:", restored);
+            // Logout
+            db.logout();
+            console.log("\n✓ Logged out");
+        }
+    }
+    console.log("\n✅ Example completed!");
+    console.log("\nSummary:");
+    console.log("- Use AutoQuickStart for easy initialization");
+    console.log("- Use api.database for basic operations (get, put, auth, etc.)");
+    console.log("- Use api helper methods for high-level operations:");
+    console.log("  • updateProfile(), getProfile()");
+    console.log("  • saveSettings(), getSettings()");
+    console.log("  • createCollection(), addToCollection(), getCollection()");
+    console.log("  • arrayToIndexedObject(), indexedObjectToArray()");
+}
+// Esegui il test
+if (require.main === module) {
+    simpleAPITest().catch(console.error);
+}

package/dist/examples/simple-crypto-identity-example.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Esempio semplificato del CryptoIdentityManager
+ * Focus sulla funzionalità principale senza plugin opzionali
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleCryptoIdentityExample = simpleCryptoIdentityExample;
+const index_1 = require("../index");
+// Esempio principale
+async function simpleCryptoIdentityExample() {
+    console.log("🚀 Esempio Semplificato CryptoIdentityManager");
+    console.log("============================================\n");
+    // 1. Inizializza ShogunCore
+    const core = new index_1.ShogunCore({
+        gunOptions: {
+            peers: ["https://peer.wallie.io/gun"],
+            radisk: true,
+            localStorage: false,
+        },
+    });
+    console.log("✅ ShogunCore inizializzato");
+    // 2. Registra un nuovo utente (genera automaticamente SEA pair)
+    const username = `user_${Date.now()}`;
+    const signupResult = await core.signUp(username, "password123");
+    if (!signupResult.success) {
+        console.error("❌ Registrazione fallita:", signupResult.error);
+        return;
+    }
+    console.log("✅ Utente registrato:", {
+        username: signupResult.username,
+        userPub: signupResult.userPub?.substring(0, 20) + "...",
+        hasSEAPair: !!signupResult.sea,
+    });
+    // 3. Le identità crypto sono state generate automaticamente durante la registrazione
+    const cryptoManager = new index_1.CryptoIdentityManager(core);
+    // 4. Recupera le identità crypto dell'utente corrente
+    const identitiesResult = await cryptoManager.getCurrentUserIdentities();
+    if (identitiesResult.success && identitiesResult.identities) {
+        const identities = identitiesResult.identities;
+        console.log("\n🔐 Identità crypto generate automaticamente:");
+        console.log("===========================================");
+        console.log("- RSA Key Pair:", identities.rsa ? "✅" : "❌");
+        console.log("- AES Symmetric Key:", identities.aes ? "✅" : "❌");
+        console.log("- Signal Protocol Identity:", identities.signal ? "✅" : "❌");
+        console.log("- PGP Key Pair:", identities.pgp ? "✅" : "❌");
+        console.log("- MLS Group:", identities.mls ? "✅" : "❌");
+        console.log("- SFrame Key:", identities.sframe ? "✅" : "❌");
+        console.log("- Created At:", new Date(identities.createdAt).toISOString());
+        console.log("- Version:", identities.version);
+    }
+    else {
+        console.error("❌ Errore nel recupero delle identità:", identitiesResult.error);
+    }
+    // 5. Test login con utente esistente
+    console.log("\n🔄 Test login con utente esistente...");
+    const loginResult = await core.login(username, "password123");
+    if (loginResult.success) {
+        console.log("✅ Login riuscito");
+        // Le identità crypto esistenti vengono recuperate automaticamente
+        const existingIdentities = await cryptoManager.getCurrentUserIdentities();
+        if (existingIdentities.success) {
+            console.log("✅ Identità crypto esistenti recuperate");
+        }
+    }
+    else {
+        console.error("❌ Login fallito:", loginResult.error);
+    }
+    // 6. Test verifica esistenza identità
+    console.log("\n🔍 Test verifica esistenza identità...");
+    const hasIdentities = await cryptoManager.hasStoredIdentities(username);
+    console.log(`✅ Identità salvate per ${username}: ${hasIdentities ? "Sì" : "No"}`);
+    console.log("\n🎉 Esempio completato!");
+    console.log("=====================");
+    console.log("✅ Il CryptoIdentityManager funziona perfettamente!");
+    console.log("✅ Le identità crypto vengono generate automaticamente");
+    console.log("✅ Le identità vengono salvate e recuperate correttamente");
+    console.log("✅ Il sistema è pronto per l'uso! 🚀");
+}
+// Esegui l'esempio se il file viene eseguito direttamente
+if (typeof window === "undefined" && require.main === module) {
+    simpleCryptoIdentityExample().catch((error) => {
+        console.error("❌ Errore durante l'esecuzione dell'esempio:", error);
+    });
+}