shogun-core 5.2.0 → 5.2.2

package/dist/utils/errorHandler.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandler = exports.ErrorType = void 0;
+exports.createError = createError;
+/**
+ * Types of errors that can occur in the application
+ */
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["AUTHENTICATION"] = "AuthenticationError";
+    ErrorType["AUTHORIZATION"] = "AuthorizationError";
+    ErrorType["VALIDATION"] = "ValidationError";
+    ErrorType["NETWORK"] = "NetworkError";
+    ErrorType["DATABASE"] = "DatabaseError";
+    ErrorType["WALLET"] = "WalletError";
+    ErrorType["STORAGE"] = "StorageError";
+    ErrorType["ENCRYPTION"] = "EncryptionError";
+    ErrorType["SIGNATURE"] = "SignatureError";
+    ErrorType["ENVIRONMENT"] = "EnvironmentError";
+    ErrorType["SECURITY"] = "SecurityError";
+    ErrorType["GUN"] = "GunError";
+    ErrorType["STEALTH"] = "StealthError";
+    ErrorType["WEBAUTHN"] = "WebAuthnError";
+    ErrorType["PLUGIN"] = "PluginError";
+    ErrorType["UNKNOWN"] = "UnknownError";
+    ErrorType["CONNECTOR"] = "ConnectorError";
+    ErrorType["GENERAL"] = "GeneralError";
+    ErrorType["CONTRACT"] = "ContractError";
+    ErrorType["BIP32"] = "BIP32Error";
+    ErrorType["ETHEREUM"] = "EthereumError";
+    ErrorType["BITCOIN"] = "BitcoinError";
+})(ErrorType || (exports.ErrorType = ErrorType = {}));
+/**
+ * Wrapper to standardize errors
+ * @param type - Error type
+ * @param code - Error code
+ * @param message - Error message
+ * @param originalError - Original error
+ * @returns A structured error object
+ */
+function createError(type, code, message, originalError) {
+    return {
+        type,
+        code,
+        message,
+        originalError,
+        timestamp: Date.now(),
+    };
+}
+/**
+ * Centralized error handler
+ */
+class ErrorHandler {
+    /**
+     * Set an external logging service for production error monitoring
+     * @param logger - External logger function to send errors to a monitoring service
+     */
+    static setExternalLogger(logger) {
+        this.externalLogger = logger;
+    }
+    /**
+     * Handles an error by logging it and notifying listeners
+     * @param error - The error to handle
+     */
+    static handleError(error) {
+        // Log essential errors only
+        if (error.type === ErrorType.AUTHENTICATION ||
+            error.type === ErrorType.AUTHORIZATION ||
+            error.type === ErrorType.SECURITY) {
+            // Ensure console.error is available and safe to use
+            if (typeof console !== "undefined" && console.error) {
+                console.error(`[${error.type}] ${error.code}: ${error.message}`);
+            }
+        }
+        // Store the error in memory
+        this.errors.push(error);
+        // Keep only the last maxErrors
+        if (this.errors.length > this.maxErrors) {
+            this.errors = this.errors.slice(-this.maxErrors);
+        }
+        // Send to external logger if set (for production monitoring)
+        if (this.externalLogger) {
+            try {
+                this.externalLogger(error);
+            }
+            catch (e) {
+                // Fallback logging for external logger errors
+                console.error("Failed to send error to external logger:", e);
+            }
+        }
+        // Notify all listeners
+        this.listeners.forEach((listener) => {
+            try {
+                listener(error);
+            }
+            catch (e) {
+                // Silent error to prevent infinite loops
+            }
+        });
+    }
+    /**
+     * Handles a raw error by converting it to ShogunError
+     * @param type - Error type
+     * @param code - Error code
+     * @param message - Error message
+     * @param originalError - Original error
+     * @param logLevel - Log level for the error
+     */
+    static handle(type, code, message, originalError, logLevel = "error") {
+        // Create a formatted error message (tests expect the plain message)
+        const finalMessage = message;
+        // Log the error
+        switch (logLevel) {
+            case "debug":
+                console.log(`[${type}] ${code}: ${finalMessage}`);
+                break;
+            case "warn":
+                console.log(`[${type}] ${code}: ${finalMessage}`);
+                break;
+            case "info":
+                console.log(`[${type}] ${code}: ${finalMessage}`);
+                break;
+            case "error":
+            default:
+                console.log(`[${type}] ${code}: ${finalMessage}`);
+                break;
+        }
+        const error = createError(type, code, finalMessage, originalError);
+        this.handleError(error);
+        return error;
+    }
+    /**
+     * Handles errors and throws them as standardized ShogunError objects
+     * @param type - Error type
+     * @param code - Error code
+     * @param message - Error message
+     * @param originalError - Original error
+     * @throws ShogunError
+     */
+    static handleAndThrow(type, code, message, originalError) {
+        const error = this.handle(type, code, message, originalError);
+        throw error;
+    }
+    /**
+     * Retrieves the last N errors
+     * @param count - Number of errors to retrieve
+     * @returns List of most recent errors
+     */
+    static getRecentErrors(count = 10) {
+        return this.errors.slice(-Math.min(count, this.errors.length));
+    }
+    /**
+     * Adds a listener for errors
+     * @param listener - Function that will be called when an error occurs
+     */
+    static addListener(listener) {
+        this.listeners.push(listener);
+    }
+    /**
+     * Removes an error listener
+     * @param listener - Function to remove
+     */
+    static removeListener(listener) {
+        const index = this.listeners.indexOf(listener);
+        if (index !== -1) {
+            this.listeners.splice(index, 1);
+        }
+    }
+    /**
+     * Notifies all listeners of an error
+     * @param error - Error to notify
+     */
+    static notifyListeners(error) {
+        for (const listener of this.listeners) {
+            try {
+                listener(error);
+            }
+            catch (listenerError) {
+                console.error(`Error in error listener: ${listenerError}`);
+            }
+        }
+    }
+    /**
+     * Helper function to format error messages from native errors
+     * @param error - Error to format
+     * @returns Formatted error message
+     */
+    static formatError(error) {
+        if (!error) {
+            return "Unknown error";
+        }
+        if (error instanceof Error) {
+            return `${error.name}: ${error.message}`;
+        }
+        if (typeof error === "string") {
+            return error;
+        }
+        if (typeof error === "object") {
+            try {
+                return JSON.stringify(error);
+            }
+            catch (e) {
+                return `Object: ${Object.prototype.toString.call(error)}`;
+            }
+        }
+        return String(error);
+    }
+    /**
+     * Error handling with retry logic
+     */
+    static async withRetry(fn, errorType, errorCode, maxRetries = 3, retryDelay = 1000) {
+        let lastError;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                const delay = retryDelay * attempt;
+                if (attempt < maxRetries) {
+                    console.log(`Retrying operation after ${delay}ms (attempt ${attempt}/${maxRetries})`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+        }
+        // If we got here, all retries failed.
+        // Log the failure and rethrow the last error message for test expectations compatibility.
+        this.handle(errorType, errorCode, `Operation failed after ${maxRetries} attempts`, lastError);
+        // Prefer the original error message if available
+        if (lastError instanceof Error) {
+            throw new Error(lastError.message);
+        }
+        throw new Error(this.formatError(lastError));
+    }
+    /**
+     * Clear all stored errors
+     */
+    static clearErrors() {
+        this.errors = [];
+    }
+}
+exports.ErrorHandler = ErrorHandler;
+ErrorHandler.errors = [];
+ErrorHandler.maxErrors = 100;
+ErrorHandler.listeners = [];
+ErrorHandler.externalLogger = null;

package/dist/utils/eventEmitter.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = void 0;
+/**
+ * Simple event emitter implementation with generic event types
+ */
+class EventEmitter {
+    constructor() {
+        this.events = new Map();
+    }
+    /**
+     * Registers an event listener
+     */
+    on(event, listener) {
+        if (!this.events.has(event)) {
+            this.events.set(event, []);
+        }
+        this.events.get(event)?.push(listener);
+    }
+    /**
+     * Emits an event with arguments
+     */
+    emit(event, data) {
+        if (!this.events.has(event))
+            return false;
+        const listeners = this.events.get(event) || [];
+        listeners.forEach((listener) => {
+            try {
+                listener(data);
+            }
+            catch (error) {
+                // Ensure error is properly formatted for console.error and pass Error instance
+                const err = error instanceof Error ? error : new Error(String(error));
+                console.error(`Error in event listener for ${String(event)}:`, err);
+            }
+        });
+        return true;
+    }
+    /**
+     * Removes an event listener
+     */
+    off(event, listener) {
+        if (!this.events.has(event))
+            return;
+        const listeners = this.events.get(event) || [];
+        const index = listeners.indexOf(listener);
+        if (index !== -1) {
+            listeners.splice(index, 1);
+            if (listeners.length === 0) {
+                this.events.delete(event);
+            }
+            else {
+                this.events.set(event, listeners);
+            }
+        }
+    }
+    /**
+     * Registers a one-time event listener
+     */
+    once(event, listener) {
+        const onceWrapper = (data) => {
+            listener(data);
+            this.off(event, onceWrapper);
+        };
+        this.on(event, onceWrapper);
+    }
+    /**
+     * Removes all listeners for an event or all events
+     */
+    removeAllListeners(event) {
+        if (event) {
+            this.events.delete(event);
+        }
+        else {
+            this.events.clear();
+        }
+    }
+}
+exports.EventEmitter = EventEmitter;

package/dist/utils/seedPhrase.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Seed Phrase Utilities for Multi-Device Authentication
+ * Provides BIP39-compatible seed phrase generation and validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSeedPhrase = generateSeedPhrase;
+exports.validateSeedPhrase = validateSeedPhrase;
+exports.mnemonicToSeed = mnemonicToSeed;
+exports.seedToPassword = seedToPassword;
+exports.deriveCredentialsFromMnemonic = deriveCredentialsFromMnemonic;
+exports.formatSeedPhrase = formatSeedPhrase;
+exports.normalizeSeedPhrase = normalizeSeedPhrase;
+const bip39_1 = require("@scure/bip39");
+const english_1 = require("@scure/bip39/wordlists/english");
+const sha256_1 = require("@noble/hashes/sha256");
+const utils_1 = require("@noble/hashes/utils");
+/**
+ * Generate a new 12-word BIP39 mnemonic seed phrase
+ * @returns {string} 12-word mnemonic seed phrase
+ */
+function generateSeedPhrase() {
+    return (0, bip39_1.generateMnemonic)(english_1.wordlist, 128); // 128 bits = 12 words
+}
+/**
+ * Validate a BIP39 mnemonic seed phrase
+ * @param {string} mnemonic - The seed phrase to validate
+ * @returns {boolean} True if valid, false otherwise
+ */
+function validateSeedPhrase(mnemonic) {
+    try {
+        return (0, bip39_1.validateMnemonic)(mnemonic, english_1.wordlist);
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Derive a deterministic seed from mnemonic and username
+ * @param {string} mnemonic - The BIP39 mnemonic seed phrase
+ * @param {string} username - Username to include in derivation
+ * @returns {Uint8Array} 64-byte seed for key derivation
+ */
+function mnemonicToSeed(mnemonic, username) {
+    if (!validateSeedPhrase(mnemonic)) {
+        throw new Error("Invalid mnemonic seed phrase");
+    }
+    // Use username as additional entropy in the passphrase
+    // This ensures different users with same seed phrase get different keys
+    const passphrase = `shogun-${username}`;
+    return (0, bip39_1.mnemonicToSeedSync)(mnemonic, passphrase);
+}
+/**
+ * Convert seed to deterministic password for GunDB
+ * @param {Uint8Array} seed - The seed from mnemonic
+ * @returns {string} Hex-encoded password
+ */
+function seedToPassword(seed) {
+    // Hash the seed to create a deterministic password
+    const hash = (0, sha256_1.sha256)(seed);
+    return (0, utils_1.bytesToHex)(hash);
+}
+/**
+ * Derive GunDB credentials from mnemonic
+ * @param {string} mnemonic - The BIP39 mnemonic
+ * @param {string} username - Username for derivation
+ * @returns {{password: string; seed: Uint8Array}} Credentials for GunDB
+ */
+function deriveCredentialsFromMnemonic(mnemonic, username) {
+    const seed = mnemonicToSeed(mnemonic, username);
+    const password = seedToPassword(seed);
+    return {
+        password,
+        seed,
+    };
+}
+/**
+ * Format seed phrase for display (with word numbers)
+ * @param {string} mnemonic - The seed phrase
+ * @returns {string} Formatted seed phrase with numbers
+ */
+function formatSeedPhrase(mnemonic) {
+    const words = mnemonic.split(" ");
+    return words.map((word, index) => `${index + 1}. ${word}`).join("\n");
+}
+/**
+ * Normalize and clean user input for seed phrase
+ * @param {string} input - User-provided seed phrase
+ * @returns {string} Normalized seed phrase
+ */
+function normalizeSeedPhrase(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, " ") // Replace multiple spaces with single space
+        .replace(/[^\w\s]/g, ""); // Remove special characters
+}

package/dist/utils/validation.js

@@ -0,0 +1,81 @@
+"use strict";
+// Utility di validazione e generazione credenziali per ShogunCore
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateUsername = validateUsername;
+exports.validateEmail = validateEmail;
+exports.validateProvider = validateProvider;
+exports.generateUsernameFromIdentity = generateUsernameFromIdentity;
+exports.generateDeterministicPassword = generateDeterministicPassword;
+// --- VALIDAZIONE ---
+/**
+ * Valida uno username secondo le regole comuni
+ */
+function validateUsername(username) {
+    if (!username || typeof username !== "string")
+        return false;
+    if (username.length < 3 || username.length > 64)
+        return false;
+    if (!/^[a-zA-Z0-9._-]+$/.test(username))
+        return false;
+    return true;
+}
+/**
+ * Valida una email
+ */
+function validateEmail(email) {
+    if (!email || typeof email !== "string")
+        return false;
+    // Regex semplice per email
+    return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email);
+}
+/**
+ * Valida un provider OAuth supportato
+ * @deprecated OAuth has been removed from Shogun Core
+ */
+function validateProvider(provider) {
+    console.warn("[validation] OAuth has been removed from Shogun Core");
+    return false;
+}
+// --- GENERAZIONE USERNAME ---
+/**
+ * Genera uno username uniforme a partire da provider e userInfo
+ * Esempio: google_utente, github_12345, nostr_pubkey, web3_0xabc...
+ */
+function generateUsernameFromIdentity(provider, userInfo) {
+    if (provider === "web3" && userInfo.id) {
+        return `web3_${userInfo.id.toLowerCase()}`;
+    }
+    if (provider === "nostr" && userInfo.id) {
+        return `nostr_${userInfo.id}`;
+    }
+    if (provider === "webauthn" && userInfo.id) {
+        return `webauthn_${userInfo.id}`;
+    }
+    if (userInfo.email && validateEmail(userInfo.email)) {
+        return `${provider}_${userInfo.email.split("@")[0]}`;
+    }
+    if (userInfo.name) {
+        return `${provider}_${userInfo.name.replace(/\s+/g, "_")}`;
+    }
+    if (userInfo.id) {
+        return `${provider}_${userInfo.id}`;
+    }
+    return `${provider}_user`;
+}
+// --- GENERAZIONE PASSWORD DETERMINISTICA ---
+const ethers_1 = require("ethers");
+/**
+ * Genera una password deterministica sicura a partire da un salt
+ * Usare per OAuth, Web3, Nostr, ecc.
+ */
+function generateDeterministicPassword(salt) {
+    try {
+        // Restituisce una stringa hex di 32 caratteri
+        return ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(salt)).slice(2, 34);
+    }
+    catch (error) {
+        // Fallback in case ethers is not available
+        console.warn("ethers not available, using fallback password generation");
+        return Buffer.from(salt).toString("hex").slice(0, 32);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shogun-core",
-  "version": "5.2.0",
+  "version": "5.2.2",
   "description": "SHOGUN CORE - Core library for Shogun Ecosystem",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -47,6 +47,8 @@
     "test:ci": "jest --ci --coverage --watchAll=false",
     "test:integration": "jest --config src/__tests__/integration/jest.integration.config.js",
     "test:integration:watch": "jest --config src/__tests__/integration/jest.integration.config.js --watch",
+    "crypto-identities:example": "yarn tsx src/examples/crypto-identity-example.ts",
+    "crypto-identities:simple": "yarn tsx src/examples/simple-crypto-identity-example.ts",
     "coverage": "jest --coverage"
   },
   "keywords": [
@@ -59,8 +61,13 @@
   "author": "Scobru",
   "license": "MIT",
   "dependencies": {
+    "@hpke/chacha20poly1305": "^1.7.1",
+    "@hpke/hybridkem-x-wing": "^0.6.1",
+    "@hpke/ml-kem": "^0.2.1",
+    "@noble/ciphers": "2.0.1",
     "@noble/curves": "^1.9.1",
     "@noble/hashes": "^1.5.0",
+    "@noble/post-quantum": "^0.5.2",
     "@scure/bip39": "^1.5.0",
     "@semaphore-protocol/group": "^3.15.0",
     "@semaphore-protocol/identity": "^3.15.0",
@@ -72,8 +79,10 @@
     "ethers": "^6.13.5",
     "gun": "git+https://github.com/amark/gun.git",
     "nostr-tools": "^2.15.0",
+    "openpgp": "^6.2.2",
     "react": "^19.2.0",
     "rxjs": "^7.8.2",
+    "ts-mls": "^1.3.2",
     "uuid": "^11.1.0",
     "vm-browserify": "^1.1.2"
   },
@@ -106,61 +115,5 @@
   },
   "engines": {
     "node": ">=18"
-  },
-  "jest": {
-    "preset": "ts-jest",
-    "testEnvironment": "node",
-    "roots": [
-      "<rootDir>/src"
-    ],
-    "testMatch": [
-      "**/__tests__/**/*.ts",
-      "**/?(*.)+(spec|test).ts"
-    ],
-    "testPathIgnorePatterns": [
-      ".*complete-integration\\.test\\.ts$",
-      ".*user_manager\\.integration\\.test\\.ts$",
-      ".*saveUser\\.integration\\.test\\.ts$",
-      ".*oauthPlugin\\.integration\\.test\\.ts$",
-      ".*gun-Instance\\.integration\\.test\\.ts$",
-      ".*robust-integration\\.test\\.ts$",
-      ".*final-integration\\.test\\.ts$",
-      ".*quick-integration\\.test\\.ts$"
-    ],
-    "transform": {
-      "^.+\\.ts$": "ts-jest"
-    },
-    "transformIgnorePatterns": [
-      "node_modules/(?!(@zk-kit|@semaphore-protocol|ffjavascript)/)"
-    ],
-    "collectCoverageFrom": [
-      "src/**/*.ts",
-      "!src/**/*.d.ts",
-      "!src/index.ts"
-    ],
-    "coverageDirectory": "coverage",
-    "coverageReporters": [
-      "text",
-      "lcov",
-      "html"
-    ],
-    "setupFilesAfterEnv": [
-      "<rootDir>/src/__tests__/setup.ts"
-    ],
-    "moduleNameMapper": {
-      "^@/(.*)$": "<rootDir>/src/$1"
-    },
-    "testTimeout": 30000,
-    "forceExit": true,
-    "detectOpenHandles": true,
-    "maxWorkers": 1,
-    "coverageThreshold": {
-      "global": {
-        "branches": 10,
-        "functions": 15,
-        "lines": 20,
-        "statements": 20
-      }
-    }
   }
 }