Refactoring

submodules/CallListUI/Sources/CallListControllerNode.swift

@@ -384,6 +384,7 @@ final class CallListControllerNode: ASDisplayNode {
             let disposable = strongSelf.openGroupCallDisposable
             
             let account = strongSelf.context.account
+            let engine = strongSelf.context.engine
             var signal: Signal<CachedChannelData.ActiveCall?, NoError> = strongSelf.context.account.postbox.transaction { transaction -> CachedChannelData.ActiveCall? in
                 let cachedData = transaction.getPeerCachedData(peerId: peerId)
                 if let cachedData = cachedData as? CachedChannelData {
@@ -397,7 +398,7 @@ final class CallListControllerNode: ASDisplayNode {
                 if let activeCall = activeCall {
                     return .single(activeCall)
                 } else {
-                    return updatedCurrentPeerGroupCall(account: account, peerId: peerId)
+                    return engine.calls.updatedCurrentPeerGroupCall(peerId: peerId)
                 }
             }
             

submodules/ChatListUI/Sources/ChatContextMenus.swift

@@ -49,141 +49,162 @@ enum ChatContextMenuSource {
 func chatContextMenuItems(context: AccountContext, peerId: PeerId, promoInfo: ChatListNodeEntryPromoInfo?, source: ChatContextMenuSource, chatListController: ChatListControllerImpl?, joined: Bool) -> Signal<[ContextMenuItem], NoError> {
     let presentationData = context.sharedContext.currentPresentationData.with({ $0 })
     let strings = presentationData.strings
-    return context.account.postbox.transaction { [weak chatListController] transaction -> [ContextMenuItem] in
-        if promoInfo != nil {
-            return []
-        }
-        
-        var items: [ContextMenuItem] = []
-        
-        if case let .search(search) = source {
-            switch search {
-            case .recentPeers:
-                items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_RemoveFromRecents, textColor: .destructive, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Clear"), color: theme.contextMenu.destructiveColor) }, action: { _, f in
-                    let _ = (context.engine.peers.removeRecentPeer(peerId: peerId)
-                    |> deliverOnMainQueue).start(completed: {
-                        f(.default)
-                    })
-                })))
-                items.append(.separator)
-            case .recentSearch:
-                items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_RemoveFromRecents, textColor: .destructive, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Clear"), color: theme.contextMenu.destructiveColor) }, action: { _, f in
-                    let _ = (context.engine.peers.removeRecentlySearchedPeer(peerId: peerId)
-                    |> deliverOnMainQueue).start(completed: {
-                        f(.default)
-                    })
-                })))
-                items.append(.separator)
-            case .search:
-                break
-            }
-        }
-        
-        let isSavedMessages = peerId == context.account.peerId
-        
-        let chatPeer = transaction.getPeer(peerId)
-        var maybePeer: Peer?
-        if let chatPeer = chatPeer {
-            if let chatPeer = chatPeer as? TelegramSecretChat {
-                maybePeer = transaction.getPeer(chatPeer.regularPeerId)
+
+    return context.account.postbox.transaction { transaction -> (PeerGroupId, ChatListIndex)? in
+        transaction.getPeerChatListIndex(peerId)
+    }
+    |> mapToSignal { groupAndIndex -> Signal<[ContextMenuItem], NoError> in
+        let location: TogglePeerChatPinnedLocation
+        var chatListFilter: ChatListFilter?
+        if case let .chatList(filter) = source, let chatFilter = filter {
+            chatListFilter = chatFilter
+            location = .filter(chatFilter.id)
+        } else {
+            if let (group, _) = groupAndIndex {
+                location = .group(group)
             } else {
-                maybePeer = chatPeer
-            }
-        }
-        
-        guard let peer = maybePeer else {
-            return []
-        }
-        
-        if !isSavedMessages, let peer = peer as? TelegramUser, !peer.flags.contains(.isSupport) && peer.botInfo == nil && !peer.isDeleted {
-            if !transaction.isPeerContact(peerId: peer.id) {
-                items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_AddToContacts, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/AddUser"), color: theme.contextMenu.primaryColor) }, action: { _, f in
-                    context.sharedContext.openAddPersonContact(context: context, peerId: peerId, pushController: { controller in
-                        if let navigationController = chatListController?.navigationController as? NavigationController {
-                            navigationController.pushViewController(controller)
-                        }
-                    }, present: { c, a in
-                        if let chatListController = chatListController {
-                            chatListController.present(c, in: .window(.root), with: a)
-                        }
-                    })
-                    f(.default)
-                })))
-                items.append(.separator)
-            }
-        }
-        
-        var isMuted = false
-        if let notificationSettings = transaction.getPeerNotificationSettings(peerId) as? TelegramPeerNotificationSettings {
-            if case .muted = notificationSettings.muteState {
-                isMuted = true
+                location = .group(.root)
             }
         }
 
-        var isUnread = false
-        if let readState = transaction.getCombinedPeerReadState(peerId), readState.isUnread {
-            isUnread = true
-        }
-        
-        let isContact = transaction.isPeerContact(peerId: peerId)
-        
-        if case let .chatList(currentFilter) = source {
-            if let currentFilter = currentFilter {
-                items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_RemoveFromFolder, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/RemoveFromFolder"), color: theme.contextMenu.primaryColor) }, action: { c, _ in
-                    let _ = (context.account.postbox.transaction { transaction -> Void in
-                        updateChatListFiltersInteractively(transaction: transaction, { filters in
-                            var filters = filters
-                            for i in 0 ..< filters.count {
-                                if filters[i].id == currentFilter.id {
-                                    let _ = filters[i].data.addExcludePeer(peerId: peer.id)
-                                    break
+        return combineLatest(
+            context.engine.peers.updatedChatListFilters()
+            |> take(1),
+            context.engine.peers.getPinnedItemIds(location: location)
+        )
+        |> mapToSignal { filters, pinnedItemIds -> Signal<[ContextMenuItem], NoError> in
+            let isPinned = pinnedItemIds.contains(.peer(peerId))
+
+            return context.account.postbox.transaction { [weak chatListController] transaction -> [ContextMenuItem] in
+                if promoInfo != nil {
+                    return []
+                }
+
+                var items: [ContextMenuItem] = []
+
+                if case let .search(search) = source {
+                    switch search {
+                    case .recentPeers:
+                        items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_RemoveFromRecents, textColor: .destructive, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Clear"), color: theme.contextMenu.destructiveColor) }, action: { _, f in
+                            let _ = (context.engine.peers.removeRecentPeer(peerId: peerId)
+                            |> deliverOnMainQueue).start(completed: {
+                                f(.default)
+                            })
+                        })))
+                        items.append(.separator)
+                    case .recentSearch:
+                        items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_RemoveFromRecents, textColor: .destructive, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Clear"), color: theme.contextMenu.destructiveColor) }, action: { _, f in
+                            let _ = (context.engine.peers.removeRecentlySearchedPeer(peerId: peerId)
+                            |> deliverOnMainQueue).start(completed: {
+                                f(.default)
+                            })
+                        })))
+                        items.append(.separator)
+                    case .search:
+                        break
+                    }
+                }
+
+                let isSavedMessages = peerId == context.account.peerId
+
+                let chatPeer = transaction.getPeer(peerId)
+                var maybePeer: Peer?
+                if let chatPeer = chatPeer {
+                    if let chatPeer = chatPeer as? TelegramSecretChat {
+                        maybePeer = transaction.getPeer(chatPeer.regularPeerId)
+                    } else {
+                        maybePeer = chatPeer
+                    }
+                }
+
+                guard let peer = maybePeer else {
+                    return []
+                }
+
+                if !isSavedMessages, let peer = peer as? TelegramUser, !peer.flags.contains(.isSupport) && peer.botInfo == nil && !peer.isDeleted {
+                    if !transaction.isPeerContact(peerId: peer.id) {
+                        items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_AddToContacts, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/AddUser"), color: theme.contextMenu.primaryColor) }, action: { _, f in
+                            context.sharedContext.openAddPersonContact(context: context, peerId: peerId, pushController: { controller in
+                                if let navigationController = chatListController?.navigationController as? NavigationController {
+                                    navigationController.pushViewController(controller)
                                 }
+                            }, present: { c, a in
+                                if let chatListController = chatListController {
+                                    chatListController.present(c, in: .window(.root), with: a)
+                                }
+                            })
+                            f(.default)
+                        })))
+                        items.append(.separator)
+                    }
+                }
+
+                var isMuted = false
+                if let notificationSettings = transaction.getPeerNotificationSettings(peerId) as? TelegramPeerNotificationSettings {
+                    if case .muted = notificationSettings.muteState {
+                        isMuted = true
+                    }
+                }
+
+                var isUnread = false
+                if let readState = transaction.getCombinedPeerReadState(peerId), readState.isUnread {
+                    isUnread = true
+                }
+
+                let isContact = transaction.isPeerContact(peerId: peerId)
+
+                if case let .chatList(currentFilter) = source {
+                    if let currentFilter = currentFilter {
+                        items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_RemoveFromFolder, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/RemoveFromFolder"), color: theme.contextMenu.primaryColor) }, action: { c, _ in
+                            let _ = (context.engine.peers.updateChatListFiltersInteractively { filters in
+                                var filters = filters
+                                for i in 0 ..< filters.count {
+                                    if filters[i].id == currentFilter.id {
+                                        let _ = filters[i].data.addExcludePeer(peerId: peer.id)
+                                        break
+                                    }
+                                }
+                                return filters
+                            }
+                            |> deliverOnMainQueue).start(completed: {
+                                c.dismiss(completion: {
+                                    chatListController?.present(UndoOverlayController(presentationData: presentationData, content: .chatRemovedFromFolder(chatTitle: peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder), folderTitle: currentFilter.title), elevatedLayout: false, animateInAsReplacement: true, action: { _ in
+                                        return false
+                                    }), in: .current)
+                                })
+                            })
+                        })))
+                    } else {
+                        var hasFolders = false
+
+                        for filter in filters {
+                            let predicate = chatListFilterPredicate(filter: filter.data)
+                            if predicate.includes(peer: peer, groupId: .root, isRemovedFromTotalUnreadCount: isMuted, isUnread: isUnread, isContact: isContact, messageTagSummaryResult: false) {
+                                continue
+                            }
+
+                            var data = filter.data
+                            if data.addIncludePeer(peerId: peer.id) {
+                                hasFolders = true
+                                break
                             }
-                            return filters
-                        })
-                    }
-                    |> deliverOnMainQueue).start(completed: {
-                        c.dismiss(completion: {
-                            chatListController?.present(UndoOverlayController(presentationData: presentationData, content: .chatRemovedFromFolder(chatTitle: peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder), folderTitle: currentFilter.title), elevatedLayout: false, animateInAsReplacement: true, action: { _ in
-                                return false
-                            }), in: .current)
-                        })
-                    })
-                })))
-            } else {
-                var hasFolders = false
-                updateChatListFiltersInteractively(transaction: transaction, { filters in
-                    for filter in filters {
-                        let predicate = chatListFilterPredicate(filter: filter.data)
-                        if predicate.includes(peer: peer, groupId: .root, isRemovedFromTotalUnreadCount: isMuted, isUnread: isUnread, isContact: isContact, messageTagSummaryResult: false) {
-                            continue
                         }
-                        
-                        var data = filter.data
-                        if data.addIncludePeer(peerId: peer.id) {
-                            hasFolders = true
-                            break
-                        }
-                    }
-                    return filters
-                })
-                
-                if hasFolders {
-                    items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_AddToFolder, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Folder"), color: theme.contextMenu.primaryColor) }, action: { c, _ in
-                        let _ = (context.account.postbox.transaction { transaction -> [ContextMenuItem] in
-                            var updatedItems: [ContextMenuItem] = []
-                            updateChatListFiltersInteractively(transaction: transaction, { filters in
+
+                        if hasFolders {
+                            items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_AddToFolder, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Folder"), color: theme.contextMenu.primaryColor) }, action: { c, _ in
+                                var updatedItems: [ContextMenuItem] = []
+
                                 for filter in filters {
                                     let predicate = chatListFilterPredicate(filter: filter.data)
                                     if predicate.includes(peer: peer, groupId: .root, isRemovedFromTotalUnreadCount: isMuted, isUnread: isUnread, isContact: isContact, messageTagSummaryResult: false) {
                                         continue
                                     }
-                                    
+
                                     var data = filter.data
                                     if !data.addIncludePeer(peerId: peer.id) {
                                         continue
                                     }
-                                    
+
                                     let filterType = chatListFilterType(filter)
                                     updatedItems.append(.action(ContextMenuActionItem(text: filter.title, icon: { theme in
                                         let imageName: String
@@ -208,7 +229,7 @@ func chatContextMenuItems(context: AccountContext, peerId: PeerId, promoInfo: Ch
                                         return generateTintedImage(image: UIImage(bundleImageName: imageName), color: theme.contextMenu.primaryColor)
                                     }, action: { c, f in
                                         c.dismiss(completion: {
-                                            let _ = (updateChatListFiltersInteractively(postbox: context.account.postbox, { filters in
+                                            let _ = (context.engine.peers.updateChatListFiltersInteractively { filters in
                                                 var filters = filters
                                                 for i in 0 ..< filters.count {
                                                     if filters[i].id == filter.id {
@@ -217,180 +238,160 @@ func chatContextMenuItems(context: AccountContext, peerId: PeerId, promoInfo: Ch
                                                     }
                                                 }
                                                 return filters
-                                            })).start()
-                                            
+                                            }).start()
+
                                             chatListController?.present(UndoOverlayController(presentationData: presentationData, content: .chatAddedToFolder(chatTitle: peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder), folderTitle: filter.title), elevatedLayout: false, animateInAsReplacement: true, action: { _ in
                                                 return false
                                             }), in: .current)
                                         })
                                     })))
                                 }
-                                
-                                return filters
-                            })
-                            
-                            updatedItems.append(.separator)
-                            updatedItems.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_Back, icon: { theme in
-                                return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Back"), color: theme.contextMenu.primaryColor)
-                            }, action: { c, _ in
-                                c.setItems(chatContextMenuItems(context: context, peerId: peerId, promoInfo: promoInfo, source: source, chatListController: chatListController, joined: joined))
+
+                                updatedItems.append(.separator)
+                                updatedItems.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_Back, icon: { theme in
+                                    return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Back"), color: theme.contextMenu.primaryColor)
+                                }, action: { c, _ in
+                                    c.setItems(chatContextMenuItems(context: context, peerId: peerId, promoInfo: promoInfo, source: source, chatListController: chatListController, joined: joined))
+                                })))
+
+                                c.setItems(.single(updatedItems))
                             })))
-                            
-                            return updatedItems
                         }
-                        |> deliverOnMainQueue).start(next: { updatedItems in
-                            c.setItems(.single(updatedItems))
-                        })
+                    }
+                }
+
+                if isUnread {
+                    items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_MarkAsRead, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/MarkAsRead"), color: theme.contextMenu.primaryColor) }, action: { _, f in
+                        let _ = togglePeerUnreadMarkInteractively(postbox: context.account.postbox, viewTracker: context.account.viewTracker, peerId: peerId).start()
+                        f(.default)
+                    })))
+                } else {
+                    items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_MarkAsUnread, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/MarkAsUnread"), color: theme.contextMenu.primaryColor) }, action: { _, f in
+                        let _ = togglePeerUnreadMarkInteractively(postbox: context.account.postbox, viewTracker: context.account.viewTracker, peerId: peerId).start()
+                        f(.default)
                     })))
                 }
-            }
-        }
-        
-        if isUnread {
-            items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_MarkAsRead, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/MarkAsRead"), color: theme.contextMenu.primaryColor) }, action: { _, f in
-                let _ = togglePeerUnreadMarkInteractively(postbox: context.account.postbox, viewTracker: context.account.viewTracker, peerId: peerId).start()
-                f(.default)
-            })))
-        } else {
-            items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_MarkAsUnread, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/MarkAsUnread"), color: theme.contextMenu.primaryColor) }, action: { _, f in
-                let _ = togglePeerUnreadMarkInteractively(postbox: context.account.postbox, viewTracker: context.account.viewTracker, peerId: peerId).start()
-                f(.default)
-            })))
-        }
-        
-        let groupAndIndex = transaction.getPeerChatListIndex(peerId)
-        
-        let archiveEnabled = !isSavedMessages && peerId != PeerId(namespace: Namespaces.Peer.CloudUser, id: PeerId.Id._internalFromInt32Value(777000)) && peerId == context.account.peerId
-        if let (group, index) = groupAndIndex {
-            if archiveEnabled {
-                let isArchived = group == Namespaces.PeerGroup.archive
-                items.append(.action(ContextMenuActionItem(text: isArchived ? strings.ChatList_Context_Unarchive : strings.ChatList_Context_Archive, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: isArchived ? "Chat/Context Menu/Unarchive" : "Chat/Context Menu/Archive"), color: theme.contextMenu.primaryColor) }, action: { _, f in
-                    if isArchived {
-                        let _ = (context.account.postbox.transaction { transaction -> Void in
-                            updatePeerGroupIdInteractively(transaction: transaction, peerId: peerId, groupId: .root)
-                            }
-                        |> deliverOnMainQueue).start(completed: {
-                            f(.default)
-                        })
-                    } else {
-                        if let chatListController = chatListController {
-                            chatListController.archiveChats(peerIds: [peerId])
-                            f(.default)
-                        } else {
-                            let _ = (context.account.postbox.transaction { transaction -> Void in
-                                updatePeerGroupIdInteractively(transaction: transaction, peerId: peerId, groupId: Namespaces.PeerGroup.archive)
+
+                let archiveEnabled = !isSavedMessages && peerId != PeerId(namespace: Namespaces.Peer.CloudUser, id: PeerId.Id._internalFromInt32Value(777000)) && peerId == context.account.peerId
+                if let (group, index) = groupAndIndex {
+                    if archiveEnabled {
+                        let isArchived = group == Namespaces.PeerGroup.archive
+                        items.append(.action(ContextMenuActionItem(text: isArchived ? strings.ChatList_Context_Unarchive : strings.ChatList_Context_Archive, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: isArchived ? "Chat/Context Menu/Unarchive" : "Chat/Context Menu/Archive"), color: theme.contextMenu.primaryColor) }, action: { _, f in
+                            if isArchived {
+                                let _ = (context.account.postbox.transaction { transaction -> Void in
+                                    updatePeerGroupIdInteractively(transaction: transaction, peerId: peerId, groupId: .root)
+                                    }
+                                |> deliverOnMainQueue).start(completed: {
+                                    f(.default)
+                                })
+                            } else {
+                                if let chatListController = chatListController {
+                                    chatListController.archiveChats(peerIds: [peerId])
+                                    f(.default)
+                                } else {
+                                    let _ = (context.account.postbox.transaction { transaction -> Void in
+                                        updatePeerGroupIdInteractively(transaction: transaction, peerId: peerId, groupId: Namespaces.PeerGroup.archive)
+                                    }
+                                    |> deliverOnMainQueue).start(completed: {
+                                        f(.default)
+                                    })
+                                }
                             }
+                        })))
+                    }
+
+                    if isPinned || chatListFilter == nil || peerId.namespace != Namespaces.Peer.SecretChat {
+                        items.append(.action(ContextMenuActionItem(text: isPinned ? strings.ChatList_Context_Unpin : strings.ChatList_Context_Pin, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: isPinned ? "Chat/Context Menu/Unpin" : "Chat/Context Menu/Pin"), color: theme.contextMenu.primaryColor) }, action: { _, f in
+                            let _ = (context.engine.peers.toggleItemPinned(location: location, itemId: .peer(peerId))
+                            |> deliverOnMainQueue).start(next: { result in
+                                switch result {
+                                case .done:
+                                    break
+                                case .limitExceeded:
+                                    break
+                                }
+                                f(.default)
+                            })
+                        })))
+                    }
+
+                    if !isSavedMessages, let notificationSettings = transaction.getPeerNotificationSettings(peerId) as? TelegramPeerNotificationSettings {
+                        var isMuted = false
+                        if case .muted = notificationSettings.muteState {
+                            isMuted = true
+                        }
+                        items.append(.action(ContextMenuActionItem(text: isMuted ? strings.ChatList_Context_Unmute : strings.ChatList_Context_Mute, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: isMuted ? "Chat/Context Menu/Unmute" : "Chat/Context Menu/Muted"), color: theme.contextMenu.primaryColor) }, action: { _, f in
+                            let _ = (context.engine.peers.togglePeerMuted(peerId: peerId)
                             |> deliverOnMainQueue).start(completed: {
                                 f(.default)
                             })
+                        })))
+                    }
+                } else {
+                    if case .search = source {
+                        if let _ = peer as? TelegramChannel {
+                            items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_JoinChannel, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Add"), color: theme.contextMenu.primaryColor) }, action: { _, f in
+                                var createSignal = context.peerChannelMemberCategoriesContextsManager.join(engine: context.engine, peerId: peerId, hash: nil)
+                                var cancelImpl: (() -> Void)?
+                                let progressSignal = Signal<Never, NoError> { subscriber in
+                                    let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                                    let controller = OverlayStatusController(theme: presentationData.theme, type: .loading(cancelled: {
+                                        cancelImpl?()
+                                    }))
+                                    chatListController?.present(controller, in: .window(.root))
+                                    return ActionDisposable { [weak controller] in
+                                        Queue.mainQueue().async() {
+                                            controller?.dismiss()
+                                        }
+                                    }
+                                }
+                                |> runOn(Queue.mainQueue())
+                                |> delay(0.15, queue: Queue.mainQueue())
+                                let progressDisposable = progressSignal.start()
+
+                                createSignal = createSignal
+                                |> afterDisposed {
+                                    Queue.mainQueue().async {
+                                        progressDisposable.dispose()
+                                    }
+                                }
+                                let joinChannelDisposable = MetaDisposable()
+                                cancelImpl = {
+                                    joinChannelDisposable.set(nil)
+                                }
+
+                                joinChannelDisposable.set((createSignal
+                                |> deliverOnMainQueue).start(next: { _ in
+                                    if let navigationController = (chatListController?.navigationController as? NavigationController) {
+                                        context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peerId)))
+                                    }
+                                }, error: { _ in
+                                    if let chatListController = chatListController {
+                                        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                                        chatListController.present(textAlertController(context: context, title: nil, text: presentationData.strings.Login_UnknownError, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})]), in: .window(.root))
+                                    }
+                                }))
+                                f(.default)
+                            })))
                         }
                     }
-                })))
-            }
-            
-//            if  {
-                let location: TogglePeerChatPinnedLocation
-                var chatListFilter: ChatListFilter?
-                if case let .chatList(filter) = source, let chatFilter = filter {
-                    chatListFilter = chatFilter
-                    location = .filter(chatFilter.id)
-                } else {
-                    location = .group(group)
                 }
-                
-                let isPinned = getPinnedItemIds(transaction: transaction, location: location).contains(.peer(peerId))
-                
-                if isPinned || chatListFilter == nil || peerId.namespace != Namespaces.Peer.SecretChat {
-                    items.append(.action(ContextMenuActionItem(text: isPinned ? strings.ChatList_Context_Unpin : strings.ChatList_Context_Pin, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: isPinned ? "Chat/Context Menu/Unpin" : "Chat/Context Menu/Pin"), color: theme.contextMenu.primaryColor) }, action: { _, f in
-                        let _ = (toggleItemPinned(postbox: context.account.postbox, location: location, itemId: .peer(peerId))
-                        |> deliverOnMainQueue).start(next: { result in
-                            switch result {
-                            case .done:
-                                break
-                            case .limitExceeded:
-                                break
-                            }
-                            f(.default)
-                        })
-                    })))
-                }
-//            }
-        
-            if !isSavedMessages, let notificationSettings = transaction.getPeerNotificationSettings(peerId) as? TelegramPeerNotificationSettings {
-                var isMuted = false
-                if case .muted = notificationSettings.muteState {
-                    isMuted = true
-                }
-                items.append(.action(ContextMenuActionItem(text: isMuted ? strings.ChatList_Context_Unmute : strings.ChatList_Context_Mute, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: isMuted ? "Chat/Context Menu/Unmute" : "Chat/Context Menu/Muted"), color: theme.contextMenu.primaryColor) }, action: { _, f in
-                    let _ = (context.engine.peers.togglePeerMuted(peerId: peerId)
-                    |> deliverOnMainQueue).start(completed: {
-                        f(.default)
-                    })
-                })))
-            }
-        } else {
-            if case .search = source {
-                if let _ = peer as? TelegramChannel {
-                    items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_JoinChannel, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Add"), color: theme.contextMenu.primaryColor) }, action: { _, f in
-                        var createSignal = context.peerChannelMemberCategoriesContextsManager.join(engine: context.engine, peerId: peerId, hash: nil)
-                        var cancelImpl: (() -> Void)?
-                        let progressSignal = Signal<Never, NoError> { subscriber in
-                            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
-                            let controller = OverlayStatusController(theme: presentationData.theme, type: .loading(cancelled: {
-                                cancelImpl?()
-                            }))
-                            chatListController?.present(controller, in: .window(.root))
-                            return ActionDisposable { [weak controller] in
-                                Queue.mainQueue().async() {
-                                    controller?.dismiss()
-                                }
-                            }
+
+                if case .chatList = source, groupAndIndex != nil {
+                    items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_Delete, textColor: .destructive, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Delete"), color: theme.contextMenu.destructiveColor) }, action: { _, f in
+                        if let chatListController = chatListController {
+                            chatListController.deletePeerChat(peerId: peerId, joined: joined)
                         }
-                        |> runOn(Queue.mainQueue())
-                        |> delay(0.15, queue: Queue.mainQueue())
-                        let progressDisposable = progressSignal.start()
-                        
-                        createSignal = createSignal
-                        |> afterDisposed {
-                            Queue.mainQueue().async {
-                                progressDisposable.dispose()
-                            }
-                        }
-                        let joinChannelDisposable = MetaDisposable()
-                        cancelImpl = {
-                            joinChannelDisposable.set(nil)
-                        }
-                        
-                        joinChannelDisposable.set((createSignal
-                        |> deliverOnMainQueue).start(next: { _ in
-                            if let navigationController = (chatListController?.navigationController as? NavigationController) {
-                                context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peerId)))
-                            }
-                        }, error: { _ in
-                            if let chatListController = chatListController {
-                                let presentationData = context.sharedContext.currentPresentationData.with { $0 }
-                                chatListController.present(textAlertController(context: context, title: nil, text: presentationData.strings.Login_UnknownError, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})]), in: .window(.root))
-                            }
-                        }))
                         f(.default)
                     })))
                 }
+
+                if let item = items.last, case .separator = item {
+                    items.removeLast()
+                }
+
+                return items
             }
         }
-        
-        if case .chatList = source, groupAndIndex != nil {
-            items.append(.action(ContextMenuActionItem(text: strings.ChatList_Context_Delete, textColor: .destructive, icon: { theme in generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Delete"), color: theme.contextMenu.destructiveColor) }, action: { _, f in
-                if let chatListController = chatListController {
-                    chatListController.deletePeerChat(peerId: peerId, joined: joined)
-                }
-                f(.default)
-            })))
-        }
-        
-        if let item = items.last, case .separator = item {
-            items.removeLast()
-        }
-        
-        return items
     }
 }

submodules/ChatListUI/Sources/ChatListController.swift

