shogun-core 3.3.8 → 4.0.0

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/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 };

package/dist/types/gundb/types.d.ts

@@ -240,7 +240,7 @@ export interface TypedGunError extends Error {
     context?: Record<string, unknown>;
 }
 export type GunOperation = "get" | "put" | "set" | "remove" | "once" | "on" | "off";
-export type GunAuthMethod = "password" | "pair" | "webauthn" | "web3" | "nostr";
+export type GunAuthMethod = "password" | "pair" | "webauthn" | "web3" | "nostr" | "zkproof";
 export interface TypedGunWrapper<T = Record<string, unknown>> {
     gun: IGunInstance<any>;
     user: IGunUserInstance | null;

package/dist/types/index.d.ts

@@ -11,3 +11,4 @@ export * from "./config/simplified-config";
 export type * from "./interfaces/plugin";
 export type { IGunUserInstance, IGunInstance, GunDataEventData, GunPeerEventData, DeriveOptions, TypedGunOperationResult, TypedAuthResult, };
 export { Gun, ShogunCore, SEA, RxJS, crypto, derive, GunErrors, DataBase, SimpleGunAPI, QuickStart, quickStart, createSimpleAPI, AutoQuickStart, autoQuickStart, };
+export { generateSeedPhrase, validateSeedPhrase, mnemonicToSeed, seedToPassword, deriveCredentialsFromMnemonic, formatSeedPhrase, normalizeSeedPhrase, } from "./utils/seedPhrase";

package/dist/types/interfaces/events.d.ts

@@ -4,13 +4,13 @@ import { EventEmitter } from "../utils/eventEmitter";
  * @interface AuthEventData
  * @property {string} [userPub] - The user's public key (optional)
  * @property {string} [username] - Optional username
- * @property {"password" | "webauthn" | "web3" | "nostr" | "oauth" | "bitcoin" } method - Authentication method used
- * @property {string} [provider] - Optional provider name (for OAuth)
+ * @property {"password" | "webauthn" | "web3" | "nostr" | "zkproof" | "pair" } method - Authentication method used
+ * @property {string} [provider] - Optional provider name
  */
 export interface AuthEventData {
     userPub?: string;
     username?: string;
-    method: "password" | "webauthn" | "web3" | "nostr" | "oauth" | "bitcoin" | "pair";
+    method: "password" | "webauthn" | "web3" | "nostr" | "zkproof" | "pair";
     provider?: string;
 }
 /**

package/dist/types/interfaces/shogun.d.ts

@@ -36,14 +36,14 @@ export declare enum CorePlugins {
     Web3 = "web3",
     /** Bitcoin wallet plugin */
     Nostr = "nostr",
-    /** OAuth plugin */
-    OAuth = "oauth"
+    /** Zero-Knowledge Proof plugin */
+    ZkProof = "zkproof"
 }
