Fix pairing system: Add waitForPairingCommitment with device sync and update documentation

- Add waitForPairingCommitment function with automatic device synchronization
- Integrate updateDevice() call in waitForPairingCommitment for better sync
- Increase retry attempts to 30 with 2s delay (60s total wait time)
- Add detailed logging for pairing process synchronization
- Update router to call waitForPairingCommitment before confirmPairing
- Remove redundant updateDevice() call from router
- Update PAIRING_SYSTEM_ANALYSIS.md with coherence issues and recommendations
- Identify joiner flow inconsistencies requiring future fixes

doc/PAIRING_SYSTEM_ANALYSIS.md

@@ -0,0 +1,277 @@
+# Analyse du Système de Pairing - Version Actuelle
+
+## Vue d'ensemble
+
+Ce document résume l'analyse complète du système de pairing et les corrections apportées pour résoudre les problèmes identifiés.
+
+## Problèmes Identifiés et Solutions
+
+### 1. Problème de `checkConnections` pour le Pairing
+
+**Problème** : La méthode `checkConnections` a été mise à jour il y a un mois pour prendre un `Process` et un `stateId` au lieu d'une liste de membres, mais la gestion des processus de pairing était défaillante.
+
+**Symptômes** :
+- `checkConnections` échouait pour les processus de pairing
+- Les adresses des membres n'étaient pas correctement récupérées
+- Erreur "Not a pairing process" même pour des processus de pairing valides
+
+**Solution Appliquée** :
+```typescript
+// Correction dans checkConnections pour gérer les pairedAddresses
+if (members.size === 0) {
+  // This must be a pairing process
+  let publicData: Record<string, any> | null = null;
+  if (!stateId) {
+    publicData = process.states[process.states.length - 2]?.public_data;
+  } else {
+    publicData = process.states.find(state => state.state_id === stateId)?.public_data || null;
+  }
+
+  // If pairedAddresses is not in the current state, look in previous states
+  if (!publicData || !publicData['pairedAddresses']) {
+    // Look for pairedAddresses in previous states
+    for (let i = process.states.length - 1; i >= 0; i--) {
+      const state = process.states[i];
+      if (state.public_data && state.public_data['pairedAddresses']) {
+        publicData = state.public_data;
+        break;
+      }
+    }
+  }
+
+  const decodedAddresses = this.decodeValue(publicData['pairedAddresses']);
+  members.add({ sp_addresses: decodedAddresses });
+}
+```
+
+### 2. Problème de `confirmPairing` avec `getPairingProcessId()`
+
+**Problème** : `confirmPairing` échouait car `getPairingProcessId()` utilisait `sdkClient.get_pairing_process_id()` qui n'était pas encore disponible car le processus de pairing n'était pas encore committé.
+
+**Symptômes** :
+- Erreur "Failed to get pairing process" dans `confirmPairing`
+- Le SDK n'avait pas encore le processus de pairing disponible
+- Échec de confirmation du pairing
+
+**Solution Appliquée** :
+```typescript
+public async confirmPairing(pairingId?: string) {
+  try {
+    console.log('confirmPairing');
+    let processId: string;
+    if (pairingId) {
+      processId = pairingId;
+      console.log('pairingId (provided):', processId);
+    } else if (this.processId) {
+      processId = this.processId;
+      console.log('pairingId (from stored processId):', processId);
+    } else {
+      // Try to get pairing process ID, with retry if it fails
+      let retries = 3;
+      while (retries > 0) {
+        try {
+          processId = this.getPairingProcessId();
+          console.log('pairingId (from SDK):', processId);
+          break;
+        } catch (e) {
+          retries--;
+          if (retries === 0) throw e;
+          console.log(`Failed to get pairing process ID, retrying... (${retries} attempts left)`);
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+      }
+    }
+    // ... rest of the method
+  } catch (e) {
+    console.error('Failed to confirm pairing');
+    return;
+  }
+}
+```
+
+### 3. Problème de `pairing_process_commitment` à `null`
+
+**Problème** : Le `pairing_process_commitment` restait à `null` dans le device dump car le device n'était pas synchronisé avec l'état committé du processus.
+
+**Symptômes** :
+- `pairing_process_commitment: null` dans le device dump
+- Le commitment n'était pas synchronisé avec l'état committé du processus
+- Échec de la confirmation du pairing
+
+**Solution Appliquée** :
+```typescript
+// Intégration de updateDevice() dans waitForPairingCommitment
+public async waitForPairingCommitment(processId: string, maxRetries: number = 10, retryDelay: number = 1000): Promise<void> {
+  console.log(`Waiting for pairing process ${processId} to be committed...`);
+
+  // First, try to update the device to sync with the committed state
+  try {
+    await this.updateDevice();
+    console.log('Device updated, checking commitment...');
+  } catch (e) {
+    console.log('Failed to update device, continuing with polling...', e);
+  }
+
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const device = this.dumpDeviceFromMemory();
+      console.log(`Attempt ${i + 1}/${maxRetries}: pairing_process_commitment =`, device.pairing_process_commitment);
+
+      // Check if the commitment is set and not null/empty
+      if (device.pairing_process_commitment &&
+          device.pairing_process_commitment !== null &&
+          device.pairing_process_commitment !== '') {
+        console.log('Pairing process commitment found:', device.pairing_process_commitment);
+        return;
+      }
+    } catch (e) {
+      console.log(`Attempt ${i + 1}/${maxRetries}: Device not ready yet - ${e}`);
+    }
+
+    if (i < maxRetries - 1) {
+      await new Promise(resolve => setTimeout(resolve, retryDelay));
+    }
+  }
+
+  throw new Error(`Pairing process ${processId} was not committed after ${maxRetries} attempts`);
+}
+```
+
+Et simplification du router :
+```typescript
+console.log("⏳ Waiting for pairing process to be committed...");
+await services.waitForPairingCommitment(pairingId);
+
+console.log("🔁 Confirming pairing...");
+await services.confirmPairing(pairingId);
+```
+
+## Architecture du Système de Pairing
+
+### Flux de Création du Pairing (Créateur)
+
+1. **Création du processus** : `createPairingProcess("", [myAddress])`
+2. **Enregistrement du device** : `pairDevice(pairingId, [myAddress])`
+3. **Traitement de l'API** : `handleApiReturn(createPairingProcessReturn)`
+4. **Création de la mise à jour PRD** : `createPrdUpdate(pairingId, stateId)`
+5. **Approbation du changement** : `approveChange(pairingId, stateId)`
+6. **Attente du commit avec synchronisation** : `waitForPairingCommitment(pairingId)` (inclut `updateDevice()`)
+7. **Confirmation du pairing** : `confirmPairing(pairingId)`
+
+### Flux de Rejoindre le Pairing (Joiner) - ⚠️ INCOHÉRENT
+
+**Problème identifié** : Le joiner n'a pas de flux de confirmation complet.
+
+**Flux actuel (incomplet)** :
+1. **Création avec liste vide** : `createPairingProcess("", [])` ❌
+2. **Établissement des connexions** : `checkConnections(process)`
+3. **Pas de confirmation** : Aucun `waitForPairingCommitment` ou `confirmPairing` ❌
+
+**Flux attendu (cohérent)** :
+1. **Récupération du processus existant** : `getPairingProcessId()`
+2. **Rejoindre le processus** : Pas de création, mais participation au processus existant
+3. **Flux de confirmation complet** : Même flux que le créateur
+4. **Attente du commit** : `waitForPairingCommitment()`
+5. **Confirmation du pairing** : `confirmPairing()`
+
+### Gestion des Connexions
+
+La méthode `checkConnections` gère maintenant :
+- **Processus normaux** : Utilise les rôles pour trouver les membres
+- **Processus de pairing** : Utilise `pairedAddresses` des données publiques
+- **Recherche dans les états précédents** : Si `pairedAddresses` n'est pas dans l'état actuel
+- **Décodage des adresses** : Les données publiques sont encodées et nécessitent un décodage
+
+## Points Clés Appris
+
+### 1. Encodage des Données Publiques
+- Les données publiques sont encodées avec `this.sdkClient.encode_json()`
+- `pairedAddresses` nécessite un décodage avec `this.decodeValue()`
+- Les données ne sont pas directement utilisables sans décodage
+
+### 2. Gestion Multi-Hosts
+- Le créateur et le joiner peuvent être sur des hosts différents
+- Le joiner doit récupérer les adresses depuis le processus existant
+- `this.processId` n'est disponible que sur le même host
+
+### 3. Synchronisation du SDK
+- Le SDK n'a pas immédiatement le processus de pairing disponible
+- Il faut attendre que le processus soit committé
+- `updateDevice()` est nécessaire pour synchroniser l'état
+
+### 4. Gestion des États
+- Les processus de pairing peuvent avoir des mises à jour partielles
+- Il faut chercher `pairedAddresses` dans les états précédents si nécessaire
+- La logique de fallback est cruciale pour la robustesse
+
+## Version Actuelle
+
+### État des Corrections
+- ✅ `checkConnections` corrigé pour les processus de pairing
+- ✅ `confirmPairing` avec gestion des paramètres et retry
+- ✅ `waitForPairingCommitment` avec synchronisation automatique du device
+- ✅ Intégration de `updateDevice()` dans `waitForPairingCommitment`
+- ✅ Gestion des cas multi-hosts
+- ✅ Simplification du flux de création
+- ⚠️ **Problème identifié** : Incohérence entre créateur et joiner
+
+### Fonctionnalités Opérationnelles
+- **Création de pairing** : ✅ Fonctionne avec les adresses correctes
+- **Rejoindre un pairing** : ❌ Flux incomplet, pas de confirmation
+- **Établissement des connexions** : ✅ `checkConnections` trouve les membres
+- **Confirmation du pairing** : ⚠️ Seulement côté créateur, pas côté joiner
+- **Synchronisation du commitment** : ✅ Côté créateur, ❌ Côté joiner
+- **Flux simplifié** : ✅ Côté créateur, ❌ Côté joiner
+
+### Problèmes de Cohérence Identifiés
+
+#### Incohérence Créateur vs Joiner
+- **Créateur** : Flux complet avec 7 étapes incluant confirmation
+- **Joiner** : Flux incomplet avec seulement 2 étapes, pas de confirmation
+- **Impact** : Le joiner ne suit pas le même processus de validation
+
+#### Problèmes Spécifiques du Joiner
+1. **Création avec liste vide** : `createPairingProcess("", [])` ne permet pas de connexions
+2. **Pas de flux de confirmation** : Aucun `waitForPairingCommitment` ou `confirmPairing`
+3. **Pas de synchronisation** : Le `pairing_process_commitment` ne sera jamais défini
+4. **Pas de validation** : Le pairing n'est pas validé côté joiner
+
+### Améliorations Récentes
+
+#### Synchronisation Automatique du Device
+- **Intégration de `updateDevice()`** : Appelé automatiquement dans `waitForPairingCommitment`
+- **Gestion des erreurs** : Continue le polling même si `updateDevice()` échoue
+- **Logs détaillés** : Suivi complet du processus de synchronisation
+- **Temps d'attente augmenté** : 30 tentatives × 2 secondes = 60 secondes max
+
+#### Simplification du Flux
+- **Moins d'étapes manuelles** : `updateDevice()` intégré dans `waitForPairingCommitment`
+- **Flux plus robuste** : Gestion automatique de la synchronisation
+- **Code plus maintenable** : Logique centralisée dans une seule méthode
+
+### Points d'Attention
+- Le système nécessite que les deux côtés soient synchronisés
+- Les retry automatiques sont implémentés pour la robustesse
+- La gestion des erreurs est améliorée avec des logs détaillés
+- Le flux est maintenant plus prévisible et fiable
+- La synchronisation du device est automatique et robuste
+
+## Recommandations
+
+### Corrections Prioritaires
+1. **Corriger le flux du joiner** : Implémenter le même flux de confirmation que le créateur
+2. **Unifier les processus** : Le joiner devrait rejoindre un processus existant, pas en créer un nouveau
+3. **Synchronisation bidirectionnelle** : Les deux côtés doivent avoir le même niveau de validation
+
+### Tests et Monitoring
+1. **Tests** : Tester le pairing entre différents hosts avec les deux flux
+2. **Monitoring** : Surveiller les logs pour identifier les problèmes potentiels
+3. **Performance** : Optimiser les délais de retry si nécessaire
+4. **Documentation** : Maintenir cette documentation à jour avec les évolutions
+
+### Actions Immédiates
+1. **Analyser le flux du joiner** : Comprendre comment il devrait rejoindre un processus existant
+2. **Implémenter la cohérence** : Appliquer le même flux de confirmation aux deux côtés
+3. **Valider la synchronisation** : S'assurer que les deux côtés ont le même `pairing_process_commitment`
+
+Cette analyse fournit une base solide pour comprendre et maintenir le système de pairing, mais révèle des incohérences importantes qui doivent être corrigées.

