shogun-core 6.2.4 → 6.3.0

package/dist/src/utils/errorHandler.js

@@ -0,0 +1,339 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+/**
+ * Types of errors that can occur in the application
+ */
+export 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 || (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
+ */
+export function createError(type, code, message, originalError) {
+    return {
+        type: type,
+        code: code,
+        message: message,
+        originalError: originalError,
+        timestamp: Date.now(),
+    };
+}
+/**
+ * Centralized error handler
+ */
+var ErrorHandler = /** @class */ (function () {
+    function ErrorHandler() {
+    }
+    /**
+     * Set an external logging service for production error monitoring
+     * @param logger - External logger function to send errors to a monitoring service
+     */
+    ErrorHandler.setExternalLogger = function (logger) {
+        this.externalLogger = logger;
+    };
+    /**
+     * Handles an error by logging it and notifying listeners
+     * @param error - The error to handle
+     */
+    ErrorHandler.handleError = function (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("[".concat(error.type, "] ").concat(error.code, ": ").concat(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(function (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
+     */
+    ErrorHandler.handle = function (type, code, message, originalError, logLevel) {
+        if (logLevel === void 0) { logLevel = "error"; }
+        // Create a formatted error message (tests expect the plain message)
+        var finalMessage = message;
+        // Log the error
+        switch (logLevel) {
+            case "debug":
+                console.log("[".concat(type, "] ").concat(code, ": ").concat(finalMessage));
+                break;
+            case "warn":
+                console.log("[".concat(type, "] ").concat(code, ": ").concat(finalMessage));
+                break;
+            case "info":
+                console.log("[".concat(type, "] ").concat(code, ": ").concat(finalMessage));
+                break;
+            case "error":
+            default:
+                console.log("[".concat(type, "] ").concat(code, ": ").concat(finalMessage));
+                break;
+        }
+        var 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
+     */
+    ErrorHandler.handleAndThrow = function (type, code, message, originalError) {
+        var 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
+     */
+    ErrorHandler.getRecentErrors = function (count) {
+        if (count === void 0) { 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
+     */
+    ErrorHandler.addListener = function (listener) {
+        this.listeners.push(listener);
+    };
+    /**
+     * Removes an error listener
+     * @param listener - Function to remove
+     */
+    ErrorHandler.removeListener = function (listener) {
+        var index = this.listeners.indexOf(listener);
+        if (index !== -1) {
+            this.listeners.splice(index, 1);
+        }
+    };
+    /**
+     * Notifies all listeners of an error
+     * @param error - Error to notify
+     */
+    ErrorHandler.notifyListeners = function (error) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this.listeners), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var listener = _c.value;
+                try {
+                    listener(error);
+                }
+                catch (listenerError) {
+                    console.error("Error in error listener: ".concat(listenerError));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    /**
+     * Helper function to format error messages from native errors
+     * @param error - Error to format
+     * @returns Formatted error message
+     */
+    ErrorHandler.formatError = function (error) {
+        if (!error) {
+            return "Unknown error";
+        }
+        if (error instanceof Error) {
+            return "".concat(error.name, ": ").concat(error.message);
+        }
+        if (typeof error === "string") {
+            return error;
+        }
+        if (typeof error === "object") {
+            try {
+                return JSON.stringify(error);
+            }
+            catch (e) {
+                return "Object: ".concat(Object.prototype.toString.call(error));
+            }
+        }
+        return String(error);
+    };
+    /**
+     * Error handling with retry logic
+     */
+    ErrorHandler.withRetry = function (fn_1, errorType_1, errorCode_1) {
+        return __awaiter(this, arguments, void 0, function (fn, errorType, errorCode, maxRetries, retryDelay) {
+            var lastError, _loop_1, attempt, state_1;
+            if (maxRetries === void 0) { maxRetries = 3; }
+            if (retryDelay === void 0) { retryDelay = 1000; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _loop_1 = function (attempt) {
+                            var _b, error_1, delay_1;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        _c.trys.push([0, 2, , 5]);
+                                        _b = {};
+                                        return [4 /*yield*/, fn()];
+                                    case 1: return [2 /*return*/, (_b.value = _c.sent(), _b)];
+                                    case 2:
+                                        error_1 = _c.sent();
+                                        lastError = error_1;
+                                        delay_1 = retryDelay * attempt;
+                                        if (!(attempt < maxRetries)) return [3 /*break*/, 4];
+                                        console.log("Retrying operation after ".concat(delay_1, "ms (attempt ").concat(attempt, "/").concat(maxRetries, ")"));
+                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, delay_1); })];
+                                    case 3:
+                                        _c.sent();
+                                        _c.label = 4;
+                                    case 4: return [3 /*break*/, 5];
+                                    case 5: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        attempt = 1;
+                        _a.label = 1;
+                    case 1:
+                        if (!(attempt <= maxRetries)) return [3 /*break*/, 4];
+                        return [5 /*yield**/, _loop_1(attempt)];
+                    case 2:
+                        state_1 = _a.sent();
+                        if (typeof state_1 === "object")
+                            return [2 /*return*/, state_1.value];
+                        _a.label = 3;
+                    case 3:
+                        attempt++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        // 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 ".concat(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
+     */
+    ErrorHandler.clearErrors = function () {
+        this.errors = [];
+    };
+    ErrorHandler.errors = [];
+    ErrorHandler.maxErrors = 100;
+    ErrorHandler.listeners = [];
+    ErrorHandler.externalLogger = null;
+    return ErrorHandler;
+}());
+export { ErrorHandler };

package/dist/{utils → src/utils}/eventEmitter.js

@@ -1,49 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventEmitter = void 0;
 /**
  * Simple event emitter implementation with generic event types
  */
-class EventEmitter {
-    constructor() {
+var EventEmitter = /** @class */ (function () {
+    function EventEmitter() {
         this.events = new Map();
     }
     /**
      * Registers an event listener
      */
-    on(event, listener) {
+    EventEmitter.prototype.on = function (event, listener) {
+        var _a;
         if (!this.events.has(event)) {
             this.events.set(event, []);
         }
-        this.events.get(event)?.push(listener);
-    }
+        (_a = this.events.get(event)) === null || _a === void 0 ? void 0 : _a.push(listener);
+    };
     /**
      * Emits an event with arguments
      */
-    emit(event, data) {
+    EventEmitter.prototype.emit = function (event, data) {
         if (!this.events.has(event))
             return false;
-        const listeners = this.events.get(event) || [];
-        listeners.forEach((listener) => {
+        var listeners = this.events.get(event) || [];
+        listeners.forEach(function (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);
+                var err = error instanceof Error ? error : new Error(String(error));
+                console.error("Error in event listener for ".concat(String(event), ":"), err);
             }
         });
         return true;
-    }
+    };
     /**
      * Removes an event listener
      */
-    off(event, listener) {
+    EventEmitter.prototype.off = function (event, listener) {
         if (!this.events.has(event))
             return;
-        const listeners = this.events.get(event) || [];
-        const index = listeners.indexOf(listener);
+        var listeners = this.events.get(event) || [];
+        var index = listeners.indexOf(listener);
         if (index !== -1) {
             listeners.splice(index, 1);
             if (listeners.length === 0) {
@@ -53,27 +51,29 @@ class EventEmitter {
                 this.events.set(event, listeners);
             }
         }
-    }
+    };
     /**
      * Registers a one-time event listener
      */
-    once(event, listener) {
-        const onceWrapper = (data) => {
+    EventEmitter.prototype.once = function (event, listener) {
+        var _this = this;
+        var onceWrapper = function (data) {
             listener(data);
-            this.off(event, onceWrapper);
+            _this.off(event, onceWrapper);
         };
         this.on(event, onceWrapper);
-    }
+    };
     /**
      * Removes all listeners for an event or all events
      */
-    removeAllListeners(event) {
+    EventEmitter.prototype.removeAllListeners = function (event) {
         if (event) {
             this.events.delete(event);
         }
         else {
             this.events.clear();
         }
-    }
-}
-exports.EventEmitter = EventEmitter;
+    };
+    return EventEmitter;
+}());
+export { EventEmitter };

package/dist/{utils → src/utils}/seedPhrase.js

@@ -1,35 +1,26 @@
-"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");
+import { generateMnemonic, mnemonicToSeedSync, validateMnemonic, } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex } from "@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
+export function generateSeedPhrase() {
+    return generateMnemonic(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) {
+export function validateSeedPhrase(mnemonic) {
     try {
-        return (0, bip39_1.validateMnemonic)(mnemonic, english_1.wordlist);
+        return validateMnemonic(mnemonic, wordlist);
     }
     catch (error) {
         return false;
@@ -41,24 +32,24 @@ function validateSeedPhrase(mnemonic) {
  * @param {string} username - Username to include in derivation
  * @returns {Uint8Array} 64-byte seed for key derivation
  */
-function mnemonicToSeed(mnemonic, username) {
+export 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);
+    var passphrase = "shogun-".concat(username);
+    return 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) {
+export function seedToPassword(seed) {
     // Hash the seed to create a deterministic password
-    const hash = (0, sha256_1.sha256)(seed);
-    return (0, utils_1.bytesToHex)(hash);
+    var hash = sha256(seed);
+    return bytesToHex(hash);
 }
 /**
  * Derive GunDB credentials from mnemonic
@@ -66,12 +57,12 @@ function seedToPassword(seed) {
  * @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);
+export function deriveCredentialsFromMnemonic(mnemonic, username) {
+    var seed = mnemonicToSeed(mnemonic, username);
+    var password = seedToPassword(seed);
     return {
-        password,
-        seed,
+        password: password,
+        seed: seed,
     };
 }
 /**
@@ -79,16 +70,16 @@ function deriveCredentialsFromMnemonic(mnemonic, username) {
  * @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");
+export function formatSeedPhrase(mnemonic) {
+    var words = mnemonic.split(" ");
+    return words.map(function (word, index) { return "".concat(index + 1, ". ").concat(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) {
+export function normalizeSeedPhrase(input) {
     return input
         .toLowerCase()
         .trim()

package/dist/{utils → src/utils}/validation.js

@@ -1,16 +1,9 @@
-"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) {
+export function validateUsername(username) {
     if (!username || typeof username !== "string")
         return false;
     if (username.length < 3 || username.length > 64)
@@ -22,7 +15,7 @@ function validateUsername(username) {
 /**
  * Valida una email
  */
-function validateEmail(email) {
+export function validateEmail(email) {
     if (!email || typeof email !== "string")
         return false;
     // Regex semplice per email
@@ -32,7 +25,7 @@ function validateEmail(email) {
  * Valida un provider OAuth supportato
  * @deprecated OAuth has been removed from Shogun Core
  */
-function validateProvider(provider) {
+export function validateProvider(provider) {
     console.warn("[validation] OAuth has been removed from Shogun Core");
     return false;
 }
@@ -41,37 +34,37 @@ function validateProvider(provider) {
  * Genera uno username uniforme a partire da provider e userInfo
  * Esempio: google_utente, github_12345, nostr_pubkey, web3_0xabc...
  */
-function generateUsernameFromIdentity(provider, userInfo) {
+export function generateUsernameFromIdentity(provider, userInfo) {
     if (provider === "web3" && userInfo.id) {
-        return `web3_${userInfo.id.toLowerCase()}`;
+        return "web3_".concat(userInfo.id.toLowerCase());
     }
     if (provider === "nostr" && userInfo.id) {
-        return `nostr_${userInfo.id}`;
+        return "nostr_".concat(userInfo.id);
     }
     if (provider === "webauthn" && userInfo.id) {
-        return `webauthn_${userInfo.id}`;
+        return "webauthn_".concat(userInfo.id);
     }
     if (userInfo.email && validateEmail(userInfo.email)) {
-        return `${provider}_${userInfo.email.split("@")[0]}`;
+        return "".concat(provider, "_").concat(userInfo.email.split("@")[0]);
     }
     if (userInfo.name) {
-        return `${provider}_${userInfo.name.replace(/\s+/g, "_")}`;
+        return "".concat(provider, "_").concat(userInfo.name.replace(/\s+/g, "_"));
     }
     if (userInfo.id) {
-        return `${provider}_${userInfo.id}`;
+        return "".concat(provider, "_").concat(userInfo.id);
     }
-    return `${provider}_user`;
+    return "".concat(provider, "_user");
 }
 // --- GENERAZIONE PASSWORD DETERMINISTICA ---
-const ethers_1 = require("ethers");
+import { ethers } from "ethers";
 /**
  * Genera una password deterministica sicura a partire da un salt
  * Usare per OAuth, Web3, Nostr, ecc.
  */
-function generateDeterministicPassword(salt) {
+export function generateDeterministicPassword(salt) {
     try {
         // Restituisce una stringa hex di 32 caratteri
-        return ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(salt)).slice(2, 34);
+        return ethers.keccak256(ethers.toUtf8Bytes(salt)).slice(2, 34);
     }
     catch (error) {
         // Fallback in case ethers is not available