shogun-core 0.0.1

package/dist/stealth/stealth.js

@@ -0,0 +1,289 @@
+/**
+ * Gestisce la logica stealth usando Gun e SEA
+ */
+import { ethers } from 'ethers';
+class Stealth {
+    constructor() {
+        this.lastEphemeralKeyPair = null;
+        this.lastMethodUsed = "unknown";
+        this.STEALTH_DATA_TABLE = "Stealth";
+    }
+    /**
+     * Rimuove il tilde (~) iniziale dalla chiave pubblica se presente
+     */
+    formatPublicKey(publicKey) {
+        if (!publicKey) {
+            return null;
+        }
+        const trimmedKey = publicKey.trim();
+        if (!trimmedKey) {
+            return null;
+        }
+        if (!/^[~]?[\w+/=\-_.]+$/.test(trimmedKey)) {
+            return null;
+        }
+        return trimmedKey.startsWith("~") ? trimmedKey.slice(1) : trimmedKey;
+    }
+    /**
+     * Crea un nuovo account stealth
+     */
+    async createAccount() {
+        try {
+            // Genera una nuova coppia di chiavi
+            const keyPair = await Gun.SEA.pair();
+            if (!keyPair || !keyPair.pub || !keyPair.priv || !keyPair.epub || !keyPair.epriv) {
+                throw new Error("Failed to generate stealth key pair");
+            }
+            return {
+                pub: keyPair.pub,
+                priv: keyPair.priv,
+                epub: keyPair.epub,
+                epriv: keyPair.epriv
+            };
+        }
+        catch (error) {
+            console.error("Error creating stealth account:", error);
+            throw error;
+        }
+    }
+    /**
+     * Genera un indirizzo stealth per la chiave pubblica del destinatario
+     */
+    async generateStealthAddress(recipientPublicKey) {
+        if (!recipientPublicKey) {
+            throw new Error("Invalid keys: missing or invalid parameters");
+        }
+        // Prima creiamo le chiavi stealth se non esistono
+        const stealthKeys = await this.createAccount();
+        if (!stealthKeys) {
+            throw new Error("Failed to create stealth keys");
+        }
+        console.log("Generazione indirizzo stealth con chiavi:", {
+            userPub: stealthKeys.pub,
+            userEpub: stealthKeys.epub,
+            recipientPub: recipientPublicKey
+        });
+        return new Promise((resolve, reject) => {
+            // Genera una coppia di chiavi effimere
+            Gun.SEA.pair((ephemeralKeyPair) => {
+                if (!ephemeralKeyPair?.epub || !ephemeralKeyPair?.epriv) {
+                    reject(new Error("Invalid ephemeral keys"));
+                    return;
+                }
+                console.log("Chiavi effimere generate:", ephemeralKeyPair);
+                // Memorizza l'intero pair per debug
+                this.lastEphemeralKeyPair = ephemeralKeyPair;
+                // MODIFICA CRUCIALE: Usiamo l'interfaccia definita
+                const stealthData = {
+                    recipientPublicKey,
+                    ephemeralKeyPair: ephemeralKeyPair,
+                    timestamp: Date.now()
+                };
+                // Usa questo formato specifico per il parametro di SEA.secret
+                const keyForSecret = {
+                    epub: ephemeralKeyPair.epub,
+                    epriv: ephemeralKeyPair.epriv
+                };
+                console.log("Formato chiave per segreto (generazione):", JSON.stringify(keyForSecret));
+                Gun.SEA.secret(recipientPublicKey, keyForSecret, async (sharedSecret) => {
+                    console.log("Segreto condiviso generato correttamente con le chiavi del destinatario");
+                    console.log("Formato di input usato:", {
+                        recipientPublicKey,
+                        ephemeralKeyObject: keyForSecret
+                    });
+                    try {
+                        // Genera l'indirizzo stealth usando il segreto condiviso
+                        const stealthPrivateKey = ethers.keccak256(ethers.toUtf8Bytes(sharedSecret));
+                        const stealthWallet = new ethers.Wallet(stealthPrivateKey);
+                        console.log("Indirizzo stealth generato:", {
+                            address: stealthWallet.address,
+                            ephemeralPubKey: ephemeralKeyPair.epub,
+                            recipientPublicKey
+                        });
+                        // Salva il metodo utilizzato e il segreto condiviso
+                        this.lastMethodUsed = "standard";
+                        stealthData.method = "standard";
+                        stealthData.sharedSecret = sharedSecret;
+                        // Salva i dati nella memoria locale per consentire l'apertura
+                        this.saveStealthHistory(stealthWallet.address, stealthData);
+                        resolve({
+                            stealthAddress: stealthWallet.address,
+                            ephemeralPublicKey: ephemeralKeyPair.epub,
+                            recipientPublicKey
+                        });
+                    }
+                    catch (error) {
+                        reject(new Error(`Error creating stealth address: ${error instanceof Error ? error.message : "unknown error"}`));
+                    }
+                });
+            });
+        });
+    }
+    /**
+     * Apre un indirizzo stealth derivando la chiave privata
+     */
+    async openStealthAddress(stealthAddress, ephemeralPublicKey, pair) {
+        console.log(`Tentativo di apertura dell'indirizzo stealth ${stealthAddress}`);
+        // Prima controlla se abbiamo i dati salvati in locale
+        try {
+            const stealthHistory = localStorage.getItem('stealthHistory') || '{}';
+            const history = JSON.parse(stealthHistory);
+            console.log(`Controllo se esistono dati per l'indirizzo ${stealthAddress} in localStorage`);
+            if (history[stealthAddress]) {
+                console.log("Trovati dati stealth salvati localmente:", history[stealthAddress]);
+                const data = history[stealthAddress];
+                // Se abbiamo il segreto condiviso, possiamo derivare direttamente il wallet
+                if (data.sharedSecret) {
+                    console.log("Derivazione diretta dal segreto condiviso salvato");
+                    const stealthPrivateKey = ethers.keccak256(ethers.toUtf8Bytes(data.sharedSecret));
+                    return new ethers.Wallet(stealthPrivateKey);
+                }
+                // Se abbiamo il metodo e le chiavi effimere complete, proviamo a rigenerare il segreto
+                if (data.method && data.ephemeralKeyPair) {
+                    console.log("Tentativo di rigenerazione del segreto con il metodo:", data.method);
+                    if (data.method === "standard") {
+                        // Usa il formato specifico che abbiamo usato durante la generazione
+                        const keyForSecret = {
+                            epub: data.ephemeralKeyPair.epub,
+                            epriv: data.ephemeralKeyPair.epriv
+                        };
+                        console.log("Rigenerazione con formato esplicito:", JSON.stringify(keyForSecret));
+                        return new Promise((resolve, reject) => {
+                            Gun.SEA.secret(data.recipientPublicKey, keyForSecret, async (secret) => {
+                                if (!secret) {
+                                    return reject(new Error("Impossibile rigenerare il segreto condiviso"));
+                                }
+                                try {
+                                    const stealthPrivateKey = ethers.keccak256(ethers.toUtf8Bytes(secret));
+                                    const wallet = new ethers.Wallet(stealthPrivateKey);
+                                    // Verifica che il wallet generato corrisponda all'indirizzo
+                                    if (wallet.address.toLowerCase() === stealthAddress.toLowerCase()) {
+                                        console.log("Rigenerazione riuscita! Indirizzo corrispondente:", wallet.address);
+                                        return resolve(wallet);
+                                    }
+                                    else {
+                                        console.log("Indirizzo generato non corrispondente:", wallet.address);
+                                        // Continua con i metodi standard
+                                    }
+                                }
+                                catch (e) {
+                                    console.error("Errore durante la derivazione:", e);
+                                    // Continua con i metodi standard
+                                }
+                            });
+                        });
+                    }
+                }
+            }
+            else {
+                console.log("Nessun dato stealth trovato in localStorage per questo indirizzo");
+            }
+        }
+        catch (e) {
+            console.log("Errore nel recupero dei dati da localStorage:", e);
+        }
+        // Se non abbiamo dati salvati, procedi con il metodo normale
+        if (!stealthAddress || !ephemeralPublicKey) {
+            throw new Error("Missing parameters: stealthAddress or ephemeralPublicKey");
+        }
+        // Recupera le chiavi stealth dell'utente
+        let keys = pair;
+        console.log("Apertura indirizzo stealth con chiavi recuperate:", {
+            stealthAddress,
+            ephemeralPublicKey,
+            userKeysFound: !!keys
+        });
+        return new Promise((resolve, reject) => {
+            // Prova tutte le possibili combinazioni di parametri per SEA.secret
+            const attempts = [
+                // Tentativo 1: Metodo standard - ephemeral keys first
+                () => {
+                    console.log("Tentativo 1: Metodo standard con chiavi effimere");
+                    return new Promise((res) => {
+                        Gun.SEA.secret(ephemeralPublicKey, keys, async (secret) => {
+                            try {
+                                if (!secret) {
+                                    return res(null);
+                                }
+                                const wallet = this.deriveWalletFromSecret(secret);
+                                if (wallet.address.toLowerCase() === stealthAddress.toLowerCase()) {
+                                    return res(wallet);
+                                }
+                                return res(null);
+                            }
+                            catch (e) {
+                                return res(null);
+                            }
+                        });
+                    });
+                }
+            ];
+            // Funzione helper per derivare il wallet dal secret
+            this.deriveWalletFromSecret = (secret) => {
+                const stealthPrivateKey = ethers.keccak256(ethers.toUtf8Bytes(secret));
+                return new ethers.Wallet(stealthPrivateKey);
+            };
+            // Esegui tutti i tentativi in sequenza
+            const tryNextAttempt = async (index = 0) => {
+                if (index >= attempts.length) {
+                    return reject(new Error("Tutti i metodi di derivazione dell'indirizzo stealth hanno fallito"));
+                }
+                const wallet = await attempts[index]();
+                if (wallet) {
+                    console.log(`Metodo ${index + 1} ha funzionato!`);
+                    return resolve(wallet);
+                }
+                tryNextAttempt(index + 1);
+            };
+            tryNextAttempt();
+        });
+    }
+    /**
+     * Ottiene la chiave pubblica da un indirizzo
+     */
+    async getPublicKey(publicKey) {
+        // Formatta la chiave pubblica
+        return this.formatPublicKey(publicKey);
+    }
+    /**
+     * Salva le chiavi stealth nel profilo utente
+     * @returns Le chiavi stealth da salvare
+     */
+    prepareStealthKeysForSaving(stealthKeyPair) {
+        if (!stealthKeyPair?.pub || !stealthKeyPair?.priv || !stealthKeyPair?.epub || !stealthKeyPair?.epriv) {
+            throw new Error("Invalid stealth keys: missing or incomplete parameters");
+        }
+        return stealthKeyPair;
+    }
+    /**
+     * Deriva un wallet dal segreto condiviso
+     */
+    deriveWalletFromSecret(secret) {
+        const stealthPrivateKey = ethers.keccak256(ethers.toUtf8Bytes(secret));
+        return new ethers.Wallet(stealthPrivateKey);
+    }
+    /**
+     * Salva i dati stealth nella localStorage
+     */
+    saveStealthHistory(address, data) {
+        // Salva nella localStorage
+        try {
+            const stealthHistory = localStorage.getItem('stealthHistory') || '{}';
+            const history = JSON.parse(stealthHistory);
+            history[address] = data;
+            localStorage.setItem('stealthHistory', JSON.stringify(history));
+            console.log(`Dati stealth salvati per l'indirizzo ${address}`);
+        }
+        catch (e) {
+            console.error("Errore nel salvataggio dei dati stealth:", e);
+        }
+    }
+}
+// Rendi disponibile globalmente
+if (typeof window !== 'undefined') {
+    window.Stealth = Stealth;
+}
+else if (typeof global !== 'undefined') {
+    global.Stealth = Stealth;
+}
+export { Stealth };

