shogun-core 6.2.3 → 6.3.0

package/dist/plugins/zkproof/zkProofConnector.js

@@ -1,198 +0,0 @@
-"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.indexOf(identity.commitment) === -1) {
-                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

@@ -1,272 +0,0 @@
-"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/storage/storage.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShogunStorage = void 0;
-/**
- * Storage implementation based on StorageMock
- * Provides a unified storage interface that works in both browser and non-browser environments
- * In browser environments, data is persisted to localStorage as a backup
- */
-class ShogunStorage {
-    /**
-     * Initializes storage and loads any existing keypair from localStorage if available
-     */
-    constructor(silent = false) {
-        this.store = new Map();
-        this.silent = silent;
-        this.isTestMode = process.env.NODE_ENV === "test";
-        this.useLocalStorage = false;
-        // In test mode, don't use localStorage to avoid test pollution
-        if (this.isTestMode) {
-            this.useLocalStorage = false;
-            return;
-        }
-        if (typeof localStorage !== "undefined") {
-            try {
-                // Probe localStorage without polluting expectations in tests
-                const testKey = "_shogun_test";
-                localStorage.setItem(testKey, testKey);
-                localStorage.removeItem(testKey);
-                this.useLocalStorage = true;
-                if (!this.silent) {
-                    console.log("ShogunStorage: localStorage enabled");
-                }
-                const storedPair = localStorage.getItem("shogun_keypair");
-                if (storedPair) {
-                    this.store.set("keypair", JSON.parse(storedPair));
-                }
-            }
-            catch (error) {
-                this.useLocalStorage = false;
-                // Silence logs in tests; tests expect no console.error during constructor
-                if (!this.silent) {
-                    console.log("ShogunStorage: localStorage error:", error.message);
-                }
-            }
-        }
-    }
-    /**
-     * Gets the stored keypair asynchronously
-     * @returns Promise resolving to the keypair or null if not found
-     */
-    async getPair() {
-        return this.getPairSync();
-    }
-    /**
-     * Gets the stored keypair synchronously
-     * @returns The keypair or null if not found
-     */
-    getPairSync() {
-        return this.store.get("keypair") || null;
-    }
-    /**
-     * Stores a keypair both in memory and localStorage if available
-     * @param pair - The keypair to store
-     */
-    async setPair(pair) {
-        this.store.set("keypair", pair);
-        // Also save to localStorage in browser environments
-        if (this.useLocalStorage) {
-            try {
-                localStorage.setItem("shogun_keypair", JSON.stringify(pair));
-            }
-            catch (error) {
-                if (!this.isTestMode) {
-                    console.error("Error saving data to localStorage:", error);
-                }
-            }
-        }
-    }
-    /**
-     * Clears all stored data from both memory and localStorage
-     */
-    clearAll() {
-        this.store.clear();
-        // Also clear localStorage in browser environments
-        if (this.useLocalStorage) {
-            try {
-                localStorage.removeItem("shogun_keypair");
-            }
-            catch (error) {
-                if (!this.isTestMode) {
-                    console.error("Error removing data from localStorage:", error);
-                }
-            }
-        }
-    }
-    /**
-     * Gets an item from storage
-     * @param key - The key to retrieve
-     * @returns The stored value, or null if not found
-     */
-    getItem(key) {
-        const value = this.store.get(key);
-        if (value === undefined) {
-            return null;
-        }
-        return value;
-    }
-    /**
-     * Stores an item in both memory and localStorage if available
-     * @param key - The key to store under
-     * @param value - The value to store (must be JSON stringifiable)
-     */
-    setItem(key, value) {
-        // Store the raw value as-is to preserve formatting
-        this.store.set(key, value);
-        if (this.useLocalStorage) {
-            try {
-                localStorage.setItem(key, typeof value === "string" ? value : JSON.stringify(value));
-            }
-            catch (error) {
-                if (!this.isTestMode) {
-                    console.error(`Error saving ${key} to localStorage:`, error);
-                }
-            }
-        }
-    }
-    /**
-     * Removes an item from both memory and localStorage if available
-     * @param key - The key to remove
-     */
-    removeItem(key) {
-        this.store.delete(key);
-        if (this.useLocalStorage) {
-            try {
-                localStorage.removeItem(key);
-            }
-            catch (error) {
-                if (!this.isTestMode) {
-                    console.error(`Error removing ${key} from localStorage:`, error);
-                }
-            }
-        }
-    }
-}
-exports.ShogunStorage = ShogunStorage;

package/dist/types/gundb/gun-es.d.ts

@@ -1,8 +0,0 @@
-import { Gun, SEA } from "./min";
-import "gun/lib/then";
-import "gun/lib/radix";
-import "gun/lib/radisk";
-import "gun/lib/store";
-import "gun/lib/rindexed";
-import "gun/lib/webrtc";
-export { Gun, SEA };