Update API

submodules/TelegramApi/Sources/Api0.swift

@@ -710,8 +710,8 @@ fileprivate let parsers: [Int32 : (BufferReader) -> Any?] = {
     dict[236446268] = { return Api.PhotoSize.parse_photoSizeEmpty($0) }
     dict[-96535659] = { return Api.PhotoSize.parse_photoSizeProgressive($0) }
     dict[-525288402] = { return Api.PhotoSize.parse_photoStrippedSize($0) }
-    dict[-2032041631] = { return Api.Poll.parse_poll($0) }
+    dict[1484026161] = { return Api.Poll.parse_poll($0) }
-    dict[1823064809] = { return Api.PollAnswer.parse_pollAnswer($0) }
+    dict[-15277366] = { return Api.PollAnswer.parse_pollAnswer($0) }
     dict[997055186] = { return Api.PollAnswerVoters.parse_pollAnswerVoters($0) }
     dict[2061444128] = { return Api.PollResults.parse_pollResults($0) }
     dict[1558266229] = { return Api.PopularContact.parse_popularContact($0) }
@@ -1358,7 +1358,7 @@ public extension Api {
                 return parser(reader)
             }
             else {
-                telegramApiLog("Type constructor \(String(signature, radix: 16, uppercase: false)) not found")
+                telegramApiLog("Type constructor \(String(UInt32(bitPattern: signature), radix: 16, uppercase: false)) not found")
                 return nil
             }
         }

submodules/TelegramApi/Sources/Api18.swift

