Merge f1646e0b0fe58c67086cb6e951cd192ea83ffe74 into 65bcaaa5725f15f9b4e03bb47f1d41c36c756633

Update version to 8.1.
Add nanostar_amount to StarTransaction.
2025-08-22 01:49:24 +00:00 · 2024-12-05 11:53:00 +05:00 · 2024-12-02 00:56:55 +03:00 · 2024-12-01 11:52:45 +03:00 · 2024-12-01 11:50:32 +03:00 · 2024-12-01 11:46:45 +03:00
6 changed files with 127 additions and 88 deletions
--- a/CMakeLists.txt
+++ b/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.")
--- a/build.html
+++ b/build.html
@ -3,6 +3,7 @@

 <head>
  <title>Telegram Bot API server build instructions</title>
+  <link rel="icon" type="image/svg+xml" sizes="16x16|any" href="https://telegram.org/img/t_logo.svg"/>
  <style>
    :root {
      --background: #fafafa;
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 66c4751742d2ca810033b289fc57ab4f83cfc833
+Subproject commit 7648b99d81d36d44bae3ca6c514a816a2fe8cfd1
--- a/telegram-bot-api/Client.cpp
+++ b/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);
    }
  }

--- a/telegram-bot-api/Client.h
+++ b/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;
--- a/telegram-bot-api/telegram-bot-api.cpp
+++ b/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();
Author	SHA1	Message	Date
Serjan Nasredin	73de846fc9	Merge f1646e0b0fe58c67086cb6e951cd192ea83ffe74 into 65bcaaa5725f15f9b4e03bb47f1d41c36c756633	2024-12-05 11:53:00 +05:00
levlam	65bcaaa572	Update version to 8.1.	2024-12-02 00:56:55 +03:00
levlam	dfe62e6ccd	Add nanostar_amount to StarTransaction.	2024-12-01 11:52:45 +03:00
levlam	9707d8486b	Add "affiliate_program" Star transaction type.	2024-12-01 11:50:32 +03:00
levlam	cc2c3678a9	Add affiliate info to relevant Star transactions.	2024-12-01 11:46:45 +03:00
levlam	26f945f2b0	Update TDLib to 1.8.41.	2024-12-01 00:34:48 +03:00
snxx-lppxx	f1646e0b0f	Add Telegram's favicon	2022-01-27 18:45:16 +05:00