shogun-core 3.3.0 → 3.3.1

package/dist/ship/interfaces/ISHIP_00.js

@@ -1,135 +0,0 @@
-"use strict";
-/**
- * SHIP-00: Decentralized Identity & Authentication Interface
- *
- * @title ISHIP_00 - Identity Foundation
- * @notice Base interface for decentralized identity in Shogun ecosystem
- *
- * ## Abstract
- *
- * This standard defines the foundational interface for identity that enables:
- * - Username/password authentication with deterministic key generation
- * - SEA key pair management (export, import, backup)
- * - Public key publication and discovery on GunDB
- * - User registry and lookup system
- * - Blockchain address derivation (Ethereum, Bitcoin, etc.)
- *
- * ## Specification
- *
- * Based on:
- * - GunDB for P2P identity storage
- * - SEA (Security, Encryption, Authorization) for key management
- * - Shogun Core DataBase API for authentication
- * - BIP32-like derivation for blockchain addresses
- *
- * ## Usage
- *
- * SHIP-00 serves as the foundation for all other SHIPs:
- * - SHIP-01 (Messaging) depends on SHIP-00 for identity
- * - SHIP-02 (Address Derivation) extends SHIP-00
- * - SHIP-03 (Multi-Modal Auth) extends SHIP-00
- * - SHIP-04 (File Storage) uses SHIP-00 for ACL
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-// ============================================================================
-// IMPLEMENTATION EXAMPLE
-// ============================================================================
-/**
- * Example of how to implement ISHIP_00
- *
- * ```typescript
- * import { ShogunCore } from 'shogun-core';
- * import { ISHIP_00, SEAPair, AuthResult, SignupResult } from './interfaces/ISHIP_00';
- *
- * class IdentityManager implements ISHIP_00 {
- *     private shogun: ShogunCore;
- *
- *     constructor(config: IdentityConfig) {
- *         this.shogun = new ShogunCore({
- *             gunOptions: {
- *                 peers: config.peers,
- *                 radisk: config.radisk,
- *                 localStorage: config.localStorage
- *             },
- *             scope: config.scope
- *         });
- *     }
- *
- *     async signup(username: string, password: string): Promise<SignupResult> {
- *         // Use Shogun Core signUp method
- *         const result = await this.shogun.signUp(username, password);
- *
- *         if (result.success) {
- *             // Publish public key
- *             await this.publishPublicKey();
- *
- *             // Derive Ethereum address
- *             const derivedAddress = await this.deriveEthereumAddress(result.userPub);
- *
- *             return {
- *                 success: true,
- *                 userPub: result.userPub,
- *                 username: username,
- *                 derivedAddress: derivedAddress
- *             };
- *         }
- *
- *         return {
- *             success: false,
- *             error: result.error || 'Signup failed'
- *         };
- *     }
- *
- *     async login(username: string, password: string): Promise<AuthResult> {
- *         // Use Shogun Core login method
- *         const result = await this.shogun.login(username, password);
- *
- *         if (result.success) {
- *             const derivedAddress = await this.deriveEthereumAddress(result.userPub);
- *
- *             return {
- *                 success: true,
- *                 userPub: result.userPub,
- *                 username: username,
- *                 derivedAddress: derivedAddress
- *             };
- *         }
- *
- *         return {
- *             success: false,
- *             error: result.error || 'Login failed'
- *         };
- *     }
- *
- *     exportKeyPair(): SEAPair | null {
- *         if (!this.isLoggedIn()) return null;
- *
- *         const seaPair = (this.shogun.db.gun.user() as any)?._?.sea;
- *         if (!seaPair) return null;
- *
- *         return {
- *             pub: seaPair.pub,
- *             priv: seaPair.priv,
- *             epub: seaPair.epub,
- *             epriv: seaPair.epriv
- *         };
- *     }
- *
- *     async getUserByAlias(username: string): Promise<UserData | null> {
- *         // Use Shogun Core getUserByAlias method
- *         return await this.shogun.db.getUserByAlias(username);
- *     }
- *
- *     async deriveEthereumAddress(publicKey?: string): Promise<string> {
- *         // Use shogun-derive package
- *         const derived = await derive(seaPair.priv, null, {
- *             includeSecp256k1Ethereum: true
- *         });
- *
- *         return derived.secp256k1Ethereum.address;
- *     }
- *
- *     // ... implement other methods
- * }
- * ```
- */

package/dist/ship/interfaces/ISHIP_01.js