package/dist/storage/storage.js

@@ -0,0 +1,93 @@
+// Implementazione della Storage basata su StorageMock
+export class Storage {
+    constructor() {
+        this.store = new Map();
+        // Se in ambiente browser, tenta di caricare i dati da localStorage
+        if (typeof localStorage !== "undefined") {
+            try {
+                const storedPair = localStorage.getItem("shogun_keypair");
+                if (storedPair) {
+                    this.store.set("keypair", JSON.parse(storedPair));
+                }
+            }
+            catch (error) {
+                console.error("Errore nel recuperare i dati da localStorage:", error);
+            }
+        }
+    }
+    async getPair() {
+        return this.getPairSync();
+    }
+    getPairSync() {
+        return this.store.get("keypair") || null;
+    }
+    async setPair(pair) {
+        this.store.set("keypair", pair);
+        // Se in ambiente browser, salva anche nel localStorage
+        if (typeof localStorage !== "undefined") {
+            try {
+                localStorage.setItem("shogun_keypair", JSON.stringify(pair));
+            }
+            catch (error) {
+                console.error("Errore nel salvare i dati nel localStorage:", error);
+            }
+        }
+    }
+    clearAll() {
+        this.store.clear();
+        // Se in ambiente browser, pulisci anche localStorage
+        if (typeof localStorage !== "undefined") {
+            try {
+                localStorage.removeItem("shogun_keypair");
+            }
+            catch (error) {
+                console.error("Errore nel rimuovere i dati dal localStorage:", error);
+            }
+        }
+    }
+    // Metodi per compatibilità con l'interfaccia Storage standard
+    getItem(key) {
+        const value = this.store.get(key);
+        return value !== undefined ? JSON.stringify(value) : null;
+    }
+    setItem(key, value) {
+        try {
+            const parsedValue = JSON.parse(value);
+            this.store.set(key, parsedValue);
+            // Se in ambiente browser, salva anche nel localStorage
+            if (typeof localStorage !== "undefined") {
+                try {
+                    localStorage.setItem(key, value);
+                }
+                catch (error) {
+                    console.error(`Errore nel salvare ${key} nel localStorage:`, error);
+                }
+            }
+        }
+        catch (error) {
+            // Se non è JSON valido, salva come stringa
+            this.store.set(key, value);
+            // Se in ambiente browser, salva anche nel localStorage
+            if (typeof localStorage !== "undefined") {
+                try {
+                    localStorage.setItem(key, value);
+                }
+                catch (error) {
+                    console.error(`Errore nel salvare ${key} nel localStorage:`, error);
+                }
+            }
+        }
+    }
+    removeItem(key) {
+        this.store.delete(key);
+        // Se in ambiente browser, rimuovi anche dal localStorage
+        if (typeof localStorage !== "undefined") {
+            try {
+                localStorage.removeItem(key);
+            }
+            catch (error) {
+                console.error(`Errore nel rimuovere ${key} dal localStorage:`, error);
+            }
+        }
+    }
+}

