shogun-core 5.2.0 → 5.2.2

package/dist/types/managers/PluginManager.d.ts

@@ -0,0 +1,145 @@
+import { ShogunPlugin } from "../interfaces/plugin";
+import { PluginCategory } from "../interfaces/shogun";
+import { IShogunCore } from "../interfaces/shogun";
+/**
+ * Manages plugin registration, validation, and lifecycle
+ */
+export declare class PluginManager {
+    private plugins;
+    private core;
+    constructor(core: IShogunCore);
+    /**
+     * Register a plugin with the Shogun SDK
+     * @param plugin Plugin instance to register
+     * @throws Error if a plugin with the same name is already registered
+     */
+    register(plugin: ShogunPlugin): void;
+    /**
+     * Unregister a plugin from the Shogun SDK
+     * @param name Name of the plugin to unregister
+     */
+    unregister(name: string): boolean;
+    /**
+     * Retrieve a registered plugin by name
+     * @param name Name of the plugin
+     * @returns The requested plugin or undefined if not found
+     * @template T Type of the plugin or its public interface
+     */
+    getPlugin<T = ShogunPlugin>(name: string): T | undefined;
+    /**
+     * Get information about all registered plugins
+     * @returns Array of plugin information objects
+     */
+    getPluginsInfo(): Array<{
+        name: string;
+        version: string;
+        category?: PluginCategory;
+        description?: string;
+    }>;
+    /**
+     * Get the total number of registered plugins
+     * @returns Number of registered plugins
+     */
+    getPluginCount(): number;
+    /**
+     * Check if all plugins are properly initialized
+     * @returns Object with initialization status for each plugin
+     */
+    getPluginsInitializationStatus(): Record<string, {
+        initialized: boolean;
+        error?: string;
+    }>;
+    /**
+     * Validate plugin system integrity
+     * @returns Object with validation results
+     */
+    validatePluginSystem(): {
+        totalPlugins: number;
+        initializedPlugins: number;
+        failedPlugins: string[];
+        warnings: string[];
+    };
+    /**
+     * Attempt to reinitialize failed plugins
+     * @returns Object with reinitialization results
+     */
+    reinitializeFailedPlugins(): {
+        success: string[];
+        failed: Array<{
+            name: string;
+            error: string;
+        }>;
+    };
+    /**
+     * Check plugin compatibility with current ShogunCore version
+     * @returns Object with compatibility information
+     */
+    checkPluginCompatibility(): {
+        compatible: Array<{
+            name: string;
+            version: string;
+        }>;
+        incompatible: Array<{
+            name: string;
+            version: string;
+            reason: string;
+        }>;
+        unknown: Array<{
+            name: string;
+            version: string;
+        }>;
+    };
+    /**
+     * Get comprehensive debug information about the plugin system
+     * @returns Complete plugin system debug information
+     */
+    getPluginSystemDebugInfo(): {
+        shogunCoreVersion: string;
+        totalPlugins: number;
+        plugins: Array<{
+            name: string;
+            version: string;
+            category?: PluginCategory;
+            description?: string;
+            initialized: boolean;
+            error?: string;
+        }>;
+        initializationStatus: Record<string, {
+            initialized: boolean;
+            error?: string;
+        }>;
+        validation: {
+            totalPlugins: number;
+            initializedPlugins: number;
+            failedPlugins: string[];
+            warnings: string[];
+        };
+        compatibility: {
+            compatible: Array<{
+                name: string;
+                version: string;
+            }>;
+            incompatible: Array<{
+                name: string;
+                version: string;
+                reason: string;
+            }>;
+            unknown: Array<{
+                name: string;
+                version: string;
+            }>;
+        };
+    };
+    /**
+     * Check if a plugin is registered
+     * @param name Name of the plugin to check
+     * @returns true if the plugin is registered, false otherwise
+     */
+    hasPlugin(name: string): boolean;
+    /**
+     * Get all plugins of a specific category
+     * @param category Category of plugins to filter
+     * @returns Array of plugins in the specified category
+     */
+    getPluginsByCategory(category: PluginCategory): ShogunPlugin[];
+}

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

