shogun-core 1.1.4 → 1.2.2

package/dist/types/index.d.ts

@@ -1,283 +1,2 @@
-import { GunDB } from "./gun/gun";
-import { ShogunStorage } from "./storage/storage";
-import { IShogunCore, ShogunSDKConfig, AuthResult, SignUpResult, LoggingConfig, PluginCategory } from "./types/shogun";
-import { IGunUserInstance } from "gun";
-import { ethers } from "ethers";
-import { ShogunError } from "./utils/errorHandler";
-import { GunRxJS } from "./gun/rxjs-integration";
-import { Observable } from "rxjs";
-import { ShogunPlugin } from "./types/plugin";
-import { GunInstance } from "./gun/types";
-export { RelayVerifier } from "./contracts/utils";
-export * from "./utils/errorHandler";
-export type * from "./utils/errorHandler";
-export * from "./gun/rxjs-integration";
+export * from "./core";
 export * from "./plugins";
-export type * from "./types/plugin";
-export * from "./contracts/entryPoint";
-export * from "./contracts/utils";
-export * from "./contracts/registry";
-export * from "./contracts/relay";
-export type * from "./contracts/entryPoint";
-export type * from "./contracts/relay";
-export type * from "./contracts/registry";
-export type * from "./contracts/base";
-export type * from "./contracts/utils";
-/**
- * Main ShogunCore class - implements the IShogunCore interface
- *
- * This is the primary entry point for the Shogun SDK, providing access to:
- * - Decentralized database (GunDB)
- * - Authentication methods (traditional, WebAuthn, MetaMask)
- * - Plugin system for extensibility
- * - DID (Decentralized Identity) management
- * - RxJS integration for reactive programming
- *
- * @since 2.0.0
- */
-export declare class ShogunCore implements IShogunCore {
-    /** Current API version - used for deprecation warnings and migration guidance */
-    static readonly API_VERSION = "2.0.0";
-    /** Gun database instance */
-    gun: GunInstance<any>;
-    /** Gun user instance */
-    user: IGunUserInstance<any> | null;
-    /** GunDB wrapper */
-    gundb: GunDB;
-    /** Storage implementation */
-    storage: ShogunStorage;
-    /** Event emitter for SDK events */
-    private readonly eventEmitter;
-    /** Ethereum provider */
-    provider?: ethers.Provider;
-    /** SDK configuration */
-    config: ShogunSDKConfig;
-    /** RxJS integration */
-    rx: GunRxJS;
-    /** Plugin registry */
-    private readonly plugins;
-    /**
-     * Initialize the Shogun SDK
-     * @param config - SDK Configuration object
-     * @description Creates a new instance of ShogunCore with the provided configuration.
-     * Initializes all required components including storage, event emitter, GunDB connection,
-     * and plugin system.
-     */
-    constructor(config: ShogunSDKConfig);
-    /**
-     * Register built-in plugins based on configuration
-     * @private
-     */
-    private registerBuiltinPlugins;
-    /**
-     * Register a new plugin with the SDK
-     * @param plugin The plugin to register
-     * @throws Error if a plugin with the same name is already registered
-     */
-    register(plugin: ShogunPlugin): void;
-    /**
-     * Unregister a plugin from the SDK
-     * @param pluginName Name of the plugin to unregister
-     */
-    unregister(pluginName: string): void;
-    /**
-     * 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>(name: string): T | undefined;
-    /**
-     * 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[];
-    /**
-     * Get an authentication method plugin by type
-     * @param type The type of authentication method
-     * @returns The authentication plugin or undefined if not available
-     * This is a more modern approach to accessing authentication methods
-     */
-    getAuthenticationMethod(type: "password" | "webauthn" | "metamask"): unknown;
-    /**
-     * Observe a Gun node for changes
-     * @param path - Path to observe (can be a string or a Gun chain)
-     * @returns Observable that emits whenever the node changes
-     */
-    rxGet<T>(path: string): Observable<T>;
-    /**
-     * Match data based on Gun's '.map()' and convert to Observable
-     * @param path - Path to the collection
-     * @param matchFn - Optional function to filter results
-     * @returns Observable array of matched items
-     */
-    match<T>(path: string | any, matchFn?: (data: any) => boolean): Observable<T[]>;
-    /**
-     * Put data and return an Observable
-     * @param path - Path where to put the data
-     * @param oata - Data to put
-     * @returns Observable that completes when the put is acknowledged
-     */
-    rxPut<T>(path: string | any, data: T): Observable<T>;
-    /**
-     * Set data on a node and return an Observable
-     * @param path - Path to the collection
-     * @param data - Data to set
-     * @returns Observable that completes when the set is acknowledged
-     */
-    rxSet<T>(path: string | any, data: T): Observable<T>;
-    /**
-     * Get data once and return as Observable
-     * @param path - Path to get data from
-     * @returns Observable that emits the data once
-     */
-    rxOnce<T>(path: string | any): Observable<T>;
-    /**
-     * Compute derived values from gun data
-     * @param sources - Array of paths or observables to compute from
-     * @param computeFn - Function that computes a new value from the sources
-     * @returns Observable of computed values
-     */
-    compute<T, R>(sources: Array<string | Observable<any>>, computeFn: (...values: T[]) => R): Observable<R>;
-    /**
-     * User put data and return an Observable (for authenticated users)
-     * @param path - Path where to put the data
-     * @param data - Data to put
-     * @returns Observable that completes when the put is acknowledged
-     */
-    rxUserPut<T>(path: string, data: T): Observable<T>;
-    /**
-     * Observe user data
-     * @param path - Path to observe in user space
-     * @returns Observable that emits whenever the user data changes
-     */
-    observeUser<T>(path: string): Observable<T>;
-    /**
-     * Retrieve recent errors logged by the system
-     * @param count - Number of errors to retrieve (default: 10)
-     * @returns List of most recent errors
-     */
-    getRecentErrors(count?: number): ShogunError[];
-    /**
-     * Configure logging behavior for the Shogun SDK
-     * @param {LoggingConfig} config - Logging configuration object containing:
-     *   - level: The minimum log level to display (error, warn, info, debug, trace)
-     *   - logToConsole: Whether to output logs to the console (default: true)
-     *   - customLogger: Optional custom logger implementation
-     *   - logTimestamps: Whether to include timestamps in logs (default: true)
-     * @returns {void}
-     * @description Updates the logging configuration for the SDK. Changes take effect immediately
-     * for all subsequent log operations.
-     */
-    configureLogging(config: LoggingConfig): void;
-    /**
-     * Check if user is logged in
-     * @returns {boolean} True if user is logged in, false otherwise
-     * @description Verifies authentication status by checking GunDB login state
-     * and presence of authentication credentials in storage
-     */
-    isLoggedIn(): boolean;
-    /**
-     * Perform user logout
-     * @description Logs out the current user from GunDB and emits logout event.
-     * If user is not authenticated, the logout operation is ignored.
-     */
-    logout(): void;
-    /**
-     * Authenticate user with username and password
-     * @param username - Username
-     * @param password - User password
-     * @returns {Promise<AuthResult>} Promise with authentication result
-     * @description Attempts to log in user with provided credentials.
-     * Emits login event on success.
-     */
-    login(username: string, password: string): Promise<AuthResult>;
-    /**
-     * Register a new user with provided credentials
-     * @param username - Username
-     * @param password - Password
-     * @param passwordConfirmation - Password confirmation
-     * @returns {Promise<SignUpResult>} Registration result
-     * @description Creates a new user account with the provided credentials.
-     * Validates password requirements and emits signup event on success.
-     */
-    signUp(username: string, password: string, passwordConfirmation?: string): Promise<SignUpResult>;
-    /**
-     * Create a new user with GunDB
-     * @param username - Username
-     * @param password - Password
-     * @returns {Promise<{success: boolean, userPub?: string, error?: string}>} Promise with success status and user public key
-     * @description Creates a new user in GunDB with error handling
-     */
-    private createUserWithGunDB;
-    /**
-     * Retrieves data from a Gun node at the specified path
-     * @param path - The path to the Gun node
-     * @returns Promise that resolves with the node data or rejects with an error
-     */
-    get(path: string): Promise<any>;
-    /**
-     * Stores data in Gun at the root level
-     * @param data - The data to store
-     * @returns Promise that resolves when data is stored or rejects with an error
-     */
-    put(data: Record<string, any>): Promise<any>;
-    /**
-     * Stores data in the authenticated user's space
-     * @param data - The data to store in user space
-     * @returns Promise that resolves when data is stored or rejects with an error
-     */
-    userPut(data: Record<string, any>): Promise<any>;
-    /**
-     * Retrieves data from the authenticated user's space at the specified path
-     * @param path - The path to the user data
-     * @returns Promise that resolves with the user data or rejects with an error
-     */
-    userGet(path: string): Promise<any>;
-    /**
-     * Emits an event through the core's event emitter.
-     * Plugins should use this method to emit events instead of accessing the private eventEmitter directly.
-     * @param eventName The name of the event to emit.
-     * @param data The data to pass with the event.
-     */
-    emit(eventName: string | symbol, data?: any): boolean;
-    /**
-     * Add an event listener
-     * @param eventName The name of the event to listen for
-     * @param listener The callback function to execute when the event is emitted
-     */
-    on(eventName: string | symbol, listener: (data: unknown) => void): this;
-    /**
-     * Add a one-time event listener
-     * @param eventName The name of the event to listen for
-     * @param listener The callback function to execute when the event is emitted
-     */
-    once(eventName: string | symbol, listener: (data: unknown) => void): this;
-    /**
-     * Remove an event listener
-     * @param eventName The name of the event to stop listening for
-     * @param listener The callback function to remove
-     */
-    off(eventName: string | symbol, listener: (data: unknown) => void): this;
-    /**
-     * Remove all listeners for a specific event or all events
-     * @param eventName Optional. The name of the event to remove listeners for.
-     * If not provided, all listeners for all events are removed.
-     */
-    removeAllListeners(eventName?: string | symbol): this;
-}
-export * from "./types/shogun";
-export { GunDB } from "./gun/gun";
-export { MetaMask } from "./plugins/metamask/metamask";
-export { Stealth } from "./plugins/stealth/stealth";
-export type { EphemeralKeyPair, StealthData, StealthAddressResult, LogLevel, LogMessage, } from "./plugins/stealth/types";
-export { Webauthn } from "./plugins/webauthn/webauthn";
-export { ShogunStorage } from "./storage/storage";
-export { ShogunEventEmitter } from "./types/events";

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