package/dist/types/auth/credentialAuth.d.ts

@@ -0,0 +1,56 @@
+import { GunDB } from "../gun/gun";
+import { Storage } from "../storage/storage";
+import { AuthResult } from "../gun/auth";
+/**
+ * Classe per l'autenticazione con username e password
+ * Livello più alto di astrazione per gestire l'autenticazione utente
+ */
+export declare class UserAuth {
+    private gundb;
+    private gun;
+    private storage;
+    private auth;
+    constructor(gundb: GunDB, gun: any, storage: Storage);
+    /**
+     * Crea un risultato di autenticazione
+     * @param success - Indica se l'autenticazione è riuscita
+     * @param data - Dati aggiuntivi
+     * @returns Risultato dell'autenticazione
+     */
+    private createAuthResult;
+    /**
+     * 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
+     */
+    login(username: string, password: string, options?: {
+        setUserpub?: (pub: string) => void;
+        setSignedIn?: (signedIn: boolean) => void;
+        timeout?: number;
+        attemptCleanup?: boolean;
+        retryCount?: number;
+    }): Promise<AuthResult>;
+    /**
+     * 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
+     */
+    register(username: string, password: string, passwordConfirmation: string, options?: {
+        setErrorMessage?: (message: string) => void;
+        setUserpub?: (pub: string) => void;
+        setSignedIn?: (signedIn: boolean) => void;
+        messages?: {
+            [key: string]: string;
+        };
+        forceResetUser?: boolean;
+        timeout?: number;
+        attemptCleanup?: boolean;
+        cleanupFirst?: boolean;
+    }): Promise<AuthResult>;
+}
+export declare const CredentialAuth: typeof UserAuth;

