shogun-core 3.3.7 → 4.0.0

package/dist/core.js

@@ -318,13 +318,12 @@ class ShogunCore {
     }
 }
 exports.ShogunCore = ShogunCore;
-ShogunCore.API_VERSION = "^3.0.11";
+ShogunCore.API_VERSION = "^3.3.8";
 // Global declarations are handled in the original core.ts file
 // to avoid conflicts, we only set the window properties here
 if (typeof window !== "undefined") {
-    window.SHOGUN_CORE = (config) => {
+    window.Shogun = (config) => {
         return new ShogunCore(config);
     };
-    window.SHOGUN_CORE_CLASS = ShogunCore;
 }
 exports.default = ShogunCore;

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

@@ -1,87 +1,112 @@
 "use strict";
 /**
- * Esempio semplice che mostra le differenze principali tra i metodi API
+ * 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("🚀 Test semplice API ShogunCore\n");
-    // Setup
+    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;
-    // === DIFFERENZE PRINCIPALI ===
-    console.log("📊 === DIFFERENZE GET ===\n");
-    // 1. get() - restituisce dati direttamente
-    const data1 = await api.get("test/path");
-    console.log('get("test/path"):', data1); // null o dati
-    // 2. getNode() - restituisce nodo Gun per chaining
-    const node1 = api.getNode("test/path");
-    console.log('getNode("test/path"):', typeof node1); // "object" (Gun node)
-    // 3. node() - alias di getNode()
-    const node2 = api.node("test/path");
-    console.log('node("test/path"):', typeof node2); // "object" (Gun node)
-    // 4. chain() - wrapper con metodi di convenienza
-    const chain1 = api.chain("test/path");
-    console.log('chain("test/path"):', Object.keys(chain1)); // ['get', 'put', 'set', 'once', 'then', 'map']
-    console.log("\n💾 === DIFFERENZE PUT/SET ===\n");
+    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() };
-    // 1. put() - salva dati globali
-    const putResult = await api.put("global/data", testData);
-    console.log("put() result:", putResult); // true/false
-    // 2. set() - come put() ma semantica diversa
-    const setResult = await api.set("global/data2", {
-        ...testData,
-        method: "set",
-    });
-    console.log("set() result:", setResult); // true/false
-    // Verifica
-    const retrieved1 = await api.get("global/data");
-    const retrieved2 = await api.get("global/data2");
-    console.log("Retrieved put data:", retrieved1);
-    console.log("Retrieved set data:", retrieved2);
-    console.log("\n🗑️ === DIFFERENZE REMOVE ===\n");
-    // remove() - rimuove dati globali
-    const removeResult = await api.remove("global/data2");
-    console.log("remove() result:", removeResult); // true/false
-    const afterRemove = await api.get("global/data2");
-    console.log("Data after remove:", afterRemove); // null
-    console.log("\n🔐 === TEST AUTENTICAZIONE ===\n");
-    // Signup e login
+    // 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 api.signup(username, password);
-    console.log("Signup result:", signupResult);
-    if (signupResult) {
-        const loginResult = await api.login(username, password);
-        console.log("Login result:", loginResult);
-        if (loginResult) {
-            console.log("\n👤 === OPERAZIONI UTENTE ===\n");
-            // getUserData() - per dati utente
-            const userData = await api.getUserData("profile");
-            console.log('getUserData("profile"):', userData); // null o dati utente
-            // putUserData() - salva dati utente
-            const profileData = { name: "Test User", email: "test@example.com" };
-            const putUserResult = await api.putUserData("profile", profileData);
-            console.log("putUserData() result:", putUserResult); // true/false
-            // Verifica dati utente
-            const retrievedProfile = await api.getUserData("profile");
-            console.log("Retrieved profile:", retrievedProfile);
-            // removeUserData() - rimuove dati utente
-            const removeUserResult = await api.removeUserData("profile");
-            console.log("removeUserData() result:", removeUserResult); // true/false
-            const afterRemoveUser = await api.getUserData("profile");
-            console.log("User data after remove:", afterRemoveUser); // null
+    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
-            api.logout();
-            console.log("Logged out");
+            db.logout();
+            console.log("\n✓ Logged out");
         }
     }
-    console.log("\n✅ Test completato!");
+    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) {

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

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * ZK-Proof Verifiable Credentials Example
+ *
+ * This demonstrates how to use ZK-Proof for proving attributes
+ * about documents and identity without revealing sensitive data
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ageVerificationExample = ageVerificationExample;
+exports.citizenshipExample = citizenshipExample;
+exports.educationExample = educationExample;
+exports.incomeExample = incomeExample;
+exports.customCredentialExample = customCredentialExample;
+const core_1 = require("../core");
+const zkCredentials_1 = require("../plugins/zkproof/zkCredentials");
+const shogun_relays_1 = require("shogun-relays");
+const identity_1 = require("@semaphore-protocol/identity");
+// Example 1: Age Verification
+async function ageVerificationExample() {
+    console.log("=== Age Verification Example ===\n");
+    const relays = await (0, shogun_relays_1.forceListUpdate)();
+    const shogun = new core_1.ShogunCore({
+        gunOptions: { peers: relays },
+        zkproof: { enabled: true },
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const zkPlugin = shogun.getPlugin("zkproof");
+    if (!zkPlugin)
+        return;
+    // Create ZK identity
+    const identity = await zkPlugin.generateIdentity();
+    const semaphoreIdentity = new identity_1.Identity(identity.trapdoor);
+    // Create credentials manager
+    const zkCreds = new zkCredentials_1.ZkCredentials();
+    console.log("Scenario: User wants to prove they're 18+ without revealing birthdate\n");
+    // User's actual birthdate (PRIVATE)
+    const birthDate = new Date("1990-05-15");
+    const actualAge = Math.floor((Date.now() - birthDate.getTime()) / (365.25 * 24 * 60 * 60 * 1000));
+    console.log(`Private data (NOT revealed):`);
+    console.log(`  Birth date: ${birthDate.toDateString()}`);
+    console.log(`  Actual age: ${actualAge}\n`);
+    try {
+        // Generate proof that age >= 18 WITHOUT revealing exact age
+        const ageProof = await zkCreds.proveAge(semaphoreIdentity, birthDate, 18);
+        console.log(`Public proof generated:`);
+        console.log(`  Claim: "${ageProof.claim}"`);
+        console.log(`  Type: ${ageProof.type}`);
+        console.log(`  ✅ Birth date NOT revealed!`);
+        console.log(`  ✅ Exact age NOT revealed!`);
+        // Anyone can verify the proof
+        const verification = await zkCreds.verifyCredential(ageProof);
+        console.log(`\nVerification result: ${verification.verified ? "✅ VALID" : "❌ INVALID"}`);
+    }
+    catch (error) {
+        console.log(`Note: Full proof generation requires circuit files`);
+        console.log(`Run: yarn setup:zkproof`);
+    }
+}
+// Example 2: Citizenship Verification
+async function citizenshipExample() {
+    console.log("\n=== Citizenship Verification Example ===\n");
+    const relays = await (0, shogun_relays_1.forceListUpdate)();
+    const shogun = new core_1.ShogunCore({
+        gunOptions: { peers: relays },
+        zkproof: { enabled: true },
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const zkPlugin = shogun.getPlugin("zkproof");
+    if (!zkPlugin)
+        return;
+    const identity = await zkPlugin.generateIdentity();
+    const semaphoreIdentity = new identity_1.Identity(identity.trapdoor);
+    const zkCreds = new zkCredentials_1.ZkCredentials();
+    console.log("Scenario: Prove EU citizenship without revealing country\n");
+    console.log(`Private data (NOT revealed):`);
+    console.log(`  Country: Italy`);
+    console.log(`  Passport: IT123456789\n`);
+    try {
+        const citizenshipProof = await zkCreds.proveCitizenship(semaphoreIdentity, "Italy", "EU");
+        console.log(`Public proof:`);
+        console.log(`  Claim: "${citizenshipProof.claim}"`);
+        console.log(`  ✅ Specific country NOT revealed!`);
+        console.log(`  ✅ Passport number NOT revealed!`);
+    }
+    catch (error) {
+        console.log(`Note: Full proof requires circuit files`);
+    }
+}
+// Example 3: Education Credentials
+async function educationExample() {
+    console.log("\n=== Education Credential Example ===\n");
+    const relays = await (0, shogun_relays_1.forceListUpdate)();
+    const shogun = new core_1.ShogunCore({
+        gunOptions: { peers: relays },
+        zkproof: { enabled: true },
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const zkPlugin = shogun.getPlugin("zkproof");
+    if (!zkPlugin)
+        return;
+    const identity = await zkPlugin.generateIdentity();
+    const semaphoreIdentity = new identity_1.Identity(identity.trapdoor);
+    const zkCreds = new zkCredentials_1.ZkCredentials();
+    console.log("Scenario: Prove you have a degree without revealing details\n");
+    console.log(`Private data (NOT revealed):`);
+    console.log(`  University: MIT`);
+    console.log(`  Degree: Computer Science`);
+    console.log(`  Year: 2020`);
+    console.log(`  Grade: 110/110\n`);
+    try {
+        const eduProof = await zkCreds.proveEducation(semaphoreIdentity, "Bachelor of Science", "MIT", 2020);
+        console.log(`Public proof:`);
+        console.log(`  Claim: "${eduProof.claim}"`);
+        console.log(`  ✅ University name NOT revealed!`);
+        console.log(`  ✅ Grades NOT revealed!`);
+        console.log(`  ✅ Only proves you HAVE the degree`);
+    }
+    catch (error) {
+        console.log(`Note: Full proof requires circuit files`);
+    }
+}
+// Example 4: Income Verification
+async function incomeExample() {
+    console.log("\n=== Income Verification Example ===\n");
+    const relays = await (0, shogun_relays_1.forceListUpdate)();
+    const shogun = new core_1.ShogunCore({
+        gunOptions: { peers: relays },
+        zkproof: { enabled: true },
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const zkPlugin = shogun.getPlugin("zkproof");
+    if (!zkPlugin)
+        return;
+    const identity = await zkPlugin.generateIdentity();
+    const semaphoreIdentity = new identity_1.Identity(identity.trapdoor);
+    const zkCreds = new zkCredentials_1.ZkCredentials();
+    console.log("Scenario: Apply for loan proving income > 50k without revealing exact salary\n");
+    console.log(`Private data (NOT revealed):`);
+    console.log(`  Actual salary: 75,000 EUR`);
+    console.log(`  Employer: Tech Company XYZ\n`);
+    try {
+        const incomeProof = await zkCreds.proveIncome(semaphoreIdentity, 75000, 50000, "EUR");
+        console.log(`Public proof sent to bank:`);
+        console.log(`  Claim: "${incomeProof.claim}"`);
+        console.log(`  ✅ Exact salary NOT revealed!`);
+        console.log(`  ✅ Only proves income >= 50,000 EUR`);
+        console.log(`\n  Bank sees: "This person earns at least 50k"`);
+        console.log(`  Bank does NOT see: Actual amount or employer`);
+    }
+    catch (error) {
+        console.log(`Note: Full proof requires circuit files`);
+    }
+}
+// Example 5: Custom Credential
+async function customCredentialExample() {
+    console.log("\n=== Custom Credential Example ===\n");
+    const relays = await (0, shogun_relays_1.forceListUpdate)();
+    const shogun = new core_1.ShogunCore({
+        gunOptions: { peers: relays },
+        zkproof: { enabled: true },
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const zkPlugin = shogun.getPlugin("zkproof");
+    if (!zkPlugin)
+        return;
+    const identity = await zkPlugin.generateIdentity();
+    const semaphoreIdentity = new identity_1.Identity(identity.trapdoor);
+    const zkCreds = new zkCredentials_1.ZkCredentials();
+    console.log("Scenario: Prove you're a verified developer without revealing GitHub profile\n");
+    console.log(`Private data (NOT revealed):`);
+    console.log(`  GitHub: @johndoe`);
+    console.log(`  Repositories: 150`);
+    console.log(`  Stars: 5,234`);
+    console.log(`  Years active: 8\n`);
+    try {
+        const devProof = await zkCreds.proveAttribute(semaphoreIdentity, {
+            type: zkCredentials_1.CredentialType.CUSTOM,
+            claim: "Verified GitHub developer with 5+ years experience",
+            privateData: {
+                githubUsername: "johndoe",
+                repositories: 150,
+                stars: 5234,
+                yearsActive: 8,
+                verified: true,
+            },
+        });
+        console.log(`Public proof:`);
+        console.log(`  Claim: "${devProof.claim}"`);
+        console.log(`  ✅ GitHub username NOT revealed!`);
+        console.log(`  ✅ Exact stats NOT revealed!`);
+        console.log(`  ✅ Privacy-preserving reputation proof`);
+    }
+    catch (error) {
+        console.log(`Note: Full proof requires circuit files`);
+    }
+}
+// Run all examples
+async function main() {
+    console.log("🔐 ZK-Proof Verifiable Credentials Examples");
+    console.log("==========================================\n");
+    try {
+        await ageVerificationExample();
+        await citizenshipExample();
+        await educationExample();
+        await incomeExample();
+        await customCredentialExample();
+        console.log("\n✨ All credential examples completed!");
+        console.log("\nℹ️  Note: These examples show the credential structure.");
+        console.log("   For full ZK proof generation, run: yarn setup:zkproof");
+    }
+    catch (error) {
+        console.error("\n❌ Error:", error);
+    }
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/examples/zkproof-example.js

@@ -0,0 +1,206 @@
+"use strict";
+/**
+ * Zero-Knowledge Proof Authentication Example
+ *
+ * This example demonstrates how to use the ZK-Proof plugin with Shogun Core
+ * for privacy-preserving authentication using Semaphore protocol.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicExample = basicExample;
+exports.deterministicExample = deterministicExample;
+exports.proofExample = proofExample;
+exports.multiDeviceExample = multiDeviceExample;
+const core_1 = require("../core");
+const shogun_relays_1 = require("shogun-relays");
+// Example 1: Basic ZK-Proof signup and login
+async function basicExample() {
+    console.log("=== Basic ZK-Proof Authentication Example ===\n");
+    const relays = await (0, shogun_relays_1.forceListUpdate)();
+    // Initialize Shogun with ZK-Proof plugin
+    const shogun = new core_1.ShogunCore({
+        gunOptions: {
+            peers: relays,
+        },
+        zkproof: {
+            enabled: true,
+            defaultGroupId: "my-app-users",
+        },
+    });
+    // Wait for plugin initialization
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    // Get the ZK-Proof plugin
+    const zkPlugin = shogun.getPlugin("zkproof");
+    if (!zkPlugin) {
+        console.error("ZK-Proof plugin not available");
+        return;
+    }
+    // SIGN UP - Generate new anonymous identity
+    console.log("1. Creating new ZK identity...");
+    const signupResult = await zkPlugin.signUp();
+    if (signupResult.success) {
+        console.log("✅ Signup successful!");
+        console.log(`   Username (commitment): ${signupResult.username}`);
+        console.log(`   User Public Key: ${signupResult.userPub?.slice(0, 16)}...`);
+        console.log("\n⚠️  CRITICAL: Save this trapdoor for account recovery:");
+        console.log(`   Trapdoor: ${signupResult.seedPhrase}\n`);
+        // Simulate user saving the trapdoor
+        const savedTrapdoor = signupResult.seedPhrase;
+        // Logout
+        shogun.logout();
+        console.log("2. Logged out\n");
+        // LOGIN - Authenticate with trapdoor
+        console.log("3. Logging in with trapdoor...");
+        const loginResult = await zkPlugin.login(savedTrapdoor);
+        if (loginResult.success) {
+            console.log("✅ Login successful!");
+            console.log(`   Username: ${loginResult.username}`);
+            console.log(`   User Public Key: ${loginResult.userPub?.slice(0, 16)}...`);
+            console.log(`   Auth Method: ${loginResult.authMethod}`);
+        }
+        else {
+            console.error("❌ Login failed:", loginResult.error);
+        }
+    }
+    else {
+        console.error("❌ Signup failed:", signupResult.error);
+    }
+}
+// Example 2: Deterministic identity generation
+async function deterministicExample() {
+    console.log("\n=== Deterministic ZK Identity Example ===\n");
+    const relays = await (0, shogun_relays_1.forceListUpdate)();
+    const shogun = new core_1.ShogunCore({
+        gunOptions: {
+            peers: relays,
+        },
+        zkproof: {
+            enabled: true,
+            deterministic: true,
+        },
+    });
+    // Wait for plugin initialization
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const zkPlugin = shogun.getPlugin("zkproof");
+    if (!zkPlugin) {
+        console.error("ZK-Proof plugin not available");
+        return;
+    }
+    // Use a seed for deterministic generation
+    const seed = "my-secret-seed-phrase-12345";
+    console.log("1. Creating identity from seed...");
+    const signupResult = await zkPlugin.signUp(seed);
+    if (signupResult.success) {
+        console.log("✅ Identity created from seed");
+        console.log(`   Commitment: ${signupResult.username}`);
+        // With the same seed, you'll always get the same identity
+        const identity2 = await zkPlugin.generateIdentity(seed);
+        console.log("\n2. Regenerating from same seed...");
+        console.log(`   Same commitment? ${identity2.commitment === signupResult.username?.replace("zk_", "")}`);
+    }
+}
+// Example 3: Generate and verify ZK proofs
+async function proofExample() {
+    console.log("\n=== ZK Proof Generation & Verification Example ===\n");
+    const relays = await (0, shogun_relays_1.forceListUpdate)();
+    const shogun = new core_1.ShogunCore({
+        gunOptions: {
+            peers: relays,
+        },
+        zkproof: {
+            enabled: true,
+            defaultGroupId: "proof-demo-group",
+        },
+    });
+    // Wait for plugin initialization
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const zkPlugin = shogun.getPlugin("zkproof");
+    if (!zkPlugin) {
+        console.error("ZK-Proof plugin not available");
+        return;
+    }
+    // Create identity
+    console.log("1. Generating identity...");
+    const identity = await zkPlugin.generateIdentity();
+    console.log(`   Commitment: ${identity.commitment.slice(0, 16)}...`);
+    // Add to group
+    console.log("\n2. Adding to group...");
+    zkPlugin.addToGroup(identity.commitment, "proof-demo-group");
+    // Generate proof of membership
+    console.log("\n3. Generating ZK proof...");
+    const proof = await zkPlugin.generateProof(identity, {
+        groupId: "proof-demo-group",
+        message: "I am a member of this group",
+        scope: "membership-verification",
+    });
+    console.log("   Proof generated!");
+    console.log(`   Merkle root: ${proof.merkleTreeRoot.slice(0, 16)}...`);
+    console.log(`   Nullifier hash: ${proof.nullifierHash.slice(0, 16)}...`);
+    // Verify the proof
+    console.log("\n4. Verifying proof...");
+    const verificationResult = await zkPlugin.verifyProof(proof);
+    if (verificationResult.verified) {
+        console.log("✅ Proof verified successfully!");
+        console.log("   User proved group membership without revealing identity");
+    }
+    else {
+        console.error("❌ Proof verification failed");
+    }
+}
+// Example 4: Multi-device scenario
+async function multiDeviceExample() {
+    console.log("\n=== Multi-Device ZK Authentication Example ===\n");
+    const relays = await (0, shogun_relays_1.forceListUpdate)();
+    // Device 1: Create account
+    console.log("📱 DEVICE 1: Creating account...");
+    const shogun1 = new core_1.ShogunCore({
+        gunOptions: {
+            peers: relays,
+        },
+        zkproof: { enabled: true },
+    });
+    // Wait for plugin initialization
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const zkPlugin1 = shogun1.getPlugin("zkproof");
+    const signupResult = await zkPlugin1.signUp();
+    console.log("✅ Account created on Device 1");
+    console.log(`   Commitment: ${signupResult.username}`);
+    // User writes down the trapdoor
+    const trapdoor = signupResult.seedPhrase;
+    console.log(`\n📝 User writes down trapdoor: ${trapdoor.slice(0, 20)}...`);
+    // Device 2: Import account
+    console.log("\n💻 DEVICE 2: Importing account with trapdoor...");
+    const shogun2 = new core_1.ShogunCore({
+        gunOptions: {
+            peers: relays,
+        },
+        zkproof: { enabled: true },
+    });
+    // Wait for plugin initialization
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const zkPlugin2 = shogun2.getPlugin("zkproof");
+    const loginResult = await zkPlugin2.login(trapdoor);
+    if (loginResult.success) {
+        console.log("✅ Successfully logged in on Device 2");
+        console.log(`   Same user: ${loginResult.username === signupResult.username}`);
+        console.log("\n🎉 Multi-device authentication working!");
+    }
+}
+// Run examples
+async function main() {
+    try {
+        // Run all examples
+        await basicExample();
+        await deterministicExample();
+        // await proofExample(); // Requires ZK circuit files - see README for setup
+        await multiDeviceExample();
+        console.log("\n✨ All examples completed successfully!");
+    }
+    catch (error) {
+        console.error("\n❌ Error running examples:", error);
+    }
+    process.exit(0);
+}
+// Run if executed directly
+if (require.main === module) {
+    main();
+}