@@ -0,0 +1,35 @@
+import { ShogunCore } from "../core";
+import { ShogunPlugin } from "../interfaces/plugin";
+import { PluginCategory } from "../interfaces/shogun";
+import { EventEmitter } from "../utils/eventEmitter";
+/**
+ * Classe base per tutti i plugin di ShogunCore
+ * Fornisce funzionalità comuni e implementazione base dell'interfaccia ShogunPlugin
+ */
+export declare abstract class BasePlugin extends EventEmitter implements ShogunPlugin {
+    /** Nome univoco del plugin - deve essere implementato dalle sottoclassi */
+    abstract name: string;
+    /** Versione del plugin - deve essere implementata dalle sottoclassi */
+    abstract version: string;
+    /** Descrizione opzionale del plugin */
+    description?: string;
+    /** Categoria del plugin */
+    _category?: PluginCategory;
+    /** Riferimento all'istanza di ShogunCore */
+    protected core: ShogunCore | null;
+    /**
+     * Inizializza il plugin con un'istanza di ShogunCore
+     * @param core Istanza di ShogunCore
+     */
+    initialize(core: ShogunCore): void;
+    /**
+     * Distrugge il plugin e libera le risorse
+     */
+    destroy(): void;
+    /**
+     * Verifica che il plugin sia stato inizializzato prima di usare il core
+     * @throws Error se il plugin non è stato inizializzato
+     * @returns L'istanza di ShogunCore non null
+     */
+    protected assertInitialized(): ShogunCore;
+}

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

