test simplexmq with mlock

apps/ios/Shared/Model/SimpleXAPI.swift

@@ -90,12 +90,12 @@ private func withBGTask<T>(bgDelay: Double? = nil, f: @escaping () -> T) -> T {
     return r
 }
 
-func chatSendCmdSync(_ cmd: ChatCommand, bgTask: Bool = true, bgDelay: Double? = nil, _ ctrl: chat_ctrl? = nil) -> ChatResponse {
+func chatSendCmdSync(_ cmd: ChatCommand, bgTask: Bool = true, bgDelay: Double? = nil) -> ChatResponse {
     logger.debug("chatSendCmd \(cmd.cmdType)")
     let start = Date.now
     let resp = bgTask
-                ? withBGTask(bgDelay: bgDelay) { sendSimpleXCmd(cmd, ctrl) }
-                : sendSimpleXCmd(cmd, ctrl)
+                ? withBGTask(bgDelay: bgDelay) { sendSimpleXCmd(cmd) }
+                : sendSimpleXCmd(cmd)
     logger.debug("chatSendCmd \(cmd.cmdType): \(resp.responseType)")
     if case let .response(_, json) = resp {
         logger.debug("chatSendCmd \(cmd.cmdType) response: \(json)")
@@ -106,24 +106,24 @@ func chatSendCmdSync(_ cmd: ChatCommand, bgTask: Bool = true, bgDelay: Double? =
     return resp
 }
 
-func chatSendCmd(_ cmd: ChatCommand, bgTask: Bool = true, bgDelay: Double? = nil, _ ctrl: chat_ctrl? = nil) async -> ChatResponse {
+func chatSendCmd(_ cmd: ChatCommand, bgTask: Bool = true, bgDelay: Double? = nil) async -> ChatResponse {
     await withCheckedContinuation { cont in
-        cont.resume(returning: chatSendCmdSync(cmd, bgTask: bgTask, bgDelay: bgDelay, ctrl))
+        cont.resume(returning: chatSendCmdSync(cmd, bgTask: bgTask, bgDelay: bgDelay))
     }
 }
 
-func chatRecvMsg(_ ctrl: chat_ctrl? = nil) async -> ChatResponse? {
+func chatRecvMsg() async -> ChatResponse? {
     await withCheckedContinuation { cont in
         _  = withBGTask(bgDelay: msgDelay) { () -> ChatResponse? in
-            let resp = recvSimpleXMsg(ctrl)
+            let resp = recvSimpleXMsg()
             cont.resume(returning: resp)
             return resp
         }
     }
 }
 
-func apiGetActiveUser(ctrl: chat_ctrl? = nil) throws -> User? {
-    let r = chatSendCmdSync(.showActiveUser, ctrl)
+func apiGetActiveUser() throws -> User? {
+    let r = chatSendCmdSync(.showActiveUser)
     switch r {
     case let .activeUser(user): return user
     case .chatCmdError(_, .error(.noActiveUser)): return nil
@@ -131,8 +131,8 @@ func apiGetActiveUser(ctrl: chat_ctrl? = nil) throws -> User? {
     }
 }
 
-func apiCreateActiveUser(_ p: Profile?, sameServers: Bool = false, pastTimestamp: Bool = false, ctrl: chat_ctrl? = nil) throws -> User {
-    let r = chatSendCmdSync(.createActiveUser(profile: p, sameServers: sameServers, pastTimestamp: pastTimestamp), ctrl)
+func apiCreateActiveUser(_ p: Profile?, sameServers: Bool = false, pastTimestamp: Bool = false) throws -> User {
+    let r = chatSendCmdSync(.createActiveUser(profile: p, sameServers: sameServers, pastTimestamp: pastTimestamp))
     if case let .activeUser(user) = r { return user }
     throw r
 }
@@ -210,8 +210,8 @@ func apiDeleteUser(_ userId: Int64, _ delSMPQueues: Bool, viewPwd: String?) asyn
     throw r
 }
 
-func apiStartChat(ctrl: chat_ctrl? = nil) throws -> Bool {
-    let r = chatSendCmdSync(.startChat(mainApp: true), ctrl)
+func apiStartChat() throws -> Bool {
+    let r = chatSendCmdSync(.startChat(mainApp: true))
     switch r {
     case .chatStarted: return true
     case .chatRunning: return false
@@ -240,14 +240,20 @@ func apiSuspendChat(timeoutMicroseconds: Int) {
     logger.error("apiSuspendChat error: \(String(describing: r))")
 }
 
-func apiSetTempFolder(tempFolder: String, ctrl: chat_ctrl? = nil) throws {
-    let r = chatSendCmdSync(.setTempFolder(tempFolder: tempFolder), ctrl)
+func apiSetTempFolder(tempFolder: String) throws {
+    let r = chatSendCmdSync(.setTempFolder(tempFolder: tempFolder))
     if case .cmdOk = r { return }
     throw r
 }
 
-func apiSetFilesFolder(filesFolder: String, ctrl: chat_ctrl? = nil) throws {
-    let r = chatSendCmdSync(.setFilesFolder(filesFolder: filesFolder), ctrl)
+func apiSetFilesFolder(filesFolder: String) throws {
+    let r = chatSendCmdSync(.setFilesFolder(filesFolder: filesFolder))
+    if case .cmdOk = r { return }
+    throw r
+}
+
+func setXFTPConfig(_ cfg: XFTPFileConfig?) throws {
+    let r = chatSendCmdSync(.apiSetXFTPConfig(config: cfg))
     if case .cmdOk = r { return }
     throw r
 }
@@ -276,10 +282,6 @@ func apiStorageEncryption(currentKey: String = "", newKey: String = "") async th
     try await sendCommandOkResp(.apiStorageEncryption(config: DBEncryptionConfig(currentKey: currentKey, newKey: newKey)))
 }
 
-func testStorageEncryption(key: String, _ ctrl: chat_ctrl? = nil) async throws {
-    try await sendCommandOkResp(.testStorageEncryption(key: key), ctrl)
-}
-
 func apiGetChats() throws -> [ChatData] {
     let userId = try currentUserId("apiGetChats")
     return try apiChatsResponse(chatSendCmdSync(.apiGetChats(userId: userId)))
@@ -502,8 +504,8 @@ func getNetworkConfig() async throws -> NetCfg? {
     throw r
 }
 
-func setNetworkConfig(_ cfg: NetCfg, ctrl: chat_ctrl? = nil) throws {
-    let r = chatSendCmdSync(.apiSetNetworkConfig(networkConfig: cfg), ctrl)
+func setNetworkConfig(_ cfg: NetCfg) throws {
+    let r = chatSendCmdSync(.apiSetNetworkConfig(networkConfig: cfg))
     if case .cmdOk = r { return }
     throw r
 }
@@ -868,26 +870,6 @@ func apiChatUnread(type: ChatType, id: Int64, unreadChat: Bool) async throws {
     try await sendCommandOkResp(.apiChatUnread(type: type, id: id, unreadChat: unreadChat))
 }
 
-func uploadStandaloneFile(user: any UserLike, file: CryptoFile, ctrl: chat_ctrl? = nil) async -> (FileTransferMeta?, String?) {
-    let r = await chatSendCmd(.apiUploadStandaloneFile(userId: user.userId, file: file), ctrl)
-    if case let .sndStandaloneFileCreated(_, fileTransferMeta) = r {
-        return (fileTransferMeta, nil)
-    } else {
-        logger.error("uploadStandaloneFile error: \(String(describing: r))")
-        return (nil, String(describing: r))
-    }
-}
-
-func downloadStandaloneFile(user: any UserLike, url: String, file: CryptoFile, ctrl: chat_ctrl? = nil) async -> (RcvFileTransfer?, String?) {
-    let r = await chatSendCmd(.apiDownloadStandaloneFile(userId: user.userId, url: url, file: file), ctrl)
-    if case let .rcvStandaloneFileCreated(_, rcvFileTransfer) = r {
-        return (rcvFileTransfer, nil)
-    } else {
-        logger.error("downloadStandaloneFile error: \(String(describing: r))")
-        return (nil, String(describing: r))
-    }
-}
-
 func receiveFile(user: any UserLike, fileId: Int64, auto: Bool = false) async {
     if let chatItem = await apiReceiveFile(fileId: fileId, encrypted: privacyEncryptLocalFilesGroupDefault.get(), auto: auto) {
         await chatItemSimpleUpdate(user, chatItem)
@@ -933,8 +915,8 @@ func cancelFile(user: User, fileId: Int64) async {
     }
 }
 
-func apiCancelFile(fileId: Int64, ctrl: chat_ctrl? = nil) async -> AChatItem? {
-    let r = await chatSendCmd(.cancelFile(fileId: fileId), ctrl)
+func apiCancelFile(fileId: Int64) async -> AChatItem? {
+    let r = await chatSendCmd(.cancelFile(fileId: fileId))
     switch r {
     case let .sndFileCancelled(_, chatItem, _, _) : return chatItem
     case let .rcvFileCancelled(_, chatItem, _) : return chatItem
@@ -1106,8 +1088,8 @@ func apiMarkChatItemRead(_ cInfo: ChatInfo, _ cItem: ChatItem) async {
     }
 }
 
-private func sendCommandOkResp(_ cmd: ChatCommand, _ ctrl: chat_ctrl? = nil) async throws {
-    let r = await chatSendCmd(cmd, ctrl)
+private func sendCommandOkResp(_ cmd: ChatCommand) async throws {
+    let r = await chatSendCmd(cmd)
     if case .cmdOk = r { return }
     throw r
 }
@@ -1267,6 +1249,7 @@ func initializeChat(start: Bool, confirmStart: Bool = false, dbKey: String? = ni
     }
     try apiSetTempFolder(tempFolder: getTempFilesDirectory().path)
     try apiSetFilesFolder(filesFolder: getAppFilesDirectory().path)
+    try setXFTPConfig(getXFTPCfg())
     try apiSetEncryptLocalFiles(privacyEncryptLocalFilesGroupDefault.get())
     m.chatInitialized = true
     m.currentUser = try apiGetActiveUser()
@@ -1347,16 +1330,6 @@ func startChat(refreshInvitations: Bool = true) throws {
     chatLastStartGroupDefault.set(Date.now)
 }
 
-func startChatWithTemporaryDatabase(ctrl: chat_ctrl) throws -> User? {
-    logger.debug("startChatWithTemporaryDatabase")
-    let migrationActiveUser = try? apiGetActiveUser(ctrl: ctrl) ?? apiCreateActiveUser(Profile(displayName: "Temp", fullName: ""), ctrl: ctrl)
-    try setNetworkConfig(getNetCfg(), ctrl: ctrl)
-    try apiSetTempFolder(tempFolder: getMigrationTempFilesDirectory().path, ctrl: ctrl)
-    try apiSetFilesFolder(filesFolder: getMigrationTempFilesDirectory().path, ctrl: ctrl)
-    _ = try apiStartChat(ctrl: ctrl)
-    return migrationActiveUser
-}
-
 func changeActiveUser(_ userId: Int64, viewPwd: String?) {
     do {
         try changeActiveUser_(userId, viewPwd: viewPwd)
@@ -1735,37 +1708,27 @@ func processReceivedMsg(_ res: ChatResponse) async {
     case let .rcvFileSndCancelled(user, aChatItem, _):
         await chatItemSimpleUpdate(user, aChatItem)
         Task { cleanupFile(aChatItem) }
-    case let .rcvFileProgressXFTP(user, aChatItem, _, _, _):
-        if let aChatItem = aChatItem {
-            await chatItemSimpleUpdate(user, aChatItem)
-        }
-    case let .rcvFileError(user, aChatItem, _):
-        if let aChatItem = aChatItem {
-            await chatItemSimpleUpdate(user, aChatItem)
-            Task { cleanupFile(aChatItem) }
-        }
+    case let .rcvFileProgressXFTP(user, aChatItem, _, _):
+        await chatItemSimpleUpdate(user, aChatItem)
+    case let .rcvFileError(user, aChatItem):
+        await chatItemSimpleUpdate(user, aChatItem)
+        Task { cleanupFile(aChatItem) }
     case let .sndFileStart(user, aChatItem, _):
         await chatItemSimpleUpdate(user, aChatItem)
     case let .sndFileComplete(user, aChatItem, _):
         await chatItemSimpleUpdate(user, aChatItem)
         Task { cleanupDirectFile(aChatItem) }
     case let .sndFileRcvCancelled(user, aChatItem, _):
-        if let aChatItem = aChatItem {
-            await chatItemSimpleUpdate(user, aChatItem)
-            Task { cleanupDirectFile(aChatItem) }
-        }
+        await chatItemSimpleUpdate(user, aChatItem)
+        Task { cleanupDirectFile(aChatItem) }
     case let .sndFileProgressXFTP(user, aChatItem, _, _, _):
-        if let aChatItem = aChatItem {
-            await chatItemSimpleUpdate(user, aChatItem)
-        }
+        await chatItemSimpleUpdate(user, aChatItem)
     case let .sndFileCompleteXFTP(user, aChatItem, _):
         await chatItemSimpleUpdate(user, aChatItem)
         Task { cleanupFile(aChatItem) }
-    case let .sndFileError(user, aChatItem, _):
-        if let aChatItem = aChatItem {
-            await chatItemSimpleUpdate(user, aChatItem)
-            Task { cleanupFile(aChatItem) }
-        }
+    case let .sndFileError(user, aChatItem):
+        await chatItemSimpleUpdate(user, aChatItem)
+        Task { cleanupFile(aChatItem) }
     case let .callInvitation(invitation):
         await MainActor.run {
             m.callInvitations[invitation.contact.id] = invitation

apps/ios/Shared/Views/Database/DatabaseEncryptionView.swift

@@ -36,7 +36,6 @@ enum DatabaseEncryptionAlert: Identifiable {
 struct DatabaseEncryptionView: View {
     @EnvironmentObject private var m: ChatModel
     @Binding var useKeychain: Bool
-    var migration: Bool
     @State private var alert: DatabaseEncryptionAlert? = nil
     @State private var progressIndicator = false
     @State private var useKeychainToggle = storeDBPassphraseGroupDefault.get()
@@ -49,12 +48,7 @@ struct DatabaseEncryptionView: View {
 
     var body: some View {
         ZStack {
-            List {
-                if migration {
-                    chatStoppedView()
-                }
-                databaseEncryptionView()
-            }
+            databaseEncryptionView()
             if progressIndicator {
                 ProgressView().scaleEffect(2)
             }
@@ -62,49 +56,47 @@ struct DatabaseEncryptionView: View {
     }
 
     private func databaseEncryptionView() -> some View {
-        Section {
-            if !migration {
+        List {
+            Section {
                 settingsRow(storedKey ? "key.fill" : "key", color: storedKey ? .green : .secondary) {
                     Toggle("Save passphrase in Keychain", isOn: $useKeychainToggle)
-                        .onChange(of: useKeychainToggle) { _ in
-                            if useKeychainToggle {
-                                setUseKeychain(true)
-                            } else if storedKey {
-                                alert = .keychainRemoveKey
-                            } else {
-                                setUseKeychain(false)
-                            }
+                    .onChange(of: useKeychainToggle) { _ in
+                        if useKeychainToggle {
+                            setUseKeychain(true)
+                        } else if storedKey {
+                            alert = .keychainRemoveKey
+                        } else {
+                            setUseKeychain(false)
                         }
-                        .disabled(initialRandomDBPassphrase)
+                    }
+                    .disabled(initialRandomDBPassphrase)
                 }
-            }
 
-            if !initialRandomDBPassphrase && m.chatDbEncrypted == true {
-                PassphraseField(key: $currentKey, placeholder: "Current passphrase…", valid: validKey(currentKey))
-            }
-
-            PassphraseField(key: $newKey, placeholder: "New passphrase…", valid: validKey(newKey), showStrength: true)
-            PassphraseField(key: $confirmNewKey, placeholder: "Confirm new passphrase…", valid: confirmNewKey == "" || newKey == confirmNewKey)
-
-            settingsRow("lock.rotation") {
-                Button(migration ? "Set passphrase" : "Update database passphrase") {
-                    alert = currentKey == ""
-                    ? (useKeychain ? .encryptDatabaseSaved : .encryptDatabase)
-                    : (useKeychain ? .changeDatabaseKeySaved : .changeDatabaseKey)
+                if !initialRandomDBPassphrase && m.chatDbEncrypted == true {
+                    PassphraseField(key: $currentKey, placeholder: "Current passphrase…", valid: validKey(currentKey))
                 }
-            }
-            .disabled(
-                (m.chatDbEncrypted == true && currentKey == "") ||
-                currentKey == newKey ||
-                newKey != confirmNewKey ||
-                newKey == "" ||
-                !validKey(currentKey) ||
-                !validKey(newKey)
-            )
-        } header: {
-            Text(migration ? "Database passphrase" : "")
-        } footer: {
-            if !migration {
+
+                PassphraseField(key: $newKey, placeholder: "New passphrase…", valid: validKey(newKey), showStrength: true)
+                PassphraseField(key: $confirmNewKey, placeholder: "Confirm new passphrase…", valid: confirmNewKey == "" || newKey == confirmNewKey)
+
+                settingsRow("lock.rotation") {
+                    Button("Update database passphrase") {
+                        alert = currentKey == ""
+                        ? (useKeychain ? .encryptDatabaseSaved : .encryptDatabase)
+                        : (useKeychain ? .changeDatabaseKeySaved : .changeDatabaseKey)
+                    }
+                }
+                .disabled(
+                    (m.chatDbEncrypted == true && currentKey == "") ||
+                    currentKey == newKey ||
+                    newKey != confirmNewKey ||
+                    newKey == "" ||
+                    !validKey(currentKey) ||
+                    !validKey(newKey)
+                )
+            } header: {
+                Text("")
+            } footer: {
                 VStack(alignment: .leading, spacing: 16) {
                     if m.chatDbEncrypted == false {
                         Text("Your chat database is not encrypted - set passphrase to encrypt it.")
@@ -129,10 +121,6 @@ struct DatabaseEncryptionView: View {
                 }
                 .padding(.top, 1)
                 .font(.callout)
-            } else {
-                Text("Set database passphrase to migrate it")
-                .padding(.top, 1)
-                .font(.callout)
             }
         }
         .onAppear {
@@ -358,6 +346,6 @@ func validKey(_ s: String) -> Bool {
 
 struct DatabaseEncryptionView_Previews: PreviewProvider {
     static var previews: some View {
-        DatabaseEncryptionView(useKeychain: Binding.constant(true), migration: false)
+        DatabaseEncryptionView(useKeychain: Binding.constant(true))
     }
 }

apps/ios/Shared/Views/Database/DatabaseView.swift

@@ -116,7 +116,7 @@ struct DatabaseView: View {
                 let color: Color = unencrypted ? .orange : .secondary
                 settingsRow(unencrypted ? "lock.open" : useKeychain ? "key" : "lock", color: color) {
                     NavigationLink {
-                        DatabaseEncryptionView(useKeychain: $useKeychain, migration: false)
+                        DatabaseEncryptionView(useKeychain: $useKeychain)
                             .navigationTitle("Database passphrase")
                     } label: {
                         Text("Database passphrase")
@@ -485,10 +485,6 @@ func deleteChatAsync() async throws {
     _ = kcDatabasePassword.remove()
     storeDBPassphraseGroupDefault.set(true)
     deleteAppDatabaseAndFiles()
-    // Clean state so when creating new user the app will start chat automatically (see CreateProfile:createProfile())
-    DispatchQueue.main.async {
-        ChatModel.shared.users = []
-    }
 }
 
 struct DatabaseView_Previews: PreviewProvider {

apps/ios/Shared/Views/Database/MigrateToAppGroupView.swift

@@ -216,18 +216,16 @@ struct MigrateToAppGroupView: View {
     }
 }
 
-func exportChatArchive(_ storagePath: URL? = nil) async throws -> URL {
+func exportChatArchive() async throws -> URL {
     let archiveTime = Date.now
     let ts = archiveTime.ISO8601Format(Date.ISO8601FormatStyle(timeSeparator: .omitted))
     let archiveName = "simplex-chat.\(ts).zip"
-    let archivePath = (storagePath ?? getDocumentsDirectory()).appendingPathComponent(archiveName)
+    let archivePath = getDocumentsDirectory().appendingPathComponent(archiveName)
     let config = ArchiveConfig(archivePath: archivePath.path)
     try await apiExportArchive(config: config)
-    if storagePath == nil {
-        deleteOldArchive()
-        UserDefaults.standard.set(archiveName, forKey: DEFAULT_CHAT_ARCHIVE_NAME)
-        chatArchiveTimeDefault.set(archiveTime)
-    }
+    deleteOldArchive()
+    UserDefaults.standard.set(archiveName, forKey: DEFAULT_CHAT_ARCHIVE_NAME)
+    chatArchiveTimeDefault.set(archiveTime)
     return archivePath
 }
 

apps/ios/Shared/Views/Migration/MigrateFromAnotherDevice.swift

@@ -1,515 +0,0 @@
-//
-//  MigrateFromAnotherDevice.swift
-//  SimpleX (iOS)
-//
-//  Created by Avently on 23.02.2024.
-//  Copyright © 2024 SimpleX Chat. All rights reserved.
-//
-
-import SwiftUI
-import SimpleXChat
-
-private enum MigrationState: Equatable {
-    case pasteOrScanLink(link: String)
-    case linkDownloading(link: String)
-    case downloadProgress(downloadedBytes: Int64, totalBytes: Int64, fileId: Int64, link: String, archivePath: URL, ctrl: chat_ctrl?)
-    case downloadFailed(totalBytes: Int64, link: String, archivePath: URL)
-    case archiveImport(archivePath: String)
-    case passphraseEntering(passphrase: String)
-    case migration(passphrase: String)
-}
-
-private enum MigrateFromAnotherDeviceViewAlert: Identifiable {
-    case chatImportedWithErrors(title: LocalizedStringKey = "Chat database imported",
-                                text: LocalizedStringKey = "Some non-fatal errors occurred during import - you may see Chat console for more details.")
-
-    case wrongPassphrase(title: LocalizedStringKey = "Wrong passphrase!", message: LocalizedStringKey = "Enter correct passphrase.")
-    case invalidConfirmation(title: LocalizedStringKey = "Invalid migration confirmation")
-    case keychainError(_ title: LocalizedStringKey = "Keychain error")
-    case databaseError(_ title: LocalizedStringKey = "Database error", message: String)
-    case unknownError(_ title: LocalizedStringKey = "Unknown error", message: String)
-
-    case error(title: LocalizedStringKey, error: String = "")
-
-    var id: String {
-        switch self {
-        case .chatImportedWithErrors: return "chatImportedWithErrors"
-
-        case .wrongPassphrase: return "wrongPassphrase"
-        case .invalidConfirmation: return "invalidConfirmation"
-        case .keychainError: return "keychainError"
-        case let .databaseError(title, message): return "\(title) \(message)"
-        case let .unknownError(title, message): return "\(title) \(message)"
-
-        case let .error(title, _): return "error \(title)"
-        }
-    }
-}
-
-struct MigrateFromAnotherDevice: View {
-    @EnvironmentObject var m: ChatModel
-    @Environment(\.dismiss) var dismiss: DismissAction
-    @State private var migrationState: MigrationState = .pasteOrScanLink(link: "")
-    @State private var useKeychain = storeDBPassphraseGroupDefault.get()
-    @State private var alert: MigrateFromAnotherDeviceViewAlert?
-    private let tempDatabaseUrl = urlForTemporaryDatabase()
-    @State private var chatReceiver: MigrationChatReceiver? = nil
-    @State private var backDisabled: Bool = false
-    @State private var showQRCodeScanner: Bool = true
-
-    var body: some View {
-        VStack {
-            switch migrationState {
-            case let .pasteOrScanLink(link):
-                pasteOrScanLinkView(link)
-            case let .linkDownloading(link):
-                linkDownloadingView(link)
-            case let .downloadProgress(downloaded, total, _, link, archivePath, _):
-                downloadProgressView(downloaded, totalBytes: total, link, archivePath)
-            case let .downloadFailed(total, link, archivePath):
-                downloadFailedView(totalBytes: total, link, archivePath)
-            case let .archiveImport(archivePath):
-                archiveImportView(archivePath)
-            case let .passphraseEntering(passphrase):
-                PassphraseEnteringView(migrationState: $migrationState, currentKey: passphrase, alert: $alert)
-            case let .migration(passphrase):
-                migrationView(passphrase)
-            }
-        }
-        .modifier(BackButton(label: "Back") {
-            if !backDisabled {
-                dismiss()
-            }
-        })
-        .onChange(of: migrationState) { state in
-            backDisabled = switch migrationState {
-            case .passphraseEntering: true
-            case .migration: true
-            default: false
-            }
-        }
-        .onDisappear {
-            Task {
-                if case let .downloadProgress(_, _, fileId, _, _, ctrl) = migrationState, let ctrl {
-                    await stopArchiveDownloading(fileId, ctrl)
-                }
-                chatReceiver?.stop()
-                try? FileManager.default.removeItem(atPath: "\(tempDatabaseUrl.path)_chat.db")
-                try? FileManager.default.removeItem(atPath: "\(tempDatabaseUrl.path)_agent.db")
-                try? FileManager.default.removeItem(at: getMigrationTempFilesDirectory())
-            }
-        }
-        .alert(item: $alert) { alert in
-            switch alert {
-            case let .chatImportedWithErrors(title, text): 
-                return Alert(title: Text(title), message: Text(text))
-            case let .wrongPassphrase(title, message):
-                return Alert(title: Text(title), message: Text(message))
-            case let .invalidConfirmation(title):
-                return Alert(title: Text(title))
-            case let .keychainError(title):
-                return Alert(title: Text(title))
-            case let .databaseError(title, message):
-                return Alert(title: Text(title), message: Text(message))
-            case let .unknownError(title, message):
-                return Alert(title: Text(title), message: Text(message))
-            case let .error(title, error):
-                return Alert(title: Text(title), message: Text(error))
-            }
-        }
-        .interactiveDismissDisabled(backDisabled)
-    }
-
-    private func pasteOrScanLinkView(_ link: String) -> some View {
-        ZStack {
-            List {
-                Section("Paste link to an archive") {
-                    pasteLinkView()
-                }
-                Section("Or scan QR code") {
-                    ScannerInView(showQRCodeScanner: $showQRCodeScanner) { resp in
-                        switch resp {
-                        case let .success(r):
-                            let link = r.string
-                            if strHasSimplexFileLink(link.trimmingCharacters(in: .whitespaces)) {
-                                migrationState = .linkDownloading(link: link.trimmingCharacters(in: .whitespaces))
-                            } else {
-                                alert = .error(title: "Invalid link", error: "The text you pasted is not a SimpleX link.")
-                            }
-                        case let .failure(e):
-                            logger.error("processQRCode QR code error: \(e.localizedDescription)")
-                            alert = .error(title: "Invalid link", error: "The text you pasted is not a SimpleX link.")
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    private func pasteLinkView() -> some View {
-        Button {
-            if let str = UIPasteboard.general.string {
-                if strHasSimplexFileLink(str.trimmingCharacters(in: .whitespaces)) {
-                    migrationState = .linkDownloading(link: str.trimmingCharacters(in: .whitespaces))
-                } else {
-                    alert = .error(title: "Invalid link", error: "The text you pasted is not a SimpleX link.")
-                }
-            }
-        } label: {
-            Text("Tap to paste link")
-        }
-        .disabled(!ChatModel.shared.pasteboardHasStrings)
-        .frame(maxWidth: .infinity, alignment: .center)
-    }
-
-    private func linkDownloadingView(_ link: String) -> some View {
-        ZStack {
-            List {
-                Section {} header: {
-                    Text("Downloading link details…")
-                }
-            }
-            progressView()
-        }
-        .onAppear {
-            downloadLinkDetails(link)
-        }
-    }
-
-    private func downloadProgressView(_ downloadedBytes: Int64, totalBytes: Int64, _ link: String, _ archivePath: URL) -> some View {
-        ZStack {
-            List {
-                Section {} header: {
-                    Text("Downloading archive…")
-                }
-            }
-            let ratio = Float(downloadedBytes) / Float(totalBytes)
-            largeProgressView(ratio, "\(Int(ratio * 100))%", "\(ByteCountFormatter.string(fromByteCount: downloadedBytes, countStyle: .binary)) downloaded")
-        }
-    }
-
-    private func downloadFailedView(totalBytes: Int64, _ link: String, _ archivePath: URL) -> some View {
-        List {
-            Section {
-                Button(action: {
-                    migrationState = .downloadProgress(downloadedBytes: 0, totalBytes: totalBytes, fileId: 0, link: link, archivePath: archivePath, ctrl: nil)
-                }) {
-                    settingsRow("tray.and.arrow.down") {
-                        Text("Repeat download").foregroundColor(.accentColor)
-                    }
-                }
-            } header: {
-                Text("Download failed")
-            } footer: {
-                Text("You can give another try")
-                    .font(.callout)
-            }
-        }
-        .onAppear {
-            chatReceiver?.stop()
-            try? FileManager.default.removeItem(atPath: "\(tempDatabaseUrl.path)_chat.db")
-            try? FileManager.default.removeItem(atPath: "\(tempDatabaseUrl.path)_agent.db")
-        }
-    }
-
-    private func archiveImportView(_ archivePath: String) -> some View {
-        ZStack {
-            List {
-                Section {} header: {
-                    Text("Importing archive…")
-                }
-            }
-            progressView()
-        }
-        .onAppear {
-            importArchive(archivePath)
-        }
-    }
-
-    private func migrationView(_ passphrase: String) -> some View {
-        ZStack {
-            List {
-                Section {} header: {
-                    Text("Migrating…")
-                }
-            }
-            progressView()
-        }
-        .onAppear {
-            startChat(passphrase)
-        }
-    }
-
-    private func largeProgressView(_ value: Float, _ title: String, _ description: LocalizedStringKey) -> some View {
-        ZStack {
-            VStack {
-                Text(description)
-                    .font(.title3)
-                    .hidden()
-
-                Text(title)
-                    .font(.system(size: 60))
-                    .foregroundColor(.accentColor)
-
-                Text(description)
-                    .font(.title3)
-            }
-
-            Circle()
-                .trim(from: 0, to: CGFloat(value))
-                .stroke(
-                    Color.accentColor,
-                    style: StrokeStyle(lineWidth: 30)
-                )
-                .rotationEffect(.degrees(-90))
-                .animation(.linear, value: value)
-                .frame(maxWidth: .infinity)
-                .padding(.horizontal)
-                .padding(.horizontal)
-        }
-        .frame(maxWidth: .infinity)
-    }
-
-    private func downloadLinkDetails(_ link: String) {
-        let archiveTime = Date.now
-        let ts = archiveTime.ISO8601Format(Date.ISO8601FormatStyle(timeSeparator: .omitted))
-        let archiveName = "simplex-chat.\(ts).zip"
-        let archivePath = getMigrationTempFilesDirectory().appendingPathComponent(archiveName)
-
-        startDownloading(0, link, archivePath)
-    }
-
-    private func initTemporaryDatabase() -> (chat_ctrl, User)? {
-        let (status, ctrl) = chatInitTemporaryDatabase(url: tempDatabaseUrl)
-        showErrorOnMigrationIfNeeded(status, $alert)
-        do {
-            if let ctrl, let user = try startChatWithTemporaryDatabase(ctrl: ctrl) {
-                return (ctrl, user)
-            }
-        } catch let error {
-            logger.error("Error while starting chat in temporary database: \(error.localizedDescription)")
-        }
-        return nil
-    }
-
-    private func startDownloading(_ totalBytes: Int64, _ link: String, _ archivePath: URL) {
-        Task {
-            guard let ctrlAndUser = initTemporaryDatabase() else {
-                return migrationState = .downloadFailed(totalBytes: totalBytes, link: link, archivePath: archivePath)
-            }
-            let (ctrl, user) = ctrlAndUser
-            chatReceiver = MigrationChatReceiver(ctrl: ctrl) { msg in
-                Task {
-                    await TerminalItems.shared.add(.resp(.now, msg))
-                }
-                logger.debug("processReceivedMsg: \(msg.responseType)")
-                await MainActor.run {
-                    switch msg {
-                    case let .rcvFileProgressXFTP(_, _, receivedSize, totalSize, rcvFileTransfer):
-                        migrationState = .downloadProgress(downloadedBytes: receivedSize, totalBytes: totalSize, fileId: rcvFileTransfer.fileId, link: link, archivePath: archivePath, ctrl: ctrl)
-                    case .rcvStandaloneFileComplete:
-                        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
-                            migrationState = .archiveImport(archivePath: archivePath.path)
-                        }
-                    default:
-                        logger.debug("unsupported event: \(msg.responseType)")
-                    }
-                }
-            }
-            chatReceiver?.start()
-
-            let (res, error) = await downloadStandaloneFile(user: user, url: link, file: CryptoFile.plain(archivePath.lastPathComponent), ctrl: ctrl)
-            if res == nil {
-                migrationState = .downloadFailed(totalBytes: totalBytes, link: link, archivePath: archivePath)
-                return alert = .error(title: "Error downloading the archive", error: error ?? "")
-            }
-        }
-    }
-
-    private func importArchive(_ archivePath: String) {
-        Task {
-            do {
-                try await apiDeleteStorage()
-                do {
-                    let config = ArchiveConfig(archivePath: archivePath)
-                    let archiveErrors = try await apiImportArchive(config: config)
-                    if !archiveErrors.isEmpty {
-                        alert = .chatImportedWithErrors()
-                    }
-                    migrationState = .passphraseEntering(passphrase: "")
-                } catch let error {
-                    alert = .error(title: "Error importing chat database", error: responseError(error))
-                }
-            } catch let error {
-                alert = .error(title: "Error deleting chat database", error: responseError(error))
-            }
-        }
-    }
-
-
-    private func stopArchiveDownloading(_ fileId: Int64, _ ctrl: chat_ctrl) async {
-        _ = await apiCancelFile(fileId: fileId, ctrl: ctrl)
-    }
-
-    private func cancelMigration(_ fileId: Int64, _ ctrl: chat_ctrl) {
-        Task {
-            await stopArchiveDownloading(fileId, ctrl)
-            await MainActor.run {
-                dismiss()
-            }
-        }
-    }
-
-    private func startChat(_ passphrase: String) {
-        _ = kcDatabasePassword.set(passphrase)
-        storeDBPassphraseGroupDefault.set(true)
-        initialRandomDBPassphraseGroupDefault.set(false)
-        AppChatState.shared.set(.active)
-        Task {
-            do {
-//                resetChatCtrl()
-                try initializeChat(start: true, confirmStart: false, dbKey: passphrase, refreshInvitations: true)
-                await MainActor.run {
-                    hideView()
-                    AlertManager.shared.showAlertMsg(title: "Chat migrated!", message: "Notify another device")
-                }
-            } catch let error {
-                hideView()
-                AlertManager.shared.showAlert(Alert(title: Text("Error starting chat"), message: Text(responseError(error))))
-            }
-        }
-    }
-
-    private func hideView() {
-        onboardingStageDefault.set(.onboardingComplete)
-        m.onboardingStage = .onboardingComplete
-        dismiss()
-    }
-
-    private func strHasSimplexFileLink(_ text: String) -> Bool {
-        text.starts(with: "simplex:/file") || text.starts(with: "https://simplex.chat/file")
-    }
-
-    private static func urlForTemporaryDatabase() -> URL {
-        URL(fileURLWithPath: generateNewFileName(getMigrationTempFilesDirectory().path + "/" + "migration", "db", fullPath: true))
-    }
-}
-
-private struct PassphraseEnteringView: View {
-    @Binding var migrationState: MigrationState
-    @State private var useKeychain = storeDBPassphraseGroupDefault.get()
-    @State var currentKey: String
-    @State private var verifyingPassphrase: Bool = false
-    @Binding var alert: MigrateFromAnotherDeviceViewAlert?
-
-    var body: some View {
-        ZStack {
-            List {
-                Section {
-                    PassphraseField(key: $currentKey, placeholder: "Current passphrase…", valid: validKey(currentKey))
-                    Button(action: {
-                        verifyingPassphrase = true
-                        hideKeyboard()
-                        Task {
-                            let (status, ctrl) = chatInitTemporaryDatabase(url: getAppDatabasePath(), key: currentKey)
-                            let success = switch status {
-                            case .ok, .invalidConfirmation: true
-                            default: false
-                            }
-                            if success {
-//                                if let ctrl {
-//                                    chat_close_store(ctrl)
-//                                }
-                                applyChatCtrl(ctrl: ctrl, result: (currentKey != "", status))
-                                migrationState = .migration(passphrase: currentKey)
-                            } else {
-                                showErrorOnMigrationIfNeeded(status, $alert)
-                            }
-                            verifyingPassphrase = false
-                        }
-                    }) {
-                        settingsRow("key", color: .secondary) {
-                            Text("Open chat")
-                        }
-                    }
-                } header: {
-                    Text("Enter passphrase")
-                } footer: {
-                    Text("Passphrase will be stored on device in Keychain. It's required for notifications to work. You can change it later in settings")
-                        .font(.callout)
-                }
-            }
-            if verifyingPassphrase {
-                progressView()
-            }
-        }
-    }
-}
-
-private func showErrorOnMigrationIfNeeded(_ status: DBMigrationResult, _ alert: Binding<MigrateFromAnotherDeviceViewAlert?>) {
-    switch status {
-    case .invalidConfirmation:
-        alert.wrappedValue = .invalidConfirmation()
-    case .errorNotADatabase:
-        alert.wrappedValue = .wrongPassphrase()
-    case .errorKeychain:
-        alert.wrappedValue = .keychainError()
-    case let .errorSQL(_, error):
-        alert.wrappedValue = .databaseError(message: error)
-    case let .unknown(error):
-        alert.wrappedValue = .unknownError(message: error)
-    case .errorMigration: ()
-    case .ok: ()
-    }
-}
-
-private func progressView() -> some View {
-    VStack {
-        ProgressView().scaleEffect(2)
-    }
-    .frame(maxWidth: .infinity, maxHeight: .infinity )
-}
-
-private class MigrationChatReceiver {
-    let ctrl: chat_ctrl
-    let processReceivedMsg: (ChatResponse) async -> Void
-    private var receiveLoop: Task<Void, Never>?
-    private var receiveMessages = true
-
-    init(ctrl: chat_ctrl, _ processReceivedMsg: @escaping (ChatResponse) async -> Void) {
-        self.ctrl = ctrl
-        self.processReceivedMsg = processReceivedMsg
-    }
-
-    func start() {
-        logger.debug("MigrationChatReceiver.start")
-        receiveMessages = true
-        if receiveLoop != nil { return }
-        receiveLoop = Task { await receiveMsgLoop() }
-    }
-
-    func receiveMsgLoop() async {
-        // TODO use function that has timeout
-        if let msg = await chatRecvMsg(ctrl) {
-            await processReceivedMsg(msg)
-        }
-        if self.receiveMessages {
-            _ = try? await Task.sleep(nanoseconds: 7_500_000)
-            await receiveMsgLoop()
-        }
-    }
-
-    func stop() {
-        logger.debug("MigrationChatReceiver.stop")
-        receiveMessages = false
-        receiveLoop?.cancel()
-        receiveLoop = nil
-        chat_close_store(ctrl)
-    }
-}
-
-struct MigrateFromAnotherDevice_Previews: PreviewProvider {
-    static var previews: some View {
-        MigrateFromAnotherDevice()
-    }
-}

apps/ios/Shared/Views/Migration/MigrateToAnotherDevice.swift

@@ -1,670 +0,0 @@
-//
-//  MigrateToAnotherDevice.swift
-//  SimpleX (iOS)
-//
-//  Created by Avently on 14.02.2024.
-//  Copyright © 2024 SimpleX Chat. All rights reserved.
-//
-
-import SwiftUI
-import SimpleXChat
-
-private enum MigrationState: Equatable {
-    case initial
-    case chatStopInProgress
-    case chatStopFailed(reason: String)
-    case passphraseNotSet
-    case passphraseConfirmation
-    case uploadConfirmation
-    case archiving
-    case uploadProgress(uploadedBytes: Int64, totalBytes: Int64, fileId: Int64, archivePath: URL, ctrl: chat_ctrl?)
-    case uploadFailed(totalBytes: Int64, archivePath: URL)
-    case linkCreation(totalBytes: Int64)
-    case linkShown(fileId: Int64, link: String, archivePath: URL, ctrl: chat_ctrl)
-    case finished
-}
-
-private enum MigrateToAnotherDeviceViewAlert: Identifiable {
-    case deleteChat(_ title: LocalizedStringKey = "Delete chat profile?", _ text: LocalizedStringKey = "This action cannot be undone - your profile, contacts, messages and files will be irreversibly lost.")
-    case startChat(_ title: LocalizedStringKey = "Start chat?", _ text: LocalizedStringKey = "Warning: starting chat on multiple devices is not supported and will cause message delivery failures")
-
-    case wrongPassphrase(title: LocalizedStringKey = "Wrong passphrase!", message: LocalizedStringKey = "Enter correct passphrase.")
-    case invalidConfirmation(title: LocalizedStringKey = "Invalid migration confirmation")
-    case keychainError(_ title: LocalizedStringKey = "Keychain error")
-    case databaseError(_ title: LocalizedStringKey = "Database error", message: String)
-    case unknownError(_ title: LocalizedStringKey = "Unknown error", message: String)
-
-    case error(title: LocalizedStringKey, error: String = "")
-
-    var id: String {
-        switch self {
-        case let .deleteChat(title, text): return "\(title) \(text)"
-        case let .startChat(title, text): return "\(title) \(text)"
-
-        case .wrongPassphrase: return "wrongPassphrase"
-        case .invalidConfirmation: return "invalidConfirmation"
-        case .keychainError: return "keychainError"
-        case let .databaseError(title, message): return "\(title) \(message)"
-        case let .unknownError(title, message): return "\(title) \(message)"
-
-        case let .error(title, _): return "error \(title)"
-        }
-    }
-}
-
-struct MigrateToAnotherDevice: View {
-    @EnvironmentObject var m: ChatModel
-    @Environment(\.dismiss) var dismiss: DismissAction
-    @Binding var showSettings: Bool
-    @State private var migrationState: MigrationState = .initial
-    @State private var useKeychain = storeDBPassphraseGroupDefault.get()
-    @AppStorage(GROUP_DEFAULT_INITIAL_RANDOM_DB_PASSPHRASE, store: groupDefaults) private var initialRandomDBPassphrase: Bool = false
-    @State private var alert: MigrateToAnotherDeviceViewAlert?
-    @State private var authorized = !UserDefaults.standard.bool(forKey: DEFAULT_PERFORM_LA)
-    @State private var chatWasStoppedInitially: Bool = true
-    private let tempDatabaseUrl = urlForTemporaryDatabase()
-    @State private var chatReceiver: MigrationChatReceiver? = nil
-    @State private var backDisabled: Bool = false
-
-    var body: some View {
-        if authorized {
-            migrateView()
-        } else {
-            Button(action: runAuth) { Label("Unlock", systemImage: "lock") }
-                .onAppear(perform: runAuth)
-        }
-    }
-
-    private func runAuth() { authorize(NSLocalizedString("Open migration to another device", comment: "authentication reason"), $authorized) }
-
-    func migrateView() -> some View {
-        VStack {
-            switch migrationState {
-            case .initial: EmptyView()
-            case .chatStopInProgress:
-                chatStopInProgressView()
-            case let .chatStopFailed(reason):
-                chatStopFailedView(reason)
-            case .passphraseNotSet:
-                passphraseNotSetView()
-            case .passphraseConfirmation:
-                PassphraseConfirmationView(migrationState: $migrationState, alert: $alert)
-            case .uploadConfirmation:
-                uploadConfirmationView()
-            case .archiving:
-                archivingView()
-            case let .uploadProgress(uploaded, total, _, archivePath, _):
-                uploadProgressView(uploaded, totalBytes: total, archivePath)
-            case let .uploadFailed(total, archivePath):
-                uploadFailedView(totalBytes: total, archivePath)
-            case let .linkCreation(totalBytes):
-                linkCreationView(totalBytes)
-            case let .linkShown(fileId, link, archivePath, ctrl):
-                linkView(fileId, link, archivePath, ctrl)
-            case .finished:
-                finishedView()
-            }
-        }
-        .modifier(BackButton(label: "Back") {
-            if !backDisabled {
-                dismiss()
-            }
-        })
-        .onChange(of: migrationState) { state in
-            backDisabled = switch migrationState {
-            case .linkCreation: true
-            case .linkShown: true
-            default: false
-            }
-        }
-        .onAppear {
-            if case .initial = migrationState {
-                if m.chatRunning == false {
-                    migrationState = initialRandomDBPassphrase ? .passphraseNotSet : .passphraseConfirmation
-                    chatWasStoppedInitially = true
-                } else {
-                    migrationState = .chatStopInProgress
-                    chatWasStoppedInitially = false
-                    stopChat()
-                }
-            }
-        }
-        .onDisappear {
-            if case .linkShown = migrationState {} else if case .finished = migrationState {} else if !chatWasStoppedInitially {
-                Task {
-                    AppChatState.shared.set(.active)
-                    try? startChat(refreshInvitations: true)
-                }
-            }
-            Task {
-                if case let .uploadProgress(_, _, fileId, _, ctrl) = migrationState, let ctrl {
-                    await cancelUploadedAchive(fileId, ctrl)
-                }
-                chatReceiver?.stop()
-                try? FileManager.default.removeItem(atPath: "\(tempDatabaseUrl.path)_chat.db")
-                try? FileManager.default.removeItem(atPath: "\(tempDatabaseUrl.path)_agent.db")
-                try? FileManager.default.removeItem(at: getMigrationTempFilesDirectory())
-            }
-        }
-        .alert(item: $alert) { alert in
-            switch alert {
-            case let .startChat(title, text):
-                return Alert(
-                    title: Text(title),
-                    message: Text(text),
-                    primaryButton: .destructive(Text("Start chat")) {
-                        startChatAndDismiss()
-                    },
-                    secondaryButton: .cancel()
-                )
-            case let .deleteChat(title, text):
-                return Alert(
-                    title: Text(title),
-                    message: Text(text),
-                    primaryButton: .destructive(Text("Delete")) {
-                        deleteChatAndDismiss()
-                    },
-                    secondaryButton: .cancel()
-                )
-            case let .wrongPassphrase(title, message):
-                return Alert(title: Text(title), message: Text(message))
-            case let .invalidConfirmation(title):
-                return Alert(title: Text(title))
-            case let .keychainError(title):
-                return Alert(title: Text(title))
-            case let .databaseError(title, message):
-                return Alert(title: Text(title), message: Text(message))
-            case let .unknownError(title, message):
-                return Alert(title: Text(title), message: Text(message))
-            case let .error(title, error):
-                return Alert(title: Text(title), message: Text(error))
-            }
-        }
-        .interactiveDismissDisabled(backDisabled)
-    }
-
-    private func chatStopInProgressView() -> some View {
-        ZStack {
-            List {
-                Section {} header: {
-                    Text("Stopping chat")
-                }
-            }
-            progressView()
-        }
-    }
-
-    private func chatStopFailedView(_ reason: String) -> some View {
-        Section {
-            Text(reason)
-            Button(action: stopChat) {
-                settingsRow("stop.fill") {
-                    Text("Stop chat").foregroundColor(.red)
-                }
-            }
-        } header: {
-            Text("Error stopping chat")
-        } footer: {
-            Text("In order to continue, chat should be stopped")
-                .font(.callout)
-        }
-    }
-
-    private func passphraseNotSetView() -> some View {
-        DatabaseEncryptionView(useKeychain: $useKeychain, migration: true)
-            .onChange(of: initialRandomDBPassphrase) { initial in
-                if !initial {
-                    migrationState = .uploadConfirmation
-                }
-            }
-    }
-
-    private func uploadConfirmationView() -> some View {
-        List {
-            Section {
-                Button(action: { migrationState = .archiving }) {
-                    settingsRow("tray.and.arrow.up") {
-                        Text("Archive and upload").foregroundColor(.accentColor)
-                    }
-                }
-            } header: {
-                Text("Confirm upload")
-            } footer: {
-                Text("All your contacts, conversations and files will be archived and uploaded as encrypted file to configured XFTP relays")
-                    .font(.callout)
-            }
-        }
-    }
-
-    private func archivingView() -> some View {
-        ZStack {
-            List {
-                Section {} header: {
-                    Text("Archiving database…")
-                }
-            }
-            progressView()
-        }
-        .onAppear {
-            exportArchive()
-        }
-    }
-
-    private func uploadProgressView(_ uploadedBytes: Int64, totalBytes: Int64, _ archivePath: URL) -> some View {
-        ZStack {
-            List {
-                Section {} header: {
-                    Text("Uploading archive…")
-                }
-            }
-            let ratio = Float(uploadedBytes) / Float(totalBytes)
-            largeProgressView(ratio, "\(Int(ratio * 100))%", "\(ByteCountFormatter.string(fromByteCount: uploadedBytes, countStyle: .binary)) uploaded")
-        }
-        .onAppear {
-            startUploading(totalBytes, archivePath)
-        }
-    }
-
-    private func uploadFailedView(totalBytes: Int64, _ archivePath: URL) -> some View {
-        List {
-            Section {
-                Button(action: {
-                    migrationState = .uploadProgress(uploadedBytes: 0, totalBytes: totalBytes, fileId: 0, archivePath: archivePath, ctrl: nil)
-                }) {
-                    settingsRow("tray.and.arrow.up") {
-                        Text("Repeat upload").foregroundColor(.accentColor)
-                    }
-                }
-            } header: {
-                Text("Upload failed")
-            } footer: {
-                Text("You can give another try")
-                    .font(.callout)
-            }
-        }
-        .onAppear {
-            chatReceiver?.stop()
-            try? FileManager.default.removeItem(atPath: "\(tempDatabaseUrl.path)_chat.db")
-            try? FileManager.default.removeItem(atPath: "\(tempDatabaseUrl.path)_agent.db")
-        }
-    }
-
-    private func linkCreationView(_ totalBytes: Int64) -> some View {
-        ZStack {
-            List {
-                Section {} header: {
-                    Text("Creating archive link…")
-                }
-            }
-            progressView()
-        }
-    }
-
-    private func linkView(_ fileId: Int64, _ link: String, _ archivePath: URL, _ ctrl: chat_ctrl) -> some View {
-        List {
-            Section {
-                Button(action: { cancelMigration(fileId, ctrl) }) {
-                    settingsRow("multiply") {
-                        Text("Cancel migration").foregroundColor(.red)
-                    }
-                }
-                Button(action: { finishMigration(fileId, ctrl) }) {
-                    settingsRow("checkmark") {
-                        Text("Finalize migration").foregroundColor(.accentColor)
-                    }
-                }
-            } footer: {
-                Text("Make sure you made the migration before going forward")
-                    .font(.callout)
-            }
-            Section {
-                SimpleXLinkQRCode(uri: link)
-                    .frame(maxWidth: .infinity)
-                shareLinkButton(link)
-            } header: {
-                Text("Link to uploaded archive")
-            } footer: {
-                Text("Choose Migrate from another device on your new device and scan QR code")
-                    .font(.callout)
-            }
-        }
-    }
-
-    private func finishedView() -> some View {
-        List {
-            Section {
-                Button(action: { alert = .deleteChat() }) {
-                    settingsRow("trash.fill") {
-                        Text("Delete database from this device").foregroundColor(.accentColor)
-                    }
-                }
-                Button(action: { alert = .startChat() }) {
-                    settingsRow("play.fill") {
-                        Text("Start chat").foregroundColor(.red)
-                    }
-                }
-            } header: {
-                Text("Migration complete")
-            } footer: {
-                Text("You should not use the same database on two devices")
-                    .font(.callout)
-            }
-        }
-    }
-
-    private func shareLinkButton(_ link: String) -> some View {
-        Button {
-            showShareSheet(items: [simplexChatLink(link)])
-        } label: {
-            Label("Share link", systemImage: "square.and.arrow.up")
-        }
-    }
-
-    private func largeProgressView(_ value: Float, _ title: String, _ description: LocalizedStringKey) -> some View {
-        ZStack {
-            VStack {
-                Text(description)
-                    .font(.title3)
-                    .hidden()
-
-                Text(title)
-                    .font(.system(size: 60))
-                    .foregroundColor(.accentColor)
-
-                Text(description)
-                    .font(.title3)
-            }
-
-            Circle()
-                .trim(from: 0, to: CGFloat(value))
-                .stroke(
-                    Color.accentColor,
-                    style: StrokeStyle(lineWidth: 30)
-                )
-                .rotationEffect(.degrees(-90))
-                .animation(.linear, value: value)
-                .frame(maxWidth: .infinity)
-                .padding(.horizontal)
-                .padding(.horizontal)
-        }
-        .frame(maxWidth: .infinity)
-    }
-
-    private func stopChat() {
-        Task {
-            do {
-                try await stopChatAsync()
-                await MainActor.run {
-                    migrationState = initialRandomDBPassphraseGroupDefault.get() ? .passphraseNotSet : .passphraseConfirmation
-                }
-            } catch let e {
-                await MainActor.run {
-                    migrationState = .chatStopFailed(reason: e.localizedDescription)
-                }
-            }
-        }
-    }
-
-    private func exportArchive() {
-        Task {
-            do {
-                try? FileManager.default.createDirectory(at: getMigrationTempFilesDirectory(), withIntermediateDirectories: true)
-                let archivePath = try await exportChatArchive(getMigrationTempFilesDirectory())
-                if let attrs = try? FileManager.default.attributesOfItem(atPath: archivePath.path),
-                    let totalBytes = attrs[.size] as? Int64 {
-                    await MainActor.run {
-                        migrationState = .uploadProgress(uploadedBytes: 0, totalBytes: totalBytes, fileId: 0, archivePath: archivePath, ctrl: nil)
-                    }
-                } else {
-                    await MainActor.run {
-                        alert = .error(title: "Exported file doesn't exist")
-                        migrationState = .uploadConfirmation
-                    }
-                }
-            } catch let error {
-                await MainActor.run {
-                    alert = .error(title: "Error exporting chat database", error: responseError(error))
-                    migrationState = .uploadConfirmation
-                }
-            }
-        }
-    }
-
-    private func initTemporaryDatabase() -> (chat_ctrl, User)? {
-        let (status, ctrl) = chatInitTemporaryDatabase(url: tempDatabaseUrl)
-        showErrorOnMigrationIfNeeded(status, $alert)
-        do {
-            if let ctrl, let user = try startChatWithTemporaryDatabase(ctrl: ctrl) {
-                return (ctrl, user)
-            }
-        } catch let error {
-            logger.error("Error while starting chat in temporary database: \(error.localizedDescription)")
-        }
-        return nil
-    }
-
-    private func startUploading(_ totalBytes: Int64, _ archivePath: URL) {
-        Task {
-            guard let ctrlAndUser = initTemporaryDatabase() else {
-                return migrationState = .uploadFailed(totalBytes: totalBytes, archivePath: archivePath)
-            }
-            let (ctrl, user) = ctrlAndUser
-            chatReceiver = MigrationChatReceiver(ctrl: ctrl) { msg in
-                Task {
-                    await TerminalItems.shared.add(.resp(.now, msg))
-                }
-                logger.debug("processReceivedMsg: \(msg.responseType)")
-                await MainActor.run {
-                    switch msg {
-                    case let .sndFileProgressXFTP(_, _, fileTransferMeta, sentSize, totalSize):
-                        if case let .uploadProgress(uploaded, total, _, _, _) = migrationState, uploaded != total {
-                            migrationState = .uploadProgress(uploadedBytes: sentSize, totalBytes: totalSize, fileId: fileTransferMeta.fileId, archivePath: archivePath, ctrl: ctrl)
-                        }
-                    case let .sndFileRedirectStartXFTP(_, fileTransferMeta, _):
-                        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
-                            migrationState = .linkCreation(totalBytes: fileTransferMeta.fileSize)
-                        }
-                    case let .sndStandaloneFileComplete(_, fileTransferMeta, rcvURIs):
-                        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
-                            migrationState = .linkShown(fileId: fileTransferMeta.fileId, link: rcvURIs[0], archivePath: archivePath, ctrl: ctrl)
-                        }
-                    default:
-                        logger.debug("unsupported event: \(msg.responseType)")
-                    }
-                }
-            }
-            chatReceiver?.start()
-
-            let (res, error) = await uploadStandaloneFile(user: user, file: CryptoFile.plain(archivePath.lastPathComponent), ctrl: ctrl)
-            guard let res = res else {
-                migrationState = .uploadFailed(totalBytes: totalBytes, archivePath: archivePath)
-                return alert = .error(title: "Error uploading the archive", error: error ?? "")
-            }
-            migrationState = .uploadProgress(uploadedBytes: 0, totalBytes: res.fileSize, fileId: res.fileId, archivePath: archivePath, ctrl: ctrl)
-        }
-    }
-
-    private func cancelUploadedAchive(_ fileId: Int64, _ ctrl: chat_ctrl) async {
-        _ = await apiCancelFile(fileId: fileId, ctrl: ctrl)
-    }
-
-    private func cancelMigration(_ fileId: Int64, _ ctrl: chat_ctrl) {
-        Task {
-            await cancelUploadedAchive(fileId, ctrl)
-            await MainActor.run {
-                if !chatWasStoppedInitially {
-                    startChatAndDismiss()
-                } else {
-                    dismiss()
-                }
-            }
-        }
-    }
-
-    private func finishMigration(_ fileId: Int64, _ ctrl: chat_ctrl) {
-        Task {
-            await cancelUploadedAchive(fileId, ctrl)
-            await MainActor.run {
-                migrationState = .finished
-            }
-        }
-    }
-
-    private func deleteChatAndDismiss() {
-        Task {
-            do {
-                try await deleteChatAsync()
-                m.chatDbChanged = true
-                m.chatInitialized = false
-                showSettings = false
-                DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
-                    resetChatCtrl()
-                    do {
-                        try initializeChat(start: false)
-                        m.chatDbChanged = false
-                        AppChatState.shared.set(.active)
-                    } catch let error {
-                        fatalError("Error starting chat \(responseError(error))")
-                    }
-                }
-                dismiss()
-            } catch let error {
-                alert = .error(title: "Error deleting database", error: responseError(error))
-            }
-        }
-    }
-
-    private func startChatAndDismiss() {
-        Task {
-            AppChatState.shared.set(.active)
-            try? startChat(refreshInvitations: true)
-            dismiss()
-        }
-    }
-
-    private static func urlForTemporaryDatabase() -> URL {
-        URL(fileURLWithPath: generateNewFileName(getMigrationTempFilesDirectory().path + "/" + "migration", "db", fullPath: true))
-    }
-}
-
-private struct PassphraseConfirmationView: View {
-    @Binding var migrationState: MigrationState
-    @State private var useKeychain = storeDBPassphraseGroupDefault.get()
-    @State private var currentKey: String = ""
-    @State private var verifyingPassphrase: Bool = false
-    @Binding var alert: MigrateToAnotherDeviceViewAlert?
-
-    var body: some View {
-        ZStack {
-            List {
-                chatStoppedView()
-                Section {
-                    PassphraseField(key: $currentKey, placeholder: "Current passphrase…", valid: validKey(currentKey))
-                    Button(action: {
-                        verifyingPassphrase = true
-                        hideKeyboard()
-                        Task {
-                            await verifyDatabasePassphrase(currentKey)
-                            verifyingPassphrase = false
-                        }
-                    }) {
-                        settingsRow(useKeychain ? "key" : "lock", color: .secondary) {
-                            Text("Verify passphrase")
-                        }
-                    }
-                } header: {
-                    Text("Verify database passphrase to migrate it")
-                } footer: {
-                    Text("Make sure you remember database passphrase before migrating")
-                        .font(.callout)
-                }
-            }
-            if verifyingPassphrase {
-                progressView()
-            }
-        }
-    }
-
-    private func verifyDatabasePassphrase(_ dbKey: String) async {
-        do {
-            try await testStorageEncryption(key: dbKey)
-            migrationState = .uploadConfirmation
-        } catch {
-            showErrorOnMigrationIfNeeded(.errorNotADatabase(dbFile: ""), $alert)
-        }
-    }
-}
-
-private func showErrorOnMigrationIfNeeded(_ status: DBMigrationResult, _ alert: Binding<MigrateToAnotherDeviceViewAlert?>) {
-    switch status {
-    case .invalidConfirmation:
-        alert.wrappedValue = .invalidConfirmation()
-    case .errorNotADatabase:
-        alert.wrappedValue = .wrongPassphrase()
-    case .errorKeychain:
-        alert.wrappedValue = .keychainError()
-    case let .errorSQL(_, error):
-        alert.wrappedValue = .databaseError(message: error)
-    case let .unknown(error):
-        alert.wrappedValue = .unknownError(message: error)
-    case .errorMigration: ()
-    case .ok: ()
-    }
-}
-
-private func progressView() -> some View {
-    VStack {
-        ProgressView().scaleEffect(2)
-    }
-    .frame(maxWidth: .infinity, maxHeight: .infinity )
-}
-
-func chatStoppedView() -> some View {
-    settingsRow("exclamationmark.octagon.fill", color: .red) {
-        Text("Chat is stopped")
-    }
-}
-
-private class MigrationChatReceiver {
-    let ctrl: chat_ctrl
-    let processReceivedMsg: (ChatResponse) async -> Void
-    private var receiveLoop: Task<Void, Never>?
-    private var receiveMessages = true
-
-    init(ctrl: chat_ctrl, _ processReceivedMsg: @escaping (ChatResponse) async -> Void) {
-        self.ctrl = ctrl
-        self.processReceivedMsg = processReceivedMsg
-    }
-
-    func start() {
-        logger.debug("MigrationChatReceiver.start")
-        receiveMessages = true
-        if receiveLoop != nil { return }
-        receiveLoop = Task { await receiveMsgLoop() }
-    }
-
-    func receiveMsgLoop() async {
-        // TODO use function that has timeout
-        if let msg = await chatRecvMsg(ctrl) {
-            await processReceivedMsg(msg)
-        }
-        if self.receiveMessages {
-            _ = try? await Task.sleep(nanoseconds: 7_500_000)
-            await receiveMsgLoop()
-        }
-    }
-
-    func stop() {
-        logger.debug("MigrationChatReceiver.stop")
-        receiveMessages = false
-        receiveLoop?.cancel()
-        receiveLoop = nil
-        chat_close_store(ctrl)
-    }
-}
-
-struct MigrateToAnotherDevice_Previews: PreviewProvider {
-    static var previews: some View {
-        MigrateToAnotherDevice(showSettings: Binding.constant(true))
-    }
-}

apps/ios/Shared/Views/NewChat/NewChatView.swift

@@ -86,7 +86,7 @@ struct NewChatView: View {
                         }
                 }
                 if case .connect = selection {
-                    ConnectView(showQRCodeScanner: $showQRCodeScanner, pastedLink: $pastedLink, alert: $alert)
+                    ConnectView(showQRCodeScanner: showQRCodeScanner, pastedLink: $pastedLink, alert: $alert)
                         .transition(.move(edge: .trailing))
                 }
             }
@@ -284,7 +284,8 @@ private struct InviteView: View {
 
 private struct ConnectView: View {
     @Environment(\.dismiss) var dismiss: DismissAction
-    @Binding var showQRCodeScanner: Bool
+    @State var showQRCodeScanner = false
+    @State private var cameraAuthorizationStatus: AVAuthorizationStatus?
     @Binding var pastedLink: String
     @Binding var alert: NewChatViewAlert?
     @State private var sheet: PlanAndConnectActionSheet?
@@ -294,13 +295,32 @@ private struct ConnectView: View {
             Section("Paste the link you received") {
                 pasteLinkView()
             }
-            Section("Or scan QR code") {
-                ScannerInView(showQRCodeScanner: $showQRCodeScanner, processQRCode: processQRCode)
-            }
+
+            scanCodeView()
         }
         .actionSheet(item: $sheet) { s in
             planAndConnectActionSheet(s, dismiss: true, cleanup: { pastedLink = "" })
         }
+        .onAppear {
+            let status = AVCaptureDevice.authorizationStatus(for: .video)
+            cameraAuthorizationStatus = status
+            if showQRCodeScanner {
+                switch status {
+                case .notDetermined: askCameraAuthorization()
+                case .restricted: showQRCodeScanner = false
+                case .denied: showQRCodeScanner = false
+                case .authorized: ()
+                @unknown default: askCameraAuthorization()
+                }
+            }
+        }
+    }
+
+    func askCameraAuthorization(_ cb: (() -> Void)? = nil) {
+        AVCaptureDevice.requestAccess(for: .video) { allowed in
+            cameraAuthorizationStatus = AVCaptureDevice.authorizationStatus(for: .video)
+            if allowed { cb?() }
+        }
     }
 
     @ViewBuilder private func pasteLinkView() -> some View {
@@ -331,45 +351,8 @@ private struct ConnectView: View {
         }
     }
 
-    private func processQRCode(_ resp: Result<ScanResult, ScanError>) {
-        switch resp {
-        case let .success(r):
-            let link = r.string
-            if strIsSimplexLink(r.string) {
-                connect(link)
-            } else {
-                alert = .newChatSomeAlert(alert: .someAlert(
-                    alert: mkAlert(title: "Invalid QR code", message: "The code you scanned is not a SimpleX link QR code."),
-                    id: "processQRCode: code is not a SimpleX link"
-                ))
-            }
-        case let .failure(e):
-            logger.error("processQRCode QR code error: \(e.localizedDescription)")
-            alert = .newChatSomeAlert(alert: .someAlert(
-                alert: mkAlert(title: "Invalid QR code", message: "Error scanning code: \(e.localizedDescription)"),
-                id: "processQRCode: failure"
-            ))
-        }
-    }
-
-    private func connect(_ link: String) {
-        planAndConnect(
-            link,
-            showAlert: { alert = .planAndConnectAlert(alert: $0) },
-            showActionSheet: { sheet = $0 },
-            dismiss: true,
-            incognito: nil
-        )
-    }
-}
-
-struct ScannerInView: View {
-    @Binding var showQRCodeScanner: Bool
-    let processQRCode: (_ resp: Result<ScanResult, ScanError>) -> Void
-    @State private var cameraAuthorizationStatus: AVAuthorizationStatus?
-
-    var body: some View {
-        Group {
+    private func scanCodeView() -> some View {
+        Section("Or scan QR code") {
             if showQRCodeScanner, case .authorized = cameraAuthorizationStatus {
                 CodeScannerView(codeTypes: [.qr], scanMode: .continuous, completion: processQRCode)
                     .aspectRatio(1, contentMode: .fit)
@@ -413,26 +396,37 @@ struct ScannerInView: View {
                 .disabled(cameraAuthorizationStatus == .restricted)
             }
         }
-        .onAppear {
-            let status = AVCaptureDevice.authorizationStatus(for: .video)
-            cameraAuthorizationStatus = status
-            if showQRCodeScanner {
-                switch status {
-                case .notDetermined: askCameraAuthorization()
-                case .restricted: showQRCodeScanner = false
-                case .denied: showQRCodeScanner = false
-                case .authorized: ()
-                @unknown default: askCameraAuthorization()
-                }
+    }
+
+    private func processQRCode(_ resp: Result<ScanResult, ScanError>) {
+        switch resp {
+        case let .success(r):
+            let link = r.string
+            if strIsSimplexLink(r.string) {
+                connect(link)
+            } else {
+                alert = .newChatSomeAlert(alert: .someAlert(
+                    alert: mkAlert(title: "Invalid QR code", message: "The code you scanned is not a SimpleX link QR code."),
+                    id: "processQRCode: code is not a SimpleX link"
+                ))
             }
+        case let .failure(e):
+            logger.error("processQRCode QR code error: \(e.localizedDescription)")
+            alert = .newChatSomeAlert(alert: .someAlert(
+                alert: mkAlert(title: "Invalid QR code", message: "Error scanning code: \(e.localizedDescription)"),
+                id: "processQRCode: failure"
+            ))
         }
     }
 
-    func askCameraAuthorization(_ cb: (() -> Void)? = nil) {
-        AVCaptureDevice.requestAccess(for: .video) { allowed in
-            cameraAuthorizationStatus = AVCaptureDevice.authorizationStatus(for: .video)
-            if allowed { cb?() }
-        }
+    private func connect(_ link: String) {
+        planAndConnect(
+            link,
+            showAlert: { alert = .planAndConnectAlert(alert: $0) },
+            showActionSheet: { sheet = $0 },
+            dismiss: true,
+            incognito: nil
+        )
     }
 }
 

apps/ios/Shared/Views/Onboarding/HowItWorks.swift

@@ -37,7 +37,7 @@ struct HowItWorks: View {
             Spacer()
 
             if onboarding {
-                OnboardingActionButton(hideMigrate: true)
+                OnboardingActionButton()
                     .padding(.bottom, 8)
             }
         }

apps/ios/Shared/Views/Onboarding/SimpleXInfo.swift

@@ -42,7 +42,7 @@ struct SimpleXInfo: View {
 
                     Spacer()
                     if onboarding {
-                        OnboardingActionButton(hideMigrate: false)
+                        OnboardingActionButton()
                         Spacer()
                     }
 
@@ -87,28 +87,10 @@ struct SimpleXInfo: View {
 
 struct OnboardingActionButton: View {
     @EnvironmentObject var m: ChatModel
-    let hideMigrate: Bool
-    @State private var migrateFromAnotherDevice: Bool = false
 
     var body: some View {
         if m.currentUser == nil {
             actionButton("Create your profile", onboarding: .step2_CreateProfile)
-
-            if !hideMigrate {
-                actionButton("Migrate from another device") {
-                    migrateFromAnotherDevice = true
-                }
-                .sheet(isPresented: $migrateFromAnotherDevice) {
-                    VStack(alignment: .leading) {
-                        Text("Migrate here")
-                            .font(.largeTitle)
-                            .padding([.leading, .top, .trailing])
-                            .padding(.top)
-                        MigrateFromAnotherDevice()
-                    }
-                    .background(Color(uiColor: .tertiarySystemGroupedBackground))
-                }
-            }
         } else {
             actionButton("Make a private connection", onboarding: .onboardingComplete)
         }
@@ -129,21 +111,6 @@ struct OnboardingActionButton: View {
         .frame(maxWidth: .infinity)
         .padding(.bottom)
     }
-
-    private func actionButton(_ label: LocalizedStringKey, action: @escaping () -> Void) -> some View {
-        Button {
-            withAnimation {
-                action()
-            }
-        } label: {
-            HStack {
-                Text(label).font(.title2)
-                Image(systemName: "greaterthan")
-            }
-        }
-        .frame(maxWidth: .infinity)
-        .padding(.bottom)
-    }
 }
 
 struct SimpleXInfo_Previews: PreviewProvider {

apps/ios/Shared/Views/UserSettings/DeveloperView.swift

@@ -42,6 +42,25 @@ struct DeveloperView: View {
                 } footer: {
                     (developerTools ? Text("Show:") : Text("Hide:")) + Text(" ") + Text("Database IDs and Transport isolation option.")
                 }
+
+//                Section {
+//                    settingsRow("arrow.up.doc") {
+//                        Toggle("Send videos and files via XFTP", isOn: $xftpSendEnabled)
+//                            .onChange(of: xftpSendEnabled) { _ in
+//                                do {
+//                                    try setXFTPConfig(getXFTPCfg())
+//                                } catch {
+//                                    logger.error("setXFTPConfig: cannot set XFTP config \(responseError(error))")
+//                                }
+//                            }
+//                    }
+//                } header: {
+//                    Text("Experimental")
+//                } footer: {
+//                    if xftpSendEnabled {
+//                        Text("v4.6.1+ is required to receive via XFTP.")
+//                    }
+//                }
             }
         }
     }

apps/ios/Shared/Views/UserSettings/SettingsView.swift

@@ -163,57 +163,48 @@ struct SettingsView: View {
         NavigationView {
             List {
                 Section("You") {
-                    Group {
-                        if let user = user {
-                            NavigationLink {
-                                UserProfile()
-                                    .navigationTitle("Your current profile")
-                            } label: {
-                                ProfilePreview(profileOf: user)
-                                    .padding(.leading, -8)
-                            }
-                        }
-
+                    if let user = user {
                         NavigationLink {
-                            UserProfilesView(showSettings: $showSettings)
+                            UserProfile()
+                                .navigationTitle("Your current profile")
                         } label: {
-                            settingsRow("person.crop.rectangle.stack") { Text("Your chat profiles") }
-                        }
-
-
-                        if let user = user {
-                            NavigationLink {
-                                UserAddressView(shareViaProfile: user.addressShared)
-                                    .navigationTitle("SimpleX address")
-                                    .navigationBarTitleDisplayMode(.large)
-                            } label: {
-                                settingsRow("qrcode") { Text("Your SimpleX address") }
-                            }
-
-                            NavigationLink {
-                                PreferencesView(profile: user.profile, preferences: user.fullPreferences, currentPreferences: user.fullPreferences)
-                                    .navigationTitle("Your preferences")
-                            } label: {
-                                settingsRow("switch.2") { Text("Chat preferences") }
-                            }
-                        }
-
-                        NavigationLink {
-                            ConnectDesktopView(viaSettings: true)
-                        } label: {
-                            settingsRow("desktopcomputer") { Text("Use from desktop") }
+                            ProfilePreview(profileOf: user)
+                                .padding(.leading, -8)
                         }
                     }
-                    .disabled(chatModel.chatRunning != true)
 
                     NavigationLink {
-                        MigrateToAnotherDevice(showSettings: $showSettings)
-                            .navigationTitle("Migrate device")
-                            .navigationBarTitleDisplayMode(.large)
+                        UserProfilesView(showSettings: $showSettings)
                     } label: {
-                        settingsRow("tray.and.arrow.up") { Text("Migrate to another device") }
+                        settingsRow("person.crop.rectangle.stack") { Text("Your chat profiles") }
+                    }
+
+
+                    if let user = user {
+                        NavigationLink {
+                            UserAddressView(shareViaProfile: user.addressShared)
+                                .navigationTitle("SimpleX address")
+                                .navigationBarTitleDisplayMode(.large)
+                        } label: {
+                            settingsRow("qrcode") { Text("Your SimpleX address") }
+                        }
+
+                        NavigationLink {
+                            PreferencesView(profile: user.profile, preferences: user.fullPreferences, currentPreferences: user.fullPreferences)
+                                .navigationTitle("Your preferences")
+                        } label: {
+                            settingsRow("switch.2") { Text("Chat preferences") }
+                        }
+                    }
+
+                    NavigationLink {
+                        ConnectDesktopView(viaSettings: true)
+                    } label: {
+                        settingsRow("desktopcomputer") { Text("Use from desktop") }
                     }
                 }
+                .disabled(chatModel.chatRunning != true)
+                
                 Section("Settings") {
                     NavigationLink {
                         NotificationsView()

apps/ios/SimpleX NSE/NotificationService.swift

@@ -453,6 +453,7 @@ var receiverStarted = false
 let startLock = DispatchSemaphore(value: 1)
 let suspendLock = DispatchSemaphore(value: 1)
 var networkConfig: NetCfg = getNetCfg()
+let xftpConfig: XFTPFileConfig? = getXFTPCfg()
 
 // startChat uses semaphore startLock to ensure that only one didReceive thread can start chat controller
 // Subsequent calls to didReceive will be waiting on semaphore and won't start chat again, as it will be .active
@@ -498,6 +499,7 @@ func doStartChat() -> DBMigrationResult? {
             try setNetworkConfig(networkConfig)
             try apiSetTempFolder(tempFolder: getTempFilesDirectory().path)
             try apiSetFilesFolder(filesFolder: getAppFilesDirectory().path)
+            try setXFTPConfig(xftpConfig)
             try apiSetEncryptLocalFiles(privacyEncryptLocalFilesGroupDefault.get())
             // prevent suspension while starting chat
             suspendLock.wait()
@@ -640,9 +642,7 @@ func receivedMsgNtf(_ res: ChatResponse) async -> (String, NSENotification)? {
         cleanupDirectFile(aChatItem)
         return nil
     case let .sndFileRcvCancelled(_, aChatItem, _):
-        if let aChatItem = aChatItem {
-            cleanupDirectFile(aChatItem)
-        }
+        cleanupDirectFile(aChatItem)
         return nil
     case let .sndFileCompleteXFTP(_, aChatItem, _):
         cleanupFile(aChatItem)
@@ -733,6 +733,12 @@ func apiSetFilesFolder(filesFolder: String) throws {
     throw r
 }
 
+func setXFTPConfig(_ cfg: XFTPFileConfig?) throws {
+    let r = sendSimpleXCmd(.apiSetXFTPConfig(config: cfg))
+    if case .cmdOk = r { return }
+    throw r
+}
+
 func apiSetEncryptLocalFiles(_ enable: Bool) throws {
     let r = sendSimpleXCmd(.apiSetEncryptLocalFiles(enable: enable))
     if case .cmdOk = r { return }

apps/ios/SimpleX.xcodeproj/project.pbxproj

@@ -90,11 +90,11 @@
 		5CB0BA90282713D900B3292C /* SimpleXInfo.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB0BA8F282713D900B3292C /* SimpleXInfo.swift */; };
 		5CB0BA92282713FD00B3292C /* CreateProfile.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB0BA91282713FD00B3292C /* CreateProfile.swift */; };
 		5CB0BA9A2827FD8800B3292C /* HowItWorks.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB0BA992827FD8800B3292C /* HowItWorks.swift */; };
-		5CB1CE9C2B8771DB00963938 /* libffi.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE972B8771DB00963938 /* libffi.a */; };
-		5CB1CE9D2B8771DB00963938 /* libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE982B8771DB00963938 /* libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI.a */; };
-		5CB1CE9E2B8771DB00963938 /* libgmpxx.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE992B8771DB00963938 /* libgmpxx.a */; };
-		5CB1CE9F2B8771DB00963938 /* libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI-ghc9.6.3.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE9A2B8771DB00963938 /* libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI-ghc9.6.3.a */; };
-		5CB1CEA02B8771DB00963938 /* libgmp.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE9B2B8771DB00963938 /* libgmp.a */; };
+		5CB1CE882B8259EB00963938 /* libgmpxx.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE832B8259EB00963938 /* libgmpxx.a */; };
+		5CB1CE892B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE842B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a */; };
+		5CB1CE8A2B8259EB00963938 /* libffi.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE852B8259EB00963938 /* libffi.a */; };
+		5CB1CE8B2B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE862B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a */; };
+		5CB1CE8C2B8259EB00963938 /* libgmp.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE872B8259EB00963938 /* libgmp.a */; };
 		5CB2084F28DA4B4800D024EC /* RTCServers.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB2084E28DA4B4800D024EC /* RTCServers.swift */; };
 		5CB346E52868AA7F001FD2EF /* SuspendChat.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB346E42868AA7F001FD2EF /* SuspendChat.swift */; };
 		5CB346E72868D76D001FD2EF /* NotificationsView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB346E62868D76D001FD2EF /* NotificationsView.swift */; };
@@ -185,8 +185,6 @@
 		64E972072881BB22008DBC02 /* CIGroupInvitationView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 64E972062881BB22008DBC02 /* CIGroupInvitationView.swift */; };
 		64F1CC3B28B39D8600CD1FB1 /* IncognitoHelp.swift in Sources */ = {isa = PBXBuildFile; fileRef = 64F1CC3A28B39D8600CD1FB1 /* IncognitoHelp.swift */; };
 		8C05382E2B39887E006436DC /* VideoUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8C05382D2B39887E006436DC /* VideoUtils.swift */; };
-		8C7D949A2B88952700B7B9E1 /* MigrateFromAnotherDevice.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8C7D94992B88952700B7B9E1 /* MigrateFromAnotherDevice.swift */; };
-		8C7DF3202B7CDB0A00C886D0 /* MigrateToAnotherDevice.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8C7DF31F2B7CDB0A00C886D0 /* MigrateToAnotherDevice.swift */; };
 		D7197A1829AE89660055C05A /* WebRTC in Frameworks */ = {isa = PBXBuildFile; productRef = D7197A1729AE89660055C05A /* WebRTC */; };
 		D72A9088294BD7A70047C86D /* NativeTextEditor.swift in Sources */ = {isa = PBXBuildFile; fileRef = D72A9087294BD7A70047C86D /* NativeTextEditor.swift */; };
 		D741547829AF89AF0022400A /* StoreKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = D741547729AF89AF0022400A /* StoreKit.framework */; };
@@ -374,11 +372,11 @@
 		5CB0BA8F282713D900B3292C /* SimpleXInfo.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SimpleXInfo.swift; sourceTree = "<group>"; };
 		5CB0BA91282713FD00B3292C /* CreateProfile.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CreateProfile.swift; sourceTree = "<group>"; };
 		5CB0BA992827FD8800B3292C /* HowItWorks.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HowItWorks.swift; sourceTree = "<group>"; };
-		5CB1CE972B8771DB00963938 /* libffi.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libffi.a; sourceTree = "<group>"; };
-		5CB1CE982B8771DB00963938 /* libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI.a"; sourceTree = "<group>"; };
-		5CB1CE992B8771DB00963938 /* libgmpxx.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmpxx.a; sourceTree = "<group>"; };
-		5CB1CE9A2B8771DB00963938 /* libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI-ghc9.6.3.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI-ghc9.6.3.a"; sourceTree = "<group>"; };
-		5CB1CE9B2B8771DB00963938 /* libgmp.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmp.a; sourceTree = "<group>"; };
+		5CB1CE832B8259EB00963938 /* libgmpxx.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmpxx.a; sourceTree = "<group>"; };
+		5CB1CE842B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a"; sourceTree = "<group>"; };
+		5CB1CE852B8259EB00963938 /* libffi.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libffi.a; sourceTree = "<group>"; };
+		5CB1CE862B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a"; sourceTree = "<group>"; };
+		5CB1CE872B8259EB00963938 /* libgmp.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmp.a; sourceTree = "<group>"; };
 		5CB2084E28DA4B4800D024EC /* RTCServers.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RTCServers.swift; sourceTree = "<group>"; };
 		5CB2085428DE647400D024EC /* de */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = de; path = de.lproj/Localizable.strings; sourceTree = "<group>"; };
 		5CB346E42868AA7F001FD2EF /* SuspendChat.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SuspendChat.swift; sourceTree = "<group>"; };
@@ -475,8 +473,6 @@
 		64E972062881BB22008DBC02 /* CIGroupInvitationView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CIGroupInvitationView.swift; sourceTree = "<group>"; };
 		64F1CC3A28B39D8600CD1FB1 /* IncognitoHelp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = IncognitoHelp.swift; sourceTree = "<group>"; };
 		8C05382D2B39887E006436DC /* VideoUtils.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VideoUtils.swift; sourceTree = "<group>"; };
-		8C7D94992B88952700B7B9E1 /* MigrateFromAnotherDevice.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MigrateFromAnotherDevice.swift; sourceTree = "<group>"; };
-		8C7DF31F2B7CDB0A00C886D0 /* MigrateToAnotherDevice.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MigrateToAnotherDevice.swift; sourceTree = "<group>"; };
 		D72A9087294BD7A70047C86D /* NativeTextEditor.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NativeTextEditor.swift; sourceTree = "<group>"; };
 		D741547729AF89AF0022400A /* StoreKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = StoreKit.framework; path = Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS16.1.sdk/System/Library/Frameworks/StoreKit.framework; sourceTree = DEVELOPER_DIR; };
 		D741547929AF90B00022400A /* PushKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = PushKit.framework; path = Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS16.1.sdk/System/Library/Frameworks/PushKit.framework; sourceTree = DEVELOPER_DIR; };
@@ -518,13 +514,13 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				5CB1CE882B8259EB00963938 /* libgmpxx.a in Frameworks */,
+				5CB1CE8C2B8259EB00963938 /* libgmp.a in Frameworks */,
 				5CE2BA93284534B000EC33A6 /* libiconv.tbd in Frameworks */,
-				5CB1CEA02B8771DB00963938 /* libgmp.a in Frameworks */,
-				5CB1CE9E2B8771DB00963938 /* libgmpxx.a in Frameworks */,
-				5CB1CE9C2B8771DB00963938 /* libffi.a in Frameworks */,
 				5CE2BA94284534BB00EC33A6 /* libz.tbd in Frameworks */,
-				5CB1CE9D2B8771DB00963938 /* libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI.a in Frameworks */,
-				5CB1CE9F2B8771DB00963938 /* libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI-ghc9.6.3.a in Frameworks */,
+				5CB1CE8A2B8259EB00963938 /* libffi.a in Frameworks */,
+				5CB1CE892B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a in Frameworks */,
+				5CB1CE8B2B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -557,7 +553,6 @@
 				5CB924DD27A8622200ACCCDD /* NewChat */,
 				5CFA59C22860B04D00863A68 /* Database */,
 				5CB634AB29E46CDB0066AD6B /* LocalAuth */,
-				8C7D94982B8894D300B7B9E1 /* Migration */,
 				5CA8D01B2AD9B076001FD661 /* RemoteAccess */,
 				5CB924DF27A8678B00ACCCDD /* UserSettings */,
 				5C2E261127A30FEA00F70299 /* TerminalView.swift */,
@@ -587,11 +582,11 @@
 		5C764E5C279C70B7000C6508 /* Libraries */ = {
 			isa = PBXGroup;
 			children = (
-				5CB1CE972B8771DB00963938 /* libffi.a */,
-				5CB1CE9B2B8771DB00963938 /* libgmp.a */,
-				5CB1CE992B8771DB00963938 /* libgmpxx.a */,
-				5CB1CE9A2B8771DB00963938 /* libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI-ghc9.6.3.a */,
-				5CB1CE982B8771DB00963938 /* libHSsimplex-chat-5.5.5.0-4Xh8aGOq2uNGBj7gMJTaKI.a */,
+				5CB1CE852B8259EB00963938 /* libffi.a */,
+				5CB1CE872B8259EB00963938 /* libgmp.a */,
+				5CB1CE832B8259EB00963938 /* libgmpxx.a */,
+				5CB1CE862B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a */,
+				5CB1CE842B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a */,
 			);
 			path = Libraries;
 			sourceTree = "<group>";
@@ -898,15 +893,6 @@
 			path = Group;
 			sourceTree = "<group>";
 		};
-		8C7D94982B8894D300B7B9E1 /* Migration */ = {
-			isa = PBXGroup;
-			children = (
-				8C7DF31F2B7CDB0A00C886D0 /* MigrateToAnotherDevice.swift */,
-				8C7D94992B88952700B7B9E1 /* MigrateFromAnotherDevice.swift */,
-			);
-			path = Migration;
-			sourceTree = "<group>";
-		};
 /* End PBXGroup section */
 
 /* Begin PBXHeadersBuildPhase section */
@@ -1138,7 +1124,6 @@
 				5CBD285A295711D700EC2CF4 /* ImageUtils.swift in Sources */,
 				6419EC562AB8BC8B004A607A /* ContextInvitingContactMemberView.swift in Sources */,
 				5CE4407927ADB701007B033A /* EmojiItemView.swift in Sources */,
-				8C7D949A2B88952700B7B9E1 /* MigrateFromAnotherDevice.swift in Sources */,
 				5C3F1D562842B68D00EC8A82 /* IntegrityErrorItemView.swift in Sources */,
 				5C029EAA283942EA004A9677 /* CallController.swift in Sources */,
 				5CBE6C142944CC12002D9531 /* ScanCodeView.swift in Sources */,
@@ -1235,7 +1220,6 @@
 				5CB0BA92282713FD00B3292C /* CreateProfile.swift in Sources */,
 				5C5F2B7027EBC704006A9D5F /* ProfileImage.swift in Sources */,
 				5C9329412929248A0090FFF9 /* ScanProtocolServer.swift in Sources */,
-				8C7DF3202B7CDB0A00C886D0 /* MigrateToAnotherDevice.swift in Sources */,
 				64AA1C6C27F3537400AC7277 /* DeletedItemView.swift in Sources */,
 				5C93293F2928E0FD0090FFF9 /* AudioRecPlay.swift in Sources */,
 				5C029EA82837DBB3004A9677 /* CICallItemView.swift in Sources */,

apps/ios/SimpleXChat/API.swift

@@ -54,18 +54,6 @@ public func chatMigrateInit(_ useKey: String? = nil, confirmMigrations: Migratio
     return result
 }
 
-public func chatInitTemporaryDatabase(url: URL, key: String? = nil) -> (DBMigrationResult, chat_ctrl?) {
-    let dbPath = url.path
-    let dbKey = key ?? randomDatabasePassword()
-    logger.debug("chatInitTemporaryDatabase path: \(dbPath)")
-    var temporaryController: chat_ctrl? = nil
-    var cPath = dbPath.cString(using: .utf8)!
-    var cKey = dbKey.cString(using: .utf8)!
-    var cConfirm = MigrationConfirmation.error.rawValue.cString(using: .utf8)!
-    let cjson = chat_migrate_init_key(&cPath, &cKey, 1, &cConfirm, 0, &temporaryController)!
-    return (dbMigrationResult(fromCString(cjson)), temporaryController)
-}
-
 public func chatCloseStore() {
     let err = fromCString(chat_close_store(getChatCtrl()))
     if err != "" {
@@ -85,22 +73,17 @@ public func resetChatCtrl() {
     migrationResult = nil
 }
 
-public func applyChatCtrl(ctrl: chat_ctrl?, result: (Bool, DBMigrationResult)) {
-    chatController = ctrl
-    migrationResult = result
-}
-
-public func sendSimpleXCmd(_ cmd: ChatCommand, _ ctrl: chat_ctrl? = nil) -> ChatResponse {
+public func sendSimpleXCmd(_ cmd: ChatCommand) -> ChatResponse {
     var c = cmd.cmdString.cString(using: .utf8)!
-    let cjson  = chat_send_cmd(ctrl ?? getChatCtrl(), &c)!
+    let cjson  = chat_send_cmd(getChatCtrl(), &c)!
     return chatResponse(fromCString(cjson))
 }
 
 // in microseconds
 let MESSAGE_TIMEOUT: Int32 = 15_000_000
 
-public func recvSimpleXMsg(_ ctrl: chat_ctrl? = nil) -> ChatResponse? {
-    if let cjson = chat_recv_msg_wait(ctrl ?? getChatCtrl(), MESSAGE_TIMEOUT) {
+public func recvSimpleXMsg() -> ChatResponse? {
+    if let cjson = chat_recv_msg_wait(getChatCtrl(), MESSAGE_TIMEOUT) {
         let s = fromCString(cjson)
         return s == "" ? nil : chatResponse(s)
     }

apps/ios/SimpleXChat/APITypes.swift

@@ -31,12 +31,12 @@ public enum ChatCommand {
     case apiSuspendChat(timeoutMicroseconds: Int)
     case setTempFolder(tempFolder: String)
     case setFilesFolder(filesFolder: String)
+    case apiSetXFTPConfig(config: XFTPFileConfig?)
     case apiSetEncryptLocalFiles(enable: Bool)
     case apiExportArchive(config: ArchiveConfig)
     case apiImportArchive(config: ArchiveConfig)
     case apiDeleteStorage
     case apiStorageEncryption(config: DBEncryptionConfig)
-    case testStorageEncryption(key: String)
     case apiGetChats(userId: Int64)
     case apiGetChat(type: ChatType, id: Int64, pagination: ChatPagination, search: String)
     case apiGetChatItemInfo(type: ChatType, id: Int64, itemId: Int64)
@@ -131,8 +131,6 @@ public enum ChatCommand {
     case listRemoteCtrls
     case stopRemoteCtrl
     case deleteRemoteCtrl(remoteCtrlId: Int64)
-    case apiUploadStandaloneFile(userId: Int64, file: CryptoFile)
-    case apiDownloadStandaloneFile(userId: Int64, url: String, file: CryptoFile)
     // misc
     case showVersion
     case string(String)
@@ -164,12 +162,16 @@ public enum ChatCommand {
             case let .apiSuspendChat(timeoutMicroseconds): return "/_app suspend \(timeoutMicroseconds)"
             case let .setTempFolder(tempFolder): return "/_temp_folder \(tempFolder)"
             case let .setFilesFolder(filesFolder): return "/_files_folder \(filesFolder)"
+            case let .apiSetXFTPConfig(cfg): if let cfg = cfg {
+                return "/_xftp on \(encodeJSON(cfg))"
+            } else {
+                return "/_xftp off"
+            }
             case let .apiSetEncryptLocalFiles(enable): return "/_files_encrypt \(onOff(enable))"
             case let .apiExportArchive(cfg): return "/_db export \(encodeJSON(cfg))"
             case let .apiImportArchive(cfg): return "/_db import \(encodeJSON(cfg))"
             case .apiDeleteStorage: return "/_db delete"
             case let .apiStorageEncryption(cfg): return "/_db encryption \(encodeJSON(cfg))"
-            case let .testStorageEncryption(key): return "/db test key \(key)"
             case let .apiGetChats(userId): return "/_get chats \(userId) pcc=on"
             case let .apiGetChat(type, id, pagination, search): return "/_get chat \(ref(type, id)) \(pagination.cmdString)" +
                 (search == "" ? "" : " search=\(search)")
@@ -282,8 +284,6 @@ public enum ChatCommand {
             case .listRemoteCtrls: return "/list remote ctrls"
             case .stopRemoteCtrl: return "/stop remote ctrl"
             case let .deleteRemoteCtrl(rcId): return "/delete remote ctrl \(rcId)"
-            case let .apiUploadStandaloneFile(userId, file): return "/_upload \(userId) \(file.filePath)"
-            case let .apiDownloadStandaloneFile(userId, link, file): return "/_download \(userId) \(link) \(file.filePath)"
             case .showVersion: return "/version"
             case let .string(str): return str
             }
@@ -311,12 +311,12 @@ public enum ChatCommand {
             case .apiSuspendChat: return "apiSuspendChat"
             case .setTempFolder: return "setTempFolder"
             case .setFilesFolder: return "setFilesFolder"
+            case .apiSetXFTPConfig: return "apiSetXFTPConfig"
             case .apiSetEncryptLocalFiles: return "apiSetEncryptLocalFiles"
             case .apiExportArchive: return "apiExportArchive"
             case .apiImportArchive: return "apiImportArchive"
             case .apiDeleteStorage: return "apiDeleteStorage"
             case .apiStorageEncryption: return "apiStorageEncryption"
-            case .testStorageEncryption: return "testStorageEncryption"
             case .apiGetChats: return "apiGetChats"
             case .apiGetChat: return "apiGetChat"
             case .apiGetChatItemInfo: return "apiGetChatItemInfo"
@@ -409,8 +409,6 @@ public enum ChatCommand {
             case .listRemoteCtrls: return "listRemoteCtrls"
             case .stopRemoteCtrl: return "stopRemoteCtrl"
             case .deleteRemoteCtrl: return "deleteRemoteCtrl"
-            case .apiUploadStandaloneFile: return "apiUploadStandaloneFile"
-            case .apiDownloadStandaloneFile: return "apiDownloadStandaloneFile"
             case .showVersion: return "showVersion"
             case .string: return "console command"
             }
@@ -445,8 +443,6 @@ public enum ChatCommand {
             return .apiUnhideUser(userId: userId, viewPwd: obfuscate(viewPwd))
         case let .apiDeleteUser(userId, delSMPQueues, viewPwd):
             return .apiDeleteUser(userId: userId, delSMPQueues: delSMPQueues, viewPwd: obfuscate(viewPwd))
-        case let .testStorageEncryption(key):
-            return .testStorageEncryption(key: obfuscate(key))
         default: return self
         }
     }
@@ -595,27 +591,20 @@ public enum ChatResponse: Decodable, Error {
     // receiving file events
     case rcvFileAccepted(user: UserRef, chatItem: AChatItem)
     case rcvFileAcceptedSndCancelled(user: UserRef, rcvFileTransfer: RcvFileTransfer)
-    case rcvStandaloneFileCreated(user: UserRef, rcvFileTransfer: RcvFileTransfer)
-    case rcvFileStart(user: UserRef, chatItem: AChatItem) // send by chats
-    case rcvFileProgressXFTP(user: UserRef, chatItem_: AChatItem?, receivedSize: Int64, totalSize: Int64, rcvFileTransfer: RcvFileTransfer)
+    case rcvFileStart(user: UserRef, chatItem: AChatItem)
+    case rcvFileProgressXFTP(user: UserRef, chatItem: AChatItem, receivedSize: Int64, totalSize: Int64)
     case rcvFileComplete(user: UserRef, chatItem: AChatItem)
-    case rcvStandaloneFileComplete(user: UserRef, targetPath: String, rcvFileTransfer: RcvFileTransfer)
-    case rcvFileCancelled(user: UserRef, chatItem_: AChatItem?, rcvFileTransfer: RcvFileTransfer)
+    case rcvFileCancelled(user: UserRef, chatItem: AChatItem, rcvFileTransfer: RcvFileTransfer)
     case rcvFileSndCancelled(user: UserRef, chatItem: AChatItem, rcvFileTransfer: RcvFileTransfer)
-    case rcvFileError(user: UserRef, chatItem_: AChatItem?, rcvFileTransfer: RcvFileTransfer)
+    case rcvFileError(user: UserRef, chatItem: AChatItem)
     // sending file events
     case sndFileStart(user: UserRef, chatItem: AChatItem, sndFileTransfer: SndFileTransfer)
     case sndFileComplete(user: UserRef, chatItem: AChatItem, sndFileTransfer: SndFileTransfer)
-    case sndFileRcvCancelled(user: UserRef, chatItem_: AChatItem?, sndFileTransfer: SndFileTransfer)
-    case sndFileCancelled(user: UserRef, chatItem_: AChatItem?, fileTransferMeta: FileTransferMeta, sndFileTransfers: [SndFileTransfer])
-    case sndStandaloneFileCreated(user: UserRef, fileTransferMeta: FileTransferMeta) // returned by _upload
-    case sndFileStartXFTP(user: UserRef, chatItem: AChatItem, fileTransferMeta: FileTransferMeta) // not used
-    case sndFileProgressXFTP(user: UserRef, chatItem_: AChatItem?, fileTransferMeta: FileTransferMeta, sentSize: Int64, totalSize: Int64)
-    case sndFileRedirectStartXFTP(user: UserRef, fileTransferMeta: FileTransferMeta, redirectMeta: FileTransferMeta)
+    case sndFileCancelled(user: UserRef, chatItem: AChatItem, fileTransferMeta: FileTransferMeta, sndFileTransfers: [SndFileTransfer])
+    case sndFileRcvCancelled(user: UserRef, chatItem: AChatItem, sndFileTransfer: SndFileTransfer)
+    case sndFileProgressXFTP(user: UserRef, chatItem: AChatItem, fileTransferMeta: FileTransferMeta, sentSize: Int64, totalSize: Int64)
     case sndFileCompleteXFTP(user: UserRef, chatItem: AChatItem, fileTransferMeta: FileTransferMeta)
-    case sndStandaloneFileComplete(user: UserRef, fileTransferMeta: FileTransferMeta, rcvURIs: [String])
-    case sndFileCancelledXFTP(user: UserRef, chatItem_: AChatItem?, fileTransferMeta: FileTransferMeta)
-    case sndFileError(user: UserRef, chatItem_: AChatItem?, fileTransferMeta: FileTransferMeta)
+    case sndFileError(user: UserRef, chatItem: AChatItem)
     // call events
     case callInvitation(callInvitation: RcvCallInvitation)
     case callOffer(user: UserRef, contact: Contact, callType: CallType, offer: WebRTCSession, sharedKey: String?, askConfirmation: Bool)
@@ -753,25 +742,18 @@ public enum ChatResponse: Decodable, Error {
             case .newMemberContactReceivedInv: return "newMemberContactReceivedInv"
             case .rcvFileAccepted: return "rcvFileAccepted"
             case .rcvFileAcceptedSndCancelled: return "rcvFileAcceptedSndCancelled"
-            case .rcvStandaloneFileCreated: return "rcvStandaloneFileCreated"
             case .rcvFileStart: return "rcvFileStart"
             case .rcvFileProgressXFTP: return "rcvFileProgressXFTP"
             case .rcvFileComplete: return "rcvFileComplete"
-            case .rcvStandaloneFileComplete: return "rcvStandaloneFileComplete"
             case .rcvFileCancelled: return "rcvFileCancelled"
             case .rcvFileSndCancelled: return "rcvFileSndCancelled"
             case .rcvFileError: return "rcvFileError"
             case .sndFileStart: return "sndFileStart"
             case .sndFileComplete: return "sndFileComplete"
             case .sndFileCancelled: return "sndFileCancelled"
-            case .sndStandaloneFileCreated: return "sndStandaloneFileCreated"
-            case .sndFileStartXFTP: return "sndFileStartXFTP"
-            case .sndFileProgressXFTP: return "sndFileProgressXFTP"
-            case .sndFileRedirectStartXFTP: return "sndFileRedirectStartXFTP"
             case .sndFileRcvCancelled: return "sndFileRcvCancelled"
+            case .sndFileProgressXFTP: return "sndFileProgressXFTP"
             case .sndFileCompleteXFTP: return "sndFileCompleteXFTP"
-            case .sndStandaloneFileComplete: return "sndStandaloneFileComplete"
-            case .sndFileCancelledXFTP: return "sndFileCancelledXFTP"
             case .sndFileError: return "sndFileError"
             case .callInvitation: return "callInvitation"
             case .callOffer: return "callOffer"
@@ -910,26 +892,19 @@ public enum ChatResponse: Decodable, Error {
             case let .newMemberContactReceivedInv(u, contact, groupInfo, member): return withUser(u, "contact: \(contact)\ngroupInfo: \(groupInfo)\nmember: \(member)")
             case let .rcvFileAccepted(u, chatItem): return withUser(u, String(describing: chatItem))
             case .rcvFileAcceptedSndCancelled: return noDetails
-            case .rcvStandaloneFileCreated: return noDetails
             case let .rcvFileStart(u, chatItem): return withUser(u, String(describing: chatItem))
-            case let .rcvFileProgressXFTP(u, chatItem, receivedSize, totalSize, _): return withUser(u, "chatItem: \(String(describing: chatItem))\nreceivedSize: \(receivedSize)\ntotalSize: \(totalSize)")
-            case let .rcvStandaloneFileComplete(u, targetPath, _): return withUser(u, targetPath)
+            case let .rcvFileProgressXFTP(u, chatItem, receivedSize, totalSize): return withUser(u, "chatItem: \(String(describing: chatItem))\nreceivedSize: \(receivedSize)\ntotalSize: \(totalSize)")
             case let .rcvFileComplete(u, chatItem): return withUser(u, String(describing: chatItem))
             case let .rcvFileCancelled(u, chatItem, _): return withUser(u, String(describing: chatItem))
             case let .rcvFileSndCancelled(u, chatItem, _): return withUser(u, String(describing: chatItem))
-            case let .rcvFileError(u, chatItem, _): return withUser(u, String(describing: chatItem))
+            case let .rcvFileError(u, chatItem): return withUser(u, String(describing: chatItem))
             case let .sndFileStart(u, chatItem, _): return withUser(u, String(describing: chatItem))
             case let .sndFileComplete(u, chatItem, _): return withUser(u, String(describing: chatItem))
             case let .sndFileCancelled(u, chatItem, _, _): return withUser(u, String(describing: chatItem))
-            case .sndStandaloneFileCreated: return noDetails
-            case let .sndFileStartXFTP(u, chatItem, _): return withUser(u, String(describing: chatItem))
             case let .sndFileRcvCancelled(u, chatItem, _): return withUser(u, String(describing: chatItem))
             case let .sndFileProgressXFTP(u, chatItem, _, sentSize, totalSize): return withUser(u, "chatItem: \(String(describing: chatItem))\nsentSize: \(sentSize)\ntotalSize: \(totalSize)")
-            case let .sndFileRedirectStartXFTP(u, _, redirectMeta): return withUser(u, String(describing: redirectMeta))
             case let .sndFileCompleteXFTP(u, chatItem, _): return withUser(u, String(describing: chatItem))
-            case let .sndStandaloneFileComplete(u, _, rcvURIs): return withUser(u, String(rcvURIs.count))
-            case let .sndFileCancelledXFTP(u, chatItem, _): return withUser(u, String(describing: chatItem))
-            case let .sndFileError(u, chatItem, _): return withUser(u, String(describing: chatItem))
+            case let .sndFileError(u, chatItem): return withUser(u, String(describing: chatItem))
             case let .callInvitation(inv): return String(describing: inv)
             case let .callOffer(u, contact, callType, offer, sharedKey, askConfirmation): return withUser(u, "contact: \(contact.id)\ncallType: \(String(describing: callType))\nsharedKey: \(sharedKey ?? "")\naskConfirmation: \(askConfirmation)\noffer: \(String(describing: offer))")
             case let .callAnswer(u, contact, answer): return withUser(u, "contact: \(contact.id)\nanswer: \(String(describing: answer))")
@@ -1030,6 +1005,10 @@ struct ComposedMessage: Encodable {
     var msgContent: MsgContent
 }
 
+public struct XFTPFileConfig: Encodable {
+    var minFileSize: Int64
+}
+
 public struct ArchiveConfig: Encodable {
     var archivePath: String
     var disableCompression: Bool?
@@ -1753,7 +1732,6 @@ public enum StoreError: Decodable {
     case fileIdNotFoundBySharedMsgId(sharedMsgId: String)
     case sndFileNotFoundXFTP(agentSndFileId: String)
     case rcvFileNotFoundXFTP(agentRcvFileId: String)
-    case extraFileDescrNotFoundXFTP(fileId: Int64)
     case connectionNotFound(agentConnId: String)
     case connectionNotFoundById(connId: Int64)
     case connectionNotFoundByMemberId(groupMemberId: Int64)

apps/ios/SimpleXChat/AppGroup.swift

@@ -36,7 +36,7 @@ let GROUP_DEFAULT_NETWORK_TCP_KEEP_INTVL = "networkTCPKeepIntvl"
 let GROUP_DEFAULT_NETWORK_TCP_KEEP_CNT = "networkTCPKeepCnt"
 public let GROUP_DEFAULT_INCOGNITO = "incognito"
 let GROUP_DEFAULT_STORE_DB_PASSPHRASE = "storeDBPassphrase"
-public let GROUP_DEFAULT_INITIAL_RANDOM_DB_PASSPHRASE = "initialRandomDBPassphrase"
+let GROUP_DEFAULT_INITIAL_RANDOM_DB_PASSPHRASE = "initialRandomDBPassphrase"
 public let GROUP_DEFAULT_CONFIRM_DB_UPGRADES = "confirmDBUpgrades"
 public let GROUP_DEFAULT_CALL_KIT_ENABLED = "callKitEnabled"
 
@@ -265,6 +265,10 @@ public class Default<T> {
     }
 }
 
+public func getXFTPCfg() -> XFTPFileConfig {
+    return XFTPFileConfig(minFileSize: 0)
+}
+
 public func getNetCfg() -> NetCfg {
     let onionHosts = networkUseOnionHostsGroupDefault.get()
     let (hostMode, requiredHostMode) = onionHosts.hostMode

apps/ios/SimpleXChat/ChatTypes.swift

@@ -2268,7 +2268,7 @@ public struct ChatItem: Identifiable, Decodable {
         case .rcvDirectEvent(rcvDirectEvent: let rcvDirectEvent):
             switch rcvDirectEvent {
             case .contactDeleted: return false
-            case .profileUpdated: return false
+            case .profileUpdated: return true
             }
         case .rcvGroupEvent(rcvGroupEvent: let rcvGroupEvent):
             switch rcvGroupEvent {
@@ -3378,14 +3378,11 @@ public struct SndFileTransfer: Decodable {
 }
 
 public struct RcvFileTransfer: Decodable {
-    public let fileId: Int64
+
 }
 
 public struct FileTransferMeta: Decodable {
-    public let fileId: Int64
-    public let fileName: String
-    public let filePath: String
-    public let fileSize: Int64
+    
 }
 
 public enum CICallStatus: String, Decodable {

apps/ios/SimpleXChat/FileUtils.swift

@@ -83,7 +83,6 @@ public func deleteAppDatabaseAndFiles() {
     try? fm.removeItem(atPath: dbPath + CHAT_DB_BAK)
     try? fm.removeItem(atPath: dbPath + AGENT_DB_BAK)
     try? fm.removeItem(at: getTempFilesDirectory())
-    try? fm.removeItem(at: getMigrationTempFilesDirectory())
     try? fm.createDirectory(at: getTempFilesDirectory(), withIntermediateDirectories: true)
     deleteAppFiles()
     _ = kcDatabasePassword.remove()
@@ -184,10 +183,6 @@ public func getTempFilesDirectory() -> URL {
     getAppDirectory().appendingPathComponent("temp_files", isDirectory: true)
 }
 
-public func getMigrationTempFilesDirectory() -> URL {
-    getDocumentsDirectory().appendingPathComponent("migration_temp_files", isDirectory: true)
-}
-
 public func getAppFilesDirectory() -> URL {
     getAppDirectory().appendingPathComponent("app_files", isDirectory: true)
 }

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/ChatModel.kt

@@ -1822,7 +1822,7 @@ data class ChatItem (
       is CIContent.SndGroupInvitation -> false
       is CIContent.RcvDirectEventContent -> when (content.rcvDirectEvent) {
         is RcvDirectEvent.ContactDeleted -> false
-        is RcvDirectEvent.ProfileUpdated -> false
+        is RcvDirectEvent.ProfileUpdated -> true
       }
       is CIContent.RcvGroupEventContent -> when (content.rcvGroupEvent) {
         is RcvGroupEvent.MemberAdded -> false

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/SimpleXAPI.kt

@@ -631,6 +631,12 @@ object ChatController {
     throw Error("failed to set remote hosts folder: ${r.responseType} ${r.details}")
   }
 
+  suspend fun apiSetXFTPConfig(cfg: XFTPFileConfig?) {
+    val r = sendCmd(null, CC.ApiSetXFTPConfig(cfg))
+    if (r is CR.CmdOk) return
+    throw Error("apiSetXFTPConfig bad response: ${r.responseType} ${r.details}")
+  }
+
   suspend fun apiSetEncryptLocalFiles(enable: Boolean) = sendCommandOkResp(null, CC.ApiSetEncryptLocalFiles(enable))
 
   suspend fun apiExportArchive(config: ArchiveConfig) {
@@ -2165,6 +2171,10 @@ object ChatController {
     }
   }
 
+  fun getXFTPCfg(): XFTPFileConfig {
+    return XFTPFileConfig(minFileSize = 0)
+  }
+
   fun getNetCfg(): NetCfg {
     val useSocksProxy = appPrefs.networkUseSocksProxy.get()
     val proxyHostPort  = appPrefs.networkProxyHostPort.get()
@@ -2273,6 +2283,7 @@ sealed class CC {
   class SetTempFolder(val tempFolder: String): CC()
   class SetFilesFolder(val filesFolder: String): CC()
   class SetRemoteHostsFolder(val remoteHostsFolder: String): CC()
+  class ApiSetXFTPConfig(val config: XFTPFileConfig?): CC()
   class ApiSetEncryptLocalFiles(val enable: Boolean): CC()
   class ApiExportArchive(val config: ArchiveConfig): CC()
   class ApiImportArchive(val config: ArchiveConfig): CC()
@@ -2402,6 +2413,7 @@ sealed class CC {
     is SetTempFolder -> "/_temp_folder $tempFolder"
     is SetFilesFolder -> "/_files_folder $filesFolder"
     is SetRemoteHostsFolder -> "/remote_hosts_folder $remoteHostsFolder"
+    is ApiSetXFTPConfig -> if (config != null) "/_xftp on ${json.encodeToString(config)}" else "/_xftp off"
     is ApiSetEncryptLocalFiles -> "/_files_encrypt ${onOff(enable)}"
     is ApiExportArchive -> "/_db export ${json.encodeToString(config)}"
     is ApiImportArchive -> "/_db import ${json.encodeToString(config)}"
@@ -2536,6 +2548,7 @@ sealed class CC {
     is SetTempFolder -> "setTempFolder"
     is SetFilesFolder -> "setFilesFolder"
     is SetRemoteHostsFolder -> "setRemoteHostsFolder"
+    is ApiSetXFTPConfig -> "apiSetXFTPConfig"
     is ApiSetEncryptLocalFiles -> "apiSetEncryptLocalFiles"
     is ApiExportArchive -> "apiExportArchive"
     is ApiImportArchive -> "apiImportArchive"
@@ -2701,6 +2714,9 @@ sealed class ChatPagination {
 @Serializable
 class ComposedMessage(val fileSource: CryptoFile?, val quotedItemId: Long?, val msgContent: MsgContent)
 
+@Serializable
+class XFTPFileConfig(val minFileSize: Long)
+
 @Serializable
 class ArchiveConfig(val archivePath: String, val disableCompression: Boolean? = null, val parentTempDirectory: String? = null)
 

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/platform/Core.kt

@@ -91,6 +91,7 @@ suspend fun initChatController(useKey: String? = null, confirmMigrations: Migrat
     if (appPlatform.isDesktop) {
       controller.apiSetRemoteHostsFolder(remoteHostsDir.absolutePath)
     }
+    controller.apiSetXFTPConfig(controller.getXFTPCfg())
     controller.apiSetEncryptLocalFiles(controller.appPrefs.privacyEncryptLocalFiles.get())
     // If we migrated successfully means previous re-encryption process on database level finished successfully too
     if (appPreferences.encryptionStartedAt.get() != null) appPreferences.encryptionStartedAt.set(null)

apps/multiplatform/gradle.properties

@@ -25,11 +25,11 @@ android.nonTransitiveRClass=true
 android.enableJetifier=true
 kotlin.mpp.androidSourceSetLayoutVersion=2
 
-android.version_name=5.5.5
-android.version_code=185
+android.version_name=5.5.4
+android.version_code=183
 
-desktop.version_name=5.5.5
-desktop.version_code=31
+desktop.version_name=5.5.4
+desktop.version_code=30
 
 kotlin.version=1.8.20
 gradle.plugin.version=7.4.2

cabal.project

@@ -12,7 +12,7 @@ constraints: zip +disable-bzip2 +disable-zstd
 source-repository-package
     type: git
     location: https://github.com/simplex-chat/simplexmq.git
-    tag: 0d843ea4ce1b26a25b55756bf86d1007629896c5
+    tag: e6c444f5d1e94f057ac776b8c6c6c8663236831f
 
 source-repository-package
     type: git

docs/SERVER.md

@@ -24,7 +24,7 @@ _Please note_: when you change the servers in the app configuration, it only aff
    - Semi-automatic deployment:
      - [Offical installation script](https://github.com/simplex-chat/simplexmq#using-installation-script)
      - [Docker container](https://github.com/simplex-chat/simplexmq#using-docker)
-     - [Linode Marketplace](https://www.linode.com/marketplace/apps/simplex-chat/simplex-chat/)
+     - [Linode StackScript](https://github.com/simplex-chat/simplexmq#deploy-smp-server-on-linode)
 
 Manual installation requires some preliminary actions:
 
@@ -33,7 +33,7 @@ Manual installation requires some preliminary actions:
    - Using offical binaries:
 
      ```sh
-     curl -L https://github.com/simplex-chat/simplexmq/releases/latest/download/smp-server-ubuntu-20_04-x86-64 -o /usr/local/bin/smp-server && chmod +x /usr/local/bin/smp-server
+     curl -L https://github.com/simplex-chat/simplexmq/releases/latest/download/smp-server-ubuntu-20_04-x86-64 -o /usr/local/bin/smp-server
      ```
 
    - Compiling from source:
@@ -417,63 +417,6 @@ To import `csv` to `Grafana` one should:
 
 For further documentation, see: [CSV Data Source for Grafana - Documentation](https://grafana.github.io/grafana-csv-datasource/)
 
-# Updating your SMP server
-
-To update your smp-server to latest version, choose your installation method and follow the steps:
-
-   - Manual deployment
-     1. Stop the server:
-        ```sh
-        sudo systemctl stop smp-server
-        ```
-     2. Update the binary:
-        ```sh
-         curl -L https://github.com/simplex-chat/simplexmq/releases/latest/download/smp-server-ubuntu-20_04-x86-64 -o /usr/local/bin/smp-server && chmod +x /usr/local/bin/smp-server
-        ```
-     3. Start the server:
-        ```sh
-        sudo systemctl start smp-server
-        ```
-
-   - [Offical installation script](https://github.com/simplex-chat/simplexmq#using-installation-script)
-     1. Execute the followin command:
-        ```sh
-        sudo simplex-servers-update
-        ```
-     2. Done!
-
-   - [Docker container](https://github.com/simplex-chat/simplexmq#using-docker)
-     1. Stop and remove the container:
-        ```sh
-        docker rm $(docker stop $(docker ps -a -q --filter ancestor=simplexchat/smp-server --format="{{.ID}}"))
-        ```
-     2. Pull latest image:
-        ```sh
-        docker pull simplexchat/smp-server:latest
-        ```
-     3. Start new container:
-        ```sh
-        docker run -d \
-          -p 5223:5223 \
-          -v $HOME/simplex/smp/config:/etc/opt/simplex:z \
-          -v $HOME/simplex/smp/logs:/var/opt/simplex:z \
-          simplexchat/smp-server:latest
-        ```
-
-   - [Linode Marketplace](https://www.linode.com/marketplace/apps/simplex-chat/simplex-chat/)
-     1. Pull latest images:
-        ```sh
-        docker-compose --project-directory /etc/docker/compose/simplex pull
-        ```
-     2. Restart the containers:
-        ```sh
-        docker-compose --project-directory /etc/docker/compose/simplex up -d --remove-orphans
-        ```
-     3. Remove obsolete images:
-        ```sh
-        docker image prune
-        ```
-
 ### Configuring the app to use the server
 
 To configure the app to use your messaging server copy it's full address, including password, and add it to the app. You have an option to use your server together with preset servers or without them - you can remove or disable them.

docs/XFTP-SERVER.md

@@ -24,7 +24,6 @@ XFTP is a new file transfer protocol focussed on meta-data protection - it is ba
    - Semi-automatic deployment:
      - [Offical installation script](https://github.com/simplex-chat/simplexmq#using-installation-script)
      - [Docker container](https://github.com/simplex-chat/simplexmq#using-docker)
-     - [Linode Marketplace](https://www.linode.com/marketplace/apps/simplex-chat/simplex-chat/)
 
 Manual installation requires some preliminary actions:
 
@@ -33,7 +32,7 @@ Manual installation requires some preliminary actions:
    - Using offical binaries:
 
      ```sh
-     curl -L https://github.com/simplex-chat/simplexmq/releases/latest/download/xftp-server-ubuntu-20_04-x86-64 -o /usr/local/bin/xftp-server && chmod +x /usr/local/bin/xftp-server
+     curl -L https://github.com/simplex-chat/simplexmq/releases/latest/download/xftp-server-ubuntu-20_04-x86-64 -o /usr/local/bin/xftp-server
      ```
 
    - Compiling from source:
@@ -419,65 +418,6 @@ To import `csv` to `Grafana` one should:
 
 For further documentation, see: [CSV Data Source for Grafana - Documentation](https://grafana.github.io/grafana-csv-datasource/)
 
-
-# Updating your XFTP server
-
-To update your XFTP server to latest version, choose your installation method and follow the steps:
-
-   - Manual deployment
-     1. Stop the server:
-        ```sh
-        sudo systemctl stop xftp-server
-        ```
-     2. Update the binary:
-        ```sh
-         curl -L https://github.com/simplex-chat/simplexmq/releases/latest/download/xftp-server-ubuntu-20_04-x86-64 -o /usr/local/bin/xftp-server && chmod +x /usr/local/bin/xftp-server
-        ```
-     3. Start the server:
-        ```sh
-        sudo systemctl start xftp-server
-        ```
-
-   - [Offical installation script](https://github.com/simplex-chat/simplexmq#using-installation-script)
-     1. Execute the followin command:
-        ```sh
-        sudo simplex-servers-update
-        ```
-     2. Done!
-
-   - [Docker container](https://github.com/simplex-chat/simplexmq#using-docker)
-     1. Stop and remove the container:
-        ```sh
-        docker rm $(docker stop $(docker ps -a -q --filter ancestor=simplexchat/xftp-server --format="{{.ID}}"))
-        ```
-     2. Pull latest image:
-        ```sh
-        docker pull simplexchat/xftp-server:latest
-        ```
-     3. Start new container:
-        ```sh
-        docker run -d \
-          -p 443:443 \
-          -v $HOME/simplex/xftp/config:/etc/opt/simplex-xftp:z \
-          -v $HOME/simplex/xftp/logs:/var/opt/simplex-xftp:z \
-          -v $HOME/simplex/xftp/files:/srv/xftp:z \
-          simplexchat/xftp-server:latest
-        ```
-
-   - [Linode Marketplace](https://www.linode.com/marketplace/apps/simplex-chat/simplex-chat/)
-     1. Pull latest images:
-        ```sh
-        docker-compose --project-directory /etc/docker/compose/simplex pull
-        ```
-     2. Restart the containers:
-        ```sh
-        docker-compose --project-directory /etc/docker/compose/simplex up -d --remove-orphans
-        ```
-     3. Remove obsolete images:
-        ```sh
-        docker image prune
-        ```
-
 ### Configuring the app to use the server
 
 Please see: [SMP Server: Configuring the app to use the server](./SERVER.md#configuring-the-app-to-use-the-server).

docs/rfcs/2023-09-30-pq-double-ratchet.md

@@ -82,7 +82,7 @@ def RatchetInitAlicePQ2HE(state, SK, bob_dh_public_key, shared_hka, shared_nhkb,
     state.PQRs = GENERATE_PQKEM()
     state.PQRr = bob_pq_kem_encapsulation_key
     state.PQRss = random // shared secret for KEM
-    state.PQRct = PQKEM-ENC(state.PQRr, state.PQRss) // encapsulated additional shared secret
+    state.PQRenc_ss = PQKEM-ENC(state.PQRr.encaps, state.PQRss) // encapsulated additional shared secret
     // above added for KEM
     // below augments DH key agreement with PQ shared secret
     state.RK, state.CKs, state.NHKs = KDF_RK_HE(SK, DH(state.DHRs, state.DHRr) || state.PQRss) 
@@ -103,7 +103,7 @@ def RatchetInitBobPQ2HE(state, SK, bob_dh_key_pair, shared_hka, shared_nhkb, bob
     state.PQRs = bob_pq_kem_key_pair
     state.PQRr = None
     state.PQRss = None
-    state.PQRct = None
+    state.PQRenc_ss = None
     // above added for KEM
     state.RK = SK 
     state.CKs = None
@@ -132,10 +132,10 @@ def RatchetEncryptPQ2HE(state, plaintext, AD):
     // encapsulation key from PQRs and encapsulated shared secret is added to header
     header = HEADER_PQ2(
       dh = state.DHRs.public,
-      kem = state.PQRs.public, // added for KEM #2
-      ct = state.PQRct // added for KEM #1
       pn = state.PN,
       n = state.Ns,
+      encaps = state.PQRs.encaps, // added for KEM #1
+      enc_ss = state.PQRenc_ss // added for KEM #2
     )
     enc_header = HENCRYPT(state.HKs, header)
     state.Ns += 1
@@ -162,16 +162,6 @@ def RatchetDecryptPQ2HE(state, enc_header, ciphertext, AD):
     state.Nr += 1
     return DECRYPT(mk, ciphertext, CONCAT(AD, enc_header))
 
-// DecryptHeader is the same as in double ratchet specification
-def DecryptHeader(state, enc_header):
-    header = HDECRYPT(state.HKr, enc_header)
-    if header != None:
-        return header, False
-    header = HDECRYPT(state.NHKr, enc_header)
-    if header != None:
-        return header, True
-    raise Error()
-
 def DHRatchetPQ2HE(state, header):
     state.PN = state.Ns
     state.Ns = 0
@@ -180,16 +170,16 @@ def DHRatchetPQ2HE(state, header):
     state.HKr = state.NHKr
     state.DHRr = header.dh
     // save new encapsulation key from header
-    state.PQRr = header.kem
+    state.PQRr = header.encaps
     // decapsulate shared secret from header - KEM #2
-    ss = PQKEM-DEC(state.PQRs.private, header.ct)
+    ss = PQKEM-DEC(state.PQRs.decaps, header.enc_ss)
     // use decapsulated shared secret with receiving ratchet
     state.RK, state.CKr, state.NHKr = KDF_RK_HE(state.RK, DH(state.DHRs, state.DHRr) || ss)
     state.DHRs = GENERATE_DH()
     // below is added for KEM
     state.PQRs = GENERATE_PQKEM() // generate new PQ key pair
     state.PQRss = random // shared secret for KEM
-    state.PQRct = PQKEM-ENC(state.PQRr, state.PQRss) // encapsulated additional shared secret KEM #1
+    state.PQRenc_ss = PQKEM-ENC(state.PQRr.encaps, state.PQRss) // encapsulated additional shared secret KEM #1
     // above is added for KEM
     // use new shared secret with sending ratchet
     state.RK, state.CKs, state.NHKs = KDF_RK_HE(state.RK, DH(state.DHRs, state.DHRr) || state.PQRss)
@@ -211,7 +201,7 @@ The main downside is the absense of performance-efficient implementation for aar
 
 ## Implementation considerations for SimpleX Chat
 
-As SimpleX Chat pads messages to a fixed size, using 16kb transport blocks, the size increase introduced by this scheme will not cause additional traffic in most cases. For large texts it may require additional messages to be sent. Similarly, for media previews it may require either reducing the preview size (and quality), or sending additional messages, or compressing the current JSON encoding, e.g. with zstd algorithm.
+As SimpleX Chat pads messages to a fixed size, using 16kb transport blocks, the size increase introduced by this scheme will not cause additional traffic in most cases. For large texts it may require additional messages to be sent. Similarly, for media previews it may require either reducing the preview size (and quality) or sending additional messages.
 
 That might be the primary reason why this scheme was not adopted by Signal, as it would have resulted in substantial traffic growth – to the best of our knowledge, Signal messages are not padded to a fixed size.
 
@@ -219,8 +209,6 @@ Sharing the initial keys in case of SimpleX Chat it is equivalent to sharing the
 
 It is possible to postpone sharing the encapsulation key until the first message from Alice (confirmation message in SMP protocol), the party sending connection request. The upside here is that the invitation link size would not increase. The downside is that the user profile shared in this confirmation will not be encrypted with PQ-resistant algorithm. To mitigate it, the hadnshake protocol can be modified to postpone sending the user profile until the second message from Alice (HELLO message in SMP protocol).
 
-Another consideration is pairwise ratchets in groups. Key generation in sntrup761 is quite slow - on slow devices it can probably be as slow as 10 keys per second, so using this primitive in groups larger than 10 members would result in slow performance. An option could be not to use ratchets in groups at all, but that would result in the lack of protection in small groups that simply combine multiple devices of 1-3 people. So a better option would be to support dynamically adding and removing sntrup761 keys for pairwise ratchets in groups, which means that when sending each message a boolean flag needs to be passed whether to use PQ KEM or not.
-
 ## Summary
 
 If chosen PQ KEM proves secure against quantum computer attacks, then the proposed augmented double ratchet will also be secure against quantum computer attack, including break-in recovery property, while keeping deniability and forward secrecy, because the [same proof](https://eprint.iacr.org/2016/1013.pdf) as for double ratchet algorithm would hold here, provided KEM is secure.

docs/rfcs/2024-02-19-settings.md

@@ -1,60 +0,0 @@
-# Migrating app settings to another device
-
-## Problem
-
-This is related to simplified database migration UX in the [previous RFC](./2024-02-12-database-migration.md).
-
-Currently, when database is imported after the onboarding is complete, users can configure the app prior to the import.
-
-Some of the settings are particularly important for privacy and security:
-- SOCKS proxy settings
-- Automatic image etc. downloads
-- Link previews
-
-With the new UX, the chat will start automatically, without giving users a chance to configure the app. That means that we have to migrate settings to a new device as well, as part of the archive.
-
-## Solution
-
-There are several possible approaches:
-- put settings to the database via the API
-- save settings as some file with cross-platform format (e.g. JSON or YAML or properties used on desktop).
-
-The second approach seems much simpler than maintaining the settings in the database.
-
-If we save a file, then there are two options:
-- native apps maintain cross-platform schemas for this file, support any JSON and parse it in a safe way (so that even invalid or incorrect JSON - e.g., array instead of object - or invalid types in some properties do not cause the failure of properties that are correct).
-- this schema and type will be maintained in the core library, that will be responsible for storing and reading the settings and passing to native UI as correct record of a given type.
-
-The downside of the second approach is that addition of any property that needs to be migrated will have to be done on any change in either of the platforms. The downside of the first approach is that neither app platform will be self-sufficient any more, and not only iOS/Android would have to take into account code, but also each other code.
-
-If we go with the second approach, there will be these types:
-
-```haskell
-data AppSettings = AppSettings
-  { networkConfig :: NetworkConfig, -- existing type in Haskell and all UIs
-    privacyConfig :: PrivacyConfig -- new type, etc.
-    -- ... additional properties after the initial release should be added as Maybe, as all extensions
-  }
-
-data ArchiveConfig = ArchiveConfig
-  { -- existing properties
-    archivePath :: FilePath,
-    disableCompression :: Maybe Bool,
-    parentTempDirectory :: Maybe FilePath,
-    -- new property
-    appSettings :: AppSettings
-    -- for export, these settings will contain the settings passed from the UI and will be saved to JSON file as simplex_v1_settings.json in the archive
-    -- for import, these settings will contain the defaults that will be used if some property or subproperty is missing in JSON
-  }
-
--- importArchive :: ChatMonad m => ArchiveConfig -> m [ArchiveError] -- current type
-importArchive :: ChatMonad m => ArchiveConfig -> m ArchiveImportResult -- new type
-
--- | CRArchiveImported {archiveErrors :: [ArchiveError]} -- current type
-  | CRArchiveImported {importResult :: ArchiveImportResult} -- new type
-
-data ArchiveImportResult = ArchiveImportResult
-  { archiveErrors :: [ArchiveError],
-    appSettings :: Maybe AppSettings
-  }
-```

package.yaml

@@ -1,5 +1,5 @@
 name: simplex-chat
-version: 5.5.5.0
+version: 5.5.3.0
 #synopsis:
 #description:
 homepage: https://github.com/simplex-chat/simplex-chat#readme

packages/simplex-chat-client/typescript/src/command.ts

@@ -12,6 +12,7 @@ export type ChatCommand =
   | APIStopChat
   | SetTempFolder
   | SetFilesFolder
+  | APISetXFTPConfig
   | SetIncognito
   | APIExportArchive
   | APIImportArchive
@@ -111,6 +112,7 @@ type ChatCommandTag =
   | "apiStopChat"
   | "setTempFolder"
   | "setFilesFolder"
+  | "apiSetXFTPConfig"
   | "setIncognito"
   | "apiExportArchive"
   | "apiImportArchive"
@@ -240,6 +242,15 @@ export interface SetFilesFolder extends IChatCommand {
   filePath: string
 }
 
+export interface APISetXFTPConfig extends IChatCommand {
+  type: "apiSetXFTPConfig"
+  config?: XFTPFileConfig
+}
+
+export interface XFTPFileConfig {
+  minFileSize: number
+}
+
 export interface SetIncognito extends IChatCommand {
   type: "setIncognito"
   incognito: boolean
@@ -696,6 +707,8 @@ export function cmdString(cmd: ChatCommand): string {
       return `/_temp_folder ${cmd.tempFolder}`
     case "setFilesFolder":
       return `/_files_folder ${cmd.filePath}`
+    case "apiSetXFTPConfig":
+      return `/_xftp ${onOff(cmd.config)}${maybeJSON(cmd.config)}`
     case "setIncognito":
       return `/incognito ${onOff(cmd.incognito)}`
     case "apiExportArchive":

scripts/nix/sha256map.nix

@@ -1,5 +1,5 @@
 {
-  "https://github.com/simplex-chat/simplexmq.git"."0d843ea4ce1b26a25b55756bf86d1007629896c5" = "0p3mw5kpqhxsjhairx7qaacv33hm11wmbax6jzv2w49nwkcpnbal";
+  "https://github.com/simplex-chat/simplexmq.git"."e6c444f5d1e94f057ac776b8c6c6c8663236831f" = "0r66s7q9l8ccpmg4gnk8z1yby9zp9p0c4gjsgx54cnc0rdl7nr4w";
   "https://github.com/simplex-chat/hs-socks.git"."a30cc7a79a08d8108316094f8f2f82a0c5e1ac51" = "0yasvnr7g91k76mjkamvzab2kvlb1g5pspjyjn2fr6v83swjhj38";
   "https://github.com/simplex-chat/direct-sqlcipher.git"."f814ee68b16a9447fbb467ccc8f29bdd3546bfd9" = "1ql13f4kfwkbaq7nygkxgw84213i0zm7c1a8hwvramayxl38dq5d";
   "https://github.com/simplex-chat/sqlcipher-simple.git"."a46bd361a19376c5211f1058908fc0ae6bf42446" = "1z0r78d8f0812kxbgsm735qf6xx8lvaz27k1a0b4a2m0sshpd5gl";

simplex-chat.cabal

@@ -5,7 +5,7 @@ cabal-version: 1.12
 -- see: https://github.com/sol/hpack
 
 name:           simplex-chat
-version:        5.5.5.0
+version:        5.5.3.0
 category:       Web, System, Services, Cryptography
 homepage:       https://github.com/simplex-chat/simplex-chat#readme
 author:         simplex.chat
@@ -26,7 +26,6 @@ flag swift
 library
   exposed-modules:
       Simplex.Chat
-      Simplex.Chat.AppSettings
       Simplex.Chat.Archive
       Simplex.Chat.Bot
       Simplex.Chat.Bot.KnownContacts
@@ -135,7 +134,6 @@ library
       Simplex.Chat.Migrations.M20240115_block_member_for_all
       Simplex.Chat.Migrations.M20240122_indexes
       Simplex.Chat.Migrations.M20240214_redirect_file_id
-      Simplex.Chat.Migrations.M20240222_app_settings
       Simplex.Chat.Mobile
       Simplex.Chat.Mobile.File
       Simplex.Chat.Mobile.Shared
@@ -151,7 +149,6 @@ library
       Simplex.Chat.Remote.Transport
       Simplex.Chat.Remote.Types
       Simplex.Chat.Store
-      Simplex.Chat.Store.AppSettings
       Simplex.Chat.Store.Connections
       Simplex.Chat.Store.Direct
       Simplex.Chat.Store.Files

src/Simplex/Chat.hs

@@ -26,7 +26,6 @@ import qualified Data.Aeson as J
 import Data.Attoparsec.ByteString.Char8 (Parser)
 import qualified Data.Attoparsec.ByteString.Char8 as A
 import Data.Bifunctor (bimap, first, second)
-import Data.ByteArray (ScrubbedBytes)
 import qualified Data.ByteArray as BA
 import qualified Data.ByteString.Base64 as B64
 import Data.ByteString.Char8 (ByteString)
@@ -68,7 +67,6 @@ import Simplex.Chat.Protocol
 import Simplex.Chat.Remote
 import Simplex.Chat.Remote.Types
 import Simplex.Chat.Store
-import Simplex.Chat.Store.AppSettings
 import Simplex.Chat.Store.Connections
 import Simplex.Chat.Store.Direct
 import Simplex.Chat.Store.Files
@@ -83,7 +81,7 @@ import Simplex.Chat.Types.Util
 import Simplex.Chat.Util (encryptFile, shuffle)
 import Simplex.FileTransfer.Client.Main (maxFileSize)
 import Simplex.FileTransfer.Client.Presets (defaultXFTPServers)
-import Simplex.FileTransfer.Description (FileDescriptionURI (..), ValidFileDescription)
+import Simplex.FileTransfer.Description (FileDescriptionURI (..), ValidFileDescription, gb, kb, mb)
 import qualified Simplex.FileTransfer.Description as FD
 import Simplex.FileTransfer.Protocol (FileParty (..), FilePartyI)
 import Simplex.Messaging.Agent as Agent
@@ -100,6 +98,7 @@ import Simplex.Messaging.Client (defaultNetworkConfig)
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Crypto.File (CryptoFile (..), CryptoFileArgs (..))
 import qualified Simplex.Messaging.Crypto.File as CF
+import Simplex.Messaging.Crypto.Memory (LockedBytes)
 import Simplex.Messaging.Encoding
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Parsers (base64P)
@@ -146,6 +145,8 @@ defaultChatConfig =
       xftpDescrPartSize = 14000,
       inlineFiles = defaultInlineFilesConfig,
       autoAcceptFileSize = 0,
+      xftpFileConfig = Just defaultXFTPFileConfig,
+      tempDir = Nothing,
       showReactions = False,
       showReceipts = False,
       logLevel = CLLImportant,
@@ -196,7 +197,7 @@ smallGroupsRcptsMemLimit = 20
 logCfg :: LogConfig
 logCfg = LogConfig {lc_file = Nothing, lc_stderr = True}
 
-createChatDatabase :: FilePath -> ScrubbedBytes -> Bool -> MigrationConfirmation -> IO (Either MigrationError ChatDatabase)
+createChatDatabase :: FilePath -> LockedBytes -> Bool -> MigrationConfirmation -> IO (Either MigrationError ChatDatabase)
 createChatDatabase filePrefix key keepKey confirmMigrations = runExceptT $ do
   chatStore <- ExceptT $ createChatStore (chatStoreFile filePrefix) key keepKey confirmMigrations
   agentStore <- ExceptT $ createAgentStore (agentStoreFile filePrefix) key keepKey confirmMigrations
@@ -206,7 +207,7 @@ newChatController :: ChatDatabase -> Maybe User -> ChatConfig -> ChatOpts -> Boo
 newChatController
   ChatDatabase {chatStore, agentStore}
   user
-  cfg@ChatConfig {agentConfig = aCfg, defaultServers, inlineFiles, deviceNameForRemote}
+  cfg@ChatConfig {agentConfig = aCfg, defaultServers, inlineFiles, tempDir, deviceNameForRemote}
   ChatOpts {coreOptions = CoreChatOpts {smpServers, xftpServers, networkConfig, logLevel, logConnections, logServerHosts, logFile, tbqSize, highlyAvailable}, deviceName, optFilesFolder, showReactions, allowInstantFiles, autoAcceptFileSize}
   backgroundMode = do
     let inlineFiles' = if allowInstantFiles || autoAcceptFileSize > 0 then inlineFiles else inlineFiles {sendChunks = 0, receiveInstant = False}
@@ -241,7 +242,8 @@ newChatController
     chatActivated <- newTVarIO True
     showLiveItems <- newTVarIO False
     encryptLocalFiles <- newTVarIO False
-    tempDirectory <- newTVarIO Nothing
+    userXFTPFileConfig <- newTVarIO $ xftpFileConfig cfg
+    tempDirectory <- newTVarIO tempDir
     contactMergeEnabled <- newTVarIO True
     pure
       ChatController
@@ -276,6 +278,7 @@ newChatController
           chatActivated,
           showLiveItems,
           encryptLocalFiles,
+          userXFTPFileConfig,
           tempDirectory,
           logFilePath = logFile,
           contactMergeEnabled
@@ -585,6 +588,9 @@ processChatCommand' vr = \case
     createDirectoryIfMissing True rf
     chatWriteVar remoteHostsFolder $ Just rf
     ok_
+  APISetXFTPConfig cfg -> do
+    asks userXFTPFileConfig >>= atomically . (`writeTVar` cfg)
+    ok_
   APISetEncryptLocalFiles on -> chatWriteVar encryptLocalFiles on >> ok_
   SetContactMergeEnabled onOff -> do
     asks contactMergeEnabled >>= atomically . (`writeTVar` onOff)
@@ -598,11 +604,9 @@ processChatCommand' vr = \case
     fileErrs <- importArchive cfg
     setStoreChanged
     pure $ CRArchiveImported fileErrs
-  APISaveAppSettings as -> withStore' (`saveAppSettings` as) >> ok_
-  APIGetAppSettings platformDefaults -> CRAppSettings <$> withStore' (`getAppSettings` platformDefaults)
   APIDeleteStorage -> withStoreChanged deleteStorage
   APIStorageEncryption cfg -> withStoreChanged $ sqlCipherExport cfg
-  TestStorageEncryption key -> sqlCipherTestKey key >> ok_
+  TestStorageEncryption key -> withStoreChanged $ sqlCipherTestKey key
   ExecChatStoreSQL query -> CRSQLResult <$> withStore' (`execSQL` query)
   ExecAgentStoreSQL query -> CRSQLResult <$> withAgent (`execAgentStoreSQL` query)
   SlowSQLQueries -> do
@@ -648,7 +652,7 @@ processChatCommand' vr = \case
           memStatuses -> pure $ Just $ map (uncurry MemberDeliveryStatus) memStatuses
       _ -> pure Nothing
     pure $ CRChatItemInfo user aci ChatItemInfo {itemVersions, memberDeliveryStatuses}
-  APISendMessage (ChatRef cType chatId) live itemTTL (ComposedMessage file_ quotedItemId_ mc) -> withUser $ \user -> withChatLock "sendMessage" $ case cType of
+  APISendMessage (ChatRef cType chatId) live itemTTL (ComposedMessage file_ quotedItemId_ mc) -> withUser $ \user@User {userId} -> withChatLock "sendMessage" $ case cType of
     CTDirect -> do
       ct@Contact {contactId, contactUsed} <- withStore $ \db -> getContact db user chatId
       assertDirectAllowed user MDSnd ct XMsgNew_
@@ -656,19 +660,45 @@ processChatCommand' vr = \case
       if isVoice mc && not (featureAllowed SCFVoice forUser ct)
         then pure $ chatCmdError (Just user) ("feature not allowed " <> T.unpack (chatFeatureNameText CFVoice))
         else do
-          (fInv_, ciFile_) <- L.unzip <$> setupSndFileTransfer ct
+          (fInv_, ciFile_, ft_) <- unzipMaybe3 <$> setupSndFileTransfer ct
           timed_ <- sndContactCITimed live ct itemTTL
           (msgContainer, quotedItem_) <- prepareMsg fInv_ timed_
-          (msg, _) <- sendDirectContactMessage ct (XMsgNew msgContainer)
+          (msg@SndMessage {sharedMsgId}, _) <- sendDirectContactMessage ct (XMsgNew msgContainer)
           ci <- saveSndChatItem' user (CDDirectSnd ct) msg (CISndMsgContent mc) ciFile_ quotedItem_ timed_ live
+          case ft_ of
+            Just ft@FileTransferMeta {fileInline = Just IFMSent} ->
+              sendDirectFileInline ct ft sharedMsgId
+            _ -> pure ()
           forM_ (timed_ >>= timedDeleteAt') $
             startProximateTimedItemThread user (ChatRef CTDirect contactId, chatItemId' ci)
           pure $ CRNewChatItem user (AChatItem SCTDirect SMDSnd (DirectChat ct) ci)
       where
-        setupSndFileTransfer :: Contact -> m (Maybe (FileInvitation, CIFile 'MDSnd))
+        setupSndFileTransfer :: Contact -> m (Maybe (FileInvitation, CIFile 'MDSnd, FileTransferMeta))
         setupSndFileTransfer ct = forM file_ $ \file -> do
-          fileSize <- checkSndFile file
-          xftpSndFileTransfer user file fileSize 1 $ CGContact ct
+          (fileSize, fileMode) <- checkSndFile mc file 1
+          case fileMode of
+            SendFileSMP fileInline -> smpSndFileTransfer file fileSize fileInline
+            SendFileXFTP -> xftpSndFileTransfer user file fileSize 1 $ CGContact ct
+          where
+            smpSndFileTransfer :: CryptoFile -> Integer -> Maybe InlineFileMode -> m (FileInvitation, CIFile 'MDSnd, FileTransferMeta)
+            smpSndFileTransfer (CryptoFile _ (Just _)) _ _ = throwChatError $ CEFileInternal "locally encrypted files can't be sent via SMP" -- can only happen if XFTP is disabled
+            smpSndFileTransfer (CryptoFile file Nothing) fileSize fileInline = do
+              subMode <- chatReadVar subscriptionMode
+              (agentConnId_, fileConnReq) <-
+                if isJust fileInline
+                  then pure (Nothing, Nothing)
+                  else bimap Just Just <$> withAgent (\a -> createConnection a (aUserId user) True SCMInvitation Nothing subMode)
+              let fileName = takeFileName file
+                  fileInvitation = FileInvitation {fileName, fileSize, fileDigest = Nothing, fileConnReq, fileInline, fileDescr = Nothing}
+              chSize <- asks $ fileChunkSize . config
+              withStore $ \db -> do
+                ft@FileTransferMeta {fileId} <- liftIO $ createSndDirectFileTransfer db userId ct file fileInvitation agentConnId_ chSize subMode
+                fileStatus <- case fileInline of
+                  Just IFMSent -> createSndDirectInlineFT db ct ft $> CIFSSndTransfer 0 1
+                  _ -> pure CIFSSndStored
+                let fileSource = Just $ CF.plain file
+                    ciFile = CIFile {fileId, fileName, fileSize, fileSource, fileStatus, fileProtocol = FPSMP}
+                pure (fileInvitation, ciFile, ft)
         prepareMsg :: Maybe FileInvitation -> Maybe CITimed -> m (MsgContainer, Maybe (CIQuote 'CTDirect))
         prepareMsg fInv_ timed_ = case quotedItemId_ of
           Nothing -> pure (MCSimple (ExtMsgContent mc fInv_ (ttl' <$> timed_) (justTrue live)), Nothing)
@@ -695,27 +725,53 @@ processChatCommand' vr = \case
           | isVoice mc && not (groupFeatureAllowed SGFVoice gInfo) = notAllowedError GFVoice
           | not (isVoice mc) && isJust file_ && not (groupFeatureAllowed SGFFiles gInfo) = notAllowedError GFFiles
           | otherwise = do
-              (fInv_, ciFile_) <- L.unzip <$> setupSndFileTransfer g (length $ filter memberCurrent ms)
+              (fInv_, ciFile_, ft_) <- unzipMaybe3 <$> setupSndFileTransfer g (length $ filter memberCurrent ms)
               timed_ <- sndGroupCITimed live gInfo itemTTL
               (msgContainer, quotedItem_) <- prepareGroupMsg user gInfo mc quotedItemId_ fInv_ timed_ live
-              (msg, sentToMembers) <- sendGroupMessage user gInfo ms (XMsgNew msgContainer)
+              (msg@SndMessage {sharedMsgId}, sentToMembers) <- sendGroupMessage user gInfo ms (XMsgNew msgContainer)
               ci <- saveSndChatItem' user (CDGroupSnd gInfo) msg (CISndMsgContent mc) ciFile_ quotedItem_ timed_ live
               withStore' $ \db ->
                 forM_ sentToMembers $ \GroupMember {groupMemberId} ->
                   createGroupSndStatus db (chatItemId' ci) groupMemberId CISSndNew
+              mapM_ (sendGroupFileInline ms sharedMsgId) ft_
               forM_ (timed_ >>= timedDeleteAt') $
                 startProximateTimedItemThread user (ChatRef CTGroup groupId, chatItemId' ci)
               pure $ CRNewChatItem user (AChatItem SCTGroup SMDSnd (GroupChat gInfo) ci)
         notAllowedError f = pure $ chatCmdError (Just user) ("feature not allowed " <> T.unpack (groupFeatureNameText f))
-        setupSndFileTransfer :: Group -> Int -> m (Maybe (FileInvitation, CIFile 'MDSnd))
-        setupSndFileTransfer g n = forM file_ $ \file -> do
-          fileSize <- checkSndFile file
-          xftpSndFileTransfer user file fileSize n $ CGGroup g
+        setupSndFileTransfer :: Group -> Int -> m (Maybe (FileInvitation, CIFile 'MDSnd, FileTransferMeta))
+        setupSndFileTransfer g@(Group gInfo _) n = forM file_ $ \file -> do
+          (fileSize, fileMode) <- checkSndFile mc file $ fromIntegral n
+          case fileMode of
+            SendFileSMP fileInline -> smpSndFileTransfer file fileSize fileInline
+            SendFileXFTP -> xftpSndFileTransfer user file fileSize n $ CGGroup g
+          where
+            smpSndFileTransfer :: CryptoFile -> Integer -> Maybe InlineFileMode -> m (FileInvitation, CIFile 'MDSnd, FileTransferMeta)
+            smpSndFileTransfer (CryptoFile _ (Just _)) _ _ = throwChatError $ CEFileInternal "locally encrypted files can't be sent via SMP" -- can only happen if XFTP is disabled
+            smpSndFileTransfer (CryptoFile file Nothing) fileSize fileInline = do
+              let fileName = takeFileName file
+                  fileInvitation = FileInvitation {fileName, fileSize, fileDigest = Nothing, fileConnReq = Nothing, fileInline, fileDescr = Nothing}
+                  fileStatus = if fileInline == Just IFMSent then CIFSSndTransfer 0 1 else CIFSSndStored
+              chSize <- asks $ fileChunkSize . config
+              withStore' $ \db -> do
+                ft@FileTransferMeta {fileId} <- createSndGroupFileTransfer db userId gInfo file fileInvitation chSize
+                let fileSource = Just $ CF.plain file
+                    ciFile = CIFile {fileId, fileName, fileSize, fileSource, fileStatus, fileProtocol = FPSMP}
+                pure (fileInvitation, ciFile, ft)
+        sendGroupFileInline :: [GroupMember] -> SharedMsgId -> FileTransferMeta -> m ()
+        sendGroupFileInline ms sharedMsgId ft@FileTransferMeta {fileInline} =
+          when (fileInline == Just IFMSent) . forM_ ms $ \m ->
+            processMember m `catchChatError` (toView . CRChatError (Just user))
+          where
+            processMember m@GroupMember {activeConn = Just conn@Connection {connStatus}} =
+              when (connStatus == ConnReady || connStatus == ConnSndReady) $ do
+                void . withStore' $ \db -> createSndGroupInlineFT db m conn ft
+                sendMemberFileInline m conn ft sharedMsgId
+            processMember _ = pure ()
     CTLocal -> pure $ chatCmdError (Just user) "not supported"
     CTContactRequest -> pure $ chatCmdError (Just user) "not supported"
     CTContactConnection -> pure $ chatCmdError (Just user) "not supported"
     where
-      xftpSndFileTransfer :: User -> CryptoFile -> Integer -> Int -> ContactOrGroup -> m (FileInvitation, CIFile 'MDSnd)
+      xftpSndFileTransfer :: User -> CryptoFile -> Integer -> Int -> ContactOrGroup -> m (FileInvitation, CIFile 'MDSnd, FileTransferMeta)
       xftpSndFileTransfer user file fileSize n contactOrGroup = do
         (fInv, ciFile, ft) <- xftpSndFileTransfer_ user file fileSize n $ Just contactOrGroup
         case contactOrGroup of
@@ -729,7 +785,10 @@ processChatCommand' vr = \case
                   withStore' $
                     \db -> createSndFTDescrXFTP db user (Just m) conn ft dummyFileDescr
               saveMemberFD _ = pure ()
-        pure (fInv, ciFile)
+        pure (fInv, ciFile, ft)
+      unzipMaybe3 :: Maybe (a, b, c) -> (Maybe a, Maybe b, Maybe c)
+      unzipMaybe3 (Just (a, b, c)) = (Just a, Just b, Just c)
+      unzipMaybe3 _ = (Nothing, Nothing, Nothing)
   APICreateChatItem folderId (ComposedMessage file_ quotedItemId_ mc) -> withUser $ \user -> do
     forM_ quotedItemId_ $ \_ -> throwError $ ChatError $ CECommandError "not supported"
     nf <- withStore $ \db -> getNoteFolder db user folderId
@@ -947,7 +1006,7 @@ processChatCommand' vr = \case
         -- functions below are called in separate transactions to prevent crashes on android
         -- (possibly, race condition on integrity check?)
         withStore' $ \db -> deleteContactConnectionsAndFiles db userId ct
-        withStore $ \db -> deleteContact db user ct
+        withStore' $ \db -> deleteContact db user ct
         pure $ CRContactDeleted user ct
     CTContactConnection -> withChatLock "deleteChat contactConnection" . procCmd $ do
       conn@PendingContactConnection {pccAgentConnId = AgentConnId acId} <- withStore $ \db -> getPendingContactConnection db userId chatId
@@ -988,7 +1047,7 @@ processChatCommand' vr = \case
                     Just _ -> pure []
                     Nothing -> do
                       conns <- withStore' $ \db -> getContactConnections db userId ct
-                      withStore (\db -> setContactDeleted db user ct)
+                      withStore' (\db -> setContactDeleted db user ct)
                         `catchChatError` (toView . CRChatError (Just user))
                       pure $ map aConnId conns
     CTLocal -> pure $ chatCmdError (Just user) "not supported"
@@ -1994,9 +2053,8 @@ processChatCommand' vr = \case
   StopRemoteCtrl -> withUser_ $ stopRemoteCtrl >> ok_
   ListRemoteCtrls -> withUser_ $ CRRemoteCtrlList <$> listRemoteCtrls
   DeleteRemoteCtrl rc -> withUser_ $ deleteRemoteCtrl rc >> ok_
-  APIUploadStandaloneFile userId file@CryptoFile {filePath} -> withUserId userId $ \user -> do
-    fsFilePath <- toFSFilePath filePath
-    fileSize <- liftIO $ CF.getFileContentsSize file {filePath = fsFilePath}
+  APIUploadStandaloneFile userId file -> withUserId userId $ \user -> do
+    fileSize <- liftIO $ CF.getFileContentsSize file
     (_, _, fileTransferMeta) <- xftpSndFileTransfer_ user file fileSize 1 Nothing
     pure CRSndStandaloneFileCreated {user, fileTransferMeta}
   APIDownloadStandaloneFile userId uri file -> withUserId userId $ \user -> do
@@ -2150,13 +2208,27 @@ processChatCommand' vr = \case
     contactMember Contact {contactId} =
       find $ \GroupMember {memberContactId = cId, memberStatus = s} ->
         cId == Just contactId && s /= GSMemRemoved && s /= GSMemLeft
-    checkSndFile :: CryptoFile -> m Integer
-    checkSndFile (CryptoFile f cfArgs) = do
+    checkSndFile :: MsgContent -> CryptoFile -> Integer -> m (Integer, SendFileMode)
+    checkSndFile mc (CryptoFile f cfArgs) n = do
       fsFilePath <- toFSFilePath f
       unlessM (doesFileExist fsFilePath) . throwChatError $ CEFileNotFound f
+      ChatConfig {fileChunkSize, inlineFiles} <- asks config
+      xftpCfg <- readTVarIO =<< asks userXFTPFileConfig
       fileSize <- liftIO $ CF.getFileContentsSize $ CryptoFile fsFilePath cfArgs
       when (fromInteger fileSize > maxFileSize) $ throwChatError $ CEFileSize f
-      pure fileSize
+      let chunks = -((-fileSize) `div` fileChunkSize)
+          fileInline = inlineFileMode mc inlineFiles chunks n
+          fileMode = case xftpCfg of
+            Just cfg
+              | isJust cfArgs -> SendFileXFTP
+              | fileInline == Just IFMSent || fileSize < minFileSize cfg || n <= 0 -> SendFileSMP fileInline
+              | otherwise -> SendFileXFTP
+            _ -> SendFileSMP fileInline
+      pure (fileSize, fileMode)
+    inlineFileMode mc InlineFilesConfig {offerChunks, sendChunks, totalSendChunks} chunks n
+      | chunks > offerChunks = Nothing
+      | chunks <= sendChunks && chunks * n <= totalSendChunks && isVoice mc = Just IFMSent
+      | otherwise = Just IFMOffer
     updateProfile :: User -> Profile -> m ChatResponse
     updateProfile user p' = updateProfile_ user p' $ withStore $ \db -> updateUserProfile db user p'
     updateProfile_ :: User -> Profile -> m User -> m ChatResponse
@@ -3079,7 +3151,7 @@ cleanupManager = do
     cleanupDeletedContacts user = do
       contacts <- withStore' (`getDeletedContacts` user)
       forM_ contacts $ \ct ->
-        withStore (\db -> deleteContactWithoutGroups db user ct)
+        withStore' (\db -> deleteContactWithoutGroups db user ct)
           `catchChatError` (toView . CRChatError (Just user))
     cleanupMessages = do
       ts <- liftIO getCurrentTime
@@ -4871,7 +4943,7 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
         else do
           contactConns <- withStore' $ \db -> getContactConnections db userId c
           deleteAgentConnectionsAsync user $ map aConnId contactConns
-          withStore $ \db -> deleteContact db user c
+          withStore' $ \db -> deleteContact db user c
       where
         brokerTs = metaBrokerTs msgMeta
 
@@ -6461,6 +6533,8 @@ chatCommandP =
       "/_temp_folder " *> (SetTempFolder <$> filePath),
       ("/_files_folder " <|> "/files_folder ") *> (SetFilesFolder <$> filePath),
       "/remote_hosts_folder " *> (SetRemoteHostsFolder <$> filePath),
+      "/_xftp " *> (APISetXFTPConfig <$> ("on " *> (Just <$> jsonP) <|> ("off" $> Nothing))),
+      "/xftp " *> (APISetXFTPConfig <$> ("on" *> (Just <$> xftpCfgP) <|> ("off" $> Nothing))),
       "/_files_encrypt " *> (APISetEncryptLocalFiles <$> onOffP),
       "/contact_merge " *> (SetContactMergeEnabled <$> onOffP),
       "/_db export " *> (APIExportArchive <$> jsonP),
@@ -6472,8 +6546,6 @@ chatCommandP =
       "/db key " *> (APIStorageEncryption <$> (dbEncryptionConfig <$> dbKeyP <* A.space <*> dbKeyP)),
       "/db decrypt " *> (APIStorageEncryption . (`dbEncryptionConfig` "") <$> dbKeyP),
       "/db test key " *> (TestStorageEncryption <$> dbKeyP),
-      "/_save app settings" *> (APISaveAppSettings <$> jsonP),
-      "/_get app settings" *> (APIGetAppSettings <$> optional (A.space *> jsonP)),
       "/sql chat " *> (ExecChatStoreSQL <$> textP),
       "/sql agent " *> (ExecAgentStoreSQL <$> textP),
       "/sql slow" $> SlowSQLQueries,
@@ -6838,6 +6910,14 @@ chatCommandP =
       logErrors <- " log=" *> onOffP <|> pure False
       let tcpTimeout = 1000000 * fromMaybe (maybe 5 (const 10) socksProxy) t_
       pure $ fullNetworkConfig socksProxy tcpTimeout logErrors
+    xftpCfgP = XFTPFileConfig <$> (" size=" *> fileSizeP <|> pure 0)
+    fileSizeP =
+      A.choice
+        [ gb <$> A.decimal <* "gb",
+          mb <$> A.decimal <* "mb",
+          kb <$> A.decimal <* "kb",
+          A.decimal
+        ]
     dbKeyP = nonEmptyKey <$?> strP
     nonEmptyKey k@(DBEncryptionKey s) = if BA.null s then Left "empty key" else Right k
     dbEncryptionConfig currentKey newKey = DBEncryptionConfig {currentKey, newKey, keepKey = Just False}

src/Simplex/Chat/AppSettings.hs

@@ -1,190 +0,0 @@
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE StrictData #-}
-{-# LANGUAGE TemplateHaskell #-}
-
-module Simplex.Chat.AppSettings where
-
-import Control.Applicative ((<|>))
-import Data.Aeson (FromJSON (..), (.:?))
-import qualified Data.Aeson as J
-import qualified Data.Aeson.TH as JQ
-import Data.Maybe (fromMaybe)
-import Data.Text (Text)
-import Simplex.Messaging.Client (NetworkConfig, defaultNetworkConfig)
-import Simplex.Messaging.Parsers (defaultJSON, dropPrefix, enumJSON)
-import Simplex.Messaging.Util (catchAll_)
-
-data AppPlatform = APIOS | APAndroid | APDesktop deriving (Show)
-
-data NotificationMode = NMOff | NMPeriodic | NMInstant deriving (Show)
-
-data NotificationPreviewMode = NPMHidden | NPMContact | NPMMessage deriving (Show)
-
-data LockScreenCalls = LSCDisable | LSCShow | LSCAccept deriving (Show)
-
-data AppSettings = AppSettings
-  { appPlatform :: Maybe AppPlatform,
-    networkConfig :: Maybe NetworkConfig,
-    privacyEncryptLocalFiles :: Maybe Bool,
-    privacyAcceptImages :: Maybe Bool,
-    privacyLinkPreviews :: Maybe Bool,
-    privacyShowChatPreviews :: Maybe Bool,
-    privacySaveLastDraft :: Maybe Bool,
-    privacyProtectScreen :: Maybe Bool,
-    notificationMode :: Maybe NotificationMode,
-    notificationPreviewMode :: Maybe NotificationPreviewMode,
-    webrtcPolicyRelay :: Maybe Bool,
-    webrtcICEServers :: Maybe [Text],
-    confirmRemoteSessions :: Maybe Bool,
-    connectRemoteViaMulticast :: Maybe Bool,
-    connectRemoteViaMulticastAuto :: Maybe Bool,
-    developerTools :: Maybe Bool,
-    confirmDBUpgrades :: Maybe Bool,
-    androidCallOnLockScreen :: Maybe LockScreenCalls,
-    iosCallKitEnabled :: Maybe Bool,
-    iosCallKitCallsInRecents :: Maybe Bool
-  }
-  deriving (Show)
-
-defaultAppSettings :: AppSettings
-defaultAppSettings =
-  AppSettings
-    { appPlatform = Nothing,
-      networkConfig = Just defaultNetworkConfig,
-      privacyEncryptLocalFiles = Just True,
-      privacyAcceptImages = Just True,
-      privacyLinkPreviews = Just True,
-      privacyShowChatPreviews = Just True,
-      privacySaveLastDraft = Just True,
-      privacyProtectScreen = Just False,
-      notificationMode = Just NMInstant,
-      notificationPreviewMode = Just NPMMessage,
-      webrtcPolicyRelay = Just True,
-      webrtcICEServers = Just [],
-      confirmRemoteSessions = Just False,
-      connectRemoteViaMulticast = Just True,
-      connectRemoteViaMulticastAuto = Just True,
-      developerTools = Just False,
-      confirmDBUpgrades = Just False,
-      androidCallOnLockScreen = Just LSCShow,
-      iosCallKitEnabled = Just True,
-      iosCallKitCallsInRecents = Just False
-    }
-
-defaultParseAppSettings :: AppSettings
-defaultParseAppSettings =
-  AppSettings
-    { appPlatform = Nothing,
-      networkConfig = Nothing,
-      privacyEncryptLocalFiles = Nothing,
-      privacyAcceptImages = Nothing,
-      privacyLinkPreviews = Nothing,
-      privacyShowChatPreviews = Nothing,
-      privacySaveLastDraft = Nothing,
-      privacyProtectScreen = Nothing,
-      notificationMode = Nothing,
-      notificationPreviewMode = Nothing,
-      webrtcPolicyRelay = Nothing,
-      webrtcICEServers = Nothing,
-      confirmRemoteSessions = Nothing,
-      connectRemoteViaMulticast = Nothing,
-      connectRemoteViaMulticastAuto = Nothing,
-      developerTools = Nothing,
-      confirmDBUpgrades = Nothing,
-      androidCallOnLockScreen = Nothing,
-      iosCallKitEnabled = Nothing,
-      iosCallKitCallsInRecents = Nothing
-    }
-
-combineAppSettings :: AppSettings -> AppSettings -> AppSettings
-combineAppSettings platformDefaults storedSettings =
-  AppSettings
-    { appPlatform = p appPlatform, 
-      networkConfig = p networkConfig,
-      privacyEncryptLocalFiles = p privacyEncryptLocalFiles,
-      privacyAcceptImages = p privacyAcceptImages,
-      privacyLinkPreviews = p privacyLinkPreviews,
-      privacyShowChatPreviews = p privacyShowChatPreviews,
-      privacySaveLastDraft = p privacySaveLastDraft,
-      privacyProtectScreen = p privacyProtectScreen,
-      notificationMode = p notificationMode,
-      notificationPreviewMode = p notificationPreviewMode,
-      webrtcPolicyRelay = p webrtcPolicyRelay,
-      webrtcICEServers = p webrtcICEServers,
-      confirmRemoteSessions = p confirmRemoteSessions,
-      connectRemoteViaMulticast = p connectRemoteViaMulticast,
-      connectRemoteViaMulticastAuto = p connectRemoteViaMulticastAuto,
-      developerTools = p developerTools,
-      confirmDBUpgrades = p confirmDBUpgrades,
-      iosCallKitEnabled = p iosCallKitEnabled,
-      iosCallKitCallsInRecents = p iosCallKitCallsInRecents,
-      androidCallOnLockScreen = p androidCallOnLockScreen
-    }
-  where
-    p :: (AppSettings -> Maybe a) -> Maybe a
-    p sel = sel storedSettings <|> sel platformDefaults <|> sel defaultAppSettings
-
-$(JQ.deriveJSON (enumJSON $ dropPrefix "AP") ''AppPlatform)
-
-$(JQ.deriveJSON (enumJSON $ dropPrefix "NM") ''NotificationMode)
-
-$(JQ.deriveJSON (enumJSON $ dropPrefix "NPM") ''NotificationPreviewMode)
-
-$(JQ.deriveJSON (enumJSON $ dropPrefix "LSC") ''LockScreenCalls)
-
-$(JQ.deriveToJSON defaultJSON ''AppSettings)
-
-instance FromJSON AppSettings where
-  parseJSON (J.Object v) = do
-    appPlatform <- p "appPlatform"
-    networkConfig <- p "networkConfig"
-    privacyEncryptLocalFiles <- p "privacyEncryptLocalFiles"
-    privacyAcceptImages <- p "privacyAcceptImages"
-    privacyLinkPreviews <- p "privacyLinkPreviews"
-    privacyShowChatPreviews <- p "privacyShowChatPreviews"
-    privacySaveLastDraft <- p "privacySaveLastDraft"
-    privacyProtectScreen <- p "privacyProtectScreen"
-    notificationMode <- p "notificationMode"
-    notificationPreviewMode <- p "notificationPreviewMode"
-    webrtcPolicyRelay <- p "webrtcPolicyRelay"
-    webrtcICEServers <- p "webrtcICEServers"
-    confirmRemoteSessions <- p "confirmRemoteSessions"
-    connectRemoteViaMulticast <- p "connectRemoteViaMulticast"
-    connectRemoteViaMulticastAuto <- p "connectRemoteViaMulticastAuto"
-    developerTools <- p "developerTools"
-    confirmDBUpgrades <- p "confirmDBUpgrades"
-    iosCallKitEnabled <- p "iosCallKitEnabled"
-    iosCallKitCallsInRecents <- p "iosCallKitCallsInRecents"
-    androidCallOnLockScreen <- p "androidCallOnLockScreen"
-    pure
-      AppSettings
-        { appPlatform,
-          networkConfig,
-          privacyEncryptLocalFiles,
-          privacyAcceptImages,
-          privacyLinkPreviews,
-          privacyShowChatPreviews,
-          privacySaveLastDraft,
-          privacyProtectScreen,
-          notificationMode,
-          notificationPreviewMode,
-          webrtcPolicyRelay,
-          webrtcICEServers,
-          confirmRemoteSessions,
-          connectRemoteViaMulticast,
-          connectRemoteViaMulticastAuto,
-          developerTools,
-          confirmDBUpgrades,
-          iosCallKitEnabled,
-          iosCallKitCallsInRecents,
-          androidCallOnLockScreen
-        }
-    where
-      p key = v .:? key <|> pure Nothing
-  parseJSON _ = pure defaultParseAppSettings
-
-readAppSettings :: FilePath -> Maybe AppSettings -> IO AppSettings
-readAppSettings f platformDefaults =
-  combineAppSettings (fromMaybe defaultAppSettings platformDefaults) . fromMaybe defaultParseAppSettings
-    <$> (J.decodeFileStrict f `catchAll_` pure Nothing)

src/Simplex/Chat/Archive.hs

@@ -27,6 +27,7 @@ import qualified Database.SQLite3 as SQL
 import Simplex.Chat.Controller
 import Simplex.Messaging.Agent.Client (agentClientStore)
 import Simplex.Messaging.Agent.Store.SQLite (SQLiteStore (..), closeSQLiteStore, keyString, sqlString, storeKey)
+import Simplex.Messaging.Crypto.Memory (LockedBytes)
 import Simplex.Messaging.Util
 import System.FilePath
 import UnliftIO.Directory
@@ -172,7 +173,7 @@ withDB f' a err =
     sqliteError' :: Show e => e -> m (Maybe SQLiteError)
     sqliteError' = pure . Just . SQLiteError . show
 
-testSQL :: BA.ScrubbedBytes -> Text
+testSQL :: LockedBytes -> Text
 testSQL k =
   T.unlines $
     keySQL k
@@ -181,7 +182,7 @@ testSQL k =
             "SELECT count(*) FROM sqlite_master;"
           ]
 
-keySQL :: BA.ScrubbedBytes -> [Text]
+keySQL :: LockedBytes -> [Text]
 keySQL k = ["PRAGMA key = " <> keyString k <> ";" | not (BA.null k)]
 
 sqlCipherTestKey :: forall m. ChatMonad m => DBEncryptionKey -> m ()

src/Simplex/Chat/Controller.hs

@@ -29,7 +29,6 @@ import qualified Data.Aeson.TH as JQ
 import qualified Data.Aeson.Types as JT
 import qualified Data.Attoparsec.ByteString.Char8 as A
 import Data.Bifunctor (first)
-import Data.ByteArray (ScrubbedBytes)
 import qualified Data.ByteArray as BA
 import Data.ByteString.Char8 (ByteString)
 import qualified Data.ByteString.Char8 as B
@@ -49,7 +48,6 @@ import Data.Word (Word16)
 import Language.Haskell.TH (Exp, Q, runIO)
 import Numeric.Natural
 import qualified Paths_simplex_chat as SC
-import Simplex.Chat.AppSettings
 import Simplex.Chat.Call
 import Simplex.Chat.Markdown (MarkdownList)
 import Simplex.Chat.Messages
@@ -72,6 +70,7 @@ import qualified Simplex.Messaging.Agent.Store.SQLite.DB as DB
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Crypto.File (CryptoFile (..))
 import qualified Simplex.Messaging.Crypto.File as CF
+import Simplex.Messaging.Crypto.Memory (LockedBytes)
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Notifications.Protocol (DeviceToken (..), NtfTknStatus)
 import Simplex.Messaging.Parsers (defaultJSON, dropPrefix, enumJSON, parseAll, parseString, sumTypeJSON)
@@ -130,6 +129,8 @@ data ChatConfig = ChatConfig
     xftpDescrPartSize :: Int,
     inlineFiles :: InlineFilesConfig,
     autoAcceptFileSize :: Integer,
+    xftpFileConfig :: Maybe XFTPFileConfig, -- Nothing - XFTP is disabled
+    tempDir :: Maybe FilePath,
     showReactions :: Bool,
     showReceipts :: Bool,
     subscriptionEvents :: Bool,
@@ -204,6 +205,7 @@ data ChatController = ChatController
     timedItemThreads :: TMap (ChatRef, ChatItemId) (TVar (Maybe (Weak ThreadId))),
     showLiveItems :: TVar Bool,
     encryptLocalFiles :: TVar Bool,
+    userXFTPFileConfig :: TVar (Maybe XFTPFileConfig),
     tempDirectory :: TVar (Maybe FilePath),
     logFilePath :: Maybe FilePath,
     contactMergeEnabled :: TVar Bool
@@ -241,13 +243,12 @@ data ChatCommand
   | SetTempFolder FilePath
   | SetFilesFolder FilePath
   | SetRemoteHostsFolder FilePath
+  | APISetXFTPConfig (Maybe XFTPFileConfig)
   | APISetEncryptLocalFiles Bool
   | SetContactMergeEnabled Bool
   | APIExportArchive ArchiveConfig
   | ExportArchive
   | APIImportArchive ArchiveConfig
-  | APISaveAppSettings AppSettings
-  | APIGetAppSettings (Maybe AppSettings)
   | APIDeleteStorage
   | APIStorageEncryption DBEncryptionConfig
   | TestStorageEncryption DBEncryptionKey
@@ -476,6 +477,7 @@ allowRemoteCommand = \case
   SetTempFolder _ -> False
   SetFilesFolder _ -> False
   SetRemoteHostsFolder _ -> False
+  APISetXFTPConfig _ -> False
   APISetEncryptLocalFiles _ -> False
   APIExportArchive _ -> False
   APIImportArchive _ -> False
@@ -714,7 +716,6 @@ data ChatResponse
   | CRChatError {user_ :: Maybe User, chatError :: ChatError}
   | CRChatErrors {user_ :: Maybe User, chatErrors :: [ChatError]}
   | CRArchiveImported {archiveErrors :: [ArchiveError]}
-  | CRAppSettings {appSettings :: AppSettings}
   | CRTimedAction {action :: String, durationMilliseconds :: Int64}
   deriving (Show)
 
@@ -879,7 +880,7 @@ data ArchiveConfig = ArchiveConfig {archivePath :: FilePath, disableCompression
 data DBEncryptionConfig = DBEncryptionConfig {currentKey :: DBEncryptionKey, newKey :: DBEncryptionKey, keepKey :: Maybe Bool}
   deriving (Show)
 
-newtype DBEncryptionKey = DBEncryptionKey ScrubbedBytes
+newtype DBEncryptionKey = DBEncryptionKey LockedBytes
   deriving (Show)
 
 instance IsString DBEncryptionKey where fromString = parseString $ parseAll strP
@@ -942,6 +943,14 @@ instance FromJSON ComposedMessage where
   parseJSON invalid =
     JT.prependFailure "bad ComposedMessage, " (JT.typeMismatch "Object" invalid)
 
+data XFTPFileConfig = XFTPFileConfig
+  { minFileSize :: Integer
+  }
+  deriving (Show)
+
+defaultXFTPFileConfig :: XFTPFileConfig
+defaultXFTPFileConfig = XFTPFileConfig {minFileSize = 0}
+
 data NtfMsgInfo = NtfMsgInfo {msgId :: Text, msgTs :: UTCTime}
   deriving (Show)
 
@@ -1001,6 +1010,11 @@ data CoreVersionInfo = CoreVersionInfo
   }
   deriving (Show)
 
+data SendFileMode
+  = SendFileSMP (Maybe InlineFileMode)
+  | SendFileXFTP
+  deriving (Show)
+
 data SlowSQLQuery = SlowSQLQuery
   { query :: Text,
     queryStats :: SlowQueryStats
@@ -1404,4 +1418,6 @@ $(JQ.deriveFromJSON defaultJSON ''ArchiveConfig)
 
 $(JQ.deriveFromJSON defaultJSON ''DBEncryptionConfig)
 
+$(JQ.deriveJSON defaultJSON ''XFTPFileConfig)
+
 $(JQ.deriveToJSON defaultJSON ''ComposedMessage)

src/Simplex/Chat/Messages/CIContent.hs

@@ -172,7 +172,7 @@ ciRequiresAttention content = case msgDirection @d of
     CIRcvGroupInvitation {} -> True
     CIRcvDirectEvent rde -> case rde of
       RDEContactDeleted -> False
-      RDEProfileUpdated {} -> False
+      RDEProfileUpdated {} -> True
     CIRcvGroupEvent rge -> case rge of
       RGEMemberAdded {} -> False
       RGEMemberConnected -> False

src/Simplex/Chat/Migrations/M20240222_app_settings.hs

@@ -1,20 +0,0 @@
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Chat.Migrations.M20240222_app_settings where
-
-import Database.SQLite.Simple (Query)
-import Database.SQLite.Simple.QQ (sql)
-
-m20240222_app_settings :: Query
-m20240222_app_settings =
-  [sql|
-CREATE TABLE app_settings (
-  app_settings TEXT NOT NULL
-);
-|]
-
-down_m20240222_app_settings :: Query
-down_m20240222_app_settings =
-  [sql|
-DROP TABLE app_settings;
-|]

src/Simplex/Chat/Migrations/chat_schema.sql

@@ -562,7 +562,6 @@ CREATE TABLE note_folders(
   favorite INTEGER NOT NULL DEFAULT 0,
   unread_chat INTEGER NOT NULL DEFAULT 0
 );
-CREATE TABLE app_settings(app_settings TEXT NOT NULL);
 CREATE INDEX contact_profiles_index ON contact_profiles(
   display_name,
   full_name

src/Simplex/Chat/Mobile.hs

@@ -15,7 +15,6 @@ import Control.Monad.Reader
 import qualified Data.Aeson as J
 import qualified Data.Aeson.TH as JQ
 import Data.Bifunctor (first)
-import Data.ByteArray (ScrubbedBytes)
 import qualified Data.ByteArray as BA
 import qualified Data.ByteString.Base64.URL as U
 import Data.ByteString.Char8 (ByteString)
@@ -50,6 +49,7 @@ import Simplex.Messaging.Agent.Env.SQLite (createAgentStore)
 import Simplex.Messaging.Agent.Store.SQLite (MigrationConfirmation (..), MigrationError, closeSQLiteStore, reopenSQLiteStore)
 import Simplex.Messaging.Client (defaultNetworkConfig)
 import qualified Simplex.Messaging.Crypto as C
+import Simplex.Messaging.Crypto.Memory (LockedBytes)
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Parsers (defaultJSON, dropPrefix, sumTypeJSON)
 import Simplex.Messaging.Protocol (AProtoServerWithAuth (..), AProtocolType (..), BasicAuth (..), CorrId (..), ProtoServerWithAuth (..), ProtocolServer (..))
@@ -227,10 +227,10 @@ defaultMobileConfig =
 getActiveUser_ :: SQLiteStore -> IO (Maybe User)
 getActiveUser_ st = find activeUser <$> withTransaction st getUsers
 
-chatMigrateInit :: String -> ScrubbedBytes -> String -> IO (Either DBMigrationResult ChatController)
+chatMigrateInit :: String -> LockedBytes -> String -> IO (Either DBMigrationResult ChatController)
 chatMigrateInit dbFilePrefix dbKey confirm = chatMigrateInitKey dbFilePrefix dbKey False confirm False
 
-chatMigrateInitKey :: String -> ScrubbedBytes -> Bool -> String -> Bool -> IO (Either DBMigrationResult ChatController)
+chatMigrateInitKey :: String -> LockedBytes -> Bool -> String -> Bool -> IO (Either DBMigrationResult ChatController)
 chatMigrateInitKey dbFilePrefix dbKey keepKey confirm backgroundMode = runExceptT $ do
   confirmMigrations <- liftEitherWith (const DBMInvalidConfirmation) $ strDecode $ B.pack confirm
   chatStore <- migrate createChatStore (chatStoreFile dbFilePrefix) confirmMigrations

src/Simplex/Chat/Options.hs

@@ -19,7 +19,6 @@ where
 
 import Control.Logger.Simple (LogLevel (..))
 import qualified Data.Attoparsec.ByteString.Char8 as A
-import Data.ByteArray (ScrubbedBytes)
 import qualified Data.ByteString.Char8 as B
 import Data.Text (Text)
 import Numeric.Natural (Natural)
@@ -27,6 +26,7 @@ import Options.Applicative
 import Simplex.Chat.Controller (ChatLogLevel (..), updateStr, versionNumber, versionString)
 import Simplex.FileTransfer.Description (mb)
 import Simplex.Messaging.Client (NetworkConfig (..), defaultNetworkConfig)
+import Simplex.Messaging.Crypto.Memory (LockedBytes)
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Parsers (parseAll)
 import Simplex.Messaging.Protocol (ProtoServerWithAuth, ProtocolTypeI, SMPServerWithAuth, XFTPServerWithAuth)
@@ -51,7 +51,7 @@ data ChatOpts = ChatOpts
 
 data CoreChatOpts = CoreChatOpts
   { dbFilePrefix :: String,
-    dbKey :: ScrubbedBytes,
+    dbKey :: LockedBytes,
     smpServers :: [SMPServerWithAuth],
     xftpServers :: [XFTPServerWithAuth],
     networkConfig :: NetworkConfig,

src/Simplex/Chat/Store.hs

@@ -12,13 +12,13 @@ module Simplex.Chat.Store
   )
 where
 
-import Data.ByteArray (ScrubbedBytes)
 import Simplex.Chat.Store.Migrations
 import Simplex.Chat.Store.Profiles
 import Simplex.Chat.Store.Shared
 import Simplex.Messaging.Agent.Store.SQLite (MigrationConfirmation, MigrationError, SQLiteStore (..), createSQLiteStore, withTransaction)
+import Simplex.Messaging.Crypto.Memory (LockedBytes)
 
-createChatStore :: FilePath -> ScrubbedBytes -> Bool -> MigrationConfirmation -> IO (Either MigrationError SQLiteStore)
+createChatStore :: FilePath -> LockedBytes -> Bool -> MigrationConfirmation -> IO (Either MigrationError SQLiteStore)
 createChatStore dbPath key keepKey = createSQLiteStore dbPath key keepKey migrations
 
 chatStoreFile :: FilePath -> FilePath

src/Simplex/Chat/Store/AppSettings.hs

@@ -1,22 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-
-module Simplex.Chat.Store.AppSettings where
-
-import Control.Monad (join)
-import Control.Monad.IO.Class (liftIO)
-import qualified Data.Aeson as J
-import Data.Maybe (fromMaybe)
-import Database.SQLite.Simple (Only (..))
-import Simplex.Chat.AppSettings (AppSettings (..), combineAppSettings, defaultAppSettings, defaultParseAppSettings)
-import Simplex.Messaging.Agent.Store.SQLite (maybeFirstRow)
-import qualified Simplex.Messaging.Agent.Store.SQLite.DB as DB
-
-saveAppSettings :: DB.Connection -> AppSettings -> IO ()
-saveAppSettings db appSettings = do
-  DB.execute_ db "DELETE FROM app_settings"
-  DB.execute db "INSERT INTO app_settings (app_settings) VALUES (?)" (Only $ J.encode appSettings)
-
-getAppSettings :: DB.Connection -> Maybe AppSettings -> IO AppSettings
-getAppSettings db platformDefaults = do
-  stored_ <- join <$> liftIO (maybeFirstRow (J.decodeStrict . fromOnly) $ DB.query_ db "SELECT app_settings FROM app_settings")
-  pure $ combineAppSettings (fromMaybe defaultAppSettings platformDefaults) (fromMaybe defaultParseAppSettings stored_)

src/Simplex/Chat/Store/Direct.hs

@@ -229,45 +229,37 @@ deleteContactConnectionsAndFiles db userId Contact {contactId} = do
     (userId, contactId)
   DB.execute db "DELETE FROM files WHERE user_id = ? AND contact_id = ?" (userId, contactId)
 
-deleteContact :: DB.Connection -> User -> Contact -> ExceptT StoreError IO ()
-deleteContact db user@User {userId} ct@Contact {contactId, localDisplayName, activeConn} = do
-  assertNotUser db user ct
-  liftIO $ do
-    DB.execute db "DELETE FROM chat_items WHERE user_id = ? AND contact_id = ?" (userId, contactId)
-    ctMember :: (Maybe ContactId) <- maybeFirstRow fromOnly $ DB.query db "SELECT contact_id FROM group_members WHERE user_id = ? AND contact_id = ? LIMIT 1" (userId, contactId)
-    if isNothing ctMember
-      then do
-        deleteContactProfile_ db userId contactId
-        -- user's local display name already checked in assertNotUser
-        DB.execute db "DELETE FROM display_names WHERE user_id = ? AND local_display_name = ?" (userId, localDisplayName)
-      else do
-        currentTs <- getCurrentTime
-        DB.execute db "UPDATE group_members SET contact_id = NULL, updated_at = ? WHERE user_id = ? AND contact_id = ?" (currentTs, userId, contactId)
-    DB.execute db "DELETE FROM contacts WHERE user_id = ? AND contact_id = ?" (userId, contactId)
-    forM_ activeConn $ \Connection {customUserProfileId} ->
-      forM_ customUserProfileId $ \profileId ->
-        deleteUnusedIncognitoProfileById_ db user profileId
+deleteContact :: DB.Connection -> User -> Contact -> IO ()
+deleteContact db user@User {userId} Contact {contactId, localDisplayName, activeConn} = do
+  DB.execute db "DELETE FROM chat_items WHERE user_id = ? AND contact_id = ?" (userId, contactId)
+  ctMember :: (Maybe ContactId) <- maybeFirstRow fromOnly $ DB.query db "SELECT contact_id FROM group_members WHERE user_id = ? AND contact_id = ? LIMIT 1" (userId, contactId)
+  if isNothing ctMember
+    then do
+      deleteContactProfile_ db userId contactId
+      DB.execute db "DELETE FROM display_names WHERE user_id = ? AND local_display_name = ?" (userId, localDisplayName)
+    else do
+      currentTs <- getCurrentTime
+      DB.execute db "UPDATE group_members SET contact_id = NULL, updated_at = ? WHERE user_id = ? AND contact_id = ?" (currentTs, userId, contactId)
+  DB.execute db "DELETE FROM contacts WHERE user_id = ? AND contact_id = ?" (userId, contactId)
+  forM_ activeConn $ \Connection {customUserProfileId} ->
+    forM_ customUserProfileId $ \profileId ->
+      deleteUnusedIncognitoProfileById_ db user profileId
 
 -- should only be used if contact is not member of any groups
-deleteContactWithoutGroups :: DB.Connection -> User -> Contact -> ExceptT StoreError IO ()
-deleteContactWithoutGroups db user@User {userId} ct@Contact {contactId, localDisplayName, activeConn} = do
-  assertNotUser db user ct
-  liftIO $ do
-    DB.execute db "DELETE FROM chat_items WHERE user_id = ? AND contact_id = ?" (userId, contactId)
-    deleteContactProfile_ db userId contactId
-    -- user's local display name already checked in assertNotUser
-    DB.execute db "DELETE FROM display_names WHERE user_id = ? AND local_display_name = ?" (userId, localDisplayName)
-    DB.execute db "DELETE FROM contacts WHERE user_id = ? AND contact_id = ?" (userId, contactId)
-    forM_ activeConn $ \Connection {customUserProfileId} ->
-      forM_ customUserProfileId $ \profileId ->
-        deleteUnusedIncognitoProfileById_ db user profileId
+deleteContactWithoutGroups :: DB.Connection -> User -> Contact -> IO ()
+deleteContactWithoutGroups db user@User {userId} Contact {contactId, localDisplayName, activeConn} = do
+  DB.execute db "DELETE FROM chat_items WHERE user_id = ? AND contact_id = ?" (userId, contactId)
+  deleteContactProfile_ db userId contactId
+  DB.execute db "DELETE FROM display_names WHERE user_id = ? AND local_display_name = ?" (userId, localDisplayName)
+  DB.execute db "DELETE FROM contacts WHERE user_id = ? AND contact_id = ?" (userId, contactId)
+  forM_ activeConn $ \Connection {customUserProfileId} ->
+    forM_ customUserProfileId $ \profileId ->
+      deleteUnusedIncognitoProfileById_ db user profileId
 
-setContactDeleted :: DB.Connection -> User -> Contact -> ExceptT StoreError IO ()
-setContactDeleted db user@User {userId} ct@Contact {contactId} = do
-  assertNotUser db user ct
-  liftIO $ do
-    currentTs <- getCurrentTime
-    DB.execute db "UPDATE contacts SET deleted = 1, updated_at = ? WHERE user_id = ? AND contact_id = ?" (currentTs, userId, contactId)
+setContactDeleted :: DB.Connection -> User -> Contact -> IO ()
+setContactDeleted db User {userId} Contact {contactId} = do
+  currentTs <- getCurrentTime
+  DB.execute db "UPDATE contacts SET deleted = 1, updated_at = ? WHERE user_id = ? AND contact_id = ?" (currentTs, userId, contactId)
 
 getDeletedContacts :: DB.Connection -> User -> IO [Contact]
 getDeletedContacts db user@User {userId} = do
@@ -328,7 +320,7 @@ updateContactProfile db user@User {userId} c p'
       ExceptT . withLocalDisplayName db userId newName $ \ldn -> do
         currentTs <- getCurrentTime
         updateContactProfile_' db userId profileId p' currentTs
-        updateContactLDN_ db user contactId localDisplayName ldn currentTs
+        updateContactLDN_ db userId contactId localDisplayName ldn currentTs
         pure $ Right c {localDisplayName = ldn, profile, mergedPreferences}
   where
     Contact {contactId, localDisplayName, profile = LocalProfile {profileId, displayName, localAlias}, userPreferences} = c
@@ -499,8 +491,8 @@ updateMemberContactProfile_' db userId profileId Profile {displayName, fullName,
     |]
     (displayName, fullName, image, updatedAt, userId, profileId)
 
-updateContactLDN_ :: DB.Connection -> User -> Int64 -> ContactName -> ContactName -> UTCTime -> IO ()
-updateContactLDN_ db user@User {userId} contactId displayName newName updatedAt = do
+updateContactLDN_ :: DB.Connection -> UserId -> Int64 -> ContactName -> ContactName -> UTCTime -> IO ()
+updateContactLDN_ db userId contactId displayName newName updatedAt = do
   DB.execute
     db
     "UPDATE contacts SET local_display_name = ?, updated_at = ? WHERE user_id = ? AND contact_id = ?"
@@ -509,7 +501,7 @@ updateContactLDN_ db user@User {userId} contactId displayName newName updatedAt
     db
     "UPDATE group_members SET local_display_name = ?, updated_at = ? WHERE user_id = ? AND contact_id = ?"
     (newName, updatedAt, userId, contactId)
-  safeDeleteLDN db user displayName
+  DB.execute db "DELETE FROM display_names WHERE local_display_name = ? AND user_id = ?" (displayName, userId)
 
 getContactByName :: DB.Connection -> User -> ContactName -> ExceptT StoreError IO Contact
 getContactByName db user localDisplayName = do
@@ -622,7 +614,7 @@ createOrUpdateContactRequest db user@User {userId} userContactLinkId invId (Vers
                 WHERE user_id = ? AND contact_request_id = ?
               |]
               (invId, minV, maxV, ldn, currentTs, userId, cReqId)
-            safeDeleteLDN db user oldLdn
+            DB.execute db "DELETE FROM display_names WHERE local_display_name = ? AND user_id = ?" (oldLdn, userId)
       where
         updateProfile currentTs =
           DB.execute
@@ -692,9 +684,8 @@ deleteContactRequest db User {userId} contactRequestId = do
         SELECT local_display_name FROM contact_requests
         WHERE user_id = ? AND contact_request_id = ?
       )
-      AND local_display_name NOT IN (SELECT local_display_name FROM users WHERE user_id = ?)
     |]
-    (userId, userId, contactRequestId, userId)
+    (userId, userId, contactRequestId)
   DB.execute db "DELETE FROM contact_requests WHERE user_id = ? AND contact_request_id = ?" (userId, contactRequestId)
 
 createAcceptedContact :: DB.Connection -> User -> ConnId -> VersionRange -> ContactName -> ProfileId -> Profile -> Int64 -> Maybe XContactId -> Maybe IncognitoProfile -> SubscriptionMode -> Bool -> IO Contact

src/Simplex/Chat/Store/Files.hs

@@ -14,6 +14,7 @@ module Simplex.Chat.Store.Files
   ( getLiveSndFileTransfers,
     getLiveRcvFileTransfers,
     getPendingSndChunks,
+    createSndDirectFileTransfer,
     createSndDirectFTConnection,
     createSndGroupFileTransfer,
     createSndGroupFileTransferConnection,
@@ -173,6 +174,23 @@ getPendingSndChunks db fileId connId =
       |]
       (fileId, connId)
 
+createSndDirectFileTransfer :: DB.Connection -> UserId -> Contact -> FilePath -> FileInvitation -> Maybe ConnId -> Integer -> SubscriptionMode -> IO FileTransferMeta
+createSndDirectFileTransfer db userId Contact {contactId} filePath FileInvitation {fileName, fileSize, fileInline} acId_ chunkSize subMode = do
+  currentTs <- getCurrentTime
+  DB.execute
+    db
+    "INSERT INTO files (user_id, contact_id, file_name, file_path, file_size, chunk_size, file_inline, ci_file_status, protocol, created_at, updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?)"
+    ((userId, contactId, fileName, filePath, fileSize, chunkSize) :. (fileInline, CIFSSndStored, FPSMP, currentTs, currentTs))
+  fileId <- insertedRowId db
+  forM_ acId_ $ \acId -> do
+    Connection {connId} <- createSndFileConnection_ db userId fileId acId subMode
+    let fileStatus = FSNew
+    DB.execute
+      db
+      "INSERT INTO snd_files (file_id, file_status, file_inline, connection_id, created_at, updated_at) VALUES (?,?,?,?,?,?)"
+      (fileId, fileStatus, fileInline, connId, currentTs, currentTs)
+  pure FileTransferMeta {fileId, xftpSndFile = Nothing, xftpRedirectFor = Nothing, fileName, filePath, fileSize, fileInline, chunkSize, cancelled = False}
+
 createSndDirectFTConnection :: DB.Connection -> User -> Int64 -> (CommandId, ConnId) -> SubscriptionMode -> IO ()
 createSndDirectFTConnection db user@User {userId} fileId (cmdId, acId) subMode = do
   currentTs <- getCurrentTime

src/Simplex/Chat/Store/Groups.hs

@@ -225,9 +225,8 @@ deleteGroupLink db User {userId} GroupInfo {groupId} = do
           JOIN user_contact_links uc USING (user_contact_link_id)
           WHERE uc.user_id = ? AND uc.group_id = ?
         )
-        AND local_display_name NOT IN (SELECT local_display_name FROM users WHERE user_id = ?)
     |]
-    (userId, userId, groupId, userId)
+    (userId, userId, groupId)
   DB.execute
     db
     [sql|
@@ -587,7 +586,7 @@ deleteGroup :: DB.Connection -> User -> GroupInfo -> IO ()
 deleteGroup db user@User {userId} g@GroupInfo {groupId, localDisplayName} = do
   deleteGroupProfile_ db userId groupId
   DB.execute db "DELETE FROM groups WHERE user_id = ? AND group_id = ?" (userId, groupId)
-  safeDeleteLDN db user localDisplayName
+  DB.execute db "DELETE FROM display_names WHERE user_id = ? AND local_display_name = ?" (userId, localDisplayName)
   forM_ (incognitoMembershipProfile g) $ deleteUnusedIncognitoProfileById_ db user . localProfileId
 
 deleteGroupProfile_ :: DB.Connection -> UserId -> GroupId -> IO ()
@@ -1045,14 +1044,14 @@ deleteGroupMember db user@User {userId} m@GroupMember {groupMemberId, groupId, m
   when (memberIncognito m) $ deleteUnusedIncognitoProfileById_ db user $ localProfileId memberProfile
 
 cleanupMemberProfileAndName_ :: DB.Connection -> User -> GroupMember -> IO ()
-cleanupMemberProfileAndName_ db user@User {userId} GroupMember {groupMemberId, memberContactId, memberContactProfileId, localDisplayName} =
+cleanupMemberProfileAndName_ db User {userId} GroupMember {groupMemberId, memberContactId, memberContactProfileId, localDisplayName} =
   -- check record has no memberContactId (contact_id) - it means contact has been deleted and doesn't use profile & ldn
   when (isNothing memberContactId) $ do
     -- check other group member records don't use profile & ldn
     sameProfileMember :: (Maybe GroupMemberId) <- maybeFirstRow fromOnly $ DB.query db "SELECT group_member_id FROM group_members WHERE user_id = ? AND contact_profile_id = ? AND group_member_id != ? LIMIT 1" (userId, memberContactProfileId, groupMemberId)
     when (isNothing sameProfileMember) $ do
       DB.execute db "DELETE FROM contact_profiles WHERE user_id = ? AND contact_profile_id = ?" (userId, memberContactProfileId)
-      safeDeleteLDN db user localDisplayName
+      DB.execute db "DELETE FROM display_names WHERE user_id = ? AND local_display_name = ?" (userId, localDisplayName)
 
 deleteGroupMemberConnection :: DB.Connection -> User -> GroupMember -> IO ()
 deleteGroupMemberConnection db User {userId} GroupMember {groupMemberId} =
@@ -1331,7 +1330,7 @@ getViaGroupContact db user@User {userId} GroupMember {groupMemberId} = do
   maybe (pure Nothing) (fmap eitherToMaybe . runExceptT . getContact db user) contactId_
 
 updateGroupProfile :: DB.Connection -> User -> GroupInfo -> GroupProfile -> ExceptT StoreError IO GroupInfo
-updateGroupProfile db user@User {userId} g@GroupInfo {groupId, localDisplayName, groupProfile = GroupProfile {displayName}} p'@GroupProfile {displayName = newName, fullName, description, image, groupPreferences}
+updateGroupProfile db User {userId} g@GroupInfo {groupId, localDisplayName, groupProfile = GroupProfile {displayName}} p'@GroupProfile {displayName = newName, fullName, description, image, groupPreferences}
   | displayName == newName = liftIO $ do
       currentTs <- getCurrentTime
       updateGroupProfile_ currentTs
@@ -1362,7 +1361,7 @@ updateGroupProfile db user@User {userId} g@GroupInfo {groupId, localDisplayName,
         db
         "UPDATE groups SET local_display_name = ?, updated_at = ? WHERE user_id = ? AND group_id = ?"
         (ldn, currentTs, userId, groupId)
-      safeDeleteLDN db user localDisplayName
+      DB.execute db "DELETE FROM display_names WHERE local_display_name = ? AND user_id = ?" (localDisplayName, userId)
 
 getGroupInfo :: DB.Connection -> VersionRange -> User -> Int64 -> ExceptT StoreError IO GroupInfo
 getGroupInfo db vr User {userId, userContactId} groupId =
@@ -1465,7 +1464,7 @@ getMatchingContacts db user@User {userId} Contact {contactId, profile = LocalPro
         FROM contacts ct
         JOIN contact_profiles p ON ct.contact_profile_id = p.contact_profile_id
         WHERE ct.user_id = ? AND ct.contact_id != ?
-          AND ct.contact_status = ? AND ct.deleted = 0 AND ct.is_user = 0
+          AND ct.contact_status = ? AND ct.deleted = 0
           AND p.display_name = ? AND p.full_name = ?
       |]
 
@@ -1503,7 +1502,7 @@ getMatchingMemberContacts db user@User {userId} GroupMember {memberProfile = Loc
         FROM contacts ct
         JOIN contact_profiles p ON ct.contact_profile_id = p.contact_profile_id
         WHERE ct.user_id = ?
-          AND ct.contact_status = ? AND ct.deleted = 0 AND ct.is_user = 0
+          AND ct.contact_status = ? AND ct.deleted = 0
           AND p.display_name = ? AND p.full_name = ?
       |]
 
@@ -1616,8 +1615,6 @@ mergeContactRecords db user@User {userId} to@Contact {localDisplayName = keepLDN
   let (toCt, fromCt) = toFromContacts to from
       Contact {contactId = toContactId, localDisplayName = toLDN} = toCt
       Contact {contactId = fromContactId, localDisplayName = fromLDN} = fromCt
-  assertNotUser db user toCt
-  assertNotUser db user fromCt
   liftIO $ do
     currentTs <- getCurrentTime
     -- next query fixes incorrect unused contacts deletion
@@ -2021,7 +2018,7 @@ createMemberContactConn_
     pure Connection {connId, agentConnId = AgentConnId acId, peerChatVRange, connType = ConnContact, contactConnInitiated = False, entityId = Just contactId, viaContact = Nothing, viaUserContactLink = Nothing, viaGroupLink = False, groupLinkId = Nothing, customUserProfileId, connLevel, connStatus = ConnJoined, localAlias = "", createdAt = currentTs, connectionCode = Nothing, authErrCounter = 0}
 
 updateMemberProfile :: DB.Connection -> User -> GroupMember -> Profile -> ExceptT StoreError IO GroupMember
-updateMemberProfile db user@User {userId} m p'
+updateMemberProfile db User {userId} m p'
   | displayName == newName = do
       liftIO $ updateMemberContactProfileReset_ db userId profileId p'
       pure m {memberProfile = profile}
@@ -2033,7 +2030,7 @@ updateMemberProfile db user@User {userId} m p'
           db
           "UPDATE group_members SET local_display_name = ?, updated_at = ? WHERE user_id = ? AND group_member_id = ?"
           (ldn, currentTs, userId, groupMemberId)
-        safeDeleteLDN db user localDisplayName
+        DB.execute db "DELETE FROM display_names WHERE local_display_name = ? AND user_id = ?" (localDisplayName, userId)
         pure $ Right m {localDisplayName = ldn, memberProfile = profile}
   where
     GroupMember {groupMemberId, localDisplayName, memberProfile = LocalProfile {profileId, displayName, localAlias}} = m
@@ -2041,7 +2038,7 @@ updateMemberProfile db user@User {userId} m p'
     profile = toLocalProfile profileId p' localAlias
 
 updateContactMemberProfile :: DB.Connection -> User -> GroupMember -> Contact -> Profile -> ExceptT StoreError IO (GroupMember, Contact)
-updateContactMemberProfile db user@User {userId} m ct@Contact {contactId} p'
+updateContactMemberProfile db User {userId} m ct@Contact {contactId} p'
   | displayName == newName = do
       liftIO $ updateMemberContactProfile_ db userId profileId p'
       pure (m {memberProfile = profile}, ct {profile} :: Contact)
@@ -2049,7 +2046,7 @@ updateContactMemberProfile db user@User {userId} m ct@Contact {contactId} p'
       ExceptT . withLocalDisplayName db userId newName $ \ldn -> do
         currentTs <- getCurrentTime
         updateMemberContactProfile_' db userId profileId p' currentTs
-        updateContactLDN_ db user contactId localDisplayName ldn currentTs
+        updateContactLDN_ db userId contactId localDisplayName ldn currentTs
         pure $ Right (m {localDisplayName = ldn, memberProfile = profile}, ct {localDisplayName = ldn, profile} :: Contact)
   where
     GroupMember {localDisplayName, memberProfile = LocalProfile {profileId, displayName, localAlias}} = m

src/Simplex/Chat/Store/Migrations.hs

@@ -99,7 +99,6 @@ import Simplex.Chat.Migrations.M20240104_members_profile_update
 import Simplex.Chat.Migrations.M20240115_block_member_for_all
 import Simplex.Chat.Migrations.M20240122_indexes
 import Simplex.Chat.Migrations.M20240214_redirect_file_id
-import Simplex.Chat.Migrations.M20240222_app_settings
 import Simplex.Messaging.Agent.Store.SQLite.Migrations (Migration (..))
 
 schemaMigrations :: [(String, Query, Maybe Query)]
@@ -198,8 +197,7 @@ schemaMigrations =
     ("20240104_members_profile_update", m20240104_members_profile_update, Just down_m20240104_members_profile_update),
     ("20240115_block_member_for_all", m20240115_block_member_for_all, Just down_m20240115_block_member_for_all),
     ("20240122_indexes", m20240122_indexes, Just down_m20240122_indexes),
-    ("20240214_redirect_file_id", m20240214_redirect_file_id, Just down_m20240214_redirect_file_id),
-    ("20240222_app_settings", m20240222_app_settings, Just down_m20240222_app_settings)
+    ("20240214_redirect_file_id", m20240214_redirect_file_id, Just down_m20240214_redirect_file_id)
   ]
 
 -- | The list of migrations in ascending order by date

src/Simplex/Chat/Store/Profiles.hs

@@ -267,7 +267,7 @@ updateUserProfile db user p'
           "INSERT INTO display_names (local_display_name, ldn_base, user_id, created_at, updated_at) VALUES (?,?,?,?,?)"
           (newName, newName, userId, currentTs, currentTs)
         updateContactProfile_' db userId profileId p' currentTs
-        updateContactLDN_ db user userContactId localDisplayName newName currentTs
+        updateContactLDN_ db userId userContactId localDisplayName newName currentTs
         pure user {localDisplayName = newName, profile, fullPreferences, userMemberProfileUpdatedAt = userMemberProfileUpdatedAt'}
   where
     updateUserMemberProfileUpdatedAt_ currentTs
@@ -388,7 +388,6 @@ deleteUserAddress db user@User {userId} = do
           JOIN user_contact_links uc USING (user_contact_link_id)
           WHERE uc.user_id = :user_id AND uc.local_display_name = '' AND uc.group_id IS NULL
         )
-        AND local_display_name NOT IN (SELECT local_display_name FROM users WHERE user_id = :user_id)
     |]
     [":user_id" := userId]
   DB.executeNamed

src/Simplex/Chat/Store/Shared.hs

@@ -111,7 +111,6 @@ data StoreError
   | SERemoteHostDuplicateCA
   | SERemoteCtrlNotFound {remoteCtrlId :: RemoteCtrlId}
   | SERemoteCtrlDuplicateCA
-  | SEProhibitedDeleteUser {userId :: UserId, contactId :: ContactId}
   deriving (Show, Exception)
 
 $(J.deriveJSON (sumTypeJSON $ dropPrefix "SE") ''StoreError)
@@ -403,33 +402,3 @@ createWithRandomBytes' size gVar create = tryCreate 3
 
 encodedRandomBytes :: TVar ChaChaDRG -> Int -> IO ByteString
 encodedRandomBytes gVar n = atomically $ B64.encode <$> C.randomBytes n gVar
-
-assertNotUser :: DB.Connection -> User -> Contact -> ExceptT StoreError IO ()
-assertNotUser db User {userId} Contact {contactId, localDisplayName} = do
-  r :: (Maybe Int64) <-
-    -- This query checks that the foreign keys in the users table
-    -- are not referencing the contact about to be deleted.
-    -- With the current schema it would cause cascade delete of user,
-    -- with mofified schema (in v5.6.0-beta.0) it would cause foreign key violation error.
-    liftIO . maybeFirstRow fromOnly $
-      DB.query
-        db
-        [sql|
-          SELECT 1 FROM users
-          WHERE (user_id = ? AND local_display_name = ?)
-             OR contact_id = ?
-          LIMIT 1
-        |]
-        (userId, localDisplayName, contactId)
-  when (isJust r) $ throwError $ SEProhibitedDeleteUser userId contactId
-
-safeDeleteLDN :: DB.Connection -> User -> ContactName -> IO ()
-safeDeleteLDN db User {userId} localDisplayName = do
-  DB.execute
-    db
-    [sql|
-      DELETE FROM display_names
-      WHERE user_id = ? AND local_display_name = ?
-        AND local_display_name NOT IN (SELECT local_display_name FROM users WHERE user_id = ?)
-    |]
-    (userId, localDisplayName, userId)

src/Simplex/Chat/View.hs

@@ -385,7 +385,6 @@ responseToView hu@(currentRH, user_) ChatConfig {logLevel, showReactions, showRe
   CRChatError u e -> ttyUser' u $ viewChatError logLevel testView e
   CRChatErrors u errs -> ttyUser' u $ concatMap (viewChatError logLevel testView) errs
   CRArchiveImported archiveErrs -> if null archiveErrs then ["ok"] else ["archive import errors: " <> plain (show archiveErrs)]
-  CRAppSettings as -> ["app settings: " <> plain (LB.unpack $ J.encode as)]
   CRTimedAction _ _ -> []
   where
     ttyUser :: User -> [StyledString] -> [StyledString]

tests/ChatClient.hs

@@ -15,15 +15,13 @@ import Control.Concurrent.STM
 import Control.Exception (bracket, bracket_)
 import Control.Monad
 import Control.Monad.Except
-import Control.Monad.Reader
-import Data.ByteArray (ScrubbedBytes)
 import Data.Functor (($>))
 import Data.List (dropWhileEnd, find)
 import Data.Maybe (isNothing)
 import qualified Data.Text as T
 import Network.Socket
 import Simplex.Chat
-import Simplex.Chat.Controller (ChatCommand (..), ChatConfig (..), ChatController (..), ChatDatabase (..), ChatLogLevel (..))
+import Simplex.Chat.Controller (ChatConfig (..), ChatController (..), ChatDatabase (..), ChatLogLevel (..))
 import Simplex.Chat.Core
 import Simplex.Chat.Options
 import Simplex.Chat.Store
@@ -39,6 +37,7 @@ import Simplex.Messaging.Agent.RetryInterval
 import Simplex.Messaging.Agent.Store.SQLite (MigrationConfirmation (..))
 import qualified Simplex.Messaging.Agent.Store.SQLite.DB as DB
 import Simplex.Messaging.Client (ProtocolClientConfig (..), defaultNetworkConfig)
+import Simplex.Messaging.Crypto.Memory (LockedBytes)
 import Simplex.Messaging.Server (runSMPServerBlocking)
 import Simplex.Messaging.Server.Env.STM
 import Simplex.Messaging.Transport
@@ -93,7 +92,7 @@ testCoreOpts =
       highlyAvailable = False
     }
 
-getTestOpts :: Bool -> ScrubbedBytes -> ChatOpts
+getTestOpts :: Bool -> LockedBytes -> ChatOpts
 getTestOpts maintenance dbKey = testOpts {maintenance, coreOptions = testCoreOpts {dbKey}}
 
 termSettings :: VirtualTerminalSettings
@@ -130,7 +129,8 @@ testCfg =
     { agentConfig = testAgentCfg,
       showReceipts = False,
       testView = True,
-      tbqSize = 16
+      tbqSize = 16,
+      xftpFileConfig = Nothing
     }
 
 testAgentCfgVPrev :: AgentConfig
@@ -209,7 +209,6 @@ startTestChat_ db cfg opts user = do
   t <- withVirtualTerminal termSettings pure
   ct <- newChatTerminal t opts
   cc <- newChatController db (Just user) cfg opts False
-  void $ execChatCommand' (SetTempFolder "tests/tmp/tmp") `runReaderT` cc
   chatAsync <- async . runSimplexChat opts user cc $ \_u cc' -> runChatTerminal ct cc' opts
   atomically . unless (maintenance opts) $ readTVar (agentAsync cc) >>= \a -> when (isNothing a) retry
   termQ <- newTQueueIO

tests/ChatTests/Direct.hs

@@ -14,9 +14,6 @@ import Data.Aeson (ToJSON)
 import qualified Data.Aeson as J
 import qualified Data.ByteString.Char8 as B
 import qualified Data.ByteString.Lazy.Char8 as LB
-import qualified Data.Text as T
-import Simplex.Chat.AppSettings (defaultAppSettings)
-import qualified Simplex.Chat.AppSettings as AS
 import Simplex.Chat.Call
 import Simplex.Chat.Controller (ChatConfig (..))
 import Simplex.Chat.Options (ChatOpts (..))
@@ -24,7 +21,6 @@ import Simplex.Chat.Protocol (supportedChatVRange)
 import Simplex.Chat.Store (agentStoreFile, chatStoreFile)
 import Simplex.Chat.Types (authErrDisableCount, sameVerificationCode, verificationCode)
 import qualified Simplex.Messaging.Crypto as C
-import Simplex.Messaging.Util (safeDecodeUtf8)
 import Simplex.Messaging.Version
 import System.Directory (copyFile, doesDirectoryExist, doesFileExist)
 import System.FilePath ((</>))
@@ -88,9 +84,8 @@ chatDirectTests = do
     it "disabling chat item expiration doesn't disable it for other users" testDisableCIExpirationOnlyForOneUser
     it "both users have configured timed messages with contacts, messages expire, restart" testUsersTimedMessages
     it "user profile privacy: hide profiles and notificaitons" testUserPrivacy
-  describe "settings" $ do
-    it "set chat item expiration TTL" testSetChatItemTTL
-    it "save/get app settings" testAppSettings
+  describe "chat item expiration" $ do
+    it "set chat item TTL" testSetChatItemTTL
   describe "connection switch" $ do
     it "switch contact to a different queue" testSwitchContact
     it "stop switching contact to a different queue" testAbortSwitchContact
@@ -1072,7 +1067,7 @@ testChatWorking alice bob = do
   alice <# "bob> hello too"
 
 testMaintenanceModeWithFiles :: HasCallStack => FilePath -> IO ()
-testMaintenanceModeWithFiles tmp = withXFTPServer $ do
+testMaintenanceModeWithFiles tmp = do
   withNewTestChat tmp "bob" bobProfile $ \bob -> do
     withNewTestChatOpts tmp testOpts {maintenance = True} "alice" aliceProfile $ \alice -> do
       alice ##> "/_start"
@@ -1080,26 +1075,12 @@ testMaintenanceModeWithFiles tmp = withXFTPServer $ do
       alice ##> "/_files_folder ./tests/tmp/alice_files"
       alice <## "ok"
       connectUsers alice bob
-
-      bob #> "/f @alice ./tests/fixtures/test.jpg"
-      bob <## "use /fc 1 to cancel sending"
-      alice <# "bob> sends file test.jpg (136.5 KiB / 139737 bytes)"
-      alice <## "use /fr 1 [<dir>/ | <path>] to receive it"
-      bob <## "completed uploading file 1 (test.jpg) for alice"
-
-      alice ##> "/fr 1"
-      alice
-        <### [ "saving file 1 from bob to test.jpg",
-               "started receiving file 1 (test.jpg) from bob"
-             ]
+      startFileTransferWithDest' bob alice "test.jpg" "136.5 KiB / 139737 bytes" Nothing
+      bob <## "completed sending file 1 (test.jpg) to alice"
       alice <## "completed receiving file 1 (test.jpg) from bob"
-
       src <- B.readFile "./tests/fixtures/test.jpg"
-      dest <- B.readFile "./tests/tmp/alice_files/test.jpg"
-      dest `shouldBe` src
-
+      B.readFile "./tests/tmp/alice_files/test.jpg" `shouldReturn` src
       threadDelay 500000
-
       alice ##> "/_stop"
       alice <## "chat stopped"
       alice ##> "/_db export {\"archivePath\": \"./tests/tmp/alice-chat.zip\"}"
@@ -2200,24 +2181,6 @@ testSetChatItemTTL =
       alice #$> ("/ttl none", id, "ok")
       alice #$> ("/ttl", id, "old messages are not being deleted")
 
-testAppSettings :: HasCallStack => FilePath -> IO ()
-testAppSettings tmp =
-  withNewTestChat tmp "alice" aliceProfile $ \alice -> do
-    let settings = T.unpack . safeDecodeUtf8 . LB.toStrict $ J.encode defaultAppSettings
-        settingsApp = T.unpack . safeDecodeUtf8 . LB.toStrict $ J.encode defaultAppSettings {AS.webrtcICEServers = Just ["non-default.value.com"]}
-    -- app-provided defaults
-    alice ##> ("/_get app settings " <> settingsApp)
-    alice <## ("app settings: " <> settingsApp)
-    -- parser defaults fallback
-    alice ##> "/_get app settings"
-    alice <## ("app settings: " <> settings)
-    -- store
-    alice ##> ("/_save app settings " <> settingsApp)
-    alice <## "ok"
-    -- read back
-    alice ##> "/_get app settings"
-    alice <## ("app settings: " <> settingsApp)
-
 testSwitchContact :: HasCallStack => FilePath -> IO ()
 testSwitchContact =
   testChat2 aliceProfile bobProfile $

tests/ChatTests/Groups.hs

@@ -11,7 +11,7 @@ import Control.Monad (void, when)
 import qualified Data.ByteString as B
 import Data.List (isInfixOf)
 import qualified Data.Text as T
-import Simplex.Chat.Controller (ChatConfig (..))
+import Simplex.Chat.Controller (ChatConfig (..), XFTPFileConfig (..))
 import Simplex.Chat.Protocol (supportedChatVRange)
 import Simplex.Chat.Store (agentStoreFile, chatStoreFile)
 import Simplex.Chat.Types (GroupMemberRole (..))
@@ -4321,7 +4321,7 @@ testGroupMsgForwardDeletion =
 
 testGroupMsgForwardFile :: HasCallStack => FilePath -> IO ()
 testGroupMsgForwardFile =
-  testChat3 aliceProfile bobProfile cathProfile $
+  testChatCfg3 cfg aliceProfile bobProfile cathProfile $
     \alice bob cath -> withXFTPServer $ do
       setupGroupForwarding3 "team" alice bob cath
 
@@ -4343,6 +4343,8 @@ testGroupMsgForwardFile =
       src <- B.readFile "./tests/fixtures/test.jpg"
       dest <- B.readFile "./tests/tmp/test.jpg"
       dest `shouldBe` src
+  where
+    cfg = testCfg {xftpFileConfig = Just $ XFTPFileConfig {minFileSize = 0}, tempDir = Just "./tests/tmp"}
 
 testGroupMsgForwardChangeRole :: HasCallStack => FilePath -> IO ()
 testGroupMsgForwardChangeRole =
@@ -4575,7 +4577,7 @@ testGroupHistoryPreferenceOff =
 
 testGroupHistoryHostFile :: HasCallStack => FilePath -> IO ()
 testGroupHistoryHostFile =
-  testChat3 aliceProfile bobProfile cathProfile $
+  testChatCfg3 cfg aliceProfile bobProfile cathProfile $
     \alice bob cath -> withXFTPServer $ do
       createGroup2 "team" alice bob
 
@@ -4611,10 +4613,12 @@ testGroupHistoryHostFile =
       src <- B.readFile "./tests/fixtures/test.jpg"
       dest <- B.readFile "./tests/tmp/test.jpg"
       dest `shouldBe` src
+  where
+    cfg = testCfg {xftpFileConfig = Just $ XFTPFileConfig {minFileSize = 0}, tempDir = Just "./tests/tmp"}
 
 testGroupHistoryMemberFile :: HasCallStack => FilePath -> IO ()
 testGroupHistoryMemberFile =
-  testChat3 aliceProfile bobProfile cathProfile $
+  testChatCfg3 cfg aliceProfile bobProfile cathProfile $
     \alice bob cath -> withXFTPServer $ do
       createGroup2 "team" alice bob
 
@@ -4650,6 +4654,8 @@ testGroupHistoryMemberFile =
       src <- B.readFile "./tests/fixtures/test.jpg"
       dest <- B.readFile "./tests/tmp/test.jpg"
       dest `shouldBe` src
+  where
+    cfg = testCfg {xftpFileConfig = Just $ XFTPFileConfig {minFileSize = 0}, tempDir = Just "./tests/tmp"}
 
 testGroupHistoryLargeFile :: HasCallStack => FilePath -> IO ()
 testGroupHistoryLargeFile =
@@ -4707,11 +4713,11 @@ testGroupHistoryLargeFile =
       destCath <- B.readFile "./tests/tmp/testfile_2"
       destCath `shouldBe` src
   where
-    cfg = testCfg {xftpDescrPartSize = 200}
+    cfg = testCfg {xftpDescrPartSize = 200, xftpFileConfig = Just $ XFTPFileConfig {minFileSize = 0}, tempDir = Just "./tests/tmp"}
 
 testGroupHistoryMultipleFiles :: HasCallStack => FilePath -> IO ()
 testGroupHistoryMultipleFiles =
-  testChat3 aliceProfile bobProfile cathProfile $
+  testChatCfg3 cfg aliceProfile bobProfile cathProfile $
     \alice bob cath -> withXFTPServer $ do
       xftpCLI ["rand", "./tests/tmp/testfile_bob", "2mb"] `shouldReturn` ["File created: " <> "./tests/tmp/testfile_bob"]
       xftpCLI ["rand", "./tests/tmp/testfile_alice", "1mb"] `shouldReturn` ["File created: " <> "./tests/tmp/testfile_alice"]
@@ -4788,10 +4794,12 @@ testGroupHistoryMultipleFiles =
         `shouldContain` [ ((0, "hi alice"), Just "./tests/tmp/testfile_bob_1"),
                           ((0, "hey bob"), Just "./tests/tmp/testfile_alice_1")
                         ]
+  where
+    cfg = testCfg {xftpFileConfig = Just $ XFTPFileConfig {minFileSize = 0}, tempDir = Just "./tests/tmp"}
 
 testGroupHistoryFileCancel :: HasCallStack => FilePath -> IO ()
 testGroupHistoryFileCancel =
-  testChat3 aliceProfile bobProfile cathProfile $
+  testChatCfg3 cfg aliceProfile bobProfile cathProfile $
     \alice bob cath -> withXFTPServer $ do
       xftpCLI ["rand", "./tests/tmp/testfile_bob", "2mb"] `shouldReturn` ["File created: " <> "./tests/tmp/testfile_bob"]
       xftpCLI ["rand", "./tests/tmp/testfile_alice", "1mb"] `shouldReturn` ["File created: " <> "./tests/tmp/testfile_alice"]
@@ -4843,10 +4851,12 @@ testGroupHistoryFileCancel =
             bob <## "#team: alice added cath (Catherine) to the group (connecting...)"
             bob <## "#team: new member cath is connected"
         ]
+  where
+    cfg = testCfg {xftpFileConfig = Just $ XFTPFileConfig {minFileSize = 0}, tempDir = Just "./tests/tmp"}
 
 testGroupHistoryFileCancelNoText :: HasCallStack => FilePath -> IO ()
 testGroupHistoryFileCancelNoText =
-  testChat3 aliceProfile bobProfile cathProfile $
+  testChatCfg3 cfg aliceProfile bobProfile cathProfile $
     \alice bob cath -> withXFTPServer $ do
       xftpCLI ["rand", "./tests/tmp/testfile_bob", "2mb"] `shouldReturn` ["File created: " <> "./tests/tmp/testfile_bob"]
       xftpCLI ["rand", "./tests/tmp/testfile_alice", "1mb"] `shouldReturn` ["File created: " <> "./tests/tmp/testfile_alice"]
@@ -4902,6 +4912,8 @@ testGroupHistoryFileCancelNoText =
             bob <## "#team: alice added cath (Catherine) to the group (connecting...)"
             bob <## "#team: new member cath is connected"
         ]
+  where
+    cfg = testCfg {xftpFileConfig = Just $ XFTPFileConfig {minFileSize = 0}, tempDir = Just "./tests/tmp"}
 
 testGroupHistoryQuotes :: HasCallStack => FilePath -> IO ()
 testGroupHistoryQuotes =

tests/ChatTests/Local.hs

@@ -12,6 +12,7 @@ import Simplex.Chat.Controller (ChatConfig (..), InlineFilesConfig (..), default
 import System.Directory (copyFile, doesFileExist)
 import System.FilePath ((</>))
 import Test.Hspec hiding (it)
+import UnliftIO.Async (concurrently_)
 
 chatLocalChatsTests :: SpecWith FilePath
 chatLocalChatsTests = do
@@ -157,24 +158,24 @@ testFiles tmp = withNewTestChat tmp "alice" aliceProfile $ \alice -> do
 
 testOtherFiles :: FilePath -> IO ()
 testOtherFiles =
-  testChatCfg2 cfg aliceProfile bobProfile $ \alice bob -> withXFTPServer $ do
+  testChatCfg2 cfg aliceProfile bobProfile $ \alice bob -> do
     connectUsers alice bob
     createCCNoteFolder bob
     bob ##> "/_files_folder ./tests/tmp/"
     bob <## "ok"
-
-    alice #> "/f @bob ./tests/fixtures/test.jpg"
-    alice <## "use /fc 1 to cancel sending"
+    alice ##> "/_send @2 json {\"msgContent\":{\"type\":\"voice\", \"duration\":10, \"text\":\"\"}, \"filePath\":\"./tests/fixtures/test.jpg\"}"
+    alice <# "@bob voice message (00:10)"
+    alice <# "/f @bob ./tests/fixtures/test.jpg"
+    -- below is not shown in "sent" mode
+    -- alice <## "use /fc 1 to cancel sending"
+    bob <# "alice> voice message (00:10)"
     bob <# "alice> sends file test.jpg (136.5 KiB / 139737 bytes)"
-    bob <## "use /fr 1 [<dir>/ | <path>] to receive it"
-    alice <## "completed uploading file 1 (test.jpg) for bob"
-
-    bob ##> "/fr 1"
-    bob
-      <### [ "saving file 1 from alice to test.jpg",
-              "started receiving file 1 (test.jpg) from alice"
-            ]
-    bob <## "completed receiving file 1 (test.jpg) from alice"
+    -- below is not shown in "sent" mode
+    -- bob <## "use /fr 1 [<dir>/ | <path>] to receive it"
+    bob <## "started receiving file 1 (test.jpg) from alice"
+    concurrently_
+      (alice <## "completed sending file 1 (test.jpg) to bob")
+      (bob <## "completed receiving file 1 (test.jpg) from alice")
 
     bob /* "test"
     bob ##> "/tail *"

tests/ChatTests/Profiles.hs

@@ -1493,7 +1493,7 @@ testSetConnectionAlias = testChat2 aliceProfile bobProfile $
 
 testSetContactPrefs :: HasCallStack => FilePath -> IO ()
 testSetContactPrefs = testChat2 aliceProfile bobProfile $
-  \alice bob -> withXFTPServer $ do
+  \alice bob -> do
     alice #$> ("/_files_folder ./tests/tmp/alice", id, "ok")
     bob #$> ("/_files_folder ./tests/tmp/bob", id, "ok")
     createDirectoryIfMissing True "./tests/tmp/alice"
@@ -1528,24 +1528,15 @@ testSetContactPrefs = testChat2 aliceProfile bobProfile $
     bob #$> ("/_get chat @2 count=100", chat, startFeatures <> [(0, "Voice messages: enabled for you")])
     alice ##> sendVoice
     alice <## voiceNotAllowed
-
-    -- sending voice message allowed
     bob ##> sendVoice
     bob <# "@alice voice message (00:10)"
     bob <# "/f @alice test.txt"
-    bob <## "use /fc 1 to cancel sending"
+    bob <## "completed sending file 1 (test.txt) to alice"
     alice <# "bob> voice message (00:10)"
     alice <# "bob> sends file test.txt (11 bytes / 11 bytes)"
-    alice <## "use /fr 1 [<dir>/ | <path>] to receive it"
-    bob <## "completed uploading file 1 (test.txt) for alice"
-    alice ##> "/fr 1"
-    alice
-      <### [ "saving file 1 from bob to test_1.txt",
-             "started receiving file 1 (test.txt) from bob"
-           ]
+    alice <## "started receiving file 1 (test.txt) from bob"
     alice <## "completed receiving file 1 (test.txt) from bob"
     (bob </)
-
     -- alice ##> "/_profile 1 {\"displayName\": \"alice\", \"fullName\": \"Alice\", \"preferences\": {\"voice\": {\"allow\": \"no\"}}}"
     alice ##> "/set voice no"
     alice <## "updated preferences:"

tests/ChatTests/Utils.hs

@@ -19,7 +19,7 @@ import Data.Maybe (fromMaybe)
 import Data.String
 import qualified Data.Text as T
 import Database.SQLite.Simple (Only (..))
-import Simplex.Chat.Controller (ChatConfig (..), ChatController (..))
+import Simplex.Chat.Controller (ChatConfig (..), ChatController (..), InlineFilesConfig (..), defaultInlineFilesConfig)
 import Simplex.Chat.Protocol
 import Simplex.Chat.Store.NoteFolders (createNoteFolder)
 import Simplex.Chat.Store.Profiles (getUserContactProfiles)
@@ -32,6 +32,7 @@ import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Version
 import System.Directory (doesFileExist)
 import System.Environment (lookupEnv, withArgs)
+import System.FilePath ((</>))
 import System.IO.Silently (capture_)
 import System.Info (os)
 import Test.Hspec hiding (it)
@@ -95,6 +96,29 @@ versionTestMatrix3 runTest = do
   it "curr to prev" $ runTestCfg3 testCfgVPrev testCfg testCfg runTest
   it "curr+prev to prev" $ runTestCfg3 testCfgVPrev testCfg testCfgVPrev runTest
 
+inlineCfg :: Integer -> ChatConfig
+inlineCfg n = testCfg {inlineFiles = defaultInlineFilesConfig {sendChunks = 0, offerChunks = n, receiveChunks = n}}
+
+fileTestMatrix2 :: (HasCallStack => TestCC -> TestCC -> IO ()) -> SpecWith FilePath
+fileTestMatrix2 runTest = do
+  it "via connection" $ runTestCfg2 viaConn viaConn runTest
+  it "inline (accepting)" $ runTestCfg2 inline inline runTest
+  it "via connection (inline offered)" $ runTestCfg2 inline viaConn runTest
+  it "via connection (inline supported)" $ runTestCfg2 viaConn inline runTest
+  where
+    inline = inlineCfg 100
+    viaConn = inlineCfg 0
+
+fileTestMatrix3 :: (HasCallStack => TestCC -> TestCC -> TestCC -> IO ()) -> SpecWith FilePath
+fileTestMatrix3 runTest = do
+  it "via connection" $ runTestCfg3 viaConn viaConn viaConn runTest
+  it "inline" $ runTestCfg3 inline inline inline runTest
+  it "via connection (inline offered)" $ runTestCfg3 inline viaConn viaConn runTest
+  it "via connection (inline supported)" $ runTestCfg3 viaConn inline inline runTest
+  where
+    inline = inlineCfg 100
+    viaConn = inlineCfg 0
+
 runTestCfg2 :: ChatConfig -> ChatConfig -> (HasCallStack => TestCC -> TestCC -> IO ()) -> FilePath -> IO ()
 runTestCfg2 aliceCfg bobCfg runTest tmp =
   withNewTestChatCfg tmp aliceCfg "alice" aliceProfile $ \alice ->
@@ -571,6 +595,20 @@ checkActionDeletesFile file action = do
   fileExistsAfter <- doesFileExist file
   fileExistsAfter `shouldBe` False
 
+startFileTransferWithDest' :: HasCallStack => TestCC -> TestCC -> String -> String -> Maybe String -> IO ()
+startFileTransferWithDest' cc1 cc2 fileName fileSize fileDest_ = do
+  name1 <- userName cc1
+  name2 <- userName cc2
+  cc1 #> ("/f @" <> name2 <> " ./tests/fixtures/" <> fileName)
+  cc1 <## "use /fc 1 to cancel sending"
+  cc2 <# (name1 <> "> sends file " <> fileName <> " (" <> fileSize <> ")")
+  cc2 <## "use /fr 1 [<dir>/ | <path>] to receive it"
+  cc2 ##> ("/fr 1" <> maybe "" (" " <>) fileDest_)
+  cc2 <## ("saving file 1 from " <> name1 <> " to " <> maybe id (</>) fileDest_ fileName)
+  concurrently_
+    (cc2 <## ("started receiving file 1 (" <> fileName <> ") from " <> name1))
+    (cc1 <## ("started sending file 1 (" <> fileName <> ") to " <> name2))
+
 currentChatVRangeInfo :: String
 currentChatVRangeInfo =
   "peer chat protocol version range: " <> vRangeStr supportedChatVRange

tests/RemoteTests.hs

@@ -13,7 +13,7 @@ import qualified Data.ByteString as B
 import qualified Data.ByteString.Lazy.Char8 as LB
 import qualified Data.Map.Strict as M
 import Simplex.Chat.Archive (archiveFilesFolder)
-import Simplex.Chat.Controller (versionNumber)
+import Simplex.Chat.Controller (ChatConfig (..), XFTPFileConfig (..), versionNumber)
 import qualified Simplex.Chat.Controller as Controller
 import Simplex.Chat.Mobile.File
 import Simplex.Chat.Remote.Types
@@ -194,7 +194,7 @@ remoteMessageTest = testChat3 aliceProfile aliceDesktopProfile bobProfile $ \mob
 
 remoteStoreFileTest :: HasCallStack => FilePath -> IO ()
 remoteStoreFileTest =
-  testChat3 aliceProfile aliceDesktopProfile bobProfile $ \mobile desktop bob ->
+  testChatCfg3 cfg aliceProfile aliceDesktopProfile bobProfile $ \mobile desktop bob ->
     withXFTPServer $ do
       let mobileFiles = "./tests/tmp/mobile_files"
       mobile ##> ("/_files_folder " <> mobileFiles)
@@ -317,13 +317,15 @@ remoteStoreFileTest =
 
       stopMobile mobile desktop
   where
+    cfg = testCfg {xftpFileConfig = Just $ XFTPFileConfig {minFileSize = 0}, tempDir = Just "./tests/tmp/tmp"}
     hostError cc err = do
       r <- getTermLine cc
       r `shouldStartWith` "remote host 1 error"
       r `shouldContain` err
 
 remoteCLIFileTest :: HasCallStack => FilePath -> IO ()
-remoteCLIFileTest = testChat3 aliceProfile aliceDesktopProfile bobProfile $ \mobile desktop bob -> withXFTPServer $ do
+remoteCLIFileTest = testChatCfg3 cfg aliceProfile aliceDesktopProfile bobProfile $ \mobile desktop bob -> withXFTPServer $ do
+  createDirectoryIfMissing True "./tests/tmp/tmp/"
   let mobileFiles = "./tests/tmp/mobile_files"
   mobile ##> ("/_files_folder " <> mobileFiles)
   mobile <## "ok"
@@ -390,6 +392,8 @@ remoteCLIFileTest = testChat3 aliceProfile aliceDesktopProfile bobProfile $ \mob
   B.readFile (bobFiles </> "test.jpg") `shouldReturn` src'
 
   stopMobile mobile desktop
+  where
+    cfg = testCfg {xftpFileConfig = Just $ XFTPFileConfig {minFileSize = 0}, tempDir = Just "./tests/tmp/tmp"}
 
 switchRemoteHostTest :: FilePath -> IO ()
 switchRemoteHostTest = testChat3 aliceProfile aliceDesktopProfile bobProfile $ \mobile desktop bob -> do