@@ -1,14 +1,11 @@
 export { BasePlugin } from "./base";
 export type { ShogunPlugin, PluginManager } from "../types/plugin";
-export * from "./wallet";
-export * from "./stealth";
-export * from "./metamask";
-export * from "./webauthn";
+export { Webauthn } from "./webauthn/webauthn";
 export { WebauthnPlugin } from "./webauthn/webauthnPlugin";
 export type { WebauthnPluginInterface } from "./webauthn/types";
-export { MetaMaskPlugin } from "./metamask/metamaskPlugin";
-export type { MetaMaskPluginInterface } from "./metamask/types";
-export { WalletPlugin } from "./wallet/walletPlugin";
-export type { WalletPluginInterface } from "./wallet/types";
-export { StealthPlugin } from "./stealth/stealthPlugin";
-export type { StealthPluginInterface } from "./stealth/types";
+export { Web3Connector } from "./web3/web3Connector";
+export { Web3ConnectorPlugin } from "./web3/web3ConnectorPlugin";
+export type { Web3ConectorPluginInterface } from "./web3/types";
+export { NostrConnector } from "./nostr/nostrConnector";
+export { NostrConnectorPlugin } from "./nostr/nostrConnectorPlugin";
+export type { NostrConnectorPluginInterface, NostrConnectorCredentials, NostrConnectorKeyPair, NostrConnectorConfig, AlbyProvider, NostrProvider, } from "./nostr/types";

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

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

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