package/dist/types/auth/metamaskAuth.d.ts

@@ -0,0 +1,74 @@
+import { AuthResult } from "../gun/auth";
+import { GunDB } from "../gun/gun";
+import { Storage } from "../storage/storage";
+import { MetaMask } from "../connector/metamask";
+import { ethers } from "ethers";
+/**
+ * Gestisce l'autenticazione con MetaMask
+ */
+export declare class MetaMaskAuth {
+    private gun;
+    private gundb;
+    private storage;
+    private auth;
+    private metamask;
+    private signer;
+    constructor(gundb: GunDB, gun: any, storage: Storage, metamask: MetaMask);
+    /**
+     * Crea un oggetto AuthResult
+     * @param success - Se l'operazione è riuscita
+     * @param data - Dati aggiuntivi
+     * @returns AuthResult
+     */
+    private createAuthResult;
+    /**
+     * Normalizza un indirizzo Ethereum
+     * @param address - Indirizzo da normalizzare
+     * @returns Indirizzo normalizzato
+     */
+    private normalizeEthAddress;
+    /**
+     * Registra un utente con MetaMask
+     * @param address - Indirizzo Ethereum da MetaMask
+     * @returns Risultato dell'autenticazione
+     */
+    /**
+     * Ottiene il signer Ethereum
+     * @returns Signer Ethereum
+     */
+    getSigner(): ethers.Signer | null;
+    /**
+     * Gestisce il login con MetaMask
+     * @param address - Indirizzo Ethereum
+     * @returns Risultato del login
+     */
+    loginWithMetaMask(address: string): Promise<AuthResult>;
+    /**
+     * Registra un utente con credenziali MetaMask
+     * @param address - Indirizzo Ethereum
+     * @returns Risultato dell'autenticazione
+     */
+    private registerUserWithMetaMask;
+    /**
+     * Gestisce la registrazione con MetaMask
+     * @param address - Indirizzo Ethereum
+     * @returns Risultato della registrazione
+     */
+    signUpWithMetaMask(address: string): Promise<AuthResult>;
+    /**
+     * Ottiene le credenziali MetaMask salvate per un indirizzo
+     * @param address - Indirizzo Ethereum
+     * @returns Credenziali o null se non trovate
+     */
+    getMetaMaskCredentials(address: string): Promise<{
+        username: string;
+        password: string;
+    } | null>;
+    /**
+     * Autentica un utente con username e password
+     * @param username - Nome utente
+     * @param password - Password
+     * @returns Risultato dell'autenticazione
+     */
+    private authenticateWithCredentials;
+}

