From 8ffe1c23c176b7d857b3ef534be26e2b5a67b41d Mon Sep 17 00:00:00 2001
From: Stanislav Dmitrenko <7953703+avently@users.noreply.github.com>
Date: Thu, 12 Oct 2023 20:19:57 +0800
Subject: [PATCH 1/5] android, desktop: better handling of parallel updates of
 chats (#3204)

* android, desktop: better handling of parallel updates of chats

* one more case
---
 .../main/java/chat/simplex/app/SimplexApp.kt  | 32 +++++++++--------
 .../chat/simplex/common/model/ChatModel.kt    | 34 +++++++++++--------
 .../chat/simplex/common/model/SimpleXAPI.kt   | 14 +++++---
 .../common/views/database/DatabaseView.kt     |  8 +++--
 4 files changed, 53 insertions(+), 35 deletions(-)

diff --git a/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexApp.kt b/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexApp.kt
index f70032788..d2c446517 100644
--- a/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexApp.kt
+++ b/apps/multiplatform/android/src/main/java/chat/simplex/app/SimplexApp.kt
@@ -9,12 +9,14 @@ import chat.simplex.common.helpers.APPLICATION_ID
 import chat.simplex.common.helpers.requiresIgnoringBattery
 import chat.simplex.common.model.*
 import chat.simplex.common.model.ChatController.appPrefs
+import chat.simplex.common.model.ChatModel.updatingChatsMutex
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.onboarding.OnboardingStage
 import chat.simplex.common.platform.*
 import chat.simplex.common.views.call.RcvCallInvitation
 import com.jakewharton.processphoenix.ProcessPhoenix
 import kotlinx.coroutines.*
+import kotlinx.coroutines.sync.withLock
 import java.io.*
 import java.util.*
 import java.util.concurrent.TimeUnit
@@ -52,21 +54,23 @@ class SimplexApp: Application(), LifecycleEventObserver {
         Lifecycle.Event.ON_START -> {
           isAppOnForeground = true
           if (chatModel.chatRunning.value == true) {
-            kotlin.runCatching {
-              val currentUserId = chatModel.currentUser.value?.userId
-              val chats = ArrayList(chatController.apiGetChats())
-              /** Active user can be changed in background while [ChatController.apiGetChats] is executing */
-              if (chatModel.currentUser.value?.userId == currentUserId) {
-                val currentChatId = chatModel.chatId.value
-                val oldStats = if (currentChatId != null) chatModel.getChat(currentChatId)?.chatStats else null
-                if (oldStats != null) {
-                  val indexOfCurrentChat = chats.indexOfFirst { it.id == currentChatId }
-                  /** Pass old chatStats because unreadCounter can be changed already while [ChatController.apiGetChats] is executing */
-                  if (indexOfCurrentChat >= 0) chats[indexOfCurrentChat] = chats[indexOfCurrentChat].copy(chatStats = oldStats)
+            updatingChatsMutex.withLock {
+              kotlin.runCatching {
+                val currentUserId = chatModel.currentUser.value?.userId
+                val chats = ArrayList(chatController.apiGetChats())
+                /** Active user can be changed in background while [ChatController.apiGetChats] is executing */
+                if (chatModel.currentUser.value?.userId == currentUserId) {
+                  val currentChatId = chatModel.chatId.value
+                  val oldStats = if (currentChatId != null) chatModel.getChat(currentChatId)?.chatStats else null
+                  if (oldStats != null) {
+                    val indexOfCurrentChat = chats.indexOfFirst { it.id == currentChatId }
+                    /** Pass old chatStats because unreadCounter can be changed already while [ChatController.apiGetChats] is executing */
+                    if (indexOfCurrentChat >= 0) chats[indexOfCurrentChat] = chats[indexOfCurrentChat].copy(chatStats = oldStats)
+                  }
+                  chatModel.updateChats(chats)
                 }
-                chatModel.updateChats(chats)
-              }
-            }.onFailure { Log.e(TAG, it.stackTraceToString()) }
+              }.onFailure { Log.e(TAG, it.stackTraceToString()) }
+            }
           }
         }
         Lifecycle.Event.ON_RESUME -> {
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/ChatModel.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/ChatModel.kt
index 88ad78612..ac5f9fb8a 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/ChatModel.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/ChatModel.kt
@@ -6,7 +6,6 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.SpanStyle
 import androidx.compose.ui.text.font.*
 import androidx.compose.ui.text.style.TextDecoration
-import chat.simplex.common.model.*
 import chat.simplex.common.platform.*
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.call.*
@@ -16,6 +15,8 @@ import chat.simplex.res.MR
 import dev.icerock.moko.resources.ImageResource
 import dev.icerock.moko.resources.StringResource
 import kotlinx.coroutines.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import kotlinx.datetime.*
 import kotlinx.datetime.TimeZone
 import kotlinx.serialization.*
@@ -102,6 +103,8 @@ object ChatModel {
   val filesToDelete = mutableSetOf<File>()
   val simplexLinkMode by lazy { mutableStateOf(ChatController.appPrefs.simplexLinkMode.get()) }
 
+  var updatingChatsMutex: Mutex = Mutex()
+
   fun getUser(userId: Long): User? = if (currentUser.value?.userId == userId) {
     currentUser.value
   } else {
@@ -198,7 +201,7 @@ object ChatModel {
     }
   }
 
-  suspend fun addChatItem(cInfo: ChatInfo, cItem: ChatItem) {
+  suspend fun addChatItem(cInfo: ChatInfo, cItem: ChatItem) = updatingChatsMutex.withLock {
     // update previews
     val i = getChatIndex(cInfo.id)
     val chat: Chat
@@ -221,10 +224,11 @@ object ChatModel {
     } else {
       addChat(Chat(chatInfo = cInfo, chatItems = arrayListOf(cItem)))
     }
-    // add to current chat
-    if (chatId.value == cInfo.id) {
-      Log.d(TAG, "TODOCHAT: addChatItem: adding to chat ${chatId.value} from ${cInfo.id} ${cItem.id}, size ${chatItems.size}")
-      withContext(Dispatchers.Main) {
+    Log.d(TAG, "TODOCHAT: addChatItem: adding to chat ${chatId.value} from ${cInfo.id} ${cItem.id}, size ${chatItems.size}")
+    withContext(Dispatchers.Main) {
+      // add to current chat
+      if (chatId.value == cInfo.id) {
+        Log.d(TAG, "TODOCHAT: addChatItem: chatIds are equal, size ${chatItems.size}")
         // Prevent situation when chat item already in the list received from backend
         if (chatItems.none { it.id == cItem.id }) {
           if (chatItems.lastOrNull()?.id == ChatItem.TEMP_LIVE_CHAT_ITEM_ID) {
@@ -238,7 +242,7 @@ object ChatModel {
     }
   }
 
-  suspend fun upsertChatItem(cInfo: ChatInfo, cItem: ChatItem): Boolean {
+  suspend fun upsertChatItem(cInfo: ChatInfo, cItem: ChatItem): Boolean  = updatingChatsMutex.withLock {
     // update previews
     val i = getChatIndex(cInfo.id)
     val chat: Chat
@@ -258,10 +262,10 @@ object ChatModel {
       addChat(Chat(chatInfo = cInfo, chatItems = arrayListOf(cItem)))
       res = true
     }
-    // update current chat
-    return if (chatId.value == cInfo.id) {
-      Log.d(TAG, "TODOCHAT: upsertChatItem: upserting to chat ${chatId.value} from ${cInfo.id} ${cItem.id}, size ${chatItems.size}")
-      withContext(Dispatchers.Main) {
+    Log.d(TAG, "TODOCHAT: upsertChatItem: upserting to chat ${chatId.value} from ${cInfo.id} ${cItem.id}, size ${chatItems.size}")
+    return withContext(Dispatchers.Main) {
+      // update current chat
+      if (chatId.value == cInfo.id) {
         val itemIndex = chatItems.indexOfFirst { it.id == cItem.id }
         if (itemIndex >= 0) {
           chatItems[itemIndex] = cItem
@@ -272,15 +276,15 @@ object ChatModel {
           Log.d(TAG, "TODOCHAT: upsertChatItem: added to chat $chatId from ${cInfo.id} ${cItem.id}, size ${chatItems.size}")
           true
         }
+      } else {
+        res
       }
-    } else {
-      res
     }
   }
 
   suspend fun updateChatItem(cInfo: ChatInfo, cItem: ChatItem) {
-    if (chatId.value == cInfo.id) {
-      withContext(Dispatchers.Main) {
+    withContext(Dispatchers.Main) {
+      if (chatId.value == cInfo.id) {
         val itemIndex = chatItems.indexOfFirst { it.id == cItem.id }
         if (itemIndex >= 0) {
           chatItems[itemIndex] = cItem
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/SimpleXAPI.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/SimpleXAPI.kt
index 3644268ba..dc2c3c0f2 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/SimpleXAPI.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/SimpleXAPI.kt
@@ -4,6 +4,7 @@ import chat.simplex.common.views.helpers.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.painter.Painter
+import chat.simplex.common.model.ChatModel.updatingChatsMutex
 import dev.icerock.moko.resources.compose.painterResource
 import chat.simplex.common.platform.*
 import chat.simplex.common.ui.theme.*
@@ -16,6 +17,7 @@ import com.charleskorn.kaml.YamlConfiguration
 import chat.simplex.res.MR
 import com.russhwolf.settings.Settings
 import kotlinx.coroutines.*
+import kotlinx.coroutines.sync.withLock
 import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
 import kotlinx.serialization.*
@@ -349,8 +351,10 @@ object ChatController {
         startReceiver()
         Log.d(TAG, "startChat: started")
       } else {
-        val chats = apiGetChats()
-        chatModel.updateChats(chats)
+        updatingChatsMutex.withLock {
+          val chats = apiGetChats()
+          chatModel.updateChats(chats)
+        }
         Log.d(TAG, "startChat: running")
       }
     } catch (e: Error) {
@@ -384,8 +388,10 @@ object ChatController {
   suspend fun getUserChatData() {
     chatModel.userAddress.value = apiGetUserAddress()
     chatModel.chatItemTTL.value = getChatItemTTL()
-    val chats = apiGetChats()
-    chatModel.updateChats(chats)
+    updatingChatsMutex.withLock {
+      val chats = apiGetChats()
+      chatModel.updateChats(chats)
+    }
   }
 
   private fun startReceiver() {
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseView.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseView.kt
index fa0f8f54d..0cca35474 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseView.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/database/DatabaseView.kt
@@ -20,11 +20,13 @@ import androidx.compose.ui.text.*
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.model.*
+import chat.simplex.common.model.ChatModel.updatingChatsMutex
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.usersettings.*
 import chat.simplex.common.platform.*
 import chat.simplex.res.MR
+import kotlinx.coroutines.sync.withLock
 import kotlinx.datetime.*
 import java.io.*
 import java.net.URI
@@ -620,8 +622,10 @@ private fun afterSetCiTTL(
   appFilesCountAndSize.value = directoryFileCountAndSize(appFilesDir.absolutePath)
   withApi {
     try {
-      val chats = m.controller.apiGetChats()
-      m.updateChats(chats)
+      updatingChatsMutex.withLock {
+        val chats = m.controller.apiGetChats()
+        m.updateChats(chats)
+      }
     } catch (e: Exception) {
       Log.e(TAG, "apiGetChats error: ${e.message}")
     }

From 675fc19745960db809e77ced0554b6947ae3187b Mon Sep 17 00:00:00 2001
From: Stanislav Dmitrenko <7953703+avently@users.noreply.github.com>
Date: Fri, 13 Oct 2023 07:05:06 +0800
Subject: [PATCH 2/5] rfc: desktop calls (#3208)

* rfc: desktop calls

* errors

* html

* link

* screen sharing

* additions

* addition

* correction

---------

Co-authored-by: Evgeny Poberezkin <2769109+epoberezkin@users.noreply.github.com>
---
 docs/rfcs/2023-10-12-desktop-calls.md | 34 +++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 docs/rfcs/2023-10-12-desktop-calls.md

diff --git a/docs/rfcs/2023-10-12-desktop-calls.md b/docs/rfcs/2023-10-12-desktop-calls.md
new file mode 100644
index 000000000..c956ed011
--- /dev/null
+++ b/docs/rfcs/2023-10-12-desktop-calls.md
@@ -0,0 +1,34 @@
+# Desktop calls
+
+To make audio and video calls on desktop there are some options:
+- adapt [libwebrtc](webrtc.googlesource.com/) from Google which would be the most reliable, performant and seamless solution;
+- include some kind of WebView to the app via libraries;
+- implement a signaling server in the app and let users to use HTML page with WebRTC code that already exist for Android.
+
+## WebRTC lib
+
+To adapt libwebrtc we need to make SDK that is compatible with Java (JNI layer + desktop implementation of VideoCodecs and other features). There are two SDKs exist already: for Android and for Objective-C. Making Android SDK compatible with Java-only SDK gives a lot of problems and requires to have 5+ professional C++ developers with weeks/months for developing. Which is not something good.
+
+Another considered option was adopting Jitsi Java SDK, but it's state is not very clear, and in any case it is much more effort.
+
+## WebView
+
+Including WebView is possible but requires a lot of megabytes of storage to waste on such libs. Because only Chromium-like WebViews support WebRTC features. Which means 100+ MB to the package on top of 200+ MB now.
+
+## Standalone browser + WebRTC HTML page
+
+The last solution is what can give the most useful result: the same package size as before + already existent code which can be reused with small modifications + quality of result will depend on Chromium/Firefox/Safari devs (which is good, since they are interested in making all features working for everyone). 
+
+# Details of implementation
+
+Since the code for WebView has already written (https://github.com/simplex-chat/simplex-chat/tree/0e4376bada2d0c4ec2ade7f30b0048dc8b13abd8/apps/multiplatform/android/src/main/assets/www) it can be used to make calls on a desktop browser too. The only differences are these:
+- UI needs to be changed - buttons controlling calls should be added. For example, end call, disable camera/mic. This will be added to separate HTML and JS files that would communication with the existing WebRTC JS code via the existing functional API.
+- signaling websocket server should be started in order to allow Haskell backend to talk with HTML page and to exchange messages between all parties. It is bidirectional communication between server and webpage since both parties have to send messages to each other.
+
+There is no need to have TLS-secured connection between server and webpage since it's only used locally. And browser will not be happy with self-signed certificate too.
+
+After accepting the call, webpage will be opened in the default browser. URL will look like: `https://localhost:123/simplex/call/` (to reduce questions and to namespace other files - the main UI page will be index.html, that would load via folder path) After that internal machinary will connect both parties together. Same as on Android but with a different signaling channel, in this case it's websockets. 
+
+Ending the call by the user will also send a new action to signaling server to allow the backend to notify other party.
+
+The solution will also allow to make screen sharing in the future that will be supported on every OS and graphics environment where the user's browser supports it.
\ No newline at end of file

From ab290fb0683047f706f49d5b35052c44873518f7 Mon Sep 17 00:00:00 2001
From: Evgeny Poberezkin <2769109+epoberezkin@users.noreply.github.com>
Date: Fri, 13 Oct 2023 11:51:01 +0100
Subject: [PATCH 3/5] core: track network statuses, use in commands/events
 (#3211)

* core: track network statuses, use in commands/events

* ui types, test

* remove comment
---
 apps/ios/Shared/Model/ChatModel.swift         | 38 ----------
 apps/ios/Shared/Model/SimpleXAPI.swift        | 27 +++++---
 apps/ios/SimpleXChat/APITypes.swift           | 59 ++++++++++++++--
 apps/ios/SimpleXChat/ChatTypes.swift          | 12 +++-
 .../chat/simplex/common/model/ChatModel.kt    | 20 ++++--
 .../chat/simplex/common/model/SimpleXAPI.kt   | 39 ++++++++---
 src/Simplex/Chat.hs                           | 69 ++++++++++++++-----
 src/Simplex/Chat/Controller.hs                | 15 +++-
 src/Simplex/Chat/Mobile.hs                    |  3 +-
 src/Simplex/Chat/Types.hs                     | 37 +++++++++-
 src/Simplex/Chat/View.hs                      | 10 ++-
 tests/ChatTests/Direct.hs                     | 16 +++++
 tests/MobileTests.hs                          | 32 ++++-----
 13 files changed, 275 insertions(+), 102 deletions(-)

diff --git a/apps/ios/Shared/Model/ChatModel.swift b/apps/ios/Shared/Model/ChatModel.swift
index a1ec2f8f5..ec1a56742 100644
--- a/apps/ios/Shared/Model/ChatModel.swift
+++ b/apps/ios/Shared/Model/ChatModel.swift
@@ -688,41 +688,3 @@ final class Chat: ObservableObject, Identifiable {
 
     public static var sampleData: Chat = Chat(chatInfo: ChatInfo.sampleData.direct, chatItems: [])
 }
-
-enum NetworkStatus: Decodable, Equatable {
-    case unknown
-    case connected
-    case disconnected
-    case error(String)
-
-    var statusString: LocalizedStringKey {
-        get {
-            switch self {
-            case .connected: return "connected"
-            case .error: return "error"
-            default: return "connecting"
-            }
-        }
-    }
-
-    var statusExplanation: LocalizedStringKey {
-        get {
-            switch self {
-            case .connected: return "You are connected to the server used to receive messages from this contact."
-            case let .error(err): return "Trying to connect to the server used to receive messages from this contact (error: \(err))."
-            default: return "Trying to connect to the server used to receive messages from this contact."
-            }
-        }
-    }
-
-    var imageName: String {
-        get {
-            switch self {
-            case .unknown: return "circle.dotted"
-            case .connected: return "circle.fill"
-            case .disconnected: return "ellipsis.circle.fill"
-            case .error: return "exclamationmark.circle.fill"
-            }
-        }
-    }
-}
diff --git a/apps/ios/Shared/Model/SimpleXAPI.swift b/apps/ios/Shared/Model/SimpleXAPI.swift
index 85e66e893..e4f64ee97 100644
--- a/apps/ios/Shared/Model/SimpleXAPI.swift
+++ b/apps/ios/Shared/Model/SimpleXAPI.swift
@@ -944,6 +944,12 @@ func apiCallStatus(_ contact: Contact, _ status: String) async throws {
     }
 }
 
+func apiGetNetworkStatuses() throws -> [ConnNetworkStatus] {
+    let r = chatSendCmdSync(.apiGetNetworkStatuses)
+    if case let .networkStatuses(_, statuses) = r { return statuses }
+    throw r
+}
+
 func markChatRead(_ chat: Chat, aboveItem: ChatItem? = nil) async {
     do {
         if chat.chatStats.unreadCount > 0 {
@@ -1348,13 +1354,6 @@ func processReceivedMsg(_ res: ChatResponse) async {
         await updateContactsStatus(contactRefs, status: .connected)
     case let .contactsDisconnected(_, contactRefs):
         await updateContactsStatus(contactRefs, status: .disconnected)
-    case let .contactSubError(user, contact, chatError):
-        await MainActor.run {
-            if active(user) {
-                m.updateContact(contact)
-            }
-            processContactSubError(contact, chatError)
-        }
     case let .contactSubSummary(_, contactSubscriptions):
         await MainActor.run {
             for sub in contactSubscriptions {
@@ -1369,6 +1368,18 @@ func processReceivedMsg(_ res: ChatResponse) async {
                 }
             }
         }
+    case let .networkStatus(status, connections):
+        await MainActor.run {
+            for cId in connections {
+                m.networkStatuses[cId] = status
+            }
+        }
+    case let .networkStatuses(statuses): ()
+        await MainActor.run {
+            for s in statuses {
+                m.networkStatuses[s.agentConnId] = s.networkStatus
+            }
+        }
     case let .newChatItem(user, aChatItem):
         let cInfo = aChatItem.chatInfo
         let cItem = aChatItem.chatItem
@@ -1649,7 +1660,7 @@ func processContactSubError(_ contact: Contact, _ chatError: ChatError) {
     case .errorAgent(agentError: .SMP(smpErr: .AUTH)): err = "contact deleted"
     default: err = String(describing: chatError)
     }
-    m.setContactNetworkStatus(contact, .error(err))
+    m.setContactNetworkStatus(contact, .error(connectionError: err))
 }
 
 func refreshCallInvitations() throws {
diff --git a/apps/ios/SimpleXChat/APITypes.swift b/apps/ios/SimpleXChat/APITypes.swift
index d65b9b328..d29e2481d 100644
--- a/apps/ios/SimpleXChat/APITypes.swift
+++ b/apps/ios/SimpleXChat/APITypes.swift
@@ -110,6 +110,7 @@ public enum ChatCommand {
     case apiEndCall(contact: Contact)
     case apiGetCallInvitations
     case apiCallStatus(contact: Contact, callStatus: WebRTCCallStatus)
+    case apiGetNetworkStatuses
     case apiChatRead(type: ChatType, id: Int64, itemRange: (Int64, Int64))
     case apiChatUnread(type: ChatType, id: Int64, unreadChat: Bool)
     case receiveFile(fileId: Int64, encrypted: Bool, inline: Bool?)
@@ -241,6 +242,7 @@ public enum ChatCommand {
             case let .apiEndCall(contact): return "/_call end @\(contact.apiId)"
             case .apiGetCallInvitations: return "/_call get"
             case let .apiCallStatus(contact, callStatus): return "/_call status @\(contact.apiId) \(callStatus.rawValue)"
+            case .apiGetNetworkStatuses: return "/_network_statuses"
             case let .apiChatRead(type, id, itemRange: (from, to)): return "/_read chat \(ref(type, id)) from=\(from) to=\(to)"
             case let .apiChatUnread(type, id, unreadChat): return "/_unread chat \(ref(type, id)) \(onOff(unreadChat))"
             case let .receiveFile(fileId, encrypted, inline):
@@ -356,6 +358,7 @@ public enum ChatCommand {
             case .apiEndCall: return "apiEndCall"
             case .apiGetCallInvitations: return "apiGetCallInvitations"
             case .apiCallStatus: return "apiCallStatus"
+            case .apiGetNetworkStatuses: return "apiGetNetworkStatuses"
             case .apiChatRead: return "apiChatRead"
             case .apiChatUnread: return "apiChatUnread"
             case .receiveFile: return "receiveFile"
@@ -480,11 +483,14 @@ public enum ChatResponse: Decodable, Error {
     case acceptingContactRequest(user: UserRef, contact: Contact)
     case contactRequestRejected(user: UserRef)
     case contactUpdated(user: UserRef, toContact: Contact)
+    // TODO remove events below
     case contactsSubscribed(server: String, contactRefs: [ContactRef])
     case contactsDisconnected(server: String, contactRefs: [ContactRef])
-    case contactSubError(user: UserRef, contact: Contact, chatError: ChatError)
     case contactSubSummary(user: UserRef, contactSubscriptions: [ContactSubStatus])
-    case groupSubscribed(user: UserRef, groupInfo: GroupInfo)
+    // TODO remove events above
+    case networkStatus(networkStatus: NetworkStatus, connections: [String])
+    case networkStatuses(user_: UserRef?, networkStatuses: [ConnNetworkStatus])
+    case groupSubscribed(user: UserRef, groupInfo: GroupRef)
     case memberSubErrors(user: UserRef, memberSubErrors: [MemberSubError])
     case groupEmpty(user: UserRef, groupInfo: GroupInfo)
     case userContactLinkSubscribed
@@ -620,8 +626,9 @@ public enum ChatResponse: Decodable, Error {
             case .contactUpdated: return "contactUpdated"
             case .contactsSubscribed: return "contactsSubscribed"
             case .contactsDisconnected: return "contactsDisconnected"
-            case .contactSubError: return "contactSubError"
             case .contactSubSummary: return "contactSubSummary"
+            case .networkStatus: return "networkStatus"
+            case .networkStatuses: return "networkStatuses"
             case .groupSubscribed: return "groupSubscribed"
             case .memberSubErrors: return "memberSubErrors"
             case .groupEmpty: return "groupEmpty"
@@ -757,8 +764,9 @@ public enum ChatResponse: Decodable, Error {
             case let .contactUpdated(u, toContact): return withUser(u, String(describing: toContact))
             case let .contactsSubscribed(server, contactRefs): return "server: \(server)\ncontacts:\n\(String(describing: contactRefs))"
             case let .contactsDisconnected(server, contactRefs): return "server: \(server)\ncontacts:\n\(String(describing: contactRefs))"
-            case let .contactSubError(u, contact, chatError): return withUser(u, "contact:\n\(String(describing: contact))\nerror:\n\(String(describing: chatError))")
             case let .contactSubSummary(u, contactSubscriptions): return withUser(u, String(describing: contactSubscriptions))
+            case let .networkStatus(status, conns): return "networkStatus: \(String(describing: status))\nconnections: \(String(describing: conns))"
+            case let .networkStatuses(u, statuses): return withUser(u, String(describing: statuses))
             case let .groupSubscribed(u, groupInfo): return withUser(u, String(describing: groupInfo))
             case let .memberSubErrors(u, memberSubErrors): return withUser(u, String(describing: memberSubErrors))
             case let .groupEmpty(u, groupInfo): return withUser(u, String(describing: groupInfo))
@@ -1181,6 +1189,49 @@ public struct KeepAliveOpts: Codable, Equatable {
     public static let defaults: KeepAliveOpts = KeepAliveOpts(keepIdle: 30, keepIntvl: 15, keepCnt: 4)
 }
 
+public enum NetworkStatus: Decodable, Equatable {
+    case unknown
+    case connected
+    case disconnected
+    case error(connectionError: String)
+
+    public var statusString: LocalizedStringKey {
+        get {
+            switch self {
+            case .connected: return "connected"
+            case .error: return "error"
+            default: return "connecting"
+            }
+        }
+    }
+
+    public var statusExplanation: LocalizedStringKey {
+        get {
+            switch self {
+            case .connected: return "You are connected to the server used to receive messages from this contact."
+            case let .error(err): return "Trying to connect to the server used to receive messages from this contact (error: \(err))."
+            default: return "Trying to connect to the server used to receive messages from this contact."
+            }
+        }
+    }
+
+    public var imageName: String {
+        get {
+            switch self {
+            case .unknown: return "circle.dotted"
+            case .connected: return "circle.fill"
+            case .disconnected: return "ellipsis.circle.fill"
+            case .error: return "exclamationmark.circle.fill"
+            }
+        }
+    }
+}
+
+public struct ConnNetworkStatus: Decodable {
+    public var agentConnId: String
+    public var networkStatus: NetworkStatus
+}
+
 public struct ChatSettings: Codable {
     public var enableNtfs: MsgFilter
     public var sendRcpts: Bool?
diff --git a/apps/ios/SimpleXChat/ChatTypes.swift b/apps/ios/SimpleXChat/ChatTypes.swift
index 37e4f0316..caaccb545 100644
--- a/apps/ios/SimpleXChat/ChatTypes.swift
+++ b/apps/ios/SimpleXChat/ChatTypes.swift
@@ -1729,6 +1729,11 @@ public struct GroupInfo: Identifiable, Decodable, NamedChat {
     )
 }
 
+public struct GroupRef: Decodable {
+    public var groupId: Int64
+    var localDisplayName: GroupName
+}
+
 public struct GroupProfile: Codable, NamedChat {
     public init(displayName: String, fullName: String, description: String? = nil, image: String? = nil, groupPreferences: GroupPreferences? = nil) {
         self.displayName = displayName
@@ -1871,6 +1876,11 @@ public struct GroupMemberRef: Decodable {
     var profile: Profile
 }
 
+public struct GroupMemberIds: Decodable {
+    var groupMemberId: Int64
+    var groupId: Int64
+}
+
 public enum GroupMemberRole: String, Identifiable, CaseIterable, Comparable, Decodable {
     case observer = "observer"
     case member = "member"
@@ -1963,7 +1973,7 @@ public enum InvitedBy: Decodable {
 }
 
 public struct MemberSubError: Decodable {
-    var member: GroupMember
+    var member: GroupMemberIds
     var memberError: ChatError
 }
 
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/ChatModel.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/ChatModel.kt
index ac5f9fb8a..a4b76cc79 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/ChatModel.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/ChatModel.kt
@@ -789,16 +789,19 @@ sealed class NetworkStatus {
   val statusExplanation: String get() =
     when (this) {
       is Connected -> generalGetString(MR.strings.connected_to_server_to_receive_messages_from_contact)
-      is Error -> String.format(generalGetString(MR.strings.trying_to_connect_to_server_to_receive_messages_with_error), error)
+      is Error -> String.format(generalGetString(MR.strings.trying_to_connect_to_server_to_receive_messages_with_error), connectionError)
       else -> generalGetString(MR.strings.trying_to_connect_to_server_to_receive_messages)
     }
 
   @Serializable @SerialName("unknown") class Unknown: NetworkStatus()
   @Serializable @SerialName("connected") class Connected: NetworkStatus()
   @Serializable @SerialName("disconnected") class Disconnected: NetworkStatus()
-  @Serializable @SerialName("error") class Error(val error: String): NetworkStatus()
+  @Serializable @SerialName("error") class Error(val connectionError: String): NetworkStatus()
 }
 
+@Serializable
+data class ConnNetworkStatus(val agentConnId: String, val networkStatus: NetworkStatus)
+
 @Serializable
 data class Contact(
   val contactId: Long,
@@ -1051,6 +1054,9 @@ data class GroupInfo (
   }
 }
 
+@Serializable
+data class GroupRef(val groupId: Long, val localDisplayName: String)
+
 @Serializable
 data class GroupProfile (
   override val displayName: String,
@@ -1159,11 +1165,17 @@ data class GroupMember (
 data class GroupMemberSettings(val showMessages: Boolean) {}
 
 @Serializable
-class GroupMemberRef(
+data class GroupMemberRef(
   val groupMemberId: Long,
   val profile: Profile
 )
 
+@Serializable
+data class GroupMemberIds(
+  val groupMemberId: Long,
+  val groupId: Long
+)
+
 @Serializable
 enum class GroupMemberRole(val memberRole: String) {
   @SerialName("observer") Observer("observer"), // order matters in comparisons
@@ -1257,7 +1269,7 @@ class LinkPreview (
 
 @Serializable
 class MemberSubError (
-  val member: GroupMember,
+  val member: GroupMemberIds,
   val memberError: ChatError
 )
 
diff --git a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/SimpleXAPI.kt b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/SimpleXAPI.kt
index dc2c3c0f2..e19520093 100644
--- a/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/SimpleXAPI.kt
+++ b/apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/SimpleXAPI.kt
@@ -1082,6 +1082,13 @@ object ChatController {
     return r is CR.CmdOk
   }
 
+  suspend fun apiGetNetworkStatuses(): List<ConnNetworkStatus>? {
+    val r = sendCmd(CC.ApiGetNetworkStatuses())
+    if (r is CR.NetworkStatuses) return r.networkStatuses
+    Log.e(TAG, "apiGetNetworkStatuses bad response: ${r.responseType} ${r.details}")
+    return null
+  }
+
   suspend fun apiChatRead(type: ChatType, id: Long, range: CC.ItemRange): Boolean {
     val r = sendCmd(CC.ApiChatRead(type, id, range))
     if (r is CR.CmdOk) return true
@@ -1425,12 +1432,6 @@ object ChatController {
       }
       is CR.ContactsSubscribed -> updateContactsStatus(r.contactRefs, NetworkStatus.Connected())
       is CR.ContactsDisconnected -> updateContactsStatus(r.contactRefs, NetworkStatus.Disconnected())
-      is CR.ContactSubError -> {
-        if (active(r.user)) {
-          chatModel.updateContact(r.contact)
-        }
-        processContactSubError(r.contact, r.chatError)
-      }
       is CR.ContactSubSummary -> {
         for (sub in r.contactSubscriptions) {
           if (active(r.user)) {
@@ -1444,6 +1445,16 @@ object ChatController {
           }
         }
       }
+      is CR.NetworkStatusResp -> {
+        for (cId in r.connections) {
+          chatModel.networkStatuses[cId] = r.networkStatus
+        }
+      }
+      is CR.NetworkStatuses -> {
+        for (s in r.networkStatuses) {
+          chatModel.networkStatuses[s.agentConnId] = s.networkStatus
+        }
+      }
       is CR.NewChatItem -> {
         val cInfo = r.chatItem.chatInfo
         val cItem = r.chatItem.chatItem
@@ -1915,6 +1926,7 @@ sealed class CC {
   class ApiSendCallExtraInfo(val contact: Contact, val extraInfo: WebRTCExtraInfo): CC()
   class ApiEndCall(val contact: Contact): CC()
   class ApiCallStatus(val contact: Contact, val callStatus: WebRTCCallStatus): CC()
+  class ApiGetNetworkStatuses(): CC()
   class ApiAcceptContact(val incognito: Boolean, val contactReqId: Long): CC()
   class ApiRejectContact(val contactReqId: Long): CC()
   class ApiChatRead(val type: ChatType, val id: Long, val range: ItemRange): CC()
@@ -2024,6 +2036,7 @@ sealed class CC {
     is ApiSendCallExtraInfo -> "/_call extra @${contact.apiId} ${json.encodeToString(extraInfo)}"
     is ApiEndCall -> "/_call end @${contact.apiId}"
     is ApiCallStatus -> "/_call status @${contact.apiId} ${callStatus.value}"
+    is ApiGetNetworkStatuses -> "/_network_statuses"
     is ApiChatRead -> "/_read chat ${chatRef(type, id)} from=${range.from} to=${range.to}"
     is ApiChatUnread -> "/_unread chat ${chatRef(type, id)} ${onOff(unreadChat)}"
     is ReceiveFile -> "/freceive $fileId encrypt=${onOff(encrypted)}" + (if (inline == null) "" else " inline=${onOff(inline)}")
@@ -2120,6 +2133,7 @@ sealed class CC {
     is ApiSendCallExtraInfo -> "apiSendCallExtraInfo"
     is ApiEndCall -> "apiEndCall"
     is ApiCallStatus -> "apiCallStatus"
+    is ApiGetNetworkStatuses -> "apiGetNetworkStatuses"
     is ApiChatRead -> "apiChatRead"
     is ApiChatUnread -> "apiChatUnread"
     is ReceiveFile -> "receiveFile"
@@ -3333,11 +3347,14 @@ sealed class CR {
   @Serializable @SerialName("acceptingContactRequest") class AcceptingContactRequest(val user: UserRef, val contact: Contact): CR()
   @Serializable @SerialName("contactRequestRejected") class ContactRequestRejected(val user: UserRef): CR()
   @Serializable @SerialName("contactUpdated") class ContactUpdated(val user: UserRef, val toContact: Contact): CR()
+  // TODO remove below
   @Serializable @SerialName("contactsSubscribed") class ContactsSubscribed(val server: String, val contactRefs: List<ContactRef>): CR()
   @Serializable @SerialName("contactsDisconnected") class ContactsDisconnected(val server: String, val contactRefs: List<ContactRef>): CR()
-  @Serializable @SerialName("contactSubError") class ContactSubError(val user: UserRef, val contact: Contact, val chatError: ChatError): CR()
   @Serializable @SerialName("contactSubSummary") class ContactSubSummary(val user: UserRef, val contactSubscriptions: List<ContactSubStatus>): CR()
-  @Serializable @SerialName("groupSubscribed") class GroupSubscribed(val user: UserRef, val group: GroupInfo): CR()
+  // TODO remove above
+  @Serializable @SerialName("networkStatus") class NetworkStatusResp(val networkStatus: NetworkStatus, val connections: List<String>): CR()
+  @Serializable @SerialName("networkStatuses") class NetworkStatuses(val user_: UserRef?, val networkStatuses: List<ConnNetworkStatus>): CR()
+  @Serializable @SerialName("groupSubscribed") class GroupSubscribed(val user: UserRef, val group: GroupRef): CR()
   @Serializable @SerialName("memberSubErrors") class MemberSubErrors(val user: UserRef, val memberSubErrors: List<MemberSubError>): CR()
   @Serializable @SerialName("groupEmpty") class GroupEmpty(val user: UserRef, val group: GroupInfo): CR()
   @Serializable @SerialName("userContactLinkSubscribed") class UserContactLinkSubscribed: CR()
@@ -3467,8 +3484,9 @@ sealed class CR {
     is ContactUpdated -> "contactUpdated"
     is ContactsSubscribed -> "contactsSubscribed"
     is ContactsDisconnected -> "contactsDisconnected"
-    is ContactSubError -> "contactSubError"
     is ContactSubSummary -> "contactSubSummary"
+    is NetworkStatusResp -> "networkStatus"
+    is NetworkStatuses -> "networkStatuses"
     is GroupSubscribed -> "groupSubscribed"
     is MemberSubErrors -> "memberSubErrors"
     is GroupEmpty -> "groupEmpty"
@@ -3596,8 +3614,9 @@ sealed class CR {
     is ContactUpdated -> withUser(user, json.encodeToString(toContact))
     is ContactsSubscribed -> "server: $server\ncontacts:\n${json.encodeToString(contactRefs)}"
     is ContactsDisconnected -> "server: $server\ncontacts:\n${json.encodeToString(contactRefs)}"
-    is ContactSubError -> withUser(user, "error:\n${chatError.string}\ncontact:\n${json.encodeToString(contact)}")
     is ContactSubSummary -> withUser(user, json.encodeToString(contactSubscriptions))
+    is NetworkStatusResp -> "networkStatus $networkStatus\nconnections: $connections"
+    is NetworkStatuses -> withUser(user_, json.encodeToString(networkStatuses))
     is GroupSubscribed -> withUser(user, json.encodeToString(group))
     is MemberSubErrors -> withUser(user, json.encodeToString(memberSubErrors))
     is GroupEmpty -> withUser(user, json.encodeToString(group))
diff --git a/src/Simplex/Chat.hs b/src/Simplex/Chat.hs
index b7421d936..56077c3bf 100644
--- a/src/Simplex/Chat.hs
+++ b/src/Simplex/Chat.hs
@@ -143,7 +143,8 @@ defaultChatConfig =
       initialCleanupManagerDelay = 30 * 1000000, -- 30 seconds
       cleanupManagerInterval = 30 * 60, -- 30 minutes
       cleanupManagerStepDelay = 3 * 1000000, -- 3 seconds
-      ciExpirationInterval = 30 * 60 * 1000000 -- 30 minutes
+      ciExpirationInterval = 30 * 60 * 1000000, -- 30 minutes
+      coreApi = False
     }
 
 _defaultSMPServers :: NonEmpty SMPServerWithAuth
@@ -195,6 +196,7 @@ newChatController ChatDatabase {chatStore, agentStore} user cfg@ChatConfig {agen
   idsDrg <- newTVarIO =<< liftIO drgNew
   inputQ <- newTBQueueIO tbqSize
   outputQ <- newTBQueueIO tbqSize
+  connNetworkStatuses <- atomically TM.empty
   subscriptionMode <- newTVarIO SMSubscribe
   chatLock <- newEmptyTMVarIO
   sndFiles <- newTVarIO M.empty
@@ -221,6 +223,7 @@ newChatController ChatDatabase {chatStore, agentStore} user cfg@ChatConfig {agen
         idsDrg,
         inputQ,
         outputQ,
+        connNetworkStatuses,
         subscriptionMode,
         chatLock,
         sndFiles,
@@ -1086,6 +1089,8 @@ processChatCommand = \case
         user <- getUserByContactId db contactId
         contact <- getContact db user contactId
         pure RcvCallInvitation {user, contact, callType = peerCallType, sharedKey, callTs}
+  APIGetNetworkStatuses -> withUser $ \_ ->
+    CRNetworkStatuses Nothing . map (uncurry ConnNetworkStatus) . M.toList <$> chatReadVar connNetworkStatuses
   APICallStatus contactId receivedStatus ->
     withCurrentCall contactId $ \user ct call ->
       updateCallItemStatus user ct call receivedStatus Nothing $> Just call
@@ -1688,6 +1693,8 @@ processChatCommand = \case
         (connId, cReq) <- withAgent $ \a -> createConnection a (aUserId user) True SCMInvitation Nothing subMode
         -- [incognito] reuse membership incognito profile
         ct <- withStore' $ \db -> createMemberContact db user connId cReq g m mConn subMode
+        -- TODO not sure it is correct to set connections status here?
+        setContactNetworkStatus ct NSConnected
         pure $ CRNewMemberContact user ct g m
       _ -> throwChatError CEGroupMemberNotActive
   APISendMemberContactInvitation contactId msgContent_ -> withUser $ \user -> do
@@ -2627,6 +2634,7 @@ subscribeUserConnections onlyNeeded agentBatchSubscribe user@User {userId} = do
   rs <- withAgent $ \a -> agentBatchSubscribe a conns
   -- send connection events to view
   contactSubsToView rs cts ce
+-- TODO possibly, we could either disable these events or replace with less noisy for API
   contactLinkSubsToView rs ucs
   groupSubsToView rs gs ms ce
   sndFileSubsToView rs sfts
@@ -2687,12 +2695,30 @@ subscribeUserConnections onlyNeeded agentBatchSubscribe user@User {userId} = do
       let connIds = map aConnId' pcs
       pure (connIds, M.fromList $ zip connIds pcs)
     contactSubsToView :: Map ConnId (Either AgentErrorType ()) -> Map ConnId Contact -> Bool -> m ()
-    contactSubsToView rs cts ce = do
-      toView . CRContactSubSummary user $ map (uncurry ContactSubStatus) cRs
-      when ce $ mapM_ (toView . uncurry (CRContactSubError user)) cErrors
+    contactSubsToView rs cts ce = ifM (asks $ coreApi . config) notifyAPI notifyCLI
       where
-        cRs = resultsFor rs cts
-        cErrors = sortOn (\(Contact {localDisplayName = n}, _) -> n) $ filterErrors cRs
+        notifyCLI = do
+          let cRs = resultsFor rs cts
+              cErrors = sortOn (\(Contact {localDisplayName = n}, _) -> n) $ filterErrors cRs
+          toView . CRContactSubSummary user $ map (uncurry ContactSubStatus) cRs
+          when ce $ mapM_ (toView . uncurry (CRContactSubError user)) cErrors
+        notifyAPI = do
+          let statuses = M.foldrWithKey' addStatus [] cts
+          chatModifyVar connNetworkStatuses $ M.union (M.fromList statuses)
+          toView $ CRNetworkStatuses (Just user) $ map (uncurry ConnNetworkStatus) statuses
+          where
+            addStatus :: ConnId -> Contact -> [(AgentConnId, NetworkStatus)] -> [(AgentConnId, NetworkStatus)]
+            addStatus connId ct =
+              let ns = (contactAgentConnId ct, netStatus $ resultErr connId rs)
+              in (ns :)
+            netStatus :: Maybe ChatError -> NetworkStatus
+            netStatus = maybe NSConnected $ NSError . errorNetworkStatus
+            errorNetworkStatus :: ChatError -> String
+            errorNetworkStatus = \case
+              ChatErrorAgent (BROKER _ NETWORK) _ -> "network"
+              ChatErrorAgent (SMP SMP.AUTH) _ -> "contact deleted"
+              e -> show e
+-- TODO possibly below could be replaced with less noisy events for API
     contactLinkSubsToView :: Map ConnId (Either AgentErrorType ()) -> Map ConnId UserContact -> m ()
     contactLinkSubsToView rs = toView . CRUserContactSubSummary user . map (uncurry UserContactSubStatus) . resultsFor rs
     groupSubsToView :: Map ConnId (Either AgentErrorType ()) -> [Group] -> Map ConnId GroupMember -> Bool -> m ()
@@ -2742,12 +2768,12 @@ subscribeUserConnections onlyNeeded agentBatchSubscribe user@User {userId} = do
     resultsFor rs = M.foldrWithKey' addResult []
       where
         addResult :: ConnId -> a -> [(a, Maybe ChatError)] -> [(a, Maybe ChatError)]
-        addResult connId = (:) . (,err)
-          where
-            err = case M.lookup connId rs of
-              Just (Left e) -> Just $ ChatErrorAgent e Nothing
-              Just _ -> Nothing
-              _ -> Just . ChatError . CEAgentNoSubResult $ AgentConnId connId
+        addResult connId = (:) . (,resultErr connId rs)
+    resultErr :: ConnId -> Map ConnId (Either AgentErrorType ()) -> Maybe ChatError
+    resultErr connId rs = case M.lookup connId rs of
+      Just (Left e) -> Just $ ChatErrorAgent e Nothing
+      Just _ -> Nothing
+      _ -> Just . ChatError . CEAgentNoSubResult $ AgentConnId connId
 
 cleanupManager :: forall m. ChatMonad m => m ()
 cleanupManager = do
@@ -2892,16 +2918,22 @@ processAgentMessageNoConn :: forall m. ChatMonad m => ACommand 'Agent 'AENone ->
 processAgentMessageNoConn = \case
   CONNECT p h -> hostEvent $ CRHostConnected p h
   DISCONNECT p h -> hostEvent $ CRHostDisconnected p h
-  DOWN srv conns -> serverEvent srv conns CRContactsDisconnected
-  UP srv conns -> serverEvent srv conns CRContactsSubscribed
+  DOWN srv conns -> serverEvent srv conns NSDisconnected CRContactsDisconnected
+  UP srv conns -> serverEvent srv conns NSConnected CRContactsSubscribed
   SUSPENDED -> toView CRChatSuspended
   DEL_USER agentUserId -> toView $ CRAgentUserDeleted agentUserId
   where
     hostEvent :: ChatResponse -> m ()
     hostEvent = whenM (asks $ hostEvents . config) . toView
-    serverEvent srv conns event = do
-      cs <- withStore' (`getConnectionsContacts` conns)
-      toView $ event srv cs
+    serverEvent srv conns nsStatus event = ifM (asks $ coreApi . config) notifyAPI notifyCLI
+      where
+        notifyAPI = do
+          let connIds = map AgentConnId conns
+          chatModifyVar connNetworkStatuses $ \m -> foldl' (\m' cId -> M.insert cId nsStatus m') m connIds
+          toView $ CRNetworkStatus nsStatus connIds
+        notifyCLI = do
+          cs <- withStore' (`getConnectionsContacts` conns)
+          toView $ event srv cs
 
 processAgentMsgSndFile :: forall m. ChatMonad m => ACorrId -> SndFileId -> ACommand 'Agent 'AESndFile -> m ()
 processAgentMsgSndFile _corrId aFileId msg =
@@ -3188,6 +3220,7 @@ processAgentMessageConn user@User {userId} corrId agentConnId agentMessage = do
             Nothing -> do
               -- [incognito] print incognito profile used for this contact
               incognitoProfile <- forM customUserProfileId $ \profileId -> withStore (\db -> getProfileById db userId profileId)
+              setContactNetworkStatus ct NSConnected
               toView $ CRContactConnected user ct (fmap fromLocalProfile incognitoProfile)
               when (directOrUsed ct) $ createFeatureEnabledItems ct
               when (contactConnInitiated conn) $ do
@@ -3762,6 +3795,7 @@ processAgentMessageConn user@User {userId} corrId agentConnId agentMessage = do
     notifyMemberConnected :: GroupInfo -> GroupMember -> Maybe Contact -> m ()
     notifyMemberConnected gInfo m ct_ = do
       memberConnectedChatItem gInfo m
+      mapM_ (`setContactNetworkStatus` NSConnected) ct_
       toView $ CRConnectedToGroupMember user gInfo m ct_
 
     probeMatchingContactsAndMembers :: Contact -> IncognitoEnabled -> Bool -> m ()
@@ -5569,6 +5603,7 @@ chatCommandP =
       "/_call end @" *> (APIEndCall <$> A.decimal),
       "/_call status @" *> (APICallStatus <$> A.decimal <* A.space <*> strP),
       "/_call get" $> APIGetCallInvitations,
+      "/_network_statuses" $> APIGetNetworkStatuses,
       "/_profile " *> (APIUpdateProfile <$> A.decimal <* A.space <*> jsonP),
       "/_set alias @" *> (APISetContactAlias <$> A.decimal <*> (A.space *> textP <|> pure "")),
       "/_set alias :" *> (APISetConnectionAlias <$> A.decimal <*> (A.space *> textP <|> pure "")),
diff --git a/src/Simplex/Chat/Controller.hs b/src/Simplex/Chat/Controller.hs
index af9f34d2d..2704c2721 100644
--- a/src/Simplex/Chat/Controller.hs
+++ b/src/Simplex/Chat/Controller.hs
@@ -32,6 +32,7 @@ import Data.Char (ord)
 import Data.Int (Int64)
 import Data.List.NonEmpty (NonEmpty)
 import Data.Map.Strict (Map)
+import qualified Data.Map.Strict as M
 import Data.String
 import Data.Text (Text)
 import Data.Time (NominalDiffTime, UTCTime)
@@ -124,7 +125,8 @@ data ChatConfig = ChatConfig
     initialCleanupManagerDelay :: Int64,
     cleanupManagerInterval :: NominalDiffTime,
     cleanupManagerStepDelay :: Int64,
-    ciExpirationInterval :: Int64 -- microseconds
+    ciExpirationInterval :: Int64, -- microseconds
+    coreApi :: Bool
   }
 
 data DefaultAgentServers = DefaultAgentServers
@@ -164,6 +166,7 @@ data ChatController = ChatController
     idsDrg :: TVar ChaChaDRG,
     inputQ :: TBQueue String,
     outputQ :: TBQueue (Maybe CorrId, ChatResponse),
+    connNetworkStatuses :: TMap AgentConnId NetworkStatus,
     subscriptionMode :: TVar SubscriptionMode,
     chatLock :: Lock,
     sndFiles :: TVar (Map Int64 Handle),
@@ -251,6 +254,7 @@ data ChatCommand
   | APIEndCall ContactId
   | APIGetCallInvitations
   | APICallStatus ContactId WebRTCCallStatus
+  | APIGetNetworkStatuses
   | APIUpdateProfile UserId Profile
   | APISetContactPrefs ContactId Preferences
   | APISetContactAlias ContactId LocalAlias
@@ -528,6 +532,8 @@ data ChatResponse
   | CRContactSubError {user :: User, contact :: Contact, chatError :: ChatError}
   | CRContactSubSummary {user :: User, contactSubscriptions :: [ContactSubStatus]}
   | CRUserContactSubSummary {user :: User, userContactSubscriptions :: [UserContactSubStatus]}
+  | CRNetworkStatus {networkStatus :: NetworkStatus, connections :: [AgentConnId]}
+  | CRNetworkStatuses {user_ :: Maybe User, networkStatuses :: [ConnNetworkStatus]}
   | CRHostConnected {protocol :: AProtocolType, transportHost :: TransportHost}
   | CRHostDisconnected {protocol :: AProtocolType, transportHost :: TransportHost}
   | CRGroupInvitation {user :: User, groupInfo :: GroupInfo}
@@ -1044,6 +1050,13 @@ chatWriteVar :: ChatMonad' m => (ChatController -> TVar a) -> a -> m ()
 chatWriteVar f value = asks f >>= atomically . (`writeTVar` value)
 {-# INLINE chatWriteVar #-}
 
+chatModifyVar :: ChatMonad' m => (ChatController -> TVar a) -> (a -> a) -> m ()
+chatModifyVar f newValue = asks f >>= atomically . (`modifyTVar'` newValue)
+{-# INLINE chatModifyVar #-}
+
+setContactNetworkStatus :: ChatMonad' m => Contact -> NetworkStatus -> m ()
+setContactNetworkStatus ct = chatModifyVar connNetworkStatuses . M.insert (contactAgentConnId ct)
+
 tryChatError :: ChatMonad m => m a -> m (Either ChatError a)
 tryChatError = tryAllErrors mkChatError
 {-# INLINE tryChatError #-}
diff --git a/src/Simplex/Chat/Mobile.hs b/src/Simplex/Chat/Mobile.hs
index 0a970d2c8..b44488814 100644
--- a/src/Simplex/Chat/Mobile.hs
+++ b/src/Simplex/Chat/Mobile.hs
@@ -169,7 +169,8 @@ defaultMobileConfig :: ChatConfig
 defaultMobileConfig =
   defaultChatConfig
     { confirmMigrations = MCYesUp,
-      logLevel = CLLError
+      logLevel = CLLError,
+      coreApi = True
     }
 
 getActiveUser_ :: SQLiteStore -> IO (Maybe User)
diff --git a/src/Simplex/Chat/Types.hs b/src/Simplex/Chat/Types.hs
index 83d0664a0..9992f96ab 100644
--- a/src/Simplex/Chat/Types.hs
+++ b/src/Simplex/Chat/Types.hs
@@ -192,6 +192,9 @@ instance ToJSON Contact where
 contactConn :: Contact -> Connection
 contactConn Contact {activeConn} = activeConn
 
+contactAgentConnId :: Contact -> AgentConnId
+contactAgentConnId Contact {activeConn = Connection {agentConnId}} = agentConnId
+
 contactConnId :: Contact -> ConnId
 contactConnId = aConnId . contactConn
 
@@ -1140,13 +1143,16 @@ liveRcvFileTransferPath ft = fp <$> liveRcvFileTransferInfo ft
     fp RcvFileInfo {filePath} = filePath
 
 newtype AgentConnId = AgentConnId ConnId
-  deriving (Eq, Show)
+  deriving (Eq, Ord, Show)
 
 instance StrEncoding AgentConnId where
   strEncode (AgentConnId connId) = strEncode connId
   strDecode s = AgentConnId <$> strDecode s
   strP = AgentConnId <$> strP
 
+instance FromJSON AgentConnId where
+  parseJSON = strParseJSON "AgentConnId"
+
 instance ToJSON AgentConnId where
   toJSON = strToJSON
   toEncoding = strToJEncoding
@@ -1477,6 +1483,35 @@ serializeIntroStatus = \case
 textParseJSON :: TextEncoding a => String -> J.Value -> JT.Parser a
 textParseJSON name = J.withText name $ maybe (fail $ "bad " <> name) pure . textDecode
 
+data NetworkStatus
+  = NSUnknown
+  | NSConnected
+  | NSDisconnected
+  | NSError {connectionError :: String}
+  deriving (Eq, Ord, Show, Generic)
+
+netStatusStr :: NetworkStatus -> String
+netStatusStr = \case
+  NSUnknown -> "unknown"
+  NSConnected -> "connected"
+  NSDisconnected -> "disconnected"
+  NSError e -> "error: " <> e
+
+instance FromJSON NetworkStatus where
+  parseJSON = J.genericParseJSON . sumTypeJSON $ dropPrefix "NS"
+
+instance ToJSON NetworkStatus where
+  toJSON = J.genericToJSON . sumTypeJSON $ dropPrefix "NS"
+  toEncoding = J.genericToEncoding . sumTypeJSON $ dropPrefix "NS"
+
+data ConnNetworkStatus = ConnNetworkStatus
+  { agentConnId :: AgentConnId,
+    networkStatus :: NetworkStatus
+  }
+  deriving (Show, Generic, FromJSON)
+
+instance ToJSON ConnNetworkStatus where toEncoding = J.genericToEncoding J.defaultOptions
+
 type CommandId = Int64
 
 aCorrId :: CommandId -> ACorrId
diff --git a/src/Simplex/Chat/View.hs b/src/Simplex/Chat/View.hs
index 86a10988d..bcbc45f4e 100644
--- a/src/Simplex/Chat/View.hs
+++ b/src/Simplex/Chat/View.hs
@@ -19,7 +19,7 @@ import Data.Char (isSpace, toUpper)
 import Data.Function (on)
 import Data.Int (Int64)
 import Data.List (groupBy, intercalate, intersperse, partition, sortOn)
-import Data.List.NonEmpty (NonEmpty)
+import Data.List.NonEmpty (NonEmpty (..))
 import qualified Data.List.NonEmpty as L
 import Data.Map.Strict (Map)
 import qualified Data.Map.Strict as M
@@ -210,6 +210,8 @@ responseToView user_ ChatConfig {logLevel, showReactions, showReceipts, testView
       (addresses, groupLinks) = partition (\UserContactSubStatus {userContact} -> isNothing . userContactGroupId $ userContact) summary
       addressSS UserContactSubStatus {userContactError} = maybe ("Your address is active! To show: " <> highlight' "/sa") (\e -> "User address error: " <> sShow e <> ", to delete your address: " <> highlight' "/da") userContactError
       (groupLinkErrors, groupLinksSubscribed) = partition (isJust . userContactError) groupLinks
+  CRNetworkStatus status conns -> if testView then [plain $ show (length conns) <> " connections " <> netStatusStr status] else []
+  CRNetworkStatuses u statuses -> if testView then ttyUser' u $ viewNetworkStatuses statuses else []
   CRGroupInvitation u g -> ttyUser u [groupInvitation' g]
   CRReceivedGroupInvitation {user = u, groupInfo = g, contact = c, memberRole = r} -> ttyUser u $ viewReceivedGroupInvitation g c r
   CRUserJoinedGroup u g _ -> ttyUser u $ viewUserJoinedGroup g
@@ -800,6 +802,12 @@ viewDirectMessagesProhibited :: MsgDirection -> Contact -> [StyledString]
 viewDirectMessagesProhibited MDSnd c = ["direct messages to indirect contact " <> ttyContact' c <> " are prohibited"]
 viewDirectMessagesProhibited MDRcv c = ["received prohibited direct message from indirect contact " <> ttyContact' c <> " (discarded)"]
 
+viewNetworkStatuses :: [ConnNetworkStatus] -> [StyledString]
+viewNetworkStatuses = map viewStatuses . L.groupBy ((==) `on` netStatus) . sortOn netStatus
+  where
+    netStatus ConnNetworkStatus {networkStatus} = networkStatus
+    viewStatuses ss@(s :| _) = plain $ show (L.length ss) <> " connections " <> netStatusStr (netStatus s)
+
 viewUserJoinedGroup :: GroupInfo -> [StyledString]
 viewUserJoinedGroup g =
   case incognitoMembershipProfile g of
diff --git a/tests/ChatTests/Direct.hs b/tests/ChatTests/Direct.hs
index b4c3c53cd..677bc4c09 100644
--- a/tests/ChatTests/Direct.hs
+++ b/tests/ChatTests/Direct.hs
@@ -119,6 +119,8 @@ chatDirectTests = do
       testReqVRange vr11 supportedChatVRange
       testReqVRange vr11 vr11
     it "update peer version range on received messages" testUpdatePeerChatVRange
+  describe "network statuses" $ do
+    it "should get network statuses" testGetNetworkStatuses
   where
     testInvVRange vr1 vr2 = it (vRangeStr vr1 <> " - " <> vRangeStr vr2) $ testConnInvChatVRange vr1 vr2
     testReqVRange vr1 vr2 = it (vRangeStr vr1 <> " - " <> vRangeStr vr2) $ testConnReqChatVRange vr1 vr2
@@ -2623,6 +2625,20 @@ testUpdatePeerChatVRange tmp =
   where
     cfg11 = testCfg {chatVRange = vr11} :: ChatConfig
 
+testGetNetworkStatuses :: HasCallStack => FilePath -> IO ()
+testGetNetworkStatuses tmp = do
+  withNewTestChatCfg tmp cfg "alice" aliceProfile $ \alice -> do
+    withNewTestChatCfg tmp cfg "bob" bobProfile $ \bob -> do
+      connectUsers alice bob
+      alice ##> "/_network_statuses"
+      alice <## "1 connections connected"
+  withTestChatCfg tmp cfg "alice" $ \alice ->
+    withTestChatCfg tmp cfg "bob" $ \bob -> do
+      alice <## "1 connections connected"
+      bob <## "1 connections connected"
+  where
+    cfg = testCfg {coreApi = True}
+
 vr11 :: VersionRange
 vr11 = mkVersionRange 1 1
 
diff --git a/tests/MobileTests.hs b/tests/MobileTests.hs
index 692dd5884..aa36b397a 100644
--- a/tests/MobileTests.hs
+++ b/tests/MobileTests.hs
@@ -120,19 +120,19 @@ chatStartedSwift = "{\"resp\":{\"_owsf\":true,\"chatStarted\":{}}}"
 chatStartedTagged :: LB.ByteString
 chatStartedTagged = "{\"resp\":{\"type\":\"chatStarted\"}}"
 
-contactSubSummary :: LB.ByteString
-contactSubSummary =
+networkStatuses :: LB.ByteString
+networkStatuses =
 #if defined(darwin_HOST_OS) && defined(swiftJSON)
-  contactSubSummarySwift
+  networkStatusesSwift
 #else
-  contactSubSummaryTagged
+  networkStatusesTagged
 #endif
 
-contactSubSummarySwift :: LB.ByteString
-contactSubSummarySwift = "{\"resp\":{\"_owsf\":true,\"contactSubSummary\":{" <> userJSON <> ",\"contactSubscriptions\":[]}}}"
+networkStatusesSwift :: LB.ByteString
+networkStatusesSwift = "{\"resp\":{\"_owsf\":true,\"networkStatuses\":{\"user_\":" <> userJSON <> ",\"networkStatuses\":[]}}}"
 
-contactSubSummaryTagged :: LB.ByteString
-contactSubSummaryTagged = "{\"resp\":{\"type\":\"contactSubSummary\"," <> userJSON <> ",\"contactSubscriptions\":[]}}"
+networkStatusesTagged :: LB.ByteString
+networkStatusesTagged = "{\"resp\":{\"type\":\"networkStatuses\",\"user_\":" <> userJSON <> ",\"networkStatuses\":[]}}"
 
 memberSubSummary :: LB.ByteString
 memberSubSummary =
@@ -143,10 +143,10 @@ memberSubSummary =
 #endif
 
 memberSubSummarySwift :: LB.ByteString
-memberSubSummarySwift = "{\"resp\":{\"_owsf\":true,\"memberSubSummary\":{" <> userJSON <> ",\"memberSubscriptions\":[]}}}"
+memberSubSummarySwift = "{\"resp\":{\"_owsf\":true,\"memberSubSummary\":{\"user\":" <> userJSON <> ",\"memberSubscriptions\":[]}}}"
 
 memberSubSummaryTagged :: LB.ByteString
-memberSubSummaryTagged = "{\"resp\":{\"type\":\"memberSubSummary\"," <> userJSON <> ",\"memberSubscriptions\":[]}}"
+memberSubSummaryTagged = "{\"resp\":{\"type\":\"memberSubSummary\",\"user\":" <> userJSON <> ",\"memberSubscriptions\":[]}}"
 
 userContactSubSummary :: LB.ByteString
 userContactSubSummary =
@@ -157,10 +157,10 @@ userContactSubSummary =
 #endif
 
 userContactSubSummarySwift :: LB.ByteString
-userContactSubSummarySwift = "{\"resp\":{\"_owsf\":true,\"userContactSubSummary\":{" <> userJSON <> ",\"userContactSubscriptions\":[]}}}"
+userContactSubSummarySwift = "{\"resp\":{\"_owsf\":true,\"userContactSubSummary\":{\"user\":" <> userJSON <> ",\"userContactSubscriptions\":[]}}}"
 
 userContactSubSummaryTagged :: LB.ByteString
-userContactSubSummaryTagged = "{\"resp\":{\"type\":\"userContactSubSummary\"," <> userJSON <> ",\"userContactSubscriptions\":[]}}"
+userContactSubSummaryTagged = "{\"resp\":{\"type\":\"userContactSubSummary\",\"user\":" <> userJSON <> ",\"userContactSubscriptions\":[]}}"
 
 pendingSubSummary :: LB.ByteString
 pendingSubSummary =
@@ -171,13 +171,13 @@ pendingSubSummary =
 #endif
 
 pendingSubSummarySwift :: LB.ByteString
-pendingSubSummarySwift = "{\"resp\":{\"_owsf\":true,\"pendingSubSummary\":{" <> userJSON <> ",\"pendingSubscriptions\":[]}}}"
+pendingSubSummarySwift = "{\"resp\":{\"_owsf\":true,\"pendingSubSummary\":{\"user\":" <> userJSON <> ",\"pendingSubscriptions\":[]}}}"
 
 pendingSubSummaryTagged :: LB.ByteString
-pendingSubSummaryTagged = "{\"resp\":{\"type\":\"pendingSubSummary\"," <> userJSON <> ",\"pendingSubscriptions\":[]}}"
+pendingSubSummaryTagged = "{\"resp\":{\"type\":\"pendingSubSummary\",\"user\":" <> userJSON <> ",\"pendingSubscriptions\":[]}}"
 
 userJSON :: LB.ByteString
-userJSON = "\"user\":{\"userId\":1,\"agentUserId\":\"1\",\"userContactId\":1,\"localDisplayName\":\"alice\",\"profile\":{\"profileId\":1,\"displayName\":\"alice\",\"fullName\":\"Alice\",\"localAlias\":\"\"},\"fullPreferences\":{\"timedMessages\":{\"allow\":\"yes\"},\"fullDelete\":{\"allow\":\"no\"},\"reactions\":{\"allow\":\"yes\"},\"voice\":{\"allow\":\"yes\"},\"calls\":{\"allow\":\"yes\"}},\"activeUser\":true,\"showNtfs\":true,\"sendRcptsContacts\":true,\"sendRcptsSmallGroups\":true}"
+userJSON = "{\"userId\":1,\"agentUserId\":\"1\",\"userContactId\":1,\"localDisplayName\":\"alice\",\"profile\":{\"profileId\":1,\"displayName\":\"alice\",\"fullName\":\"Alice\",\"localAlias\":\"\"},\"fullPreferences\":{\"timedMessages\":{\"allow\":\"yes\"},\"fullDelete\":{\"allow\":\"no\"},\"reactions\":{\"allow\":\"yes\"},\"voice\":{\"allow\":\"yes\"},\"calls\":{\"allow\":\"yes\"}},\"activeUser\":true,\"showNtfs\":true,\"sendRcptsContacts\":true,\"sendRcptsSmallGroups\":true}"
 
 parsedMarkdown :: LB.ByteString
 parsedMarkdown =
@@ -215,7 +215,7 @@ testChatApi tmp = do
   chatSendCmd cc "/u" `shouldReturn` activeUser
   chatSendCmd cc "/create user alice Alice" `shouldReturn` activeUserExists
   chatSendCmd cc "/_start" `shouldReturn` chatStarted
-  chatRecvMsg cc `shouldReturn` contactSubSummary
+  chatRecvMsg cc `shouldReturn` networkStatuses
   chatRecvMsg cc `shouldReturn` userContactSubSummary
   chatRecvMsg cc `shouldReturn` memberSubSummary
   chatRecvMsgWait cc 10000 `shouldReturn` pendingSubSummary

From 07047a3ef365bf779bb2d74281e37e45a2cdf57d Mon Sep 17 00:00:00 2001
From: Evgeny Poberezkin <2769109+epoberezkin@users.noreply.github.com>
Date: Fri, 13 Oct 2023 14:29:48 +0100
Subject: [PATCH 4/5] ios: fix pattern match

---
 apps/ios/Shared/Model/SimpleXAPI.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/ios/Shared/Model/SimpleXAPI.swift b/apps/ios/Shared/Model/SimpleXAPI.swift
index e4f64ee97..18e7f7efb 100644
--- a/apps/ios/Shared/Model/SimpleXAPI.swift
+++ b/apps/ios/Shared/Model/SimpleXAPI.swift
@@ -1374,7 +1374,7 @@ func processReceivedMsg(_ res: ChatResponse) async {
                 m.networkStatuses[cId] = status
             }
         }
-    case let .networkStatuses(statuses): ()
+    case let .networkStatuses(_, statuses): ()
         await MainActor.run {
             for s in statuses {
                 m.networkStatuses[s.agentConnId] = s.networkStatus

From c609303348784a23a134424faaad1e2813b247ab Mon Sep 17 00:00:00 2001
From: spaced4ndy <8711996+spaced4ndy@users.noreply.github.com>
Date: Fri, 13 Oct 2023 19:19:00 +0400
Subject: [PATCH 5/5] ios: connect plan (#3205)

* ios: connect plan

* improvements

* wording

* fixes

* rework to use dismissAllSheets with callback

* rework

* update texts

* Update apps/ios/Shared/Views/NewChat/NewChatButton.swift

* Update apps/ios/Shared/Views/NewChat/NewChatButton.swift

---------

Co-authored-by: Evgeny Poberezkin <2769109+epoberezkin@users.noreply.github.com>
---
 apps/ios/Shared/ContentView.swift             |  37 +-
 apps/ios/Shared/Model/ChatModel.swift         |  10 +
 apps/ios/Shared/Model/SimpleXAPI.swift        |  21 +-
 .../Chat/Group/GroupMemberInfoView.swift      |  35 +-
 .../Shared/Views/NewChat/NewChatButton.swift  | 346 ++++++++++++++++--
 .../Views/NewChat/PasteToConnectView.swift    |  18 +-
 .../Views/NewChat/ScanToConnectView.swift     |  18 +-
 apps/ios/SimpleX.xcodeproj/project.pbxproj    |  30 +-
 apps/ios/SimpleXChat/APITypes.swift           |  34 ++
 9 files changed, 437 insertions(+), 112 deletions(-)

diff --git a/apps/ios/Shared/ContentView.swift b/apps/ios/Shared/ContentView.swift
index 3dbcf4700..04eadac2c 100644
--- a/apps/ios/Shared/ContentView.swift
+++ b/apps/ios/Shared/ContentView.swift
@@ -31,11 +31,11 @@ struct ContentView: View {
     @State private var chatListActionSheet: ChatListActionSheet? = nil
 
     private enum ChatListActionSheet: Identifiable {
-        case connectViaUrl(action: ConnReqType, link: String)
+        case planAndConnectSheet(sheet: PlanAndConnectActionSheet)
 
         var id: String {
             switch self {
-            case let .connectViaUrl(_, link): return "connectViaUrl \(link)"
+            case let .planAndConnectSheet(sheet): return sheet.id
             }
         }
     }
@@ -93,7 +93,7 @@ struct ContentView: View {
                 mainView()
                 .actionSheet(item: $chatListActionSheet) { sheet in
                     switch sheet {
-                    case let .connectViaUrl(action, link): return connectViaUrlSheet(action, link)
+                    case let .planAndConnectSheet(sheet): return planAndConnectActionSheet(sheet, dismiss: false)
                     }
                 }
             } else {
@@ -290,12 +290,19 @@ struct ContentView: View {
             if let url = m.appOpenUrl {
                 m.appOpenUrl = nil
                 var path = url.path
-                logger.debug("ContentView.connectViaUrl path: \(path)")
                 if (path == "/contact" || path == "/invitation") {
                     path.removeFirst()
-                    let action: ConnReqType = path == "contact" ? .contact : .invitation
-                    let link = url.absoluteString.replacingOccurrences(of: "///\(path)", with: "/\(path)")
-                    chatListActionSheet = .connectViaUrl(action: action, link: link)
+                    // TODO normalize in backend; revert
+                    // let link = url.absoluteString.replacingOccurrences(of: "///\(path)", with: "/\(path)")
+                    var link = url.absoluteString.replacingOccurrences(of: "///\(path)", with: "/\(path)")
+                    link = link.starts(with: "simplex:/") ? link.replacingOccurrences(of: "simplex:/", with: "https://simplex.chat/") : link
+                    planAndConnect(
+                        link,
+                        showAlert: showPlanAndConnectAlert,
+                        showActionSheet: { chatListActionSheet = .planAndConnectSheet(sheet: $0) },
+                        dismiss: false,
+                        incognito: nil
+                    )
                 } else {
                     AlertManager.shared.showAlert(Alert(title: Text("Error: URL is invalid")))
                 }
@@ -303,20 +310,8 @@ struct ContentView: View {
         }
     }
 
-    private func connectViaUrlSheet(_ action: ConnReqType, _ link: String) -> ActionSheet {
-        let title: LocalizedStringKey
-        switch action {
-        case .contact: title = "Connect via contact link"
-        case .invitation: title = "Connect via one-time link"
-        }
-        return ActionSheet(
-            title: Text(title),
-            buttons: [
-                .default(Text("Use current profile")) { connectViaLink(link, incognito: false) },
-                .default(Text("Use new incognito profile")) { connectViaLink(link, incognito: true) },
-                .cancel()
-            ]
-        )
+    private func showPlanAndConnectAlert(_ alert: PlanAndConnectAlert) {
+        AlertManager.shared.showAlert(planAndConnectAlert(alert, dismiss: false))
     }
 }
 
diff --git a/apps/ios/Shared/Model/ChatModel.swift b/apps/ios/Shared/Model/ChatModel.swift
index ec1a56742..b1a83dd5e 100644
--- a/apps/ios/Shared/Model/ChatModel.swift
+++ b/apps/ios/Shared/Model/ChatModel.swift
@@ -152,6 +152,16 @@ final class ChatModel: ObservableObject {
         }
     }
 
+    func getGroupChat(_ groupId: Int64) -> Chat? {
+        chats.first { chat in
+            if case let .group(groupInfo) = chat.chatInfo {
+                return groupInfo.groupId == groupId
+            } else {
+                return false
+            }
+        }
+    }
+
     private func getChatIndex(_ id: String) -> Int? {
         chats.firstIndex(where: { $0.id == id })
     }
diff --git a/apps/ios/Shared/Model/SimpleXAPI.swift b/apps/ios/Shared/Model/SimpleXAPI.swift
index 18e7f7efb..a1c8cee77 100644
--- a/apps/ios/Shared/Model/SimpleXAPI.swift
+++ b/apps/ios/Shared/Model/SimpleXAPI.swift
@@ -586,6 +586,15 @@ func apiSetConnectionIncognito(connId: Int64, incognito: Bool) async throws -> P
     throw r
 }
 
+func apiConnectPlan(connReq: String) async throws -> ConnectionPlan {
+    logger.error("apiConnectPlan connReq: \(connReq)")
+    let userId = try currentUserId("apiConnectPlan")
+    let r = await chatSendCmd(.apiConnectPlan(userId: userId, connReq: connReq))
+    if case let .connectionPlan(_, connectionPlan) = r { return connectionPlan }
+    logger.error("apiConnectPlan error: \(responseError(r))")
+    throw r
+}
+
 func apiConnect(incognito: Bool, connReq: String) async -> ConnReqType? {
     let (connReqType, alert) = await apiConnect_(incognito: incognito, connReq: connReq)
     if let alert = alert {
@@ -610,10 +619,7 @@ func apiConnect_(incognito: Bool, connReq: String) async -> (ConnReqType?, Alert
         if let c = m.getContactChat(contact.contactId) {
             await MainActor.run { m.chatId = c.id }
         }
-        let alert = mkAlert(
-            title: "Contact already exists",
-            message: "You are already connected to \(contact.displayName)."
-        )
+        let alert = contactAlreadyExistsAlert(contact)
         return (nil, alert)
     case .chatCmdError(_, .error(.invalidConnReq)):
         let alert = mkAlert(
@@ -641,6 +647,13 @@ func apiConnect_(incognito: Bool, connReq: String) async -> (ConnReqType?, Alert
     return (nil, alert)
 }
 
+func contactAlreadyExistsAlert(_ contact: Contact) -> Alert {
+    mkAlert(
+        title: "Contact already exists",
+        message: "You are already connected to \(contact.displayName)."
+    )
+}
+
 private func connectionErrorAlert(_ r: ChatResponse) -> Alert {
     if let networkErrorAlert = networkErrorAlert(r) {
         return networkErrorAlert
diff --git a/apps/ios/Shared/Views/Chat/Group/GroupMemberInfoView.swift b/apps/ios/Shared/Views/Chat/Group/GroupMemberInfoView.swift
index 5ec14f5be..3d10101de 100644
--- a/apps/ios/Shared/Views/Chat/Group/GroupMemberInfoView.swift
+++ b/apps/ios/Shared/Views/Chat/Group/GroupMemberInfoView.swift
@@ -19,7 +19,7 @@ struct GroupMemberInfoView: View {
     @State private var connectionCode: String? = nil
     @State private var newRole: GroupMemberRole = .member
     @State private var alert: GroupMemberInfoViewAlert?
-    @State private var connectToMemberDialog: Bool = false
+    @State private var sheet: PlanAndConnectActionSheet?
     @AppStorage(DEFAULT_DEVELOPER_TOOLS) private var developerTools = false
     @State private var justOpened = true
     @State private var progressIndicator = false
@@ -30,9 +30,8 @@ struct GroupMemberInfoView: View {
         case switchAddressAlert
         case abortSwitchAddressAlert
         case syncConnectionForceAlert
-        case connRequestSentAlert(type: ConnReqType)
+        case planAndConnectAlert(alert: PlanAndConnectAlert)
         case error(title: LocalizedStringKey, error: LocalizedStringKey)
-        case other(alert: Alert)
 
         var id: String {
             switch self {
@@ -41,9 +40,8 @@ struct GroupMemberInfoView: View {
             case .switchAddressAlert: return "switchAddressAlert"
             case .abortSwitchAddressAlert: return "abortSwitchAddressAlert"
             case .syncConnectionForceAlert: return "syncConnectionForceAlert"
-            case .connRequestSentAlert: return "connRequestSentAlert"
+            case let .planAndConnectAlert(alert): return "planAndConnectAlert \(alert.id)"
             case let .error(title, _): return "error \(title)"
-            case let .other(alert): return "other \(alert)"
             }
         }
     }
@@ -206,11 +204,11 @@ struct GroupMemberInfoView: View {
                 case .switchAddressAlert: return switchAddressAlert(switchMemberAddress)
                 case .abortSwitchAddressAlert: return abortSwitchAddressAlert(abortSwitchMemberAddress)
                 case .syncConnectionForceAlert: return syncConnectionForceAlert({ syncMemberConnection(force: true) })
-                case let .connRequestSentAlert(type): return connReqSentAlert(type)
+                case let .planAndConnectAlert(alert): return planAndConnectAlert(alert, dismiss: true)
                 case let .error(title, error): return Alert(title: Text(title), message: Text(error))
-                case let .other(alert): return alert
                 }
             }
+            .actionSheet(item: $sheet) { s in planAndConnectActionSheet(s, dismiss: true) }
 
             if progressIndicator {
                 ProgressView().scaleEffect(2)
@@ -220,25 +218,16 @@ struct GroupMemberInfoView: View {
 
     func connectViaAddressButton(_ contactLink: String) -> some View {
         Button {
-            connectToMemberDialog = true
+            planAndConnect(
+                contactLink,
+                showAlert: { alert = .planAndConnectAlert(alert: $0) },
+                showActionSheet: { sheet = $0 },
+                dismiss: true,
+                incognito: nil
+            )
         } label: {
             Label("Connect", systemImage: "link")
         }
-        .confirmationDialog("Connect directly", isPresented: $connectToMemberDialog, titleVisibility: .visible) {
-            Button("Use current profile") { connectViaAddress(incognito: false, contactLink: contactLink) }
-            Button("Use new incognito profile") { connectViaAddress(incognito: true, contactLink: contactLink) }
-        }
-    }
-
-    func connectViaAddress(incognito: Bool, contactLink: String) {
-        Task {
-            let (connReqType, connectAlert) = await apiConnect_(incognito: incognito, connReq: contactLink)
-            if let connReqType = connReqType {
-                alert = .connRequestSentAlert(type: connReqType)
-            } else if let connectAlert = connectAlert {
-                alert = .other(alert: connectAlert)
-            }
-        }
     }
 
     func knownDirectChatButton(_ chat: Chat) -> some View {
diff --git a/apps/ios/Shared/Views/NewChat/NewChatButton.swift b/apps/ios/Shared/Views/NewChat/NewChatButton.swift
index a727ad6be..e4fbd8bd4 100644
--- a/apps/ios/Shared/Views/NewChat/NewChatButton.swift
+++ b/apps/ios/Shared/Views/NewChat/NewChatButton.swift
@@ -58,65 +58,331 @@ struct NewChatButton: View {
     }
 }
 
-enum ConnReqType: Equatable {
-    case contact
-    case invitation
+enum PlanAndConnectAlert: Identifiable {
+    case ownInvitationLinkConfirmConnect(connectionLink: String, connectionPlan: ConnectionPlan, incognito: Bool)
+    case invitationLinkConnecting(connectionLink: String)
+    case ownContactAddressConfirmConnect(connectionLink: String, connectionPlan: ConnectionPlan, incognito: Bool)
+    case groupLinkConfirmConnect(connectionLink: String, connectionPlan: ConnectionPlan, incognito: Bool)
+    case groupLinkConnecting(connectionLink: String, groupInfo: GroupInfo?)
+
+    var id: String {
+        switch self {
+        case let .ownInvitationLinkConfirmConnect(connectionLink, _, _): return "ownInvitationLinkConfirmConnect \(connectionLink)"
+        case let .invitationLinkConnecting(connectionLink): return "invitationLinkConnecting \(connectionLink)"
+        case let .ownContactAddressConfirmConnect(connectionLink, _, _): return "ownContactAddressConfirmConnect \(connectionLink)"
+        case let .groupLinkConfirmConnect(connectionLink, _, _): return "groupLinkConfirmConnect \(connectionLink)"
+        case let .groupLinkConnecting(connectionLink, _): return "groupLinkConnecting \(connectionLink)"
+        }
+    }
 }
 
-func connectViaLink(_ connectionLink: String, dismiss: DismissAction? = nil, incognito: Bool) {
-    Task {
-        if let connReqType = await apiConnect(incognito: incognito, connReq: connectionLink) {
-            DispatchQueue.main.async {
-                dismiss?()
-                AlertManager.shared.showAlert(connReqSentAlert(connReqType))
-            }
+func planAndConnectAlert(_ alert: PlanAndConnectAlert, dismiss: Bool) -> Alert {
+    switch alert {
+    case let .ownInvitationLinkConfirmConnect(connectionLink, connectionPlan, incognito):
+        return Alert(
+            title: Text("Connect to yourself?"),
+            message: Text("This is your own one-time link!"),
+            primaryButton: .destructive(
+                Text(incognito ? "Connect incognito" : "Connect"),
+                action: { connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: incognito) }
+            ),
+            secondaryButton: .cancel()
+        )
+    case .invitationLinkConnecting:
+        return Alert(
+            title: Text("Already connecting!"),
+            message: Text("You are already connecting via this one-time link!")
+        )
+    case let .ownContactAddressConfirmConnect(connectionLink, connectionPlan, incognito):
+        return Alert(
+            title: Text("Connect to yourself?"),
+            message: Text("This is your own SimpleX address!"),
+            primaryButton: .destructive(
+                Text(incognito ? "Connect incognito" : "Connect"),
+                action: { connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: incognito) }
+            ),
+            secondaryButton: .cancel()
+        )
+    case let .groupLinkConfirmConnect(connectionLink, connectionPlan, incognito):
+        return Alert(
+            title: Text("Join group?"),
+            message: Text("You will connect to all group members."),
+            primaryButton: .default(
+                Text(incognito ? "Join incognito" : "Join"),
+                action: { connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: incognito) }
+            ),
+            secondaryButton: .cancel()
+        )
+    case let .groupLinkConnecting(_, groupInfo):
+        if let groupInfo = groupInfo {
+            return Alert(
+                title: Text("Group already exists!"),
+                message: Text("You are already joining the group \(groupInfo.displayName).")
+            )
         } else {
-            DispatchQueue.main.async {
-                dismiss?()
+            return Alert(
+                title: Text("Already joining the group!"),
+                message: Text("You are already joining the group via this link.")
+            )
+        }
+    }
+}
+
+enum PlanAndConnectActionSheet: Identifiable {
+    case askCurrentOrIncognitoProfile(connectionLink: String, connectionPlan: ConnectionPlan?, title: LocalizedStringKey)
+    case ownLinkAskCurrentOrIncognitoProfile(connectionLink: String, connectionPlan: ConnectionPlan, title: LocalizedStringKey)
+    case ownGroupLinkConfirmConnect(connectionLink: String, connectionPlan: ConnectionPlan, incognito: Bool?, groupInfo: GroupInfo)
+
+    var id: String {
+        switch self {
+        case let .askCurrentOrIncognitoProfile(connectionLink, _, _): return "askCurrentOrIncognitoProfile \(connectionLink)"
+        case let .ownLinkAskCurrentOrIncognitoProfile(connectionLink, _, _): return "ownLinkAskCurrentOrIncognitoProfile \(connectionLink)"
+        case let .ownGroupLinkConfirmConnect(connectionLink, _, _, _): return "ownGroupLinkConfirmConnect \(connectionLink)"
+        }
+    }
+}
+
+func planAndConnectActionSheet(_ sheet: PlanAndConnectActionSheet, dismiss: Bool) -> ActionSheet {
+    switch sheet {
+    case let .askCurrentOrIncognitoProfile(connectionLink, connectionPlan, title):
+        return ActionSheet(
+            title: Text(title),
+            buttons: [
+                .default(Text("Use current profile")) { connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: false) },
+                .default(Text("Use new incognito profile")) { connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: true) },
+                .cancel()
+            ]
+        )
+    case let .ownLinkAskCurrentOrIncognitoProfile(connectionLink, connectionPlan, title):
+        return ActionSheet(
+            title: Text(title),
+            buttons: [
+                .destructive(Text("Use current profile")) { connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: false) },
+                .destructive(Text("Use new incognito profile")) { connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: true) },
+                .cancel()
+            ]
+        )
+    case let .ownGroupLinkConfirmConnect(connectionLink, connectionPlan, incognito, groupInfo):
+        if let incognito = incognito {
+            return ActionSheet(
+                title: Text("Join your group?\nThis is your link for group \(groupInfo.displayName)!"),
+                buttons: [
+                    .default(Text("Open group")) { openKnownGroup(groupInfo, dismiss: dismiss, showAlreadyExistsAlert: nil) },
+                    .destructive(Text(incognito ? "Join incognito" : "Join with current profile")) { connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: incognito) },
+                    .cancel()
+                ]
+            )
+        } else {
+            return ActionSheet(
+                title: Text("Join your group?\nThis is your link for group \(groupInfo.displayName)!"),
+                buttons: [
+                    .default(Text("Open group")) { openKnownGroup(groupInfo, dismiss: dismiss, showAlreadyExistsAlert: nil) },
+                    .destructive(Text("Use current profile")) { connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: false) },
+                    .destructive(Text("Use new incognito profile")) { connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: true) },
+                    .cancel()
+                ]
+            )
+        }
+    }
+}
+
+func planAndConnect(
+    _ connectionLink: String,
+    showAlert: @escaping (PlanAndConnectAlert) -> Void,
+    showActionSheet: @escaping (PlanAndConnectActionSheet) -> Void,
+    dismiss: Bool,
+    incognito: Bool?
+) {
+    Task {
+        do {
+            let connectionPlan = try await apiConnectPlan(connReq: connectionLink)
+            switch connectionPlan {
+            case let .invitationLink(ilp):
+                switch ilp {
+                case .ok:
+                    logger.debug("planAndConnect, .invitationLink, .ok, incognito=\(incognito?.description ?? "nil")")
+                    if let incognito = incognito {
+                        connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: incognito)
+                    } else {
+                        showActionSheet(.askCurrentOrIncognitoProfile(connectionLink: connectionLink, connectionPlan: connectionPlan, title: "Connect via one-time link"))
+                    }
+                case .ownLink:
+                    logger.debug("planAndConnect, .invitationLink, .ownLink, incognito=\(incognito?.description ?? "nil")")
+                    if let incognito = incognito {
+                        showAlert(.ownInvitationLinkConfirmConnect(connectionLink: connectionLink, connectionPlan: connectionPlan, incognito: incognito))
+                    } else {
+                        showActionSheet(.ownLinkAskCurrentOrIncognitoProfile(connectionLink: connectionLink, connectionPlan: connectionPlan, title: "Connect to yourself?\nThis is your own one-time link!"))
+                    }
+                case let .connecting(contact_):
+                    logger.debug("planAndConnect, .invitationLink, .connecting, incognito=\(incognito?.description ?? "nil")")
+                    if let contact = contact_ {
+                        openKnownContact(contact, dismiss: dismiss) { AlertManager.shared.showAlert(contactAlreadyConnectingAlert(contact)) }
+                    } else {
+                        showAlert(.invitationLinkConnecting(connectionLink: connectionLink))
+                    }
+                case let .known(contact):
+                    logger.debug("planAndConnect, .invitationLink, .known, incognito=\(incognito?.description ?? "nil")")
+                    openKnownContact(contact, dismiss: dismiss) { AlertManager.shared.showAlert(contactAlreadyExistsAlert(contact)) }
+                }
+            case let .contactAddress(cap):
+                switch cap {
+                case .ok:
+                    logger.debug("planAndConnect, .contactAddress, .ok, incognito=\(incognito?.description ?? "nil")")
+                    if let incognito = incognito {
+                        connectViaLink(connectionLink, connectionPlan: connectionPlan, dismiss: dismiss, incognito: incognito)
+                    } else {
+                        showActionSheet(.askCurrentOrIncognitoProfile(connectionLink: connectionLink, connectionPlan: connectionPlan, title: "Connect via contact address"))
+                    }
+                case .ownLink:
+                    logger.debug("planAndConnect, .contactAddress, .ownLink, incognito=\(incognito?.description ?? "nil")")
+                    if let incognito = incognito {
+                        showAlert(.ownContactAddressConfirmConnect(connectionLink: connectionLink, connectionPlan: connectionPlan, incognito: incognito))
+                    } else {
+                        showActionSheet(.ownLinkAskCurrentOrIncognitoProfile(connectionLink: connectionLink, connectionPlan: connectionPlan, title: "Connect to yourself?\nThis is your own SimpleX address!"))
+                    }
+                case let .connecting(contact):
+                    logger.debug("planAndConnect, .contactAddress, .connecting, incognito=\(incognito?.description ?? "nil")")
+                    openKnownContact(contact, dismiss: dismiss) { AlertManager.shared.showAlert(contactAlreadyConnectingAlert(contact)) }
+                case let .known(contact):
+                    logger.debug("planAndConnect, .contactAddress, .known, incognito=\(incognito?.description ?? "nil")")
+                    openKnownContact(contact, dismiss: dismiss) { AlertManager.shared.showAlert(contactAlreadyExistsAlert(contact)) }
+                }
+            case let .groupLink(glp):
+                switch glp {
+                case .ok:
+                    if let incognito = incognito {
+                        showAlert(.groupLinkConfirmConnect(connectionLink: connectionLink, connectionPlan: connectionPlan, incognito: incognito))
+                    } else {
+                        showActionSheet(.askCurrentOrIncognitoProfile(connectionLink: connectionLink, connectionPlan: connectionPlan, title: "Join group"))
+                    }
+                case let .ownLink(groupInfo):
+                    logger.debug("planAndConnect, .groupLink, .ownLink, incognito=\(incognito?.description ?? "nil")")
+                    showActionSheet(.ownGroupLinkConfirmConnect(connectionLink: connectionLink, connectionPlan: connectionPlan, incognito: incognito, groupInfo: groupInfo))
+                case let .connecting(groupInfo_):
+                    logger.debug("planAndConnect, .groupLink, .connecting, incognito=\(incognito?.description ?? "nil")")
+                    showAlert(.groupLinkConnecting(connectionLink: connectionLink, groupInfo: groupInfo_))
+                case let .known(groupInfo):
+                    logger.debug("planAndConnect, .groupLink, .known, incognito=\(incognito?.description ?? "nil")")
+                    openKnownGroup(groupInfo, dismiss: dismiss) { AlertManager.shared.showAlert(groupAlreadyExistsAlert(groupInfo)) }
+                }
+            }
+        } catch {
+            logger.debug("planAndConnect, plan error")
+            if let incognito = incognito {
+                connectViaLink(connectionLink, connectionPlan: nil, dismiss: dismiss, incognito: incognito)
+            } else {
+                showActionSheet(.askCurrentOrIncognitoProfile(connectionLink: connectionLink, connectionPlan: nil, title: "Connect via link"))
             }
         }
     }
 }
 
-struct CReqClientData: Decodable {
-    var type: String
-    var groupLinkId: String?
-}
-
-func parseLinkQueryData(_ connectionLink: String) -> CReqClientData? {
-    if let hashIndex = connectionLink.firstIndex(of: "#"),
-       let urlQuery = URL(string: String(connectionLink[connectionLink.index(after: hashIndex)...])),
-       let components = URLComponents(url: urlQuery, resolvingAgainstBaseURL: false),
-       let data = components.queryItems?.first(where: { $0.name == "data" })?.value,
-       let d = data.data(using: .utf8),
-       let crData = try? getJSONDecoder().decode(CReqClientData.self, from: d) {
-        return crData
-    } else {
-        return nil
+private func connectViaLink(_ connectionLink: String, connectionPlan: ConnectionPlan?, dismiss: Bool, incognito: Bool) {
+    Task {
+        if let connReqType = await apiConnect(incognito: incognito, connReq: connectionLink) {
+            let crt: ConnReqType
+            if let plan = connectionPlan {
+                crt = planToConnReqType(plan)
+            } else {
+                crt = connReqType
+            }
+            DispatchQueue.main.async {
+                if dismiss {
+                    dismissAllSheets(animated: true) {
+                        AlertManager.shared.showAlert(connReqSentAlert(crt))
+                    }
+                } else {
+                    AlertManager.shared.showAlert(connReqSentAlert(crt))
+                }
+            }
+        } else {
+            if dismiss {
+                DispatchQueue.main.async {
+                    dismissAllSheets(animated: true)
+                }
+            }
+        }
     }
 }
 
-func checkCRDataGroup(_ crData: CReqClientData) -> Bool {
-    return crData.type == "group" && crData.groupLinkId != nil
+func openKnownContact(_ contact: Contact, dismiss: Bool, showAlreadyExistsAlert: (() -> Void)?) {
+    Task {
+        let m = ChatModel.shared
+        if let c = m.getContactChat(contact.contactId) {
+            DispatchQueue.main.async {
+                if dismiss {
+                    dismissAllSheets(animated: true) {
+                        m.chatId = c.id
+                        showAlreadyExistsAlert?()
+                    }
+                } else {
+                    m.chatId = c.id
+                    showAlreadyExistsAlert?()
+                }
+            }
+        }
+    }
 }
 
-func groupLinkAlert(_ connectionLink: String, incognito: Bool) -> Alert {
-    return Alert(
-        title: Text("Connect via group link?"),
-        message: Text("You will join a group this link refers to and connect to its group members."),
-        primaryButton: .default(Text(incognito ? "Connect incognito" : "Connect")) {
-            connectViaLink(connectionLink, incognito: incognito)
-        },
-        secondaryButton: .cancel()
+func openKnownGroup(_ groupInfo: GroupInfo, dismiss: Bool, showAlreadyExistsAlert: (() -> Void)?) {
+    Task {
+        let m = ChatModel.shared
+        if let g = m.getGroupChat(groupInfo.groupId) {
+            DispatchQueue.main.async {
+                if dismiss {
+                    dismissAllSheets(animated: true) {
+                        m.chatId = g.id
+                        showAlreadyExistsAlert?()
+                    }
+                } else {
+                    m.chatId = g.id
+                    showAlreadyExistsAlert?()
+                }
+            }
+        }
+    }
+}
+
+func contactAlreadyConnectingAlert(_ contact: Contact) -> Alert {
+    mkAlert(
+        title: "Contact already exists",
+        message: "You are already connecting to \(contact.displayName)."
     )
 }
 
+func groupAlreadyExistsAlert(_ groupInfo: GroupInfo) -> Alert {
+    mkAlert(
+        title: "Group already exists",
+        message: "You are already in group \(groupInfo.displayName)."
+    )
+}
+
+enum ConnReqType: Equatable {
+    case invitation
+    case contact
+    case groupLink
+
+    var connReqSentText: LocalizedStringKey {
+        switch self {
+        case .invitation: return "You will be connected when your contact's device is online, please wait or check later!"
+        case .contact: return "You will be connected when your connection request is accepted, please wait or check later!"
+        case .groupLink: return "You will be connected when group link host's device is online, please wait or check later!"
+        }
+    }
+}
+
+private func planToConnReqType(_ connectionPlan: ConnectionPlan) -> ConnReqType {
+    switch connectionPlan {
+    case .invitationLink: return .invitation
+    case .contactAddress: return .contact
+    case .groupLink: return .groupLink
+    }
+}
+
 func connReqSentAlert(_ type: ConnReqType) -> Alert {
     return mkAlert(
         title: "Connection request sent!",
-        message: type == .contact
-            ? "You will be connected when your connection request is accepted, please wait or check later!"
-            : "You will be connected when your contact's device is online, please wait or check later!"
+        message: type.connReqSentText
     )
 }
 
diff --git a/apps/ios/Shared/Views/NewChat/PasteToConnectView.swift b/apps/ios/Shared/Views/NewChat/PasteToConnectView.swift
index ec199327c..af84f19fe 100644
--- a/apps/ios/Shared/Views/NewChat/PasteToConnectView.swift
+++ b/apps/ios/Shared/Views/NewChat/PasteToConnectView.swift
@@ -14,6 +14,8 @@ struct PasteToConnectView: View {
     @State private var connectionLink: String = ""
     @AppStorage(GROUP_DEFAULT_INCOGNITO, store: groupDefaults) private var incognitoDefault = false
     @FocusState private var linkEditorFocused: Bool
+    @State private var alert: PlanAndConnectAlert?
+    @State private var sheet: PlanAndConnectActionSheet?
 
     var body: some View {
         List {
@@ -57,6 +59,8 @@ struct PasteToConnectView: View {
                 + Text("You can also connect by clicking the link. If it opens in the browser, click **Open in mobile app** button.")
             }
         }
+        .alert(item: $alert) { a in planAndConnectAlert(a, dismiss: true) }
+        .actionSheet(item: $sheet) { s in planAndConnectActionSheet(s, dismiss: true) }
     }
 
     private func linkEditor() -> some View {
@@ -83,13 +87,13 @@ struct PasteToConnectView: View {
 
     private func connect() {
         let link = connectionLink.trimmingCharacters(in: .whitespaces)
-        if let crData = parseLinkQueryData(link),
-           checkCRDataGroup(crData) {
-            dismiss()
-            AlertManager.shared.showAlert(groupLinkAlert(link, incognito: incognitoDefault))
-        } else {
-            connectViaLink(link, dismiss: dismiss, incognito: incognitoDefault)
-        }
+        planAndConnect(
+            link,
+            showAlert: { alert = $0 },
+            showActionSheet: { sheet = $0 },
+            dismiss: true,
+            incognito: incognitoDefault
+        )
     }
 }
 
diff --git a/apps/ios/Shared/Views/NewChat/ScanToConnectView.swift b/apps/ios/Shared/Views/NewChat/ScanToConnectView.swift
index 01c8a4659..c55ba1502 100644
--- a/apps/ios/Shared/Views/NewChat/ScanToConnectView.swift
+++ b/apps/ios/Shared/Views/NewChat/ScanToConnectView.swift
@@ -13,6 +13,8 @@ import CodeScanner
 struct ScanToConnectView: View {
     @Environment(\.dismiss) var dismiss: DismissAction
     @AppStorage(GROUP_DEFAULT_INCOGNITO, store: groupDefaults) private var incognitoDefault = false
+    @State private var alert: PlanAndConnectAlert?
+    @State private var sheet: PlanAndConnectActionSheet?
 
     var body: some View {
         ScrollView {
@@ -49,18 +51,20 @@ struct ScanToConnectView: View {
             .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
         }
         .background(Color(.systemGroupedBackground))
+        .alert(item: $alert) { a in planAndConnectAlert(a, dismiss: true) }
+        .actionSheet(item: $sheet) { s in planAndConnectActionSheet(s, dismiss: true) }
     }
 
     func processQRCode(_ resp: Result<ScanResult, ScanError>) {
         switch resp {
         case let .success(r):
-            if let crData = parseLinkQueryData(r.string),
-               checkCRDataGroup(crData) {
-                dismiss()
-                AlertManager.shared.showAlert(groupLinkAlert(r.string, incognito: incognitoDefault))
-            } else {
-                Task { connectViaLink(r.string, dismiss: dismiss, incognito: incognitoDefault) }
-            }
+            planAndConnect(
+                r.string,
+                showAlert: { alert = $0 },
+                showActionSheet: { sheet = $0 },
+                dismiss: true,
+                incognito: incognitoDefault
+            )
         case let .failure(e):
             logger.error("ConnectContactView.processQRCode QR code error: \(e.localizedDescription)")
             dismiss()
diff --git a/apps/ios/SimpleX.xcodeproj/project.pbxproj b/apps/ios/SimpleX.xcodeproj/project.pbxproj
index 35d0b1de8..2a90e75d8 100644
--- a/apps/ios/SimpleX.xcodeproj/project.pbxproj
+++ b/apps/ios/SimpleX.xcodeproj/project.pbxproj
@@ -176,6 +176,11 @@
 		649BCDA22805D6EF00C3A862 /* CIImageView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 649BCDA12805D6EF00C3A862 /* CIImageView.swift */; };
 		64AA1C6927EE10C800AC7277 /* ContextItemView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 64AA1C6827EE10C800AC7277 /* ContextItemView.swift */; };
 		64AA1C6C27F3537400AC7277 /* DeletedItemView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 64AA1C6B27F3537400AC7277 /* DeletedItemView.swift */; };
+		64AB9C832AD6B6B900B21C4C /* libgmp.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 64AB9C7E2AD6B6B900B21C4C /* libgmp.a */; };
+		64AB9C842AD6B6B900B21C4C /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b-ghc8.10.7.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 64AB9C7F2AD6B6B900B21C4C /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b-ghc8.10.7.a */; };
+		64AB9C852AD6B6B900B21C4C /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 64AB9C802AD6B6B900B21C4C /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b.a */; };
+		64AB9C862AD6B6B900B21C4C /* libffi.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 64AB9C812AD6B6B900B21C4C /* libffi.a */; };
+		64AB9C872AD6B6B900B21C4C /* libgmpxx.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 64AB9C822AD6B6B900B21C4C /* libgmpxx.a */; };
 		64C06EB52A0A4A7C00792D4D /* ChatItemInfoView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 64C06EB42A0A4A7C00792D4D /* ChatItemInfoView.swift */; };
 		64C3B0212A0D359700E19930 /* CustomTimePicker.swift in Sources */ = {isa = PBXBuildFile; fileRef = 64C3B0202A0D359700E19930 /* CustomTimePicker.swift */; };
 		64D0C2C029F9688300B38D5F /* UserAddressView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 64D0C2BF29F9688300B38D5F /* UserAddressView.swift */; };
@@ -458,6 +463,11 @@
 		649BCDA12805D6EF00C3A862 /* CIImageView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CIImageView.swift; sourceTree = "<group>"; };
 		64AA1C6827EE10C800AC7277 /* ContextItemView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ContextItemView.swift; sourceTree = "<group>"; };
 		64AA1C6B27F3537400AC7277 /* DeletedItemView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DeletedItemView.swift; sourceTree = "<group>"; };
+		64AB9C7E2AD6B6B900B21C4C /* libgmp.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmp.a; sourceTree = "<group>"; };
+		64AB9C7F2AD6B6B900B21C4C /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b-ghc8.10.7.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b-ghc8.10.7.a"; sourceTree = "<group>"; };
+		64AB9C802AD6B6B900B21C4C /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b.a"; sourceTree = "<group>"; };
+		64AB9C812AD6B6B900B21C4C /* libffi.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libffi.a; sourceTree = "<group>"; };
+		64AB9C822AD6B6B900B21C4C /* libgmpxx.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmpxx.a; sourceTree = "<group>"; };
 		64C06EB42A0A4A7C00792D4D /* ChatItemInfoView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChatItemInfoView.swift; sourceTree = "<group>"; };
 		64C3B0202A0D359700E19930 /* CustomTimePicker.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CustomTimePicker.swift; sourceTree = "<group>"; };
 		64D0C2BF29F9688300B38D5F /* UserAddressView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UserAddressView.swift; sourceTree = "<group>"; };
@@ -507,13 +517,13 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				5CA8D0162AD746C8001FD661 /* libgmpxx.a in Frameworks */,
-				5CA8D01A2AD746C8001FD661 /* libgmp.a in Frameworks */,
-				5CA8D0182AD746C8001FD661 /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b.a in Frameworks */,
-				5CA8D0192AD746C8001FD661 /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b-ghc8.10.7.a in Frameworks */,
+				64AB9C842AD6B6B900B21C4C /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b-ghc8.10.7.a in Frameworks */,
+				64AB9C862AD6B6B900B21C4C /* libffi.a in Frameworks */,
+				64AB9C852AD6B6B900B21C4C /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b.a in Frameworks */,
 				5CE2BA93284534B000EC33A6 /* libiconv.tbd in Frameworks */,
+				64AB9C832AD6B6B900B21C4C /* libgmp.a in Frameworks */,
 				5CE2BA94284534BB00EC33A6 /* libz.tbd in Frameworks */,
-				5CA8D0172AD746C8001FD661 /* libffi.a in Frameworks */,
+				64AB9C872AD6B6B900B21C4C /* libgmpxx.a in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -574,11 +584,11 @@
 		5C764E5C279C70B7000C6508 /* Libraries */ = {
 			isa = PBXGroup;
 			children = (
-				5CA8D0122AD746C8001FD661 /* libffi.a */,
-				5CA8D0152AD746C8001FD661 /* libgmp.a */,
-				5CA8D0112AD746C8001FD661 /* libgmpxx.a */,
-				5CA8D0142AD746C8001FD661 /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b-ghc8.10.7.a */,
-				5CA8D0132AD746C8001FD661 /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b.a */,
+				64AB9C812AD6B6B900B21C4C /* libffi.a */,
+				64AB9C7E2AD6B6B900B21C4C /* libgmp.a */,
+				64AB9C822AD6B6B900B21C4C /* libgmpxx.a */,
+				64AB9C7F2AD6B6B900B21C4C /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b-ghc8.10.7.a */,
+				64AB9C802AD6B6B900B21C4C /* libHSsimplex-chat-5.4.0.1-7lTZkX9ojv2DbehL2eOY1b.a */,
 			);
 			path = Libraries;
 			sourceTree = "<group>";
diff --git a/apps/ios/SimpleXChat/APITypes.swift b/apps/ios/SimpleXChat/APITypes.swift
index d29e2481d..9eb9b9084 100644
--- a/apps/ios/SimpleXChat/APITypes.swift
+++ b/apps/ios/SimpleXChat/APITypes.swift
@@ -86,6 +86,7 @@ public enum ChatCommand {
     case apiVerifyGroupMember(groupId: Int64, groupMemberId: Int64, connectionCode: String?)
     case apiAddContact(userId: Int64, incognito: Bool)
     case apiSetConnectionIncognito(connId: Int64, incognito: Bool)
+    case apiConnectPlan(userId: Int64, connReq: String)
     case apiConnect(userId: Int64, incognito: Bool, connReq: String)
     case apiDeleteChat(type: ChatType, id: Int64)
     case apiClearChat(type: ChatType, id: Int64)
@@ -219,6 +220,7 @@ public enum ChatCommand {
             case let .apiVerifyGroupMember(groupId, groupMemberId, .none): return "/_verify code #\(groupId) \(groupMemberId)"
             case let .apiAddContact(userId, incognito): return "/_connect \(userId) incognito=\(onOff(incognito))"
             case let .apiSetConnectionIncognito(connId, incognito): return "/_set incognito :\(connId) \(onOff(incognito))"
+            case let .apiConnectPlan(userId, connReq): return "/_connect plan \(userId) \(connReq)"
             case let .apiConnect(userId, incognito, connReq): return "/_connect \(userId) incognito=\(onOff(incognito)) \(connReq)"
             case let .apiDeleteChat(type, id): return "/_delete \(ref(type, id))"
             case let .apiClearChat(type, id): return "/_clear chat \(ref(type, id))"
@@ -335,6 +337,7 @@ public enum ChatCommand {
             case .apiVerifyGroupMember: return "apiVerifyGroupMember"
             case .apiAddContact: return "apiAddContact"
             case .apiSetConnectionIncognito: return "apiSetConnectionIncognito"
+            case .apiConnectPlan: return "apiConnectPlan"
             case .apiConnect: return "apiConnect"
             case .apiDeleteChat: return "apiDeleteChat"
             case .apiClearChat: return "apiClearChat"
@@ -460,6 +463,7 @@ public enum ChatResponse: Decodable, Error {
     case connectionVerified(user: UserRef, verified: Bool, expectedCode: String)
     case invitation(user: UserRef, connReqInvitation: String, connection: PendingContactConnection)
     case connectionIncognitoUpdated(user: UserRef, toConnection: PendingContactConnection)
+    case connectionPlan(user: UserRef, connectionPlan: ConnectionPlan)
     case sentConfirmation(user: UserRef)
     case sentInvitation(user: UserRef)
     case contactAlreadyExists(user: UserRef, contact: Contact)
@@ -601,6 +605,7 @@ public enum ChatResponse: Decodable, Error {
             case .connectionVerified: return "connectionVerified"
             case .invitation: return "invitation"
             case .connectionIncognitoUpdated: return "connectionIncognitoUpdated"
+            case .connectionPlan: return "connectionPlan"
             case .sentConfirmation: return "sentConfirmation"
             case .sentInvitation: return "sentInvitation"
             case .contactAlreadyExists: return "contactAlreadyExists"
@@ -739,6 +744,7 @@ public enum ChatResponse: Decodable, Error {
             case let .connectionVerified(u, verified, expectedCode): return withUser(u, "verified: \(verified)\nconnectionCode: \(expectedCode)")
             case let .invitation(u, connReqInvitation, _): return withUser(u, connReqInvitation)
             case let .connectionIncognitoUpdated(u, toConnection): return withUser(u, String(describing: toConnection))
+            case let .connectionPlan(u, connectionPlan): return withUser(u, String(describing: connectionPlan))
             case .sentConfirmation: return noDetails
             case .sentInvitation: return noDetails
             case let .contactAlreadyExists(u, contact): return withUser(u, String(describing: contact))
@@ -859,6 +865,33 @@ public func chatError(_ chatResponse: ChatResponse) -> ChatErrorType? {
     }
 }
 
+public enum ConnectionPlan: Decodable {
+    case invitationLink(invitationLinkPlan: InvitationLinkPlan)
+    case contactAddress(contactAddressPlan: ContactAddressPlan)
+    case groupLink(groupLinkPlan: GroupLinkPlan)
+}
+
+public enum InvitationLinkPlan: Decodable {
+    case ok
+    case ownLink
+    case connecting(contact_: Contact?)
+    case known(contact: Contact)
+}
+
+public enum ContactAddressPlan: Decodable {
+    case ok
+    case ownLink
+    case connecting(contact: Contact)
+    case known(contact: Contact)
+}
+
+public enum GroupLinkPlan: Decodable {
+    case ok
+    case ownLink(groupInfo: GroupInfo)
+    case connecting(groupInfo_: GroupInfo?)
+    case known(groupInfo: GroupInfo)
+}
+
 struct NewUser: Encodable {
     var profile: Profile?
     var sameServers: Bool
@@ -1477,6 +1510,7 @@ public enum ChatErrorType: Decodable {
     case chatNotStarted
     case chatNotStopped
     case chatStoreChanged
+    case connectionPlan(connectionPlan: ConnectionPlan)
     case invalidConnReq
     case invalidChatMessage(connection: Connection, message: String)
     case contactNotReady(contact: Contact)