@@ -0,0 +1,111 @@
+import { EventEmitter } from "../../utils/eventEmitter";
+import { ConnectionResult, NostrConnectorCredentials, AlbyProvider, NostrProvider, NostrConnectorConfig, NostrConnectorKeyPair } from "./types";
+declare global {
+    interface Window {
+        alby?: AlbyProvider;
+        nostr?: NostrProvider;
+        NostrConnector?: typeof NostrConnector;
+    }
+}
+/**
+ * Class for Bitcoin wallet connections and operations
+ */
+export declare class NostrConnector extends EventEmitter {
+    private readonly MESSAGE_TO_SIGN;
+    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;
+    /**
+     * Cleanup event listeners
+     */
+    cleanup(): void;
+    /**
+     * Get cached signature if valid
+     */
+    private getCachedSignature;
+    /**
+     * Cache signature
+     */
+    private cacheSignature;
+    /**
+     * Clear signature cache for a specific address or all addresses
+     */
+    clearSignatureCache(address?: string): void;
+    /**
+     * Validates that the address is valid
+     */
+    private validateAddress;
+    /**
+     * Check if Alby extension is available
+     * @deprecated Alby support is deprecated, use Nostr instead
+     */
+    isAlbyAvailable(): boolean;
+    /**
+     * 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 the connected wallet
+     */
+    generateCredentials(address: string): Promise<NostrConnectorCredentials>;
+    /**
+     * Generate a deterministic signature for consistent authentication
+     */
+    private generateDeterministicSignature;
+    /**
+     * Generate credentials from an existing signature
+     */
+    private generateCredentialsFromSignature;
+    /**
+     * Generate a password from a signature
+     */
+    generatePassword(signature: string): Promise<string>;
+    /**
+     * Verify a signature
+     */
+    verifySignature(message: string, signature: string, address: string): Promise<boolean>;
+    /**
+     * Get the currently connected address
+     */
+    getConnectedAddress(): string | null;
+    /**
+     * Get the currently connected wallet type
+     */
+    getConnectedType(): "alby" | "nostr" | "manual" | null;
+    /**
+     * Request signature with timeout
+     */
+    private requestSignatureWithTimeout;
+    /**
+     * Request a signature from the connected wallet
+     */
+    private requestSignature;
+}

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

