Add support for BAP reporting endpoint (uplift to 1.21.x)

components/brave_rewards/browser/rewards_service.cc

@@ -92,6 +92,7 @@ void RewardsService::RegisterProfilePrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kParametersMonthlyTipChoices, "");
   registry->RegisterBooleanPref(prefs::kFetchOldBalance, true);
   registry->RegisterBooleanPref(prefs::kEmptyBalanceChecked, false);
+  registry->RegisterBooleanPref(prefs::kBAPReported, false);
   registry->RegisterStringPref(prefs::kWalletBrave, "");
   registry->RegisterStringPref(prefs::kWalletUphold, "");
 }

components/brave_rewards/browser/rewards_service_impl.cc

@@ -1503,6 +1503,9 @@ bool RewardsServiceImpl::GetBooleanOption(const std::string& name) const {
     return false;
   }
 
+  if (name == ledger::option::kShouldReportBAPAmount)
+    return OnlyAnonWallet();
+
   const auto it = kBoolOptions.find(name);
   DCHECK(it != kBoolOptions.end());
 

components/brave_rewards/browser/test/common/rewards_browsertest_response.cc

@@ -258,6 +258,12 @@ void RewardsBrowserTestResponse::Get(
     return;
   }
 
+  if (url.find("/v1/promotions/report-bap") != std::string::npos) {
+    *response = "";
+    *response_status_code = net::HTTP_OK;
+    return;
+  }
+
   if (url.find("/v1/captchas") != std::string::npos) {
     *response = captcha_;
   }

components/brave_rewards/browser/test/rewards_browsertest.cc

@@ -22,6 +22,7 @@
 #include "brave/components/brave_rewards/browser/test/common/rewards_browsertest_promotion.h"
 #include "brave/components/brave_rewards/browser/test/common/rewards_browsertest_response.h"
 #include "brave/components/brave_rewards/browser/test/common/rewards_browsertest_util.h"
+#include "brave/components/brave_rewards/common/pref_names.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/testing_profile.h"
@@ -522,4 +523,36 @@ IN_PROC_BROWSER_TEST_F(RewardsBrowserTest, BAPPopup) {
   EXPECT_TRUE(popup_shown);
 }
 
+IN_PROC_BROWSER_TEST_F(RewardsBrowserTest, BAPReporting) {
+  rewards_browsertest_util::StartProcess(rewards_service_);
+  rewards_browsertest_util::CreateWallet(rewards_service_);
+  rewards_service_->FetchPromotions();
+  promotion_->WaitForPromotionInitialization();
+  promotion_->ClaimPromotionViaCode();
+
+  rewards_browsertest_util::WaitForLedgerStop(rewards_service_);
+
+  rewards_browsertest_util::StartProcess(rewards_service_);
+  auto* prefs = browser()->profile()->GetPrefs();
+  rewards_browsertest_util::WaitForLedgerStop(rewards_service_);
+
+  EXPECT_FALSE(prefs->GetBoolean(brave_rewards::prefs::kBAPReported));
+
+  prefs->SetInteger(country_codes::kCountryIDAtInstall, 19024);
+
+  base::RunLoop run_loop;
+  PrefChangeRegistrar prefs_listener;
+  prefs_listener.Init(browser()->profile()->GetPrefs());
+  prefs_listener.Add(brave_rewards::prefs::kBAPReported,
+                     base::BindLambdaForTesting(
+                         [&run_loop](const std::string&) { run_loop.Quit(); }));
+
+  // Start the ledger process and wait for pref to be set, indicating that the
+  // reporting completed successfully.
+  rewards_browsertest_util::StartProcess(rewards_service_);
+  run_loop.Run();
+
+  EXPECT_TRUE(prefs->GetBoolean(brave_rewards::prefs::kBAPReported));
+}
+
 }  // namespace rewards_browsertest

components/brave_rewards/common/pref_names.cc