@@ -1,128 +0,0 @@
-"use strict";
-/**
- * Shogun Messaging Protocol Interface
- *
- * @title ISHIP_01 - Decentralized Encrypted Messaging
- * @notice Interface for decentralized encrypted messaging on GunDB
- * @dev This interface depends on ISHIP_00 for identity and authentication
- *
- * ## Abstract
- *
- * This standard defines an interface for decentralized messaging that allows:
- * - End-to-end encrypted message sending (ECDH)
- * - Real-time message reception
- * - Decentralized message history
- *
- * ## Dependencies
- *
- * - ISHIP_00: Identity and authentication layer
- * - GunDB: P2P storage
- * - SEA: Cryptography (ECDH + AES-GCM)
- *
- * ## Specification
- *
- * Based on:
- * - SHIP-00 for identity management
- * - GunDB for P2P storage
- * - SEA (Security, Encryption, Authorization) for cryptography
- * - ECDH (Elliptic Curve Diffie-Hellman) for key agreement
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-// ============================================================================
-// IMPLEMENTATION EXAMPLE
-// ============================================================================
-/**
- * Example of how to implement ISHIP_01 with ISHIP_00 dependency
- *
- * ```typescript
- * import { ISHIP_00 } from './ISHIP_00';
- * import { ISHIP_01, DecryptedMessage, SendMessageResult } from './ISHIP_01';
- *
- * class SecureMessagingApp implements ISHIP_01 {
- *     constructor(private identity: ISHIP_00) {
- *         // Verify identity is authenticated
- *         if (!identity.isLoggedIn()) {
- *             throw new Error('User must be authenticated');
- *         }
- *     }
- *
- *     getIdentity(): ISHIP_00 {
- *         return this.identity;
- *     }
- *
- *     async sendMessage(recipientUsername: string, message: string): Promise<SendMessageResult> {
- *         // 1. Get recipient's public key from identity provider
- *         const recipientKey = await this.identity.getPublicKey(recipientUsername);
- *         if (!recipientKey) {
- *             return { success: false, error: 'Recipient not found' };
- *         }
- *
- *         // 2. Get sender's key pair from identity provider
- *         const senderPair = this.identity.getKeyPair();
- *         if (!senderPair) {
- *             return { success: false, error: 'Not authenticated' };
- *         }
- *
- *         // 3. Encrypt with ECDH
- *         const encrypted = await crypto.encFor(
- *             message,
- *             senderPair,
- *             { epub: recipientKey.epub }
- *         );
- *
- *         // 4. Save to GunDB
- *         const messageId = generateId();
- *         await gun.get('messages').get(messageId).put({
- *             content: encrypted,
- *             from: senderPair.pub,
- *             to: recipientUsername,
- *             timestamp: Date.now().toString()
- *         });
- *
- *         return { success: true, messageId };
- *     }
- *
- *     async listenForMessages(onMessage: (message: DecryptedMessage) => void): Promise<void> {
- *         const currentUser = this.identity.getCurrentUser();
- *         if (!currentUser) {
- *             throw new Error('Not authenticated');
- *         }
- *
- *         gun.get('messages').map().on(async (data, key) => {
- *             if (data && data.to === currentUser.alias) {
- *                 // Decrypt message
- *                 const senderKey = await this.identity.getPublicKey(data.from);
- *                 const receiverPair = this.identity.getKeyPair();
- *
- *                 if (senderKey && receiverPair) {
- *                     const decrypted = await crypto.decFrom(
- *                         data.content,
- *                         { epub: senderKey.epub },
- *                         receiverPair
- *                     );
- *
- *                     onMessage({
- *                         from: data.from,
- *                         content: decrypted,
- *                         timestamp: parseInt(data.timestamp)
- *                     });
- *                 }
- *             }
- *         });
- *     }
- *
- *     async getMessageHistory(withUsername: string): Promise<MessageHistoryEntry[]> {
- *         // Implementation here
- *         return [];
- *     }
- * }
- *
- * // Usage
- * const identity = new SHIP_00(config);
- * await identity.login('alice', 'password123');
- * await identity.publishPublicKey();
- *
- * const messaging = new SecureMessagingApp(identity);
- * await messaging.sendMessage('bob', 'Hello Bob!');
- * ```
- */

package/dist/ship/interfaces/ISHIP_02.js