@@ -0,0 +1,18 @@
+export { BasePlugin } from "./base";
+export type { ShogunPlugin, PluginManager } from "../interfaces/plugin";
+export { Webauthn } from "./webauthn/webauthn";
+export { WebauthnPlugin } from "./webauthn/webauthnPlugin";
+export type { WebauthnPluginInterface } from "./webauthn/types";
+export { Web3Connector } from "./web3/web3Connector";
+export { Web3ConnectorPlugin } from "./web3/web3ConnectorPlugin";
+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 { 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";
+export { SmartWalletPlugin } from "./smartwallet/smartWalletPlugin";
+export type { SmartWalletPluginInterface, SmartWalletConfig, WalletCreateResult, WalletInfo, ExecutionResult, ProposalInfo, RecoveryRequest, } from "./smartwallet/types";

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

@@ -0,0 +1,4 @@
+export * from "./nostrConnectorPlugin";
+export * from "./nostrConnector";
+export * from "./nostrSigner";
+export * from "./types";

package/dist/types/plugins/nostr/nostrConnector.d.ts

@@ -0,0 +1,119 @@
+import { EventEmitter } from "../../utils/eventEmitter";
+import { ConnectionResult, AlbyProvider, NostrProvider, NostrConnectorConfig, NostrConnectorKeyPair } from "./types";
+declare global {
+    interface Window {
+        alby?: AlbyProvider;
+        nostr?: NostrProvider;
+        NostrConnector?: typeof NostrConnector;
+    }
+}
+export declare const MESSAGE_TO_SIGN = "I Love Shogun!";
+/**
+ * Class for Bitcoin wallet connections and operations
+ */
+declare class NostrConnector extends EventEmitter {
+    private readonly DEFAULT_CONFIG;
+    private readonly config;
+    private readonly signatureCache;
+    private connectedAddress;
+    private connectedType;
+    private manualKeyPair;
+    constructor(config?: Partial<NostrConnectorConfig>);
+    /**
+     * Setup event listeners
+     */
+    private setupEventListeners;
+    /**
+     * Clear signature cache for a specific address or all addresses
+     */
+    clearSignatureCache(address?: string): void;
+    /**
+     * Check if Nostr extension is available
+     */
+    isNostrExtensionAvailable(): boolean;
+    /**
+     * Check if any Bitcoin wallet is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Connect to a wallet type
+     */
+    connectWallet(type?: "alby" | "nostr" | "manual"): Promise<ConnectionResult>;
+    /**
+     * Connect to Nostr extension
+     */
+    private connectNostr;
+    /**
+     * Set up manual key pair for connection
+     */
+    private connectManual;
+    /**
+     * Set a manual key pair for use
+     */
+    setKeyPair(keyPair: NostrConnectorKeyPair): void;
+    /**
+     * Generate credentials using Nostr: username deterministico e chiave GunDB derivata dall'address
+     */
+    generateCredentials(address: string, signature: string, message: string): Promise<{
+        username: string;
+        key: {
+            pub: string;
+            priv: string;
+            epub: string;
+            epriv: string;
+            secp256k1Bitcoin: {
+                privateKey: string;
+                publicKey: string;
+                address: string;
+            };
+            secp256k1Ethereum: {
+                privateKey: string;
+                publicKey: string;
+                address: string;
+            };
+        };
+        message: string;
+        signature: string;
+    }>;
+    /**
+     * Generate a password from a signature
+     */
+    generatePassword(signature: string): Promise<string>;
+    /**
+     * Verify a signature
+     */
+    verifySignature(message: string, signature: string, address: any): Promise<boolean>;
+    /**
+     * Get the currently connected address
+     */
+    getConnectedAddress(): string | null;
+    /**
+     * Get the currently connected wallet type
+     */
+    getConnectedType(): "alby" | "nostr" | "manual" | null;
+    /**
+     * Request a signature from the connected wallet
+     */
+    requestSignature(address: string, message: string): Promise<string>;
+    /**
+     * Cleanup event listeners
+     */
+    cleanup(): void;
+}
+export declare function deriveNostrKeys(address: string, signature: string, message: string): Promise<{
+    pub: string;
+    priv: string;
+    epub: string;
+    epriv: string;
+    secp256k1Bitcoin: {
+        privateKey: string;
+        publicKey: string;
+        address: string;
+    };
+    secp256k1Ethereum: {
+        privateKey: string;
+        publicKey: string;
+        address: string;
+    };
+}>;
+export { NostrConnector };

package/dist/types/plugins/nostr/nostrConnectorPlugin.d.ts

@@ -0,0 +1,163 @@
+import { BasePlugin } from "../base";
+import { ShogunCore } from "../../core";
+import { NostrSigningCredential } from "./nostrSigner";
+import { NostrConnectorCredentials, ConnectionResult, NostrConnectorPluginInterface } from "./types";
+import { AuthResult, SignUpResult } from "../../interfaces/shogun";
+/**
+ * Plugin for managing Bitcoin wallet functionality in ShogunCore
+ * Supports Alby, Nostr extensions, or direct key management
+ */
+export declare class NostrConnectorPlugin extends BasePlugin implements NostrConnectorPluginInterface {
+    name: string;
+    version: string;
+    description: string;
+    private bitcoinConnector;
+    private signer;
+    /**
+     * @inheritdoc
+     */
+    initialize(core: ShogunCore): void;
+    /**
+     * @inheritdoc
+     */
+    destroy(): void;
+    /**
+     * Ensure that the Bitcoin wallet module is initialized
+     * @private
+     */
+    private assertBitcoinConnector;
+    /**
+     * Assicura che il signer sia inizializzato
+     * @private
+     */
+    private assertSigner;
+    /**
+     * @inheritdoc
+     */
+    isAvailable(): boolean;
+    /**
+     * Check if Nostr extension is available
+     */
+    isNostrExtensionAvailable(): boolean;
+    /**
+     * Connect to Nostr wallet automatically
+     * This is a convenience method for easy wallet connection
+     */
+    connectNostrWallet(): Promise<ConnectionResult>;
+    /**
+     * @inheritdoc
+     */
+    connectBitcoinWallet(type?: "alby" | "nostr" | "manual"): Promise<ConnectionResult>;
+    /**
+     * @inheritdoc
+     */
+    generateCredentials(address: string, signature: string, message: string): Promise<NostrConnectorCredentials>;
+    /**
+     * @inheritdoc
+     */
+    cleanup(): void;
+    /**
+     * @inheritdoc
+     */
+    verifySignature(message: string, signature: string, address: string): Promise<boolean>;
+    /**
+     * @inheritdoc
+     */
+    generatePassword(signature: string): Promise<string>;
+    /**
+     * Creates a new Nostr signing credential
+     * CONSISTENT with normal Nostr approach
+     */
+    createSigningCredential(address: string): Promise<NostrSigningCredential>;
+    /**
+     * Creates an authenticator function for Nostr signing
+     */
+    createAuthenticator(address: string): (data: any) => Promise<string>;
+    /**
+     * Creates a derived key pair from Nostr credential
+     */
+    createDerivedKeyPair(address: string, extra?: string[]): Promise<{
+        pub: string;
+        priv: string;
+        epub: string;
+        epriv: string;
+    }>;
+    /**
+     * Signs data with derived keys after Nostr verification
+     */
+    signWithDerivedKeys(data: any, address: string, extra?: string[]): Promise<string>;
+    /**
+     * Get signing credential by address
+     */
+    getSigningCredential(address: string): NostrSigningCredential | undefined;
+    /**
+     * List all signing credentials
+     */
+    listSigningCredentials(): NostrSigningCredential[];
+    /**
+     * Remove a signing credential
+     */
+    removeSigningCredential(address: string): boolean;
+    /**
+     * Creates a Gun user from Nostr signing credential
+     * This ensures the SAME user is created as with normal approach
+     */
+    createGunUserFromSigningCredential(address: string): Promise<{
+        success: boolean;
+        userPub?: string;
+        error?: string;
+    }>;
+    /**
+     * Get the Gun user public key for a signing credential
+     */
+    getGunUserPubFromSigningCredential(address: string): string | undefined;
+    /**
+     * Get the password (for consistency checking)
+     */
+    getPassword(address: string): string | undefined;
+    /**
+     * Verify consistency between oneshot and normal approaches
+     * This ensures both approaches create the same Gun user
+     */
+    verifyConsistency(address: string, expectedUserPub?: string): Promise<{
+        consistent: boolean;
+        actualUserPub?: string;
+        expectedUserPub?: string;
+    }>;
+    /**
+     * Complete oneshot workflow that creates the SAME Gun user as normal approach
+     * This is the recommended method for oneshot signing with full consistency
+     */
+    setupConsistentOneshotSigning(address: string): Promise<{
+        credential: NostrSigningCredential;
+        authenticator: (data: any) => Promise<string>;
+        gunUser: {
+            success: boolean;
+            userPub?: string;
+            error?: string;
+        };
+        username: string;
+        password: string;
+    }>;
+    /**
+     * Login with Bitcoin wallet
+     * @param address - Bitcoin address
+     * @returns {Promise<AuthResult>} Authentication result
+     * @description Authenticates the user using Bitcoin wallet credentials after signature verification
+     */
+    login(address: string): Promise<AuthResult>;
+    /**
+     * Register new user with Nostr wallet
+     * @param address - Nostr address
+     * @returns {Promise<SignUpResult>} Registration result
+     */
+    signUp(address: string): Promise<SignUpResult>;
+    /**
+     * Convenience method that matches the interface pattern
+     */
+    loginWithBitcoinWallet(address: string): Promise<AuthResult>;
+    /**
+     * Convenience method that matches the interface pattern
+     */
+    signUpWithBitcoinWallet(address: string): Promise<AuthResult>;
+}

package/dist/types/plugins/nostr/nostrSigner.d.ts

@@ -0,0 +1,105 @@
+import { NostrConnector } from "./nostrConnector";
+/**
+ * Nostr Signing Credential for oneshot signing
+ */
+export interface NostrSigningCredential {
+    address: string;
+    signature: string;
+    message: string;
+    username: string;
+    password: string;
+    gunUserPub?: string;
+}
+/**
+ * Nostr Signer - Provides oneshot signing functionality
+ * Similar to webauthn.js but for Nostr/Bitcoin wallets
+ * CONSISTENT with normal Nostr approach
+ */
+export declare class NostrSigner {
+    private nostrConnector;
+    private credentials;
+    private readonly MESSAGE_TO_SIGN;
+    constructor(nostrConnector?: NostrConnector);
+    /**
+     * Creates a new Nostr signing credential
+     * CONSISTENT with normal Nostr approach
+     */
+    createSigningCredential(address: string): Promise<NostrSigningCredential>;
+    /**
+     * Validates address using the same logic as NostrConnector
+     */
+    private validateAddress;
+    /**
+     * Generate deterministic signature using the SAME approach as NostrConnector
+     */
+    private generateDeterministicSignature;
+    /**
+     * Generate password using the SAME approach as NostrConnector
+     */
+    private generatePassword;
+    /**
+     * Creates an authenticator function compatible with SEA.sign
+     * This is the key function that makes it work like webauthn.js but for Nostr
+     */
+    createAuthenticator(address: string): (data: any) => Promise<string>;
+    /**
+     * Sign data using the credential
+     */
+    private signData;
+    /**
+     * Creates a derived key pair from Nostr credential
+     * CONSISTENT with normal approach: uses password as seed
+     */
+    createDerivedKeyPair(address: string, extra?: string[]): Promise<{
+        pub: string;
+        priv: string;
+        epub: string;
+        epriv: string;
+    }>;
+    /**
+     * Creates a Gun user from Nostr credential
+     * This ensures the SAME user is created as with normal approach
+     * FIX: Use derived pair instead of username/password for GunDB auth
+     */
+    createGunUser(address: string, gunInstance: any): Promise<{
+        success: boolean;
+        userPub?: string;
+        error?: string;
+    }>;
+    /**
+     * Signs data using Nostr + derived keys
+     * This provides a hybrid approach: Nostr for user verification + derived keys for actual signing
+     * CONSISTENT with normal approach
+     */
+    signWithDerivedKeys(data: any, address: string, extra?: string[]): Promise<string>;
+    /**
+     * Get the Gun user public key for a credential
+     * This allows checking if the same user would be created
+     */
+    getGunUserPub(address: string): string | undefined;
+    /**
+     * Get the password (for consistency checking)
+     */
+    getPassword(address: string): string | undefined;
+    /**
+     * Check if this credential would create the same Gun user as normal approach
+     */
+    verifyConsistency(address: string, expectedUserPub?: string): Promise<{
+        consistent: boolean;
+        actualUserPub?: string;
+        expectedUserPub?: string;
+    }>;
+    /**
+     * Get credential by address
+     */
+    getCredential(address: string): NostrSigningCredential | undefined;
+    /**
+     * List all stored credentials
+     */
+    listCredentials(): NostrSigningCredential[];
+    /**
+     * Remove a credential
+     */
+    removeCredential(address: string): boolean;
+}
+export default NostrSigner;