@@ -64,6 +64,7 @@ const char kFetchOldBalance[] =
     "brave.rewards.fetch_old_balance";
 const char kEmptyBalanceChecked[] =
     "brave.rewards.empty_balance_checked";
+const char kBAPReported[] = "brave.rewards.bap_reported";
 const char kWalletBrave[] =
     "brave.rewards.wallets.brave";
 const char kWalletUphold[] =

components/brave_rewards/common/pref_names.h

@@ -52,6 +52,7 @@ extern const char kParametersTipChoices[];
 extern const char kParametersMonthlyTipChoices[];
 extern const char kFetchOldBalance[];
 extern const char kEmptyBalanceChecked[];
+extern const char kBAPReported[];
 extern const char kWalletBrave[];
 extern const char kWalletUphold[];
 

vendor/bat-native-ledger/BUILD.gn

@@ -258,6 +258,10 @@ source_set("ledger") {
     "src/bat/ledger/internal/logging/logging_util.h",
     "src/bat/ledger/internal/logging/logging.cc",
     "src/bat/ledger/internal/logging/logging.h",
+    "src/bat/ledger/internal/promotion/bap_reporter.cc",
+    "src/bat/ledger/internal/promotion/bap_reporter.h",
+    "src/bat/ledger/internal/promotion/bap_reporter_endpoint.cc",
+    "src/bat/ledger/internal/promotion/bap_reporter_endpoint.h",
     "src/bat/ledger/internal/promotion/promotion.cc",
     "src/bat/ledger/internal/promotion/promotion.h",
     "src/bat/ledger/internal/promotion/promotion_transfer.cc",

vendor/bat-native-ledger/include/bat/ledger/option_keys.h

@@ -3,8 +3,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef BRAVELEDGER_OPTION_KEYS_H_
-#define BRAVELEDGER_OPTION_KEYS_H_
+#ifndef BRAVE_VENDOR_BAT_NATIVE_LEDGER_INCLUDE_BAT_LEDGER_OPTION_KEYS_H_
+#define BRAVE_VENDOR_BAT_NATIVE_LEDGER_INCLUDE_BAT_LEDGER_OPTION_KEYS_H_
 
 #include <string>
 
@@ -15,8 +15,9 @@ const char kPublisherListRefreshInterval[] = "publisher_list_refresh_interval";
 const char kClaimUGP[] = "claim_ugp";
 const char kContributionsDisabledForBAPMigration[] =
     "contributions_disabled_for_bap_migration";
+const char kShouldReportBAPAmount[] = "should_report_bap";
 
 }  // namespace option
 }  // namespace ledger
 
-#endif  // BRAVELEDGER_OPTION_KEYS_H_
+#endif  // BRAVE_VENDOR_BAT_NATIVE_LEDGER_INCLUDE_BAT_LEDGER_OPTION_KEYS_H_

vendor/bat-native-ledger/src/bat/ledger/internal/promotion/bap_reporter.cc

