shogun-core 3.0.3 → 3.0.4

package/dist/types/plugins/oauth/oauthPlugin.d.ts

@@ -1,91 +0,0 @@
-import { BasePlugin } from "../base";
-import { ShogunCore } from "../../core";
-import { OAuthPluginInterface, OAuthConfig, OAuthProvider, OAuthConnectionResult, OAuthCredentials, OAuthUserInfo } from "./types";
-import { AuthResult, SignUpResult } from "../../interfaces/shogun";
-/**
- * OAuth Plugin for ShogunCore
- * Provides authentication with external OAuth providers
- */
-export declare class OAuthPlugin extends BasePlugin implements OAuthPluginInterface {
-    name: string;
-    version: string;
-    description: string;
-    private oauthConnector;
-    private config;
-    private storage;
-    /**
-     * Constructor for OAuthPlugin
-     * @param config - Initial configuration for OAuth
-     */
-    constructor(config?: Partial<OAuthConfig>);
-    /**
-     * @inheritdoc
-     */
-    initialize(core: ShogunCore): void;
-    /**
-     * Valida la configurazione di sicurezza OAuth
-     */
-    private validateOAuthSecurity;
-    /**
-     * Configure the OAuth plugin with provider settings
-     * @param config - Configuration options for OAuth
-     */
-    configure(config: Partial<OAuthConfig>): void;
-    /**
-     * @inheritdoc
-     */
-    destroy(): void;
-    /**
-     * Ensure that the OAuth connector is initialized
-     * @private
-     */
-    private assertOAuthConnector;
-    /**
-     * @inheritdoc
-     */
-    isSupported(): boolean;
-    /**
-     * @inheritdoc
-     */
-    getAvailableProviders(): OAuthProvider[];
-    /**
-     * @inheritdoc
-     */
-    initiateOAuth(provider: OAuthProvider): Promise<OAuthConnectionResult>;
-    /**
-     * @inheritdoc
-     */
-    completeOAuth(provider: OAuthProvider, authCode: string, state?: string): Promise<OAuthConnectionResult>;
-    /**
-     * @inheritdoc
-     */
-    generateCredentials(userInfo: OAuthUserInfo, provider: OAuthProvider): Promise<OAuthCredentials>;
-    /**
-     * Login with OAuth
-     * @param provider - OAuth provider to use
-     * @returns {Promise<AuthResult>} Authentication result
-     * @description Authenticates user using OAuth with external providers
-     * NOTE: This method only initiates the OAuth flow. The actual authentication
-     * happens in handleOAuthCallback when the provider redirects back.
-     */
-    login(provider: OAuthProvider): Promise<AuthResult>;
-    /**
-     * Register new user with OAuth provider
-     * @param provider - OAuth provider
-     * @returns {Promise<SignUpResult>} Registration result
-     */
-    signUp(provider: OAuthProvider): Promise<SignUpResult>;
-    /**
-     * Handle OAuth callback (for frontend integration)
-     * This method would be called when the OAuth provider redirects back
-     */
-    handleOAuthCallback(provider: OAuthProvider, authCode: string, state: string): Promise<AuthResult>;
-    /**
-     * Pulisce i dati OAuth scaduti
-     */
-    private cleanupExpiredOAuthData;
-    /**
-     * Private helper to login or sign up a user
-     */
-    private _loginOrSignUp;
-}

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

