shogun-core 3.3.0 → 3.3.2

package/dist/types/ship/implementation/SHIP_04.d.ts

@@ -0,0 +1,76 @@
+/**
+ * SHIP-04: Multi-Modal Authentication Implementation
+ *
+ * Extends SHIP-00 to provide alternative authentication methods.
+ * Integrates existing Shogun Core plugins for OAuth, WebAuthn, Nostr, and Web3.
+ *
+ * Based on:
+ * - SHIP-00 for identity foundation
+ * - Shogun Core Plugins (OAuth, WebAuthn, Nostr, Web3)
+ * - External OAuth providers (Google, GitHub, etc.)
+ * - WebAuthn API for biometric auth
+ * - Nostr protocol for decentralized social
+ * - Web3 providers (MetaMask, WalletConnect)
+ *
+ * Features:
+ * ✅ OAuth authentication (Google, GitHub, Discord, etc.)
+ * ✅ WebAuthn/Passkeys (biometric, hardware keys)
+ * ✅ Nostr protocol integration
+ * ✅ Web3 wallet connection (MetaMask, etc.)
+ * ✅ SHIP-00 compatible (all methods return SEA keypair)
+ * ✅ Plugin-based architecture (modular)
+ *
+ * Inclusive Hierarchy:
+ * SHIP-04 → depends on → SHIP-00 ✅
+ */
+import type { ISHIP_00 } from "../interfaces/ISHIP_00";
+import type { ISHIP_04, OAuthProvider, OAuthAuthResult, WebAuthnAuthResult, NostrAuthResult, Web3AuthResult, AuthMethodInfo, SHIP_04_Config } from "../interfaces/ISHIP_04";
+import { AuthMethod } from "../interfaces/ISHIP_04";
+/**
+ * SHIP-04 Reference Implementation
+ *
+ * Provides multiple authentication methods on top of SHIP-00.
+ * All authentication methods are converted to SHIP-00 compatible format.
+ */
+declare class SHIP_04 implements ISHIP_04 {
+    private identity;
+    private config;
+    private initialized;
+    static readonly NODES: {
+        readonly AUTH_METHOD: "current_auth_method";
+    };
+    private oauthPlugin;
+    private webauthnPlugin;
+    private nostrPlugin;
+    private web3Plugin;
+    private currentAuthMethod;
+    constructor(identity: ISHIP_00, config?: SHIP_04_Config);
+    initialize(): Promise<void>;
+    isInitialized(): boolean;
+    getIdentity(): ISHIP_00;
+    loginWithOAuth(provider: OAuthProvider, redirectUri?: string): Promise<OAuthAuthResult>;
+    handleOAuthCallback(code: string, provider: OAuthProvider): Promise<OAuthAuthResult>;
+    isOAuthAvailable(provider?: OAuthProvider): boolean;
+    registerWithWebAuthn(username: string): Promise<WebAuthnAuthResult>;
+    loginWithWebAuthn(username: string): Promise<WebAuthnAuthResult>;
+    isWebAuthnAvailable(): boolean;
+    connectNostr(): Promise<NostrAuthResult>;
+    loginWithNostr(): Promise<NostrAuthResult>;
+    isNostrAvailable(): boolean;
+    connectWeb3(): Promise<Web3AuthResult>;
+    loginWithWeb3(message?: string): Promise<Web3AuthResult>;
+    isWeb3Available(): boolean;
+    getAvailableAuthMethods(): AuthMethodInfo[];
+    getCurrentAuthMethod(): AuthMethod | null;
+    clearAuth(): Promise<void>;
+    /**
+     * Save current auth method to Gun (optional persistence)
+     */
+    private saveAuthMethod;
+    /**
+     * Load last used auth method from Gun
+     */
+    loadAuthMethod(): Promise<AuthMethod | null>;
+    private ensureInitialized;
+}
+export { SHIP_04 };

package/dist/types/ship/implementation/SHIP_05.d.ts