@@ -436,17 +436,17 @@ public extension Api {
 }
 public extension Api {
     enum Poll: TypeConstructorDescription {
-        case poll(id: Int64, flags: Int32, question: String, answers: [Api.PollAnswer], closePeriod: Int32?, closeDate: Int32?)
+        case poll(id: Int64, flags: Int32, question: Api.TextWithEntities, answers: [Api.PollAnswer], closePeriod: Int32?, closeDate: Int32?)
     
     public func serialize(_ buffer: Buffer, _ boxed: Swift.Bool) {
     switch self {
                 case .poll(let id, let flags, let question, let answers, let closePeriod, let closeDate):
                     if boxed {
-                        buffer.appendInt32(-2032041631)
+                        buffer.appendInt32(1484026161)
                     }
                     serializeInt64(id, buffer: buffer, boxed: false)
                     serializeInt32(flags, buffer: buffer, boxed: false)
-                    serializeString(question, buffer: buffer, boxed: false)
+                    question.serialize(buffer, true)
                     buffer.appendInt32(481674261)
                     buffer.appendInt32(Int32(answers.count))
                     for item in answers {
@@ -470,8 +470,10 @@ public extension Api {
             _1 = reader.readInt64()
             var _2: Int32?
             _2 = reader.readInt32()
-            var _3: String?
+            var _3: Api.TextWithEntities?
-            _3 = parseString(reader)
+            if let signature = reader.readInt32() {
+                _3 = Api.parse(reader, signature: signature) as? Api.TextWithEntities
+            }
             var _4: [Api.PollAnswer]?
             if let _ = reader.readInt32() {
                 _4 = Api.parseVector(reader, elementSignature: 0, elementType: Api.PollAnswer.self)
@@ -498,15 +500,15 @@ public extension Api {
 }
 public extension Api {
     enum PollAnswer: TypeConstructorDescription {
-        case pollAnswer(text: String, option: Buffer)
+        case pollAnswer(text: Api.TextWithEntities, option: Buffer)
     
     public func serialize(_ buffer: Buffer, _ boxed: Swift.Bool) {
     switch self {
                 case .pollAnswer(let text, let option):
                     if boxed {
-                        buffer.appendInt32(1823064809)
+                        buffer.appendInt32(-15277366)
                     }
-                    serializeString(text, buffer: buffer, boxed: false)
+                    text.serialize(buffer, true)
                     serializeBytes(option, buffer: buffer, boxed: false)
                     break
     }
@@ -520,8 +522,10 @@ public extension Api {
     }
     
         public static func parse_pollAnswer(_ reader: BufferReader) -> PollAnswer? {
-            var _1: String?
+            var _1: Api.TextWithEntities?
-            _1 = parseString(reader)
+            if let signature = reader.readInt32() {
+                _1 = Api.parse(reader, signature: signature) as? Api.TextWithEntities
+            }
             var _2: Buffer?
             _2 = parseBytes(reader)
             let _c1 = _1 != nil

submodules/TelegramCore/Sources/ApiUtils/StoreMessage_Telegram.swift

@@ -433,7 +433,16 @@ func textMediaAndExpirationTimerFromApiMedia(_ media: Api.MessageMedia?, _ peerI
                 } else {
                     kind = .poll(multipleAnswers: (flags & (1 << 2)) != 0)
                 }
-                return (TelegramMediaPoll(pollId: MediaId(namespace: Namespaces.Media.CloudPoll, id: id), publicity: publicity, kind: kind, text: question, textEntities: [], options: answers.map(TelegramMediaPollOption.init(apiOption:)), correctAnswers: nil, results: TelegramMediaPollResults(apiResults: results), isClosed: (flags & (1 << 0)) != 0, deadlineTimeout: closePeriod), nil, nil, nil, nil)
+                
+                let questionText: String
+                let questionEntities: [MessageTextEntity]
+                switch question {
+                case let .textWithEntities(text, entities):
+                    questionText = text
+                    questionEntities = messageTextEntitiesFromApiEntities(entities)
+                }
+                
+                return (TelegramMediaPoll(pollId: MediaId(namespace: Namespaces.Media.CloudPoll, id: id), publicity: publicity, kind: kind, text: questionText, textEntities: questionEntities, options: answers.map(TelegramMediaPollOption.init(apiOption:)), correctAnswers: nil, results: TelegramMediaPollResults(apiResults: results), isClosed: (flags & (1 << 0)) != 0, deadlineTimeout: closePeriod), nil, nil, nil, nil)
             }
         case let .messageMediaDice(value, emoticon):
             return (TelegramMediaDice(emoji: emoticon, value: value), nil, nil, nil, nil)

submodules/TelegramCore/Sources/ApiUtils/TelegramMediaPoll.swift

@@ -6,13 +6,21 @@ import TelegramApi
 extension TelegramMediaPollOption {
     init(apiOption: Api.PollAnswer) {
         switch apiOption {
-            case let .pollAnswer(text, option):
+        case let .pollAnswer(text, option):
-                self.init(text: text, entities: [], opaqueIdentifier: option.makeData())
+            let answerText: String
+            let answerEntities: [MessageTextEntity]
+            switch text {
+            case let .textWithEntities(text, entities):
+                answerText = text
+                answerEntities = messageTextEntitiesFromApiEntities(entities)
+            }
+            
+            self.init(text: answerText, entities: answerEntities, opaqueIdentifier: option.makeData())
         }
     }
     
     var apiOption: Api.PollAnswer {
-        return .pollAnswer(text: self.text, option: Buffer(data: self.opaqueIdentifier))
+        return .pollAnswer(text: .textWithEntities(text: self.text, entities: apiEntitiesFromMessageTextEntities(self.entities, associatedPeers: SimpleDictionary())), option: Buffer(data: self.opaqueIdentifier))
     }
 }
 

submodules/TelegramCore/Sources/PendingMessages/PendingMessageUploadedContent.swift

@@ -251,7 +251,7 @@ func mediaContentToUpload(accountPeerId: PeerId, network: Network, postbox: Post
             mappedSolutionEntities = apiTextAttributeEntities(TextEntitiesMessageAttribute(entities: solution.entities), associatedPeers: SimpleDictionary())
             pollMediaFlags |= 1 << 1
         }
-        let inputPoll = Api.InputMedia.inputMediaPoll(flags: pollMediaFlags, poll: Api.Poll.poll(id: 0, flags: pollFlags, question: poll.text, answers: poll.options.map({ $0.apiOption }), closePeriod: poll.deadlineTimeout, closeDate: nil), correctAnswers: correctAnswers, solution: mappedSolution, solutionEntities: mappedSolutionEntities)
+        let inputPoll = Api.InputMedia.inputMediaPoll(flags: pollMediaFlags, poll: Api.Poll.poll(id: 0, flags: pollFlags, question: .textWithEntities(text: poll.text, entities: apiEntitiesFromMessageTextEntities(poll.textEntities, associatedPeers: SimpleDictionary())), answers: poll.options.map({ $0.apiOption }), closePeriod: poll.deadlineTimeout, closeDate: nil), correctAnswers: correctAnswers, solution: mappedSolution, solutionEntities: mappedSolutionEntities)
         return .single(.content(PendingMessageUploadedContentAndReuploadInfo(content: .media(inputPoll, text), reuploadInfo: nil, cacheReferenceKey: nil)))
     } else if let media = media as? TelegramMediaDice {
         let inputDice = Api.InputMedia.inputMediaDice(emoticon: media.emoji)

submodules/TelegramCore/Sources/State/AccountStateManagementUtils.swift

@@ -3897,7 +3897,16 @@ func replayFinalState(
                             } else {
                                 kind = .poll(multipleAnswers: (flags & (1 << 2)) != 0)
                             }
-                            updatedPoll = TelegramMediaPoll(pollId: MediaId(namespace: Namespaces.Media.CloudPoll, id: id), publicity: publicity, kind: kind, text: question, textEntities: [], options: answers.map(TelegramMediaPollOption.init(apiOption:)), correctAnswers: nil, results: poll.results, isClosed: (flags & (1 << 0)) != 0, deadlineTimeout: closePeriod)
+                            
+                            let questionText: String
+                            let questionEntities: [MessageTextEntity]
+                            switch question {
+                            case let .textWithEntities(text, entities):
+                                questionText = text
+                                questionEntities = messageTextEntitiesFromApiEntities(entities)
+                            }
+                            
+                            updatedPoll = TelegramMediaPoll(pollId: MediaId(namespace: Namespaces.Media.CloudPoll, id: id), publicity: publicity, kind: kind, text: questionText, textEntities: questionEntities, options: answers.map(TelegramMediaPollOption.init(apiOption:)), correctAnswers: nil, results: poll.results, isClosed: (flags & (1 << 0)) != 0, deadlineTimeout: closePeriod)
                         }
                     }
                     updatedPoll = updatedPoll.withUpdatedResults(TelegramMediaPollResults(apiResults: results), min: resultsMin)

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

@@ -44,7 +44,14 @@ func _internal_requestMessageSelectPollOption(account: Account, messageId: Messa
                                         } else {
                                             kind = .poll(multipleAnswers: (flags & (1 << 2)) != 0)
                                         }
-                                        resultPoll = TelegramMediaPoll(pollId: pollId, publicity: publicity, kind: kind, text: question, textEntities: [], options: answers.map(TelegramMediaPollOption.init(apiOption:)), correctAnswers: nil, results: TelegramMediaPollResults(apiResults: results), isClosed: (flags & (1 << 0)) != 0, deadlineTimeout: closePeriod)
+                                        let questionText: String
+                                        let questionEntities: [MessageTextEntity]
+                                        switch question {
+                                        case let .textWithEntities(text, entities):
+                                            questionText = text
+                                            questionEntities = messageTextEntitiesFromApiEntities(entities)
+                                        }
+                                        resultPoll = TelegramMediaPoll(pollId: pollId, publicity: publicity, kind: kind, text: questionText, textEntities: questionEntities, options: answers.map(TelegramMediaPollOption.init(apiOption:)), correctAnswers: nil, results: TelegramMediaPollResults(apiResults: results), isClosed: (flags & (1 << 0)) != 0, deadlineTimeout: closePeriod)
                                     }
                                 }
                                 
@@ -135,7 +142,7 @@ func _internal_requestClosePoll(postbox: Postbox, network: Network, stateManager
             pollMediaFlags |= 1 << 1
         }
         
-        return network.request(Api.functions.messages.editMessage(flags: flags, peer: inputPeer, id: messageId.id, message: nil, media: .inputMediaPoll(flags: pollMediaFlags, poll: .poll(id: poll.pollId.id, flags: pollFlags, question: poll.text, answers: poll.options.map({ $0.apiOption }), closePeriod: poll.deadlineTimeout, closeDate: nil), correctAnswers: correctAnswers, solution: mappedSolution, solutionEntities: mappedSolutionEntities), replyMarkup: nil, entities: nil, scheduleDate: nil, quickReplyShortcutId: nil))
+        return network.request(Api.functions.messages.editMessage(flags: flags, peer: inputPeer, id: messageId.id, message: nil, media: .inputMediaPoll(flags: pollMediaFlags, poll: .poll(id: poll.pollId.id, flags: pollFlags, question: .textWithEntities(text: poll.text, entities: apiEntitiesFromMessageTextEntities(poll.textEntities, associatedPeers: SimpleDictionary())), answers: poll.options.map({ $0.apiOption }), closePeriod: poll.deadlineTimeout, closeDate: nil), correctAnswers: correctAnswers, solution: mappedSolution, solutionEntities: mappedSolutionEntities), replyMarkup: nil, entities: nil, scheduleDate: nil, quickReplyShortcutId: nil))
         |> map(Optional.init)
         |> `catch` { _ -> Signal<Api.Updates?, NoError> in
             return .single(nil)