@@ -1,114 +0,0 @@
-import { BaseConfig, BaseResult, BaseCacheEntry } from "../../interfaces/common";
-import { AuthResult, SignUpResult } from "../../interfaces/shogun";
-/**
- * Supported OAuth providers
- */
-export type OAuthProvider = "google" | "github" | "discord" | "twitter" | "custom";
-/**
- * OAuth provider configuration
- */
-export interface OAuthProviderConfig {
-    clientId: string;
-    clientSecret?: string;
-    redirectUri: string;
-    scope: string[];
-    authUrl: string;
-    tokenUrl: string;
-    userInfoUrl: string;
-    usePKCE?: boolean;
-}
-/**
- * OAuth configuration
- */
-export interface OAuthConfig extends BaseConfig {
-    providers: Partial<Record<OAuthProvider, OAuthProviderConfig>>;
-    usePKCE?: boolean;
-    cacheDuration?: number;
-    timeout?: number;
-    maxRetries?: number;
-    retryDelay?: number;
-    allowUnsafeClientSecret?: boolean;
-    stateTimeout?: number;
-}
-/**
- * OAuth token response
- */
-export interface OAuthTokenResponse {
-    access_token: string;
-    token_type: string;
-    expires_in: number;
-    refresh_token?: string;
-    scope?: string;
-    id_token?: string;
-}
-/**
- * User info from OAuth provider
- */
-export interface OAuthUserInfo {
-    id: string;
-    email?: string;
-    name?: string;
-    picture?: string;
-    verified_email?: boolean;
-    provider: OAuthProvider;
-}
-/**
- * Credentials generated from OAuth flow
- */
-export interface OAuthCredentials {
-    username: string;
-    password: string;
-    salt?: string;
-    key?: any;
-    provider: OAuthProvider;
-}
-/**
- * Connection result for OAuth
- */
-export interface OAuthConnectionResult extends BaseResult {
-    provider?: OAuthProvider;
-    userInfo?: OAuthUserInfo;
-    authUrl?: string;
-}
-/**
- * OAuth plugin interface
- */
-export interface OAuthPluginInterface {
-    /**
-     * Check if OAuth is supported
-     */
-    isSupported(): boolean;
-    /**
-     * Get available OAuth providers
-     */
-    getAvailableProviders(): OAuthProvider[];
-    /**
-     * Initiate OAuth flow with a provider
-     */
-    initiateOAuth(provider: OAuthProvider): Promise<OAuthConnectionResult>;
-    /**
-     * Complete OAuth flow
-     */
-    completeOAuth(provider: OAuthProvider, authCode: string, state?: string): Promise<OAuthConnectionResult>;
-    /**
-     * Generate credentials from OAuth user info
-     */
-    generateCredentials(userInfo: OAuthUserInfo, provider: OAuthProvider, masterkey?: string): Promise<OAuthCredentials>;
-    /**
-     * Login with OAuth
-     */
-    login(provider: OAuthProvider): Promise<AuthResult>;
-    /**
-     * Sign up with OAuth provider
-     * @param provider OAuth provider to use
-     * @returns Promise with authentication result
-     */
-    signUp(provider: OAuthProvider): Promise<SignUpResult>;
-}
-/**
- * Cache entry for OAuth data
- */
-export interface OAuthCache extends BaseCacheEntry<OAuthUserInfo> {
-    provider: OAuthProvider;
-    userId: string;
-}

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

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

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

@@ -1,107 +0,0 @@
-import { ISEAPair } from "gun";
-import { BaseConfig, BaseResult, BaseCacheEntry } from "../../interfaces/common";
-import { AuthResult, SignUpResult } from "../../interfaces/shogun";
-/**
- * Result of connection attempt
- */
-export interface ConnectionResult extends BaseResult {
-    address?: string;
-    username?: string;
-    randomPassword?: string;
-}
-/**
- * Structure for credentials generated via MetaMask
- */
-export interface Web3ConnectorCredentials {
-    /** 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 MetaMask */
-    signature: string;
-}
-/**
- * Ethereum provider interface
- */
-export interface EthereumProvider {
-    request: (args: any) => Promise<any>;
-    isMetaMask?: boolean;
-    on?: (event: string, handler: (params: any) => void) => void;
-    removeListener?: (event: string, handler: (params: any) => void) => void;
-}
-/**
- * Cache entry for signatures
- */
-export interface SignatureCache extends BaseCacheEntry<string> {
-    signature: string;
-    address: string;
-}
-/**
- * MetaMask configuration options
- */
-export interface Web3Config extends BaseConfig {
-    cacheDuration?: number;
-}
-/**
- * Interfaccia per il plugin MetaMask
- */
-export interface Web3ConnectorPluginInterface {
-    /**
-     * Verifica se MetaMask è disponibile nel browser
-     * @returns true se MetaMask è disponibile, false altrimenti
-     */
-    isAvailable(): boolean;
-    /**
-     * Connette a MetaMask
-     * @returns Promise con il risultato della connessione
-     */
-    connectMetaMask(): Promise<ConnectionResult>;
-    /**
-     * Genera credenziali utilizzando MetaMask
-     * @param address Indirizzo Ethereum
-     * @returns Promise con le credenziali generate
-     */
-    generateCredentials(address: string): Promise<ISEAPair>;
-    /**
-     * Rilascia le risorse e pulisce gli event listener
-     */
-    cleanup(): void;
-    /**
-     * Imposta un provider personalizzato
-     * @param rpcUrl URL del provider RPC
-     * @param privateKey Chiave privata
-     */
-    setCustomProvider(rpcUrl: string, privateKey: string): void;
-    /**
-     * Ottiene il signer Ethereum
-     * @returns Promise con il signer
-     */
-    getSigner(): Promise<any>;
-    /**
-     * Genera una password basata su una firma
-     * @param signature Firma
-     * @returns Promise con la password generata
-     */
-    generatePassword(signature: string): Promise<string>;
-    /**
-     * Verifica una firma
-     * @param message Messaggio firmato
-     * @param signature Firma da verificare
-     * @returns Promise con l'indirizzo che ha generato la firma
-     */
-    verifySignature(message: string, signature: string): Promise<string>;
-    /**
-     * Login con MetaMask
-     * @param address Indirizzo Ethereum
-     * @returns Promise con il risultato dell'operazione
-     */
-    login(address: string): Promise<AuthResult>;
-    /**
-     * Sign up with Web3 wallet
-     * @param address Ethereum address
-     * @returns Promise with authentication result
-     */
-    signUp(address: string): Promise<SignUpResult>;
-}

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