@@ -1,57 +0,0 @@
-"use strict";
-/**
- * SHIP-02: Ethereum Address Derivation Interface
- *
- * @title ISHIP_02 - Deterministic Address Derivation
- * @notice Interface for deriving Ethereum addresses from SHIP-00 identity
- *
- * ## Abstract
- *
- * This standard extends SHIP-00 to enable:
- * - Deterministic Ethereum address derivation from identity keys
- * - BIP-32/BIP-44 hierarchical deterministic (HD) wallet support
- * - Stealth address generation for enhanced privacy
- * - Multiple address management from single identity
- * - Transaction signing with derived keys
- *
- * ## Specification
- *
- * Based on:
- * - SHIP-00 for identity foundation
- * - BIP-32 for hierarchical deterministic wallets
- * - BIP-44 for multi-account hierarchy
- * - Ethers.js for Ethereum operations
- * - ECDH for stealth address generation
- *
- * ## Dependencies
- *
- * - SHIP-00: Identity and authentication foundation
- * - ethers: Ethereum wallet and signing operations
- *
- * ## Usage
- *
- * SHIP-02 enables wallet functionality on top of SHIP-00 identity:
- * ```typescript
- * const identity = new SHIP_00({ gunOptions: { peers: ['...'] } });
- * await identity.login('alice', 'password123');
- *
- * const addressDerivation = new SHIP_02(identity);
- * await addressDerivation.initialize();
- *
- * const ethAddress = await addressDerivation.deriveEthereumAddress();
- * ```
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SHIP_02_EventType = void 0;
-/**
- * @notice Event types for SHIP-02 wallet operations
- */
-var SHIP_02_EventType;
-(function (SHIP_02_EventType) {
-    SHIP_02_EventType["WALLET_CREATED"] = "walletCreated";
-    SHIP_02_EventType["ADDRESS_DERIVED"] = "addressDerived";
-    SHIP_02_EventType["TRANSACTION_SIGNED"] = "transactionSigned";
-    SHIP_02_EventType["MNEMONIC_GENERATED"] = "mnemonicGenerated";
-    SHIP_02_EventType["SYNC_COMPLETED"] = "syncCompleted";
-    SHIP_02_EventType["ERROR"] = "error";
-})(SHIP_02_EventType || (exports.SHIP_02_EventType = SHIP_02_EventType = {}));

package/dist/ship/interfaces/ISHIP_03.js

@@ -1,61 +0,0 @@
-"use strict";
-/**
- * SHIP-03: Dual-Key Stealth Address Interface
- *
- * @title ISHIP_03 - Privacy-Preserving Stealth Addresses
- * @notice Interface for ERC-5564 compatible stealth addresses
- *
- * ## Abstract
- *
- * This standard extends SHIP-00 and SHIP-02 to enable:
- * - Dual-key stealth addresses (viewing + spending keys)
- * - ERC-5564 / Fluidkey compatibility
- * - Enhanced transaction privacy
- * - Stealth address scanning and opening
- * - Deterministic key derivation from SHIP-00 identity
- *
- * ## Specification
- *
- * Based on:
- * - SHIP-00 for identity foundation
- * - SHIP-02 for Ethereum address derivation
- * - ERC-5564 for stealth address standard
- * - Fluidkey Stealth Account Kit
- * - ECDH for shared secret derivation
- *
- * ## Key Concepts
- *
- * **Viewing Key**: Used to scan blockchain for incoming stealth payments
- * **Spending Key**: Used to spend funds received at stealth addresses
- * **Ephemeral Key**: One-time key used by sender to generate stealth address
- *
- * ## Dependencies
- *
- * - SHIP-00: Identity and authentication foundation
- * - SHIP-02: Ethereum wallet operations
- * - @fluidkey/stealth-account-kit: ERC-5564 implementation
- * - ethers: Ethereum operations
- *
- * ## Usage
- *
- * ```typescript
- * const identity = new SHIP_00({ gunOptions: { peers: ['...'] } });
- * await identity.login('alice', 'password123');
- *
- * const eth = new SHIP_02(identity);
- * await eth.initialize();
- *
- * const stealth = new SHIP_03(identity, eth);
- * await stealth.initialize();
- *
- * // Get stealth keys (derived from SHIP-00 identity)
- * const keys = await stealth.getStealthKeys();
- *
- * // Generate stealth address for recipient
- * const stealthAddr = await stealth.generateStealthAddress(
- *   recipientViewingKey,
- *   recipientSpendingKey
- * );
- * ```
- */
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-/**
- * Shogun Chat - CLI Interface
- *
- * End-to-end encrypted decentralized chat
- * Simple and functional CLI interface
- */
-export declare class MessengerCLI {
-    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;
-    private updatePrompt;
-    start(): Promise<void>;
-}

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

@@ -1,131 +0,0 @@
-/**
- * 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

@@ -1,113 +0,0 @@
-/**
- * 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 };