shogun-core 3.3.7 → 4.0.0

package/dist/plugins/zkproof/zkProofConnector.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZkProofConnector = void 0;
+const identity_1 = require("@semaphore-protocol/identity");
+const group_1 = require("@semaphore-protocol/group");
+const proof_1 = require("@semaphore-protocol/proof");
+const ethers_1 = require("ethers");
+const derive_1 = __importDefault(require("../../gundb/derive"));
+const errorHandler_1 = require("../../utils/errorHandler");
+/**
+ * Connector for ZK-Proof operations using Semaphore protocol
+ */
+class ZkProofConnector {
+    constructor() {
+        this.identityCache = new Map();
+        this.credentialCache = new Map();
+        this.groups = new Map();
+    }
+    /**
+     * Generate a new Semaphore identity
+     */
+    async generateIdentity(seed) {
+        try {
+            let identity;
+            if (seed) {
+                // Deterministic generation from seed
+                identity = new identity_1.Identity(seed);
+            }
+            else {
+                // Random generation
+                identity = new identity_1.Identity();
+            }
+            const commitment = identity.commitment.toString();
+            const trapdoor = identity.trapdoor.toString();
+            const nullifier = identity.nullifier.toString();
+            // Cache the identity
+            this.identityCache.set(commitment, identity);
+            return {
+                commitment,
+                trapdoor,
+                nullifier,
+                createdAt: Date.now(),
+            };
+        }
+        catch (error) {
+            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.ENCRYPTION, "ZK_IDENTITY_GENERATION_FAILED", `Failed to generate ZK identity: ${error.message}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Restore identity from trapdoor
+     */
+    async restoreIdentity(trapdoor) {
+        try {
+            // Reconstruct identity from trapdoor
+            const identity = new identity_1.Identity(trapdoor);
+            const commitment = identity.commitment.toString();
+            // Cache the identity
+            this.identityCache.set(commitment, identity);
+            return {
+                commitment,
+                trapdoor: identity.trapdoor.toString(),
+                nullifier: identity.nullifier.toString(),
+                createdAt: Date.now(),
+            };
+        }
+        catch (error) {
+            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.ENCRYPTION, "ZK_IDENTITY_RESTORE_FAILED", `Failed to restore ZK identity: ${error.message}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Generate Gun credentials from ZK identity
+     */
+    async generateCredentials(identityData) {
+        try {
+            // Use commitment as username and trapdoor as password for Gun
+            const username = `zk_${identityData.commitment.slice(0, 16)}`;
+            // Derive password from trapdoor and nullifier
+            const password = ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(`${identityData.trapdoor}_${identityData.nullifier}`));
+            // Derive Gun SEA pair
+            const gunPair = await (0, derive_1.default)(password, username, {
+                includeP256: true,
+            });
+            // Cache credential
+            this.credentialCache.set(identityData.commitment, {
+                commitment: identityData.commitment,
+                gunPair,
+                createdAt: identityData.createdAt,
+            });
+            return gunPair;
+        }
+        catch (error) {
+            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.ENCRYPTION, "ZK_CREDENTIAL_GENERATION_FAILED", `Failed to generate credentials from ZK identity: ${error.message}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get or create a Semaphore group
+     */
+    getOrCreateGroup(groupId = "default") {
+        if (!this.groups.has(groupId)) {
+            // Convert string groupId to BigNumber using keccak256 hash
+            const groupIdHash = ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(groupId));
+            const groupIdNumber = BigInt(groupIdHash);
+            this.groups.set(groupId, new group_1.Group(groupIdNumber));
+        }
+        return this.groups.get(groupId);
+    }
+    /**
+     * Add identity to a group
+     */
+    addToGroup(commitment, groupId = "default") {
+        const group = this.getOrCreateGroup(groupId);
+        group.addMember(BigInt(commitment));
+    }
+    /**
+     * Generate a Semaphore proof
+     */
+    async generateProof(identityData, options = {}) {
+        try {
+            const groupId = options.groupId || "default";
+            const messageString = options.message || "authenticate";
+            const scopeString = options.scope || "shogun-auth";
+            // Convert message and scope to BigNumber (Semaphore requires BigInt)
+            const messageHash = ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(messageString));
+            const message = BigInt(messageHash);
+            const scopeHash = ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(scopeString));
+            const scope = BigInt(scopeHash);
+            // Get or reconstruct identity
+            let identity = this.identityCache.get(identityData.commitment);
+            if (!identity && identityData.trapdoor) {
+                identity = new identity_1.Identity(identityData.trapdoor);
+                this.identityCache.set(identityData.commitment, identity);
+            }
+            if (!identity) {
+                throw new Error("Identity not found and cannot be reconstructed");
+            }
+            // Get group
+            const group = this.getOrCreateGroup(groupId);
+            // Add identity to group if not already added
+            if (!group.members.includes(identity.commitment)) {
+                group.addMember(identity.commitment);
+            }
+            // Generate proof
+            const fullProof = await (0, proof_1.generateProof)(identity, group, message, scope);
+            return {
+                merkleTreeRoot: fullProof.merkleTreeRoot.toString(),
+                nullifierHash: fullProof.nullifierHash.toString(),
+                signal: fullProof.signal.toString(),
+                externalNullifier: fullProof.externalNullifier.toString(),
+                proof: fullProof.proof.map((p) => p.toString()),
+            };
+        }
+        catch (error) {
+            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.ENCRYPTION, "ZK_PROOF_GENERATION_FAILED", `Failed to generate ZK proof: ${error.message}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Verify a Semaphore proof
+     */
+    async verifyProof(proof, treeDepth = 20) {
+        try {
+            const verified = await (0, proof_1.verifyProof)(proof, treeDepth);
+            return {
+                success: true,
+                verified,
+            };
+        }
+        catch (error) {
+            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.ENCRYPTION, "ZK_PROOF_VERIFICATION_FAILED", `Failed to verify ZK proof: ${error.message}`, error);
+            return {
+                success: false,
+                verified: false,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Get cached credential by commitment
+     */
+    getCredential(commitment) {
+        return this.credentialCache.get(commitment);
+    }
+    /**
+     * Clear all caches
+     */
+    cleanup() {
+        this.identityCache.clear();
+        this.credentialCache.clear();
+        this.groups.clear();
+    }
+}
+exports.ZkProofConnector = ZkProofConnector;

package/dist/plugins/zkproof/zkProofPlugin.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZkProofPlugin = void 0;
+const base_1 = require("../base");
+const zkProofConnector_1 = require("./zkProofConnector");
+const shogun_1 = require("../../interfaces/shogun");
+const errorHandler_1 = require("../../utils/errorHandler");
+/**
+ * Plugin for Zero-Knowledge Proof authentication using Semaphore protocol
+ *
+ * Features:
+ * - Anonymous authentication with ZK proofs
+ * - Multi-device support via trapdoor backup
+ * - Privacy-preserving identity management
+ * - Compatible with Gun decentralized storage
+ */
+class ZkProofPlugin extends base_1.BasePlugin {
+    constructor(config = {}) {
+        super();
+        this.name = "zkproof";
+        this.version = "1.0.0";
+        this.description = "Zero-Knowledge Proof authentication using Semaphore protocol for ShogunCore";
+        this._category = shogun_1.PluginCategory.Authentication;
+        this.connector = null;
+        this.config = {
+            defaultGroupId: "shogun-users",
+            deterministic: false,
+            minEntropy: 128,
+            ...config,
+        };
+    }
+    /**
+     * Initialize the plugin
+     */
+    initialize(core) {
+        super.initialize(core);
+        this.connector = new zkProofConnector_1.ZkProofConnector();
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        if (this.connector) {
+            this.connector.cleanup();
+        }
+        this.connector = null;
+        super.destroy();
+    }
+    /**
+     * Ensure connector is initialized
+     */
+    assertConnector() {
+        this.assertInitialized();
+        if (!this.connector) {
+            throw new Error("ZK-Proof connector not initialized");
+        }
+        return this.connector;
+    }
+    /**
+     * Generate a new ZK identity
+     */
+    async generateIdentity(seed) {
+        try {
+            return await this.assertConnector().generateIdentity(seed);
+        }
+        catch (error) {
+            throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.ENCRYPTION, "ZK_IDENTITY_GENERATION_FAILED", `Failed to generate ZK identity: ${error.message}`);
+        }
+    }
+    /**
+     * Restore identity from trapdoor/seed phrase
+     */
+    async restoreIdentity(trapdoor) {
+        try {
+            if (!trapdoor || trapdoor.trim().length === 0) {
+                throw new Error("Trapdoor is required");
+            }
+            return await this.assertConnector().restoreIdentity(trapdoor);
+        }
+        catch (error) {
+            throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.ENCRYPTION, "ZK_IDENTITY_RESTORE_FAILED", `Failed to restore ZK identity: ${error.message}`);
+        }
+    }
+    /**
+     * Generate credentials for Gun authentication
+     */
+    async generateCredentials(identityData) {
+        try {
+            return await this.assertConnector().generateCredentials(identityData);
+        }
+        catch (error) {
+            throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.ENCRYPTION, "ZK_CREDENTIAL_GENERATION_FAILED", `Failed to generate credentials: ${error.message}`);
+        }
+    }
+    /**
+     * Generate a zero-knowledge proof
+     */
+    async generateProof(identityData, options) {
+        try {
+            return await this.assertConnector().generateProof(identityData, options);
+        }
+        catch (error) {
+            throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.ENCRYPTION, "ZK_PROOF_GENERATION_FAILED", `Failed to generate ZK proof: ${error.message}`);
+        }
+    }
+    /**
+     * Verify a zero-knowledge proof
+     */
+    async verifyProof(proof, treeDepth = 20) {
+        try {
+            return await this.assertConnector().verifyProof(proof, treeDepth);
+        }
+        catch (error) {
+            return {
+                success: false,
+                verified: false,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Add identity to a group
+     */
+    addToGroup(commitment, groupId) {
+        const group = groupId || this.config.defaultGroupId || "default";
+        this.assertConnector().addToGroup(commitment, group);
+    }
+    /**
+     * Login with ZK proof
+     * @param trapdoor - User's trapdoor/seed phrase
+     * @returns Authentication result
+     */
+    async login(trapdoor) {
+        try {
+            const core = this.assertInitialized();
+            const connector = this.assertConnector();
+            if (!trapdoor || trapdoor.trim().length === 0) {
+                throw (0, errorHandler_1.createError)(errorHandler_1.ErrorType.VALIDATION, "TRAPDOOR_REQUIRED", "Trapdoor is required for ZK-Proof login");
+            }
+            console.log("🔐 ZK-Proof login - restoring identity from trapdoor");
+            // Restore identity from trapdoor
+            const identityData = await connector.restoreIdentity(trapdoor);
+            console.log(`🔐 ZK-Proof login - identity restored, commitment: ${identityData.commitment.slice(0, 16)}...`);
+            // Generate credentials for Gun
+            const gunPair = await connector.generateCredentials(identityData);
+            console.log(`🔐 ZK-Proof login - Gun credentials generated, pub: ${gunPair.pub.slice(0, 16)}...`);
+            // Authenticate with Gun using the derived pair via ShogunCore
+            const username = `zk_${identityData.commitment.slice(0, 16)}`;
+            try {
+                // Try to authenticate with existing account using ShogunCore
+                const loginResult = await core.loginWithPair(username, gunPair);
+                if (!loginResult.success) {
+                    console.log("🔐 ZK-Proof login - existing account not found, this might be first login");
+                }
+                else {
+                    console.log("🔐 ZK-Proof login - Gun authentication successful");
+                }
+            }
+            catch (authError) {
+                console.log("🔐 ZK-Proof login - existing account not found, this might be first login");
+            }
+            // Set authentication method
+            core.setAuthMethod("zkproof");
+            // Add to default group
+            this.addToGroup(identityData.commitment);
+            const result = {
+                success: true,
+                userPub: gunPair.pub,
+                username: username,
+                authMethod: "zkproof",
+                sea: {
+                    pub: gunPair.pub,
+                    priv: gunPair.priv,
+                    epub: gunPair.epub,
+                    epriv: gunPair.epriv,
+                },
+            };
+            // Emit login event
+            core.emit("auth:login", {
+                userPub: gunPair.pub,
+                username: username,
+                method: "zkproof",
+            });
+            console.log("🔐 ZK-Proof login - complete");
+            return result;
+        }
+        catch (error) {
+            const errorType = error?.type || errorHandler_1.ErrorType.AUTHENTICATION;
+            const errorCode = error?.code || "ZK_LOGIN_ERROR";
+            const errorMessage = error?.message || "Unknown error during ZK-Proof login";
+            errorHandler_1.ErrorHandler.handle(errorType, errorCode, errorMessage, error);
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Sign up with new ZK identity
+     * @param seed - Optional seed for deterministic generation
+     * @returns Authentication result with trapdoor for backup
+     */
+    async signUp(seed) {
+        try {
+            const core = this.assertInitialized();
+            const connector = this.assertConnector();
+            console.log("🔐 ZK-Proof signup - generating new identity");
+            // Generate new identity
+            const identityData = await connector.generateIdentity(seed);
+            console.log(`🔐 ZK-Proof signup - identity generated, commitment: ${identityData.commitment.slice(0, 16)}...`);
+            // Generate credentials for Gun
+            const gunPair = await connector.generateCredentials(identityData);
+            console.log(`🔐 ZK-Proof signup - Gun credentials generated, pub: ${gunPair.pub.slice(0, 16)}...`);
+            // Create Gun user account using ShogunCore methods
+            const username = `zk_${identityData.commitment.slice(0, 16)}`;
+            try {
+                // Try to create user with signUp
+                const signUpResult = await core.signUp(username, undefined, gunPair);
+                if (!signUpResult.success) {
+                    // If user already exists, login with the pair
+                    const loginResult = await core.loginWithPair(username, gunPair);
+                    if (!loginResult.success) {
+                        throw new Error(loginResult.error || "Failed to authenticate");
+                    }
+                }
+                console.log("🔐 ZK-Proof signup - Gun user created/authenticated");
+            }
+            catch (createError) {
+                throw createError;
+            }
+            // Set authentication method
+            core.setAuthMethod("zkproof");
+            // Add to default group
+            this.addToGroup(identityData.commitment);
+            const result = {
+                success: true,
+                userPub: gunPair.pub,
+                username: username,
+                authMethod: "zkproof",
+                isNewUser: true,
+                // CRITICAL: Include trapdoor for user backup (like seed phrase in WebAuthn)
+                seedPhrase: identityData.trapdoor,
+                sea: {
+                    pub: gunPair.pub,
+                    priv: gunPair.priv,
+                    epub: gunPair.epub,
+                    epriv: gunPair.epriv,
+                },
+            };
+            // Emit signup event
+            core.emit("auth:signup", {
+                userPub: gunPair.pub,
+                username: username,
+                method: "zkproof",
+            });
+            console.log("🔐 ZK-Proof signup - complete");
+            console.log(`⚠️  IMPORTANT: Save the trapdoor (seed phrase) for account recovery!`);
+            return result;
+        }
+        catch (error) {
+            const errorType = error?.type || errorHandler_1.ErrorType.AUTHENTICATION;
+            const errorCode = error?.code || "ZK_SIGNUP_ERROR";
+            const errorMessage = error?.message || "Unknown error during ZK-Proof signup";
+            errorHandler_1.ErrorHandler.handle(errorType, errorCode, errorMessage, error);
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Check if ZK-Proof is available
+     */
+    isAvailable() {
+        return typeof window !== "undefined" || typeof global !== "undefined";
+    }
+}
+exports.ZkProofPlugin = ZkProofPlugin;

package/dist/types/core.d.ts

@@ -19,7 +19,7 @@ import { PluginManager } from "./managers/PluginManager";
  * @since 2.0.0
  */
 export declare class ShogunCore implements IShogunCore {
-    static readonly API_VERSION = "^3.0.11";
+    static readonly API_VERSION = "^3.3.8";
     db: DataBase;
     storage: ShogunStorage;
     provider?: ethers.Provider;

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

@@ -1,5 +1,10 @@
 /**
- * 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
  */
 declare function simpleAPITest(): Promise<void>;
 export { simpleAPITest };

package/dist/types/examples/zkproof-credentials-example.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ZK-Proof Verifiable Credentials Example
+ *
+ * This demonstrates how to use ZK-Proof for proving attributes
+ * about documents and identity without revealing sensitive data
+ */
+declare function ageVerificationExample(): Promise<void>;
+declare function citizenshipExample(): Promise<void>;
+declare function educationExample(): Promise<void>;
+declare function incomeExample(): Promise<void>;
+declare function customCredentialExample(): Promise<void>;
+export { ageVerificationExample, citizenshipExample, educationExample, incomeExample, customCredentialExample, };

package/dist/types/examples/zkproof-example.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+declare function basicExample(): Promise<void>;
+declare function deterministicExample(): Promise<void>;
+declare function proofExample(): Promise<void>;
+declare function multiDeviceExample(): Promise<void>;
+export { basicExample, deterministicExample, proofExample, multiDeviceExample };