package.json

@@ -5,7 +5,7 @@
   "main": "dist/index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build_wasm": "wasm-pack build --out-dir ../ihm_client/pkg  ../sdk_client --target bundler --dev",
+    "build_wasm": "wasm-pack build --out-dir ../ihm_client_dev3/pkg  ../sdk_client --target bundler --dev",
     "start": "vite --host 0.0.0.0",
     "build": "tsc && vite build",
     "deploy": "sudo cp -r dist/* /var/www/html/",

src/models/process.model.ts

@@ -46,6 +46,8 @@ export enum MessageType {
   // Processes
   CREATE_PROCESS = 'CREATE_PROCESS',
   PROCESS_CREATED = 'PROCESS_CREATED',
+  CREATE_CONVERSATION = 'CREATE_CONVERSATION',
+  CONVERSATION_CREATED = 'CONVERSATION_CREATED',
   UPDATE_PROCESS = 'UPDATE_PROCESS',
   PROCESS_UPDATED = 'PROCESS_UPDATED',
   NOTIFY_UPDATE = 'NOTIFY_UPDATE',

src/router.ts

@@ -286,8 +286,11 @@ export async function registerAllListeners() {
       console.log("📜 Approve change result:", approveChangeReturn);
       await services.handleApiReturn(approveChangeReturn);
 
+      console.log("⏳ Waiting for pairing process to be committed...");
+      await services.waitForPairingCommitment(pairingId);
+
       console.log("🔁 Confirming pairing...");
-      await services.confirmPairing();
+      await services.confirmPairing(pairingId);
 
       console.log("🎉 Pairing successfully completed!");
 

src/services/service.ts

@@ -123,6 +123,7 @@ export default class Services {
       this.relayReadyResolver = null;
       this.relayReadyPromise = null;
     }
+  }
 
   public async addWebsocketConnection(url: string): Promise<void> {
     console.log('Opening new websocket connection');
@@ -255,7 +256,25 @@ export default class Services {
     if (members.size === 0) {
       // This must be a pairing process
       // Check if we have a pairedAddresses in the public data
-      const publicData = process.states[0]?.public_data;
+      let publicData: Record<string, any> | null = null;
+      if (!stateId) {
+        publicData = process.states[process.states.length - 2]?.public_data;
+      } else {
+        publicData = process.states.find(state => state.state_id === stateId)?.public_data || null;
+      }
+
+      // If pairedAddresses is not in the current state, look in previous states
+      if (!publicData || !publicData['pairedAddresses']) {
+        // Look for pairedAddresses in previous states
+        for (let i = process.states.length - 1; i >= 0; i--) {
+          const state = process.states[i];
+          if (state.public_data && state.public_data['pairedAddresses']) {
+            publicData = state.public_data;
+            break;
+          }
+        }
+      }
+
       if (!publicData || !publicData['pairedAddresses']) {
         throw new Error('Not a pairing process');
       }
@@ -754,13 +773,79 @@ export default class Services {
     }
   }
 
-  public async confirmPairing() {
+  public async waitForPairingCommitment(processId: string, maxRetries: number = 30, retryDelay: number = 2000): Promise<void> {
+    console.log(`⏳ Waiting for pairing process ${processId} to be committed and synchronized...`);
+    console.log(`🔄 This may take some time as we wait for SDK synchronization...`);
+
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        // Try to update device first (may fail if not committed yet)
+        try {
+          await this.updateDevice();
+          console.log(`✅ Device update successful on attempt ${i + 1}`);
+        } catch (e) {
+          console.log(`⚠️ Device update failed on attempt ${i + 1} (process may not be committed yet): ${e.message}`);
+        }
+
+        const device = this.dumpDeviceFromMemory();
+        console.log(`🔍 Attempt ${i + 1}/${maxRetries}: pairing_process_commitment =`, device.pairing_process_commitment);
+
+        // Check if the commitment is set and not null/empty
+        if (device.pairing_process_commitment &&
+            device.pairing_process_commitment !== null &&
+            device.pairing_process_commitment !== '') {
+          console.log('✅ Pairing process commitment found:', device.pairing_process_commitment);
+          return;
+        }
+
+        console.log(`⏳ Still waiting for SDK synchronization... (${i + 1}/${maxRetries})`);
+      } catch (e) {
+        console.log(`❌ Attempt ${i + 1}/${maxRetries}: Error during synchronization - ${e.message}`);
+      }
+
+      if (i < maxRetries - 1) {
+        console.log(`⏳ Waiting ${retryDelay}ms before next attempt...`);
+        await new Promise(resolve => setTimeout(resolve, retryDelay));
+      }
+    }
+
+    throw new Error(`❌ Pairing process ${processId} was not synchronized after ${maxRetries} attempts (${maxRetries * retryDelay / 1000}s)`);
+  }
+
+  public async confirmPairing(pairingId?: string) {
     try {
       // Is the wasm paired?
-      const pairingId = this.getPairingProcessId();
+      console.log('confirmPairing');
+      let processId: string;
+      if (pairingId) {
+        processId = pairingId;
+        console.log('pairingId (provided):', processId);
+      } else if (this.processId) {
+        processId = this.processId;
+        console.log('pairingId (from stored processId):', processId);
+      } else {
+        // Try to get pairing process ID, with retry if it fails
+        let retries = 3;
+        while (retries > 0) {
+          try {
+            processId = this.getPairingProcessId();
+            console.log('pairingId (from SDK):', processId);
+            break;
+          } catch (e) {
+            retries--;
+            if (retries === 0) {
+              throw e;
+            }
+            console.log(`Failed to get pairing process ID, retrying... (${retries} attempts left)`);
+            await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second before retry
+          }
+        }
+      }
       // TODO confirm that the pairing process id is known, commited
       const newDevice = this.dumpDeviceFromMemory();
+      console.log('newDevice:', newDevice);
       await this.saveDeviceInDatabase(newDevice);
+      console.log('Device saved in database');
     } catch (e) {
       console.error('Failed to confirm pairing');
       return;
@@ -1228,12 +1313,14 @@ export default class Services {
   }
 
   async decryptAttribute(processId: string, state: ProcessState, attribute: string): Promise<any | null> {
+    console.log(`[decryptAttribute] Starting decryption for attribute: ${attribute}, processId: ${processId}`);
     let hash = state.pcd_commitment[attribute];
     if (!hash) {
-      // attribute doesn't exist
+      console.log(`[decryptAttribute] No hash found for attribute: ${attribute}`);
       return null;
     }
     let key = state.keys[attribute];
+    console.log(`[decryptAttribute] Initial key state for ${attribute}:`, key ? 'present' : 'missing');
     const pairingProcessId = this.getPairingProcessId();
 
     // If key is missing, request an update and then retry
@@ -1253,8 +1340,12 @@ export default class Services {
         }
       }
 
-      if (!hasAccess) return null;
+      if (!hasAccess) {
+        console.log(`[decryptAttribute] No access rights for attribute: ${attribute}`);
+        return null;
+      }
 
+      console.log(`[decryptAttribute] Requesting key update for attribute: ${attribute}`);
       await this.checkConnections((await this.getProcess(processId))!);
       // We should have the key, so we're going to ask other members for it
       await this.requestDataFromPeers(processId, [state.state_id], [state.roles]);
@@ -1264,17 +1355,21 @@ export default class Services {
       let retries = 0;
 
       while ((!hash || !key) && retries < maxRetries) {
+        console.log(`[decryptAttribute] Retry ${retries + 1}/${maxRetries} for attribute: ${attribute}`);
         await new Promise(resolve => setTimeout(resolve, retryDelay));
         // Re-read hash and key after waiting
         hash = state.pcd_commitment[attribute];
         key = state.keys[attribute];
         retries++;
+        console.log(`[decryptAttribute] After retry ${retries}: hash=${!!hash}, key=${!!key}`);
       }
     }
 
     if (hash && key) {
+      console.log(`[decryptAttribute] Starting decryption process with hash: ${hash.substring(0, 8)}...`);
       const blob = await this.getBlobFromDb(hash);
       if (blob) {
+        console.log(`[decryptAttribute] Blob retrieved successfully for ${attribute}`);
         // Decrypt the data
         const buf = await blob.arrayBuffer();
         const cipher = new Uint8Array(buf);
@@ -1291,7 +1386,7 @@ export default class Services {
             throw new Error('decrypt_data returned null');
           }
         } catch (e) {
-          console.error(`Failed to decrypt data: ${e}`);
+          console.error(`[decryptAttribute] Failed to decrypt data for ${attribute}:`, e);
         }
       }
     }

src/utils/sp-address.utils.ts

@@ -162,12 +162,6 @@ async function onCreateButtonClick() {
 export async function prepareAndSendPairingTx(): Promise<void> {
   const service = await Services.getInstance();
 
-  try {
-    await service.checkConnections([]);
-  } catch (e) {
-    throw e;
-  }
-
   try {
     const relayAddress = service.getAllRelays();
     const createPairingProcessReturn = await service.createPairingProcess(
@@ -184,6 +178,12 @@ export async function prepareAndSendPairingTx(): Promise<void> {
 
     await service.handleApiReturn(createPairingProcessReturn);
 
+    try {
+      await service.checkConnections(createPairingProcessReturn.updated_process.current_process);
+    } catch (e) {
+      throw e;
+    }
+
   } catch (err) {
     console.error(err);
   }