package/dist/types/auth/webauthnAuth.d.ts

@@ -0,0 +1,83 @@
+import { GunDB } from "../gun/gun";
+import { Storage } from "../storage/storage";
+import { Webauthn } from "../webauthn/webauthn";
+import { AuthResult } from "../types/shogun";
+/**
+ * Classe che gestisce l'autenticazione con WebAuthn
+ */
+export declare class WebAuthnAuth {
+    private gundb;
+    private gun;
+    private storage;
+    private webauthn;
+    private auth;
+    constructor(gundb: GunDB, gun: any, storage: Storage, webauthn: Webauthn);
+    /**
+     * Crea un risultato di autenticazione
+     * @param success - Indica se l'autenticazione è riuscita
+     * @param data - Dati aggiuntivi
+     * @returns Risultato dell'autenticazione
+     */
+    private createAuthResult;
+    /**
+     * Verifica se WebAuthn è supportato
+     * @returns true se WebAuthn è supportato, false altrimenti
+     */
+    isWebAuthnSupported(): boolean;
+    /**
+     * Effettua il login con WebAuthn
+     * @param username - Nome utente
+     * @returns Risultato del login
+     */
+    loginWithWebAuthn(username: string, credentialId: string, options?: {
+        setUserpub?: (pub: string) => void;
+        setSignedIn?: (signedIn: boolean) => void;
+    }): Promise<AuthResult>;
+    /**
+     * Registra un nuovo utente con WebAuthn
+     * @param username - Nome utente
+     * @returns Risultato della registrazione
+     */
+    registerWithWebAuthn(username: string, credentialId: string, options?: {
+        setErrorMessage?: (message: string) => void;
+        setUserpub?: (pub: string) => void;
+        setSignedIn?: (signedIn: boolean) => void;
+    }): Promise<AuthResult>;
+    /**
+     * Recupera le credenziali WebAuthn
+     * @param username - Nome utente
+     * @returns Credenziali WebAuthn o null se non trovate
+     */
+    private getWebAuthnCredentials;
+    /**
+     * Salva le credenziali WebAuthn
+     * @param username - Nome utente
+     * @param credentials - Credenziali WebAuthn
+     */
+    private saveWebAuthnCredentials;
+    /**
+     * Gestisce il login con WebAuthn
+     */
+    handleWebAuthnLogin(username: string, credentials: {
+        id: string;
+        rawId: string;
+        type: string;
+        response: any;
+    }, options?: {
+        setUserpub?: (pub: string) => void;
+        setSignedIn?: (signedIn: boolean) => void;
+    }): Promise<AuthResult>;
+    /**
+     * Gestisce la registrazione con WebAuthn
+     */
+    handleWebAuthnRegistration(username: string, credentials: {
+        id: string;
+        rawId: string;
+        type: string;
+        response: any;
+    }, options?: {
+        setErrorMessage?: (message: string) => void;
+        setUserpub?: (pub: string) => void;
+        setSignedIn?: (signedIn: boolean) => void;
+    }): Promise<AuthResult>;
+}

