shogun-core 3.3.7 → 4.0.0

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

@@ -1,11 +1,17 @@
 /**
- * Simplified API layer to reduce complexity for common use cases.
- * Provides quick-start methods that wrap the full DataBase functionality.
+ * Simplified API layer focused on valuable helper methods.
+ * Provides quick-start initialization and high-level convenience methods.
+ *
+ * For basic operations (get, put, set, remove, auth), use DataBase directly.
+ * This class provides:
+ * - Quick initialization helpers (QuickStart, AutoQuickStart)
+ * - Array/Object conversion utilities for GunDB
+ * - High-level user data helpers (profile, settings, collections)
  */
-import { GunMessageGet, GunMessagePut } from "gun";
 import { DataBase } from "./db";
 /**
- * Simple API wrapper that provides common operations with minimal complexity.
+ * Simple API wrapper that provides high-level helper methods.
+ * For basic operations, use the DataBase instance directly via the `database` property.
  */
 export declare class SimpleGunAPI {
     private db;
@@ -15,183 +21,40 @@ export declare class SimpleGunAPI {
      */
     constructor(db: DataBase);
     /**
-     * Get data at a given path.
-     * @param path The path to retrieve data from.
-     * @returns The data at the path, or null if not found or on error.
+     * Get direct access to the DataBase instance for full control.
+     * Use this for basic operations like get, put, set, remove, login, etc.
      */
-    get<T = unknown>(path: string): Promise<T | null>;
-    /**
-     * Get the Gun node at a given path for chaining operations.
-     * @param path The path to the node.
-     * @returns The Gun node.
-     */
-    getNode(path: string): any;
-    /**
-     * Get the Gun node at a given path for direct chaining.
-     * @param path The path to the node.
-     * @returns The Gun node.
-     */
-    node(path: string): any;
-    /**
-     * Get a chainable wrapper for a Gun node at a given path.
-     * @param path The path to the node.
-     * @returns An object with chainable methods: get, put, set, once, then, map.
-     */
-    chain(path: string): {
-        get: (subPath: string) => GunMessageGet<any, any>;
-        put: (data: any) => Promise<GunMessagePut>;
-        set: (data: any) => Promise<GunMessagePut>;
-        once: () => Promise<any>;
-        then: () => Promise<any>;
-        map: (callback: (value: any, key: string) => any) => any;
-    };
-    /**
-     * Put data at a given path.
-     * @param path The path to put data to.
-     * @param data The data to put.
-     * @returns The GunMessagePut result.
-     */
-    put<T = unknown>(path: string, data: T): Promise<GunMessagePut>;
-    /**
-     * Set data at a given path (alternative to put).
-     * @param path The path to set data to.
-     * @param data The data to set.
-     * @returns The GunMessagePut result.
-     */
-    set<T = unknown>(path: string, data: T): Promise<GunMessagePut>;
-    /**
-     * Remove data at a given path.
-     * @param path The path to remove data from.
-     * @returns The GunMessagePut result.
-     */
-    remove(path: string): Promise<GunMessagePut>;
-    /**
-     * Log in a user.
-     * @param username The username.
-     * @param password The password.
-     * @returns The user info if successful, or null.
-     */
-    login(username: string, password: string): Promise<{
-        userPub: string;
-        username: string;
-    } | null>;
-    /**
-     * Sign up a new user.
-     * @param username The username.
-     * @param password The password.
-     * @returns The user info if successful, or null.
-     */
-    signup(username: string, password: string): Promise<{
-        userPub: string;
-        username: string;
-    } | null>;
-    /**
-     * Log out the current user.
-     */
-    logout(): void;
-    /**
-     * Check if a user is currently logged in.
-     * @returns True if logged in, false otherwise.
-     */
-    isLoggedIn(): boolean;
-    /**
-     * Get user data at a given path (requires login).
-     * @param path The path to the user data.
-     * @returns The user data, or null if not found or on error.
-     */
-    getUserData<T = unknown>(path: string): Promise<T | null>;
-    /**
-     * Put user data at a given path (requires login).
-     * @param path The path to put data to.
-     * @param data The data to put.
-     * @returns True if successful, false otherwise.
-     */
-    putUserData<T = unknown>(path: string, data: T): Promise<boolean>;
-    /**
-     * Set user data at a given path (alternative to put, requires login).
-     * @param path The path to set data to.
-     * @param data The data to set.
-     * @returns True if successful, false otherwise.
-     */
-    setUserData<T = unknown>(path: string, data: T): Promise<boolean>;
-    /**
-     * Remove user data at a given path (requires login).
-     * @param path The path to remove data from.
-     * @returns True if successful, false otherwise.
-     */
-    removeUserData(path: string): Promise<boolean>;
+    get database(): DataBase;
     /**
      * Convert an array to an indexed object for GunDB storage.
+     * GunDB doesn't store arrays natively, so this converts them to objects indexed by ID.
      * Example: [{id: '1', ...}, {id: '2', ...}] => { "1": {...}, "2": {...} }
-     * @param arr The array to convert.
-     * @returns The indexed object.
-     * @private
-     */
-    private getIndexedObjectFromArray;
-    /**
-     * Convert an indexed object back to an array.
-     * Example: { "1": {...}, "2": {...} } => [{id: '1', ...}, {id: '2', ...}]
-     * @param indexedObj The indexed object to convert.
-     * @returns The array.
-     * @private
-     */
-    private getArrayFromIndexedObject;
-    /**
-     * Convert an array to an indexed object for GunDB storage (public method).
-     * @param arr The array to convert.
-     * @returns The indexed object.
+     * @param arr The array to convert (each item must have an 'id' property).
+     * @returns The indexed object suitable for GunDB storage.
      */
     arrayToIndexedObject<T extends {
         id: string | number;
     }>(arr: T[]): Record<string, T>;
     /**
-     * Convert an indexed object to an array (public method).
+     * Convert an indexed object back to an array.
+     * Reverses the arrayToIndexedObject conversion.
+     * Example: { "1": {...}, "2": {...} } => [{id: '1', ...}, {id: '2', ...}]
      * @param indexedObj The indexed object to convert.
-     * @returns The array.
+     * @returns The array of items.
      */
     indexedObjectToArray<T>(indexedObj: Record<string, T> | null): T[];
     /**
-     * Get the GunDB user node at a given path (requires login).
-     * Useful for advanced operations that need direct GunDB node access.
-     * @param path The path to the user node.
-     * @returns The Gun node.
-     * @throws If not logged in.
-     */
-    getUserNode(path: string): any;
-    /**
-     * Get the GunDB global node at a given path.
-     * Useful for advanced operations that need direct GunDB node access.
-     * @param path The path to the global node.
-     * @returns The Gun node.
+     * Get all user data (returns user's entire data tree).
+     * Requires user to be logged in.
+     * @returns The complete user data tree, or null if not logged in or on error.
      */
-    getGlobalNode(path: string): any;
-    /**
-     * Get the current user info.
-     * @returns The current user info, or null if not logged in.
-     */
-    getCurrentUser(): {
-        pub: string;
-        username?: string;
-    } | null;
-    /**
-     * Check if a user exists by alias.
-     * @param alias The user alias.
-     * @returns True if the user exists, false otherwise.
-     */
-    userExists(alias: string): Promise<boolean>;
-    /**
-     * Get user info by alias.
-     * @param alias The user alias.
-     * @returns The user info, or null if not found.
-     */
-    getUser(alias: string): Promise<{
-        userPub: string;
-        username: string;
-    } | null>;
+    getAllUserData(): Promise<Record<string, unknown> | null>;
     /**
-     * Advanced user space operations
+     * Update user profile with common fields.
+     * Provides a standardized location for user profile data.
+     * @param profileData Profile data to save (name, email, bio, avatar, etc.)
+     * @returns True if successful, false otherwise.
      */
-    getAllUserData(): Promise<Record<string, unknown> | null>;
     updateProfile(profileData: {
         name?: string;
         email?: string;
@@ -199,14 +62,63 @@ export declare class SimpleGunAPI {
         avatar?: string;
         [key: string]: unknown;
     }): Promise<boolean>;
+    /**
+     * Get user profile data.
+     * @returns The user profile data, or null if not found or not logged in.
+     */
     getProfile(): Promise<Record<string, unknown> | null>;
+    /**
+     * Save user settings.
+     * Provides a standardized location for application settings.
+     * @param settings Settings object to save.
+     * @returns True if successful, false otherwise.
+     */
     saveSettings(settings: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Get user settings.
+     * @returns The user settings, or null if not found or not logged in.
+     */
     getSettings(): Promise<Record<string, unknown> | null>;
+    /**
+     * Save user preferences.
+     * Provides a standardized location for user preferences (distinct from settings).
+     * @param preferences Preferences object to save.
+     * @returns True if successful, false otherwise.
+     */
     savePreferences(preferences: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Get user preferences.
+     * @returns The user preferences, or null if not found or not logged in.
+     */
     getPreferences(): Promise<Record<string, unknown> | null>;
+    /**
+     * Create a user collection with initial items.
+     * Provides a standardized location for user collections.
+     * @param collectionName The name of the collection.
+     * @param items The initial items for the collection.
+     * @returns True if successful, false otherwise.
+     */
     createCollection<T = unknown>(collectionName: string, items: Record<string, T>): Promise<boolean>;
+    /**
+     * Add an item to a user collection.
+     * @param collectionName The name of the collection.
+     * @param itemId The ID of the item to add.
+     * @param item The item data.
+     * @returns True if successful, false otherwise.
+     */
     addToCollection<T = unknown>(collectionName: string, itemId: string, item: T): Promise<boolean>;
+    /**
+     * Get a user collection.
+     * @param collectionName The name of the collection.
+     * @returns The collection data, or null if not found or not logged in.
+     */
     getCollection(collectionName: string): Promise<Record<string, unknown> | null>;
+    /**
+     * Remove an item from a user collection.
+     * @param collectionName The name of the collection.
+     * @param itemId The ID of the item to remove.
+     * @returns True if successful, false otherwise.
+     */
     removeFromCollection(collectionName: string, itemId: string): Promise<boolean>;
 }
 /**

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[];
+}