C++

include(FetchContent)FetchContent_Declare(keygrant  GIT_REPOSITORY https://github.com/keygrantdev/keygrant-cpp.git  GIT_TAG        0.8.0)FetchContent_MakeAvailable(keygrant)
target_link_libraries(my_app PRIVATE keygrant::keygrant)

find_package(keygrant 0.8 REQUIRED)target_link_libraries(my_app PRIVATE keygrant::keygrant)

#include <keygrant/keygrant.hpp>
keygrant::LicenseConfig config;config.product = "my-product";config.apiBaseUrl = "https://api.keygrant.dev";config.publicJwk = R"({"keys":[...]})"; // the keys from /pubkeyconfig.major = 2;
keygrant::License license(config); // throws std::invalid_argument on a bad config
keygrant::LicenseStatus status = license.status();if (status.state != keygrant::LicenseState::Licensed &&    status.state != keygrant::LicenseState::Trial &&    status.state != keygrant::LicenseState::Unknown) {  keygrant::ActivateResult result = license.activate(enteredKey);  if (!result.ok) showError(keygrant::to_string(*result.error)); // "invalid-key", "limit", ...}

keygrant::ActivateOptions options;options.email = emailField.text();options.code = codeField.text();const keygrant::ActivateResult result = license.activate(key, options);if (!result.ok) {  switch (*result.error) {    case keygrant::ActivateError::UserEmailRequired:    case keygrant::ActivateError::UserEmailMismatch: askForTheAddress(); break;  // then activate again with it    case keygrant::ActivateError::UserCodeRequired:    case keygrant::ActivateError::UserCodeInvalid: askForTheCode(); break;       // a code was just mailed to it    case keygrant::ActivateError::TooManyCodes:    case keygrant::ActivateError::TooManyAttempts: askToTryLater(); break;    case keygrant::ActivateError::TryAgain: askToRetry(); break;                  // nothing was activated    default: showTheOtherErrors(); break;  }}

// 1. Email a code to the address the key was sold to (the answer is the same either way).license.pickUp(email);
// 2. The customer types the code: restore.const keygrant::RestoreResult restored = license.restoreByEmail(email, code);if (!restored.ok) {  if (restored.pickupError == keygrant::PickupError::WrongCode) askAgain();  if (restored.pickupError == keygrant::PickupError::CodeExpired) license.pickUp(email);  // a new code  if (restored.noKey) showNoKeyUnderThatAddress();}

config.revokedLicenseFiles = {"lf_8Hq2"};   // ids of files that leaked: an update adds them here

#include <keygrant/keygrant.hpp>#include <QDragEnterEvent>#include <QDropEvent>#include <QFile>#include <QFileDialog>#include <QFileInfo>#include <QFutureWatcher>#include <QMimeData>#include <QtConcurrent>
namespace {/// The first dropped local file that is a license file (`keygrant::kLicenseFileExtension`), else an empty string.QString licenseFileIn(const QMimeData* mime) {  for (const QUrl& url : mime->urls()) {    if (url.isLocalFile() && url.toLocalFile().endsWith(QStringLiteral(".kglicense"), Qt::CaseInsensitive))      return url.toLocalFile();  }  return {};}
/// Reads the file, never more than a license file can be (a larger one is refused unread), and imports it.keygrant::ImportLicenseFileResult importFile(keygrant::License& license, const QString& path) {  QFile file(path);  if (!file.open(QIODevice::ReadOnly)) throw std::runtime_error("the file cannot be opened");  const QByteArray read = file.read(static_cast<qint64>(keygrant::kMaxLicenseFileBytes) + 1);  return license.importLicenseFile(std::vector<std::uint8_t>(read.begin(), read.end()));}}  // namespace
// In the window's constructor: setAcceptDrops(true);void LicenseWindow::dragEnterEvent(QDragEnterEvent* event) {  if (!licenseFileIn(event->mimeData()).isEmpty()) event->acceptProposedAction();}
void LicenseWindow::dropEvent(QDropEvent* event) {  const QString path = licenseFileIn(event->mimeData());  if (path.isEmpty()) return;  event->acceptProposedAction();  importFrom(path);}
void LicenseWindow::openLicenseFile() {   // "Open license file..." on the license screen  const QString path = QFileDialog::getOpenFileName(this, tr("Open license file"), {},                                                    tr("License files (*.kglicense)"));  if (!path.isEmpty()) importFrom(path);}
void LicenseWindow::importFrom(const QString& path) {  auto* watcher = new QFutureWatcher<keygrant::ImportLicenseFileResult>(this);  connect(watcher, &QFutureWatcherBase::finished, this, [this, watcher] {    try {      const keygrant::ImportLicenseFileResult result = watcher->result();      if (result.ok) showLicensedTo(*result.licensedTo);                        // "Licensed to Ada Lovelace"      else if (result.error) showError(keygrant::to_string(*result.error));     // "revoked-file", "upgrade", ...      else showError(keygrant::to_string(*result.activateError));               // a key file: what activate() says    } catch (const std::exception&) {      showError("try-again");   // unreadable, a call before it has not finished, or the state not saved    }    watcher->deleteLater();  });  // Read and imported off the UI thread (a file on a network share can be slow); license_ is a  // std::shared_ptr<keygrant::License>, held by the work.  watcher->setFuture(QtConcurrent::run([license = license_, path] { return importFile(*license, path); }));}

const keygrant::UseResult spent = license.use("exports");   // use("exports", 40) spends forty at once, whole or noneif (spent.ok) {  runExport();   // spent.left: what is left now, net of this device's unsynced spends} else {  switch (*spent.error) {    // The server's word: fewer left than asked (spent.left says how many; nullopt when it gave no number).    case keygrant::UseError::UsedUp: offerMoreExports(spent.left); break;    // KeyGrant could not be reached, and this is past what this device may spend without it.    case keygrant::UseError::OfflineLimit: askToConnect(); break;    // NoMeter, NotLicensed, Revoked, Device, Upgrade, Outdated, Storage, InvalidAmount.    default: showMeterProblem(*spent.error); break;  }}
const keygrant::LicenseStatus status = license.status();   // offline, from the leasestatus.meters.at("exports");   // MeterStatus{left 950, total 1000, offline 100, unsynced 0, resets false}

// The Buy button, while the app holds no key.openInBrowser("https://buy.stripe.com/your-payment-link");
// The customer types the key from the delivery email:if (license.activate(enteredKey).ok) showThanks();

#ifdef _WIN32config.adapters.registry = std::make_shared<keygrant::WindowsRegistryStash>("my-product");#endif