shogun-core 3.2.2 → 3.3.0

package/dist/src/storage/storage.js

@@ -10,28 +10,37 @@ class ShogunStorage {
     /**
      * Initializes storage and loads any existing keypair from localStorage if available
      */
-    constructor() {
+    constructor(silent = false) {
         this.store = new Map();
+        this.silent = silent;
         this.isTestMode = process.env.NODE_ENV === "test";
         this.useLocalStorage = false;
-        // Debug: log the environment
-        console.log("ShogunStorage: NODE_ENV =", process.env.NODE_ENV);
-        console.log("ShogunStorage: isTestMode =", this.isTestMode);
+        // Debug: log the environment (only if not silent)
+        if (!this.silent) {
+            console.log("ShogunStorage: NODE_ENV =", process.env.NODE_ENV);
+            console.log("ShogunStorage: isTestMode =", this.isTestMode);
+        }
         // In test mode, don't use localStorage to avoid test pollution
         if (this.isTestMode) {
             this.useLocalStorage = false;
-            console.log("ShogunStorage: Test mode detected, localStorage disabled");
+            if (!this.silent) {
+                console.log("ShogunStorage: Test mode detected, localStorage disabled");
+            }
             return;
         }
         if (typeof localStorage !== "undefined") {
-            console.log("ShogunStorage: localStorage is defined");
+            if (!this.silent) {
+                console.log("ShogunStorage: localStorage is defined");
+            }
             try {
                 // Probe localStorage without polluting expectations in tests
                 const testKey = "_shogun_test";
                 localStorage.setItem(testKey, testKey);
                 localStorage.removeItem(testKey);
                 this.useLocalStorage = true;
-                console.log("ShogunStorage: localStorage enabled");
+                if (!this.silent) {
+                    console.log("ShogunStorage: localStorage enabled");
+                }
                 const storedPair = localStorage.getItem("shogun_keypair");
                 if (storedPair) {
                     this.store.set("keypair", JSON.parse(storedPair));
@@ -40,11 +49,15 @@ class ShogunStorage {
             catch (error) {
                 this.useLocalStorage = false;
                 // Silence logs in tests; tests expect no console.error during constructor
-                console.log("ShogunStorage: localStorage error:", error.message);
+                if (!this.silent) {
+                    console.log("ShogunStorage: localStorage error:", error.message);
+                }
             }
         }
         else {
-            console.log("ShogunStorage: localStorage is undefined");
+            if (!this.silent) {
+                console.log("ShogunStorage: localStorage is undefined");
+            }
         }
     }
     /**

package/dist/types/ship/examples/messenger-cli.d.ts

@@ -6,23 +6,29 @@
  * Simple and functional CLI interface
  */
 export declare class MessengerCLI {
-    private app;
+    private identity;
+    private messaging;
     private rl;
     private currentUser;
     private recipient;
     private derivedAddress;
     private isAuthenticated;
+    private channelToken;
+    private currentChannel;
     constructor();
     private setupHandlers;
     private withTimeout;
     login(username: string, password: string): Promise<boolean>;
     private sendMessage;
     private onMessageReceived;
+    private onChannelMessageReceived;
     private exportKeyPair;
     private importKeyPair;
     private loginWithPair;
     private wipeAllMessages;
     private handleCommand;
+    private joinChannel;
+    private leaveChannel;
     private showHelp;
     private showStatus;
     private showHeader;

package/dist/types/ship/examples/wallet-cli.d.ts

@@ -0,0 +1,131 @@
+/**
+ * SHIP-02 Example: Ethereum Wallet CLI
+ *
+ * Interactive CLI demonstrating SHIP-02 HD wallet derivation
+ * Built on top of SHIP-00 identity
+ *
+ * Usage:
+ *   yarn wallet <username> <password>
+ *
+ * Features:
+ * - Derive Ethereum addresses from identity (no mnemonics!)
+ * - BIP-44 HD wallet support
+ * - Sign transactions and messages
+ * - Export/import address book
+ * - Gun persistence
+ *
+ * Note: For stealth addresses, use `yarn stealth` (SHIP-03)
+ */
+declare class WalletCLI {
+    private identity;
+    private wallet;
+    private rl;
+    private username;
+    private running;
+    constructor(username: string, password: string);
+    /**
+     * Start the CLI
+     */
+    start(password: string): Promise<void>;
+    /**
+     * Authenticate user with SHIP-00
+     */
+    private authenticate;
+    /**
+     * Initialize SHIP-02 wallet
+     */
+    private initializeWallet;
+    /**
+     * Main menu loop
+     */
+    private mainMenu;
+    /**
+     * View all addresses
+     */
+    private viewAddresses;
+    /**
+     * Derive new address with custom index
+     */
+    private deriveNewAddress;
+    /**
+     * Derive BIP-44 address with custom parameters
+     */
+    private deriveBIP44Address;
+    /**
+     * Derive multiple addresses at once
+     */
+    private deriveMultipleAddresses;
+    /**
+     * Import address book
+     */
+    private importAddressBook;
+    /**
+     * Export encrypted wallet data
+     */
+    private exportWalletData;
+    /**
+     * Sync with Gun database
+     */
+    private syncWithGun;
+    /**
+     * View/Export mnemonic
+     */
+    private viewExportMnemonic;
+    /**
+     * Verify addresses match MetaMask
+     */
+    private verifyMetaMaskAddresses;
+    /**
+     * Sign message
+     */
+    private signMessage;
+    /**
+     * Sign transaction
+     */
+    private signTransaction;
+    /**
+     * Export address book
+     */
+    private exportAddressBook;
+    /**
+     * View master public key
+     */
+    private viewMasterPublicKey;
+    /**
+     * Create wallet using frontend API
+     */
+    private createWalletFrontendAPI;
+    /**
+     * Load all wallets using frontend API
+     */
+    private loadAllWallets;
+    /**
+     * View main wallet (derived from Gun keys)
+     */
+    private viewMainWallet;
+    /**
+     * Export all user data (complete backup)
+     */
+    private exportAllUserData;
+    /**
+     * Set RPC provider URL
+     */
+    private setRpcProvider;
+    /**
+     * Send transaction via RPC
+     */
+    private sendTransactionRPC;
+    /**
+     * Print header
+     */
+    private printHeader;
+    /**
+     * Prompt user for input
+     */
+    private prompt;
+    /**
+     * Cleanup and exit
+     */
+    private cleanup;
+}
+export { WalletCLI };

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

@@ -0,0 +1,113 @@
+/**
+ * SHIP-00: Decentralized Identity & Authentication Implementation
+ *
+ * Foundation layer for the Shogun ecosystem.
+ * Provides identity and authentication services for all other SHIPs.
+ *
+ * Based on:
+ * - Shogun Core API (see ../API.md)
+ * - GunDB for P2P identity storage
+ * - SEA for cryptographic operations
+ * - shogun-derive for address derivation
+ *
+ * Features:
+ * ✅ Username/password authentication
+ * ✅ SEA key pair management
+ * ✅ Public key publication and discovery
+ * ✅ User registry and lookup
+ * ✅ Blockchain address derivation
+ * ✅ Multi-device support (export/import)
+ */
+import type { ISHIP_00, SignupResult, AuthResult, OperationResult, SEAPair, UserIdentity, UserData, PublicKeyData } from "../interfaces/ISHIP_00";
+import { ShogunCoreConfig } from "../../src/interfaces/shogun";
+/**
+ * SHIP-00 Reference Implementation
+ *
+ * Uses Shogun Core as the underlying implementation.
+ * This class wraps Shogun Core APIs to provide the ISHIP_00 standard interface.
+ */
+declare class SHIP_00 implements ISHIP_00 {
+    private shogun;
+    static readonly NODES: {
+        readonly USERS: "users";
+        readonly PUBLIC_KEYS: "publicKeys";
+        readonly REGISTRY: "registry";
+    };
+    constructor(shogunConfig: ShogunCoreConfig);
+    /**
+     * Register new user
+     * Uses Shogun Core signUp method (see API.md)
+     */
+    signup(username: string, password: string): Promise<SignupResult>;
+    /**
+     * Login with username and password
+     * Uses Shogun Core login method (see API.md)
+     */
+    login(username: string, password: string): Promise<AuthResult>;
+    /**
+     * Login with SEA Key Pair
+     * Uses Shogun Core loginWithPair method (see API.md)
+     */
+    loginWithPair(seaPair: SEAPair): Promise<AuthResult>;
+    /**
+     * Logout
+     * Uses Shogun Core logout method (see API.md line 325)
+     */
+    logout(): void;
+    /**
+     * Check if user is logged in
+     * Uses Shogun Core isLoggedIn method (see API.md line 326)
+     */
+    isLoggedIn(): boolean;
+    /**
+     * Get underlying ShogunCore instance
+     * Provides access to Gun, SEA, and crypto utilities
+     */
+    getShogun(): any;
+    /**
+     * Publish public key on GunDB
+     * Makes user's public key discoverable by others
+     */
+    publishPublicKey(): Promise<OperationResult>;
+    /**
+     * Export current user's SEA key pair
+     * For backup and multi-device usage
+     * Uses Shogun Core exportPair method (see API.md line 354)
+     */
+    exportKeyPair(): SEAPair | null;
+    /**
+     * Get current user's key pair
+     * Alias for exportKeyPair()
+     */
+    getKeyPair(): SEAPair | null;
+    /**
+     * Get user information by username
+     * Uses Shogun Core getUserByAlias method (see API.md line 1141-1148)
+     */
+    getUserByAlias(username: string): Promise<UserData | null>;
+    /**
+     * Get user information by public key
+     * Uses Shogun Core getUserDataByPub method (see API.md line 1150-1152)
+     */
+    getUserByPub(userPub: string): Promise<UserData | null>;
+    /**
+     * Check if user exists
+     * Uses SimpleGunAPI userExists method (see API.md line 188)
+     */
+    userExists(username: string): Promise<boolean>;
+    /**
+     * Get public key by username
+     */
+    getPublicKey(username: string): Promise<PublicKeyData | null>;
+    /**
+     * Get current authenticated user info
+     * Uses Shogun Core getCurrentUser method (see API.md line 429)
+     */
+    getCurrentUser(): UserIdentity | null;
+    /**
+     * Derive Ethereum address from SEA keypair
+     * Uses shogun-derive package for deterministic derivation
+     */
+    deriveEthereumAddress(publicKey?: string): Promise<string>;
+}
+export { SHIP_00 };

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

@@ -1,109 +1,80 @@
 /**
- * Esempio Pratico: Messaggistica Decentralizzata con Shogun Core
+ * SHIP-01: Decentralized Encrypted Messaging Implementation
  *
- * Questo esempio mostra come creare un sistema di messaggistica sicuro usando:
- * - Shogun Core per autenticazione (username/password)
- * - GunDB per storage decentralizzato P2P
- * - SEA (Security, Encryption, Authorization) per crittografia
+ * Messaggistica decentralizzata E2E che dipende da SHIP-00 per l'identità.
  *
- * Vantaggi:
- * ✅ Completamente decentralizzato (no server centrale)
- * ✅ Zero costi (no blockchain, no gas fees)
- * ✅ Real-time messaging
- * ✅ Offline-first
- * ✅ End-to-end encryption
+ * Dipendenze:
+ * - SHIP-00 (Identity & Authentication) - per gestione utenti e chiavi
+ * - GunDB - per storage decentralizzato P2P
+ * - SEA - per crittografia ECDH + AES-GCM
  *
- * Note sull'ERC7627:
- * L'EIP era un template concettuale. Questo esempio implementa
- * solo la parte GunDB/Shogun Core senza interazione blockchain.
- * La funzione deriveEthereumAddress() rimane come utility per derivare
- * un address Ethereum dalla chiave GunDB se necessario in futuro.
+ * Vantaggi dell'architettura modulare:
+ * ✅ Separazione delle responsabilità (Identity vs Messaging)
+ * ✅ Riusabilità di SHIP-00 in altre applicazioni
+ * ✅ Testing più semplice e isolato
+ * ✅ Manutenibilità migliorata
  */
-import type { ISHIP_01, SignupResult, AuthResult, SendMessageResult, DecryptedMessage, OperationResult } from "../interfaces/ISHIP_01";
-import { ShogunCoreConfig } from "../../src/interfaces/shogun";
-import { ISEAPair } from "../../src/types/shogun";
+import type { ISHIP_00 } from "../interfaces/ISHIP_00";
+import type { ISHIP_01, SendMessageResult, DecryptedMessage, MessageHistoryEntry } from "../interfaces/ISHIP_01";
 /**
- * Classe per messaggistica sicura con Shogun Core
- * Implementa l'interfaccia ISHIP_01
- * Usa solo GunDB per storage decentralizzato (no blockchain)
+ * SHIP-01 Reference Implementation
+ *
+ * Questa implementazione dipende da ISHIP_00 per tutte le operazioni di identità.
+ * Si concentra esclusivamente sulla logica di messaggistica.
  */
 declare class SHIP_01 implements ISHIP_01 {
-    private shogun;
-    private static readonly NODES;
-    constructor(shogunConfig: ShogunCoreConfig);
-    /**
-     * Registra un nuovo utente
-     */
-    signup(username: string, password: string): Promise<SignupResult>;
-    /**
-     * Login con username e password
-     */
-    login(username: string, password: string): Promise<AuthResult>;
-    /**
-     * Login con SEA Key Pair
-     *
-     * Autenticazione diretta usando un key pair esportato.
-     * Utile per:
-     * - Recupero account senza password
-     * - Portabilità tra dispositivi
-     * - Backup dell'identità
-     */
-    loginWithPair(seaPair: ISEAPair): Promise<AuthResult>;
+    private identity;
+    static readonly NODES: {
+        readonly MESSAGES: "messages";
+        readonly TOKEN_MESSAGES: "token_messages";
+    };
     /**
-     * Logout
+     * Constructor
+     * @param identity ISHIP_00 instance for identity operations
      */
-    logout(): void;
+    constructor(identity: ISHIP_00);
     /**
-     * Verifica se l'utente è autenticato
+     * Get identity provider
      */
-    isLoggedIn(): boolean;
+    getIdentity(): ISHIP_00;
     /**
-     * Salva la chiave pubblica dell'utente su GunDB
-     * Questo permette ad altri di trovare la tua chiave per criptare messaggi
-     */
-    publishPublicKey(): Promise<OperationResult>;
-    /**
-     * Invia un messaggio crittografato a un altro utente
+     * Send encrypted message to a user
+     * Uses identity provider (SHIP-00) to get keys
      */
     sendMessage(recipientUsername: string, message: string): Promise<SendMessageResult>;
     /**
-     * Ottiene la chiave pubblica di un utente da GunDB
+     * Listen for incoming encrypted messages
+     * Uses identity provider (SHIP-00) to decrypt messages
      */
-    private getRecipientPublicKey;
+    listenForMessages(onMessage: (message: DecryptedMessage) => void): Promise<void>;
     /**
-     * Ascolta messaggi crittografati in arrivo su GunDB
+     * Get message history with a user
+     * Uses identity provider (SHIP-00) to decrypt messages
      */
-    listenForMessages(onMessage: (message: DecryptedMessage) => void): Promise<void>;
+    getMessageHistory(withUsername: string): Promise<MessageHistoryEntry[]>;
     /**
-     * Decripta un messaggio usando SEA.secret + SEA.decrypt (ECDH)
+     * Decrypt a message using ECDH
+     * Uses identity provider (SHIP-00) to get keys
      */
     private decryptMessage;
     /**
-     * Ottiene la chiave pubblica di un utente dalla sua pub key
+     * Get public key by pub key
+     * Uses identity provider internally
      */
     private getPublicKeyByPub;
     /**
-     * Recupera lo storico dei messaggi crittografati con un utente
+     * Generate unique message ID
      */
-    getMessageHistory(withUsername: string): Promise<Array<{
-        from: string;
-        to: string;
-        content: string;
-        timestamp: number;
-    }>>;
+    private generateMessageId;
     /**
-     * Converte la chiave pubblica di GunDB in address Ethereum
-     * Usa la chiave privata SEA come seed per derivazione deterministica
-     *
-     * Questo garantisce che:
-     * - Stesso SEA pair → stesso address Ethereum
-     * - Derivazione cryptografica sicura
-     * - Identità unificata tra GunDB e blockchain
+     * Send message encrypted with shared token/password
+     * Useful for group chats, channels, broadcast messages
      */
-    deriveEthereumAddress(publicKey?: string): Promise<string>;
+    sendMessageWithToken(token: string, message: string, channel?: string): Promise<SendMessageResult>;
     /**
-     * Genera ID messaggio univoco
+     * Listen for token-encrypted messages
+     * Automatically decrypts with provided token
      */
-    private generateMessageId;
+    listenForTokenMessages(token: string, onMessage: (message: any) => void, channel?: string): Promise<void>;
 }
 export { SHIP_01 };