Grouped the logs for decryptAttribute func

src/services/service.ts

@@ -809,7 +809,6 @@ export default class Services {
       console.error(`[Services:parseCipher] 💥 Échec critique du déchiffrement: ${e}`);
       console.warn(`[Services:parseCipher] Contrainte d'anonymat: L'expéditeur est inconnu.`);
 
-      // --- 🚨 NOUVELLE LOGIQUE 🚨 ---
       // On ne supprime rien. On lève juste un drapeau pour
       // forcer 'ensureConnections' à se méfier de la BDD.
       console.warn(`[Services:parseCipher] 🚩 ACTION: Levée du drapeau 'secretsAreCompromised'.`);
@@ -817,7 +816,6 @@ export default class Services {
     }
   }
 
-  // --- AMÉLIORATION: Refactorisé en sous-fonctions ---
   async parseNewTx(newTxMsg: string) {
     console.log('[Services:parseNewTx] 📄 Nouveau message NewTx reçu.');
     const parsedMsg: NewTxMessage = JSON.parse(newTxMsg);
@@ -1714,18 +1712,24 @@ export default class Services {
   }
 
   async decryptAttribute(processId: string, state: ProcessState, attribute: string): Promise<any | null> {
-    console.log(`[Services:decryptAttribute] 🔑 Tentative de déchiffrement de l'attribut '${attribute}' pour le processus ${processId}`);
+    // Le groupe principal est "collapsed" pour ne pas polluer la console par défaut
+    console.groupCollapsed(`[Services:decryptAttribute] 🔑 Déchiffrement de '${attribute}' (Process: ${processId})`);
+
+    try {
       let hash = state.pcd_commitment[attribute];
       if (!hash) {
-      console.warn(`[Services:decryptAttribute] ⚠️ L'attribut '${attribute}' n'existe pas (pas de hash).`);
+        console.warn(`⚠️ L'attribut n'existe pas (pas de hash).`);
-      return null;
+        return null; // Le 'finally' s'exécutera
       }
       let key = state.keys[attribute];
       const pairingProcessId = this.getPairingProcessId();
 
       // If key is missing, request an update and then retry
       if (!key) {
-      console.warn(`[Services:decryptAttribute] ⚠️ Clé manquante pour '${attribute}'. Vérification de l'accès et demande aux pairs...`);
+        // On crée un sous-groupe pour la logique de récupération de la clé
+        console.group(`🔐 Gestion de la clé manquante pour '${attribute}'`);
+
+        console.warn(`Vérification de l'accès et demande aux pairs...`);
         const roles = state.roles;
         let hasAccess = false;
         // If we're not supposed to have access to this attribute, ignore
@@ -1742,30 +1746,33 @@ export default class Services {
         }
 
         if (!hasAccess) {
-        console.log(`[Services:decryptAttribute] ⛔ Accès non autorisé à '${attribute}'. Abandon.`);
+          console.log(`⛔ Accès non autorisé. Abandon.`);
-        return null;
+          console.groupEnd(); // Ferme le sous-groupe "Gestion de la clé manquante"
+          return null; // Le 'finally' principal s'exécutera
         }
 
         const process = await this.getProcess(processId);
         if (!process) {
-        console.error(`[Services:decryptAttribute] 💥 Impossible de trouver le processus ${processId} pour ensureConnections.`);
+          console.error(`💥 Impossible de trouver le processus ${processId} pour ensureConnections.`);
+          console.groupEnd(); // Ferme le sous-groupe "Gestion de la clé manquante"
           return null;
         }
 
         await this.ensureConnections(process);
         // We should have the key, so we're going to ask other members for it
-      console.log(`[Services:decryptAttribute] 🗣️ Demande de données aux pairs pour '${attribute}'...`);
+        console.log(`🗣️ Demande de données aux pairs...`);
         await this.requestDataFromPeers(processId, [state.state_id], [state.roles]);
 
         const maxRetries = 5;
         const retryDelay = 500; // delay in milliseconds
         let retries = 0;
 
+        // On crée un sous-groupe replié pour la boucle de réessai (potentiellement verbeuse)
+        console.groupCollapsed(`⏳ Boucle d'attente de la clé (max ${maxRetries} tentatives)`);
         while ((!hash || !key) && retries < maxRetries) {
-        console.log(`[Services:decryptAttribute] ⏳ Attente de la clé... (Tentative ${retries + 1}/${maxRetries})`);
+          console.log(`(Tentative ${retries + 1}/${maxRetries})...`);
           await new Promise((resolve) => setTimeout(resolve, retryDelay));
           // Re-read hash and key after waiting
-        // AMÉLIORATION: On doit relire l'état complet depuis la BDD/cache, car 'state' est un instantané
           const updatedProcess = await this.getProcess(processId);
           const updatedState = this.getStateFromId(updatedProcess, state.state_id);
           if (updatedState) {
@@ -1774,10 +1781,13 @@ export default class Services {
           }
           retries++;
         }
-    }
+        console.groupEnd(); // Ferme le sous-groupe "Boucle d'attente"
+
+        console.groupEnd(); // Ferme le sous-groupe "Gestion de la clé manquante"
+      } // Fin de if (!key)
 
       if (hash && key) {
-      console.log(`[Services:decryptAttribute] ℹ️ Clé et hash trouvés pour '${attribute}'. Tentative de déchiffrement...`);
+        console.log(`ℹ️ Clé et hash trouvés. Tentative de déchiffrement...`);
         const blob = await this.getBlobFromDb(hash);
         if (blob) {
           // Decrypt the data
@@ -1791,22 +1801,30 @@ export default class Services {
             if (clear) {
               // deserialize the result to get the actual data
               const decoded = this.sdkClient.decode_value(clear);
-            console.log(`[Services:decryptAttribute] ✅ Attribut '${attribute}' déchiffré avec succès.`);
+              console.log(`✅ Attribut '${attribute}' déchiffré avec succès.`);
-            return decoded;
+              return decoded; // Le 'finally' s'exécutera
             } else {
               throw new Error('decrypt_data returned null');
             }
           } catch (e) {
-          console.error(`[Services:decryptAttribute] 💥 Échec du déchiffrement (decrypt_data): ${e}`);
+            console.error(`💥 Échec du déchiffrement (decrypt_data): ${e}`);
           }
         } else {
-        console.error(`[Services:decryptAttribute] 💥 Échec: Blob non trouvé en BDD pour le hash ${hash}`);
+          console.error(`💥 Échec: Blob non trouvé en BDD pour le hash ${hash}`);
         }
       } else {
-      console.error(`[Services:decryptAttribute] 💥 Échec: Clé ou hash manquant après ${maxRetries} tentatives pour '${attribute}'.`);
+        console.error(`💥 Échec: Clé ou hash manquant après ${maxRetries} tentatives pour '${attribute}'.`);
       }
 
+      return null; // Le 'finally' s'exécutera
+    } catch (error) {
+      // Intercepte les erreurs inattendues non gérées
+      console.error(`💥 Erreur inattendue dans decryptAttribute:`, error);
       return null;
+    } finally {
+      // Ce bloc est TOUJOURS exécuté, assurant que le groupe est fermé.
+      console.groupEnd();
+    }
   }
 
   getNotifications(): any[] | null {