shogun-core 5.2.0 → 5.2.2

package/dist/examples/auth-test.js

@@ -0,0 +1,253 @@
+"use strict";
+/**
+ * Authentication Test Script
+ *
+ * Tests signup and login functionality with username and password
+ * Includes timeout handling and error recovery testing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authTest = authTest;
+const api_1 = require("../gundb/api");
+async function authTest() {
+    console.log("🔐 ShogunCore Authentication Test\n");
+    // === INITIALIZATION ===
+    console.log("📦 === INITIALIZATION ===\n");
+    // Use AutoQuickStart for easy setup with multiple peers for reliability
+    const quickStart = new api_1.AutoQuickStart({
+        peers: [
+            "https://peer.wallie.io/gun",
+            "https://gun-manhattan.herokuapp.com/gun",
+            "https://gun.defucc.me/gun",
+        ],
+        appScope: "auth-test",
+        // Enable debug logging
+        enableGunDebug: true,
+        enableConnectionMonitoring: true,
+    });
+    try {
+        await quickStart.init();
+        console.log("✓ ShogunCore initialized successfully");
+    }
+    catch (error) {
+        console.error("❌ Failed to initialize ShogunCore:", error);
+        return;
+    }
+    const api = quickStart.api;
+    const db = api.database;
+    console.log("- Database instance:", db ? "Available" : "Not available");
+    console.log("- Current user:", db.getCurrentUser()?.alias || "None");
+    console.log("- Is logged in:", db.isLoggedIn());
+    console.log("");
+    // === TEST 1: BASIC SIGNUP AND LOGIN ===
+    console.log("🧪 === TEST 1: BASIC SIGNUP AND LOGIN ===\n");
+    const testUsername = `testuser_${Date.now()}`;
+    const testPassword = "testpass123!@#";
+    console.log(`Testing with username: ${testUsername}`);
+    console.log(`Password: ${testPassword}\n`);
+    // Test signup
+    console.log("🔄 Attempting signup...");
+    const signupStartTime = Date.now();
+    try {
+        const signupResult = await db.signUp(testUsername, testPassword);
+        const signupDuration = Date.now() - signupStartTime;
+        console.log(`✓ Signup completed in ${signupDuration}ms`);
+        console.log("Signup result:", {
+            success: signupResult.success,
+            userPub: signupResult.userPub
+                ? `${signupResult.userPub.substring(0, 20)}...`
+                : "None",
+            username: signupResult.username,
+            isNewUser: signupResult.isNewUser,
+            error: signupResult.error || "None",
+        });
+        if (!signupResult.success) {
+            console.error("❌ Signup failed:", signupResult.error);
+            return;
+        }
+    }
+    catch (error) {
+        console.error("❌ Signup threw exception:", error);
+        return;
+    }
+    console.log("");
+    // Test login
+    console.log("🔄 Attempting login...");
+    const loginStartTime = Date.now();
+    try {
+        const loginResult = await db.login(testUsername, testPassword);
+        const loginDuration = Date.now() - loginStartTime;
+        console.log(`✓ Login completed in ${loginDuration}ms`);
+        console.log("Login result:", {
+            success: loginResult.success,
+            userPub: loginResult.userPub
+                ? `${loginResult.userPub.substring(0, 20)}...`
+                : "None",
+            username: loginResult.username,
+            error: loginResult.error || "None",
+        });
+        if (!loginResult.success) {
+            console.error("❌ Login failed:", loginResult.error);
+            return;
+        }
+        // Verify user state
+        console.log("\n🔍 Verifying user state...");
+        const currentUser = db.getCurrentUser();
+        const isLoggedIn = db.isLoggedIn();
+        console.log("Current user:", {
+            alias: currentUser?.alias || "None",
+            pub: currentUser?.pub ? `${currentUser.pub.substring(0, 20)}...` : "None",
+            epub: currentUser?.epub
+                ? `${currentUser.epub.substring(0, 20)}...`
+                : "None",
+        });
+        console.log("Is logged in:", isLoggedIn);
+        if (!isLoggedIn || !currentUser) {
+            console.error("❌ User state verification failed");
+            return;
+        }
+    }
+    catch (error) {
+        console.error("❌ Login threw exception:", error);
+        return;
+    }
+    console.log("");
+    // === TEST 2: DATA OPERATIONS WHILE LOGGED IN ===
+    console.log("💾 === TEST 2: DATA OPERATIONS WHILE LOGGED IN ===\n");
+    try {
+        // Test encrypted data storage
+        const testData = {
+            message: "Hello from auth test!",
+            timestamp: Date.now(),
+            secret: "This is encrypted data",
+        };
+        console.log("🔄 Storing encrypted data...");
+        await db.put("test/encrypted-data", testData);
+        console.log("✓ Data stored successfully");
+        console.log("🔄 Retrieving encrypted data...");
+        const retrievedData = await db.getData("test/encrypted-data");
+        console.log("✓ Data retrieved:", retrievedData);
+        // Test profile operations
+        console.log("\n🔄 Testing profile operations...");
+        await api.updateProfile({
+            name: "Auth Test User",
+            email: "authtest@example.com",
+            bio: "Testing authentication flow",
+        });
+        console.log("✓ Profile updated");
+        const profile = await api.getProfile();
+        console.log("✓ Profile retrieved:", profile);
+    }
+    catch (error) {
+        console.error("❌ Data operations failed:", error);
+    }
+    console.log("");
+    // === TEST 3: LOGOUT ===
+    console.log("🚪 === TEST 3: LOGOUT ===\n");
+    try {
+        console.log("🔄 Attempting logout...");
+        db.logout();
+        // Wait a moment for logout to complete
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        const isStillLoggedIn = db.isLoggedIn();
+        const currentUserAfterLogout = db.getCurrentUser();
+        console.log("✓ Logout completed");
+        console.log("Is logged in after logout:", isStillLoggedIn);
+        console.log("Current user after logout:", currentUserAfterLogout?.alias || "None");
+        if (isStillLoggedIn) {
+            console.warn("⚠️ User still appears to be logged in after logout");
+        }
+        else {
+            console.log("✓ Logout successful - user is no longer logged in");
+        }
+    }
+    catch (error) {
+        console.error("❌ Logout failed:", error);
+    }
+    console.log("");
+    // === TEST 4: RE-LOGIN ===
+    console.log("🔄 === TEST 4: RE-LOGIN ===\n");
+    try {
+        console.log("🔄 Attempting re-login with same credentials...");
+        const reloginResult = await db.login(testUsername, testPassword);
+        console.log("Re-login result:", {
+            success: reloginResult.success,
+            userPub: reloginResult.userPub
+                ? `${reloginResult.userPub.substring(0, 20)}...`
+                : "None",
+            username: reloginResult.username,
+            error: reloginResult.error || "None",
+        });
+        if (reloginResult.success) {
+            console.log("✓ Re-login successful");
+            console.log("Current user:", db.getCurrentUser()?.alias || "None");
+        }
+        else {
+            console.error("❌ Re-login failed:", reloginResult.error);
+        }
+    }
+    catch (error) {
+        console.error("❌ Re-login threw exception:", error);
+    }
+    console.log("");
+    // === TEST 5: ERROR HANDLING ===
+    console.log("⚠️ === TEST 5: ERROR HANDLING ===\n");
+    // Test invalid credentials
+    console.log("🔄 Testing invalid password...");
+    try {
+        const invalidLoginResult = await db.login(testUsername, "wrongpassword");
+        console.log("Invalid login result:", {
+            success: invalidLoginResult.success,
+            error: invalidLoginResult.error || "None",
+        });
+        if (!invalidLoginResult.success) {
+            console.log("✓ Invalid password correctly rejected");
+        }
+        else {
+            console.warn("⚠️ Invalid password was accepted (unexpected)");
+        }
+    }
+    catch (error) {
+        console.log("✓ Invalid password threw exception (expected):", error instanceof Error ? error.message : String(error));
+    }
+    // Test non-existent user
+    console.log("\n🔄 Testing non-existent user...");
+    try {
+        const nonexistentLoginResult = await db.login("nonexistentuser123", "password");
+        console.log("Non-existent user login result:", {
+            success: nonexistentLoginResult.success,
+            error: nonexistentLoginResult.error || "None",
+        });
+        if (!nonexistentLoginResult.success) {
+            console.log("✓ Non-existent user correctly rejected");
+        }
+        else {
+            console.warn("⚠️ Non-existent user was accepted (unexpected)");
+        }
+    }
+    catch (error) {
+        console.log("✓ Non-existent user threw exception (expected):", error instanceof Error ? error.message : String(error));
+    }
+    console.log("");
+    // === FINAL LOGOUT ===
+    console.log("🚪 === FINAL CLEANUP ===\n");
+    try {
+        db.logout();
+        console.log("✓ Final logout completed");
+    }
+    catch (error) {
+        console.error("❌ Final logout failed:", error);
+    }
+    console.log("\n✅ Authentication test completed!");
+    console.log("\n📊 Test Summary:");
+    console.log("- ✓ Signup with username/password");
+    console.log("- ✓ Login with username/password");
+    console.log("- ✓ Data operations while logged in");
+    console.log("- ✓ Logout functionality");
+    console.log("- ✓ Re-login capability");
+    console.log("- ✓ Error handling for invalid credentials");
+    console.log("- ✓ Error handling for non-existent users");
+}
+// Esegui il test
+if (require.main === module) {
+    authTest().catch(console.error);
+}

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

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Esempio di utilizzo del CryptoIdentityManager
+ * Mostra come le identità crypto vengono generate automaticamente dopo l'autenticazione SEA
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCryptoIdentityExamples = runCryptoIdentityExamples;
+const index_1 = require("../index");
+// Esempio di utilizzo
+async function cryptoIdentityExample() {
+    console.log("🚀 Avvio esempio CryptoIdentityManager");
+    // 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 = `mario_rossi_${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,
+        hasSEAPair: !!signupResult.sea,
+    });
+    // 3. Le identità crypto sono state generate automaticamente durante la registrazione
+    // Possiamo accedervi tramite il CryptoIdentityManager
+    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("🔐 Identità crypto generate automaticamente:");
+        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. Esempio di 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. Esempio di rigenerazione forzata delle identità
+    console.log("\n🔄 Test rigenerazione identità...");
+    if (signupResult.sea) {
+        const regenerateResult = await cryptoManager.setupCryptoIdentities(username, signupResult.sea, true);
+        if (regenerateResult.success) {
+            console.log("✅ Identità crypto rigenerate:", regenerateResult.savedKeys);
+        }
+        else {
+            console.error("❌ Rigenerazione fallita:", regenerateResult.error);
+        }
+    }
+    console.log("\n🎉 Esempio completato!");
+}
+// Esempio di utilizzo con diversi metodi di autenticazione
+async function multiAuthExample() {
+    console.log("\n🔐 Esempio con diversi metodi di autenticazione");
+    const core = new index_1.ShogunCore({
+        gunOptions: {
+            peers: ["https://peer.wallie.io/gun"],
+            radisk: true,
+            localStorage: false,
+        },
+    });
+    // Esempio con WebAuthn (se disponibile)
+    try {
+        const webauthnPlugin = core.getAuthenticationMethod("webauthn");
+        if (webauthnPlugin) {
+            console.log("🔐 Test WebAuthn signup...");
+            const webauthnResult = await webauthnPlugin.signUp("alice_webauthn");
+            if (webauthnResult.success) {
+                console.log("✅ WebAuthn signup riuscito");
+                // Le identità crypto vengono generate automaticamente anche con WebAuthn
+                const cryptoManager = new index_1.CryptoIdentityManager(core);
+                const identities = await cryptoManager.getCurrentUserIdentities();
+                if (identities.success) {
+                    console.log("✅ Identità crypto generate con WebAuthn");
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.log("ℹ️ WebAuthn non disponibile:", error);
+    }
+    // Esempio con ZK-Proof (se disponibile)
+    try {
+        const zkPlugin = core.getAuthenticationMethod("zkproof");
+        if (zkPlugin) {
+            console.log("🔐 Test ZK-Proof signup...");
+            // ZK-Proof non richiede password, usa il metodo corretto
+            const zkResult = await zkPlugin.signUp();
+            if (zkResult.success) {
+                console.log("✅ ZK-Proof signup riuscito");
+                // Le identità crypto vengono generate automaticamente anche con ZK-Proof
+                const cryptoManager = new index_1.CryptoIdentityManager(core);
+                const identities = await cryptoManager.getCurrentUserIdentities();
+                if (identities.success) {
+                    console.log("✅ Identità crypto generate con ZK-Proof");
+                }
+            }
+            else {
+                console.log("ℹ️ ZK-Proof signup non riuscito:", zkResult.error);
+            }
+        }
+        else {
+            console.log("ℹ️ ZK-Proof plugin non disponibile");
+        }
+    }
+    catch (error) {
+        console.log("ℹ️ ZK-Proof test saltato:", error instanceof Error ? error.message : String(error));
+    }
+}
+// Funzione principale per eseguire gli esempi
+async function runCryptoIdentityExamples() {
+    try {
+        await cryptoIdentityExample();
+        await multiAuthExample();
+    }
+    catch (error) {
+        console.error("❌ Errore durante l'esecuzione degli esempi:", error);
+    }
+}
+// Esegui gli esempi se il file viene eseguito direttamente
+if (typeof window === "undefined" && require.main === module) {
+    runCryptoIdentityExamples();
+}

package/dist/examples/crypto-working-test.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Simple crypto test that actually works
+const crypto_1 = require("../crypto");
+// Simple test function
+async function testCrypto() {
+    try {
+        console.log("🔐 Starting crypto test...");
+        // Test 1: Random string generation
+        console.log("\n1. Testing random string generation...");
+        const randomStr = (0, crypto_1.randomString)("test-");
+        console.log("✅ Random string:", randomStr);
+        // Test 2: Hashing
+        console.log("\n2. Testing hashing...");
+        const hash = await (0, crypto_1.sha256Hash)({
+            message: "Hello Crypto!",
+            timestamp: Date.now(),
+        });
+        console.log("✅ SHA-256 hash:", hash.substring(0, 20) + "...");
+        // Test 3: RSA key generation and encryption
+        console.log("\n3. Testing RSA encryption...");
+        const keyPair = await (0, crypto_1.generateKeyPair)();
+        console.log("✅ RSA key pair generated");
+        const publicKey = await (0, crypto_1.deserializePublicKey)(keyPair.publicKey);
+        const privateKey = await (0, crypto_1.deserializePrivateKey)(keyPair.privateKey);
+        const encryptedMessage = await (0, crypto_1.encrypt)("Secret RSA message", publicKey);
+        const decryptedMessage = await (0, crypto_1.decrypt)(encryptedMessage, privateKey);
+        console.log("✅ RSA encrypted:", encryptedMessage.substring(0, 30) + "...");
+        console.log("✅ RSA decrypted:", decryptedMessage);
+        // Test 4: AES symmetric encryption
+        console.log("\n4. Testing AES symmetric encryption...");
+        const symmetricKey = await (0, crypto_1.generateSymmetricKey)();
+        const deserializedKey = await (0, crypto_1.deserializeSymmetricKey)(symmetricKey);
+        const encryptedData = await (0, crypto_1.encryptWithSymmetricKey)("Secret AES message", deserializedKey);
+        const decryptedData = await (0, crypto_1.decryptWithSymmetricKey)(encryptedData, deserializedKey);
+        console.log("✅ AES encrypted:", encryptedData.ciphertext.substring(0, 30) + "...");
+        console.log("✅ AES decrypted:", decryptedData);
+        // Test 5: File encryption
+        console.log("\n5. Testing file encryption...");
+        const fileContent = "This is a secret file content for testing!";
+        const password = "testPassword123";
+        const encryptedFile = await (0, crypto_1.encryptTextFile)(fileContent, password, "test.txt");
+        const decryptedFile = await (0, crypto_1.decryptTextFile)(encryptedFile, password);
+        console.log("✅ File encrypted:", encryptedFile.fileName);
+        console.log("✅ File decrypted:", decryptedFile.textContent);
+        console.log("\n🎉 All crypto tests completed successfully!");
+        return {
+            success: true,
+            tests: {
+                randomString: randomStr,
+                hash: hash.substring(0, 20) + "...",
+                rsaEncryption: {
+                    encrypted: encryptedMessage.substring(0, 30) + "...",
+                    decrypted: decryptedMessage,
+                },
+                aesEncryption: {
+                    encrypted: encryptedData.ciphertext.substring(0, 30) + "...",
+                    decrypted: decryptedData,
+                },
+                fileEncryption: {
+                    fileName: encryptedFile.fileName,
+                    decrypted: decryptedFile.textContent,
+                },
+            },
+        };
+    }
+    catch (error) {
+        console.error("❌ Crypto test failed:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+// Run the test
+testCrypto()
+    .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/double-ratchet-test.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Double Ratchet Protocol test
+const crypto_1 = require("../crypto");
+// Test Double Ratchet Protocol
+async function testDoubleRatchet() {
+    try {
+        console.log("🔄 Starting Double Ratchet Protocol test...");
+        const result = await (0, crypto_1.demonstrateDoubleRatchet)();
+        if (result.success) {
+            console.log("✅ Double Ratchet Protocol test successful!");
+            console.log("Messages exchanged:", result.messagesExchanged);
+            console.log("Forward secrecy:", result.demonstration.forwardSecrecy);
+            console.log("Out-of-order handling:", result.demonstration.outOfOrderHandling);
+            console.log("DH ratcheting:", result.demonstration.dhRatcheting);
+            console.log("Chain key updating:", result.demonstration.chainKeyUpdating);
+            // Test individual functions
+            console.log("\n🧪 Testing individual Double Ratchet functions...");
+            // Test state serialization
+            const aliceStateSerialized = result.aliceState;
+            console.log("✅ Alice state serialized:", aliceStateSerialized.substring(0, 100) + "...");
+            // Test conversation
+            console.log("✅ Conversation messages:", result.conversation.length);
+            result.conversation.forEach((msg, index) => {
+                console.log(`  Message ${index + 1}: ${msg.from} → Message #${msg.envelope.messageNumber}`);
+            });
+        }
+        else {
+            console.log("❌ Double Ratchet Protocol test failed");
+        }
+        return result;
+    }
+    catch (error) {
+        console.error("❌ Double Ratchet Protocol test error:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+// Test interactive Double Ratchet messaging
+async function testInteractiveDoubleRatchet() {
+    try {
+        console.log("🔄 Starting Interactive Double Ratchet test...");
+        // Initialize X3DH for shared secret
+        const { initializeSignalUser, getSignalPublicKeyBundle, performSignalX3DHKeyExchange, } = await import("../crypto/signal-protocol.js");
+        const alice = await initializeSignalUser("Alice");
+        const bob = await initializeSignalUser("Bob");
+        const bobBundle = await getSignalPublicKeyBundle(bob);
+        const exchangeResult = await performSignalX3DHKeyExchange(alice, bobBundle);
+        console.log("✅ X3DH key exchange completed");
+        // Initialize Double Ratchet states
+        const aliceState = await (0, crypto_1.initializeDoubleRatchet)(exchangeResult.masterSecret, true);
+        const bobState = await (0, crypto_1.initializeDoubleRatchet)(exchangeResult.masterSecret, false);
+        console.log("✅ Double Ratchet states initialized");
+        // Test message exchange
+        const messages = [
+            "Hello Bob! This is our first Double Ratchet message! 🔒",
+            "Hi Alice! The Double Ratchet is working perfectly! 🎉",
+            "This is message 3 with forward secrecy! 🛡️",
+            "And this is message 4 - each with a unique key! 🔑",
+        ];
+        const conversation = [];
+        for (let i = 0; i < messages.length; i++) {
+            const sender = i % 2 === 0 ? "Alice" : "Bob";
+            const senderState = sender === "Alice" ? aliceState : bobState;
+            const receiverState = sender === "Alice" ? bobState : aliceState;
+            console.log(`\n📤 ${sender} sending message ${i + 1}: "${messages[i]}"`);
+            // Encrypt
+            const envelope = await (0, crypto_1.doubleRatchetEncrypt)(senderState, messages[i]);
+            console.log(`✅ ${sender} encrypted message #${envelope.messageNumber}`);
+            // Decrypt
+            const decrypted = await (0, crypto_1.doubleRatchetDecrypt)(receiverState, envelope);
+            console.log(`✅ ${sender === "Alice" ? "Bob" : "Alice"} decrypted: "${decrypted}"`);
+            // Verify
+            if (decrypted === messages[i]) {
+                console.log(`✅ Message ${i + 1} verified successfully`);
+                conversation.push({
+                    sender,
+                    receiver: sender === "Alice" ? "Bob" : "Alice",
+                    original: messages[i],
+                    decrypted,
+                    messageNumber: envelope.messageNumber,
+                    verified: true,
+                });
+            }
+            else {
+                console.log(`❌ Message ${i + 1} verification failed`);
+                conversation.push({
+                    sender,
+                    receiver: sender === "Alice" ? "Bob" : "Alice",
+                    original: messages[i],
+                    decrypted,
+                    messageNumber: envelope.messageNumber,
+                    verified: false,
+                });
+            }
+        }
+        // Test state serialization
+        const aliceSerialized = await (0, crypto_1.serializeDoubleRatchetState)(aliceState);
+        const bobSerialized = await (0, crypto_1.serializeDoubleRatchetState)(bobState);
+        console.log("\n📊 Interactive Double Ratchet test results:");
+        console.log(`Messages exchanged: ${conversation.length}`);
+        console.log(`All messages verified: ${conversation.every((msg) => msg.verified)}`);
+        console.log(`Alice state serialized: ${aliceSerialized.length} characters`);
+        console.log(`Bob state serialized: ${bobSerialized.length} characters`);
+        return {
+            success: true,
+            messagesExchanged: conversation.length,
+            allVerified: conversation.every((msg) => msg.verified),
+            conversation,
+            aliceState: aliceSerialized,
+            bobState: bobSerialized,
+        };
+    }
+    catch (error) {
+        console.error("❌ Interactive Double Ratchet test error:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+// Run the tests
+async function runAllTests() {
+    console.log("🚀 Running all Double Ratchet tests...\n");
+    // Test 1: Basic demonstration
+    console.log("=== Test 1: Basic Double Ratchet Demonstration ===");
+    const basicResult = await testDoubleRatchet();
+    console.log("\n=== Test 2: Interactive Double Ratchet Messaging ===");
+    const interactiveResult = await testInteractiveDoubleRatchet();
+    console.log("\n📊 Final Results:");
+    console.log("Basic test:", basicResult.success ? "✅ PASSED" : "❌ FAILED");
+    console.log("Interactive test:", interactiveResult.success ? "✅ PASSED" : "❌ FAILED");
+    if (basicResult.success && interactiveResult.success) {
+        console.log("\n🎉 All Double Ratchet tests completed successfully!");
+    }
+    else {
+        console.log("\n❌ Some tests failed");
+    }
+    return {
+        basic: basicResult,
+        interactive: interactiveResult,
+        allPassed: basicResult.success && interactiveResult.success,
+    };
+}
+// Run the tests
+runAllTests()
+    .then((result) => {
+    console.log("\n📊 Final Test Summary:");
+    console.log(JSON.stringify(result, null, 2));
+})
+    .catch((error) => {
+    console.error("💥 Test execution failed:", error);
+});