@@ -0,0 +1,70 @@
+/**
+ * SHIP-05: Decentralized File Storage Implementation
+ *
+ * Simple encrypted file storage on IPFS.
+ * Extends SHIP-00 to provide encrypted file storage capabilities.
+ *
+ * Based on:
+ * - SHIP-00 for identity foundation
+ * - IPFS for decentralized file storage
+ * - shogun-ipfs for IPFS operations
+ * - Deterministic encryption from wallet signatures
+ *
+ * Features:
+ * ✅ Encrypted file upload with wallet signature
+ * ✅ Deterministic encryption keys from wallet
+ * ✅ IPFS storage (Pinata, IPFS node, or custom)
+ * ✅ File metadata on GunDB
+ * ✅ File download and decryption
+ */
+import type { ISHIP_00 } from "../interfaces/ISHIP_00";
+import type { ISHIP_05, UploadResult, FileMetadata, UploadOptions, DownloadOptions, EncryptionOptions, SHIP_05_Config } from "../interfaces/ISHIP_05";
+/**
+ * SHIP-05 Reference Implementation
+ *
+ * Provides encrypted file storage on IPFS.
+ * All encryption is deterministic based on wallet signatures.
+ */
+declare class SHIP_05 implements ISHIP_05 {
+    private identity;
+    private config;
+    private initialized;
+    static readonly NODES: {
+        readonly USER_FILES: "user_files";
+    };
+    private ipfsStorage;
+    private fileCache;
+    constructor(identity: ISHIP_00, config?: SHIP_05_Config);
+    initialize(options?: SHIP_05_Config): Promise<void>;
+    isInitialized(): boolean;
+    getIdentity(): ISHIP_00;
+    uploadFile(file: File | Buffer, options?: UploadOptions): Promise<UploadResult>;
+    uploadJson(data: any, options?: UploadOptions): Promise<UploadResult>;
+    downloadFile(hash: string, options?: DownloadOptions): Promise<string | Blob>;
+    getFileMetadata(hash: string): Promise<FileMetadata | null>;
+    deleteFile(hash: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getUserFiles(): Promise<FileMetadata[]>;
+    encryptData(data: string | Buffer, options?: EncryptionOptions): Promise<string>;
+    decryptData(encryptedData: string, options?: EncryptionOptions): Promise<string>;
+    isFileAccessible(hash: string): Promise<boolean>;
+    getStorageStats(): Promise<{
+        totalFiles: number;
+        totalMB: number;
+        encryptedFiles: number;
+        plainFiles: number;
+    }>;
+    private ensureInitialized;
+    private initializeIPFS;
+    private uploadToIPFS;
+    private uploadToIPFSFallback;
+    private unpinFromIPFS;
+    private downloadFromIPFS;
+    private saveFileMetadata;
+    private removeFileMetadata;
+    private getUserFilesFromGun;
+    private fileToBase64;
+}
+export { SHIP_05 };

package/dist/types/ship/implementation/SHIP_06.d.ts

@@ -0,0 +1,66 @@
+/**
+ * SHIP-06: Ephemeral P2P Messaging Implementation
+ *
+ * Two modes:
+ * 1. Standalone: new SHIP_06(gunPeers[], roomId) - NO authentication!
+ *    - Uses ShogunCore internally with silent: true, disableAutoRecall: true
+ *    - Zero logs, zero storage, pure relay communication
+ *    - Room hashed with Web Crypto API SHA-256 for deterministic IDs
+ *
+ * 2. With Identity: new SHIP_06(ISHIP_00, roomId) - Authenticated sessions
+ *    - Uses existing Gun instance from SHIP-00
+ *    - All ShogunCore features available
+ *
+ * Architecture:
+ * - Gun Relay for P2P communication (no WebRTC complexity!)
+ * - SEA for ephemeral key generation and ECDH encryption
+ * - Pure relay mode: radisk: false, localStorage: false, multicast: false
+ */
+import type { ISHIP_00 } from "../interfaces/ISHIP_00";
+import type { ISHIP_06, EphemeralMessage, EphemeralConfig, PeerInfo } from "../interfaces/ISHIP_06";
+import type { SEAPair } from "../interfaces/ISHIP_00";
+declare class SHIP_06 implements ISHIP_06 {
+    private identity;
+    private roomId;
+    private config;
+    private connected;
+    private swarmId;
+    private myAddress;
+    private myPair;
+    private gun;
+    private sea;
+    private roomNode;
+    private presenceNode;
+    private messagesNode;
+    private peers;
+    private messageHandlers;
+    private encryptedMessageHandlers;
+    private peerSeenHandlers;
+    private peerLeftHandlers;
+    private heartbeatInterval;
+    private processedMessages;
+    constructor(identityOrPeers: ISHIP_00 | string[], roomId: string, config?: Partial<EphemeralConfig> | {
+        debug?: boolean;
+    });
+    getIdentity(): ISHIP_00;
+    connect(): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    getSwarmId(): string;
+    getAddress(): string;
+    private announcePresence;
+    private startHeartbeat;
+    private listenForPeers;
+    sendBroadcast(message: string): Promise<void>;
+    sendDirect(peerAddress: string, message: string): Promise<void>;
+    private listenForMessages;
+    onMessage(callback: (message: EphemeralMessage) => void): void;
+    onPeerSeen(callback: (address: string) => void): void;
+    onPeerLeft(callback: (address: string) => void): void;
+    onEncryptedMessage(callback: (address: string, data: any) => void): void;
+    getPeers(): string[];
+    getPeerInfo(address: string): PeerInfo | null;
+    getEphemeralPair(): Promise<SEAPair>;
+    setEphemeralPair(pair: SEAPair): Promise<void>;
+}
+export { SHIP_06 };

package/dist/types/ship/implementation/SHIP_07.d.ts

@@ -0,0 +1,101 @@
+/**
+ * SHIP-07: Secure Vault Implementation
+ *
+ * Vault crittografato decentralizzato che dipende da SHIP-00 per l'identità.
+ *
+ * Dipendenze:
+ * - SHIP-00 (Identity & Authentication) - per gestione utenti e chiavi
+ * - GunDB - per storage decentralizzato P2P
+ * - SEA - per crittografia AES-256-GCM
+ *
+ * Ispirato a: https://github.com/draeder/gunsafe
+ */
+import type { ISHIP_00 } from "../interfaces/ISHIP_00";
+import type { ISHIP_07, VaultRecord, VaultResult, VaultStats, RecordMetadata, GetOptions, ListOptions, ImportOptions, ExportOptions } from "../interfaces/ISHIP_07";
+/**
+ * SHIP-07 Reference Implementation
+ *
+ * Questa implementazione dipende da ISHIP_00 per tutte le operazioni di identità.
+ * Si concentra esclusivamente sulla logica del vault crittografato.
+ */
+declare class SHIP_07 implements ISHIP_07 {
+    private identity;
+    private initialized;
+    private vaultNodeName;
+    private vaultNode;
+    private recordsNode;
+    private metadataNode;
+    private static readonly VAULT_VERSION;
+    private static readonly DEFAULT_NODE_NAME;
+    /**
+     * Constructor
+     * @param identity ISHIP_00 instance for identity operations
+     * @param vaultNodeName Optional custom vault node name
+     */
+    constructor(identity: ISHIP_00, vaultNodeName?: string);
+    /**
+     * Get identity provider
+     */
+    getIdentity(): ISHIP_00;
+    /**
+     * Initialize vault
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if vault is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Store encrypted record in vault
+     */
+    put(name: string, data: any, metadata?: RecordMetadata): Promise<VaultResult>;
+    /**
+     * Retrieve and decrypt record from vault
+     */
+    get(name: string, options?: GetOptions): Promise<VaultRecord | null>;
+    /**
+     * Delete record from vault (soft delete)
+     */
+    delete(name?: string): Promise<VaultResult>;
+    /**
+     * List all record names in vault
+     */
+    list(options?: ListOptions): Promise<string[]>;
+    /**
+     * Check if record exists
+     */
+    exists(name: string): Promise<boolean>;
+    /**
+     * Update existing record
+     */
+    update(name: string, data: any): Promise<VaultResult>;
+    /**
+     * Export entire vault (encrypted)
+     */
+    export(password?: string, options?: ExportOptions): Promise<string>;
+    /**
+     * Import vault from backup
+     */
+    import(backupData: string, password?: string, options?: ImportOptions): Promise<VaultResult>;
+    /**
+     * Get vault statistics
+     */
+    getStats(): Promise<VaultStats>;
+    /**
+     * Clear all records (soft delete all)
+     */
+    clear(): Promise<VaultResult>;
+    /**
+     * Compact vault (remove deleted records permanently)
+     */
+    compact(): Promise<VaultResult>;
+    /**
+     * Search records by content
+     */
+    search(query: string): Promise<string[]>;
+    /**
+     * Update record count in metadata
+     */
+    private updateRecordCount;
+}
+export { SHIP_07 };

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

@@ -0,0 +1,14 @@
+export { SHIP_00 } from "../ship/implementation/SHIP_00";
+export type { ISHIP_00 } from "../ship/interfaces/ISHIP_00";
+export { SHIP_01 } from "../ship/implementation/SHIP_01";
+export type { ISHIP_01 } from "../ship/interfaces/ISHIP_01";
+export { SHIP_02 } from "../ship/implementation/SHIP_02";
+export type { ISHIP_02 } from "../ship/interfaces/ISHIP_02";
+export { SHIP_03 } from "../ship/implementation/SHIP_03";
+export type { ISHIP_03 } from "../ship/interfaces/ISHIP_03";
+export { SHIP_04 } from "../ship/implementation/SHIP_04";
+export type { ISHIP_04 } from "../ship/interfaces/ISHIP_04";
+export { SHIP_05 } from "../ship/implementation/SHIP_05";
+export type { ISHIP_05 } from "../ship/interfaces/ISHIP_05";
+export { SHIP_06 } from "../ship/implementation/SHIP_06";
+export type { ISHIP_06 } from "../ship/interfaces/ISHIP_06";

package/dist/types/ship/interfaces/ISHIP_04.d.ts

@@ -0,0 +1,245 @@
+/**
+ * SHIP-04: Multi-Modal Authentication Interface
+ *
+ * @title ISHIP_04 - Alternative Authentication Methods
+ * @notice Interface for multi-modal authentication extending SHIP-00
+ *
+ * ## Abstract
+ *
+ * This standard extends SHIP-00 to provide multiple authentication methods:
+ * - OAuth (Google, GitHub, Discord, etc.)
+ * - WebAuthn/Passkeys (biometric authentication)
+ * - Nostr (decentralized social protocol)
+ * - Web3 (MetaMask, WalletConnect, etc.)
+ *
+ * ## Dependencies
+ *
+ * - SHIP-00: Base identity foundation
+ * - Shogun Core Plugins: OAuth, WebAuthn, Nostr, Web3
+ *
+ * ## Inclusive Hierarchy
+ *
+ * SHIP-04 extends SHIP-00 (✅ allowed):
+ * ```
+ * SHIP-04 (Multi-Modal Auth)
+ *    ↓ depends on
+ * SHIP-00 (Identity Foundation)
+ * ```
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * const identity = new SHIP_00(config);
+ * const multiAuth = new SHIP_04(identity);
+ *
+ * // Login with OAuth
+ * await multiAuth.loginWithOAuth('google');
+ *
+ * // Or WebAuthn
+ * await multiAuth.loginWithWebAuthn('alice');
+ *
+ * // Result is SHIP-00 compatible!
+ * const user = identity.getCurrentUser();
+ * ```
+ */
+import type { ISHIP_00, AuthResult } from "./ISHIP_00";
+/**
+ * Available authentication methods
+ * Exported as const enum to allow usage as both type and value
+ */
+export declare const enum AuthMethod {
+    PASSWORD = "password",// Traditional (SHIP-00)
+    OAUTH = "oauth",// OAuth providers
+    WEBAUTHN = "webauthn",// Biometric/Passkey
+    NOSTR = "nostr",// Nostr protocol
+    WEB3 = "web3"
+}
+export type AuthMethodType = "password" | "oauth" | "webauthn" | "nostr" | "web3";
+/**
+ * OAuth provider types
+ * Note: Must match Shogun Core plugin types
+ */
+export type OAuthProvider = "google" | "github" | "discord" | "twitter" | "custom";
+/**
+ * OAuth authentication result
+ */
+export interface OAuthAuthResult extends AuthResult {
+    provider?: OAuthProvider;
+    email?: string;
+    profilePicture?: string;
+}
+/**
+ * WebAuthn authentication result
+ */
+export interface WebAuthnAuthResult extends AuthResult {
+    credentialId?: string;
+    authenticatorType?: string;
+}
+/**
+ * Nostr authentication result
+ */
+export interface NostrAuthResult extends AuthResult {
+    nostrPubkey?: string;
+    relays?: string[];
+}
+/**
+ * Web3 authentication result
+ */
+export interface Web3AuthResult extends AuthResult {
+    walletAddress?: string;
+    chainId?: number;
+    walletType?: string;
+}
+/**
+ * Authentication method info
+ */
+export interface AuthMethodInfo {
+    method: AuthMethod;
+    available: boolean;
+    configured: boolean;
+    lastUsed?: number;
+}
+/**
+ * SHIP-04 Configuration
+ */
+export interface SHIP_04_Config {
+    /** Enable OAuth authentication */
+    enableOAuth?: boolean;
+    /** OAuth providers configuration */
+    oauthProviders?: {
+        [key in OAuthProvider]?: {
+            clientId: string;
+            clientSecret?: string;
+            redirectUri: string;
+            scopes?: string[];
+        };
+    };
+    /** Enable WebAuthn authentication */
+    enableWebAuthn?: boolean;
+    /** WebAuthn RP name */
+    webAuthnRpName?: string;
+    /** WebAuthn RP ID */
+    webAuthnRpId?: string;
+    /** Enable Nostr authentication */
+    enableNostr?: boolean;
+    /** Nostr relays */
+    nostrRelays?: string[];
+    /** Enable Web3 authentication */
+    enableWeb3?: boolean;
+    /** Preferred Web3 provider */
+    web3Provider?: "metamask" | "walletconnect" | "coinbase";
+}
+/**
+ * @title ISHIP_04 - Multi-Modal Authentication
+ * @notice Main interface for alternative authentication methods
+ * @dev Extends SHIP-00 with OAuth, WebAuthn, Nostr, and Web3 auth
+ */
+export interface ISHIP_04 {
+    /**
+     * @notice Initialize multi-modal auth system
+     * @dev Initializes all enabled authentication plugins
+     * @returns Promise that resolves when initialization is complete
+     */
+    initialize(): Promise<void>;
+    /**
+     * @notice Check if system is initialized
+     * @returns True if initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * @notice Get the underlying SHIP-00 identity provider
+     * @returns SHIP-00 instance
+     */
+    getIdentity(): ISHIP_00;
+    /**
+     * @notice Login with OAuth provider
+     * @param provider OAuth provider (google, github, etc.)
+     * @param redirectUri Optional redirect URI override
+     * @returns Promise resolving to OAuth auth result
+     */
+    loginWithOAuth(provider: OAuthProvider, redirectUri?: string): Promise<OAuthAuthResult>;
+    /**
+     * @notice Handle OAuth callback after redirect
+     * @param code Authorization code from OAuth provider
+     * @param provider OAuth provider
+     * @returns Promise resolving to auth result
+     */
+    handleOAuthCallback(code: string, provider: OAuthProvider): Promise<OAuthAuthResult>;
+    /**
+     * @notice Check if OAuth is available and configured
+     * @param provider Optional specific provider to check
+     * @returns True if OAuth is available
+     */
+    isOAuthAvailable(provider?: OAuthProvider): boolean;
+    /**
+     * @notice Register new user with WebAuthn
+     * @param username Username for the account
+     * @returns Promise resolving to WebAuthn auth result
+     */
+    registerWithWebAuthn(username: string): Promise<WebAuthnAuthResult>;
+    /**
+     * @notice Login with WebAuthn (biometric/passkey)
+     * @param username Username to authenticate
+     * @returns Promise resolving to WebAuthn auth result
+     */
+    loginWithWebAuthn(username: string): Promise<WebAuthnAuthResult>;
+    /**
+     * @notice Check if WebAuthn is supported
+     * @returns True if WebAuthn is available
+     */
+    isWebAuthnAvailable(): boolean;
+    /**
+     * @notice Connect and authenticate with Nostr
+     * @returns Promise resolving to Nostr auth result
+     */
+    connectNostr(): Promise<NostrAuthResult>;
+    /**
+     * @notice Login with Nostr extension (nos2x, Alby, etc.)
+     * @returns Promise resolving to Nostr auth result
+     */
+    loginWithNostr(): Promise<NostrAuthResult>;
+    /**
+     * @notice Check if Nostr is available
+     * @returns True if Nostr extension detected
+     */
+    isNostrAvailable(): boolean;
+    /**
+     * @notice Connect Web3 wallet (MetaMask, WalletConnect, etc.)
+     * @returns Promise resolving to Web3 auth result
+     */
+    connectWeb3(): Promise<Web3AuthResult>;
+    /**
+     * @notice Login with Web3 wallet
+     * @param message Optional message to sign
+     * @returns Promise resolving to Web3 auth result
+     */
+    loginWithWeb3(message?: string): Promise<Web3AuthResult>;
+    /**
+     * @notice Check if Web3 is available
+     * @returns True if Web3 provider detected
+     */
+    isWeb3Available(): boolean;
+    /**
+     * @notice Get all available authentication methods
+     * @returns Array of available auth methods with info
+     */
+    getAvailableAuthMethods(): AuthMethodInfo[];
+    /**
+     * @notice Get current authentication method
+     * @returns Current auth method or null
+     */
+    getCurrentAuthMethod(): AuthMethod | null;
+    /**
+     * @notice Clear authentication data
+     * @returns Promise that resolves when cleared
+     */
+    clearAuth(): Promise<void>;
+}
+export type SHIP_04_Events = {
+    oauthConnected: (result: OAuthAuthResult) => void;
+    webauthnRegistered: (result: WebAuthnAuthResult) => void;
+    nostrConnected: (result: NostrAuthResult) => void;
+    web3Connected: (result: Web3AuthResult) => void;
+    authMethodChanged: (method: AuthMethod) => void;
+    error: (error: Error) => void;
+};