-export type AuthMethod = "password" | "webauthn" | "web3" | "nostr" | "oauth" | "pair";
+export type AuthMethod = "password" | "webauthn" | "web3" | "nostr" | "zkproof" | "pair";
 export interface AuthEventData {
     userPub?: string;
     username?: string;
-    method: "password" | "webauthn" | "web3" | "nostr" | "oauth" | "pair";
+    method: "password" | "webauthn" | "web3" | "nostr" | "zkproof" | "pair";
     provider?: string;
 }
 export interface AuthResult {
@@ -70,14 +70,6 @@ export interface AuthResult {
         email?: string;
         name?: string;
         picture?: string;
-        oauth?: {
-            provider: string;
-            id: string;
-            email?: string;
-            name?: string;
-            picture?: string;
-            lastLogin: number;
-        };
     };
 }
 /**
@@ -100,6 +92,7 @@ export interface SignUpResult {
         epub: string;
         epriv: string;
     };
+    seedPhrase?: string;
     redirectUrl?: string;
     pendingAuth?: boolean;
     provider?: string;
@@ -109,14 +102,6 @@ export interface SignUpResult {
         email?: string;
         name?: string;
         picture?: string;
-        oauth?: {
-            provider: string;
-            id: string;
-            email?: string;
-            name?: string;
-            picture?: string;
-            lastLogin: number;
-        };
     };
 }
 export interface IShogunCore extends PluginManager {
@@ -177,11 +162,11 @@ export interface ShogunCoreConfig {
     nostr?: {
         enabled?: boolean;
     };
-    oauth?: {
+    zkproof?: {
         enabled?: boolean;
-        usePKCE?: boolean;
-        allowUnsafeClientSecret?: boolean;
-        providers?: Record<string, any>;
+        defaultGroupId?: string;
+        deterministic?: boolean;
+        minEntropy?: number;
     };
     timeouts?: {
         login?: number;

package/dist/types/plugins/index.d.ts

@@ -9,6 +9,8 @@ export type { Web3ConnectorPluginInterface } from "./web3/types";
 export { NostrConnector } from "./nostr/nostrConnector";
 export { NostrConnectorPlugin } from "./nostr/nostrConnectorPlugin";
 export type { NostrConnectorPluginInterface, NostrConnectorCredentials, NostrConnectorKeyPair, NostrConnectorConfig, AlbyProvider, NostrProvider, } from "./nostr/types";
-export { OAuthConnector } from "./oauth/oauthConnector";
-export { OAuthPlugin } from "./oauth/oauthPlugin";
-export * from "./oauth/types";
+export { ZkProofConnector } from "./zkproof/zkProofConnector";
+export { ZkProofPlugin } from "./zkproof/zkProofPlugin";
+export { ZkCredentials, CredentialType } from "./zkproof/zkCredentials";
+export type { ZkProofPluginInterface, ZkIdentityData, ZkProofAuthResult, ZkProofGenerationOptions, ZkProofVerificationResult, ZkProofCredential, ZkProofConfig, SemaphoreProof, } from "./zkproof/types";
+export type { CredentialClaim, VerifiableCredentialProof, CredentialVerificationResult, } from "./zkproof/zkCredentials";

package/dist/types/plugins/webauthn/types.d.ts

@@ -148,9 +148,29 @@ export interface WebauthnPluginInterface {
     /**
      * Signup con WebAuthn
      * @param username Nome utente
+     * @param options Optional signup options
      * @returns Promise con il risultato dell'operazione
      */
