Merge commit 'bcbcc94b585076fe8dbd2bb7b0f4b01dbb89a904'

# Conflicts:
#	submodules/TelegramUI/Components/Chat/ChatMessageAttachedContentNode/Sources/ChatMessageAttachedContentNode.swift
#	submodules/TelegramUI/Components/Chat/ChatMessageReplyInfoNode/Sources/ChatMessageReplyInfoNode.swift

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

@@ -53,23 +53,24 @@ public enum UpdateNameColorAndEmojiError {
 
 func _internal_updateNameColorAndEmoji(account: Account, nameColor: PeerNameColor, backgroundEmojiId: Int64?) -> Signal<Void, UpdateNameColorAndEmojiError> {
     let flags: Int32 = (1 << 0)
-    return account.postbox.loadedPeerWithId(account.peerId)
-    |> castError(UpdateNameColorAndEmojiError.self)
-    |> mapToSignal { accountPeer -> Signal<Void, UpdateNameColorAndEmojiError> in
-        guard let accountPeer = accountPeer as? TelegramUser else {
-            return .fail(.generic)
+    return account.postbox.transaction { transaction -> Signal<Peer, NoError> in
+        guard let peer = transaction.getPeer(account.peerId) as? TelegramUser else {
+            return .complete()
         }
+        updatePeersCustom(transaction: transaction, peers: [peer.withUpdatedNameColor(nameColor).withUpdatedBackgroundEmojiId(backgroundEmojiId)], update: { _, updated in
+            return updated
+        })
+        return .single(peer)
+    }
+    |> switchToLatest
+    |> castError(UpdateNameColorAndEmojiError.self)
+    |> mapToSignal { _ -> Signal<Void, UpdateNameColorAndEmojiError> in
         return account.network.request(Api.functions.account.updateColor(flags: flags, color: nameColor.rawValue, backgroundEmojiId: backgroundEmojiId ?? 0))
         |> mapError { _ -> UpdateNameColorAndEmojiError in
             return .generic
         }
-        |> mapToSignal { apiUser -> Signal<Void, UpdateNameColorAndEmojiError> in
-            return account.postbox.transaction { transaction -> Void in
-                updatePeersCustom(transaction: transaction, peers: [accountPeer.withUpdatedNameColor(nameColor).withUpdatedBackgroundEmojiId(backgroundEmojiId)], update: { _, updated in
-                    return updated
-                })
-            }
-            |> castError(UpdateNameColorAndEmojiError.self)
+        |> mapToSignal { _ -> Signal<Void, UpdateNameColorAndEmojiError> in
+            return .complete()
         }
     }
 }

submodules/TelegramCore/Sources/TelegramEngine/Payments/BotPaymentForm.swift

@@ -7,8 +7,10 @@ import TelegramApi
 public enum BotPaymentInvoiceSource {
     case message(MessageId)
     case slug(String)
+    case premiumGiveaway(boostPeer: EnginePeer.Id, additionalPeerIds: [EnginePeer.Id], countries: [String], onlyNewSubscribers: Bool, randomId: Int64, untilDate: Int32, currency: String, amount: Int64, option: PremiumGiftCodeOption)
 }
 
+
 public struct BotPaymentInvoiceFields: OptionSet {
     public var rawValue: Int32
     
@@ -203,17 +205,55 @@ extension BotPaymentRequestedInfo {
     }
 }
 
+private func _internal_parseInputInvoice(transaction: Transaction, source: BotPaymentInvoiceSource) -> Api.InputInvoice? {
+    switch source {
+    case let .message(messageId):
+        guard let inputPeer = transaction.getPeer(messageId.peerId).flatMap(apiInputPeer) else {
+            return nil
+        }
+        return .inputInvoiceMessage(peer: inputPeer, msgId: messageId.id)
+    case let .slug(slug):
+        return .inputInvoiceSlug(slug: slug)
+    case let .premiumGiveaway(boostPeerId, additionalPeerIds, countries, onlyNewSubscribers, randomId, untilDate, currency, amount, option):
+        guard let peer = transaction.getPeer(boostPeerId), let apiBoostPeer = apiInputPeer(peer) else {
+            return nil
+        }
+        var flags: Int32 = 0
+        if onlyNewSubscribers {
+            flags |= (1 << 0)
+        }
+        var additionalPeers: [Api.InputPeer] = []
+        if !additionalPeerIds.isEmpty {
+            flags |= (1 << 1)
+            for peerId in additionalPeerIds {
+                if let peer = transaction.getPeer(peerId), let inputPeer = apiInputPeer(peer) {
+                    additionalPeers.append(inputPeer)
+                }
+            }
+        }
+        if !countries.isEmpty {
+            flags |= (1 << 2)
+        }
+        let input: Api.InputStorePaymentPurpose = .inputStorePaymentPremiumGiveaway(flags: flags, boostPeer: apiBoostPeer, additionalPeers: additionalPeers, countriesIso2: countries, randomId: randomId, untilDate: untilDate, currency: currency, amount: amount)
+
+        flags = 0
+        
+        if let _ = option.storeProductId {
+            flags |= (1 << 0)
+        }
+        if option.storeQuantity > 0 {
+            flags |= (1 << 1)
+        }
+        
+        let option: Api.PremiumGiftCodeOption = .premiumGiftCodeOption(flags: flags, users: option.users, months: option.months, storeProduct: option.storeProductId, storeQuantity: option.storeQuantity, currency: option.currency, amount: option.amount)
+        
+        return .inputInvoicePremiumGiftCode(purpose: input, option: option)
+    }
+}
+
 func _internal_fetchBotPaymentInvoice(postbox: Postbox, network: Network, source: BotPaymentInvoiceSource) -> Signal<TelegramMediaInvoice, BotPaymentFormRequestError> {
     return postbox.transaction { transaction -> Api.InputInvoice? in
-        switch source {
-        case let .message(messageId):
-            guard let inputPeer = transaction.getPeer(messageId.peerId).flatMap(apiInputPeer) else {
-                return nil
-            }
-            return .inputInvoiceMessage(peer: inputPeer, msgId: messageId.id)
-        case let .slug(slug):
-            return .inputInvoiceSlug(slug: slug)
-        }
+        return _internal_parseInputInvoice(transaction: transaction, source: source)
     }
     |> castError(BotPaymentFormRequestError.self)
     |> mapToSignal { invoice -> Signal<TelegramMediaInvoice, BotPaymentFormRequestError> in
@@ -251,15 +291,7 @@ func _internal_fetchBotPaymentInvoice(postbox: Postbox, network: Network, source
 
 func _internal_fetchBotPaymentForm(accountPeerId: PeerId, postbox: Postbox, network: Network, source: BotPaymentInvoiceSource, themeParams: [String: Any]?) -> Signal<BotPaymentForm, BotPaymentFormRequestError> {
     return postbox.transaction { transaction -> Api.InputInvoice? in
-        switch source {
-        case let .message(messageId):
-            guard let inputPeer = transaction.getPeer(messageId.peerId).flatMap(apiInputPeer) else {
-                return nil
-            }
-            return .inputInvoiceMessage(peer: inputPeer, msgId: messageId.id)
-        case let .slug(slug):
-            return .inputInvoiceSlug(slug: slug)
-        }
+        return _internal_parseInputInvoice(transaction: transaction, source: source)
     }
     |> castError(BotPaymentFormRequestError.self)
     |> mapToSignal { invoice -> Signal<BotPaymentForm, BotPaymentFormRequestError> in
@@ -354,15 +386,7 @@ extension BotPaymentShippingOption {
 
 func _internal_validateBotPaymentForm(account: Account, saveInfo: Bool, source: BotPaymentInvoiceSource, formInfo: BotPaymentRequestedInfo) -> Signal<BotPaymentValidatedFormInfo, ValidateBotPaymentFormError> {
     return account.postbox.transaction { transaction -> Api.InputInvoice? in
-        switch source {
-        case let .message(messageId):
-            guard let inputPeer = transaction.getPeer(messageId.peerId).flatMap(apiInputPeer) else {
-                return nil
-            }
-            return .inputInvoiceMessage(peer: inputPeer, msgId: messageId.id)
-        case let .slug(slug):
-            return .inputInvoiceSlug(slug: slug)
-        }
+        return _internal_parseInputInvoice(transaction: transaction, source: source)
     }
     |> castError(ValidateBotPaymentFormError.self)
     |> mapToSignal { invoice -> Signal<BotPaymentValidatedFormInfo, ValidateBotPaymentFormError> in
@@ -440,15 +464,7 @@ public enum SendBotPaymentResult {
 
 func _internal_sendBotPaymentForm(account: Account, formId: Int64, source: BotPaymentInvoiceSource, validatedInfoId: String?, shippingOptionId: String?, tipAmount: Int64?, credentials: BotPaymentCredentials) -> Signal<SendBotPaymentResult, SendBotPaymentFormError> {
     return account.postbox.transaction { transaction -> Api.InputInvoice? in
-        switch source {
-        case let .message(messageId):
-            guard let inputPeer = transaction.getPeer(messageId.peerId).flatMap(apiInputPeer) else {
-                return nil
-            }
-            return .inputInvoiceMessage(peer: inputPeer, msgId: messageId.id)
-        case let .slug(slug):
-            return .inputInvoiceSlug(slug: slug)
-        }
+        return _internal_parseInputInvoice(transaction: transaction, source: source)
     }
     |> castError(SendBotPaymentFormError.self)
     |> mapToSignal { invoice -> Signal<SendBotPaymentResult, SendBotPaymentFormError> in
@@ -510,6 +526,12 @@ func _internal_sendBotPaymentForm(account: Account, formId: Int64, source: BotPa
                                                     }
                                                 }
                                             }
+                                        case let .premiumGiveaway(_, _, _, _, randomId, _, _, _, _):
+                                            if message.globallyUniqueId == randomId {
+                                                if case let .Id(id) = message.id {
+                                                    receiptMessageId = id
+                                                }
+                                            }
                                         }
                                     }
                                 }

submodules/TelegramCore/Sources/TelegramEngine/Payments/GiftCodes.swift

@@ -20,18 +20,23 @@ public struct PremiumGiftCodeOption: Codable, Equatable {
         case months
         case storeProductId
         case storeQuantity
+        case currency
+        case amount
     }
     
     public let users: Int32
     public let months: Int32
     public let storeProductId: String?
     public let storeQuantity: Int32
-    
-    public init(users: Int32, months: Int32, storeProductId: String?, storeQuantity: Int32) {
+    public let currency: String
+    public let amount: Int64
+    public init(users: Int32, months: Int32, storeProductId: String?, storeQuantity: Int32, currency: String, amount: Int64) {
         self.users = users
         self.months = months
         self.storeProductId = storeProductId
         self.storeQuantity = storeQuantity
+        self.currency = currency
+        self.amount = amount
     }
     
     public init(from decoder: Decoder) throws {
@@ -40,6 +45,9 @@ public struct PremiumGiftCodeOption: Codable, Equatable {
         self.months = try container.decode(Int32.self, forKey: .months)
         self.storeProductId = try container.decodeIfPresent(String.self, forKey: .storeProductId)
         self.storeQuantity = try container.decodeIfPresent(Int32.self, forKey: .storeQuantity) ?? 1
+        self.currency = try container.decode(String.self, forKey: .currency)
+        self.amount = try container.decode(Int64.self, forKey: .amount)
+
     }
     
     public func encode(to encoder: Encoder) throws {
@@ -48,6 +56,8 @@ public struct PremiumGiftCodeOption: Codable, Equatable {
         try container.encode(self.months, forKey: .months)
         try container.encodeIfPresent(self.storeProductId, forKey: .storeProductId)
         try container.encode(self.storeQuantity, forKey: .storeQuantity)
+        try container.encode(self.currency, forKey: .currency)
+        try container.encode(self.amount, forKey: .amount)
     }
 }
 
@@ -234,8 +244,8 @@ func _internal_launchPrepaidGiveaway(account: Account, peerId: EnginePeer.Id, id
 extension PremiumGiftCodeOption {
     init(apiGiftCodeOption: Api.PremiumGiftCodeOption) {
         switch apiGiftCodeOption {
-        case let .premiumGiftCodeOption(_, users, months, storeProduct, storeQuantity, _, _):
-            self.init(users: users, months: months, storeProductId: storeProduct, storeQuantity: storeQuantity ?? 1)
+        case let .premiumGiftCodeOption(_, users, months, storeProduct, storeQuantity, curreny, amount):
+            self.init(users: users, months: months, storeProductId: storeProduct, storeQuantity: storeQuantity ?? 1, currency: curreny, amount: amount)
         }
     }
 }

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

@@ -505,6 +505,10 @@ public extension EnginePeer {
         }
         return false
     }
+    
+    var nameColor: PeerNameColor? {
+        return self._asPeer().nameColor
+    }
 }
 
 public extension EnginePeer {