@@ -1,129 +0,0 @@
-/**
- * The MetaMaskAuth class provides functionality for connecting, signing up, and logging in using MetaMask.
- */
-import { ethers } from "ethers";
-import { EventEmitter } from "../../utils/eventEmitter";
-import { ConnectionResult, EthereumProvider, Web3Config } from "./types";
-import { ISEAPair } from "gun";
-declare global {
-    interface Window {
-        ethereum?: EthereumProvider;
-        Web3Connector?: typeof Web3Connector;
-        _ethereumProviders?: EthereumProvider[];
-    }
-}
-declare global {
-    namespace NodeJS {
-        interface Global {
-            web3Connector?: typeof Web3Connector;
-        }
-    }
-}
-/**
- * Class for MetaMask connection
- */
-declare class Web3Connector extends EventEmitter {
-    private readonly MESSAGE_TO_SIGN;
-    private readonly DEFAULT_CONFIG;
-    private readonly config;
-    private readonly signatureCache;
-    private provider;
-    private customProvider;
-    private customWallet;
-    constructor(config?: Partial<Web3Config>);
-    /**
-     * Initialize the provider synchronously with fallback mechanisms
-     * to handle conflicts between multiple wallet providers
-     */
-    private initProvider;
-    /**
-     * Get available Ethereum provider from multiple possible sources
-     */
-    private getAvailableEthereumProvider;
-    /**
-     * Initialize the BrowserProvider (async method for explicit calls)
-     */
-    setupProvider(): Promise<void>;
-    /**
-     * Setup MetaMask event listeners using BrowserProvider
-     */
-    private setupEventListeners;
-    /**
-     * Cleanup event listeners
-     */
-    cleanup(): void;
-    /**
-     * Get cached signature if valid
-     */
-    private getCachedSignature;
-    /**
-     * Cache signature
-     */
-    private cacheSignature;
-    /**
-     * Validates that the address is valid
-     */
-    private validateAddress;
-    /**
-     * Connects to MetaMask with retry logic using BrowserProvider
-     */
-    connectMetaMask(): Promise<ConnectionResult>;
-    /**
-     * Generates credentials for the given address
-     */
-    generateCredentials(address: string): Promise<ISEAPair>;
-    /**
-     * Generates credentials from a signature
-     */
-    private generateCredentialsFromSignature;
-    /**
-     * Generates fallback credentials (for testing/development)
-     */
-    private generateFallbackCredentials;
-    /**
-     * Checks if MetaMask is available
-     */
-    static isMetaMaskAvailable(): boolean;
-    /**
-     * Requests signature with timeout
-     */
-    private requestSignatureWithTimeout;
-    /**
-     * Checks if the connector is available
-     */
-    isAvailable(): boolean;
-    /**
-     * Sets a custom provider for testing/development
-     */
-    setCustomProvider(rpcUrl: string, privateKey: string): void;
-    /**
-     * Get active signer instance using BrowserProvider
-     */
-    getSigner(): Promise<ethers.Signer>;
-    /**
-     * Get active provider instance using BrowserProvider
-     */
-    getProvider(): Promise<ethers.JsonRpcProvider | ethers.BrowserProvider>;
-    /**
-     * Generate deterministic password from signature
-     * @param signature - Cryptographic signature
-     * @returns 64-character hex string
-     * @throws {Error} For invalid signature
-     */
-    generatePassword(signature: string): Promise<string>;
-    /**
-     * Verify message signature
-     * @param message - Original signed message
-     * @param signature - Cryptographic signature
-     * @returns Recovered Ethereum address
-     * @throws {Error} For invalid inputs
-     */
-    verifySignature(message: string, signature: string): Promise<string>;
-    /**
-     * Get browser-based Ethereum signer
-     * @returns Browser provider signer
-     * @throws {Error} If MetaMask not detected
-     */
-    getEthereumSigner(): Promise<ethers.Signer>;
-}
-export { Web3Connector };

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