-    signUp(username: string): Promise<SignUpResult>;
+    signUp(username: string, options?: WebAuthnSignUpOptions): Promise<SignUpResult>;
+    /**
+     * Import account from seed phrase
+     * @param username Nome utente
+     * @param seedPhrase BIP39 mnemonic seed phrase (12 words)
+     * @returns Promise con il risultato dell'operazione
+     */
+    importFromSeed(username: string, seedPhrase: string): Promise<SignUpResult>;
+    /**
+     * Get seed phrase for current user (if available)
+     * @param username Nome utente
+     * @returns Seed phrase or null
+     */
+    getSeedPhrase(username: string): Promise<string | null>;
+}
+export interface WebAuthnSignUpOptions {
+    /** Use existing seed phrase instead of generating new one */
+    seedPhrase?: string;
+    /** Generate and return seed phrase for multi-device support */
+    generateSeedPhrase?: boolean;
 }
 export interface WebAuthnUniformCredentials {
     success: boolean;
@@ -159,4 +179,5 @@ export interface WebAuthnUniformCredentials {
     credentialId: string;
     publicKey?: ArrayBuffer | null;
     error?: string;
+    seedPhrase?: string;
 }

package/dist/types/plugins/webauthn/webauthn.d.ts

@@ -111,7 +111,7 @@ export declare class Webauthn extends EventEmitter {
     sign(data: Record<string, unknown>): Promise<unknown>;
 }
 export type { WebAuthnCredentials, DeviceInfo, CredentialResult };
-export declare function deriveWebauthnKeys(username: string, credentialId: string): Promise<{
+export declare function deriveWebauthnKeys(username: string, credentialIdOrSeedPhrase: string, useSeedPhrase?: boolean): Promise<{
     pub: string;
     priv: string;
     epub: string;

package/dist/types/plugins/webauthn/webauthnPlugin.d.ts

@@ -149,10 +149,31 @@ export declare class WebauthnPlugin extends BasePlugin implements WebauthnPlugin
      * Register new user with WebAuthn
      * This is the recommended method for WebAuthn registration
      * @param username - Username
-     * @returns {Promise<SignUpResult>} Registration result
+     * @param options - Optional signup options (seed phrase support)
+     * @returns {Promise<SignUpResult>} Registration result with optional seed phrase
      * @description Creates a new user account using WebAuthn credentials.
      * Requires browser support for WebAuthn.
+     * If generateSeedPhrase is true, returns a BIP39 mnemonic for multi-device support.
+     */
+    signUp(username: string, options?: {
+        seedPhrase?: string;
+        generateSeedPhrase?: boolean;
+    }): Promise<SignUpResult>;
+    /**
+     * Import existing account from seed phrase
+     * Allows accessing the same account across multiple devices
+     * @param username - Username
+     * @param seedPhrase - 12-word BIP39 mnemonic seed phrase
+     * @returns {Promise<SignUpResult>} Registration result
+     */
+    importFromSeed(username: string, seedPhrase: string): Promise<SignUpResult>;
+    /**
+     * Get seed phrase for current user (if stored)
+     * Note: Seed phrases are NOT stored by default for security
+     * Users should save their seed phrase during registration
+     * @param username - Username
+     * @returns {Promise<string | null>} Seed phrase or null
      */
-    signUp(username: string): Promise<SignUpResult>;
+    getSeedPhrase(username: string): Promise<string | null>;
 }
 export type { WebauthnPluginInterface } from "./types";

package/dist/types/plugins/zkproof/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ZK-Proof Plugin for Shogun Core
+ *
+ * Provides Zero-Knowledge Proof authentication using Semaphore protocol
+ *
+ * Features:
+ * - Anonymous authentication without revealing identity
+ * - Multi-device support via trapdoor backup
+ * - Privacy-preserving group membership proofs
+ * - Compatible with Gun decentralized storage
+ *
+ * @example
+ * ```typescript
+ * // Initialize Shogun with ZK-Proof plugin
+ * const shogun = new ShogunCore({
+ *   peers: ['https://gun-manhattan.herokuapp.com/gun'],
+ *   zkproof: {
+ *     enabled: true,
+ *     defaultGroupId: 'my-app-users'
+ *   }
+ * });
+ *
+ * await shogun.initialize();
+ *
+ * // Get the plugin
+ * const zkPlugin = shogun.getPlugin<ZkProofPlugin>('zkproof');
+ *
+ * // Sign up with ZK-Proof
+ * const signupResult = await zkPlugin.signUp();
+ * if (signupResult.success) {
+ *   console.log('Trapdoor (save this!):', signupResult.seedPhrase);
+ *   console.log('Public commitment:', signupResult.username);
+ * }
+ *
+ * // Login with trapdoor
+ * const loginResult = await zkPlugin.login(trapdoor);
+ * if (loginResult.success) {
+ *   console.log('Logged in anonymously!');
+ * }
+ * ```
+ *
+ * @module zkproof
+ */
+export { ZkProofPlugin } from "./zkProofPlugin";
+export { ZkProofConnector } from "./zkProofConnector";
+export { ZkCredentials, CredentialType } from "./zkCredentials";
+export type { ZkIdentityData, ZkProofAuthResult, ZkProofGenerationOptions, ZkProofVerificationResult, ZkProofCredential, ZkProofConfig, ZkProofPluginInterface, SemaphoreProof, } from "./types";
+export type { CredentialClaim, VerifiableCredentialProof, CredentialVerificationResult, } from "./zkCredentials";

package/dist/types/plugins/zkproof/types.d.ts

@@ -0,0 +1,123 @@
+import { ISEAPair } from "gun";
+/**
+ * ZK-Proof identity data
+ */
+export interface ZkIdentityData {
+    /** Semaphore identity commitment (public) */
+    commitment: string;
+    /** Trapdoor (private - used for recovery/login) */
+    trapdoor?: string;
+    /** Nullifier (private) */
+    nullifier?: string;
+    /** Creation timestamp */
+    createdAt: number;
+}
+/**
+ * ZK-Proof authentication result
+ */
+export interface ZkProofAuthResult {
+    success: boolean;
+    commitment?: string;
+    userPub?: string;
+    error?: string;
+}
+/**
+ * ZK-Proof generation options
+ */
+export interface ZkProofGenerationOptions {
+    /** Group ID for Semaphore group */
+    groupId?: string;
+    /** Custom message to prove */
+    message?: string;
+    /** Scope for the proof */
+    scope?: string;
+}
+/**
+ * ZK-Proof verification result
+ */
+export interface ZkProofVerificationResult {
+    success: boolean;
+    verified: boolean;
+    commitment?: string;
+    error?: string;
+}
+/**
+ * ZK-Proof credential for Gun authentication
+ */
+export interface ZkProofCredential {
+    commitment: string;
+    gunPair: ISEAPair;
+    createdAt: number;
+}
+/**
+ * ZK-Proof plugin configuration
+ */
+export interface ZkProofConfig {
+    /** Default group ID */
+    defaultGroupId?: string;
+    /** Enable deterministic identity generation */
+    deterministic?: boolean;
+    /** Minimum entropy for identity generation */
+    minEntropy?: number;
+}
+/**
+ * ZK-Proof plugin interface
+ */
+export interface ZkProofPluginInterface {
+    /**
+     * Generate a new ZK identity
+     * @param seed - Optional seed for deterministic generation
+     * @returns ZK identity data with trapdoor for backup
+     */
+    generateIdentity(seed?: string): Promise<ZkIdentityData>;
+    /**
+     * Restore identity from trapdoor/seed phrase
+     * @param trapdoor - Trapdoor or seed phrase
+     * @returns ZK identity data
+     */
+    restoreIdentity(trapdoor: string): Promise<ZkIdentityData>;
+    /**
+     * Generate credentials for Gun authentication
+     * @param identityData - ZK identity data
+     * @returns Gun SEA pair
+     */
+    generateCredentials(identityData: ZkIdentityData): Promise<ISEAPair>;
+    /**
+     * Generate a zero-knowledge proof
+     * @param identityData - ZK identity data
+     * @param options - Proof generation options
+     * @returns Proof data
+     */
+    generateProof(identityData: ZkIdentityData, options?: ZkProofGenerationOptions): Promise<any>;
+    /**
+     * Verify a zero-knowledge proof
+     * @param proof - Proof data to verify
+     * @param treeDepth - Merkle tree depth (default: 20)
+     * @returns Verification result
+     */
+    verifyProof(proof: any, treeDepth?: number): Promise<ZkProofVerificationResult>;
+    /**
+     * Login with ZK proof
+     * @param trapdoor - User's trapdoor/seed phrase
+     * @returns Authentication result
+     */
+    login(trapdoor: string): Promise<ZkProofAuthResult>;
+    /**
+     * Sign up with new ZK identity
+     * @param seed - Optional seed for deterministic generation
+     * @returns Authentication result with trapdoor for backup
+     */
+    signUp(seed?: string): Promise<ZkProofAuthResult & {
+        trapdoor?: string;
+    }>;
+}
+/**
+ * Semaphore proof data structure
+ */
+export interface SemaphoreProof {
+    merkleTreeRoot: string;
+    nullifierHash: string;
+    signal: string;
+    externalNullifier: string;
+    proof: string[];
+}