@@ -0,0 +1,115 @@
+/* Copyright (c) 2021 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "bat/ledger/internal/promotion/bap_reporter.h"
+
+#include "base/time/time.h"
+#include "bat/ledger/global_constants.h"
+#include "bat/ledger/internal/common/time_util.h"
+#include "bat/ledger/internal/ledger_impl.h"
+#include "bat/ledger/option_keys.h"
+
+using std::placeholders::_1;
+using std::placeholders::_2;
+
+namespace ledger {
+namespace promotion {
+
+namespace {
+
+constexpr int64_t kRetryDelay = 24 * base::Time::kSecondsPerHour;
+constexpr int64_t kRetryAfterFailureDelay = 10 * base::Time::kSecondsPerMinute;
+constexpr int64_t kMaxRetryAfterFailureDelay = 4 * base::Time::kSecondsPerHour;
+
+}  // namespace
+
+BAPReporter::BAPReporter(LedgerImpl* ledger)
+    : ledger_(ledger), endpoint_(ledger) {
+  DCHECK(ledger);
+}
+
+BAPReporter::~BAPReporter() = default;
+
+void BAPReporter::ReportBAPAmount() {
+  if (running_)
+    return;
+
+  timer_.Stop();
+
+  bool should_report = ledger_->ledger_client()->GetBooleanOption(
+      option::kShouldReportBAPAmount);
+
+  // Only run this reporter if the user is in a BAP region and we haven't
+  // successfully reported yet.
+  if (!should_report || ledger_->state()->GetBAPReported())
+    return;
+
+  running_ = true;
+
+  // First, get the user's unspent BAP tokens.
+  ledger_->database()->GetSpendableUnblindedTokensByBatchTypes(
+      {type::CredsBatchType::PROMOTION},
+      std::bind(&BAPReporter::OnUnblindedTokens, this, _1));
+}
+
+void BAPReporter::OnUnblindedTokens(
+    std::vector<type::UnblindedTokenPtr> tokens) {
+  double amount = 0;
+  for (const auto& token : tokens)
+    amount += token->value;
+
+  // If the user has no BAP, then schedule a retry and exit.
+  if (amount <= 0) {
+    ScheduleRetryAfterZeroBalance();
+    return;
+  }
+
+  // Send the amount to the server.
+  endpoint_.Request(amount,
+                    std::bind(&BAPReporter::OnEndpointResponse, this, _1));
+}
+
+void BAPReporter::OnEndpointResponse(bool success) {
+  // If the server reported an error, assume a temporary problem and try again
+  // later.
+  if (!success) {
+    ScheduleRetryAfterFailure();
+    return;
+  }
+
+  BLOG(1, "BAP successsfully reported");
+
+  // Set a flag to indicate that we don't need to report again.
+  ledger_->state()->SetBAPReported(true);
+  running_ = false;
+  retry_count_ = 0;
+}
+
+void BAPReporter::ScheduleRetryAfterZeroBalance() {
+  running_ = false;
+
+  base::TimeDelta delay = base::TimeDelta::FromSeconds(kRetryDelay);
+
+  BLOG(1, "User has zero balance - rescheduling BAP reporting in " << delay);
+  timer_.Start(
+      FROM_HERE, delay,
+      base::BindOnce(&BAPReporter::ReportBAPAmount, base::Unretained(this)));
+}
+
+void BAPReporter::ScheduleRetryAfterFailure() {
+  running_ = false;
+
+  base::TimeDelta delay = util::GetRandomizedDelayWithBackoff(
+      base::TimeDelta::FromSeconds(kRetryAfterFailureDelay),
+      base::TimeDelta::FromSeconds(kMaxRetryAfterFailureDelay), retry_count_++);
+
+  BLOG(1, "BAP reporting failed - rescheduling in " << delay);
+  timer_.Start(
+      FROM_HERE, delay,
+      base::BindOnce(&BAPReporter::ReportBAPAmount, base::Unretained(this)));
+}
+
+}  // namespace promotion
+}  // namespace ledger

vendor/bat-native-ledger/src/bat/ledger/internal/promotion/bap_reporter.h

@@ -0,0 +1,49 @@
+/* Copyright (c) 2021 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef BRAVE_VENDOR_BAT_NATIVE_LEDGER_SRC_BAT_LEDGER_INTERNAL_PROMOTION_BAP_REPORTER_H_
+#define BRAVE_VENDOR_BAT_NATIVE_LEDGER_SRC_BAT_LEDGER_INTERNAL_PROMOTION_BAP_REPORTER_H_
+
+#include <functional>
+#include <vector>
+
+#include "base/timer/timer.h"
+#include "bat/ledger/internal/promotion/bap_reporter_endpoint.h"
+#include "bat/ledger/ledger.h"
+
+namespace ledger {
+
+class LedgerImpl;
+
+namespace promotion {
+
+class BAPReporter {
+ public:
+  explicit BAPReporter(LedgerImpl* ledger);
+
+  BAPReporter(const BAPReporter&) = delete;
+  BAPReporter& operator=(const BAPReporter&) = delete;
+
+  ~BAPReporter();
+
+  void ReportBAPAmount();
+
+ private:
+  void OnUnblindedTokens(std::vector<type::UnblindedTokenPtr> tokens);
+  void OnEndpointResponse(bool success);
+  void ScheduleRetryAfterZeroBalance();
+  void ScheduleRetryAfterFailure();
+
+  LedgerImpl* ledger_;
+  bool running_ = false;
+  int retry_count_ = 0;
+  base::OneShotTimer timer_;
+  BAPReporterEndpoint endpoint_;
+};
+
+}  // namespace promotion
+}  // namespace ledger
+
+#endif  // BRAVE_VENDOR_BAT_NATIVE_LEDGER_SRC_BAT_LEDGER_INTERNAL_PROMOTION_BAP_REPORTER_H_

vendor/bat-native-ledger/src/bat/ledger/internal/promotion/bap_reporter_endpoint.cc

@@ -0,0 +1,92 @@
+/* Copyright (c) 2021 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "bat/ledger/internal/promotion/bap_reporter_endpoint.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/json/json_writer.h"
+#include "bat/ledger/internal/common/request_util.h"
+#include "bat/ledger/internal/endpoint/promotion/promotions_util.h"
+#include "bat/ledger/internal/ledger_impl.h"
+#include "net/http/http_status_code.h"
+
+using std::placeholders::_1;
+
+namespace ledger {
+namespace promotion {
+
+namespace {
+
+const char kEndpointPath[] = "/v1/promotions/report-bap";
+
+}  // namespace
+
+BAPReporterEndpoint::BAPReporterEndpoint(LedgerImpl* ledger) : ledger_(ledger) {
+  DCHECK(ledger_);
+}
+
+BAPReporterEndpoint::~BAPReporterEndpoint() = default;
+
+void BAPReporterEndpoint::Request(double amount, Callback callback) {
+  const auto wallet = ledger_->wallet()->GetWallet();
+  if (!wallet) {
+    BLOG(0, "Wallet is null");
+    callback(false);
+    return;
+  }
+
+  base::Value body(base::Value::Type::DICTIONARY);
+  body.SetDoubleKey("amount", amount);
+  std::string payload;
+  base::JSONWriter::Write(body, &payload);
+
+  const std::string sign_url = std::string("post ") + kEndpointPath;
+  auto headers = util::BuildSignHeaders(sign_url, payload, wallet->payment_id,
+                                        wallet->recovery_seed);
+
+  auto request = type::UrlRequest::New();
+  request->url = endpoint::promotion::GetServerUrl(kEndpointPath);
+  request->headers = std::move(headers);
+  request->content = std::move(payload);
+  request->content_type = "application/json; charset=utf-8";
+  request->method = type::UrlMethod::POST;
+  ledger_->LoadURL(
+      std::move(request),
+      std::bind(&BAPReporterEndpoint::OnFetchCompleted, this, callback, _1));
+}
+
+void BAPReporterEndpoint::OnFetchCompleted(Callback callback,
+                                           const type::UrlResponse& response) {
+  ledger::LogUrlResponse(__func__, response);
+
+  bool success = false;
+  switch (response.status_code) {
+    case net::HTTP_BAD_REQUEST: {
+      BLOG(0, "Invalid request");
+      break;
+    }
+    case net::HTTP_INTERNAL_SERVER_ERROR: {
+      BLOG(0, "Internal server error");
+      break;
+    }
+    case net::HTTP_OK:
+    case net::HTTP_CONFLICT: {
+      success = true;
+      break;
+    }
+    default: {
+      BLOG(0, "Unexpected reponse code " << response.status_code);
+      break;
+    }
+  }
+
+  callback(success);
+}
+
+}  // namespace promotion
+}  // namespace ledger