@@ -1,160 +0,0 @@
-import { BasePlugin } from "../base";
-import { ShogunCore } from "../../core";
-import { Web3SigningCredential } from "./web3Signer";
-import { ConnectionResult, Web3ConnectorPluginInterface } from "./types";
-import { ethers } from "ethers";
-import { AuthResult, SignUpResult } from "../../interfaces/shogun";
-import { ISEAPair } from "gun";
-/**
- * Plugin per la gestione delle funzionalità Web3 in ShogunCore
- */
-export declare class Web3ConnectorPlugin extends BasePlugin implements Web3ConnectorPluginInterface {
-    name: string;
-    version: string;
-    description: string;
-    private Web3;
-    private signer;
-    /**
-     * @inheritdoc
-     */
-    initialize(core: ShogunCore): void;
-    /**
-     * @inheritdoc
-     */
-    destroy(): void;
-    /**
-     * Assicura che il modulo Web3 sia inizializzato
-     * @private
-     */
-    private assertMetaMask;
-    /**
-     * Assicura che il signer sia inizializzato
-     * @private
-     */
-    private assertSigner;
-    /**
-     * @inheritdoc
-     */
-    isAvailable(): boolean;
-    /**
-     * @inheritdoc
-     */
-    connectMetaMask(): Promise<ConnectionResult>;
-    /**
-     * @inheritdoc
-     */
-    generateCredentials(address: string): Promise<ISEAPair>;
-    /**
-     * @inheritdoc
-     */
-    cleanup(): void;
-    /**
-     * @inheritdoc
-     */
-    setCustomProvider(rpcUrl: string, privateKey: string): void;
-    /**
-     * @inheritdoc
-     */
-    getSigner(): Promise<ethers.Signer>;
-    /**
-     * @inheritdoc
-     */
-    getProvider(): Promise<ethers.JsonRpcProvider | ethers.BrowserProvider>;
-    /**
-     * @inheritdoc
-     */
-    generatePassword(signature: string): Promise<string>;
-    /**
-     * @inheritdoc
-     */
-    verifySignature(message: string, signature: string): Promise<string>;
-    /**
-     * Creates a new Web3 signing credential
-     * CONSISTENT with normal Web3 approach
-     */
-    createSigningCredential(address: string): Promise<Web3SigningCredential>;
-    /**
-     * Creates an authenticator function for Web3 signing
-     */
-    createAuthenticator(address: string): (data: any) => Promise<string>;
-    /**
-     * Creates a derived key pair from Web3 credential
-     */
-    createDerivedKeyPair(address: string, extra?: string[]): Promise<{
-        pub: string;
-        priv: string;
-        epub: string;
-        epriv: string;
-    }>;
-    /**
-     * Signs data with derived keys after Web3 verification
-     */
-    signWithDerivedKeys(data: any, address: string, extra?: string[]): Promise<string>;
-    /**
-     * Get signing credential by address
-     */
-    getSigningCredential(address: string): Web3SigningCredential | undefined;
-    /**
-     * List all signing credentials
-     */
-    listSigningCredentials(): Web3SigningCredential[];
-    /**
-     * Remove a signing credential
-     */
-    removeSigningCredential(address: string): boolean;
-    /**
-     * Creates a Gun user from Web3 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): Promise<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: Web3SigningCredential;
-        authenticator: (data: any) => Promise<string>;
-        gunUser: {
-            success: boolean;
-            userPub?: string;
-            error?: string;
-        };
-        username: string;
-        password: string;
-    }>;
-    /**
-     * Login con Web3
-     * @param address - Indirizzo Ethereum
-     * @returns {Promise<AuthResult>} Risultato dell'autenticazione
-     * @description Autentica l'utente usando le credenziali del wallet Web3 dopo la verifica della firma
-     */
-    login(address: string): Promise<AuthResult>;
-    /**
-     * Register new user with Web3 wallet
-     * @param address - Ethereum address
-     * @returns {Promise<SignUpResult>} Registration result
-     */
-    signUp(address: string): Promise<SignUpResult>;
-}
-export type { Web3ConnectorPluginInterface } from "./types";