@@ -892,7 +892,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
         })
         |> mapToSignal { selectedPeerIdsAndFilterId -> Signal<(ChatListSelectionOptions, Set<PeerId>)?, NoError> in
             if let (selectedPeerIds, filterId) = selectedPeerIdsAndFilterId {
-                return chatListSelectionOptions(postbox: context.account.postbox, peerIds: selectedPeerIds, filterId: filterId)
+                return chatListSelectionOptions(context: context, peerIds: selectedPeerIds, filterId: filterId)
                 |> map { options -> (ChatListSelectionOptions, Set<PeerId>)? in
                     return (options, selectedPeerIds)
                 }
@@ -982,7 +982,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
             guard let strongSelf = self else {
                 return
             }
-            let _ = (currentChatListFilters(postbox: strongSelf.context.account.postbox)
+            let _ = (strongSelf.context.engine.peers.currentChatListFilters()
             |> deliverOnMainQueue).start(next: { [weak self] filters in
                 guard let strongSelf = self else {
                     return
@@ -996,7 +996,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
                             guard let strongSelf = self else {
                                 return
                             }
-                            let _ = (currentChatListFilters(postbox: strongSelf.context.account.postbox)
+                            let _ = (strongSelf.context.engine.peers.currentChatListFilters()
                             |> deliverOnMainQueue).start(next: { presetList in
                                 guard let strongSelf = self else {
                                     return
@@ -1024,7 +1024,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
                                 guard let strongSelf = self else {
                                     return
                                 }
-                                let _ = (currentChatListFilters(postbox: strongSelf.context.account.postbox)
+                                let _ = (strongSelf.context.engine.peers.currentChatListFilters()
                                 |> deliverOnMainQueue).start(next: { presetList in
                                     guard let strongSelf = self else {
                                         return
@@ -1032,7 +1032,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
                                     var found = false
                                     for filter in presetList {
                                         if filter.id == id {
-                                            let _ = (currentChatListFilters(postbox: strongSelf.context.account.postbox)
+                                            let _ = (strongSelf.context.engine.peers.currentChatListFilters()
                                             |> deliverOnMainQueue).start(next: { filters in
                                                 guard let strongSelf = self else {
                                                     return
@@ -1300,7 +1300,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
             }
             |> take(1)
             
-            let initializedFilters = updatedChatListFiltersInfo(postbox: self.context.account.postbox)
+            let initializedFilters = self.context.engine.peers.updatedChatListFiltersInfo()
             |> mapToSignal { (filters, isInitialized) -> Signal<Bool, NoError> in
                 if isInitialized {
                     return .single(!filters.isEmpty)
@@ -1336,7 +1336,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
                             let text: String
                             if hasFilters {
                                 text = strongSelf.presentationData.strings.ChatList_TabIconFoldersTooltipNonEmptyFolders
-                                let _ = markChatListFeaturedFiltersAsSeen(postbox: strongSelf.context.account.postbox).start()
+                                let _ = strongSelf.context.engine.peers.markChatListFeaturedFiltersAsSeen().start()
                                 return
                             } else {
                                 text = strongSelf.presentationData.strings.ChatList_TabIconFoldersTooltipEmptyFolders
@@ -1495,7 +1495,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
         }
         
         if let reorderedFilterIds = reorderedFilterIdsValue {
-            let _ = (updateChatListFiltersInteractively(postbox: self.context.account.postbox, { stateFilters in
+            let _ = (self.context.engine.peers.updateChatListFiltersInteractively { stateFilters in
                 var updatedFilters: [ChatListFilter] = []
                 for id in reorderedFilterIds {
                     if let index = stateFilters.firstIndex(where: { $0.id == id }) {
@@ -1510,7 +1510,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
                     }
                 })
                 return updatedFilters
-            })
+            }
             |> deliverOnMainQueue).start(completed: { [weak self] in
                 guard let strongSelf = self else {
                     return
@@ -1543,7 +1543,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
         }
         |> distinctUntilChanged
         
-        let filterItems = chatListFilterItems(postbox: self.context.account.postbox)
+        let filterItems = chatListFilterItems(context: self.context)
         var notifiedFirstUpdate = false
         self.filterDisposable.set((combineLatest(queue: .mainQueue(),
                 context.account.postbox.combinedView(keys: [
@@ -1652,7 +1652,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
             }
         }
         
-        let _ = (currentChatListFilters(postbox: self.context.account.postbox)
+        let _ = (self.context.engine.peers.currentChatListFilters()
         |> deliverOnMainQueue).start(next: { [weak self] filters in
             guard let strongSelf = self else {
                 return
@@ -1709,7 +1709,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
                             }
                         }
                         
-                        let _ = updateChatListFiltersInteractively(postbox: strongSelf.context.account.postbox, { filters in
+                        let _ = (strongSelf.context.engine.peers.updateChatListFiltersInteractively { filters in
                             return filters.filter({ $0.id != id })
                         }).start()
                     }
@@ -2765,8 +2765,8 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
     
     override public func tabBarItemContextAction(sourceNode: ContextExtractedContentContainingNode, gesture: ContextGesture) {
         let _ = (combineLatest(queue: .mainQueue(),
-            currentChatListFilters(postbox: self.context.account.postbox),
-            chatListFilterItems(postbox: self.context.account.postbox)
+            self.context.engine.peers.currentChatListFilters(),
+            chatListFilterItems(context: self.context)
             |> take(1)
         )
         |> deliverOnMainQueue).start(next: { [weak self] presetList, filterItemsAndTotalCount in
@@ -2774,7 +2774,7 @@ public class ChatListControllerImpl: TelegramBaseController, ChatListController
                 return
             }
             
-            let _ = markChatListFeaturedFiltersAsSeen(postbox: strongSelf.context.account.postbox).start()
+            let _ = strongSelf.context.engine.peers.markChatListFeaturedFiltersAsSeen().start()
             
             let (_, filterItems) = filterItemsAndTotalCount
             

submodules/ChatListUI/Sources/ChatListFilterPresetController.swift

@@ -624,7 +624,7 @@ private func internalChatListFilterAddChatsController(context: AccountContext, f
         }
         
         if applyAutomatically {
-            let _ = (updateChatListFiltersInteractively(postbox: context.account.postbox, { filters in
+            let _ = (context.engine.peers.updateChatListFiltersInteractively { filters in
                 var filters = filters
                 for i in 0 ..< filters.count {
                     if filters[i].id == filter.id {
@@ -634,7 +634,7 @@ private func internalChatListFilterAddChatsController(context: AccountContext, f
                     }
                 }
                 return filters
-            })
+            }
             |> deliverOnMainQueue).start(next: { _ in
                 controller?.dismiss()
             })
@@ -702,7 +702,7 @@ private func internalChatListFilterExcludeChatsController(context: AccountContex
         excludePeers.sort()
         
         if applyAutomatically {
-            let _ = (updateChatListFiltersInteractively(postbox: context.account.postbox, { filters in
+            let _ = (context.engine.peers.updateChatListFiltersInteractively { filters in
                 var filters = filters
                 for i in 0 ..< filters.count {
                     if filters[i].id == filter.id {
@@ -714,7 +714,7 @@ private func internalChatListFilterExcludeChatsController(context: AccountContex
                     }
                 }
                 return filters
-            })
+            }
             |> deliverOnMainQueue).start(next: { _ in
                 controller?.dismiss()
             })
@@ -835,7 +835,7 @@ func chatListFilterPresetController(context: AccountContext, currentPreset: Chat
             includePeers.setPeers(state.additionallyIncludePeers)
             let filter = ChatListFilter(id: currentPreset?.id ?? -1, title: state.name, emoticon: currentPreset?.emoticon, data: ChatListFilterData(categories: state.includeCategories, excludeMuted: state.excludeMuted, excludeRead: state.excludeRead, excludeArchived: state.excludeArchived, includePeers: includePeers, excludePeers: state.additionallyExcludePeers))
             
-            let _ = (currentChatListFilters(postbox: context.account.postbox)
+            let _ = (context.engine.peers.currentChatListFilters()
             |> deliverOnMainQueue).start(next: { filters in
                 let controller = internalChatListFilterAddChatsController(context: context, filter: filter, allFilters: filters, applyAutomatically: false, updated: { filter in
                     skipStateAnimation = true
@@ -856,7 +856,7 @@ func chatListFilterPresetController(context: AccountContext, currentPreset: Chat
             includePeers.setPeers(state.additionallyIncludePeers)
             let filter = ChatListFilter(id: currentPreset?.id ?? -1, title: state.name, emoticon: currentPreset?.emoticon, data: ChatListFilterData(categories: state.includeCategories, excludeMuted: state.excludeMuted, excludeRead: state.excludeRead, excludeArchived: state.excludeArchived, includePeers: includePeers, excludePeers: state.additionallyExcludePeers))
             
-            let _ = (currentChatListFilters(postbox: context.account.postbox)
+            let _ = (context.engine.peers.currentChatListFilters()
             |> deliverOnMainQueue).start(next: { filters in
                 let controller = internalChatListFilterExcludeChatsController(context: context, filter: filter, allFilters: filters, applyAutomatically: false, updated: { filter in
                     skipStateAnimation = true
@@ -985,12 +985,12 @@ func chatListFilterPresetController(context: AccountContext, currentPreset: Chat
     var attemptNavigationImpl: (() -> Bool)?
     let applyImpl: (() -> Void)? = {
         let state = stateValue.with { $0 }
-        let _ = (updateChatListFiltersInteractively(postbox: context.account.postbox, { filters in
+        let _ = (context.engine.peers.updateChatListFiltersInteractively { filters in
             var includePeers = ChatListFilterIncludePeers()
             includePeers.setPeers(state.additionallyIncludePeers)
             var updatedFilter = ChatListFilter(id: currentPreset?.id ?? -1, title: state.name, emoticon: currentPreset?.emoticon, data: ChatListFilterData(categories: state.includeCategories, excludeMuted: state.excludeMuted, excludeRead: state.excludeRead, excludeArchived: state.excludeArchived, includePeers: includePeers, excludePeers: state.additionallyExcludePeers))
             if currentPreset == nil {
-                updatedFilter.id = generateNewChatListFilterId(filters: filters)
+                updatedFilter.id = context.engine.peers.generateNewChatListFilterId(filters: filters)
             }
             var filters = filters
             if let _ = currentPreset {
@@ -1017,7 +1017,7 @@ func chatListFilterPresetController(context: AccountContext, currentPreset: Chat
                 filters.append(updatedFilter)
             }
             return filters
-        })
+        }
         |> deliverOnMainQueue).start(next: { filters in
             updated(filters)
             dismissImpl?()

submodules/ChatListUI/Sources/ChatListFilterPresetListController.swift

@@ -249,12 +249,12 @@ public func chatListFilterPresetListController(context: AccountContext, mode: Ch
     
     let arguments = ChatListFilterPresetListControllerArguments(context: context,
     addSuggestedPresed: { title, data in
-        let _ = (updateChatListFiltersInteractively(postbox: context.account.postbox, { filters in
+        let _ = (context.engine.peers.updateChatListFiltersInteractively { filters in
             var filters = filters
-            let id = generateNewChatListFilterId(filters: filters)
+            let id = context.engine.peers.generateNewChatListFilterId(filters: filters)
             filters.insert(ChatListFilter(id: id, title: title, emoticon: nil, data: data), at: 0)
             return filters
-        })
+        }
         |> deliverOnMainQueue).start(next: { _ in
         })
     }, openPreset: { preset in
@@ -279,13 +279,13 @@ public func chatListFilterPresetListController(context: AccountContext, mode: Ch
                 ActionSheetButtonItem(title: presentationData.strings.ChatList_RemoveFolderAction, color: .destructive, action: { [weak actionSheet] in
                     actionSheet?.dismissAnimated()
                     
-                    let _ = (updateChatListFiltersInteractively(postbox: context.account.postbox, { filters in
+                    let _ = (context.engine.peers.updateChatListFiltersInteractively { filters in
                         var filters = filters
                         if let index = filters.firstIndex(where: { $0.id == id }) {
                             filters.remove(at: index)
                         }
                         return filters
-                    })
+                    }
                     |> deliverOnMainQueue).start()
                 })
             ]),
@@ -300,30 +300,12 @@ public func chatListFilterPresetListController(context: AccountContext, mode: Ch
     
     let chatCountCache = Atomic<[ChatListFilterData: Int]>(value: [:])
     
-    let filtersWithCountsSignal = updatedChatListFilters(postbox: context.account.postbox)
+    let filtersWithCountsSignal = context.engine.peers.updatedChatListFilters()
     |> distinctUntilChanged
     |> mapToSignal { filters -> Signal<[(ChatListFilter, Int)], NoError> in
         return .single(filters.map { filter -> (ChatListFilter, Int) in
             return (filter, 0)
         })
-        /*return context.account.postbox.transaction { transaction -> [(ChatListFilter, Int)] in
-            return filters.map { filter -> (ChatListFilter, Int) in
-                let count: Int
-                if let cachedValue = chatCountCache.with({ dict -> Int? in
-                    return dict[filter.data]
-                }) {
-                    count = cachedValue
-                } else {
-                    count = transaction.getChatCountMatchingPredicate(chatListFilterPredicate(filter: filter.data))
-                    let _ = chatCountCache.modify { dict in
-                        var dict = dict
-                        dict[filter.data] = count
-                        return dict
-                    }
-                }
-                return (filter, count)
-            }
-        }*/
     }
     
     let featuredFilters = context.account.postbox.preferencesView(keys: [PreferencesKeys.chatListFiltersFeaturedState])
@@ -368,7 +350,7 @@ public func chatListFilterPresetListController(context: AccountContext, mode: Ch
                 |> take(1)
                 |> deliverOnMainQueue).start(next: { [weak updatedFilterOrder] updatedFilterOrderValue in
                     if let updatedFilterOrderValue = updatedFilterOrderValue {
-                        let _ = (updateChatListFiltersInteractively(postbox: context.account.postbox, { filters in
+                        let _ = (context.engine.peers.updateChatListFiltersInteractively { filters in
                             var updatedFilters: [ChatListFilter] = []
                             for id in updatedFilterOrderValue {
                                 if let index = filters.firstIndex(where: { $0.id == id }) {
@@ -382,7 +364,7 @@ public func chatListFilterPresetListController(context: AccountContext, mode: Ch
                             }
                             
                             return updatedFilters
-                        })
+                        }
                         |> deliverOnMainQueue).start(next: { _ in
                             filtersWithCounts.set(filtersWithCountsSignal)
                             let _ = (filtersWithCounts.get()

submodules/ChatListUI/Sources/ChatListSelection.swift

@@ -4,6 +4,7 @@ import SwiftSignalKit
 import Postbox
 import TelegramCore
 import SyncCore
+import AccountContext
 
 enum ChatListSelectionReadOption: Equatable {
     case all(enabled: Bool)
@@ -15,10 +16,10 @@ struct ChatListSelectionOptions: Equatable {
     let delete: Bool
 }
 
-func chatListSelectionOptions(postbox: Postbox, peerIds: Set<PeerId>, filterId: Int32?) -> Signal<ChatListSelectionOptions, NoError> {
+func chatListSelectionOptions(context: AccountContext, peerIds: Set<PeerId>, filterId: Int32?) -> Signal<ChatListSelectionOptions, NoError> {
     if peerIds.isEmpty {
         if let filterId = filterId {
-            return chatListFilterItems(postbox: postbox)
+            return chatListFilterItems(context: context)
             |> map { filterItems -> ChatListSelectionOptions in
                 for (filter, unreadCount, _) in filterItems.1 {
                     if filter.id == filterId {
@@ -30,7 +31,7 @@ func chatListSelectionOptions(postbox: Postbox, peerIds: Set<PeerId>, filterId:
             |> distinctUntilChanged
         } else {
             let key = PostboxViewKey.unreadCounts(items: [.total(nil)])
-            return postbox.combinedView(keys: [key])
+            return context.account.postbox.combinedView(keys: [key])
             |> map { view -> ChatListSelectionOptions in
                 var hasUnread = false
                 if let unreadCounts = view.views[key] as? UnreadMessageCountsView, let total = unreadCounts.total() {
@@ -48,7 +49,7 @@ func chatListSelectionOptions(postbox: Postbox, peerIds: Set<PeerId>, filterId:
     } else {
         let items: [UnreadMessageCountsItem] = peerIds.map(UnreadMessageCountsItem.peer)
         let key = PostboxViewKey.unreadCounts(items: items)
-        return postbox.combinedView(keys: [key])
+        return context.account.postbox.combinedView(keys: [key])
         |> map { view -> ChatListSelectionOptions in
             var hasUnread = false
             if let unreadCounts = view.views[key] as? UnreadMessageCountsView {

submodules/ChatListUI/Sources/Node/ChatListNode.swift

@@ -703,7 +703,7 @@ public final class ChatListNode: ListView {
             } else {
                 location = .group(groupId)
             }
-            let _ = (toggleItemPinned(postbox: context.account.postbox, location: location, itemId: itemId)
+            let _ = (context.engine.peers.toggleItemPinned(location: location, itemId: itemId)
             |> deliverOnMainQueue).start(next: { result in
                 if let strongSelf = self {
                     switch result {
@@ -1204,16 +1204,18 @@ public final class ChatListNode: ListView {
                     }
                     
                     if case let .index(index) = fromEntry.sortIndex, let _ = index.pinningIndex {
-                        return strongSelf.context.account.postbox.transaction { transaction -> Bool in
-                            let location: TogglePeerChatPinnedLocation
-                            if let chatListFilter = chatListFilter {
-                                location = .filter(chatListFilter.id)
-                            } else {
-                                location = .group(groupId)
-                            }
-                            
-                            var itemIds = getPinnedItemIds(transaction: transaction, location: location)
-                            
+                        let location: TogglePeerChatPinnedLocation
+                        if let chatListFilter = chatListFilter {
+                            location = .filter(chatListFilter.id)
+                        } else {
+                            location = .group(groupId)
+                        }
+
+                        let engine = strongSelf.context.engine
+                        return engine.peers.getPinnedItemIds(location: location)
+                        |> mapToSignal { itemIds -> Signal<Bool, NoError> in
+                            var itemIds = itemIds
+
                             var itemId: PinnedItemId?
                             switch fromEntry {
                             case let .PeerEntry(index, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _):
@@ -1221,7 +1223,7 @@ public final class ChatListNode: ListView {
                             default:
                                 break
                             }
-                            
+
                             if let itemId = itemId {
                                 itemIds = itemIds.filter({ $0 != itemId })
                                 if let referenceId = referenceId {
@@ -1245,9 +1247,9 @@ public final class ChatListNode: ListView {
                                 } else {
                                     itemIds.append(itemId)
                                 }
-                                return reorderPinnedItemIds(transaction: transaction, location: location, itemIds: itemIds)
+                                return engine.peers.reorderPinnedItemIds(location: location, itemIds: itemIds)
                             } else {
-                                return false
+                                return .single(false)
                             }
                         }
                     }
@@ -1378,7 +1380,7 @@ public final class ChatListNode: ListView {
     
     private func resetFilter() {
         if let chatListFilter = self.chatListFilter {
-            self.updatedFilterDisposable.set((updatedChatListFilters(postbox: self.context.account.postbox)
+            self.updatedFilterDisposable.set((self.context.engine.peers.updatedChatListFilters()
             |> map { filters -> ChatListFilter? in
                 for filter in filters {
                     if filter.id == chatListFilter.id {

submodules/ChatListUI/Sources/TabBarChatListFilterController.swift

@@ -10,8 +10,8 @@ import Postbox
 import TelegramUIPreferences
 import TelegramCore
 
-func chatListFilterItems(postbox: Postbox) -> Signal<(Int, [(ChatListFilter, Int, Bool)]), NoError> {
-    return updatedChatListFilters(postbox: postbox)
+func chatListFilterItems(context: AccountContext) -> Signal<(Int, [(ChatListFilter, Int, Bool)]), NoError> {
+    return context.engine.peers.updatedChatListFilters()
     |> distinctUntilChanged
     |> mapToSignal { filters -> Signal<(Int, [(ChatListFilter, Int, Bool)]), NoError> in
         var unreadCountItems: [UnreadMessageCountsItem] = []
@@ -40,8 +40,8 @@ func chatListFilterItems(postbox: Postbox) -> Signal<(Int, [(ChatListFilter, Int
             keys.append(.basicPeer(peerId))
         }
         
-        return combineLatest(queue: postbox.queue,
-            postbox.combinedView(keys: keys),
+        return combineLatest(queue: context.account.postbox.queue,
+            context.account.postbox.combinedView(keys: keys),
             Signal<Bool, NoError>.single(true)
         )
         |> map { view, _ -> (Int, [(ChatListFilter, Int, Bool)]) in
@@ -63,7 +63,7 @@ func chatListFilterItems(postbox: Postbox) -> Signal<(Int, [(ChatListFilter, Int
                 case let .peer(peerId, state):
                     if let state = state, state.isUnread {
                         if let peerView = view.views[.basicPeer(peerId)] as? BasicPeerView, let peer = peerView.peer {
-                            let tag = postbox.seedConfiguration.peerSummaryCounterTags(peer, peerView.isContact)
+                            let tag = context.account.postbox.seedConfiguration.peerSummaryCounterTags(peer, peerView.isContact)
                             
                             var peerCount = Int(state.count)
                             if state.isUnread {

submodules/DebugSettingsUI/Sources/DebugController.swift

@@ -574,10 +574,11 @@ private enum DebugControllerEntry: ItemListNodeEntry {
                 if let context = arguments.context {
                     let _ = (context.account.postbox.transaction { transaction -> Void in
                         transaction.clearItemCacheCollection(collectionId: Namespaces.CachedItemCollection.cachedPollResults)
-                        unmarkChatListFeaturedFiltersAsSeen(transaction: transaction)
                         
                         transaction.clearItemCacheCollection(collectionId: Namespaces.CachedItemCollection.cachedStickerPacks)
                     }).start()
+
+                    let _ = context.engine.peers.unmarkChatListFeaturedFiltersAsSeen()
                 }
             })
         case .crash:

submodules/InviteLinksUI/Sources/InviteLinkEditController.swift

@@ -387,7 +387,7 @@ public func inviteLinkEditController(context: AccountContext, peerId: PeerId, in
                         dismissAction()
                         dismissImpl?()
                         
-                        let _ = (revokePeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link)
+                        let _ = (context.engine.peers.revokePeerExportedInvitation(peerId: peerId, link: invite.link)
                         |> timeout(10, queue: Queue.mainQueue(), alternate: .fail(.generic))
                         |> deliverOnMainQueue).start(next: { invite in
                             switch invite {
@@ -444,7 +444,7 @@ public func inviteLinkEditController(context: AccountContext, peerId: PeerId, in
 
             let usageLimit = state.usage.value
             if invite == nil {
-                let _ = (createPeerExportedInvitation(account: context.account, peerId: peerId, expireDate: expireDate, usageLimit: usageLimit)
+                let _ = (context.engine.peers.createPeerExportedInvitation(peerId: peerId, expireDate: expireDate, usageLimit: usageLimit)
                 |> timeout(10, queue: Queue.mainQueue(), alternate: .fail(.generic))
                 |> deliverOnMainQueue).start(next: { invite in
                     completion?(invite)
@@ -458,7 +458,7 @@ public func inviteLinkEditController(context: AccountContext, peerId: PeerId, in
                     presentControllerImpl?(textAlertController(context: context, title: nil, text: presentationData.strings.Login_UnknownError, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})]), nil)
                 })
             } else if let invite = invite {
-                let _ = (editPeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link, expireDate: expireDate, usageLimit: usageLimit)
+                let _ = (context.engine.peers.editPeerExportedInvitation(peerId: peerId, link: invite.link, expireDate: expireDate, usageLimit: usageLimit)
                 |> timeout(10, queue: Queue.mainQueue(), alternate: .fail(.generic))
                 |> deliverOnMainQueue).start(next: { invite in
                     completion?(invite)

submodules/InviteLinksUI/Sources/InviteLinkInviteController.swift

@@ -285,7 +285,7 @@ public final class InviteLinkInviteController: ViewController {
             self.presentationDataPromise = Promise(self.presentationData)
             self.controller = controller
             
-            self.invitesContext = PeerExportedInvitationsContext(account: context.account, peerId: peerId, adminId: nil, revoked: false, forceUpdate: false)
+            self.invitesContext = context.engine.peers.peerExportedInvitations(peerId: peerId, adminId: nil, revoked: false, forceUpdate: false)
                         
             self.dimNode = ASDisplayNode()
             self.dimNode.backgroundColor = UIColor(white: 0.0, alpha: 0.5)
@@ -396,7 +396,7 @@ public final class InviteLinkInviteController: ViewController {
                                     dismissAction()
                                     
                                     if let invite = invite {
-                                        let _ = (revokePeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(next: { result in
+                                        let _ = (context.engine.peers.revokePeerExportedInvitation(peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(next: { result in
                                             if let result = result, case let .replace(_, invite) = result {
                                                 mainInvitePromise.set(invite)
                                             }

submodules/InviteLinksUI/Sources/InviteLinkListController.swift

@@ -418,12 +418,12 @@ public func inviteLinkListController(context: AccountContext, peerId: PeerId, ad
     var getControllerImpl: (() -> ViewController?)?
     
     let adminId = admin?.peer.peer?.id
-    let invitesContext = PeerExportedInvitationsContext(account: context.account, peerId: peerId, adminId: adminId, revoked: false, forceUpdate: true)
-    let revokedInvitesContext = PeerExportedInvitationsContext(account: context.account, peerId: peerId, adminId: adminId, revoked: true, forceUpdate: true)
+    let invitesContext = context.engine.peers.peerExportedInvitations(peerId: peerId, adminId: adminId, revoked: false, forceUpdate: true)
+    let revokedInvitesContext = context.engine.peers.peerExportedInvitations(peerId: peerId, adminId: adminId, revoked: true, forceUpdate: true)
     
     let creators: Signal<[ExportedInvitationCreator], NoError>
     if adminId == nil {
-        creators = .single([]) |> then(peerExportedInvitationsCreators(account: context.account, peerId: peerId))
+        creators = .single([]) |> then(context.engine.peers.peerExportedInvitationsCreators(peerId: peerId))
     } else {
         creators = .single([])
     }
@@ -520,7 +520,7 @@ public func inviteLinkListController(context: AccountContext, peerId: PeerId, ad
                                     }
                                 }
                                 if revoke {
-                                    revokeLinkDisposable.set((revokePeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(next: { result in
+                                    revokeLinkDisposable.set((context.engine.peers.revokePeerExportedInvitation(peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(next: { result in
                                         updateState { state in
                                             var updatedState = state
                                             updatedState.revokingPrivateLink = false
@@ -661,7 +661,7 @@ public func inviteLinkListController(context: AccountContext, peerId: PeerId, ad
                         ActionSheetButtonItem(title: presentationData.strings.InviteLink_DeleteLinkAlert_Action, color: .destructive, action: {
                             dismissAction()
 
-                            revokeLinkDisposable.set((deletePeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(completed: {
+                            revokeLinkDisposable.set((context.engine.peers.deletePeerExportedInvitation(peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(completed: {
                             }))
                             
                             revokedInvitesContext.remove(invite)
@@ -695,7 +695,7 @@ public func inviteLinkListController(context: AccountContext, peerId: PeerId, ad
                             ActionSheetButtonItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeLink, color: .destructive, action: {
                                 dismissAction()
                                 
-                                revokeLinkDisposable.set((revokePeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(next: { result in
+                                revokeLinkDisposable.set((context.engine.peers.revokePeerExportedInvitation(peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(next: { result in
                                     if case let .replace(_, newInvite) = result {
                                         invitesContext.add(newInvite)
                                     }
@@ -732,7 +732,7 @@ public func inviteLinkListController(context: AccountContext, peerId: PeerId, ad
                 ActionSheetButtonItem(title: presentationData.strings.InviteLink_DeleteAllRevokedLinksAlert_Action, color: .destructive, action: {
                     dismissAction()
                     
-                    deleteAllRevokedLinksDisposable.set((deleteAllRevokedPeerExportedInvitations(account: context.account, peerId: peerId, adminId: adminId ?? context.account.peerId) |> deliverOnMainQueue).start(completed: {
+                    deleteAllRevokedLinksDisposable.set((context.engine.peers.deleteAllRevokedPeerExportedInvitations(peerId: peerId, adminId: adminId ?? context.account.peerId) |> deliverOnMainQueue).start(completed: {
                     }))
                     
                     revokedInvitesContext.clear()
@@ -770,7 +770,7 @@ public func inviteLinkListController(context: AccountContext, peerId: PeerId, ad
     |> distinctUntilChanged
     |> deliverOnMainQueue
     |> map { invite -> PeerInvitationImportersContext? in
-        return invite.flatMap { PeerInvitationImportersContext(account: context.account, peerId: peerId, invite: $0) }
+        return invite.flatMap { context.engine.peers.peerInvitationImporters(peerId: peerId, invite: $0) }
     } |> afterNext { context in
         if let context = context {
             importersState.set(context.state |> map(Optional.init))

submodules/InviteLinksUI/Sources/InviteLinkViewController.swift

@@ -374,7 +374,7 @@ public final class InviteLinkViewController: ViewController {
             self.presentationDataPromise = Promise(self.presentationData)
             self.controller = controller
             
-            self.importersContext = importersContext ?? PeerInvitationImportersContext(account: context.account, peerId: peerId, invite: invite)
+            self.importersContext = importersContext ?? context.engine.peers.peerInvitationImporters(peerId: peerId, invite: invite)
             
             self.dimNode = ASDisplayNode()
             self.dimNode.backgroundColor = UIColor(white: 0.0, alpha: 0.5)
@@ -483,7 +483,7 @@ public final class InviteLinkViewController: ViewController {
                                     dismissAction()
                                     self?.controller?.dismiss()
                                     
-                                    let _ = (deletePeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(completed: {
+                                    let _ = (context.engine.peers.deletePeerExportedInvitation(peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(completed: {
                                     })
                                     
                                     self?.controller?.revokedInvitationsContext?.remove(invite)
@@ -537,7 +537,7 @@ public final class InviteLinkViewController: ViewController {
                                         dismissAction()
                                         self?.controller?.dismiss()
 
-                                        let _ = (revokePeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(next: { result in
+                                        let _ = (context.engine.peers.revokePeerExportedInvitation(peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(next: { result in
                                             if case let .replace(_, newInvite) = result {
                                                 self?.controller?.invitationsContext?.add(newInvite)
                                             }

submodules/JoinLinkPreviewUI/Sources/JoinLinkPreviewController.swift

@@ -70,7 +70,7 @@ public final class JoinLinkPreviewController: ViewController {
         if let resolvedState = self.resolvedState {
             signal = .single(resolvedState)
         } else {
-            signal = joinLinkInformation(self.link, account: self.context.account)
+            signal = self.context.engine.peers.joinLinkInformation(self.link)
         }
         
         self.disposable.set((signal
@@ -121,7 +121,7 @@ public final class JoinLinkPreviewController: ViewController {
     }
     
     private func join() {
-        self.disposable.set((joinChatInteractively(with: self.link, account: self.context.account) |> deliverOnMainQueue).start(next: { [weak self] peerId in
+        self.disposable.set((self.context.engine.peers.joinChatInteractively(with: self.link) |> deliverOnMainQueue).start(next: { [weak self] peerId in
             if let strongSelf = self {
                 if let peerId = peerId {
                     strongSelf.navigateToPeer(peerId, nil)

submodules/LegacyMediaPickerUI/Sources/LegacyLiveUploadInterface.swift

@@ -5,6 +5,7 @@ import TelegramCore
 import SyncCore
 import LegacyComponents
 import SwiftSignalKit
+import AccountContext
 
 public class VideoConversionWatcher: TGMediaVideoFileWatcher {
     private let update: (String, Int) -> Void
@@ -44,7 +45,7 @@ public final class LegacyLiveUploadInterfaceResult: NSObject {
 }
 
 public final class LegacyLiveUploadInterface: VideoConversionWatcher, TGLiveUploadInterface {
-    private let account: Account
+    private let context: AccountContext
     private let id: Int64
     private var path: String?
     private var size: Int?
@@ -52,8 +53,8 @@ public final class LegacyLiveUploadInterface: VideoConversionWatcher, TGLiveUplo
     private let data = Promise<MediaResourceData>()
     private let dataValue = Atomic<MediaResourceData?>(value: nil)
     
-    public init(account: Account) {
-        self.account = account
+    public init(context: AccountContext) {
+        self.context = context
         self.id = Int64.random(in: Int64.min ... Int64.max)
         
         var updateImpl: ((String, Int) -> Void)?
@@ -65,7 +66,7 @@ public final class LegacyLiveUploadInterface: VideoConversionWatcher, TGLiveUplo
             if let strongSelf = self {
                 if strongSelf.path == nil {
                     strongSelf.path = path
-                    strongSelf.account.messageMediaPreuploadManager.add(network: strongSelf.account.network, postbox: strongSelf.account.postbox, id: strongSelf.id, encrypt: false, tag: nil, source: strongSelf.data.get())
+                    strongSelf.context.engine.resources.preUpload(id: strongSelf.id, encrypt: false, tag: nil, source: strongSelf.data.get())
                 }
                 strongSelf.size = size
                 

submodules/LegacyMediaPickerUI/Sources/LegacySuggestionContext.swift

@@ -46,7 +46,7 @@ public func legacySuggestionContext(context: AccountContext, peerId: PeerId, cha
     }
     suggestionContext.hashtagListSignal = { query in
         return SSignal { subscriber in
-            let disposable = (recentlyUsedHashtags(postbox: context.account.postbox) |> map { hashtags -> [String] in
+            let disposable = (context.engine.messages.recentlyUsedHashtags() |> map { hashtags -> [String] in
                 let normalizedQuery = query?.lowercased()
                 var result: [String] = []
                 if let normalizedQuery = normalizedQuery {

submodules/LiveLocationManager/Sources/LiveLocationManager.swift

@@ -44,11 +44,11 @@ public final class LiveLocationManagerImpl: LiveLocationManager {
     
     private var invalidationTimer: (SwiftSignalKit.Timer, Int32)?
     
-    public init(account: Account, locationManager: DeviceLocationManager, inForeground: Signal<Bool, NoError>) {
+    public init(engine: TelegramEngine, account: Account, locationManager: DeviceLocationManager, inForeground: Signal<Bool, NoError>) {
         self.account = account
         self.locationManager = locationManager
         
-        self.summaryManagerImpl = LiveLocationSummaryManagerImpl(queue: self.queue, postbox: account.postbox, accountPeerId: account.peerId, viewTracker: account.viewTracker)
+        self.summaryManagerImpl = LiveLocationSummaryManagerImpl(queue: self.queue, engine: engine, postbox: account.postbox, accountPeerId: account.peerId, viewTracker: account.viewTracker)
         
         let viewKey: PostboxViewKey = .localMessageTag(.OutgoingLiveLocation)
         self.messagesDisposable = (account.postbox.combinedView(keys: [viewKey])

submodules/LiveLocationManager/Sources/LiveLocationSummaryManager.swift

@@ -79,6 +79,7 @@ private final class LiveLocationSummaryContext {
 
 private final class LiveLocationPeerSummaryContext {
     private let queue: Queue
+    private let engine: TelegramEngine
     private let accountPeerId: PeerId
     private let viewTracker: AccountViewTracker
     private let peerId: PeerId
@@ -116,8 +117,9 @@ private final class LiveLocationPeerSummaryContext {
     
     private let peerDisposable = MetaDisposable()
     
-    init(queue: Queue, accountPeerId: PeerId, viewTracker: AccountViewTracker, peerId: PeerId, becameEmpty: @escaping () -> Void) {
+    init(queue: Queue, engine: TelegramEngine, accountPeerId: PeerId, viewTracker: AccountViewTracker, peerId: PeerId, becameEmpty: @escaping () -> Void) {
         self.queue = queue
+        self.engine = engine
         self.accountPeerId = accountPeerId
         self.viewTracker = viewTracker
         self.peerId = peerId
@@ -160,7 +162,7 @@ private final class LiveLocationPeerSummaryContext {
     
     private func updateSubscription() {
         if self.isActive || !self.subscribers.isEmpty {
-            self.peerDisposable.set((topPeerActiveLiveLocationMessages(viewTracker: self.viewTracker, accountPeerId: self.accountPeerId, peerId: self.peerId)
+            self.peerDisposable.set((self.engine.messages.topPeerActiveLiveLocationMessages(peerId: self.peerId)
                 |> deliverOn(self.queue)).start(next: { [weak self] accountPeer, messages in
                     if let strongSelf = self {
                         var peersAndMessages: [(Peer, Message)] = []
@@ -187,6 +189,7 @@ private final class LiveLocationPeerSummaryContext {
 
 public final class LiveLocationSummaryManagerImpl: LiveLocationSummaryManager {
     private let queue: Queue
+    private let engine: TelegramEngine
     private let postbox: Postbox
     private let accountPeerId: PeerId
     private let viewTracker: AccountViewTracker
@@ -194,9 +197,10 @@ public final class LiveLocationSummaryManagerImpl: LiveLocationSummaryManager {
     private let globalContext: LiveLocationSummaryContext
     private var peerContexts: [PeerId: LiveLocationPeerSummaryContext] = [:]
     
-    init(queue: Queue, postbox: Postbox, accountPeerId: PeerId, viewTracker: AccountViewTracker) {
+    init(queue: Queue, engine: TelegramEngine, postbox: Postbox, accountPeerId: PeerId, viewTracker: AccountViewTracker) {
         assert(queue.isCurrent())
         self.queue = queue
+        self.engine = engine
         self.postbox = postbox
         self.accountPeerId = accountPeerId
         self.viewTracker = viewTracker
@@ -212,7 +216,7 @@ public final class LiveLocationSummaryManagerImpl: LiveLocationSummaryManager {
         
         for peerId in peerIds {
             if self.peerContexts[peerId] == nil {
-                let context = LiveLocationPeerSummaryContext(queue: self.queue, accountPeerId: self.accountPeerId, viewTracker: self.viewTracker, peerId: peerId, becameEmpty: { [weak self] in
+                let context = LiveLocationPeerSummaryContext(queue: self.queue, engine: self.engine, accountPeerId: self.accountPeerId, viewTracker: self.viewTracker, peerId: peerId, becameEmpty: { [weak self] in
                     if let strongSelf = self, let context = strongSelf.peerContexts[peerId], context.isEmpty {
                         strongSelf.peerContexts.removeValue(forKey: peerId)
                     }
@@ -242,7 +246,7 @@ public final class LiveLocationSummaryManagerImpl: LiveLocationSummaryManager {
                     if let current = strongSelf.peerContexts[peerId] {
                         context = current
                     } else {
-                        context = LiveLocationPeerSummaryContext(queue: strongSelf.queue, accountPeerId: strongSelf.accountPeerId, viewTracker: strongSelf.viewTracker, peerId: peerId, becameEmpty: {
+                        context = LiveLocationPeerSummaryContext(queue: strongSelf.queue, engine: strongSelf.engine, accountPeerId: strongSelf.accountPeerId, viewTracker: strongSelf.viewTracker, peerId: peerId, becameEmpty: {
                             if let strongSelf = self, let context = strongSelf.peerContexts[peerId], context.isEmpty {
                                 strongSelf.peerContexts.removeValue(forKey: peerId)
                             }

submodules/LocationUI/Sources/LocationUtils.swift

@@ -43,7 +43,7 @@ public func nearbyVenues(context: AccountContext, latitude: Double, longitude: D
             guard let peerId = peerId else {
                 return .single(nil)
             }
-            return requestChatContextResults(account: context.account, botId: peerId, peerId: context.account.peerId, query: query ?? "", location: .single((latitude, longitude)), offset: "")
+            return context.engine.messages.requestChatContextResults(botId: peerId, peerId: context.account.peerId, query: query ?? "", location: .single((latitude, longitude)), offset: "")
             |> map { results -> ChatContextResultCollection? in
                 return results?.results
             }

submodules/LocationUI/Sources/LocationViewControllerNode.swift

@@ -279,7 +279,7 @@ final class LocationViewControllerNode: ViewControllerTracingNode, CLLocationMan
             }
         }
         
-        let liveLocations = topPeerActiveLiveLocationMessages(viewTracker: context.account.viewTracker, accountPeerId: context.account.peerId, peerId: subject.id.peerId)
+        let liveLocations = context.engine.messages.topPeerActiveLiveLocationMessages(peerId: subject.id.peerId)
         |> map { _, messages -> [Message] in
             return messages
         }

submodules/PeerAvatarGalleryUI/Sources/AvatarGalleryController.swift

@@ -43,7 +43,7 @@ public func peerInfoProfilePhotos(context: AccountContext, peerId: PeerId) -> Si
                 return .single((true, []))
             }
         } else {
-            return fetchAndUpdateCachedPeerData(accountPeerId: context.account.peerId, peerId: peerId, network: context.account.network, postbox: context.account.postbox)
+            return context.engine.peers.fetchAndUpdateCachedPeerData(peerId: peerId)
             |> map { _ -> (Bool, [AvatarGalleryEntry])? in
                 return nil
             }
@@ -748,7 +748,7 @@ public class AvatarGalleryController: ViewController, StandalonePresentableContr
             case let .image(_, reference, _, _, _, _, _, _, _, _):
                 if self.peer.id == self.context.account.peerId, let peerReference = PeerReference(self.peer) {
                     if let reference = reference {
-                        let _ = (updatePeerPhotoExisting(network: self.context.account.network, reference: reference)
+                        let _ = (self.context.engine.accountData.updatePeerPhotoExisting(reference: reference)
                         |> deliverOnMainQueue).start(next: { [weak self] photo in
                             if let strongSelf = self, let photo = photo, let firstEntry = strongSelf.entries.first, case let .image(image) = firstEntry {
                                 let updatedEntry = AvatarGalleryEntry.image(photo.imageId, photo.reference, photo.representations.map({ ImageRepresentationWithReference(representation: $0, reference: MediaResourceReference.avatar(peer: peerReference, resource: $0.resource)) }), photo.videoRepresentations.map({ VideoRepresentationWithReference(representation: $0, reference: MediaResourceReference.avatarList(peer: peerReference, resource: $0.resource)) }), strongSelf.peer, image.5, image.6, image.7, photo.immediateThumbnailData, image.9)
@@ -860,7 +860,7 @@ public class AvatarGalleryController: ViewController, StandalonePresentableContr
                     if self.peer.id == self.context.account.peerId {
                     } else {
                         if entry == self.entries.first {
-                            let _ = updatePeerPhoto(postbox: self.context.account.postbox, network: self.context.account.network, stateManager: self.context.account.stateManager, accountPeerId: self.context.account.peerId, peerId: self.peer.id, photo: nil, mapResourceToAvatarSizes: { _, _ in .single([:]) }).start()
+                            let _ = self.context.engine.peers.updatePeerPhoto(peerId: self.peer.id, photo: nil, mapResourceToAvatarSizes: { _, _ in .single([:]) }).start()
                             dismiss = true
                         } else {
                             if let index = self.entries.firstIndex(of: entry) {
@@ -872,7 +872,7 @@ public class AvatarGalleryController: ViewController, StandalonePresentableContr
                 case let .image(_, reference, _, _, _, _, _, messageId, _, _):
                     if self.peer.id == self.context.account.peerId {
                         if let reference = reference {
-                            let _ = removeAccountPhoto(network: self.context.account.network, reference: reference).start()
+                            let _ = self.context.engine.accountData.removeAccountPhoto(reference: reference).start()
                         }
                         if entry == self.entries.first {
                             dismiss = true
@@ -889,7 +889,7 @@ public class AvatarGalleryController: ViewController, StandalonePresentableContr
                         }
                         
                         if entry == self.entries.first {
-                            let _ = updatePeerPhoto(postbox: self.context.account.postbox, network: self.context.account.network, stateManager: self.context.account.stateManager, accountPeerId: self.context.account.peerId, peerId: self.peer.id, photo: nil, mapResourceToAvatarSizes: { _, _ in .single([:]) }).start()
+                            let _ = self.context.engine.peers.updatePeerPhoto(peerId: self.peer.id, photo: nil, mapResourceToAvatarSizes: { _, _ in .single([:]) }).start()
                             dismiss = true
                         } else {
                             if let index = self.entries.firstIndex(of: entry) {

submodules/PeerInfoUI/Sources/ChannelInfoController.swift

@@ -738,7 +738,7 @@ public func channelInfoController(context: AccountContext, peerId: PeerId) -> Vi
                         updateState {
                             $0.withUpdatedUpdatingAvatar(.image(representation, true))
                         }
-                        updateAvatarDisposable.set((updatePeerPhoto(postbox: context.account.postbox, network: context.account.network, stateManager: context.account.stateManager, accountPeerId: context.account.peerId, peerId: peerId, photo: uploadedPeerPhoto(postbox: context.account.postbox, network: context.account.network, resource: resource), mapResourceToAvatarSizes: { resource, representations in
+                        updateAvatarDisposable.set((context.engine.peers.updatePeerPhoto(peerId: peerId, photo: context.engine.peers.uploadedPeerPhoto(resource: resource), mapResourceToAvatarSizes: { resource, representations in
                             return mapResourceToAvatarSizes(postbox: context.account.postbox, resource: resource, representations: representations)
                         })
                         |> deliverOnMainQueue).start(next: { result in
@@ -777,7 +777,7 @@ public func channelInfoController(context: AccountContext, peerId: PeerId) -> Vi
                             return $0.withUpdatedUpdatingAvatar(ItemListAvatarAndNameInfoItemUpdatingAvatar.none)
                         }
                     }
-                    updateAvatarDisposable.set((updatePeerPhoto(postbox: context.account.postbox, network: context.account.network, stateManager: context.account.stateManager, accountPeerId: context.account.peerId, peerId: peerId, photo: nil, mapResourceToAvatarSizes: { resource, representations in
+                    updateAvatarDisposable.set((context.engine.peers.updatePeerPhoto(peerId: peerId, photo: nil, mapResourceToAvatarSizes: { resource, representations in
                         return mapResourceToAvatarSizes(postbox: context.account.postbox, resource: resource, representations: representations)
                     }) |> deliverOnMainQueue).start(next: { result in
                         switch result {
@@ -993,7 +993,7 @@ public func channelInfoController(context: AccountContext, peerId: PeerId) -> Vi
                         
                         let updateTitle: Signal<Void, Void>
                         if let titleValue = updateValues.title {
-                            updateTitle = updatePeerTitle(account: context.account, peerId: peerId, title: titleValue)
+                            updateTitle = context.engine.peers.updatePeerTitle(peerId: peerId, title: titleValue)
                                 |> mapError { _ in return Void() }
                         } else {
                             updateTitle = .complete()
@@ -1001,7 +1001,7 @@ public func channelInfoController(context: AccountContext, peerId: PeerId) -> Vi
                         
                         let updateDescription: Signal<Void, Void>
                         if let descriptionValue = updateValues.description {
-                            updateDescription = updatePeerDescription(account: context.account, peerId: peerId, description: descriptionValue.isEmpty ? nil : descriptionValue)
+                            updateDescription = context.engine.peers.updatePeerDescription(peerId: peerId, description: descriptionValue.isEmpty ? nil : descriptionValue)
                                 |> mapError { _ in return Void() }
                         } else {
                             updateDescription = .complete()

submodules/PeerInfoUI/Sources/ChannelVisibilityController.swift

@@ -1027,7 +1027,7 @@ public func channelVisibilityController(context: AccountContext, peerId: PeerId,
                                         }
                                     }
                                     if revoke {
-                                        revokeLinkDisposable.set((revokePeerExportedInvitation(account: context.account, peerId: peerId, link: link) |> deliverOnMainQueue).start(completed: {
+                                        revokeLinkDisposable.set((context.engine.peers.revokePeerExportedInvitation(peerId: peerId, link: link) |> deliverOnMainQueue).start(completed: {
                                             updateState {
                                                 $0.withUpdatedRevokingPrivateLink(false)
                                             }

submodules/SettingsUI/Sources/Data and Storage/StorageUsageController.swift

@@ -394,7 +394,7 @@ func cacheUsageStats(context: AccountContext) -> Signal<CacheUsageStatsResult?,
         containerPath + "/Documents/tempcache_v1/store",
     ]
     return .single(nil)
-    |> then(collectCacheUsageStats(account: context.account, additionalCachePaths: additionalPaths, logFilesPath: context.sharedContext.applicationBindings.containerPath + "/telegram-data/logs")
+    |> then(context.engine.resources.collectCacheUsageStats(additionalCachePaths: additionalPaths, logFilesPath: context.sharedContext.applicationBindings.containerPath + "/telegram-data/logs")
     |> map(Optional.init))
 }
 
@@ -581,7 +581,7 @@ public func storageUsageController(context: AccountContext, cacheUsagePromise: P
                             var updatedTempPaths = stats.tempPaths
                             var updatedTempSize = stats.tempSize
                             
-                            var signal: Signal<Void, NoError> = clearCachedMediaResources(account: context.account, mediaResourceIds: clearResourceIds)
+                            var signal: Signal<Void, NoError> = context.engine.resources.clearCachedMediaResources(mediaResourceIds: clearResourceIds)
                             if otherSize.0 {
                                 let removeTempFiles: Signal<Void, NoError> = Signal { subscriber in
                                     let fileManager = FileManager.default
@@ -784,7 +784,7 @@ public func storageUsageController(context: AccountContext, cacheUsagePromise: P
                                     }
                                 }
                                 
-                                var signal = clearCachedMediaResources(account: context.account, mediaResourceIds: clearResourceIds)
+                                var signal = context.engine.resources.clearCachedMediaResources(mediaResourceIds: clearResourceIds)
                                 
                                 let resultStats = CacheUsageStats(media: media, mediaResourceIds: stats.mediaResourceIds, peers: stats.peers, otherSize: stats.otherSize, otherPaths: stats.otherPaths, cacheSize: stats.cacheSize, tempPaths: stats.tempPaths, tempSize: stats.tempSize, immutableSize: stats.immutableSize)
                                 
@@ -911,7 +911,7 @@ public func storageUsageController(context: AccountContext, cacheUsagePromise: P
                             }
                         }
                         
-                        var signal = clearCachedMediaResources(account: context.account, mediaResourceIds: clearResourceIds)
+                        var signal = context.engine.resources.clearCachedMediaResources(mediaResourceIds: clearResourceIds)
                         
                         let resultStats = CacheUsageStats(media: media, mediaResourceIds: stats.mediaResourceIds, peers: stats.peers, otherSize: stats.otherSize, otherPaths: stats.otherPaths, cacheSize: stats.cacheSize, tempPaths: stats.tempPaths, tempSize: stats.tempSize, immutableSize: stats.immutableSize)
                         

submodules/SettingsUI/Sources/Notifications/NotificationsAndSounds.swift

@@ -1008,7 +1008,7 @@ public func notificationsAndSoundsController(context: AccountContext, exceptions
     let sharedData = context.sharedContext.accountManager.sharedData(keys: [ApplicationSpecificSharedDataKeys.inAppNotificationSettings])
     let preferences = context.account.postbox.preferencesView(keys: [PreferencesKeys.globalNotifications])
     
-    let exceptionsSignal = Signal<NotificationExceptionsList?, NoError>.single(exceptionsList) |> then(notificationExceptionsList(postbox: context.account.postbox, network: context.account.network) |> map(Optional.init))
+    let exceptionsSignal = Signal<NotificationExceptionsList?, NoError>.single(exceptionsList) |> then(context.engine.peers.notificationExceptionsList() |> map(Optional.init))
     
     notificationExceptions.set(exceptionsSignal |> map { list -> (NotificationExceptionMode, NotificationExceptionMode, NotificationExceptionMode) in
         var users:[PeerId : NotificationExceptionWrapper] = [:]

submodules/SettingsUI/Sources/Themes/ThemeGridSearchContentNode.swift

@@ -520,7 +520,7 @@ final class ThemeGridSearchContentNode: SearchDisplayControllerContentNode {
                                     let geoPoint = collection.geoPoint.flatMap { geoPoint -> (Double, Double) in
                                         return (geoPoint.latitude, geoPoint.longitude)
                                     }
-                                    return requestChatContextResults(account: self.context.account, botId: collection.botId, peerId: collection.peerId, query: searchContext.result.query, location: .single(geoPoint), offset: nextOffset)
+                                    return self.context.engine.messages.requestChatContextResults(botId: collection.botId, peerId: collection.peerId, query: searchContext.result.query, location: .single(geoPoint), offset: nextOffset)
                                     |> map { results -> ChatContextResultCollection? in
                                         return results?.results
                                     }
@@ -572,7 +572,7 @@ final class ThemeGridSearchContentNode: SearchDisplayControllerContentNode {
                         
                         return (.complete() |> delay(0.1, queue: Queue.concurrentDefaultQueue()))
                         |> then(
-                            requestContextResults(account: context.account, botId: user.id, query: wallpaperQuery, peerId: context.account.peerId, limit: 16)
+                            requestContextResults(context: context, botId: user.id, query: wallpaperQuery, peerId: context.account.peerId, limit: 16)
                             |> map { results -> ChatContextResultCollection? in
                                 return results?.results
                             }

submodules/TelegramBaseController/Sources/TelegramBaseController.swift

@@ -287,7 +287,7 @@ open class TelegramBaseController: ViewController, KeyShortcutResponder {
                             let disposable = MetaDisposable()
                             
                             callContextCache.impl.syncWith { impl in
-                                let callContext = impl.get(account: context.account, peerId: peerId, call: activeCall)
+                                let callContext = impl.get(account: context.account, engine: context.engine, peerId: peerId, call: activeCall)
                                 disposable.set((callContext.context.panelData
                                 |> deliverOnMainQueue).start(next: { panelData in
                                     callContext.keep()
@@ -861,7 +861,7 @@ open class TelegramBaseController: ViewController, KeyShortcutResponder {
                 return transaction.getPeerCachedData(peerId: peerId)
             }
             
-            let _ = (combineLatest(currentAccountPeer, cachedGroupCallDisplayAsAvailablePeers(account: context.account, peerId: peerId), cachedData)
+            let _ = (combineLatest(currentAccountPeer, context.engine.calls.cachedGroupCallDisplayAsAvailablePeers(peerId: peerId), cachedData)
             |> map { currentAccountPeer, availablePeers, cachedData -> ([FoundPeer], CachedPeerData?) in
                 var result = currentAccountPeer
                 result.append(contentsOf: availablePeers)

submodules/TelegramCallsUI/Sources/MetalVideoRenderingView.swift

@@ -1,3 +1,6 @@
+#if targetEnvironment(simulator)
+#else
+
 import Foundation
 import UIKit
 import AsyncDisplayKit
@@ -650,3 +653,5 @@ class MetalVideoRenderingContext {
         commandBuffer.commit()
     }
 }
+
+#endif

submodules/TelegramCallsUI/Sources/PresentationGroupCall.swift

@@ -92,7 +92,7 @@ public final class AccountGroupCallContextImpl: AccountGroupCallContext {
         return self.panelDataPromise.get()
     }
     
-    public init(account: Account, peerId: PeerId, call: CachedChannelData.ActiveCall) {
+    public init(account: Account, engine: TelegramEngine, peerId: PeerId, call: CachedChannelData.ActiveCall) {
         self.panelDataPromise.set(.single(GroupCallPanelData(
             peerId: peerId,
             info: GroupCallInfo(
@@ -115,7 +115,7 @@ public final class AccountGroupCallContextImpl: AccountGroupCallContext {
             groupCall: nil
         )))
         
-        self.disposable = (getGroupCallParticipants(account: account, callId: call.id, accessHash: call.accessHash, offset: "", ssrcs: [], limit: 100, sortAscending: nil)
+        self.disposable = (engine.calls.getGroupCallParticipants(callId: call.id, accessHash: call.accessHash, offset: "", ssrcs: [], limit: 100, sortAscending: nil)
         |> map(Optional.init)
         |> `catch` { _ -> Signal<GroupCallParticipantsContext.State?, NoError> in
             return .single(nil)
@@ -124,8 +124,7 @@ public final class AccountGroupCallContextImpl: AccountGroupCallContext {
             guard let strongSelf = self, let state = state else {
                 return
             }
-            let context = GroupCallParticipantsContext(
-                account: account,
+            let context = engine.calls.groupCall(
                 peerId: peerId,
                 myPeerId: account.peerId,
                 id: call.id,
@@ -185,12 +184,12 @@ public final class AccountGroupCallContextCacheImpl: AccountGroupCallContextCach
             self.queue = queue
         }
         
-        public func get(account: Account, peerId: PeerId, call: CachedChannelData.ActiveCall) -> AccountGroupCallContextImpl.Proxy {
+        public func get(account: Account, engine: TelegramEngine, peerId: PeerId, call: CachedChannelData.ActiveCall) -> AccountGroupCallContextImpl.Proxy {
             let result: Record
             if let current = self.contexts[call.id] {
                 result = current
             } else {
-                let context = AccountGroupCallContextImpl(account: account, peerId: peerId, call: call)
+                let context = AccountGroupCallContextImpl(account: account, engine: engine, peerId: peerId, call: call)
                 result = Record(context: context)
                 self.contexts[call.id] = result
             }
@@ -216,8 +215,8 @@ public final class AccountGroupCallContextCacheImpl: AccountGroupCallContextCach
             })
         }
 
-        public func leaveInBackground(account: Account, id: Int64, accessHash: Int64, source: UInt32) {
-            let disposable = leaveGroupCall(account: account, callId: id, accessHash: accessHash, source: source).start()
+        public func leaveInBackground(engine: TelegramEngine, id: Int64, accessHash: Int64, source: UInt32) {
+            let disposable = engine.calls.leaveGroupCall(callId: id, accessHash: accessHash, source: source).start()
             self.leaveDisposables.add(disposable)
         }
     }
@@ -823,7 +822,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
         })
         
         if let initialCall = initialCall, let temporaryParticipantsContext = (self.accountContext.cachedGroupCallContexts as? AccountGroupCallContextCacheImpl)?.impl.syncWith({ impl in
-            impl.get(account: accountContext.account, peerId: peerId, call: CachedChannelData.ActiveCall(id: initialCall.id, accessHash: initialCall.accessHash, title: initialCall.title, scheduleTimestamp: initialCall.scheduleTimestamp, subscribedToScheduled: initialCall.subscribedToScheduled))
+            impl.get(account: accountContext.account, engine: accountContext.engine, peerId: peerId, call: CachedChannelData.ActiveCall(id: initialCall.id, accessHash: initialCall.accessHash, title: initialCall.title, scheduleTimestamp: initialCall.scheduleTimestamp, subscribedToScheduled: initialCall.subscribedToScheduled))
         }) {
             self.switchToTemporaryParticipantsContext(sourceContext: temporaryParticipantsContext.context.participantsContext, oldMyPeerId: self.joinAsPeerId)
         } else {
@@ -966,11 +965,11 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
         }
         |> beforeNext { view in
             if let view = view, view.1 == nil {
-                let _ = fetchAndUpdateCachedPeerData(accountPeerId: accountContext.account.peerId, peerId: myPeerId, network: accountContext.account.network, postbox: accountContext.account.postbox).start()
+                let _ = accountContext.engine.peers.fetchAndUpdateCachedPeerData(peerId: myPeerId).start()
             }
         }
         if let sourceContext = sourceContext, let initialState = sourceContext.immediateState {
-            let temporaryParticipantsContext = GroupCallParticipantsContext(account: self.account, peerId: self.peerId, myPeerId: myPeerId, id: sourceContext.id, accessHash: sourceContext.accessHash, state: initialState, previousServiceState: sourceContext.serviceState)
+            let temporaryParticipantsContext = self.accountContext.engine.calls.groupCall(peerId: self.peerId, myPeerId: myPeerId, id: sourceContext.id, accessHash: sourceContext.accessHash, state: initialState, previousServiceState: sourceContext.serviceState)
             self.temporaryParticipantsContext = temporaryParticipantsContext
             self.participantsContextStateDisposable.set((combineLatest(queue: .mainQueue(),
                 myPeer,
@@ -1192,8 +1191,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
         }
         |> distinctUntilChanged
 
-        let participantsContext = GroupCallParticipantsContext(
-            account: self.accountContext.account,
+        let participantsContext = self.accountContext.engine.calls.groupCall(
             peerId: self.peerId,
             myPeerId: self.joinAsPeerId,
             id: callInfo.id,
@@ -1229,7 +1227,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
         }
         |> beforeNext { view in
             if let view = view, view.1 == nil {
-                let _ = fetchAndUpdateCachedPeerData(accountPeerId: accountContext.account.peerId, peerId: myPeerId, network: accountContext.account.network, postbox: accountContext.account.postbox).start()
+                let _ = accountContext.engine.peers.fetchAndUpdateCachedPeerData(peerId: myPeerId).start()
             }
         }
         self.participantsContextStateDisposable.set(combineLatest(queue: .mainQueue(),
@@ -1399,7 +1397,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
                         disposable.set(strongSelf.requestMediaChannelDescriptions(ssrcs: ssrcs, completion: completion))
                     }
                     return disposable
-                }, audioStreamData: OngoingGroupCallContext.AudioStreamData(account: self.accountContext.account, callId: callInfo.id, accessHash: callInfo.accessHash), rejoinNeeded: { [weak self] in
+                }, audioStreamData: OngoingGroupCallContext.AudioStreamData(engine: self.accountContext.engine, callId: callInfo.id, accessHash: callInfo.accessHash), rejoinNeeded: { [weak self] in
                     Queue.mainQueue().async {
                         guard let strongSelf = self else {
                             return
@@ -1464,8 +1462,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
                 }
 
                 strongSelf.currentLocalSsrc = ssrc
-                strongSelf.requestDisposable.set((joinGroupCall(
-                    account: strongSelf.account,
+                strongSelf.requestDisposable.set((strongSelf.accountContext.engine.calls.joinGroupCall(
                     peerId: strongSelf.peerId,
                     joinAs: strongSelf.joinAsPeerId,
                     callId: callInfo.id,
@@ -1525,7 +1522,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
                         ]), on: .root, blockInteraction: false, completion: {})
                     } else if case .invalidJoinAsPeer = error {
                         let peerId = strongSelf.peerId
-                        let _ = clearCachedGroupCallDisplayAsAvailablePeers(account: strongSelf.accountContext.account, peerId: peerId).start()
+                        let _ = strongSelf.accountContext.engine.calls.clearCachedGroupCallDisplayAsAvailablePeers(peerId: peerId).start()
                         let _ = (strongSelf.accountContext.account.postbox.transaction { transaction -> Void in
                             transaction.updatePeerCachedData(peerIds: Set([peerId]), update: { _, current in
                                 if let current = current as? CachedChannelData {
@@ -1749,8 +1746,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
                     serviceState = participantsContext.serviceState
                 }
                 
-                let participantsContext = GroupCallParticipantsContext(
-                    account: self.accountContext.account,
+                let participantsContext = self.accountContext.engine.calls.groupCall(
                     peerId: self.peerId,
                     myPeerId: self.joinAsPeerId,
                     id: callInfo.id,
@@ -1770,7 +1766,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
                 }
                 |> beforeNext { view in
                     if let view = view, view.1 == nil {
-                        let _ = fetchAndUpdateCachedPeerData(accountPeerId: accountContext.account.peerId, peerId: myPeerId, network: accountContext.account.network, postbox: accountContext.account.postbox).start()
+                        let _ = accountContext.engine.peers.fetchAndUpdateCachedPeerData(peerId: myPeerId).start()
                     }
                 }
                 
@@ -2105,7 +2101,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
         }
 
         if !remainingSsrcs.isEmpty, let callInfo = self.internalState.callInfo {
-            return (getGroupCallParticipants(account: self.account, callId: callInfo.id, accessHash: callInfo.accessHash, offset: "", ssrcs: Array(remainingSsrcs), limit: 100, sortAscending: callInfo.sortAscending)
+            return (self.accountContext.engine.calls.getGroupCallParticipants(callId: callInfo.id, accessHash: callInfo.accessHash, offset: "", ssrcs: Array(remainingSsrcs), limit: 100, sortAscending: callInfo.sortAscending)
             |> deliverOnMainQueue).start(next: { state in
                 extractMediaChannelDescriptions(remainingSsrcs: &remainingSsrcs, participants: state.participants, into: &result)
 
@@ -2122,7 +2118,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
             return
         }
         if case let .established(callInfo, connectionMode, _, ssrc, _) = self.internalState, case .rtc = connectionMode {
-            let checkSignal = checkGroupCall(account: self.account, callId: callInfo.id, accessHash: callInfo.accessHash, ssrcs: [ssrc])
+            let checkSignal = self.accountContext.engine.calls.checkGroupCall(callId: callInfo.id, accessHash: callInfo.accessHash, ssrcs: [ssrc])
             
             self.checkCallDisposable = ((
                 checkSignal
@@ -2288,7 +2284,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
         self.leaving = true
         if let callInfo = self.internalState.callInfo {
             if terminateIfPossible {
-                self.leaveDisposable.set((stopGroupCall(account: self.account, peerId: self.peerId, callId: callInfo.id, accessHash: callInfo.accessHash)
+                self.leaveDisposable.set((self.accountContext.engine.calls.stopGroupCall(peerId: self.peerId, callId: callInfo.id, accessHash: callInfo.accessHash)
                 |> deliverOnMainQueue).start(completed: { [weak self] in
                     guard let strongSelf = self else {
                         return
@@ -2297,12 +2293,12 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
                 }))
             } else if let localSsrc = self.currentLocalSsrc {
                 if let contexts = self.accountContext.cachedGroupCallContexts as? AccountGroupCallContextCacheImpl {
-                    let account = self.account
+                    let engine = self.accountContext.engine
                     let id = callInfo.id
                     let accessHash = callInfo.accessHash
                     let source = localSsrc
                     contexts.impl.with { impl in
-                        impl.leaveInBackground(account: account, id: id, accessHash: accessHash, source: source)
+                        impl.leaveInBackground(engine: engine, id: id, accessHash: accessHash, source: source)
                     }
                 }
                 self.markAsCanBeRemoved()
@@ -2365,7 +2361,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
         
         self.stateValue.subscribedToScheduled = subscribe
         
-        self.subscribeDisposable.set((toggleScheduledGroupCallSubscription(account: self.account, peerId: self.peerId, callId: callInfo.id, accessHash: callInfo.accessHash, subscribe: subscribe)
+        self.subscribeDisposable.set((self.accountContext.engine.calls.toggleScheduledGroupCallSubscription(peerId: self.peerId, callId: callInfo.id, accessHash: callInfo.accessHash, subscribe: subscribe)
         |> deliverOnMainQueue).start())
     }
     
@@ -2383,7 +2379,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
             activeSpeakers: Set()
         )))
         
-        self.startDisposable.set((createGroupCall(account: self.account, peerId: self.peerId, title: nil, scheduleDate: timestamp)
+        self.startDisposable.set((self.accountContext.engine.calls.createGroupCall(peerId: self.peerId, title: nil, scheduleDate: timestamp)
         |> deliverOnMainQueue).start(next: { [weak self] callInfo in
             guard let strongSelf = self else {
                 return
@@ -2405,7 +2401,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
         self.isScheduledStarted = true
         self.stateValue.scheduleTimestamp = nil
         
-        self.startDisposable.set((startScheduledGroupCall(account: self.account, peerId: self.peerId, callId: callInfo.id, accessHash: callInfo.accessHash)
+        self.startDisposable.set((self.accountContext.engine.calls.startScheduledGroupCall(peerId: self.peerId, callId: callInfo.id, accessHash: callInfo.accessHash)
         |> deliverOnMainQueue).start(next: { [weak self] callInfo in
             guard let strongSelf = self else {
                 return
@@ -2661,8 +2657,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
                 return
             }
 
-            strongSelf.requestDisposable.set((joinGroupCallAsScreencast(
-                account: strongSelf.account,
+            strongSelf.requestDisposable.set((strongSelf.accountContext.engine.calls.joinGroupCallAsScreencast(
                 peerId: strongSelf.peerId,
                 callId: callInfo.id,
                 accessHash: callInfo.accessHash,
@@ -2693,8 +2688,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
             let maybeCallInfo: GroupCallInfo? = self.internalState.callInfo
 
             if let callInfo = maybeCallInfo {
-                self.screencastJoinDisposable.set(leaveGroupCallAsScreencast(
-                    account: self.account,
+                self.screencastJoinDisposable.set(self.accountContext.engine.calls.leaveGroupCallAsScreencast(
                     callId: callInfo.id,
                     accessHash: callInfo.accessHash
                 ).start())
@@ -2702,19 +2696,6 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
             
             self.screencastBufferServerContext?.stopScreencast()
         }
-        /*if let _ = self.screencastIpcContext {
-            self.screencastIpcContext = nil
-
-            let maybeCallInfo: GroupCallInfo? = self.internalState.callInfo
-
-            if let callInfo = maybeCallInfo {
-                self.screencastJoinDisposable.set(leaveGroupCallAsScreencast(
-                    account: self.account,
-                    callId: callInfo.id,
-                    accessHash: callInfo.accessHash
-                ).start())
-            }
-        }*/
     }
     
     public func setVolume(peerId: PeerId, volume: Int32, sync: Bool) {
@@ -2894,9 +2875,10 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
         }
         
         let account = self.account
+        let context = self.accountContext
         let currentCall: Signal<GroupCallInfo?, CallError>
         if let initialCall = self.initialCall {
-            currentCall = getCurrentGroupCall(account: account, callId: initialCall.id, accessHash: initialCall.accessHash)
+            currentCall = context.engine.calls.getCurrentGroupCall(callId: initialCall.id, accessHash: initialCall.accessHash)
             |> mapError { _ -> CallError in
                 return .generic
             }
@@ -2904,7 +2886,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
                 return summary?.info
             }
         } else if case let .active(callInfo) = self.internalState {
-            currentCall = getCurrentGroupCall(account: account, callId: callInfo.id, accessHash: callInfo.accessHash)
+            currentCall = context.engine.calls.getCurrentGroupCall(callId: callInfo.id, accessHash: callInfo.accessHash)
             |> mapError { _ -> CallError in
                 return .generic
             }
@@ -2961,7 +2943,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
         updatedInvitedPeers.insert(peerId, at: 0)
         self.invitedPeersValue = updatedInvitedPeers
         
-        let _ = inviteToGroupCall(account: self.account, callId: callInfo.id, accessHash: callInfo.accessHash, peerId: peerId).start()
+        let _ = self.accountContext.engine.calls.inviteToGroupCall(callId: callInfo.id, accessHash: callInfo.accessHash, peerId: peerId).start()
         
         return true
     }
@@ -2977,10 +2959,12 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
             return
         }
         self.stateValue.title = title.isEmpty ? nil : title
-        let _ = editGroupCallTitle(account: self.account, callId: callInfo.id, accessHash: callInfo.accessHash, title: title).start()
+        let _ = self.accountContext.engine.calls.editGroupCallTitle(callId: callInfo.id, accessHash: callInfo.accessHash, title: title).start()
     }
     
     public var inviteLinks: Signal<GroupCallInviteLinks?, NoError> {
+        let engine = self.accountContext.engine
+
         return self.state
         |> map { state -> PeerId in
             return state.myPeerId
@@ -2997,7 +2981,7 @@ public final class PresentationGroupCallImpl: PresentationGroupCall {
             }
             |> mapToSignal { state in
                 if let callInfo =  state.callInfo {
-                    return groupCallInviteLinks(account: self.account, callId: callInfo.id, accessHash: callInfo.accessHash)
+                    return engine.calls.groupCallInviteLinks(callId: callInfo.id, accessHash: callInfo.accessHash)
                 } else {
                     return .complete()
                 }

submodules/TelegramCallsUI/Sources/VideoRenderingContext.swift

@@ -19,6 +19,8 @@ protocol VideoRenderingView: UIView {
 class VideoRenderingContext {
     private var metalContextImpl: Any?
 
+    #if targetEnvironment(simulator)
+    #else
     @available(iOS 13.0, *)
     var metalContext: MetalVideoRenderingContext {
         if let value = self.metalContextImpl as? MetalVideoRenderingContext {
@@ -29,19 +31,27 @@ class VideoRenderingContext {
             return value
         }
     }
+    #endif
 
     func makeView(input: Signal<OngoingGroupCallContext.VideoFrameData, NoError>, blur: Bool) -> VideoRenderingView? {
+        #if targetEnvironment(simulator)
+        return SampleBufferVideoRenderingView(input: input)
+        #else
         if #available(iOS 13.0, *) {
             return MetalVideoRenderingView(renderingContext: self.metalContext, input: input, blur: blur)
         } else {
             return SampleBufferVideoRenderingView(input: input)
         }
+        #endif
     }
 
     func updateVisibility(isVisible: Bool) {
+        #if targetEnvironment(simulator)
+        #else
         if #available(iOS 13.0, *) {
             self.metalContext.updateVisibility(isVisible: isVisible)
         }
+        #endif
     }
 }
 

submodules/TelegramCallsUI/Sources/VoiceChatController.swift

@@ -1167,7 +1167,7 @@ public final class VoiceChatController: ViewController {
             
             let displayAsPeers: Signal<[FoundPeer], NoError> = currentAccountPeer
             |> then(
-                combineLatest(currentAccountPeer, cachedGroupCallDisplayAsAvailablePeers(account: context.account, peerId: call.peerId))
+                combineLatest(currentAccountPeer, context.engine.calls.cachedGroupCallDisplayAsAvailablePeers(peerId: call.peerId))
                 |> map { currentAccountPeer, availablePeers -> [FoundPeer] in
                     var result = currentAccountPeer
                     result.append(contentsOf: availablePeers)
@@ -1553,7 +1553,7 @@ public final class VoiceChatController: ViewController {
                                                 return .complete()
                                             }).start()
                                         } else {
-                                            let _ = (updatePeerDescription(account: strongSelf.context.account, peerId: peer.id, description: bio)
+                                            let _ = (strongSelf.context.engine.peers.updatePeerDescription(peerId: peer.id, description: bio)
                                             |> `catch` { _ -> Signal<Void, NoError> in
                                                 return .complete()
                                             }).start()
@@ -5936,7 +5936,7 @@ public final class VoiceChatController: ViewController {
                     let proceed = {
                         let _ = strongSelf.currentAvatarMixin.swap(nil)
                         let postbox = strongSelf.context.account.postbox
-                        strongSelf.updateAvatarDisposable.set((updatePeerPhoto(postbox: strongSelf.context.account.postbox, network: strongSelf.context.account.network, stateManager: strongSelf.context.account.stateManager, accountPeerId: strongSelf.context.account.peerId, peerId: peerId, photo: nil, mapResourceToAvatarSizes: { resource, representations in
+                        strongSelf.updateAvatarDisposable.set((strongSelf.context.engine.peers.updatePeerPhoto(peerId: peerId, photo: nil, mapResourceToAvatarSizes: { resource, representations in
                             return mapResourceToAvatarSizes(postbox: postbox, resource: resource, representations: representations)
                         })
                         |> deliverOnMainQueue).start())
@@ -5989,9 +5989,9 @@ public final class VoiceChatController: ViewController {
             self.updateAvatarPromise.set(.single((representation, 0.0)))
 
             let postbox = self.call.account.postbox
-            let signal = peerId.namespace == Namespaces.Peer.CloudUser ? updateAccountPhoto(account: self.call.account, resource: resource, videoResource: nil, videoStartTimestamp: nil, mapResourceToAvatarSizes: { resource, representations in
+            let signal = peerId.namespace == Namespaces.Peer.CloudUser ? self.call.accountContext.engine.accountData.updateAccountPhoto(resource: resource, videoResource: nil, videoStartTimestamp: nil, mapResourceToAvatarSizes: { resource, representations in
                 return mapResourceToAvatarSizes(postbox: postbox, resource: resource, representations: representations)
-            }) : updatePeerPhoto(postbox: postbox, network: self.call.account.network, stateManager: self.call.account.stateManager, accountPeerId: self.context.account.peerId, peerId: peerId, photo: uploadedPeerPhoto(postbox: postbox, network: self.call.account.network, resource: resource), mapResourceToAvatarSizes: { resource, representations in
+            }) : self.call.accountContext.engine.peers.updatePeerPhoto(peerId: peerId, photo: self.call.accountContext.engine.peers.uploadedPeerPhoto(resource: resource), mapResourceToAvatarSizes: { resource, representations in
                 return mapResourceToAvatarSizes(postbox: postbox, resource: resource, representations: representations)
             })
             
@@ -6027,7 +6027,8 @@ public final class VoiceChatController: ViewController {
             if let adjustments = adjustments, adjustments.videoStartValue > 0.0 {
                 videoStartTimestamp = adjustments.videoStartValue - adjustments.trimStartValue
             }
-            
+
+            let context = self.context
             let account = self.context.account
             let signal = Signal<TelegramMediaResource, UploadPeerPhotoError> { [weak self] subscriber in
                 let entityRenderer: LegacyPaintEntityRenderer? = adjustments.flatMap { adjustments in
@@ -6037,7 +6038,7 @@ public final class VoiceChatController: ViewController {
                         return nil
                     }
                 }
-                let uploadInterface = LegacyLiveUploadInterface(account: account)
+                let uploadInterface = LegacyLiveUploadInterface(context: context)
                 let signal: SSignal
                 if let asset = asset as? AVAsset {
                     signal = TGMediaVideoConverter.convert(asset, adjustments: adjustments, watcher: uploadInterface, entityRenderer: entityRenderer)!
@@ -6108,11 +6109,11 @@ public final class VoiceChatController: ViewController {
             self.updateAvatarDisposable.set((signal
             |> mapToSignal { videoResource -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in
                 if peerId.namespace == Namespaces.Peer.CloudUser {
-                    return updateAccountPhoto(account: account, resource: photoResource, videoResource: videoResource, videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: { resource, representations in
+                    return context.engine.accountData.updateAccountPhoto(resource: photoResource, videoResource: videoResource, videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: { resource, representations in
                         return mapResourceToAvatarSizes(postbox: account.postbox, resource: resource, representations: representations)
                     })
                 } else {
-                    return updatePeerPhoto(postbox: account.postbox, network: account.network, stateManager: account.stateManager, accountPeerId: account.peerId, peerId: peerId, photo: uploadedPeerPhoto(postbox: account.postbox, network: account.network, resource: photoResource), video: uploadedPeerVideo(postbox: account.postbox, network: account.network, messageMediaPreuploadManager: account.messageMediaPreuploadManager, resource: videoResource) |> map(Optional.init), videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: { resource, representations in
+                    return context.engine.peers.updatePeerPhoto(peerId: peerId, photo: context.engine.peers.uploadedPeerPhoto(resource: photoResource), video: context.engine.peers.uploadedPeerVideo(resource: videoResource) |> map(Optional.init), videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: { resource, representations in
                         return mapResourceToAvatarSizes(postbox: account.postbox, resource: resource, representations: representations)
                     })
                 }

submodules/TelegramCallsUI/Sources/VoiceChatJoinScreen.swift

@@ -72,7 +72,7 @@ public final class VoiceChatJoinScreen: ViewController {
         let context = self.context
         let peerId = self.peerId
         let invite = self.invite
-        let signal = updatedCurrentPeerGroupCall(account: context.account, peerId: peerId)
+        let signal = context.engine.calls.updatedCurrentPeerGroupCall(peerId: peerId)
         |> castError(GetCurrentGroupCallError.self)
         |> mapToSignal { call -> Signal<(Peer, GroupCallSummary)?, GetCurrentGroupCallError> in
             if let call = call {
@@ -80,7 +80,7 @@ public final class VoiceChatJoinScreen: ViewController {
                     return transaction.getPeer(peerId)
                 }
                 |> castError(GetCurrentGroupCallError.self)
-                return combineLatest(peer, getCurrentGroupCall(account: context.account, callId: call.id, accessHash: call.accessHash))
+                return combineLatest(peer, context.engine.calls.getCurrentGroupCall(callId: call.id, accessHash: call.accessHash))
                 |> map { peer, call -> (Peer, GroupCallSummary)? in
                     if let peer = peer, let call = call {
                         return (peer, call)
@@ -125,7 +125,7 @@ public final class VoiceChatJoinScreen: ViewController {
             currentGroupCall = .single(nil)
         }
             
-        self.disposable.set(combineLatest(queue: Queue.mainQueue(), signal, cachedGroupCallDisplayAsAvailablePeers(account: context.account, peerId: peerId) |> castError(GetCurrentGroupCallError.self), cachedData, currentGroupCall).start(next: { [weak self] peerAndCall, availablePeers, cachedData, currentGroupCallIdAndCanUnmute in
+        self.disposable.set(combineLatest(queue: Queue.mainQueue(), signal, context.engine.calls.cachedGroupCallDisplayAsAvailablePeers(peerId: peerId) |> castError(GetCurrentGroupCallError.self), cachedData, currentGroupCall).start(next: { [weak self] peerAndCall, availablePeers, cachedData, currentGroupCallIdAndCanUnmute in
             if let strongSelf = self {
                 if let (peer, call) = peerAndCall {
                     if let (currentGroupCall, currentGroupCallId, canUnmute) = currentGroupCallIdAndCanUnmute, call.info.id == currentGroupCallId {

submodules/TelegramCore/Sources/Account/Account.swift

@@ -852,7 +852,7 @@ public class Account {
     public private(set) var viewTracker: AccountViewTracker!
     public private(set) var pendingMessageManager: PendingMessageManager!
     public private(set) var pendingUpdateMessageManager: PendingUpdateMessageManager!
-    public private(set) var messageMediaPreuploadManager: MessageMediaPreuploadManager!
+    private(set) var messageMediaPreuploadManager: MessageMediaPreuploadManager!
     private(set) var mediaReferenceRevalidationContext: MediaReferenceRevalidationContext!
     private var peerInputActivityManager: PeerInputActivityManager!
     private var localInputActivityManager: PeerInputActivityManager!

submodules/TelegramCore/Sources/Authorization.swift

@@ -533,7 +533,7 @@ public func signUpWithName(accountManager: AccountManager, account: Unauthorized
                         let resource = LocalFileMediaResource(fileId: Int64.random(in: Int64.min ... Int64.max))
                         account.postbox.mediaBox.storeResourceData(resource.id, data: avatarData)
                         
-                        return updatePeerPhotoInternal(postbox: account.postbox, network: account.network, stateManager: nil, accountPeerId: user.id, peer: .single(user), photo: uploadedPeerPhoto(postbox: account.postbox, network: account.network, resource: resource), video: avatarVideo, videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: { _, _ in .single([:]) })
+                        return _internal_updatePeerPhotoInternal(postbox: account.postbox, network: account.network, stateManager: nil, accountPeerId: user.id, peer: .single(user), photo: _internal_uploadedPeerPhoto(postbox: account.postbox, network: account.network, resource: resource), video: avatarVideo, videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: { _, _ in .single([:]) })
                             |> `catch` { _ -> Signal<UpdatePeerPhotoStatus, SignUpError> in
                                 return .complete()
                             }

submodules/TelegramCore/Sources/State/AccountViewTracker.swift

@@ -1236,7 +1236,7 @@ public final class AccountViewTracker {
                 return
             }
             let queue = self.queue
-            context.disposable.set(combineLatest(fetchAndUpdateSupplementalCachedPeerData(peerId: peerId, network: account.network, postbox: account.postbox), fetchAndUpdateCachedPeerData(accountPeerId: account.peerId, peerId: peerId, network: account.network, postbox: account.postbox)).start(next: { [weak self] supplementalStatus, cachedStatus in
+            context.disposable.set(combineLatest(fetchAndUpdateSupplementalCachedPeerData(peerId: peerId, network: account.network, postbox: account.postbox), _internal_fetchAndUpdateCachedPeerData(accountPeerId: account.peerId, peerId: peerId, network: account.network, postbox: account.postbox)).start(next: { [weak self] supplementalStatus, cachedStatus in
                 queue.async {
                     guard let strongSelf = self else {
                         return
@@ -1278,7 +1278,7 @@ public final class AccountViewTracker {
                     return
                 }
                 let queue = self.queue
-                context.disposable.set(combineLatest(fetchAndUpdateSupplementalCachedPeerData(peerId: peerId, network: account.network, postbox: account.postbox), fetchAndUpdateCachedPeerData(accountPeerId: account.peerId, peerId: peerId, network: account.network, postbox: account.postbox)).start(next: { [weak self] supplementalStatus, cachedStatus in
+                context.disposable.set(combineLatest(fetchAndUpdateSupplementalCachedPeerData(peerId: peerId, network: account.network, postbox: account.postbox), _internal_fetchAndUpdateCachedPeerData(accountPeerId: account.peerId, peerId: peerId, network: account.network, postbox: account.postbox)).start(next: { [weak self] supplementalStatus, cachedStatus in
                     queue.async {
                         guard let strongSelf = self else {
                             return

submodules/TelegramCore/Sources/State/MessageMediaPreuploadManager.swift

@@ -33,7 +33,7 @@ private final class MessageMediaPreuploadManagerContext {
         assert(self.queue.isCurrent())
     }
     
-    func add(network: Network, postbox: Postbox, id: Int64, encrypt: Bool, tag: MediaResourceFetchTag?, source: Signal<MediaResourceData, NoError>, onComplete:(()->Void)? = nil) {
+    func add(network: Network, postbox: Postbox, id: Int64, encrypt: Bool, tag: MediaResourceFetchTag?, source: Signal<MediaResourceData, NoError>, onComplete: (()->Void)? = nil) {
         let context = MessageMediaPreuploadManagerUploadContext()
         self.uploadContexts[id] = context
         let queue = self.queue
@@ -103,7 +103,7 @@ private final class MessageMediaPreuploadManagerContext {
     }
 }
 
-public final class MessageMediaPreuploadManager {
+final class MessageMediaPreuploadManager {
     private let impl: QueueLocalObject<MessageMediaPreuploadManagerContext>
     
     init() {
@@ -113,7 +113,7 @@ public final class MessageMediaPreuploadManager {
         })
     }
     
-    public func add(network: Network, postbox: Postbox, id: Int64, encrypt: Bool, tag: MediaResourceFetchTag?, source: Signal<MediaResourceData, NoError>, onComplete:(()->Void)? = nil) {
+    func add(network: Network, postbox: Postbox, id: Int64, encrypt: Bool, tag: MediaResourceFetchTag?, source: Signal<MediaResourceData, NoError>, onComplete:(()->Void)? = nil) {
         self.impl.with { context in
             context.add(network: network, postbox: postbox, id: id, encrypt: encrypt, tag: tag, source: source, onComplete: onComplete)
         }

submodules/TelegramCore/Sources/TelegramEngine/AccountData/TelegramEngineAccountData.swift

@@ -46,5 +46,17 @@ public extension TelegramEngine {
         public func registerNotificationToken(token: Data, type: NotificationTokenType, sandbox: Bool, otherAccountUserIds: [PeerId.Id], excludeMutedChats: Bool) -> Signal<Never, NoError> {
             return _internal_registerNotificationToken(account: self.account, token: token, type: type, sandbox: sandbox, otherAccountUserIds: otherAccountUserIds, excludeMutedChats: excludeMutedChats)
         }
+
+        public func updateAccountPhoto(resource: MediaResource?, videoResource: MediaResource?, videoStartTimestamp: Double?, mapResourceToAvatarSizes: @escaping (MediaResource, [TelegramMediaImageRepresentation]) -> Signal<[Int: Data], NoError>) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> {
+            return _internal_updateAccountPhoto(account: self.account, resource: resource, videoResource: videoResource, videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: mapResourceToAvatarSizes)
+        }
+
+        public func updatePeerPhotoExisting(reference: TelegramMediaImageReference) -> Signal<TelegramMediaImage?, NoError> {
+            return _internal_updatePeerPhotoExisting(network: self.account.network, reference: reference)
+        }
+
+        public func removeAccountPhoto(reference: TelegramMediaImageReference?) -> Signal<Void, NoError> {
+            return _internal_removeAccountPhoto(network: self.account.network, reference: reference)
+        }
     }
 }

submodules/TelegramCore/Sources/TelegramEngine/Auth/TelegramEngineAuth.swift

@@ -39,6 +39,10 @@ public extension TelegramEngineUnauthorized {
         public func resendTwoStepRecoveryEmail() -> Signal<Never, ResendTwoStepRecoveryEmailError> {
             return _internal_resendTwoStepRecoveryEmail(network: self.account.network)
         }
+
+        public func uploadedPeerVideo(resource: MediaResource) -> Signal<UploadedPeerPhotoData, NoError> {
+            return _internal_uploadedPeerVideo(postbox: self.account.postbox, network: self.account.network, messageMediaPreuploadManager: nil, resource: resource)
+        }
     }
 }
 

submodules/TelegramCore/Sources/TelegramEngine/Calls/GroupCalls.swift

@@ -80,7 +80,7 @@ public enum GetCurrentGroupCallError {
     case generic
 }
 
-public func getCurrentGroupCall(account: Account, callId: Int64, accessHash: Int64, peerId: PeerId? = nil) -> Signal<GroupCallSummary?, GetCurrentGroupCallError> {
+func _internal_getCurrentGroupCall(account: Account, callId: Int64, accessHash: Int64, peerId: PeerId? = nil) -> Signal<GroupCallSummary?, GetCurrentGroupCallError> {
     return account.network.request(Api.functions.phone.getGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash)))
     |> mapError { _ -> GetCurrentGroupCallError in
         return .generic
@@ -144,7 +144,7 @@ public enum CreateGroupCallError {
     case scheduledTooLate
 }
 
-public func createGroupCall(account: Account, peerId: PeerId, title: String?, scheduleDate: Int32?) -> Signal<GroupCallInfo, CreateGroupCallError> {
+func _internal_createGroupCall(account: Account, peerId: PeerId, title: String?, scheduleDate: Int32?) -> Signal<GroupCallInfo, CreateGroupCallError> {
     return account.postbox.transaction { transaction -> Api.InputPeer? in
         let callPeer = transaction.getPeer(peerId).flatMap(apiInputPeer)
         return callPeer
@@ -210,7 +210,7 @@ public enum StartScheduledGroupCallError {
     case generic
 }
 
-public func startScheduledGroupCall(account: Account, peerId: PeerId, callId: Int64, accessHash: Int64) -> Signal<GroupCallInfo, StartScheduledGroupCallError> {
+func _internal_startScheduledGroupCall(account: Account, peerId: PeerId, callId: Int64, accessHash: Int64) -> Signal<GroupCallInfo, StartScheduledGroupCallError> {
     return account.network.request(Api.functions.phone.startScheduledGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash)))
     |> mapError { error -> StartScheduledGroupCallError in
         return .generic
@@ -254,7 +254,7 @@ public enum ToggleScheduledGroupCallSubscriptionError {
     case generic
 }
 
-public func toggleScheduledGroupCallSubscription(account: Account, peerId: PeerId, callId: Int64, accessHash: Int64, subscribe: Bool) -> Signal<Void, ToggleScheduledGroupCallSubscriptionError> {
+func _internal_toggleScheduledGroupCallSubscription(account: Account, peerId: PeerId, callId: Int64, accessHash: Int64, subscribe: Bool) -> Signal<Void, ToggleScheduledGroupCallSubscriptionError> {
     return account.network.request(Api.functions.phone.toggleGroupCallStartSubscription(call: .inputGroupCall(id: callId, accessHash: accessHash), subscribed: subscribe ? .boolTrue : .boolFalse))
     |> mapError { error -> ToggleScheduledGroupCallSubscriptionError in
         return .generic
@@ -296,7 +296,7 @@ public enum UpdateGroupCallJoinAsPeerError {
     case generic
 }
 
-public func updateGroupCallJoinAsPeer(account: Account, peerId: PeerId, joinAs: PeerId) -> Signal<Never, UpdateGroupCallJoinAsPeerError> {
+func _internal_updateGroupCallJoinAsPeer(account: Account, peerId: PeerId, joinAs: PeerId) -> Signal<Never, UpdateGroupCallJoinAsPeerError> {
     return account.postbox.transaction { transaction -> (Api.InputPeer, Api.InputPeer)? in
         if let peer = transaction.getPeer(peerId), let joinAsPeer = transaction.getPeer(joinAs), let inputPeer = apiInputPeer(peer), let joinInputPeer = apiInputPeer(joinAsPeer) {
             return (inputPeer, joinInputPeer)
@@ -335,10 +335,10 @@ public enum GetGroupCallParticipantsError {
     case generic
 }
 
-public func getGroupCallParticipants(account: Account, callId: Int64, accessHash: Int64, offset: String, ssrcs: [UInt32], limit: Int32, sortAscending: Bool?) -> Signal<GroupCallParticipantsContext.State, GetGroupCallParticipantsError> {
+func _internal_getGroupCallParticipants(account: Account, callId: Int64, accessHash: Int64, offset: String, ssrcs: [UInt32], limit: Int32, sortAscending: Bool?) -> Signal<GroupCallParticipantsContext.State, GetGroupCallParticipantsError> {
     let sortAscendingValue: Signal<(Bool, Int32?, Bool, GroupCallParticipantsContext.State.DefaultParticipantsAreMuted?, Bool, Int), GetGroupCallParticipantsError>
     
-    sortAscendingValue = getCurrentGroupCall(account: account, callId: callId, accessHash: accessHash)
+    sortAscendingValue = _internal_getCurrentGroupCall(account: account, callId: callId, accessHash: accessHash)
     |> mapError { _ -> GetGroupCallParticipantsError in
         return .generic
     }
@@ -443,7 +443,7 @@ public struct JoinGroupCallResult {
     public var jsonParams: String
 }
 
-public func joinGroupCall(account: Account, peerId: PeerId, joinAs: PeerId?, callId: Int64, accessHash: Int64, preferMuted: Bool, joinPayload: String, peerAdminIds: Signal<[PeerId], NoError>, inviteHash: String? = nil) -> Signal<JoinGroupCallResult, JoinGroupCallError> {
+func _internal_joinGroupCall(account: Account, peerId: PeerId, joinAs: PeerId?, callId: Int64, accessHash: Int64, preferMuted: Bool, joinPayload: String, peerAdminIds: Signal<[PeerId], NoError>, inviteHash: String? = nil) -> Signal<JoinGroupCallResult, JoinGroupCallError> {
     return account.postbox.transaction { transaction -> Api.InputPeer? in
         if let joinAs = joinAs {
             return transaction.getPeer(joinAs).flatMap(apiInputPeer)
@@ -498,7 +498,7 @@ public func joinGroupCall(account: Account, peerId: PeerId, joinAs: PeerId?, cal
             }
         }
 
-        let getParticipantsRequest = getGroupCallParticipants(account: account, callId: callId, accessHash: accessHash, offset: "", ssrcs: [], limit: 100, sortAscending: true)
+        let getParticipantsRequest = _internal_getGroupCallParticipants(account: account, callId: callId, accessHash: accessHash, offset: "", ssrcs: [], limit: 100, sortAscending: true)
         |> mapError { _ -> JoinGroupCallError in
             return .generic
         }
@@ -687,7 +687,7 @@ public struct JoinGroupCallAsScreencastResult {
     public var endpointId: String
 }
 
-public func joinGroupCallAsScreencast(account: Account, peerId: PeerId, callId: Int64, accessHash: Int64, joinPayload: String) -> Signal<JoinGroupCallAsScreencastResult, JoinGroupCallError> {
+func _internal_joinGroupCallAsScreencast(account: Account, peerId: PeerId, callId: Int64, accessHash: Int64, joinPayload: String) -> Signal<JoinGroupCallAsScreencastResult, JoinGroupCallError> {
     return account.network.request(Api.functions.phone.joinGroupCallPresentation(call: .inputGroupCall(id: callId, accessHash: accessHash), params: .dataJSON(data: joinPayload)))
     |> mapError { _ -> JoinGroupCallError in
         return .generic
@@ -735,7 +735,7 @@ public enum LeaveGroupCallAsScreencastError {
     case generic
 }
 
-public func leaveGroupCallAsScreencast(account: Account, callId: Int64, accessHash: Int64) -> Signal<Never, LeaveGroupCallAsScreencastError> {
+func _internal_leaveGroupCallAsScreencast(account: Account, callId: Int64, accessHash: Int64) -> Signal<Never, LeaveGroupCallAsScreencastError> {
     return account.network.request(Api.functions.phone.leaveGroupCallPresentation(call: .inputGroupCall(id: callId, accessHash: accessHash)))
     |> mapError { _ -> LeaveGroupCallAsScreencastError in
         return .generic
@@ -751,7 +751,7 @@ public enum LeaveGroupCallError {
     case generic
 }
 
-public func leaveGroupCall(account: Account, callId: Int64, accessHash: Int64, source: UInt32) -> Signal<Never, LeaveGroupCallError> {
+func _internal_leaveGroupCall(account: Account, callId: Int64, accessHash: Int64, source: UInt32) -> Signal<Never, LeaveGroupCallError> {
     return account.network.request(Api.functions.phone.leaveGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash), source: Int32(bitPattern: source)))
     |> mapError { _ -> LeaveGroupCallError in
         return .generic
@@ -767,7 +767,7 @@ public enum StopGroupCallError {
     case generic
 }
 
-public func stopGroupCall(account: Account, peerId: PeerId, callId: Int64, accessHash: Int64) -> Signal<Never, StopGroupCallError> {
+func _internal_stopGroupCall(account: Account, peerId: PeerId, callId: Int64, accessHash: Int64) -> Signal<Never, StopGroupCallError> {
     return account.network.request(Api.functions.phone.discardGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash)))
     |> mapError { _ -> StopGroupCallError in
         return .generic
@@ -809,7 +809,7 @@ public func stopGroupCall(account: Account, peerId: PeerId, callId: Int64, acces
     }
 }
 
-public func checkGroupCall(account: Account, callId: Int64, accessHash: Int64, ssrcs: [UInt32]) -> Signal<[UInt32], NoError> {
+func _internal_checkGroupCall(account: Account, callId: Int64, accessHash: Int64, ssrcs: [UInt32]) -> Signal<[UInt32], NoError> {
     return account.network.request(Api.functions.phone.checkGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash), sources: ssrcs.map(Int32.init(bitPattern:))))
     |> `catch` { _ -> Signal<[Int32], NoError> in
         return .single([])
@@ -1297,7 +1297,7 @@ public final class GroupCallParticipantsContext {
 
     public private(set) var serviceState: ServiceState
     
-    public init(account: Account, peerId: PeerId, myPeerId: PeerId, id: Int64, accessHash: Int64, state: State, previousServiceState: ServiceState?) {
+    init(account: Account, peerId: PeerId, myPeerId: PeerId, id: Int64, accessHash: Int64, state: State, previousServiceState: ServiceState?) {
         self.account = account
         self.myPeerId = myPeerId
         self.id = id
@@ -1563,7 +1563,7 @@ public final class GroupCallParticipantsContext {
 
         Logger.shared.log("GroupCallParticipantsContext", "will request ssrcs=\(ssrcs)")
         
-        self.disposable.set((getGroupCallParticipants(account: self.account, callId: self.id, accessHash: self.accessHash, offset: "", ssrcs: Array(ssrcs), limit: 100, sortAscending: true)
+        self.disposable.set((_internal_getGroupCallParticipants(account: self.account, callId: self.id, accessHash: self.accessHash, offset: "", ssrcs: Array(ssrcs), limit: 100, sortAscending: true)
         |> deliverOnMainQueue).start(next: { [weak self] state in
             guard let strongSelf = self else {
                 return
@@ -1775,7 +1775,7 @@ public final class GroupCallParticipantsContext {
         
         self.updateQueue.removeAll()
         
-        self.disposable.set((getGroupCallParticipants(account: self.account, callId: self.id, accessHash: self.accessHash, offset: "", ssrcs: [], limit: 100, sortAscending: self.stateValue.state.sortAscending)
+        self.disposable.set((_internal_getGroupCallParticipants(account: self.account, callId: self.id, accessHash: self.accessHash, offset: "", ssrcs: [], limit: 100, sortAscending: self.stateValue.state.sortAscending)
         |> deliverOnMainQueue).start(next: { [weak self] state in
             guard let strongSelf = self else {
                 return
@@ -2034,7 +2034,7 @@ public final class GroupCallParticipantsContext {
         }
         self.isLoadingMore = true
         
-        self.disposable.set((getGroupCallParticipants(account: self.account, callId: self.id, accessHash: self.accessHash, offset: token, ssrcs: [], limit: 100, sortAscending: self.stateValue.state.sortAscending)
+        self.disposable.set((_internal_getGroupCallParticipants(account: self.account, callId: self.id, accessHash: self.accessHash, offset: token, ssrcs: [], limit: 100, sortAscending: self.stateValue.state.sortAscending)
         |> deliverOnMainQueue).start(next: { [weak self] state in
             guard let strongSelf = self else {
                 return
@@ -2126,7 +2126,7 @@ public enum InviteToGroupCallError {
     case generic
 }
 
-public func inviteToGroupCall(account: Account, callId: Int64, accessHash: Int64, peerId: PeerId) -> Signal<Never, InviteToGroupCallError> {
+func _internal_inviteToGroupCall(account: Account, callId: Int64, accessHash: Int64, peerId: PeerId) -> Signal<Never, InviteToGroupCallError> {
     return account.postbox.transaction { transaction -> Peer? in
         return transaction.getPeer(peerId)
     }
@@ -2161,7 +2161,7 @@ public struct GroupCallInviteLinks {
     }
 }
 
-public func groupCallInviteLinks(account: Account, callId: Int64, accessHash: Int64) -> Signal<GroupCallInviteLinks?, NoError> {
+func _internal_groupCallInviteLinks(account: Account, callId: Int64, accessHash: Int64) -> Signal<GroupCallInviteLinks?, NoError> {
     let call = Api.InputGroupCall.inputGroupCall(id: callId, accessHash: accessHash)
     let listenerInvite: Signal<String?, NoError> = account.network.request(Api.functions.phone.exportGroupCallInvite(flags: 0, call: call))
     |> map(Optional.init)
@@ -2201,7 +2201,7 @@ public enum EditGroupCallTitleError {
     case generic
 }
 
-public func editGroupCallTitle(account: Account, callId: Int64, accessHash: Int64, title: String) -> Signal<Never, EditGroupCallTitleError> {
+func _internal_editGroupCallTitle(account: Account, callId: Int64, accessHash: Int64, title: String) -> Signal<Never, EditGroupCallTitleError> {
     return account.network.request(Api.functions.phone.editGroupCallTitle(call: .inputGroupCall(id: callId, accessHash: accessHash), title: title)) |> mapError { _ -> EditGroupCallTitleError in
         return .generic
     }
@@ -2211,7 +2211,7 @@ public func editGroupCallTitle(account: Account, callId: Int64, accessHash: Int6
     }
 }
 
-public func groupCallDisplayAsAvailablePeers(network: Network, postbox: Postbox, peerId: PeerId) -> Signal<[FoundPeer], NoError> {
+func _internal_groupCallDisplayAsAvailablePeers(network: Network, postbox: Postbox, peerId: PeerId) -> Signal<[FoundPeer], NoError> {
     return postbox.transaction { transaction -> Api.InputPeer? in
         return transaction.getPeer(peerId).flatMap(apiInputPeer)
     } |> mapToSignal { inputPeer in
@@ -2279,7 +2279,7 @@ public final class CachedDisplayAsPeers: PostboxCoding {
     }
 }
 
-public func clearCachedGroupCallDisplayAsAvailablePeers(account: Account, peerId: PeerId) -> Signal<Never, NoError> {
+func _internal_clearCachedGroupCallDisplayAsAvailablePeers(account: Account, peerId: PeerId) -> Signal<Never, NoError> {
     return account.postbox.transaction { transaction -> Void in
         let key = ValueBoxKey(length: 8)
         key.setInt64(0, value: peerId.toInt64())
@@ -2288,7 +2288,7 @@ public func clearCachedGroupCallDisplayAsAvailablePeers(account: Account, peerId
     |> ignoreValues
 }
 
-public func cachedGroupCallDisplayAsAvailablePeers(account: Account, peerId: PeerId) -> Signal<[FoundPeer], NoError> {
+func _internal_cachedGroupCallDisplayAsAvailablePeers(account: Account, peerId: PeerId) -> Signal<[FoundPeer], NoError> {
     let key = ValueBoxKey(length: 8)
     key.setInt64(0, value: peerId.toInt64())
     return account.postbox.transaction { transaction -> ([FoundPeer], Int32)? in
@@ -2314,7 +2314,7 @@ public func cachedGroupCallDisplayAsAvailablePeers(account: Account, peerId: Pee
         if let (cachedPeers, timestamp) = cachedPeersAndTimestamp, currentTimestamp - timestamp < 60 * 3 && !cachedPeers.isEmpty {
             return .single(cachedPeers)
         } else {
-            return groupCallDisplayAsAvailablePeers(network: account.network, postbox: account.postbox, peerId: peerId)
+            return _internal_groupCallDisplayAsAvailablePeers(network: account.network, postbox: account.postbox, peerId: peerId)
             |> mapToSignal { peers -> Signal<[FoundPeer], NoError> in
                 return account.postbox.transaction { transaction -> [FoundPeer] in
                     let currentTimestamp = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
@@ -2326,8 +2326,8 @@ public func cachedGroupCallDisplayAsAvailablePeers(account: Account, peerId: Pee
     }
 }
 
-public func updatedCurrentPeerGroupCall(account: Account, peerId: PeerId) -> Signal<CachedChannelData.ActiveCall?, NoError> {
-    return fetchAndUpdateCachedPeerData(accountPeerId: account.peerId, peerId: peerId, network: account.network, postbox: account.postbox)
+func _internal_updatedCurrentPeerGroupCall(account: Account, peerId: PeerId) -> Signal<CachedChannelData.ActiveCall?, NoError> {
+    return _internal_fetchAndUpdateCachedPeerData(accountPeerId: account.peerId, peerId: peerId, network: account.network, postbox: account.postbox)
     |> mapToSignal { _ -> Signal<CachedChannelData.ActiveCall?, NoError> in
         return account.postbox.transaction { transaction -> CachedChannelData.ActiveCall? in
             return (transaction.getPeerCachedData(peerId: peerId) as? CachedChannelData)?.activeCall
@@ -2363,7 +2363,7 @@ public final class AudioBroadcastDataSource {
     }
 }
 
-public func getAudioBroadcastDataSource(account: Account, callId: Int64, accessHash: Int64) -> Signal<AudioBroadcastDataSource?, NoError> {
+func _internal_getAudioBroadcastDataSource(account: Account, callId: Int64, accessHash: Int64) -> Signal<AudioBroadcastDataSource?, NoError> {
     return account.network.request(Api.functions.phone.getGroupCall(call: .inputGroupCall(id: callId, accessHash: accessHash)))
     |> map(Optional.init)
     |> `catch` { _ -> Signal<Api.phone.GroupCall?, NoError> in
@@ -2399,7 +2399,7 @@ public struct GetAudioBroadcastPartResult {
     public var responseTimestamp: Double
 }
 
-public func getAudioBroadcastPart(dataSource: AudioBroadcastDataSource, callId: Int64, accessHash: Int64, timestampIdMilliseconds: Int64, durationMilliseconds: Int64) -> Signal<GetAudioBroadcastPartResult, NoError> {
+func _internal_getAudioBroadcastPart(dataSource: AudioBroadcastDataSource, callId: Int64, accessHash: Int64, timestampIdMilliseconds: Int64, durationMilliseconds: Int64) -> Signal<GetAudioBroadcastPartResult, NoError> {
     let scale: Int32
     switch durationMilliseconds {
     case 1000:

submodules/TelegramCore/Sources/TelegramEngine/Calls/TelegramEngineCalls.swift

@@ -1,4 +1,6 @@
 import SwiftSignalKit
+import Postbox
+import SyncCore
 
 public extension TelegramEngine {
     final class Calls {
@@ -15,5 +17,93 @@ public extension TelegramEngine {
         public func saveCallDebugLog(callId: CallId, log: String) -> Signal<Void, NoError> {
             return _internal_saveCallDebugLog(network: self.account.network, callId: callId, log: log)
         }
+
+        public func getCurrentGroupCall(callId: Int64, accessHash: Int64, peerId: PeerId? = nil) -> Signal<GroupCallSummary?, GetCurrentGroupCallError> {
+            return _internal_getCurrentGroupCall(account: self.account, callId: callId, accessHash: accessHash, peerId: peerId)
+        }
+
+        public func createGroupCall(peerId: PeerId, title: String?, scheduleDate: Int32?) -> Signal<GroupCallInfo, CreateGroupCallError> {
+            return _internal_createGroupCall(account: self.account, peerId: peerId, title: title, scheduleDate: scheduleDate)
+        }
+
+        public func startScheduledGroupCall(peerId: PeerId, callId: Int64, accessHash: Int64) -> Signal<GroupCallInfo, StartScheduledGroupCallError> {
+            return _internal_startScheduledGroupCall(account: self.account, peerId: peerId, callId: callId, accessHash: accessHash)
+        }
+
+        public func toggleScheduledGroupCallSubscription(peerId: PeerId, callId: Int64, accessHash: Int64, subscribe: Bool) -> Signal<Void, ToggleScheduledGroupCallSubscriptionError> {
+            return _internal_toggleScheduledGroupCallSubscription(account: self.account, peerId: peerId, callId: callId, accessHash: accessHash, subscribe: subscribe)
+        }
+
+        public func updateGroupCallJoinAsPeer(peerId: PeerId, joinAs: PeerId) -> Signal<Never, UpdateGroupCallJoinAsPeerError> {
+            return _internal_updateGroupCallJoinAsPeer(account: self.account, peerId: peerId, joinAs: joinAs)
+        }
+
+        public func getGroupCallParticipants(callId: Int64, accessHash: Int64, offset: String, ssrcs: [UInt32], limit: Int32, sortAscending: Bool?) -> Signal<GroupCallParticipantsContext.State, GetGroupCallParticipantsError> {
+            return _internal_getGroupCallParticipants(account: self.account, callId: callId, accessHash: accessHash, offset: offset, ssrcs: ssrcs, limit: limit, sortAscending: sortAscending)
+        }
+
+        public func joinGroupCall(peerId: PeerId, joinAs: PeerId?, callId: Int64, accessHash: Int64, preferMuted: Bool, joinPayload: String, peerAdminIds: Signal<[PeerId], NoError>, inviteHash: String? = nil) -> Signal<JoinGroupCallResult, JoinGroupCallError> {
+            return _internal_joinGroupCall(account: self.account, peerId: peerId, joinAs: joinAs, callId: callId, accessHash: accessHash, preferMuted: preferMuted, joinPayload: joinPayload, peerAdminIds: peerAdminIds, inviteHash: inviteHash)
+        }
+
+        public func joinGroupCallAsScreencast(peerId: PeerId, callId: Int64, accessHash: Int64, joinPayload: String) -> Signal<JoinGroupCallAsScreencastResult, JoinGroupCallError> {
+            return _internal_joinGroupCallAsScreencast(account: self.account, peerId: peerId, callId: callId, accessHash: accessHash, joinPayload: joinPayload)
+        }
+
+        public func leaveGroupCallAsScreencast(callId: Int64, accessHash: Int64) -> Signal<Never, LeaveGroupCallAsScreencastError> {
+            return _internal_leaveGroupCallAsScreencast(account: self.account, callId: callId, accessHash: accessHash)
+        }
+
+        public func leaveGroupCall(callId: Int64, accessHash: Int64, source: UInt32) -> Signal<Never, LeaveGroupCallError> {
+            return _internal_leaveGroupCall(account: self.account, callId: callId, accessHash: accessHash, source: source)
+        }
+
+        public func stopGroupCall(peerId: PeerId, callId: Int64, accessHash: Int64) -> Signal<Never, StopGroupCallError> {
+            return _internal_stopGroupCall(account: self.account, peerId: peerId, callId: callId, accessHash: accessHash)
+        }
+
+        public func checkGroupCall(callId: Int64, accessHash: Int64, ssrcs: [UInt32]) -> Signal<[UInt32], NoError> {
+            return _internal_checkGroupCall(account: account, callId: callId, accessHash: accessHash, ssrcs: ssrcs)
+        }
+
+        public func inviteToGroupCall(callId: Int64, accessHash: Int64, peerId: PeerId) -> Signal<Never, InviteToGroupCallError> {
+            return _internal_inviteToGroupCall(account: self.account, callId: callId, accessHash: accessHash, peerId: peerId)
+        }
+
+        public func groupCallInviteLinks(callId: Int64, accessHash: Int64) -> Signal<GroupCallInviteLinks?, NoError> {
+            return _internal_groupCallInviteLinks(account: self.account, callId: callId, accessHash: accessHash)
+        }
+
+        public func editGroupCallTitle(callId: Int64, accessHash: Int64, title: String) -> Signal<Never, EditGroupCallTitleError> {
+            return _internal_editGroupCallTitle(account: self.account, callId: callId, accessHash: accessHash, title: title)
+        }
+
+        /*public func groupCallDisplayAsAvailablePeers(peerId: PeerId) -> Signal<[FoundPeer], NoError> {
+            return _internal_groupCallDisplayAsAvailablePeers(network: self.account.network, postbox: self.account.postbox, peerId: peerId)
+        }*/
+
+        public func clearCachedGroupCallDisplayAsAvailablePeers(peerId: PeerId) -> Signal<Never, NoError> {
+            return _internal_clearCachedGroupCallDisplayAsAvailablePeers(account: self.account, peerId: peerId)
+        }
+
+        public func cachedGroupCallDisplayAsAvailablePeers(peerId: PeerId) -> Signal<[FoundPeer], NoError> {
+            return _internal_cachedGroupCallDisplayAsAvailablePeers(account: self.account, peerId: peerId)
+        }
+
+        public func updatedCurrentPeerGroupCall(peerId: PeerId) -> Signal<CachedChannelData.ActiveCall?, NoError> {
+            return _internal_updatedCurrentPeerGroupCall(account: self.account, peerId: peerId)
+        }
+
+        public func getAudioBroadcastDataSource(callId: Int64, accessHash: Int64) -> Signal<AudioBroadcastDataSource?, NoError> {
+            return _internal_getAudioBroadcastDataSource(account: self.account, callId: callId, accessHash: accessHash)
+        }
+
+        public func getAudioBroadcastPart(dataSource: AudioBroadcastDataSource, callId: Int64, accessHash: Int64, timestampIdMilliseconds: Int64, durationMilliseconds: Int64) -> Signal<GetAudioBroadcastPartResult, NoError> {
+            return _internal_getAudioBroadcastPart(dataSource: dataSource, callId: callId, accessHash: accessHash, timestampIdMilliseconds: timestampIdMilliseconds, durationMilliseconds: durationMilliseconds)
+        }
+
+        public func groupCall(peerId: PeerId, myPeerId: PeerId, id: Int64, accessHash: Int64, state: GroupCallParticipantsContext.State, previousServiceState: GroupCallParticipantsContext.ServiceState?) -> GroupCallParticipantsContext {
+            return GroupCallParticipantsContext(account: self.account, peerId: peerId, myPeerId: myPeerId, id: id, accessHash: accessHash, state: state, previousServiceState: previousServiceState)
+        }
     }
 }

submodules/TelegramCore/Sources/TelegramEngine/Messages/OutgoingMessageWithChatContextResult.swift

@@ -3,8 +3,15 @@ import Postbox
 import SwiftSignalKit
 import SyncCore
 
+func _internal_enqueueOutgoingMessageWithChatContextResult(account: Account, to peerId: PeerId, results: ChatContextResultCollection, result: ChatContextResult, replyToMessageId: MessageId?, hideVia: Bool, silentPosting: Bool, scheduleTime: Int32?, correlationId: Int64?) -> Bool {
+    guard let message = outgoingMessageWithChatContextResult(to: peerId, results: results, result: result, replyToMessageId: replyToMessageId, hideVia: hideVia, silentPosting: silentPosting, scheduleTime: scheduleTime, correlationId: correlationId) else {
+        return false
+    }
+    let _ = enqueueMessages(account: account, peerId: peerId, messages: [message]).start()
+    return true
+}
 
-public func outgoingMessageWithChatContextResult(to peerId: PeerId, results: ChatContextResultCollection, result: ChatContextResult, hideVia: Bool = false, scheduleTime: Int32? = nil, correlationId: Int64? = nil) -> EnqueueMessage? {
+private func outgoingMessageWithChatContextResult(to peerId: PeerId, results: ChatContextResultCollection, result: ChatContextResult, replyToMessageId: MessageId?, hideVia: Bool, silentPosting: Bool, scheduleTime: Int32?, correlationId: Int64?) -> EnqueueMessage? {
     var attributes: [MessageAttribute] = []
     attributes.append(OutgoingChatContextResultMessageAttribute(queryId: result.queryId, id: result.id, hideVia: hideVia))
     if !hideVia {
@@ -13,6 +20,9 @@ public func outgoingMessageWithChatContextResult(to peerId: PeerId, results: Cha
     if let scheduleTime = scheduleTime {
         attributes.append(OutgoingScheduleInfoMessageAttribute(scheduleTime: scheduleTime))
     }
+    if silentPosting {
+        attributes.append(NotificationInfoMessageAttribute(flags: .muted))
+    }
     switch result.message {
         case let .auto(caption, entities, replyMarkup):
             if let entities = entities {
@@ -32,19 +42,19 @@ public func outgoingMessageWithChatContextResult(to peerId: PeerId, results: Cha
                                 return true
                             }
                             if let media: Media = internalReference.file ?? internalReference.image {
-                                return .message(text: caption, attributes: filteredAttributes, mediaReference: .standalone(media: media), replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+                                return .message(text: caption, attributes: filteredAttributes, mediaReference: .standalone(media: media), replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
                             } else {
-                                return .message(text: caption, attributes: filteredAttributes, mediaReference: nil, replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+                                return .message(text: caption, attributes: filteredAttributes, mediaReference: nil, replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
                             }
                         } else {
-                            return .message(text: "", attributes: attributes, mediaReference: .standalone(media: TelegramMediaGame(gameId: 0, accessHash: 0, name: "", title: internalReference.title ?? "", description: internalReference.description ?? "", image: internalReference.image, file: internalReference.file)), replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+                            return .message(text: "", attributes: attributes, mediaReference: .standalone(media: TelegramMediaGame(gameId: 0, accessHash: 0, name: "", title: internalReference.title ?? "", description: internalReference.description ?? "", image: internalReference.image, file: internalReference.file)), replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
                         }
                     } else if let file = internalReference.file, internalReference.type == "gif" {
-                        return .message(text: caption, attributes: attributes, mediaReference: .standalone(media: file), replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+                        return .message(text: caption, attributes: attributes, mediaReference: .standalone(media: file), replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
                     } else if let image = internalReference.image {
-                        return .message(text: caption, attributes: attributes, mediaReference: .standalone(media: image), replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+                        return .message(text: caption, attributes: attributes, mediaReference: .standalone(media: image), replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
                     } else if let file = internalReference.file {
-                        return .message(text: caption, attributes: attributes, mediaReference: .standalone(media: file), replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+                        return .message(text: caption, attributes: attributes, mediaReference: .standalone(media: file), replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
                     } else {
                         return nil
                     }
@@ -56,9 +66,9 @@ public func outgoingMessageWithChatContextResult(to peerId: PeerId, results: Cha
                             let thumbnailResource = thumbnail.resource
                             let imageDimensions = thumbnail.dimensions ?? PixelDimensions(width: 128, height: 128)
                             let tmpImage = TelegramMediaImage(imageId: MediaId(namespace: Namespaces.Media.LocalImage, id: randomId), representations: [TelegramMediaImageRepresentation(dimensions: imageDimensions, resource: thumbnailResource, progressiveSizes: [], immediateThumbnailData: nil)], immediateThumbnailData: nil, reference: nil, partialReference: nil, flags: [])
-                            return .message(text: caption, attributes: attributes, mediaReference: .standalone(media: tmpImage), replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+                            return .message(text: caption, attributes: attributes, mediaReference: .standalone(media: tmpImage), replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
                         } else {
-                            return .message(text: caption, attributes: attributes, mediaReference: nil, replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+                            return .message(text: caption, attributes: attributes, mediaReference: nil, replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
                         }
                     } else if externalReference.type == "document" || externalReference.type == "gif" || externalReference.type == "audio" || externalReference.type == "voice" {
                         var videoThumbnails: [TelegramMediaFile.VideoThumbnail] = []
@@ -118,9 +128,9 @@ public func outgoingMessageWithChatContextResult(to peerId: PeerId, results: Cha
                         }
                         
                         let file = TelegramMediaFile(fileId: MediaId(namespace: Namespaces.Media.LocalFile, id: randomId), partialReference: nil, resource: resource, previewRepresentations: previewRepresentations, videoThumbnails: videoThumbnails, immediateThumbnailData: nil, mimeType: externalReference.content?.mimeType ?? "application/binary", size: nil, attributes: fileAttributes)
-                        return .message(text: caption, attributes: attributes, mediaReference: .standalone(media: file), replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+                        return .message(text: caption, attributes: attributes, mediaReference: .standalone(media: file), replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
                     } else {
-                        return .message(text: caption, attributes: attributes, mediaReference: nil, replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+                        return .message(text: caption, attributes: attributes, mediaReference: nil, replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
                     }
             }
         case let .text(text, entities, disableUrlPreview, replyMarkup):
@@ -130,21 +140,21 @@ public func outgoingMessageWithChatContextResult(to peerId: PeerId, results: Cha
             if let replyMarkup = replyMarkup {
                 attributes.append(replyMarkup)
             }
-            return .message(text: text, attributes: attributes, mediaReference: nil, replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+            return .message(text: text, attributes: attributes, mediaReference: nil, replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
         case let .mapLocation(media, replyMarkup):
             if let replyMarkup = replyMarkup {
                 attributes.append(replyMarkup)
             }
-            return .message(text: "", attributes: attributes, mediaReference: .standalone(media: media), replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+            return .message(text: "", attributes: attributes, mediaReference: .standalone(media: media), replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
         case let .contact(media, replyMarkup):
             if let replyMarkup = replyMarkup {
                 attributes.append(replyMarkup)
             }
-            return .message(text: "", attributes: attributes, mediaReference: .standalone(media: media), replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+            return .message(text: "", attributes: attributes, mediaReference: .standalone(media: media), replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
         case let .invoice(media, replyMarkup):
             if let replyMarkup = replyMarkup {
                 attributes.append(replyMarkup)
             }
-            return .message(text: "", attributes: attributes, mediaReference: .standalone(media: media), replyToMessageId: nil, localGroupingKey: nil, correlationId: correlationId)
+            return .message(text: "", attributes: attributes, mediaReference: .standalone(media: media), replyToMessageId: replyToMessageId, localGroupingKey: nil, correlationId: correlationId)
     }
 }

submodules/TelegramCore/Sources/TelegramEngine/Messages/PeerLiveLocationsContext.swift

@@ -2,10 +2,9 @@ import Foundation
 import Postbox
 import SwiftSignalKit
 import TelegramApi
-
 import SyncCore
 
-public func topPeerActiveLiveLocationMessages(viewTracker: AccountViewTracker, accountPeerId: PeerId, peerId: PeerId) -> Signal<(Peer?, [Message]), NoError> {
+func _internal_topPeerActiveLiveLocationMessages(viewTracker: AccountViewTracker, accountPeerId: PeerId, peerId: PeerId) -> Signal<(Peer?, [Message]), NoError> {
     return viewTracker.aroundMessageHistoryViewForLocation(.peer(peerId), index: .upperBound, anchorIndex: .upperBound, count: 50, fixedCombinedReadStates: nil, tagMask: .liveLocation, orderStatistics: [], additionalData: [.peer(accountPeerId)])
     |> map { (view, _, _) -> (Peer?, [Message]) in
         var accountPeer: Peer?

submodules/TelegramCore/Sources/TelegramEngine/Messages/RecentlyUsedHashtags.swift

@@ -30,7 +30,7 @@ func addRecentlyUsedHashtag(transaction: Transaction, string: String) {
     }
 }
 
-public func removeRecentlyUsedHashtag(postbox: Postbox, string: String) -> Signal<Void, NoError> {
+func _internal_removeRecentlyUsedHashtag(postbox: Postbox, string: String) -> Signal<Void, NoError> {
     return postbox.transaction { transaction -> Void in
         if let itemId = RecentHashtagItemId(string) {
             transaction.removeOrderedItemListItem(collectionId: Namespaces.OrderedItemList.RecentlyUsedHashtags, itemId: itemId.rawValue)
@@ -38,7 +38,7 @@ public func removeRecentlyUsedHashtag(postbox: Postbox, string: String) -> Signa
     }
 }
 
-public func recentlyUsedHashtags(postbox: Postbox) -> Signal<[String], NoError> {
+func _internal_recentlyUsedHashtags(postbox: Postbox) -> Signal<[String], NoError> {
     return postbox.combinedView(keys: [.orderedItemList(id: Namespaces.OrderedItemList.RecentlyUsedHashtags)])
         |> mapToSignal { view -> Signal<[String], NoError> in
             return postbox.transaction { transaction -> [String] in

submodules/TelegramCore/Sources/TelegramEngine/Messages/RequestChatContextResults.swift

@@ -51,7 +51,7 @@ public struct RequestChatContextResultsResult {
     }
 }
 
-public func requestChatContextResults(account: Account, botId: PeerId, peerId: PeerId, query: String, location: Signal<(Double, Double)?, NoError> = .single(nil), offset: String, incompleteResults: Bool = false, staleCachedResults: Bool = false) -> Signal<RequestChatContextResultsResult?, RequestChatContextResultsError> {
+func _internal_requestChatContextResults(account: Account, botId: PeerId, peerId: PeerId, query: String, location: Signal<(Double, Double)?, NoError> = .single(nil), offset: String, incompleteResults: Bool = false, staleCachedResults: Bool = false) -> Signal<RequestChatContextResultsResult?, RequestChatContextResultsError> {
     return account.postbox.transaction { transaction -> (bot: Peer, peer: Peer)? in
         if let bot = transaction.getPeer(botId), let peer = transaction.getPeer(peerId) {
             return (bot, peer)

submodules/TelegramCore/Sources/TelegramEngine/Messages/TelegramEngineMessages.swift

@@ -151,5 +151,25 @@ public extension TelegramEngine {
         public func exportMessageLink(peerId: PeerId, messageId: MessageId, isThread: Bool = false) -> Signal<String?, NoError> {
             return _internal_exportMessageLink(account: self.account, peerId: peerId, messageId: messageId, isThread: isThread)
         }
+
+        public func enqueueOutgoingMessageWithChatContextResult(to peerId: PeerId, results: ChatContextResultCollection, result: ChatContextResult, replyToMessageId: MessageId? = nil, hideVia: Bool = false, silentPosting: Bool = false, scheduleTime: Int32? = nil, correlationId: Int64? = nil) -> Bool {
+            return _internal_enqueueOutgoingMessageWithChatContextResult(account: self.account, to: peerId, results: results, result: result, replyToMessageId: replyToMessageId, hideVia: hideVia, silentPosting: silentPosting, scheduleTime: scheduleTime, correlationId: correlationId)
+        }
+
+        public func requestChatContextResults(botId: PeerId, peerId: PeerId, query: String, location: Signal<(Double, Double)?, NoError> = .single(nil), offset: String, incompleteResults: Bool = false, staleCachedResults: Bool = false) -> Signal<RequestChatContextResultsResult?, RequestChatContextResultsError> {
+            return _internal_requestChatContextResults(account: self.account, botId: botId, peerId: peerId, query: query, location: location, offset: offset, incompleteResults: incompleteResults, staleCachedResults: staleCachedResults)
+        }
+
+        public func removeRecentlyUsedHashtag(string: String) -> Signal<Void, NoError> {
+            return _internal_removeRecentlyUsedHashtag(postbox: self.account.postbox, string: string)
+        }
+
+        public func recentlyUsedHashtags() -> Signal<[String], NoError> {
+            return _internal_recentlyUsedHashtags(postbox: self.account.postbox)
+        }
+
+        public func topPeerActiveLiveLocationMessages(peerId: PeerId) -> Signal<(Peer?, [Message]), NoError> {
+            return _internal_topPeerActiveLiveLocationMessages(viewTracker: self.account.viewTracker, accountPeerId: self.account.peerId, peerId: peerId)
+        }
     }
 }

submodules/TelegramCore/Sources/TelegramEngine/PeerManagement/TelegramEnginePeerManagement.swift

@@ -1,13 +0,0 @@
-import SwiftSignalKit
-
-public extension TelegramEngine {
-    final class PeerManagement {
-        private let account: Account
-
-        init(account: Account) {
-            self.account = account
-        }
-
-
-    }
-}

submodules/TelegramCore/Sources/TelegramEngine/Peers/ChatListFiltering.swift

@@ -367,7 +367,7 @@ public enum RequestUpdateChatListFilterError {
     case generic
 }
 
-public func requestUpdateChatListFilter(postbox: Postbox, network: Network, id: Int32, filter: ChatListFilter?) -> Signal<Never, RequestUpdateChatListFilterError> {
+func _internal_requestUpdateChatListFilter(postbox: Postbox, network: Network, id: Int32, filter: ChatListFilter?) -> Signal<Never, RequestUpdateChatListFilterError> {
     return postbox.transaction { transaction -> Api.DialogFilter? in
         return filter?.apiFilter(transaction: transaction)
     }
@@ -391,7 +391,7 @@ public enum RequestUpdateChatListFilterOrderError {
     case generic
 }
 
-public func requestUpdateChatListFilterOrder(account: Account, ids: [Int32]) -> Signal<Never, RequestUpdateChatListFilterOrderError> {
+func _internal_requestUpdateChatListFilterOrder(account: Account, ids: [Int32]) -> Signal<Never, RequestUpdateChatListFilterOrderError> {
     return account.network.request(Api.functions.messages.updateDialogFiltersOrder(order: ids))
     |> mapError { _ -> RequestUpdateChatListFilterOrderError in
         return .generic
@@ -781,7 +781,7 @@ struct ChatListFiltersState: PreferencesEntry, Equatable {
     }
 }
 
-public func generateNewChatListFilterId(filters: [ChatListFilter]) -> Int32 {
+func _internal_generateNewChatListFilterId(filters: [ChatListFilter]) -> Int32 {
     while true {
         let id = Int32(2 + arc4random_uniform(255 - 2))
         if !filters.contains(where: { $0.id == id }) {
@@ -790,7 +790,7 @@ public func generateNewChatListFilterId(filters: [ChatListFilter]) -> Int32 {
     }
 }
 
-public func updateChatListFiltersInteractively(postbox: Postbox, _ f: @escaping ([ChatListFilter]) -> [ChatListFilter]) -> Signal<[ChatListFilter], NoError> {
+func _internal_updateChatListFiltersInteractively(postbox: Postbox, _ f: @escaping ([ChatListFilter]) -> [ChatListFilter]) -> Signal<[ChatListFilter], NoError> {
     return postbox.transaction { transaction -> [ChatListFilter] in
         var updated: [ChatListFilter] = []
         var hasUpdates = false
@@ -811,7 +811,7 @@ public func updateChatListFiltersInteractively(postbox: Postbox, _ f: @escaping
     }
 }
 
-public func updateChatListFiltersInteractively(transaction: Transaction, _ f: ([ChatListFilter]) -> [ChatListFilter]) {
+func _internal_updateChatListFiltersInteractively(transaction: Transaction, _ f: ([ChatListFilter]) -> [ChatListFilter]) {
     var hasUpdates = false
     transaction.updatePreferencesEntry(key: PreferencesKeys.chatListFilters, { entry in
         var state = entry as? ChatListFiltersState ?? ChatListFiltersState.default
@@ -828,7 +828,7 @@ public func updateChatListFiltersInteractively(transaction: Transaction, _ f: ([
 }
 
 
-public func updatedChatListFilters(postbox: Postbox) -> Signal<[ChatListFilter], NoError> {
+func _internal_updatedChatListFilters(postbox: Postbox) -> Signal<[ChatListFilter], NoError> {
     return postbox.preferencesView(keys: [PreferencesKeys.chatListFilters])
     |> map { preferences -> [ChatListFilter] in
         let filtersState = preferences.values[PreferencesKeys.chatListFilters] as? ChatListFiltersState ?? ChatListFiltersState.default
@@ -837,7 +837,7 @@ public func updatedChatListFilters(postbox: Postbox) -> Signal<[ChatListFilter],
     |> distinctUntilChanged
 }
 
-public func updatedChatListFiltersInfo(postbox: Postbox) -> Signal<(filters: [ChatListFilter], synchronized: Bool), NoError> {
+func _internal_updatedChatListFiltersInfo(postbox: Postbox) -> Signal<(filters: [ChatListFilter], synchronized: Bool), NoError> {
     return postbox.preferencesView(keys: [PreferencesKeys.chatListFilters])
     |> map { preferences -> (filters: [ChatListFilter], synchronized: Bool) in
         let filtersState = preferences.values[PreferencesKeys.chatListFilters] as? ChatListFiltersState ?? ChatListFiltersState.default
@@ -854,7 +854,7 @@ public func updatedChatListFiltersInfo(postbox: Postbox) -> Signal<(filters: [Ch
     })
 }
 
-public func currentChatListFilters(postbox: Postbox) -> Signal<[ChatListFilter], NoError> {
+func _internal_currentChatListFilters(postbox: Postbox) -> Signal<[ChatListFilter], NoError> {
     return postbox.transaction { transaction -> [ChatListFilter] in
         let settings = transaction.getPreferencesEntry(key: PreferencesKeys.chatListFilters) as? ChatListFiltersState ?? ChatListFiltersState.default
         return settings.filters
@@ -941,7 +941,7 @@ public struct ChatListFiltersFeaturedState: PreferencesEntry, Equatable {
     }
 }
 
-public func markChatListFeaturedFiltersAsSeen(postbox: Postbox) -> Signal<Never, NoError> {
+func _internal_markChatListFeaturedFiltersAsSeen(postbox: Postbox) -> Signal<Never, NoError> {
     return postbox.transaction { transaction -> Void in
         transaction.updatePreferencesEntry(key: PreferencesKeys.chatListFiltersFeaturedState, { entry in
             guard var state = entry as? ChatListFiltersFeaturedState else {
@@ -954,7 +954,7 @@ public func markChatListFeaturedFiltersAsSeen(postbox: Postbox) -> Signal<Never,
     |> ignoreValues
 }
 
-public func unmarkChatListFeaturedFiltersAsSeen(transaction: Transaction) {
+func _internal_unmarkChatListFeaturedFiltersAsSeen(transaction: Transaction) {
     transaction.updatePreferencesEntry(key: PreferencesKeys.chatListFiltersFeaturedState, { entry in
         guard var state = entry as? ChatListFiltersFeaturedState else {
             return entry
@@ -964,7 +964,7 @@ public func unmarkChatListFeaturedFiltersAsSeen(transaction: Transaction) {
     })
 }
 
-public func updateChatListFeaturedFilters(postbox: Postbox, network: Network) -> Signal<Never, NoError> {
+func _internal_updateChatListFeaturedFilters(postbox: Postbox, network: Network) -> Signal<Never, NoError> {
     return network.request(Api.functions.messages.getSuggestedDialogFilters())
     |> `catch` { _ -> Signal<[Api.DialogFilterSuggested], NoError> in
         return .single([])
@@ -1111,7 +1111,7 @@ func requestChatListFiltersSync(transaction: Transaction) {
 
 func managedChatListFilters(postbox: Postbox, network: Network, accountPeerId: PeerId) -> Signal<Void, NoError> {
     return Signal { _ in
-        let updateFeaturedDisposable = updateChatListFeaturedFilters(postbox: postbox, network: network).start()
+        let updateFeaturedDisposable = _internal_updateChatListFeaturedFilters(postbox: postbox, network: network).start()
         let _ = postbox.transaction({ transaction in
             requestChatListFiltersSync(transaction: transaction)
         }).start()
@@ -1218,7 +1218,7 @@ private func synchronizeChatListFilters(transaction: Transaction, accountPeerId:
                 if !mergedFilterIds.contains(where: { $0 == filter.id }) {
                     deleteSignals = deleteSignals
                     |> then(
-                        requestUpdateChatListFilter(postbox: postbox, network: network, id: filter.id, filter: nil)
+                        _internal_requestUpdateChatListFilter(postbox: postbox, network: network, id: filter.id, filter: nil)
                         |> `catch` { _ -> Signal<Never, NoError> in
                             return .complete()
                         }
@@ -1238,7 +1238,7 @@ private func synchronizeChatListFilters(transaction: Transaction, accountPeerId:
                 if updated {
                     addSignals = addSignals
                     |> then(
-                        requestUpdateChatListFilter(postbox: postbox, network: network, id: filter.id, filter: filter)
+                        _internal_requestUpdateChatListFilter(postbox: postbox, network: network, id: filter.id, filter: filter)
                         |> `catch` { _ -> Signal<Never, NoError> in
                             return .complete()
                         }

submodules/TelegramCore/Sources/TelegramEngine/Peers/CheckPeerChatServiceActions.swift

@@ -4,7 +4,7 @@ import SwiftSignalKit
 
 import SyncCore
 
-public func checkPeerChatServiceActions(postbox: Postbox, peerId: PeerId) -> Signal<Void, NoError> {
+func _internal_checkPeerChatServiceActions(postbox: Postbox, peerId: PeerId) -> Signal<Void, NoError> {
     return postbox.transaction { transaction -> Void in
         transaction.applyMarkUnread(peerId: peerId, namespace: Namespaces.Message.SecretIncoming, value: false, interactive: true)
         

submodules/TelegramCore/Sources/TelegramEngine/Peers/InvitationLinks.swift

@@ -3,11 +3,9 @@ import Postbox
 import SwiftSignalKit
 import TelegramApi
 import MtProtoKit
-
 import SyncCore
 
-
-public func revokePersistentPeerExportedInvitation(account: Account, peerId: PeerId) -> Signal<ExportedInvitation?, NoError> {
+func _internal_revokePersistentPeerExportedInvitation(account: Account, peerId: PeerId) -> Signal<ExportedInvitation?, NoError> {
     return account.postbox.transaction { transaction -> Signal<ExportedInvitation?, NoError> in
         if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer) {
             let flags: Int32 = (1 << 2)
@@ -58,7 +56,7 @@ public enum CreatePeerExportedInvitationError {
     case generic
 }
 
-public func createPeerExportedInvitation(account: Account, peerId: PeerId, expireDate: Int32?, usageLimit: Int32?) -> Signal<ExportedInvitation?, CreatePeerExportedInvitationError> {
+func _internal_createPeerExportedInvitation(account: Account, peerId: PeerId, expireDate: Int32?, usageLimit: Int32?) -> Signal<ExportedInvitation?, CreatePeerExportedInvitationError> {
     return account.postbox.transaction { transaction -> Signal<ExportedInvitation?, CreatePeerExportedInvitationError> in
         if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer) {
             var flags: Int32 = 0
@@ -85,7 +83,7 @@ public enum EditPeerExportedInvitationError {
     case generic
 }
 
-public func editPeerExportedInvitation(account: Account, peerId: PeerId, link: String, expireDate: Int32?, usageLimit: Int32?) -> Signal<ExportedInvitation?, EditPeerExportedInvitationError> {
+func _internal_editPeerExportedInvitation(account: Account, peerId: PeerId, link: String, expireDate: Int32?, usageLimit: Int32?) -> Signal<ExportedInvitation?, EditPeerExportedInvitationError> {
     return account.postbox.transaction { transaction -> Signal<ExportedInvitation?, EditPeerExportedInvitationError> in
         if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer) {
             var flags: Int32 = 0
@@ -131,7 +129,7 @@ public enum RevokeExportedInvitationResult {
     case replace(ExportedInvitation, ExportedInvitation)
 }
 
-public func revokePeerExportedInvitation(account: Account, peerId: PeerId, link: String) -> Signal<RevokeExportedInvitationResult?, RevokePeerExportedInvitationError> {
+func _internal_revokePeerExportedInvitation(account: Account, peerId: PeerId, link: String) -> Signal<RevokeExportedInvitationResult?, RevokePeerExportedInvitationError> {
     return account.postbox.transaction { transaction -> Signal<RevokeExportedInvitationResult?, RevokePeerExportedInvitationError> in
         if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer) {
             let flags: Int32 = (1 << 2)
@@ -197,7 +195,7 @@ public struct ExportedInvitations : Equatable {
     public let totalCount: Int32
 }
 
-public func peerExportedInvitations(account: Account, peerId: PeerId, revoked: Bool, adminId: PeerId? = nil, offsetLink: ExportedInvitation? = nil) -> Signal<ExportedInvitations?, NoError> {
+func _internal_peerExportedInvitations(account: Account, peerId: PeerId, revoked: Bool, adminId: PeerId? = nil, offsetLink: ExportedInvitation? = nil) -> Signal<ExportedInvitations?, NoError> {
     return account.postbox.transaction { transaction -> Signal<ExportedInvitations?, NoError> in
         if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer), let adminPeer = transaction.getPeer(adminId ?? account.peerId), let adminId = apiInputUser(adminPeer) {
             var flags: Int32 = 0
@@ -244,7 +242,7 @@ public enum DeletePeerExportedInvitationError {
     case generic
 }
 
-public func deletePeerExportedInvitation(account: Account, peerId: PeerId, link: String) -> Signal<Never, DeletePeerExportedInvitationError> {
+func _internal_deletePeerExportedInvitation(account: Account, peerId: PeerId, link: String) -> Signal<Never, DeletePeerExportedInvitationError> {
     return account.postbox.transaction { transaction -> Signal<Never, DeletePeerExportedInvitationError> in
         if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer) {
             return account.network.request(Api.functions.messages.deleteExportedChatInvite(peer: inputPeer, link: link))
@@ -258,7 +256,7 @@ public func deletePeerExportedInvitation(account: Account, peerId: PeerId, link:
     |> switchToLatest
 }
 
-public func deleteAllRevokedPeerExportedInvitations(account: Account, peerId: PeerId, adminId: PeerId) -> Signal<Never, NoError> {
+func _internal_deleteAllRevokedPeerExportedInvitations(account: Account, peerId: PeerId, adminId: PeerId) -> Signal<Never, NoError> {
     return account.postbox.transaction { transaction -> Signal<Never, NoError> in
         if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer), let adminPeer = transaction.getPeer(adminId), let inputAdminId = apiInputUser(adminPeer) {
             return account.network.request(Api.functions.messages.deleteRevokedExportedChatInvites(peer: inputPeer, adminId: inputAdminId))
@@ -304,7 +302,7 @@ final class CachedPeerExportedInvitations: PostboxCoding {
     let canLoadMore: Bool
     let count: Int32
     
-    public static func key(peerId: PeerId, revoked: Bool) -> ValueBoxKey {
+    static func key(peerId: PeerId, revoked: Bool) -> ValueBoxKey {
         let key = ValueBoxKey(length: 8 + 4)
         key.setInt64(0, value: peerId.toInt64())
         key.setInt32(8, value: revoked ? 1 : 0)
@@ -317,13 +315,13 @@ final class CachedPeerExportedInvitations: PostboxCoding {
         self.count = count
     }
     
-    public init(decoder: PostboxDecoder) {
+    init(decoder: PostboxDecoder) {
         self.invitations = decoder.decodeObjectArrayForKey("invitations")
         self.canLoadMore = decoder.decodeBoolForKey("canLoadMore", orElse: false)
         self.count = decoder.decodeInt32ForKey("count", orElse: 0)
     }
     
-    public func encode(_ encoder: PostboxEncoder) {
+    func encode(_ encoder: PostboxEncoder) {
         encoder.encodeObjectArray(self.invitations, forKey: "invitations")
         encoder.encodeBool(self.canLoadMore, forKey: "canLoadMore")
         encoder.encodeInt32(self.count, forKey: "count")
@@ -494,7 +492,7 @@ private final class PeerExportedInvitationsContextImpl {
         self.updateState()
     }
     
-    public func add(_ invite: ExportedInvitation) {
+    func add(_ invite: ExportedInvitation) {
         var results = self.results
         results.removeAll(where: { $0.link == invite.link})
         results.insert(invite, at: 0)
@@ -503,7 +501,7 @@ private final class PeerExportedInvitationsContextImpl {
         self.updateCache()
     }
     
-    public func update(_ invite: ExportedInvitation) {
+    func update(_ invite: ExportedInvitation) {
         var results = self.results
         if let index = self.results.firstIndex(where: { $0.link == invite.link }) {
             results[index] = invite
@@ -513,7 +511,7 @@ private final class PeerExportedInvitationsContextImpl {
         self.updateCache()
     }
     
-    public func remove(_ invite: ExportedInvitation) {
+    func remove(_ invite: ExportedInvitation) {
         var results = self.results
         results.removeAll(where: { $0.link == invite.link})
         self.results = results
@@ -521,7 +519,7 @@ private final class PeerExportedInvitationsContextImpl {
         self.updateCache()
     }
     
-    public func clear() {
+    func clear() {
         self.results = []
         self.count = 0
         self.updateState()
@@ -564,7 +562,7 @@ public final class PeerExportedInvitationsContext {
         }
     }
     
-    public init(account: Account, peerId: PeerId, adminId: PeerId?, revoked: Bool, forceUpdate: Bool) {
+    init(account: Account, peerId: PeerId, adminId: PeerId?, revoked: Bool, forceUpdate: Bool) {
         let queue = self.queue
         self.impl = QueueLocalObject(queue: queue, generate: {
             return PeerExportedInvitationsContextImpl(queue: queue, account: account, peerId: peerId, adminId: adminId, revoked: revoked, forceUpdate: forceUpdate)
@@ -629,7 +627,7 @@ final class CachedPeerInvitationImporters: PostboxCoding {
     let dates: [PeerId: Int32]
     let count: Int32
     
-    public static func key(peerId: PeerId, link: String) -> ValueBoxKey {
+    static func key(peerId: PeerId, link: String) -> ValueBoxKey {
         let key = ValueBoxKey(length: 8 + 4)
         key.setInt64(0, value: peerId.toInt64())
         key.setInt32(8, value: Int32(HashFunctions.murMurHash32(link)))
@@ -644,13 +642,13 @@ final class CachedPeerInvitationImporters: PostboxCoding {
         self.count = count
     }
     
-    public init(peerIds: [PeerId], dates: [PeerId: Int32], count: Int32) {
+    init(peerIds: [PeerId], dates: [PeerId: Int32], count: Int32) {
         self.peerIds = peerIds
         self.dates = dates
         self.count = count
     }
     
-    public init(decoder: PostboxDecoder) {
+    init(decoder: PostboxDecoder) {
         self.peerIds = decoder.decodeInt64ArrayForKey("peerIds").map(PeerId.init)
         
         var dates: [PeerId: Int32] = [:]
@@ -666,7 +664,7 @@ final class CachedPeerInvitationImporters: PostboxCoding {
         self.count = decoder.decodeInt32ForKey("count", orElse: 0)
     }
     
-    public func encode(_ encoder: PostboxEncoder) {
+    func encode(_ encoder: PostboxEncoder) {
         encoder.encodeInt64Array(self.peerIds.map { $0.toInt64() }, forKey: "peerIds")
         
         var dates: [Int32] = []
@@ -859,7 +857,7 @@ public final class PeerInvitationImportersContext {
         }
     }
     
-    public init(account: Account, peerId: PeerId, invite: ExportedInvitation) {
+    init(account: Account, peerId: PeerId, invite: ExportedInvitation) {
         let queue = self.queue
         self.impl = QueueLocalObject(queue: queue, generate: {
             return PeerInvitationImportersContextImpl(queue: queue, account: account, peerId: peerId, invite: invite)
@@ -879,7 +877,7 @@ public struct ExportedInvitationCreator : Equatable {
     public let revokedCount: Int32
 }
 
-public func peerExportedInvitationsCreators(account: Account, peerId: PeerId) -> Signal<[ExportedInvitationCreator], NoError> {
+func _internal_peerExportedInvitationsCreators(account: Account, peerId: PeerId) -> Signal<[ExportedInvitationCreator], NoError> {
     return account.postbox.transaction { transaction -> Signal<[ExportedInvitationCreator], NoError> in
         if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer) {
             var isCreator = false

submodules/TelegramCore/Sources/TelegramEngine/Peers/JoinLink.swift

@@ -29,7 +29,7 @@ public enum ExternalJoiningChatState {
     case peek(PeerId, Int32)
 }
 
-public func joinChatInteractively(with hash: String, account: Account) -> Signal <PeerId?, JoinLinkError> {
+func _internal_joinChatInteractively(with hash: String, account: Account) -> Signal <PeerId?, JoinLinkError> {
     return account.network.request(Api.functions.messages.importChatInvite(hash: hash))
     |> mapError { error -> JoinLinkError in
         switch error.errorDescription {
@@ -59,7 +59,7 @@ public func joinChatInteractively(with hash: String, account: Account) -> Signal
     }
 }
 
-public func joinLinkInformation(_ hash: String, account: Account) -> Signal<ExternalJoiningChatState, NoError> {
+func _internal_joinLinkInformation(_ hash: String, account: Account) -> Signal<ExternalJoiningChatState, NoError> {
     return account.network.request(Api.functions.messages.checkChatInvite(hash: hash))
     |> map(Optional.init)
     |> `catch` { _ -> Signal<Api.ChatInvite?, NoError> in

submodules/TelegramCore/Sources/TelegramEngine/Peers/NotificationExceptionsList.swift

@@ -19,7 +19,7 @@ public final class NotificationExceptionsList: Equatable {
     }
 }
 
-public func notificationExceptionsList(postbox: Postbox, network: Network) -> Signal<NotificationExceptionsList, NoError> {
+func _internal_notificationExceptionsList(postbox: Postbox, network: Network) -> Signal<NotificationExceptionsList, NoError> {
     return network.request(Api.functions.account.getNotifyExceptions(flags: 1 << 1, peer: nil))
     |> retryRequest
     |> mapToSignal { result -> Signal<NotificationExceptionsList, NoError> in

submodules/TelegramCore/Sources/TelegramEngine/Peers/PeerPhotoUpdater.swift

@@ -15,8 +15,8 @@ public enum UploadPeerPhotoError {
     case generic
 }
 
-public func updateAccountPhoto(account: Account, resource: MediaResource?, videoResource: MediaResource?, videoStartTimestamp: Double?, mapResourceToAvatarSizes: @escaping (MediaResource, [TelegramMediaImageRepresentation]) -> Signal<[Int: Data], NoError>) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> {
-    return updatePeerPhoto(postbox: account.postbox, network: account.network, stateManager: account.stateManager, accountPeerId: account.peerId, peerId: account.peerId, photo: resource.flatMap({ uploadedPeerPhoto(postbox: account.postbox, network: account.network, resource: $0) }), video: videoResource.flatMap({ uploadedPeerVideo(postbox: account.postbox, network: account.network, messageMediaPreuploadManager: account.messageMediaPreuploadManager, resource: $0) |> map(Optional.init) }), videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: mapResourceToAvatarSizes)
+func _internal_updateAccountPhoto(account: Account, resource: MediaResource?, videoResource: MediaResource?, videoStartTimestamp: Double?, mapResourceToAvatarSizes: @escaping (MediaResource, [TelegramMediaImageRepresentation]) -> Signal<[Int: Data], NoError>) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> {
+    return _internal_updatePeerPhoto(postbox: account.postbox, network: account.network, stateManager: account.stateManager, accountPeerId: account.peerId, peerId: account.peerId, photo: resource.flatMap({ _internal_uploadedPeerPhoto(postbox: account.postbox, network: account.network, resource: $0) }), video: videoResource.flatMap({ _internal_uploadedPeerVideo(postbox: account.postbox, network: account.network, messageMediaPreuploadManager: account.messageMediaPreuploadManager, resource: $0) |> map(Optional.init) }), videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: mapResourceToAvatarSizes)
 }
 
 public struct UploadedPeerPhotoData {
@@ -37,7 +37,7 @@ enum UploadedPeerPhotoDataContent {
     case error
 }
 
-public func uploadedPeerPhoto(postbox: Postbox, network: Network, resource: MediaResource) -> Signal<UploadedPeerPhotoData, NoError> {
+func _internal_uploadedPeerPhoto(postbox: Postbox, network: Network, resource: MediaResource) -> Signal<UploadedPeerPhotoData, NoError> {
     return multipartUpload(network: network, postbox: postbox, source: .resource(.standalone(resource: resource)), encrypt: false, tag: TelegramMediaResourceFetchTag(statsCategory: .image), hintFileSize: nil, hintFileIsLarge: false, forceNoBigParts: false)
     |> map { result -> UploadedPeerPhotoData in
         return UploadedPeerPhotoData(resource: resource, content: .result(result))
@@ -47,7 +47,7 @@ public func uploadedPeerPhoto(postbox: Postbox, network: Network, resource: Medi
     }
 }
 
-public func uploadedPeerVideo(postbox: Postbox, network: Network, messageMediaPreuploadManager: MessageMediaPreuploadManager?, resource: MediaResource) -> Signal<UploadedPeerPhotoData, NoError> {
+func _internal_uploadedPeerVideo(postbox: Postbox, network: Network, messageMediaPreuploadManager: MessageMediaPreuploadManager?, resource: MediaResource) -> Signal<UploadedPeerPhotoData, NoError> {
     if let messageMediaPreuploadManager = messageMediaPreuploadManager {
         return messageMediaPreuploadManager.upload(network: network, postbox: postbox, source: .resource(.standalone(resource: resource)), encrypt: false, tag: TelegramMediaResourceFetchTag(statsCategory: .video), hintFileSize: nil, hintFileIsLarge: false)
         |> map { result -> UploadedPeerPhotoData in
@@ -67,11 +67,11 @@ public func uploadedPeerVideo(postbox: Postbox, network: Network, messageMediaPr
     }
 }
 
-public func updatePeerPhoto(postbox: Postbox, network: Network, stateManager: AccountStateManager?, accountPeerId: PeerId, peerId: PeerId, photo: Signal<UploadedPeerPhotoData, NoError>?, video: Signal<UploadedPeerPhotoData?, NoError>? = nil, videoStartTimestamp: Double? = nil, mapResourceToAvatarSizes: @escaping (MediaResource, [TelegramMediaImageRepresentation]) -> Signal<[Int: Data], NoError>) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> {
-    return updatePeerPhotoInternal(postbox: postbox, network: network, stateManager: stateManager, accountPeerId: accountPeerId, peer: postbox.loadedPeerWithId(peerId), photo: photo, video: video, videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: mapResourceToAvatarSizes)
+func _internal_updatePeerPhoto(postbox: Postbox, network: Network, stateManager: AccountStateManager?, accountPeerId: PeerId, peerId: PeerId, photo: Signal<UploadedPeerPhotoData, NoError>?, video: Signal<UploadedPeerPhotoData?, NoError>? = nil, videoStartTimestamp: Double? = nil, mapResourceToAvatarSizes: @escaping (MediaResource, [TelegramMediaImageRepresentation]) -> Signal<[Int: Data], NoError>) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> {
+    return _internal_updatePeerPhotoInternal(postbox: postbox, network: network, stateManager: stateManager, accountPeerId: accountPeerId, peer: postbox.loadedPeerWithId(peerId), photo: photo, video: video, videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: mapResourceToAvatarSizes)
 }
     
-public func updatePeerPhotoInternal(postbox: Postbox, network: Network, stateManager: AccountStateManager?, accountPeerId: PeerId, peer: Signal<Peer, NoError>, photo: Signal<UploadedPeerPhotoData, NoError>?, video: Signal<UploadedPeerPhotoData?, NoError>?, videoStartTimestamp: Double?, mapResourceToAvatarSizes: @escaping (MediaResource, [TelegramMediaImageRepresentation]) -> Signal<[Int: Data], NoError>) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> {
+func _internal_updatePeerPhotoInternal(postbox: Postbox, network: Network, stateManager: AccountStateManager?, accountPeerId: PeerId, peer: Signal<Peer, NoError>, photo: Signal<UploadedPeerPhotoData, NoError>?, video: Signal<UploadedPeerPhotoData?, NoError>?, videoStartTimestamp: Double?, mapResourceToAvatarSizes: @escaping (MediaResource, [TelegramMediaImageRepresentation]) -> Signal<[Int: Data], NoError>) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> {
     return peer
     |> mapError { _ in return .generic }
     |> mapToSignal { peer -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in
@@ -260,7 +260,7 @@ public func updatePeerPhotoInternal(postbox: Postbox, network: Network, stateMan
             }
             |> mapToSignal { result, resource, videoResource -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in
                 if case .complete = result {
-                    return fetchAndUpdateCachedPeerData(accountPeerId: accountPeerId, peerId: peer.id, network: network, postbox: postbox)
+                    return _internal_fetchAndUpdateCachedPeerData(accountPeerId: accountPeerId, peerId: peer.id, network: network, postbox: postbox)
                     |> castError(UploadPeerPhotoError.self)
                     |> mapToSignal { status -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in
                         return postbox.transaction { transaction in
@@ -335,7 +335,7 @@ public func updatePeerPhotoInternal(postbox: Postbox, network: Network, stateMan
     }
 }
 
-public func updatePeerPhotoExisting(network: Network, reference: TelegramMediaImageReference) -> Signal<TelegramMediaImage?, NoError> {
+func _internal_updatePeerPhotoExisting(network: Network, reference: TelegramMediaImageReference) -> Signal<TelegramMediaImage?, NoError> {
     switch reference {
         case let .cloud(imageId, accessHash, fileReference):
             return network.request(Api.functions.photos.updateProfilePhoto(id: .inputPhoto(id: imageId, accessHash: accessHash, fileReference: Buffer(data: fileReference))))
@@ -352,7 +352,7 @@ public func updatePeerPhotoExisting(network: Network, reference: TelegramMediaIm
     }
 }
 
-public func removeAccountPhoto(network: Network, reference: TelegramMediaImageReference?) -> Signal<Void, NoError> {
+func _internal_removeAccountPhoto(network: Network, reference: TelegramMediaImageReference?) -> Signal<Void, NoError> {
     if let reference = reference {
         switch reference {
         case let .cloud(imageId, accessHash, fileReference):

submodules/TelegramCore/Sources/TelegramEngine/Peers/RemovePeerChat.swift

@@ -34,7 +34,7 @@ func _internal_removePeerChat(account: Account, transaction: Transaction, mediaB
             }
         })
     }
-    updateChatListFiltersInteractively(transaction: transaction, { filters in
+    _internal_updateChatListFiltersInteractively(transaction: transaction, { filters in
         var filters = filters
         for i in 0 ..< filters.count {
             if filters[i].data.includePeers.peers.contains(peerId) {

submodules/TelegramCore/Sources/TelegramEngine/Peers/TelegramEnginePeers.swift

@@ -1,3 +1,4 @@
+import Foundation
 import SwiftSignalKit
 import Postbox
 import SyncCore
@@ -327,5 +328,136 @@ public extension TelegramEngine {
         public func removeRecentlyUsedInlineBot(peerId: PeerId) -> Signal<Void, NoError> {
             return _internal_removeRecentlyUsedInlineBot(account: self.account, peerId: peerId)
         }
+
+        public func uploadedPeerPhoto(resource: MediaResource) -> Signal<UploadedPeerPhotoData, NoError> {
+            return _internal_uploadedPeerPhoto(postbox: self.account.postbox, network: self.account.network, resource: resource)
+        }
+
+        public func uploadedPeerVideo(resource: MediaResource) -> Signal<UploadedPeerPhotoData, NoError> {
+            return _internal_uploadedPeerVideo(postbox: self.account.postbox, network: self.account.network, messageMediaPreuploadManager: self.account.messageMediaPreuploadManager, resource: resource)
+        }
+
+        public func updatePeerPhoto(peerId: PeerId, photo: Signal<UploadedPeerPhotoData, NoError>?, video: Signal<UploadedPeerPhotoData?, NoError>? = nil, videoStartTimestamp: Double? = nil, mapResourceToAvatarSizes: @escaping (MediaResource, [TelegramMediaImageRepresentation]) -> Signal<[Int: Data], NoError>) -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> {
+            return _internal_updatePeerPhoto(postbox: self.account.postbox, network: self.account.network, stateManager: self.account.stateManager, accountPeerId: self.account.peerId, peerId: peerId, photo: photo, video: video, videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: mapResourceToAvatarSizes)
+        }
+
+        public func requestUpdateChatListFilter(id: Int32, filter: ChatListFilter?) -> Signal<Never, RequestUpdateChatListFilterError> {
+            return _internal_requestUpdateChatListFilter(postbox: self.account.postbox, network: self.account.network, id: id, filter: filter)
+        }
+
+        public func requestUpdateChatListFilterOrder(ids: [Int32]) -> Signal<Never, RequestUpdateChatListFilterOrderError> {
+            return _internal_requestUpdateChatListFilterOrder(account: self.account, ids: ids)
+        }
+
+        public func generateNewChatListFilterId(filters: [ChatListFilter]) -> Int32 {
+            return _internal_generateNewChatListFilterId(filters: filters)
+        }
+
+        public func updateChatListFiltersInteractively(_ f: @escaping ([ChatListFilter]) -> [ChatListFilter]) -> Signal<[ChatListFilter], NoError> {
+            return _internal_updateChatListFiltersInteractively(postbox: self.account.postbox, f)
+        }
+
+        public func updatedChatListFilters() -> Signal<[ChatListFilter], NoError> {
+            return _internal_updatedChatListFilters(postbox: self.account.postbox)
+        }
+
+        public func updatedChatListFiltersInfo() -> Signal<(filters: [ChatListFilter], synchronized: Bool), NoError> {
+            return _internal_updatedChatListFiltersInfo(postbox: self.account.postbox)
+        }
+
+        public func currentChatListFilters() -> Signal<[ChatListFilter], NoError> {
+            return _internal_currentChatListFilters(postbox: self.account.postbox)
+        }
+
+        public func markChatListFeaturedFiltersAsSeen() -> Signal<Never, NoError> {
+            return _internal_markChatListFeaturedFiltersAsSeen(postbox: self.account.postbox)
+        }
+
+        public func updateChatListFeaturedFilters() -> Signal<Never, NoError> {
+            return _internal_updateChatListFeaturedFilters(postbox: self.account.postbox, network: self.account.network)
+        }
+
+        public func unmarkChatListFeaturedFiltersAsSeen() -> Signal<Never, NoError> {
+            return self.account.postbox.transaction { transaction in
+                _internal_unmarkChatListFeaturedFiltersAsSeen(transaction: transaction)
+            }
+            |> ignoreValues
+        }
+
+        public func checkPeerChatServiceActions(peerId: PeerId) -> Signal<Void, NoError> {
+            return _internal_checkPeerChatServiceActions(postbox: self.account.postbox, peerId: peerId)
+        }
+
+        public func createPeerExportedInvitation(peerId: PeerId, expireDate: Int32?, usageLimit: Int32?) -> Signal<ExportedInvitation?, CreatePeerExportedInvitationError> {
+            return _internal_createPeerExportedInvitation(account: self.account, peerId: peerId, expireDate: expireDate, usageLimit: usageLimit)
+        }
+
+        public func editPeerExportedInvitation(peerId: PeerId, link: String, expireDate: Int32?, usageLimit: Int32?) -> Signal<ExportedInvitation?, EditPeerExportedInvitationError> {
+            return _internal_editPeerExportedInvitation(account: self.account, peerId: peerId, link: link, expireDate: expireDate, usageLimit: usageLimit)
+        }
+
+        public func revokePeerExportedInvitation(peerId: PeerId, link: String) -> Signal<RevokeExportedInvitationResult?, RevokePeerExportedInvitationError> {
+            return _internal_revokePeerExportedInvitation(account: self.account, peerId: peerId, link: link)
+        }
+
+        public func deletePeerExportedInvitation(peerId: PeerId, link: String) -> Signal<Never, DeletePeerExportedInvitationError> {
+            return _internal_deletePeerExportedInvitation(account: self.account, peerId: peerId, link: link)
+        }
+
+        public func deleteAllRevokedPeerExportedInvitations(peerId: PeerId, adminId: PeerId) -> Signal<Never, NoError> {
+            return _internal_deleteAllRevokedPeerExportedInvitations(account: self.account, peerId: peerId, adminId: adminId)
+        }
+
+        public func peerExportedInvitationsCreators(peerId: PeerId) -> Signal<[ExportedInvitationCreator], NoError> {
+            return _internal_peerExportedInvitationsCreators(account: self.account, peerId: peerId)
+        }
+
+        public func peerExportedInvitations(peerId: PeerId, adminId: PeerId?, revoked: Bool, forceUpdate: Bool) -> PeerExportedInvitationsContext {
+            return PeerExportedInvitationsContext(account: self.account, peerId: peerId, adminId: adminId, revoked: revoked, forceUpdate: forceUpdate)
+        }
+
+        public func peerInvitationImporters(peerId: PeerId, invite: ExportedInvitation) -> PeerInvitationImportersContext {
+            return PeerInvitationImportersContext(account: self.account, peerId: peerId, invite: invite)
+        }
+
+        public func notificationExceptionsList() -> Signal<NotificationExceptionsList, NoError> {
+            return _internal_notificationExceptionsList(postbox: self.account.postbox, network: self.account.network)
+        }
+
+        public func fetchAndUpdateCachedPeerData(peerId: PeerId) -> Signal<Bool, NoError> {
+            return _internal_fetchAndUpdateCachedPeerData(accountPeerId: self.account.peerId, peerId: peerId, network: self.account.network, postbox: self.account.postbox)
+        }
+
+        public func toggleItemPinned(location: TogglePeerChatPinnedLocation, itemId: PinnedItemId) -> Signal<TogglePeerChatPinnedResult, NoError> {
+            return _internal_toggleItemPinned(postbox: self.account.postbox, location: location, itemId: itemId)
+        }
+
+        public func getPinnedItemIds(location: TogglePeerChatPinnedLocation) -> Signal<[PinnedItemId], NoError> {
+            return self.account.postbox.transaction { transaction -> [PinnedItemId] in
+                return _internal_getPinnedItemIds(transaction: transaction, location: location)
+            }
+        }
+
+        public func reorderPinnedItemIds(location: TogglePeerChatPinnedLocation, itemIds: [PinnedItemId]) -> Signal<Bool, NoError> {
+            return self.account.postbox.transaction { transaction -> Bool in
+                return _internal_reorderPinnedItemIds(transaction: transaction, location: location, itemIds: itemIds)
+            }
+        }
+
+        public func joinChatInteractively(with hash: String) -> Signal <PeerId?, JoinLinkError> {
+            return _internal_joinChatInteractively(with: hash, account: self.account)
+        }
+
+        public func joinLinkInformation(_ hash: String) -> Signal<ExternalJoiningChatState, NoError> {
+            return _internal_joinLinkInformation(hash, account: self.account)
+        }
+
+        public func updatePeerTitle(peerId: PeerId, title: String) -> Signal<Void, UpdatePeerTitleError> {
+            return _internal_updatePeerTitle(account: self.account, peerId: peerId, title: title)
+        }
+
+        public func updatePeerDescription(peerId: PeerId, description: String?) -> Signal<Void, UpdatePeerDescriptionError> {
+            return _internal_updatePeerDescription(account: self.account, peerId: peerId, description: description)
+        }
     }
 }

submodules/TelegramCore/Sources/TelegramEngine/Peers/TogglePeerChatPinned.swift

@@ -14,7 +14,7 @@ public enum TogglePeerChatPinnedResult {
     case limitExceeded(Int)
 }
 
-public func toggleItemPinned(postbox: Postbox, location: TogglePeerChatPinnedLocation, itemId: PinnedItemId) -> Signal<TogglePeerChatPinnedResult, NoError> {
+func _internal_toggleItemPinned(postbox: Postbox, location: TogglePeerChatPinnedLocation, itemId: PinnedItemId) -> Signal<TogglePeerChatPinnedResult, NoError> {
     return postbox.transaction { transaction -> TogglePeerChatPinnedResult in
         switch location {
         case let .group(groupId):
@@ -60,7 +60,7 @@ public func toggleItemPinned(postbox: Postbox, location: TogglePeerChatPinnedLoc
             }
         case let .filter(filterId):
             var result: TogglePeerChatPinnedResult = .done
-            updateChatListFiltersInteractively(transaction: transaction, { filters in
+            _internal_updateChatListFiltersInteractively(transaction: transaction, { filters in
                 var filters = filters
                 if let index = filters.firstIndex(where: { $0.id == filterId }) {
                     switch itemId {
@@ -81,13 +81,13 @@ public func toggleItemPinned(postbox: Postbox, location: TogglePeerChatPinnedLoc
     }
 }
 
-public func getPinnedItemIds(transaction: Transaction, location: TogglePeerChatPinnedLocation) -> [PinnedItemId] {
+func _internal_getPinnedItemIds(transaction: Transaction, location: TogglePeerChatPinnedLocation) -> [PinnedItemId] {
     switch location {
     case let .group(groupId):
         return transaction.getPinnedItemIds(groupId: groupId)
     case let .filter(filterId):
         var itemIds: [PinnedItemId] = []
-        let _ = updateChatListFiltersInteractively(transaction: transaction, { filters in
+        let _ = _internal_updateChatListFiltersInteractively(transaction: transaction, { filters in
             if let index = filters.firstIndex(where: { $0.id == filterId }) {
                 itemIds = filters[index].data.includePeers.pinnedPeers.map { peerId in
                     return .peer(peerId)
@@ -99,7 +99,7 @@ public func getPinnedItemIds(transaction: Transaction, location: TogglePeerChatP
     }
 }
 
-public func reorderPinnedItemIds(transaction: Transaction, location: TogglePeerChatPinnedLocation, itemIds: [PinnedItemId]) -> Bool {
+func _internal_reorderPinnedItemIds(transaction: Transaction, location: TogglePeerChatPinnedLocation, itemIds: [PinnedItemId]) -> Bool {
     switch location {
     case let .group(groupId):
         if transaction.getPinnedItemIds(groupId: groupId) != itemIds {
@@ -111,7 +111,7 @@ public func reorderPinnedItemIds(transaction: Transaction, location: TogglePeerC
         }
     case let .filter(filterId):
         var result: Bool = false
-        updateChatListFiltersInteractively(transaction: transaction, { filters in
+        _internal_updateChatListFiltersInteractively(transaction: transaction, { filters in
             var filters = filters
             if let index = filters.firstIndex(where: { $0.id == filterId }) {
                 let peerIds: [PeerId] = itemIds.map { itemId -> PeerId in

submodules/TelegramCore/Sources/TelegramEngine/Peers/UpdateCachedPeerData.swift

@@ -124,7 +124,7 @@ func fetchAndUpdateSupplementalCachedPeerData(peerId rawPeerId: PeerId, network:
     }
 }
 
-public func fetchAndUpdateCachedPeerData(accountPeerId: PeerId, peerId rawPeerId: PeerId, network: Network, postbox: Postbox) -> Signal<Bool, NoError> {
+func _internal_fetchAndUpdateCachedPeerData(accountPeerId: PeerId, peerId rawPeerId: PeerId, network: Network, postbox: Postbox) -> Signal<Bool, NoError> {
     return postbox.combinedView(keys: [.basicPeer(rawPeerId)])
     |> mapToSignal { views -> Signal<Bool, NoError> in
         if accountPeerId == rawPeerId {

submodules/TelegramCore/Sources/TelegramEngine/Peers/UpdatePeerInfo.swift

@@ -10,7 +10,7 @@ public enum UpdatePeerTitleError {
     case generic
 }
 
-public func updatePeerTitle(account: Account, peerId: PeerId, title: String) -> Signal<Void, UpdatePeerTitleError> {
+func _internal_updatePeerTitle(account: Account, peerId: PeerId, title: String) -> Signal<Void, UpdatePeerTitleError> {
     return account.postbox.transaction { transaction -> Signal<Void, UpdatePeerTitleError> in
         if let peer = transaction.getPeer(peerId) {
             if let peer = peer as? TelegramChannel, let inputChannel = apiInputChannel(peer) {
@@ -58,7 +58,7 @@ public enum UpdatePeerDescriptionError {
     case generic
 }
 
-public func updatePeerDescription(account: Account, peerId: PeerId, description: String?) -> Signal<Void, UpdatePeerDescriptionError> {
+func _internal_updatePeerDescription(account: Account, peerId: PeerId, description: String?) -> Signal<Void, UpdatePeerDescriptionError> {
     return account.postbox.transaction { transaction -> Signal<Void, UpdatePeerDescriptionError> in
         if let peer = transaction.getPeer(peerId) {
             if (peer is TelegramChannel || peer is TelegramGroup), let inputPeer = apiInputPeer(peer) {

submodules/TelegramCore/Sources/TelegramEngine/Resolve/DeepLinkInfo.swift

@@ -10,7 +10,7 @@ public struct DeepLinkInfo {
     public let updateApp: Bool
 }
 
-public func getDeepLinkInfo(network: Network, path: String) -> Signal<DeepLinkInfo?, NoError> {
+func _internal_getDeepLinkInfo(network: Network, path: String) -> Signal<DeepLinkInfo?, NoError> {
     return network.request(Api.functions.help.getDeepLinkInfo(path: path)) |> retryRequest
     |> map { value -> DeepLinkInfo? in
         switch value {

submodules/TelegramCore/Sources/TelegramEngine/Resolve/TelegramEngineResolve.swift

@@ -0,0 +1,16 @@
+import SwiftSignalKit
+import Postbox
+
+public extension TelegramEngine {
+    final class Resolve {
+        private let account: Account
+
+        init(account: Account) {
+            self.account = account
+        }
+
+        public func getDeepLinkInfo(path: String) -> Signal<DeepLinkInfo?, NoError> {
+            return _internal_getDeepLinkInfo(network: self.account.network, path: path)
+        }
+    }
+}

submodules/TelegramCore/Sources/TelegramEngine/Resources/CollectCacheUsageStats.swift

@@ -53,7 +53,7 @@ private final class CacheUsageStatsState {
     var upperBound: MessageIndex?
 }
 
-public func collectCacheUsageStats(account: Account, peerId: PeerId? = nil, additionalCachePaths: [String] = [], logFilesPath: String? = nil) -> Signal<CacheUsageStatsResult, NoError> {
+func _internal_collectCacheUsageStats(account: Account, peerId: PeerId? = nil, additionalCachePaths: [String] = [], logFilesPath: String? = nil) -> Signal<CacheUsageStatsResult, NoError> {
     var initialState = CacheUsageStatsState()
     if let peerId = peerId {
         initialState.lowerBound = MessageIndex.lowerBound(peerId: peerId)
@@ -291,6 +291,6 @@ public func collectCacheUsageStats(account: Account, peerId: PeerId? = nil, addi
     }
 }
 
-public func clearCachedMediaResources(account: Account, mediaResourceIds: Set<WrappedMediaResourceId>) -> Signal<Void, NoError> {
+func _internal_clearCachedMediaResources(account: Account, mediaResourceIds: Set<WrappedMediaResourceId>) -> Signal<Void, NoError> {
     return account.postbox.mediaBox.removeCachedResources(mediaResourceIds)
 }

submodules/TelegramCore/Sources/TelegramEngine/Resources/TelegramEngineResources.swift

@@ -0,0 +1,24 @@
+import SwiftSignalKit
+import Postbox
+
+public extension TelegramEngine {
+    final class Resources {
+        private let account: Account
+
+        init(account: Account) {
+            self.account = account
+        }
+
+        public func preUpload(id: Int64, encrypt: Bool, tag: MediaResourceFetchTag?, source: Signal<MediaResourceData, NoError>, onComplete: (()->Void)? = nil) {
+            return self.account.messageMediaPreuploadManager.add(network: self.account.network, postbox: self.account.postbox, id: id, encrypt: encrypt, tag: tag, source: source, onComplete: onComplete)
+        }
+
+        public func collectCacheUsageStats(peerId: PeerId? = nil, additionalCachePaths: [String] = [], logFilesPath: String? = nil) -> Signal<CacheUsageStatsResult, NoError> {
+            return _internal_collectCacheUsageStats(account: self.account, peerId: peerId, additionalCachePaths: additionalCachePaths, logFilesPath: logFilesPath)
+        }
+
+        public func clearCachedMediaResources(mediaResourceIds: Set<WrappedMediaResourceId>) -> Signal<Void, NoError> {
+            return _internal_clearCachedMediaResources(account: self.account, mediaResourceIds: mediaResourceIds)
+        }
+    }
+}

submodules/TelegramCore/Sources/TelegramEngine/Stickers/SearchStickers.swift

@@ -346,7 +346,7 @@ func _internal_searchGifs(account: Account, query: String, nextOffset: String =
         return account.postbox.loadedPeerWithId(peerId)
     }
     |> mapToSignal { peer -> Signal<ChatContextResultCollection?, NoError> in
-        return requestChatContextResults(account: account, botId: peer.id, peerId: account.peerId, query: query, offset: nextOffset)
+        return _internal_requestChatContextResults(account: account, botId: peer.id, peerId: account.peerId, query: query, offset: nextOffset)
         |> map { results -> ChatContextResultCollection? in
             return results?.results
         }

submodules/TelegramCore/Sources/TelegramEngine/TelegramEngine.swift

@@ -36,10 +36,6 @@ public final class TelegramEngine {
         return Stickers(account: self.account)
     }()
 
-    public lazy var peerManagement: PeerManagement = {
-        return PeerManagement(account: self.account)
-    }()
-
     public lazy var localization: Localization = {
         return Localization(account: self.account)
     }()
@@ -63,6 +59,14 @@ public final class TelegramEngine {
     public lazy var contacts: Contacts = {
         return Contacts(account: self.account)
     }()
+
+    public lazy var resources: Resources = {
+        return Resources(account: self.account)
+    }()
+
+    public lazy var resolve: Resolve = {
+        return Resolve(account: self.account)
+    }()
 }
 
 public final class TelegramEngineUnauthorized {

submodules/TelegramCore/Sources/Utils/MediaResourceNetworkStatsTag.swift

@@ -9,7 +9,7 @@ public enum MediaResourceStatsCategory {
     case call
 }
 
-public final class TelegramMediaResourceFetchTag: MediaResourceFetchTag {
+final class TelegramMediaResourceFetchTag: MediaResourceFetchTag {
     public let statsCategory: MediaResourceStatsCategory
     
     public init(statsCategory: MediaResourceStatsCategory) {

submodules/TelegramUI/Sources/AccountContext.swift

@@ -157,7 +157,7 @@ public final class AccountContextImpl: AccountContext {
     
     public let cachedGroupCallContexts: AccountGroupCallContextCache
     
-    public init(sharedContext: SharedAccountContextImpl, account: Account, /*tonContext: StoredTonContext?, */limitsConfiguration: LimitsConfiguration, contentSettings: ContentSettings, appConfiguration: AppConfiguration, temp: Bool = false)
+    public init(sharedContext: SharedAccountContextImpl, account: Account, limitsConfiguration: LimitsConfiguration, contentSettings: ContentSettings, appConfiguration: AppConfiguration, temp: Bool = false)
     {
         self.sharedContextImpl = sharedContext
         self.account = account
@@ -166,7 +166,7 @@ public final class AccountContextImpl: AccountContext {
         self.downloadedMediaStoreManager = DownloadedMediaStoreManagerImpl(postbox: account.postbox, accountManager: sharedContext.accountManager)
         
         if let locationManager = self.sharedContextImpl.locationManager {
-            self.liveLocationManager = LiveLocationManagerImpl(account: account, locationManager: locationManager, inForeground: sharedContext.applicationBindings.applicationInForeground)
+            self.liveLocationManager = LiveLocationManagerImpl(engine: self.engine, account: account, locationManager: locationManager, inForeground: sharedContext.applicationBindings.applicationInForeground)
         } else {
             self.liveLocationManager = nil
         }

submodules/TelegramUI/Sources/AuthorizationSequenceController.swift

@@ -705,7 +705,7 @@ public final class AuthorizationSequenceController: NavigationController, MFMail
                         }
                         |> mapToSignal { resource -> Signal<UploadedPeerPhotoData?, NoError> in
                             if let resource = resource {
-                                return uploadedPeerVideo(postbox: account.postbox, network: account.network, messageMediaPreuploadManager: nil, resource: resource) |> map(Optional.init)
+                                return TelegramEngineUnauthorized(account: account).auth.uploadedPeerVideo(resource: resource) |> map(Optional.init)
                             } else {
                                 return .single(nil)
                             }

submodules/TelegramUI/Sources/ChatController.swift

@@ -615,7 +615,7 @@ public final class ChatControllerImpl: TelegramBaseController, ChatController, G
                                                 statusController?.dismiss()
                                             }
                                             strongSelf.present(statusController, in: .window(.root))
-                                            strongSelf.createVoiceChatDisposable.set((createGroupCall(account: strongSelf.context.account, peerId: message.id.peerId, title: nil, scheduleDate: nil)
+                                            strongSelf.createVoiceChatDisposable.set((strongSelf.context.engine.calls.createGroupCall(peerId: message.id.peerId, title: nil, scheduleDate: nil)
                                             |> deliverOnMainQueue).start(next: { [weak self] info in
                                                 guard let strongSelf = self else {
                                                     return
@@ -7153,7 +7153,7 @@ public final class ChatControllerImpl: TelegramBaseController, ChatController, G
             }
             
             if case let .peer(peerId) = self.chatLocation {
-                let _ = checkPeerChatServiceActions(postbox: self.context.account.postbox, peerId: peerId).start()
+                let _ = self.context.engine.peers.checkPeerChatServiceActions(peerId: peerId).start()
             }
             
             if self.chatDisplayNode.frameForInputActionButton() != nil {
@@ -7280,7 +7280,7 @@ public final class ChatControllerImpl: TelegramBaseController, ChatController, G
                                 return
                             }
                             strongSelf.peekTimerDisposable.set(
-                                (joinChatInteractively(with: peekData.linkData, account: strongSelf.context.account)
+                                (strongSelf.context.engine.peers.joinChatInteractively(with: peekData.linkData)
                                 |> deliverOnMainQueue).start(next: { peerId in
                                     guard let strongSelf = self else {
                                         return
@@ -8314,7 +8314,7 @@ public final class ChatControllerImpl: TelegramBaseController, ChatController, G
                     }
                     let peerId = peer.id
                     
-                    let _ = (collectCacheUsageStats(account: strongSelf.context.account, peerId: peer.id)
+                    let _ = (strongSelf.context.engine.resources.collectCacheUsageStats(peerId: peer.id)
                     |> deliverOnMainQueue).start(next: { [weak self, weak controller] result in
                         controller?.dismiss()
                         
@@ -8433,7 +8433,7 @@ public final class ChatControllerImpl: TelegramBaseController, ChatController, G
                                     }
                                 }
                                 
-                                var signal = clearCachedMediaResources(account: strongSelf.context.account, mediaResourceIds: clearResourceIds)
+                                var signal = strongSelf.context.engine.resources.clearCachedMediaResources(mediaResourceIds: clearResourceIds)
                                 
                                 var cancelImpl: (() -> Void)?
                                 let presentationData = strongSelf.context.sharedContext.currentPresentationData.with { $0 }
@@ -9866,10 +9866,15 @@ public final class ChatControllerImpl: TelegramBaseController, ChatController, G
     }
     
     private func enqueueChatContextResult(_ results: ChatContextResultCollection, _ result: ChatContextResult, hideVia: Bool = false, closeMediaInput: Bool = false, silentPosting: Bool = false) {
+        if !canSendMessagesToChat(self.presentationInterfaceState) {
+            return
+        }
+
         let peerId = self.chatLocation.peerId
-        
-        if let message = outgoingMessageWithChatContextResult(to: peerId, results: results, result: result, hideVia: hideVia), canSendMessagesToChat(self.presentationInterfaceState) {
-            let replyMessageId = self.presentationInterfaceState.interfaceState.replyMessageId
+
+        let replyMessageId = self.presentationInterfaceState.interfaceState.replyMessageId
+
+        if self.context.engine.messages.enqueueOutgoingMessageWithChatContextResult(to: peerId, results: results, result: result, replyToMessageId: replyMessageId, hideVia: hideVia, silentPosting: silentPosting) {
             self.chatDisplayNode.setupSendActionOnViewUpdate({ [weak self] in
                 if let strongSelf = self {
                     strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: true, { state in
@@ -9891,9 +9896,6 @@ public final class ChatControllerImpl: TelegramBaseController, ChatController, G
                     })
                 }
             }, nil)
-            var messages = [message.withUpdatedReplyToMessageId(replyMessageId)]
-            messages = self.transformEnqueueMessages(messages, silentPosting: silentPosting)
-            self.sendMessages(messages)
         }
     }
     

submodules/TelegramUI/Sources/ChatInterfaceStateContextQueries.swift

@@ -149,7 +149,7 @@ private func updatedContextQueryResultStateForQuery(context: AccountContext, pee
                 signal = .single({ _ in return .hashtags([]) })
             }
             
-            let hashtags: Signal<(ChatPresentationInputQueryResult?) -> ChatPresentationInputQueryResult?, ChatContextQueryError> = recentlyUsedHashtags(postbox: context.account.postbox)
+            let hashtags: Signal<(ChatPresentationInputQueryResult?) -> ChatPresentationInputQueryResult?, ChatContextQueryError> = context.engine.messages.recentlyUsedHashtags()
                 |> map { hashtags -> (ChatPresentationInputQueryResult?) -> ChatPresentationInputQueryResult? in
                 let normalizedQuery = query.lowercased()
                 var result: [String] = []
@@ -279,7 +279,7 @@ private func updatedContextQueryResultStateForQuery(context: AccountContext, pee
             |> castError(ChatContextQueryError.self)
             |> mapToSignal { peer -> Signal<(ChatPresentationInputQueryResult?) -> ChatPresentationInputQueryResult?, ChatContextQueryError> in
                 if let user = peer as? TelegramUser, let botInfo = user.botInfo, let _ = botInfo.inlinePlaceholder {
-                    let contextResults = requestChatContextResults(account: context.account, botId: user.id, peerId: chatPeer.id, query: query, location: context.sharedContext.locationManager.flatMap { locationManager -> Signal<(Double, Double)?, NoError> in
+                    let contextResults = context.engine.messages.requestChatContextResults(botId: user.id, peerId: chatPeer.id, query: query, location: context.sharedContext.locationManager.flatMap { locationManager -> Signal<(Double, Double)?, NoError> in
                         return `deferred` {
                             Queue.mainQueue().async {
                                 requestBotLocationStatus(user.id)

submodules/TelegramUI/Sources/ChatRecentActionsControllerNode.swift

@@ -168,8 +168,7 @@ final class ChatRecentActionsControllerNode: ViewControllerTracingNode {
                                         items.append(ActionSheetButtonItem(title: strongSelf.presentationData.strings.InviteLink_ContextRevoke, color: .destructive, action: { [weak actionSheet] in
                                             actionSheet?.dismissAnimated()
                                             if let strongSelf = self {
-                                                let _ = (revokePeerExportedInvitation(account: strongSelf.context.account, peerId: peer.id, link: invite.link)
-                                                
+                                                let _ = (strongSelf.context.engine.peers.revokePeerExportedInvitation(peerId: peer.id, link: invite.link)
                                                 |> deliverOnMainQueue).start(completed: { [weak self] in
                                                     self?.eventLogContext.reload()
                                                 })

submodules/TelegramUI/Sources/CreateChannelController.swift

@@ -273,7 +273,7 @@ public func createChannelController(context: AccountContext) -> ViewController {
                     return $0.avatar
                 }
                 if let _ = updatingAvatar {
-                    let _ = updatePeerPhoto(postbox: context.account.postbox, network: context.account.network, stateManager: context.account.stateManager, accountPeerId: context.account.peerId, peerId: peerId, photo: uploadedAvatar.get(), video: uploadedVideoAvatar?.0.get(), videoStartTimestamp: uploadedVideoAvatar?.1, mapResourceToAvatarSizes: { resource, representations in
+                    let _ = context.engine.peers.updatePeerPhoto(peerId: peerId, photo: uploadedAvatar.get(), video: uploadedVideoAvatar?.0.get(), videoStartTimestamp: uploadedVideoAvatar?.1, mapResourceToAvatarSizes: { resource, representations in
                         return mapResourceToAvatarSizes(postbox: context.account.postbox, resource: resource, representations: representations)
                     }).start()
                 }
@@ -329,7 +329,7 @@ public func createChannelController(context: AccountContext) -> ViewController {
                     let resource = LocalFileMediaResource(fileId: Int64.random(in: Int64.min ... Int64.max))
                     context.account.postbox.mediaBox.storeResourceData(resource.id, data: data)
                     let representation = TelegramMediaImageRepresentation(dimensions: PixelDimensions(width: 640, height: 640), resource: resource, progressiveSizes: [], immediateThumbnailData: nil)
-                    uploadedAvatar.set(uploadedPeerPhoto(postbox: context.account.postbox, network: context.account.network, resource: resource))
+                    uploadedAvatar.set(context.engine.peers.uploadedPeerPhoto(resource: resource))
                     uploadedVideoAvatar = nil
                     updateState { current in
                         var current = current
@@ -363,7 +363,7 @@ public func createChannelController(context: AccountContext) -> ViewController {
                                 return nil
                             }
                         }
-                        let uploadInterface = LegacyLiveUploadInterface(account: context.account)
+                        let uploadInterface = LegacyLiveUploadInterface(context: context)
                         let signal: SSignal
                         if let asset = asset as? AVAsset {
                             signal = TGMediaVideoConverter.convert(asset, adjustments: adjustments, watcher: uploadInterface, entityRenderer: entityRenderer)!
@@ -427,7 +427,7 @@ public func createChannelController(context: AccountContext) -> ViewController {
                         }
                     }
                     
-                    uploadedAvatar.set(uploadedPeerPhoto(postbox: context.account.postbox, network: context.account.network, resource: photoResource))
+                    uploadedAvatar.set(context.engine.peers.uploadedPeerPhoto(resource: photoResource))
                     
                     let promise = Promise<UploadedPeerPhotoData?>()
                     promise.set(signal
@@ -436,7 +436,7 @@ public func createChannelController(context: AccountContext) -> ViewController {
                     }
                     |> mapToSignal { resource -> Signal<UploadedPeerPhotoData?, NoError> in
                         if let resource = resource {
-                            return uploadedPeerVideo(postbox: context.account.postbox, network: context.account.network, messageMediaPreuploadManager: context.account.messageMediaPreuploadManager, resource: resource) |> map(Optional.init)
+                            return context.engine.peers.uploadedPeerVideo(resource: resource) |> map(Optional.init)
                         } else {
                             return .single(nil)
                         }

submodules/TelegramUI/Sources/CreateGroupController.swift

@@ -482,7 +482,7 @@ public func createGroupControllerImpl(context: AccountContext, peerIds: [PeerId]
                     return $0.avatar
                 }
                 if let _ = updatingAvatar {
-                    return updatePeerPhoto(postbox: context.account.postbox, network: context.account.network, stateManager: context.account.stateManager, accountPeerId: context.account.peerId, peerId: peerId, photo: uploadedAvatar.get(), video: uploadedVideoAvatar?.0.get(), videoStartTimestamp: uploadedVideoAvatar?.1, mapResourceToAvatarSizes: { resource, representations in
+                    return context.engine.peers.updatePeerPhoto(peerId: peerId, photo: uploadedAvatar.get(), video: uploadedVideoAvatar?.0.get(), videoStartTimestamp: uploadedVideoAvatar?.1, mapResourceToAvatarSizes: { resource, representations in
                         return mapResourceToAvatarSizes(postbox: context.account.postbox, resource: resource, representations: representations)
                     })
                     |> ignoreValues
@@ -576,7 +576,7 @@ public func createGroupControllerImpl(context: AccountContext, peerIds: [PeerId]
                     let resource = LocalFileMediaResource(fileId: Int64.random(in: Int64.min ... Int64.max))
                     context.account.postbox.mediaBox.storeResourceData(resource.id, data: data)
                     let representation = TelegramMediaImageRepresentation(dimensions: PixelDimensions(width: 640, height: 640), resource: resource, progressiveSizes: [], immediateThumbnailData: nil)
-                    uploadedAvatar.set(uploadedPeerPhoto(postbox: context.account.postbox, network: context.account.network, resource: resource))
+                    uploadedAvatar.set(context.engine.peers.uploadedPeerPhoto(resource: resource))
                     uploadedVideoAvatar = nil
                     updateState { current in
                         var current = current
@@ -611,7 +611,7 @@ public func createGroupControllerImpl(context: AccountContext, peerIds: [PeerId]
                                 return nil
                             }
                         }
-                        let uploadInterface = LegacyLiveUploadInterface(account: context.account)
+                        let uploadInterface = LegacyLiveUploadInterface(context: context)
                         let signal: SSignal
                         if let asset = asset as? AVAsset {
                             signal = TGMediaVideoConverter.convert(asset, adjustments: adjustments, watcher: uploadInterface, entityRenderer: entityRenderer)!
@@ -675,7 +675,7 @@ public func createGroupControllerImpl(context: AccountContext, peerIds: [PeerId]
                         }
                     }
                     
-                    uploadedAvatar.set(uploadedPeerPhoto(postbox: context.account.postbox, network: context.account.network, resource: photoResource))
+                    uploadedAvatar.set(context.engine.peers.uploadedPeerPhoto(resource: photoResource))
                     
                     let promise = Promise<UploadedPeerPhotoData?>()
                     promise.set(signal
@@ -684,7 +684,7 @@ public func createGroupControllerImpl(context: AccountContext, peerIds: [PeerId]
                     }
                     |> mapToSignal { resource -> Signal<UploadedPeerPhotoData?, NoError> in
                         if let resource = resource {
-                            return uploadedPeerVideo(postbox: context.account.postbox, network: context.account.network, messageMediaPreuploadManager: context.account.messageMediaPreuploadManager, resource: resource) |> map(Optional.init)
+                            return context.engine.peers.uploadedPeerVideo(resource: resource) |> map(Optional.init)
                         } else {
                             return .single(nil)
                         }

submodules/TelegramUI/Sources/GifPaneSearchContentNode.swift

@@ -46,7 +46,7 @@ func paneGifSearchForQuery(context: AccountContext, query: String, offset: Strin
     }
     |> mapToSignal { peer -> Signal<(ChatPresentationInputQueryResult?, Bool, Bool), NoError> in
         if let user = peer as? TelegramUser, let botInfo = user.botInfo, let _ = botInfo.inlinePlaceholder {
-            let results = requestContextResults(account: context.account, botId: user.id, query: query, peerId: context.account.peerId, offset: offset ?? "", incompleteResults: incompleteResults, staleCachedResults: staleCachedResults, limit: 1)
+            let results = requestContextResults(context: context, botId: user.id, query: query, peerId: context.account.peerId, offset: offset ?? "", incompleteResults: incompleteResults, staleCachedResults: staleCachedResults, limit: 1)
             |> map { results -> (ChatPresentationInputQueryResult?, Bool, Bool) in
                 return (.contextRequestResult(user, results?.results), results != nil, results?.isStale ?? false)
             }

submodules/TelegramUI/Sources/HashtagChatInputContextPanelNode.swift

@@ -141,7 +141,7 @@ final class HashtagChatInputContextPanelNode: ChatInputContextPanelNode {
             }
         }, removeRequested: { [weak self] text in
             if let strongSelf = self {
-                let _ = removeRecentlyUsedHashtag(postbox: strongSelf.context.account.postbox, string: text).start()
+                let _ = strongSelf.context.engine.messages.removeRecentlyUsedHashtag(string: text).start()
                 strongSelf.revealedHashtag = nil
             }
         })

submodules/TelegramUI/Sources/HorizontalListContextResultsChatInputContextPanelNode.swift

@@ -234,7 +234,7 @@ final class HorizontalListContextResultsChatInputContextPanelNode: ChatInputCont
         let geoPoint = currentProcessedResults.geoPoint.flatMap { geoPoint -> (Double, Double) in
             return (geoPoint.latitude, geoPoint.longitude)
         }
-        self.loadMoreDisposable.set((requestChatContextResults(account: self.context.account, botId: currentProcessedResults.botId, peerId: currentProcessedResults.peerId, query: currentProcessedResults.query, location: .single(geoPoint), offset: nextOffset)
+        self.loadMoreDisposable.set((self.context.engine.messages.requestChatContextResults(botId: currentProcessedResults.botId, peerId: currentProcessedResults.peerId, query: currentProcessedResults.query, location: .single(geoPoint), offset: nextOffset)
         |> map { results -> ChatContextResultCollection? in
             return results?.results
         }

submodules/TelegramUI/Sources/LegacyInstantVideoController.swift

@@ -144,7 +144,7 @@ func legacyInstantVideoController(theme: PresentationTheme, panelFrame: CGRect,
             legacyController.view.disablesInteractiveTransitionGestureRecognizer = true
             var uploadInterface: LegacyLiveUploadInterface?
             if peerId.namespace != Namespaces.Peer.SecretChat {
-                uploadInterface = LegacyLiveUploadInterface(account: context.account)
+                uploadInterface = LegacyLiveUploadInterface(context: context)
             }
             
             var slowmodeValidUntil: Int32 = 0

submodules/TelegramUI/Sources/PeerInfo/PeerInfoData.swift

@@ -649,7 +649,7 @@ func peerInfoScreenData(context: AccountContext, peerId: PeerId, strings: Presen
                         canManageInvitations = true
                     }
                     if canManageInvitations {
-                        let invitationsContext = PeerExportedInvitationsContext(account: context.account, peerId: peerId, adminId: nil, revoked: false, forceUpdate: true)
+                        let invitationsContext = context.engine.peers.peerExportedInvitations(peerId: peerId, adminId: nil, revoked: false, forceUpdate: true)
                         invitationsContextPromise.set(.single(invitationsContext))
                         invitationsStatePromise.set(invitationsContext.state |> map(Optional.init))
                     }
@@ -812,7 +812,7 @@ func peerInfoScreenData(context: AccountContext, peerId: PeerId, strings: Presen
                         canManageInvitations = true
                     }
                     if canManageInvitations {
-                        let invitationsContext = PeerExportedInvitationsContext(account: context.account, peerId: peerId, adminId: nil, revoked: false, forceUpdate: true)
+                        let invitationsContext = context.engine.peers.peerExportedInvitations(peerId: peerId, adminId: nil, revoked: false, forceUpdate: true)
                         invitationsContextPromise.set(.single(invitationsContext))
                         invitationsStatePromise.set(invitationsContext.state |> map(Optional.init))
                     }

submodules/TelegramUI/Sources/PeerInfo/PeerInfoScreen.swift

@@ -2609,7 +2609,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
                             var hasProgress = false
                             if title != group.title {
                                 updateDataSignals.append(
-                                    updatePeerTitle(account: strongSelf.context.account, peerId: group.id, title: title)
+                                    strongSelf.context.engine.peers.updatePeerTitle(peerId: group.id, title: title)
                                     |> ignoreValues
                                     |> mapError { _ in return Void() }
                                 )
@@ -2617,7 +2617,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
                             }
                             if description != (data.cachedData as? CachedGroupData)?.about {
                                 updateDataSignals.append(
-                                    updatePeerDescription(account: strongSelf.context.account, peerId: group.id, description: description.isEmpty ? nil : description)
+                                    strongSelf.context.engine.peers.updatePeerDescription(peerId: group.id, description: description.isEmpty ? nil : description)
                                     |> ignoreValues
                                     |> mapError { _ in return Void() }
                                 )
@@ -2667,7 +2667,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
                                 var hasProgress = false
                                 if title != channel.title {
                                     updateDataSignals.append(
-                                        updatePeerTitle(account: strongSelf.context.account, peerId: channel.id, title: title)
+                                        strongSelf.context.engine.peers.updatePeerTitle(peerId: channel.id, title: title)
                                         |> ignoreValues
                                         |> mapError { _ in return Void() }
                                     )
@@ -2675,7 +2675,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
                                 }
                                 if description != (data.cachedData as? CachedChannelData)?.about {
                                     updateDataSignals.append(
-                                        updatePeerDescription(account: strongSelf.context.account, peerId: channel.id, description: description.isEmpty ? nil : description)
+                                        strongSelf.context.engine.peers.updatePeerDescription(peerId: channel.id, description: description.isEmpty ? nil : description)
                                         |> ignoreValues
                                         |> mapError { _ in return Void() }
                                     )
@@ -2752,7 +2752,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
         if self.isSettings {
             self.notificationExceptions.set(.single(NotificationExceptionsList(peers: [:], settings: [:]))
             |> then(
-                notificationExceptionsList(postbox: context.account.postbox, network: context.account.network)
+                context.engine.peers.notificationExceptionsList()
                 |> map(Optional.init)
             ))
             self.privacySettings.set(.single(nil) |> then(context.engine.privacy.requestAccountPrivacySettings() |> map(Optional.init)))
@@ -2837,7 +2837,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
             }
             
             if [Namespaces.Peer.CloudGroup, Namespaces.Peer.CloudChannel].contains(peerId.namespace) {
-                self.displayAsPeersPromise.set(cachedGroupCallDisplayAsAvailablePeers(account: context.account, peerId: peerId))
+                self.displayAsPeersPromise.set(context.engine.calls.cachedGroupCallDisplayAsAvailablePeers(peerId: peerId))
             }
         }
         
@@ -3995,13 +3995,6 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
     
     private func scheduleGroupCall() {
         self.context.scheduleGroupCall(peerId: self.peerId)
-//        
-//        
-//        let time = Int32(Date().timeIntervalSince1970 + 86400)
-//        self.activeActionDisposable.set((createGroupCall(account: self.context.account, peerId: self.peerId, title: nil, scheduleDate: time)
-//        |> deliverOnMainQueue).start(next: { [weak self] info in
-//            
-//        }))
     }
     
     private func createAndJoinGroupCall(peerId: PeerId, joinAsPeerId: PeerId?) {
@@ -4027,7 +4020,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
                 |> runOn(Queue.mainQueue())
                 |> delay(0.15, queue: Queue.mainQueue())
                 let progressDisposable = progressSignal.start()
-                let createSignal = createGroupCall(account: strongSelf.context.account, peerId: peerId, title: nil, scheduleDate: nil)
+                let createSignal = strongSelf.context.engine.calls.createGroupCall(peerId: peerId, title: nil, scheduleDate: nil)
                 |> afterDisposed {
                     Queue.mainQueue().async {
                         progressDisposable.dispose()
@@ -4389,7 +4382,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
                         }
                         
                         strongSelf.openVoiceChatDisplayAsPeerSelection(completion: { joinAsPeerId in
-                            let _ = updateGroupCallJoinAsPeer(account: context.account, peerId: peerId, joinAs: joinAsPeerId).start()
+                            let _ = context.engine.calls.updateGroupCallJoinAsPeer(peerId: peerId, joinAs: joinAsPeerId).start()
                             self?.openVoiceChatOptions(defaultJoinAsPeerId: joinAsPeerId, gesture: nil, contextController: c)
                         }, gesture: gesture, contextController: c, result: f, backAction: { [weak self] c in
                             self?.openVoiceChatOptions(defaultJoinAsPeerId: defaultJoinAsPeerId, gesture: nil, contextController: c)
@@ -5005,7 +4998,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
             if case let .image(reference, _, _, _) = item {
                 if let reference = reference {
                     if remove {
-                        let _ = removeAccountPhoto(network: self.context.account.network, reference: reference).start()
+                        let _ = self.context.engine.accountData.removeAccountPhoto(reference: reference).start()
                     }
                     let dismiss = self.headerNode.avatarListNode.listContainerNode.deleteItem(item)
                     if dismiss {
@@ -5046,9 +5039,9 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
         self.headerNode.ignoreCollapse = false
         
         let postbox = self.context.account.postbox
-        let signal = self.isSettings ? updateAccountPhoto(account: self.context.account, resource: resource, videoResource: nil, videoStartTimestamp: nil, mapResourceToAvatarSizes: { resource, representations in
+        let signal = self.isSettings ? self.context.engine.accountData.updateAccountPhoto(resource: resource, videoResource: nil, videoStartTimestamp: nil, mapResourceToAvatarSizes: { resource, representations in
             return mapResourceToAvatarSizes(postbox: postbox, resource: resource, representations: representations)
-        }) : updatePeerPhoto(postbox: postbox, network: self.context.account.network, stateManager: self.context.account.stateManager, accountPeerId: self.context.account.peerId, peerId: self.peerId, photo: uploadedPeerPhoto(postbox: postbox, network: self.context.account.network, resource: resource), mapResourceToAvatarSizes: { resource, representations in
+        }) : self.context.engine.peers.updatePeerPhoto(peerId: self.peerId, photo: self.context.engine.peers.uploadedPeerPhoto(resource: resource), mapResourceToAvatarSizes: { resource, representations in
             return mapResourceToAvatarSizes(postbox: postbox, resource: resource, representations: representations)
         })
         self.updateAvatarDisposable.set((signal
@@ -5096,6 +5089,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
         }
         
         let account = self.context.account
+        let context = self.context
         let signal = Signal<TelegramMediaResource, UploadPeerPhotoError> { [weak self] subscriber in
             let entityRenderer: LegacyPaintEntityRenderer? = adjustments.flatMap { adjustments in
                 if let paintingData = adjustments.paintingData, paintingData.hasAnimation {
@@ -5104,7 +5098,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
                     return nil
                 }
             }
-            let uploadInterface = LegacyLiveUploadInterface(account: account)
+            let uploadInterface = LegacyLiveUploadInterface(context: context)
             let signal: SSignal
             if let asset = asset as? AVAsset {
                 signal = TGMediaVideoConverter.convert(asset, adjustments: adjustments, watcher: uploadInterface, entityRenderer: entityRenderer)!
@@ -5180,11 +5174,11 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
         self.updateAvatarDisposable.set((signal
         |> mapToSignal { videoResource -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in
             if isSettings {
-                return updateAccountPhoto(account: account, resource: photoResource, videoResource: videoResource, videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: { resource, representations in
+                return context.engine.accountData.updateAccountPhoto(resource: photoResource, videoResource: videoResource, videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: { resource, representations in
                     return mapResourceToAvatarSizes(postbox: account.postbox, resource: resource, representations: representations)
                 })
             } else {
-                return updatePeerPhoto(postbox: account.postbox, network: account.network, stateManager: account.stateManager, accountPeerId: account.peerId, peerId: peerId, photo: uploadedPeerPhoto(postbox: account.postbox, network: account.network, resource: photoResource), video: uploadedPeerVideo(postbox: account.postbox, network: account.network, messageMediaPreuploadManager: account.messageMediaPreuploadManager, resource: videoResource) |> map(Optional.init), videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: { resource, representations in
+                return context.engine.peers.updatePeerPhoto(peerId: peerId, photo: context.engine.peers.uploadedPeerPhoto(resource: photoResource), video: context.engine.peers.uploadedPeerVideo(resource: videoResource) |> map(Optional.init), videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: { resource, representations in
                     return mapResourceToAvatarSizes(postbox: account.postbox, resource: resource, representations: representations)
                 })
             }
@@ -5305,7 +5299,7 @@ private final class PeerInfoScreenNode: ViewControllerTracingNode, UIScrollViewD
                         }
                     }
                     let postbox = strongSelf.context.account.postbox
-                    strongSelf.updateAvatarDisposable.set((updatePeerPhoto(postbox: strongSelf.context.account.postbox, network: strongSelf.context.account.network, stateManager: strongSelf.context.account.stateManager, accountPeerId: strongSelf.context.account.peerId, peerId: strongSelf.peerId, photo: nil, mapResourceToAvatarSizes: { resource, representations in
+                    strongSelf.updateAvatarDisposable.set((strongSelf.context.engine.peers.updatePeerPhoto(peerId: strongSelf.peerId, photo: nil, mapResourceToAvatarSizes: { resource, representations in
                         return mapResourceToAvatarSizes(postbox: postbox, resource: resource, representations: representations)
                     })
                     |> deliverOnMainQueue).start(next: { result in

submodules/TelegramUI/Sources/VerticalListContextResultsChatInputContextPanelNode.swift

@@ -340,7 +340,7 @@ final class VerticalListContextResultsChatInputContextPanelNode: ChatInputContex
         let geoPoint = currentProcessedResults.geoPoint.flatMap { geoPoint -> (Double, Double) in
             return (geoPoint.latitude, geoPoint.longitude)
         }
-        self.loadMoreDisposable.set((requestChatContextResults(account: self.context.account, botId: currentProcessedResults.botId, peerId: currentProcessedResults.peerId, query: currentProcessedResults.query, location: .single(geoPoint), offset: nextOffset)
+        self.loadMoreDisposable.set((self.context.engine.messages.requestChatContextResults(botId: currentProcessedResults.botId, peerId: currentProcessedResults.peerId, query: currentProcessedResults.query, location: .single(geoPoint), offset: nextOffset)
         |> map { results -> ChatContextResultCollection? in
             return results?.results
         }

submodules/TelegramVoip/Sources/GroupCallContext.swift

@@ -34,27 +34,16 @@ private protocol BroadcastPartSource: AnyObject {
 
 private final class NetworkBroadcastPartSource: BroadcastPartSource {
     private let queue: Queue
-    private let account: Account
+    private let engine: TelegramEngine
     private let callId: Int64
     private let accessHash: Int64
     private var dataSource: AudioBroadcastDataSource?
-
-    #if DEBUG
-    private let debugDumpDirectory: TempBoxDirectory?
-    #endif
     
-    init(queue: Queue, account: Account, callId: Int64, accessHash: Int64) {
+    init(queue: Queue, engine: TelegramEngine, callId: Int64, accessHash: Int64) {
         self.queue = queue
-        self.account = account
+        self.engine = engine
         self.callId = callId
         self.accessHash = accessHash
-
-        #if DEBUG
-        self.debugDumpDirectory = nil
-        /*let debugDumpDirectory = TempBox.shared.tempDirectory()
-        self.debugDumpDirectory = debugDumpDirectory
-        print("Debug streaming dump path: \(debugDumpDirectory.path)")*/
-        #endif
     }
     
     func requestPart(timestampMilliseconds: Int64, durationMilliseconds: Int64, completion: @escaping (OngoingGroupCallBroadcastPart) -> Void, rejoinNeeded: @escaping () -> Void) -> Disposable {
@@ -69,11 +58,12 @@ private final class NetworkBroadcastPartSource: BroadcastPartSource {
         if let dataSourceValue = self.dataSource {
             dataSource = .single(dataSourceValue)
         } else {
-            dataSource = getAudioBroadcastDataSource(account: self.account, callId: self.callId, accessHash: self.accessHash)
+            dataSource = self.engine.calls.getAudioBroadcastDataSource(callId: self.callId, accessHash: self.accessHash)
         }
 
         let callId = self.callId
         let accessHash = self.accessHash
+        let engine = self.engine
         
         let queue = self.queue
         let signal = dataSource
@@ -81,7 +71,7 @@ private final class NetworkBroadcastPartSource: BroadcastPartSource {
         |> mapToSignal { [weak self] dataSource -> Signal<GetAudioBroadcastPartResult?, NoError> in
             if let dataSource = dataSource {
                 self?.dataSource = dataSource
-                return getAudioBroadcastPart(dataSource: dataSource, callId: callId, accessHash: accessHash, timestampIdMilliseconds: timestampIdMilliseconds, durationMilliseconds: durationMilliseconds)
+                return engine.calls.getAudioBroadcastPart(dataSource: dataSource, callId: callId, accessHash: accessHash, timestampIdMilliseconds: timestampIdMilliseconds, durationMilliseconds: durationMilliseconds)
                 |> map(Optional.init)
             } else {
                 return .single(nil)
@@ -89,10 +79,6 @@ private final class NetworkBroadcastPartSource: BroadcastPartSource {
             }
         }
         |> deliverOn(self.queue)
-
-        #if DEBUG
-        let debugDumpDirectory = self.debugDumpDirectory
-        #endif
             
         return signal.start(next: { result in
             guard let result = result else {
@@ -102,12 +88,6 @@ private final class NetworkBroadcastPartSource: BroadcastPartSource {
             let part: OngoingGroupCallBroadcastPart
             switch result.status {
             case let .data(dataValue):
-                #if DEBUG
-                if let debugDumpDirectory = debugDumpDirectory {
-                    let _ = try? dataValue.write(to: URL(fileURLWithPath: debugDumpDirectory.path + "/" + "\(timestampIdMilliseconds).ogg"))
-                }
-                #endif
-
                 part = OngoingGroupCallBroadcastPart(timestampMilliseconds: timestampIdMilliseconds, responseTimestamp: result.responseTimestamp, status: .success, oggData: dataValue)
             case .notReady:
                 part = OngoingGroupCallBroadcastPart(timestampMilliseconds: timestampIdMilliseconds, responseTimestamp: result.responseTimestamp, status: .notReady, oggData: Data())
@@ -137,12 +117,12 @@ private final class OngoingGroupCallBroadcastPartTaskImpl : NSObject, OngoingGro
 
 public final class OngoingGroupCallContext {
     public struct AudioStreamData {
-        public var account: Account
+        public var engine: TelegramEngine
         public var callId: Int64
         public var accessHash: Int64
         
-        public init(account: Account, callId: Int64, accessHash: Int64) {
-            self.account = account
+        public init(engine: TelegramEngine, callId: Int64, accessHash: Int64) {
+            self.engine = engine
             self.callId = callId
             self.accessHash = accessHash
         }
@@ -351,7 +331,7 @@ public final class OngoingGroupCallContext {
             var audioLevelsUpdatedImpl: (([NSNumber]) -> Void)?
             
             if let audioStreamData = audioStreamData {
-                let broadcastPartsSource = NetworkBroadcastPartSource(queue: queue, account: audioStreamData.account, callId: audioStreamData.callId, accessHash: audioStreamData.accessHash)
+                let broadcastPartsSource = NetworkBroadcastPartSource(queue: queue, engine: audioStreamData.engine, callId: audioStreamData.callId, accessHash: audioStreamData.accessHash)
                 self.broadcastPartsSource = broadcastPartsSource
             }
             

submodules/WatchBridge/Sources/WatchRequestHandlers.swift

@@ -755,7 +755,7 @@ final class WatchLocationHandler: WatchRequestHandler {
                             guard let peerId = peerId else {
                                 return .single(nil)
                             }
-                            return requestChatContextResults(account: context.account, botId: peerId, peerId: context.account.peerId, query: "", location: .single((args.coordinate.latitude, args.coordinate.longitude)), offset: "")
+                            return context.engine.messages.requestChatContextResults(botId: peerId, peerId: context.account.peerId, query: "", location: .single((args.coordinate.latitude, args.coordinate.longitude)), offset: "")
                             |> map { results -> ChatContextResultCollection? in
                                 return results?.results
                             }

submodules/WebSearchUI/Sources/WebSearchController.swift

@@ -10,8 +10,8 @@ import LegacyComponents
 import TelegramUIPreferences
 import AccountContext
 
-public func requestContextResults(account: Account, botId: PeerId, query: String, peerId: PeerId, offset: String = "", existingResults: ChatContextResultCollection? = nil, incompleteResults: Bool = false, staleCachedResults: Bool = false, limit: Int = 60) -> Signal<RequestChatContextResultsResult?, NoError> {
-    return requestChatContextResults(account: account, botId: botId, peerId: peerId, query: query, offset: offset, incompleteResults: incompleteResults, staleCachedResults: staleCachedResults)
+public func requestContextResults(context: AccountContext, botId: PeerId, query: String, peerId: PeerId, offset: String = "", existingResults: ChatContextResultCollection? = nil, incompleteResults: Bool = false, staleCachedResults: Bool = false, limit: Int = 60) -> Signal<RequestChatContextResultsResult?, NoError> {
+    return context.engine.messages.requestChatContextResults(botId: botId, peerId: peerId, query: query, offset: offset, incompleteResults: incompleteResults, staleCachedResults: staleCachedResults)
     |> `catch` { error -> Signal<RequestChatContextResultsResult?, NoError> in
         return .single(nil)
     }
@@ -40,7 +40,7 @@ public func requestContextResults(account: Account, botId: PeerId, query: String
             updated = true
         }
         if let collection = collection, collection.results.count < limit, let nextOffset = collection.nextOffset, updated {
-            let nextResults = requestContextResults(account: account, botId: botId, query: query, peerId: peerId, offset: nextOffset, existingResults: collection, limit: limit)
+            let nextResults = requestContextResults(context: context, botId: botId, query: query, peerId: peerId, offset: nextOffset, existingResults: collection, limit: limit)
             if collection.results.count > 10 {
                 return .single(RequestChatContextResultsResult(results: collection, isStale: resultsStruct?.isStale ?? false))
                 |> then(nextResults)
@@ -445,6 +445,7 @@ public final class WebSearchController: ViewController {
         }
         
         let account = self.context.account
+        let context = self.context
         let contextBot = self.context.engine.peers.resolvePeerByName(name: name)
         |> mapToSignal { peerId -> Signal<Peer?, NoError> in
             if let peerId = peerId {
@@ -459,7 +460,7 @@ public final class WebSearchController: ViewController {
         }
         |> mapToSignal { peer -> Signal<(ChatPresentationInputQueryResult?) -> ChatPresentationInputQueryResult?, NoError> in
             if let user = peer as? TelegramUser, let botInfo = user.botInfo, let _ = botInfo.inlinePlaceholder {
-                let results = requestContextResults(account: account, botId: user.id, query: query, peerId: peerId, limit: 64)
+                let results = requestContextResults(context: context, botId: user.id, query: query, peerId: peerId, limit: 64)
                 |> map { results -> (ChatPresentationInputQueryResult?) -> ChatPresentationInputQueryResult? in
                     return { _ in
                         return .contextRequestResult(user, results?.results)

submodules/WebSearchUI/Sources/WebSearchControllerNode.swift

@@ -577,7 +577,7 @@ class WebSearchControllerNode: ASDisplayNode {
         let geoPoint = currentProcessedResults.geoPoint.flatMap { geoPoint -> (Double, Double) in
             return (geoPoint.latitude, geoPoint.longitude)
         }
-        self.loadMoreDisposable.set((requestChatContextResults(account: self.context.account, botId: currentProcessedResults.botId, peerId: currentProcessedResults.peerId, query: currentProcessedResults.query, location: .single(geoPoint), offset: nextOffset)
+        self.loadMoreDisposable.set((self.context.engine.messages.requestChatContextResults(botId: currentProcessedResults.botId, peerId: currentProcessedResults.peerId, query: currentProcessedResults.query, location: .single(geoPoint), offset: nextOffset)
             |> deliverOnMainQueue).start(next: { [weak self] nextResults in
                 guard let strongSelf = self, let nextResults = nextResults else {
                     return