shogun-core 0.0.1

package/README.md

@@ -0,0 +1,71 @@
+# Shogun SDK
+
+## Overview
+
+Welcome to the Shogun SDK! This powerful and user-friendly SDK is designed to simplify decentralized authentication and wallet management. With support for various authentication methods including standard username/password, MetaMask, and WebAuthn, Shogun SDK integrates seamlessly with GunDB for decentralized user authentication. Whether you're building a new application or enhancing an existing one, Shogun SDK provides the tools you need to manage user authentication and crypto wallets efficiently.
+
+## Key Features
+
+- **Multi-layer Authentication**: Supports username/password, MetaMask, and WebAuthn.
+- **Wallet Management**: Easily manage crypto wallets, mnemonics, and keys.
+- **GunDB Integration**: Decentralized user authentication with GunDB.
+- **Stealth Addresses**: Create and manage stealth addresses for enhanced privacy.
+- **Storage Solutions**: Simple key-value storage with support for localStorage.
+
+## Installazione
+
+```bash
+npm install @shogun/shogun-core
+# o
+yarn add @shogun/shogun-core
+```
+
+## Esempio Base d'Uso
+
+```typescript
+import { ShogunSDK } from '@shogun/shogun-core';
+
+// Inizializzazione
+const shogun = new ShogunSDK({
+  peers: ['https://your-gun-peer.com/gun'],
+  localStorage: true
+});
+
+// Autenticazione con username/password
+const loginResult = await shogun.login('username', 'password');
+
+// Oppure con MetaMask
+const metaMaskLoginResult = await shogun.loginWithMetaMask('ethereumAddress');
+
+// Oppure con WebAuthn
+const webAuthnLoginResult = await shogun.loginWithWebAuthn('username');
+```
+
+## Documentazione Completa
+
+Shogun SDK include una documentazione tecnica completa generata con TSDoc:
+
+- **Documentazione locale**: Visualizza la documentazione aprendo `./docs/index.html`
+- **Classi principali**: Consulta `./docs/classes/` per dettagli sulle singole classi
+- **Interfacce**: Consulta `./docs/interfaces/` per dettagli sulle interfacce
+
+## Requisiti di Sistema e Compatibilità
+
+- **Browser moderni** con supporto per WebAuthn (Chrome, Firefox, Edge, Safari)
+- **Node.js** 14 o superiore
+- Compatibile con **ethers.js** v6
+
+## Contribuire
+
+Le contribuzioni sono benvenute! Se desideri contribuire al progetto, per favore:
+
+1. Forka il repository
+2. Crea un branch per la tua feature (`git checkout -b feature/amazing-feature`)
+3. Committa i tuoi cambiamenti (`git commit -m 'Aggiunta nuova feature'`)
+4. Effettua il push al branch (`git push origin feature/amazing-feature`)
+5. Apri una Pull Request
+
+## Licenza
+
+MIT
+

package/dist/auth/credentialAuth.js

