From 5f2e123b9ddc08c864378477609a69596b0459c0 Mon Sep 17 00:00:00 2001
From: NicolasCantu <nicolas.cantu@pm.me>
Date: Fri, 17 Jan 2025 10:49:16 +0100
Subject: [PATCH] Fix connect to members workflow

---
 src/services/service.ts       | 42 +++++++++++++++++++----------------
 src/utils/sp-address.utils.ts | 11 ++++-----
 2 files changed, 27 insertions(+), 26 deletions(-)

diff --git a/src/services/service.ts b/src/services/service.ts
index 79528b0..21dafba 100755
--- a/src/services/service.ts
+++ b/src/services/service.ts
@@ -174,32 +174,35 @@ export default class Services {
   }
 
   public async checkConnections(members: Member[]): Promise<void> {
-    const memberPromises = members.map(async (member) => {
-      const addressPromises = member.sp_addresses.map(async (address) => {
+    // Ensure the amount is available before proceeding
+    try {
+      await this.ensureSufficientAmount();
+    } catch (e) {
+      console.error('Failed to get tokens from relay, check connection');
+      return;
+    }
+    let unconnectedAddresses = [];
+    for (const member of members) {
+      for (const address of member.sp_addresses) {
         const sharedSecret = await this.getSecretForAddress(address);
         if (!sharedSecret) {
-          const connectMemberResult = await this.connectMember([{ sp_addresses: [address] }]);
-          await this.handleApiReturn(connectMemberResult);
+          unconnectedAddresses.push(address);
         }
-      });
-
-      await Promise.all(addressPromises);
-    });
-
-    await Promise.all(memberPromises);
+      }
+    }
+    if (unconnectedAddresses && unconnectedAddresses.length != 0) {
+      const apiResult = await this.connectAddresses(unconnectedAddresses);
+      await this.handleApiReturn(apiResult);
+    }
   }
 
-  public async connectMember(members: Member[]): Promise<ApiReturn> {
-    if (members.length === 0) {
-      throw new Error('Trying to connect to empty members list');
+  public async connectAddresses(addresses: string[]): Promise<ApiReturn> {
+    if (addresses.length === 0) {
+      throw new Error('Trying to connect to empty addresses list');
     }
 
-    const members_str = members.map((member) => JSON.stringify(member));
-
     try {
-      // Ensure the amount is available before proceeding
-      await this.ensureSufficientAmount();
-      return this.sdkClient.create_connect_transaction(members_str, 1);
+      return this.sdkClient.create_connect_transaction(addresses, 1);
     } catch (e) {
       console.error('Failed to connect member:', e);
       throw e;
@@ -245,8 +248,8 @@ export default class Services {
       throw new Error('No paired member in device');
     }
     const allMembers: Member[] = otherMembers;
-    allMembers.push({ sp_addresses: me });
     const meAndOne = [{ sp_addresses: me }, otherMembers.pop()!];
+    allMembers.push({ sp_addresses: me });
     const everyOneElse = otherMembers;
     const messagingTemplate = {
       description: 'messaging',
@@ -531,6 +534,7 @@ export default class Services {
   public async handleApiReturn(apiReturn: ApiReturn) {
     if (apiReturn.new_tx_to_send && apiReturn.new_tx_to_send.transaction.length != 0) {
       await this.sendNewTxMessage(JSON.stringify(apiReturn.new_tx_to_send));
+      await new Promise(r => setTimeout(r, 500));
     }
 
     if (apiReturn.secrets) {
diff --git a/src/utils/sp-address.utils.ts b/src/utils/sp-address.utils.ts
index b0eb3ad..90cee47 100755
--- a/src/utils/sp-address.utils.ts
+++ b/src/utils/sp-address.utils.ts
@@ -164,13 +164,10 @@ export async function prepareAndSendPairingTx(secondDeviceAddress: string) {
   // Device 1 wait Device 2
   service.device1 = true;
 
-  const sharedSecret = await service.getSecretForAddress(secondDeviceAddress);
-  if (!sharedSecret) {
-    const member = {
-      sp_addresses: [secondDeviceAddress],
-    };
-    const connectMemberResult = await service.connectMember([member]);
-    await service.handleApiReturn(connectMemberResult);
+  try {
+    await service.checkConnections([{ sp_addresses: [secondDeviceAddress] }]);
+  } catch (e) {
+    throw e;
   }
   // Create the process
   setTimeout(async () => {