package/dist/types/auth.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config.d.ts

@@ -0,0 +1,39 @@
+export declare const CONFIG: {
+    TIMEOUT: {
+        AUTH: number;
+        GUN: number;
+        WALLET: number;
+    };
+    PATHS: {
+        DERIVATION_BASE: string;
+        DEFAULT_INDEX: number;
+    };
+    STORAGE_KEYS: {
+        ENTROPY: string;
+        GUN_PAIR: string;
+        WALLET_PATHS: string;
+        SESSION: string;
+    };
+    GUN_TABLES: {
+        USERS: string;
+        WALLET_PATHS: string;
+        AUTHENTICATIONS: string;
+        WEBAUTHN: string;
+        STEALTH: string;
+        MOM_MESSAGES: string;
+        MOM_MESSAGE_BLOCKS: string;
+        MOM_MESSAGE_REPLIES: string;
+        MOM_MESSAGE_UPDATES: string;
+        MOM_MESSAGE_DELETIONS: string;
+    };
+    AUTH: {
+        MIN_PASSWORD_LENGTH: number;
+        MAX_USERNAME_LENGTH: number;
+        MIN_USERNAME_LENGTH: number;
+    };
+    PREFIX: string;
+    PEERS: string[];
+    MESSAGE_TO_SIGN: string;
+    DEFAULT_RPC_URL: string;
+};
+export default CONFIG;