@@ -0,0 +1,87 @@
+import { BasePlugin } from "../base";
+import { ShogunCore } from "../../index";
+import { NostrConnectorCredentials, ConnectionResult, NostrConnectorPluginInterface } from "./types";
+import { AuthResult } from "../../types/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;
+    /**
+     * @inheritdoc
+     */
+    initialize(core: ShogunCore): void;
+    /**
+     * @inheritdoc
+     */
+    destroy(): void;
+    /**
+     * Ensure that the Bitcoin wallet module is initialized
+     * @private
+     */
+    private assertBitcoinConnector;
+    /**
+     * @inheritdoc
+     */
+    isAvailable(): boolean;
+    /**
+     * Check if Alby extension is available
+     * Note: Alby is deprecated in favor of Nostr
+     */
+    isAlbyAvailable(): boolean;
+    /**
+     * Check if Nostr extension is available
+     */
+    isNostrExtensionAvailable(): boolean;
+    /**
+     * @inheritdoc
+     */
+    connectBitcoinWallet(type?: "alby" | "nostr" | "manual"): Promise<ConnectionResult>;
+    /**
+     * @inheritdoc
+     */
+    generateCredentials(address: string): Promise<NostrConnectorCredentials>;
+    /**
+     * @inheritdoc
+     */
+    cleanup(): void;
+    /**
+     * Clear signature cache for better user recovery
+     * @param address - Optional specific address to clear, or clear all if not provided
+     */
+    clearSignatureCache(address?: string): void;
+    /**
+     * @inheritdoc
+     */
+    verifySignature(message: string, signature: string, address: string): Promise<boolean>;
+    /**
+     * @inheritdoc
+     */
+    generatePassword(signature: string): Promise<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 a new user with Bitcoin wallet
+     * @param address - Bitcoin address
+     * @returns {Promise<AuthResult>} Registration result
+     * @description Creates a new user account with Bitcoin wallet credentials
+     */
+    signUp(address: string): Promise<AuthResult>;
+    /**
+     * 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/types.d.ts

@@ -0,0 +1,122 @@
+import { BaseConfig, BaseResult, BaseCacheEntry } from "../../types/common";
+import { AuthResult } from "../../types/shogun";
+/**
+ * Result of connection attempt
+ */
+export interface ConnectionResult extends BaseResult {
+    address?: string;
+    username?: string;
+    randomPassword?: string;
+    extensionType?: "alby" | "nostr" | "manual";
+}
+/**
+ * Structure for credentials generated via Bitcoin wallet
+ */
+export interface NostrConnectorCredentials {
+    /** Generated username based on the address */
+    username: string;
+    /** Generated password based on the signature */
+    password: string;
+    /** Original message signed by the user */
+    message: string;
+    /** Signature provided by the wallet */
+    signature: string;
+}
+/**
+ * Alby extension interface
+ */
+export interface AlbyProvider {
+    isAlby?: boolean;
+    enable: () => Promise<any>;
+    signMessage?: (message: string, address?: string) => Promise<string>;
+    getPublicKey?: () => Promise<string>;
+    getInfo?: () => Promise<any>;
+}
+/**
+ * Nostr extension interface
+ */
+export interface NostrProvider {
+    getPublicKey: () => Promise<string>;
+    signEvent: (event: any) => Promise<any>;
+    nip04: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
+    };
+}
+/**
+ * Cache entry for signatures
+ */
+export interface SignatureCache extends BaseCacheEntry<string> {
+    signature: string;
+    address: string;
+}
+/**
+ * Bitcoin wallet configuration options
+ */
+export interface NostrConnectorConfig extends BaseConfig {
+    cacheDuration?: number;
+    network?: "mainnet" | "testnet";
+    useApi?: boolean;
+    apiUrl?: string;
+}
+/**
+ * Bitcoin Key pair interface
+ */
+export interface NostrConnectorKeyPair {
+    privateKey: string;
+    publicKey: string;
+    address: string;
+    type: "legacy" | "segwit" | "taproot" | "nostr";
+}
+/**
+ * Interface for the Bitcoin wallet plugin
+ */
+export interface NostrConnectorPluginInterface {
+    /**
+     * Check if any Bitcoin wallet is available in the browser
+     * @returns true if a wallet is available, false otherwise
+     */
+    isAvailable(): boolean;
+    /**
+     * Connect to a Bitcoin wallet
+     * @param type Type of wallet to connect to
+     * @returns Promise with the connection result
+     */
+    connectBitcoinWallet(type?: "alby" | "nostr" | "manual"): Promise<ConnectionResult>;
+    /**
+     * Generate credentials using a Bitcoin wallet
+     * @param address Bitcoin address
+     * @returns Promise with the generated credentials
+     */
+    generateCredentials(address: string): Promise<NostrConnectorCredentials>;
+    /**
+     * Release resources and clean up event listeners
+     */
+    cleanup(): void;
+    /**
+     * Generate a password based on a signature
+     * @param signature Signature
+     * @returns Promise with the generated password
+     */
+    generatePassword(signature: string): Promise<string>;
+    /**
+     * Verify a signature
+     * @param message Signed message
+     * @param signature Signature to verify
+     * @param address The Bitcoin address that supposedly created the signature
+     * @returns Promise that resolves to true if the signature is valid
+     */
+    verifySignature(message: string, signature: string, address: string): Promise<boolean>;
+    /**
+     * Login with Bitcoin wallet
+     * @param address Bitcoin address
+     * @returns Promise with the operation result
+     */
+    login(address: string): Promise<AuthResult>;
+    /**
+     * Signup with Bitcoin wallet
+     * @param address Bitcoin address
+     * @returns Promise with the operation result
+     */
+    signUp(address: string): Promise<AuthResult>;
+}

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