@@ -0,0 +1,154 @@
+import { logError, logDebug } from "../utils/logger";
+/**
+ * Classe per l'autenticazione con username e password
+ * Livello più alto di astrazione per gestire l'autenticazione utente
+ */
+export class UserAuth {
+    constructor(gundb, gun, storage) {
+        this.gundb = gundb;
+        this.gun = gun;
+        this.storage = storage;
+        this.auth = gundb.auth;
+    }
+    /**
+     * Crea un risultato di autenticazione
+     * @param success - Indica se l'autenticazione è riuscita
+     * @param data - Dati aggiuntivi
+     * @returns Risultato dell'autenticazione
+     */
+    createAuthResult(success, data = {}) {
+        return {
+            success,
+            ...data,
+        };
+    }
+    /**
+     * Metodo principale per l'autenticazione dell'utente
+     * @param username - Nome utente
+     * @param password - Password
+     * @param options - Opzioni avanzate per il login
+     * @returns Risultato dell'autenticazione
+     */
+    async login(username, password, options = {}) {
+        // Implementazione che sostituisce sia handleLogin che loginWithCredentials e loginWithExtendedOptions
+        logDebug(`Tentativo di login per l'utente: ${username} - timestamp: ${Date.now()}`);
+        const retryCount = options.retryCount || 1;
+        const timeout = options.timeout || 10000;
+        let lastError = null;
+        for (let attempt = 1; attempt <= retryCount; attempt++) {
+            try {
+                logDebug(`Tentativo ${attempt}/${retryCount} per l'utente: ${username}`);
+                // Adattiamo la chiamata al nuovo formato di auth.ts
+                // Convertiamo le nostre opzioni nel formato AuthOptions
+                const authOptions = {
+                    timeout: timeout,
+                    storePair: true, // Salviamo la coppia di chiavi per default
+                };
+                // Tentativo di login utilizzando Auth
+                const pub = await this.auth.login({ alias: username, pass: password }, authOptions);
+                logDebug(`Login riuscito per l'utente: ${username} - pub: ${pub}`);
+                // Callbacks opzionali
+                if (options.setUserpub) {
+                    options.setUserpub(pub);
+                }
+                if (options.setSignedIn) {
+                    options.setSignedIn(true);
+                }
+                return this.createAuthResult(true, { userPub: pub });
+            }
+            catch (error) {
+                lastError = error;
+                logDebug(`Errore nel tentativo ${attempt}: ${error instanceof Error ? error.message : "Errore sconosciuto"}`);
+            }
+        }
+        // Tutti i tentativi sono falliti
+        const errorMessage = lastError instanceof Error
+            ? lastError.message
+            : "Errore di autenticazione sconosciuto";
+        return this.createAuthResult(false, { error: errorMessage });
+    }
+    /**
+     * Metodo principale per la registrazione di un nuovo utente
+     * @param username - Nome utente
+     * @param password - Password
+     * @param passwordConfirmation - Conferma password
+     * @param options - Opzioni avanzate per la registrazione
+     * @returns Risultato della registrazione
+     */
+    async register(username, password, passwordConfirmation, options = {}) {
+        // Implementazione che sostituisce sia handleSignUp che registerWithExtendedOptions
+        logDebug(`Tentativo di registrazione per l'utente: ${username} - timestamp: ${Date.now()}`);
+        // Validazione password
+        if (password !== passwordConfirmation) {
+            const errorMessage = options.messages?.passwordMismatch || "Le password non corrispondono";
+            if (options.setErrorMessage) {
+                options.setErrorMessage(errorMessage);
+            }
+            return this.createAuthResult(false, { error: errorMessage });
+        }
+        // Verifica esistenza utente
+        try {
+            const exists = await this.auth.exists(username);
+            if (exists && !options.forceResetUser) {
+                logDebug(`[0/4] Utente ${username} esiste già - timestamp: ${Date.now()}`);
+                const errorMessage = options.messages?.userExists || "Nome utente già in uso";
+                if (options.setErrorMessage) {
+                    options.setErrorMessage(errorMessage);
+                }
+                return this.createAuthResult(false, { error: errorMessage });
+            }
+            if (exists && options.forceResetUser) {
+                logDebug(`[0/4] Utente ${username} esiste, si procede con reset forzato - timestamp: ${Date.now()}`);
+            }
+        }
+        catch (error) {
+            // Se c'è un errore nel controllo, procediamo comunque ma lo logghiamo
+            logDebug(`[0/4] Errore durante verifica esistenza utente: ${error instanceof Error ? error.message : "Unknown error"} - timestamp: ${Date.now()}`);
+        }
+        try {
+            // Crea un utente GUN usando Auth
+            try {
+                logDebug(`[1/4] Chiamata a auth.create per ${username} - timestamp: ${Date.now()}`);
+                // Adattiamo la chiamata al nuovo formato di auth.ts
+                // Convertiamo le nostre opzioni nel formato AuthOptions
+                const authOptions = {
+                    timeout: options.timeout || 10000,
+                    storePair: true, // Salviamo la coppia di chiavi per default
+                };
+                // Passando le credenziali nel formato corretto
+                const createResult = await this.auth.create({ alias: username, pass: password }, authOptions);
+                logDebug(`[1/4] auth.create completato con successo - pub: ${createResult} - timestamp: ${Date.now()}`);
+                // Callbacks opzionali
+                if (options.setUserpub) {
+                    options.setUserpub(createResult);
+                }
+                if (options.setSignedIn) {
+                    options.setSignedIn(true);
+                }
+                return this.createAuthResult(true, { userPub: createResult });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error
+                    ? error.message
+                    : "Errore durante la creazione dell'utente";
+                logError(`[1/4] ${errorMessage} - timestamp: ${Date.now()}`);
+                if (options.setErrorMessage) {
+                    options.setErrorMessage(errorMessage);
+                }
+                return this.createAuthResult(false, { error: errorMessage });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error
+                ? error.message
+                : "Errore durante la registrazione";
+            logError(`Errore generale durante la registrazione: ${errorMessage} - timestamp: ${Date.now()}`);
+            if (options.setErrorMessage) {
+                options.setErrorMessage(errorMessage);
+            }
+            return this.createAuthResult(false, { error: errorMessage });
+        }
+    }
+}
+// Per compatibilità retroattiva
+export const CredentialAuth = UserAuth;

package/dist/auth/metamaskAuth.js

@@ -0,0 +1,264 @@
+import { Auth } from "../gun/auth";
+import { log, logError, logWarning } from "../utils/logger";
+/**
+ * Gestisce l'autenticazione con MetaMask
+ */
+export class MetaMaskAuth {
+    constructor(gundb, gun, storage, metamask) {
+        this.signer = null;
+        this.gundb = gundb;
+        this.gun = gun;
+        this.storage = storage;
+        this.auth = new Auth(gun);
+        this.metamask = metamask;
+    }
+    /**
+     * Crea un oggetto AuthResult
+     * @param success - Se l'operazione è riuscita
+     * @param data - Dati aggiuntivi
+     * @returns AuthResult
+     */
+    createAuthResult(success, data = {}) {
+        return {
+            success,
+            ...data,
+        };
+    }
+    /**
+     * Normalizza un indirizzo Ethereum
+     * @param address - Indirizzo da normalizzare
+     * @returns Indirizzo normalizzato
+     */
+    normalizeEthAddress(address) {
+        return address.toLowerCase();
+    }
+    /**
+     * Registra un utente con MetaMask
+     * @param address - Indirizzo Ethereum da MetaMask
+     * @returns Risultato dell'autenticazione
+     */
+    /**
+     * Ottiene il signer Ethereum
+     * @returns Signer Ethereum
+     */
+    getSigner() {
+        return this.signer;
+    }
+    /**
+     * Gestisce il login con MetaMask
+     * @param address - Indirizzo Ethereum
+     * @returns Risultato del login
+     */
+    async loginWithMetaMask(address) {
+        try {
+            log(`Tentativo di login con MetaMask per l'indirizzo: ${address}`);
+            if (!this.metamask) {
+                return this.createAuthResult(false, {
+                    error: "MetaMask non supportato",
+                });
+            }
+            // Normalizza l'indirizzo
+            const normalizedAddress = this.normalizeEthAddress(address);
+            // Ottieni le credenziali precedentemente salvate (se esistono)
+            const savedCredentials = await this.getMetaMaskCredentials(normalizedAddress);
+            if (savedCredentials) {
+                log(`Credenziali MetaMask trovate per l'indirizzo: ${normalizedAddress}`);
+                // Usa le credenziali salvate per autenticare
+                return this.authenticateWithCredentials(savedCredentials.username, savedCredentials.password);
+            }
+            log(`Nessuna credenziale MetaMask trovata per l'indirizzo: ${normalizedAddress}, richiedo firma`);
+            try {
+                // Utilizza il connector MetaMask per generare le credenziali
+                const credentials = await this.metamask.generateCredentials(normalizedAddress);
+                // Salva le credenziali generate
+                this.storage.setItem(`metamask_credentials_${normalizedAddress}`, JSON.stringify(credentials));
+                // Autentica l'utente con le credenziali generate
+                return this.authenticateWithCredentials(credentials.username, credentials.password);
+            }
+            catch (signError) {
+                log("Errore durante la generazione delle credenziali MetaMask:", signError);
+                return this.createAuthResult(false, {
+                    error: signError.message || "Errore durante la firma con MetaMask",
+                });
+            }
+        }
+        catch (error) {
+            logError(`Errore durante il login con MetaMask per l'indirizzo: ${address}`, error);
+            return this.createAuthResult(false, {
+                error: error.message || "Errore sconosciuto",
+            });
+        }
+    }
+    /**
+     * Registra un utente con credenziali MetaMask
+     * @param address - Indirizzo Ethereum
+     * @returns Risultato dell'autenticazione
+     */
+    async registerUserWithMetaMask(address) {
+        try {
+            log(`Registrazione utente MetaMask con indirizzo: ${address}`);
+            // Recupero le credenziali salvate
+            const credentialsJson = this.storage.getItem(`metamask_credentials_${address}`);
+            if (!credentialsJson) {
+                logError(`Credenziali non trovate per l'indirizzo: ${address}`);
+                return this.createAuthResult(false, {
+                    error: "Credenziali MetaMask non trovate",
+                });
+            }
+            const credentials = JSON.parse(credentialsJson);
+            log(`Credenziali recuperate per: ${credentials.username}`);
+            // Verifica se l'utente esiste già
+            const isAvailable = await this.gundb.isUsernameAvailable(credentials.username);
+            if (!isAvailable) {
+                logWarning(`L'utente MetaMask con username ${credentials.username} esiste già`);
+                return this.createAuthResult(false, {
+                    error: "L'utente MetaMask esiste già",
+                });
+            }
+            log(`Utente non esistente, procedo con la registrazione: ${credentials.username}`);
+            // Pulisci eventuali sessioni precedenti
+            this.gun.user().leave();
+            log("Sessione precedente chiusa");
+            // Registra l'utente con GUN
+            log(`Tentativo registrazione GUN per: ${credentials.username}`);
+            await this.gundb.signUp(credentials.username, credentials.password);
+            log(`Utente registrato con successo: ${credentials.username}`);
+            // Ottieni la chiave pubblica dell'utente
+            const userPub = this.gun.user().is?.pub;
+            log(`Chiave pubblica utente: ${userPub}`);
+            // Salva i dati MetaMask nel profilo dell'utente
+            log("Salvataggio dati MetaMask nel profilo...");
+            await this.gun.user().get("profile").get("metamask").put({ address });
+            log("Dati MetaMask salvati nel profilo");
+            // Crea un'associazione tra indirizzo MetaMask e chiave pubblica
+            log(`Creazione associazione indirizzo-pub: metamask_${address}`);
+            await this.gun.get(`metamask_${address}`).put({ pub: userPub });
+            log("Associazione creata con successo");
+            return this.createAuthResult(true, {
+                userPub,
+                username: credentials.username,
+            });
+        }
+        catch (error) {
+            logError("Errore durante la registrazione dell'utente MetaMask:", error);
+            return this.createAuthResult(false, {
+                error: error.message || "Errore durante la registrazione dell'utente",
+            });
+        }
+    }
+    /**
+     * Gestisce la registrazione con MetaMask
+     * @param address - Indirizzo Ethereum
+     * @returns Risultato della registrazione
+     */
+    async signUpWithMetaMask(address) {
+        try {
+            log("Tentativo di registrazione con MetaMask:", address);
+            if (!this.metamask) {
+                logError("MetaMask non supportato");
+                return this.createAuthResult(false, {
+                    error: "MetaMask non supportato",
+                });
+            }
+            // Normalizza l'indirizzo
+            const normalizedAddress = this.normalizeEthAddress(address);
+            log(`Indirizzo normalizzato: ${normalizedAddress}`);
+            try {
+                // Utilizza il connector MetaMask per generare le credenziali
+                log("Generazione credenziali MetaMask...");
+                const credentials = await this.metamask.generateCredentials(normalizedAddress);
+                log("Credenziali generate con successo:", credentials.username);
+                // Salva le credenziali generate
+                this.storage.setItem(`metamask_credentials_${normalizedAddress}`, JSON.stringify(credentials));
+                log("Credenziali salvate nel localStorage");
+                // Registra l'utente con l'indirizzo normalizzato
+                log("Avvio registrazione utente con indirizzo normalizzato...");
+                const result = await this.registerUserWithMetaMask(normalizedAddress);
+                log("Risultato registrazione:", result);
+                if (result.success) {
+                    log("Registrazione completata con successo per:", normalizedAddress);
+                }
+                else {
+                    logError("Registrazione fallita per:", normalizedAddress, result.error);
+                }
+                return result;
+            }
+            catch (error) {
+                logError("Errore specifico durante la registrazione:", error);
+                return this.createAuthResult(false, {
+                    error: error.message || "Errore nella generazione delle credenziali MetaMask",
+                });
+            }
+        }
+        catch (error) {
+            logError("Errore generale durante la registrazione con MetaMask:", error);
+            return this.createAuthResult(false, {
+                error: error.message || "Errore sconosciuto",
+            });
+        }
+    }
+    /**
+     * Ottiene le credenziali MetaMask salvate per un indirizzo
+     * @param address - Indirizzo Ethereum
+     * @returns Credenziali o null se non trovate
+     */
+    async getMetaMaskCredentials(address) {
+        try {
+            const normalizedAddress = this.normalizeEthAddress(address);
+            const storedData = this.storage.getItem(`metamask_credentials_${normalizedAddress}`);
+            if (!storedData) {
+                const credentials = await this.metamask.generateCredentials(normalizedAddress);
+                return {
+                    username: credentials.username,
+                    password: credentials.password,
+                };
+            }
+            const credentials = JSON.parse(storedData);
+            return {
+                username: credentials.username,
+                password: credentials.password,
+            };
+        }
+        catch (error) {
+            logError("Errore durante il recupero delle credenziali MetaMask:", error);
+            return null;
+        }
+    }
+    /**
+     * Autentica un utente con username e password
+     * @param username - Nome utente
+     * @param password - Password
+     * @returns Risultato dell'autenticazione
+     */
+    async authenticateWithCredentials(username, password) {
+        try {
+            // Esegui login con Gun direttamente
+            await new Promise((resolve, reject) => {
+                this.gun.user().auth(username, password, (ack) => {
+                    if (ack.err) {
+                        reject(new Error(ack.err));
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+            // Ottieni la chiave pubblica
+            const userPub = this.gun.user().is?.pub;
+            if (!userPub) {
+                return this.createAuthResult(false, {
+                    error: "Impossibile ottenere la chiave pubblica dell'utente",
+                });
+            }
+            return this.createAuthResult(true, {
+                userPub,
+                username
+            });
+        }
+        catch (error) {
+            return this.createAuthResult(false, {
+                error: error.message || "Errore durante l'autenticazione",
+            });
+        }
+    }
+}