Update version to 8.1.

CMakeLists.txt

@@ -6,7 +6,7 @@ if (POLICY CMP0065)
   cmake_policy(SET CMP0065 NEW)
 endif()
 
-project(TelegramBotApi VERSION 8.0 LANGUAGES CXX)
+project(TelegramBotApi VERSION 8.1 LANGUAGES CXX)
 
 if (POLICY CMP0069)
   option(TELEGRAM_BOT_API_ENABLE_LTO "Use \"ON\" to enable Link Time Optimization.")

td

@@ -1 +1 @@
-Subproject commit 66c4751742d2ca810033b289fc57ab4f83cfc833
+Subproject commit 7648b99d81d36d44bae3ca6c514a816a2fe8cfd1

telegram-bot-api/Client.cpp

@@ -4230,104 +4230,135 @@ class Client::JsonRevenueWithdrawalState final : public td::Jsonable {
   const td_api::RevenueWithdrawalState *state_;
 };
 
-class Client::JsonStarTransactionPartner final : public td::Jsonable {
+class Client::JsonAffiliateInfo final : public td::Jsonable {
  public:
-  JsonStarTransactionPartner(const td_api::StarTransactionPartner *source, const Client *client)
-      : source_(source), client_(client) {
+  JsonAffiliateInfo(const td_api::affiliateInfo *affiliate_info, const Client *client)
+      : affiliate_info_(affiliate_info), client_(client) {
   }
   void store(td::JsonValueScope *scope) const {
     auto object = scope->enter_object();
-    switch (source_->get_id()) {
-      case td_api::starTransactionPartnerFragment::ID: {
-        auto source_fragment = static_cast<const td_api::starTransactionPartnerFragment *>(source_);
-        object("type", "fragment");
-        if (source_fragment->withdrawal_state_ != nullptr) {
-          object("withdrawal_state", JsonRevenueWithdrawalState(source_fragment->withdrawal_state_.get()));
-        }
-        break;
-      }
-      case td_api::starTransactionPartnerBot::ID: {
-        auto source_user = static_cast<const td_api::starTransactionPartnerBot *>(source_);
-        object("type", "user");
-        object("user", JsonUser(source_user->user_id_, client_));
-        CHECK(source_user->purpose_ != nullptr);
-        switch (source_user->purpose_->get_id()) {
-          case td_api::botTransactionPurposeInvoicePayment::ID: {
-            auto purpose =
-                static_cast<const td_api::botTransactionPurposeInvoicePayment *>(source_user->purpose_.get());
-            if (!purpose->invoice_payload_.empty()) {
-              if (!td::check_utf8(purpose->invoice_payload_)) {
-                LOG(WARNING) << "Receive non-UTF-8 invoice payload";
-                object("invoice_payload", td::JsonRawString(purpose->invoice_payload_));
+    auto chat_info = client_->get_chat(affiliate_info_->affiliate_chat_id_);
+    CHECK(chat_info != nullptr);
+    if (chat_info->type == ChatInfo::Type::Private) {
+      object("affiliate_user", JsonUser(chat_info->user_id, client_));
     } else {
-                object("invoice_payload", purpose->invoice_payload_);
+      object("affiliate_chat", JsonChat(affiliate_info_->affiliate_chat_id_, client_));
     }
+    object("commission_per_mille", affiliate_info_->commission_per_mille_);
+    object("amount", affiliate_info_->star_amount_->star_count_);
+    if (affiliate_info_->star_amount_->nanostar_count_ != 0) {
+      object("nanostar_amount", affiliate_info_->star_amount_->nanostar_count_);
+    }
+  }
+
+ private:
+  const td_api::affiliateInfo *affiliate_info_;
+  const Client *client_;
+};
+
+class Client::JsonStarTransactionType final : public td::Jsonable {
+ public:
+  JsonStarTransactionType(const td_api::StarTransactionType *type, const Client *client)
+      : type_(type), client_(client) {
+  }
+
+  void store(td::JsonValueScope *scope) const {
+    auto object = scope->enter_object();
+    switch (type_->get_id()) {
+      case td_api::starTransactionTypeFragmentDeposit::ID:
+        object("type", "fragment");
+        break;
+      case td_api::starTransactionTypeFragmentWithdrawal::ID: {
+        auto type = static_cast<const td_api::starTransactionTypeFragmentWithdrawal *>(type_);
+        object("type", "fragment");
+        if (type->withdrawal_state_ != nullptr) {
+          object("withdrawal_state", JsonRevenueWithdrawalState(type->withdrawal_state_.get()));
         }
         break;
       }
-          case td_api::botTransactionPurposePaidMedia::ID: {
-            auto purpose = static_cast<const td_api::botTransactionPurposePaidMedia *>(source_user->purpose_.get());
-            object("paid_media", td::json_array(purpose->media_, [client = client_](auto &media) {
+      case td_api::starTransactionTypeBotPaidMediaSale::ID: {
+        auto type = static_cast<const td_api::starTransactionTypeBotPaidMediaSale *>(type_);
+        object("type", "user");
+        object("user", JsonUser(type->user_id_, client_));
+        object("paid_media", td::json_array(type->media_, [client = client_](auto &media) {
                  return JsonPaidMedia(media.get(), client);
                }));
-            if (!purpose->payload_.empty()) {
-              object("paid_media_payload", purpose->payload_);
+        if (!type->payload_.empty()) {
+          object("paid_media_payload", type->payload_);
+        }
+        if (type->affiliate_ != nullptr) {
+          object("affiliate", JsonAffiliateInfo(type->affiliate_.get(), client_));
         }
         break;
       }
-          case td_api::botTransactionPurposeSubscription::ID: {
-            auto purpose = static_cast<const td_api::botTransactionPurposeSubscription *>(source_user->purpose_.get());
-            if (!purpose->invoice_payload_.empty()) {
-              if (!td::check_utf8(purpose->invoice_payload_)) {
+      case td_api::starTransactionTypeBotInvoiceSale::ID: {
+        auto type = static_cast<const td_api::starTransactionTypeBotInvoiceSale *>(type_);
+        object("type", "user");
+        object("user", JsonUser(type->user_id_, client_));
+        if (!type->invoice_payload_.empty()) {
+          if (!td::check_utf8(type->invoice_payload_)) {
             LOG(WARNING) << "Receive non-UTF-8 invoice payload";
-                object("invoice_payload", td::JsonRawString(purpose->invoice_payload_));
+            object("invoice_payload", td::JsonRawString(type->invoice_payload_));
           } else {
-                object("invoice_payload", purpose->invoice_payload_);
+            object("invoice_payload", type->invoice_payload_);
           }
         }
-            if (purpose->period_ > 0) {
-              object("subscription_period", purpose->period_);
+        if (type->affiliate_ != nullptr) {
+          object("affiliate", JsonAffiliateInfo(type->affiliate_.get(), client_));
         }
         break;
       }
-          default:
-            UNREACHABLE();
+      case td_api::starTransactionTypeBotSubscriptionSale::ID: {
+        auto type = static_cast<const td_api::starTransactionTypeBotSubscriptionSale *>(type_);
+        object("type", "user");
+        object("user", JsonUser(type->user_id_, client_));
+        if (!type->invoice_payload_.empty()) {
+          if (!td::check_utf8(type->invoice_payload_)) {
+            LOG(WARNING) << "Receive non-UTF-8 invoice payload";
+            object("invoice_payload", td::JsonRawString(type->invoice_payload_));
+          } else {
+            object("invoice_payload", type->invoice_payload_);
+          }
+        }
+        if (type->subscription_period_ > 0) {
+          object("subscription_period", type->subscription_period_);
+        }
+        if (type->affiliate_ != nullptr) {
+          object("affiliate", JsonAffiliateInfo(type->affiliate_.get(), client_));
         }
         break;
       }
-      case td_api::starTransactionPartnerTelegramAds::ID:
+      case td_api::starTransactionTypeTelegramAdsWithdrawal::ID:
         object("type", "telegram_ads");
         break;
-      case td_api::starTransactionPartnerTelegramApi::ID: {
-        auto source = static_cast<const td_api::starTransactionPartnerTelegramApi *>(source_);
+      case td_api::starTransactionTypeTelegramApiUsage::ID: {
+        auto type = static_cast<const td_api::starTransactionTypeTelegramApiUsage *>(type_);
         object("type", "telegram_api");
-        object("request_count", source->request_count_);
+        object("request_count", type->request_count_);
         break;
       }
-      case td_api::starTransactionPartnerUser::ID: {
-        auto source = static_cast<const td_api::starTransactionPartnerUser *>(source_);
-        if (source->purpose_->get_id() == td_api::userTransactionPurposeGiftSend::ID) {
+      case td_api::starTransactionTypeGiftPurchase::ID: {
+        auto type = static_cast<const td_api::starTransactionTypeGiftPurchase *>(type_);
         object("type", "user");
-          object("user", JsonUser(source->user_id_, client_));
-          object(
-              "gift",
-              JsonGift(static_cast<const td_api::userTransactionPurposeGiftSend *>(source->purpose_.get())->gift_.get(),
-                       client_));
+        object("user", JsonUser(type->user_id_, client_));
+        object("gift", JsonGift(type->gift_.get(), client_));
+        break;
+      }
+      case td_api::starTransactionTypeAffiliateProgramCommission::ID: {
+        auto type = static_cast<const td_api::starTransactionTypeAffiliateProgramCommission *>(type_);
+        object("type", "affiliate_program");
+        auto chat_info = client_->get_chat(type->chat_id_);
+        CHECK(chat_info != nullptr);
+        if (chat_info->type == ChatInfo::Type::Private) {
+          object("sponsor_user", JsonUser(chat_info->user_id, client_));
         } else {
-          LOG(ERROR) << "Receive " << to_string(*source_);
-          object("type", "other");
+          LOG(ERROR) << "Receive chat " << type->chat_id_ << " as an affiliate program sponsor";
+          object("sponsor_chat", JsonChat(type->chat_id_, client_));
         }
+        object("commission_per_mille", type->commission_per_mille_);
         break;
       }
-      case td_api::starTransactionPartnerTelegram::ID:
-      case td_api::starTransactionPartnerAppStore::ID:
-      case td_api::starTransactionPartnerGooglePlay::ID:
-      case td_api::starTransactionPartnerBusiness::ID:
-      case td_api::starTransactionPartnerChat::ID:
-        LOG(ERROR) << "Receive " << to_string(*source_);
-        object("type", "other");
-        break;
-      case td_api::starTransactionPartnerUnsupported::ID:
+      case td_api::starTransactionTypeUnsupported::ID:
         object("type", "other");
         break;
       default:
@@ -4336,7 +4367,7 @@ class Client::JsonStarTransactionPartner final : public td::Jsonable {
   }
 
  private:
-  const td_api::StarTransactionPartner *source_;
+  const td_api::StarTransactionType *type_;
   const Client *client_;
 };
 
@@ -4349,12 +4380,18 @@ class Client::JsonStarTransaction final : public td::Jsonable {
     auto object = scope->enter_object();
     object("id", transaction_->id_);
     object("date", transaction_->date_);
-    if (transaction_->star_count_ > 0) {
-      object("amount", transaction_->star_count_);
-      object("source", JsonStarTransactionPartner(transaction_->partner_.get(), client_));
+    auto star_count = transaction_->star_amount_->star_count_;
+    auto nanostar_count = transaction_->star_amount_->nanostar_count_;
+    if (star_count > 0 || nanostar_count > 0) {
+      object("source", JsonStarTransactionType(transaction_->type_.get(), client_));
     } else {
-      object("amount", -transaction_->star_count_);
-      object("receiver", JsonStarTransactionPartner(transaction_->partner_.get(), client_));
+      star_count = -star_count;
+      nanostar_count = -nanostar_count;
+      object("receiver", JsonStarTransactionType(transaction_->type_.get(), client_));
+    }
+    object("amount", star_count);
+    if (nanostar_count != 0) {
+      object("nanostar_amount", nanostar_count);
     }
   }
 

telegram-bot-api/Client.h

@@ -204,7 +204,8 @@ class Client final : public WebhookActor::Callback {
   class JsonGiveawayCompleted;
   class JsonChatBoostAdded;
   class JsonRevenueWithdrawalState;
-  class JsonStarTransactionPartner;
+  class JsonAffiliateInfo;
+  class JsonStarTransactionType;
   class JsonStarTransaction;
   class JsonStarTransactions;
   class JsonUpdateTypes;

telegram-bot-api/telegram-bot-api.cpp

@@ -165,7 +165,7 @@ int main(int argc, char *argv[]) {
   auto start_time = td::Time::now();
   auto shared_data = std::make_shared<SharedData>();
   auto parameters = std::make_unique<ClientParameters>();
-  parameters->version_ = "8.0";
+  parameters->version_ = "8.1";
   parameters->shared_data_ = shared_data;
   parameters->start_time_ = start_time;
   auto net_query_stats = td::create_net_query_stats();