@@ -0,0 +1,3 @@
+export * from "./web3ConnectorPlugin";
+export * from "./types";
+export * from "./web3Connector";

package/dist/types/plugins/{metamask → web3}/types.d.ts

@@ -11,7 +11,7 @@ export interface ConnectionResult extends BaseResult {
 /**
  * Structure for credentials generated via MetaMask
  */
-export interface MetaMaskCredentials {
+export interface Web3ConnectorCredentials {
     /** Generated username based on the address */
     username: string;
     /** Generated password based on the signature */
@@ -40,13 +40,13 @@ export interface SignatureCache extends BaseCacheEntry<string> {
 /**
  * MetaMask configuration options
  */
-export interface MetaMaskConfig extends BaseConfig {
+export interface Web3Config extends BaseConfig {
     cacheDuration?: number;
 }
 /**
  * Interfaccia per il plugin MetaMask
  */
-export interface MetaMaskPluginInterface {
+export interface Web3ConectorPluginInterface {
     /**
      * Verifica se MetaMask è disponibile nel browser
      * @returns true se MetaMask è disponibile, false altrimenti
@@ -62,7 +62,7 @@ export interface MetaMaskPluginInterface {
      * @param address Indirizzo Ethereum
      * @returns Promise con le credenziali generate
      */
-    generateCredentials(address: string): Promise<MetaMaskCredentials>;
+    generateCredentials(address: string): Promise<Web3ConnectorCredentials>;
     /**
      * Rilascia le risorse e pulisce gli event listener
      */