C++ SDK

include(FetchContent)
FetchContent_Declare(
  authforge_cpp
  GIT_REPOSITORY https://github.com/AuthForgeCC/authforge-cpp.git
  GIT_TAG v1.4.0
)
FetchContent_MakeAvailable(authforge_cpp)

target_link_libraries(your_app PRIVATE authforge_sdk)

git clone https://github.com/AuthForgeCC/authforge-cpp.git
cd authforge-cpp
cmake -S . -B build -DCMAKE_INSTALL_PREFIX=../authforge-install
cmake --build build
cmake --install build

list(APPEND CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../authforge-install")
find_package(AuthForge CONFIG REQUIRED)
target_link_libraries(your_app PRIVATE AuthForge::authforge_sdk)

#include "authforge_sdk.h"
#include <iostream>
#include <string>

int main() {
    authforge::AuthForgeClient client(
        "YOUR_APP_ID",
        "YOUR_APP_SECRET",
        "YOUR_PUBLIC_KEY"
    );

    std::string key;
    std::cout << "Enter license key: ";
    std::getline(std::cin, key);

    if (client.Login(key)) {
        std::cout << "Authenticated!" << std::endl;
        // Your app logic here; the signed session covers the grace period
    } else {
        std::cout << "Invalid license key." << std::endl;
        return 1;
    }

    return 0;
}

authforge::AuthForgeClient client(
    "app_id",                       // Required; from dashboard
    "app_secret",                   // Required for online Login/ValidateLicense; pass "" for LoginFromFile only
    "public_key",                   // Required; Ed25519 public key (base64)
    authforge::OnlineHeartbeat::Off,// Optional; ::On enables periodic online check-ins (/auth/heartbeat)
    900,                            // Optional; background timer cadence (check-ins when online, local session checks otherwise)
    "https://auth.authforge.cc",    // Optional; API base URL
    on_failure_callback,            // Optional; void(const std::string& reason, const std::exception* ex)
    15,                             // Optional; HTTP timeout in seconds
    0,                              // Optional; ttlSeconds: grace period (session TTL). 0 = server default (24h). Clamped to [3600, 604800].
    ""                              // Optional; hwidOverride: custom identity (for example "tg:123456789")
);

bool success = client.Login(license_key);

authforge::ValidateLicenseResult r = client.ValidateLicense(license_key);
if (r.valid) {
  // r.sessionToken, r.expiresIn, r.sessionDataJson, r.appVariablesJson, r.licenseVariablesJson
} else {
  // r.errorCode; e.g. invalid_key (the server's code, also on non-2xx responses), nonce_mismatch
}

#include "authforge_sdk.h"
#include <atomic>
#include <iostream>

std::atomic<bool> g_licenseLost{false};

void on_failure(const std::string& reason, const std::exception* ex) {
    const auto* af = dynamic_cast<const authforge::AuthForgeError*>(ex);
    if (reason == "heartbeat_failed" && af && af->isTransient()) {
        std::cerr << "AuthForge check-in failed (" << af->code() << "), retrying" << std::endl;
        return; // session kept; check-ins continue at the next interval
    }
    std::cerr << "Auth failed: " << reason << std::endl;
    if (ex) {
        std::cerr << "  Detail: " << ex->what() << std::endl;
    }
    // Runs on the heartbeat thread: signal the main thread instead of exiting here.
    g_licenseLost = true;
}

int main() {
    authforge::AuthForgeClient client(
        "YOUR_APP_ID",
        "YOUR_APP_SECRET",
        "YOUR_PUBLIC_KEY",
        authforge::OnlineHeartbeat::On,
        900,
        "https://auth.authforge.cc",
        on_failure
    );

    if (!client.Login(licenseKey)) {
        return 1;
    }

    while (!g_licenseLost) {
        do_one_unit_of_work(); // keep units short so the loop notices the signal quickly
    }

    save_application_state();
    client.Logout();
    return 1;
}

// Default: activate online, then run through the grace period (24h by default)
authforge::AuthForgeClient client("...", "...", "...");

// Strict policy: periodic online check-ins for fast revocation
authforge::AuthForgeClient strict_client("...", "...", "...", authforge::OnlineHeartbeat::On);

authforge::AuthForgeClient client("APP_ID", "", "PUBLIC_KEY");

// Step 1 (customer machine): write an activation request the operator drops into the mint dialog.
std::string request = client.CreateActivationRequest();

// Step 2 (customer machine, after you deliver the file): path or armored text.
if (client.LoginFromFile("license.authforge")) {
  const auto info = client.GetOfflineLicense();
  std::cout << "Offline license valid until " << (info->expiresAt ? *info->expiresAt : "forever") << "\n";
}

#include "authforge_sdk.h"
#include <iostream>
#include <string>
#include <atomic>

std::atomic<bool> g_licensed{false};

void on_auth_failure(const std::string& reason, const std::exception* ex) {
    std::cerr << "[AuthForge] " << reason;
    if (ex) std::cerr << ": " << ex->what();
    std::cerr << std::endl;

    const auto* af = dynamic_cast<const authforge::AuthForgeError*>(ex);
    if (reason == "heartbeat_failed" && af && af->isTransient()) {
        return; // session kept; the SDK checks in again at the next interval
    }
    g_licensed.store(false);
    // Don't exit here; let the game loop handle shutdown gracefully
}

int main() {
    authforge::AuthForgeClient client(
        "YOUR_APP_ID",
        "YOUR_APP_SECRET",
        "YOUR_PUBLIC_KEY",
        authforge::OnlineHeartbeat::On,  // Strict policy: check in every 15 minutes
        900,
        "https://auth.authforge.cc",
        on_auth_failure
    );

    std::string key;
    std::cout << "Enter license key: ";
    std::getline(std::cin, key);

    if (!client.Login(key)) {
        std::cerr << "Invalid license key." << std::endl;
        return 1;
    }

    g_licensed.store(true);
    std::cout << "Licensed. Starting game..." << std::endl;

    // Game loop
    while (g_licensed.load()) {
        // Update game state
        // Render frame
        // If g_licensed becomes false, show "license expired" dialog
    }

    std::cout << "License expired. Shutting down." << std::endl;
    return 0;
}