Rust

cargo add keygrant

use keygrant::{License, LicenseConfig};
let license = License::new(    LicenseConfig::new("my-product", "https://api.keygrant.dev", PUBLIC_KEYS).major(2),)?;
let status = license.status(false);if !status.permits_use() {    if let Err(error) = license.activate(&entered_key) {        show_error(error.code()); // "invalid-key", "limit", ...    }}

use keygrant::{ActivateOptions, LicenseError};
let options = ActivateOptions::new().email(&entered_email).code(&entered_code);if let Err(error) = license.activate_with(&entered_key, &options) {    match error.license_error() {        // Ask for the address, then activate again with it.        Some(LicenseError::UserEmailRequired | LicenseError::UserEmailMismatch) => {}        // A code was just mailed to the address: ask for it.        Some(LicenseError::UserCodeRequired | LicenseError::UserCodeInvalid) => {}        Some(LicenseError::TooManyCodes | LicenseError::TooManyAttempts) => {}        Some(LicenseError::TryAgain) => {}        _ => {}    }}

// 1. Email a code to the address the key was sold to (the answer is the same either way).license.pick_up(&email)?;
// 2. The customer types the code: restore.match license.restore_by_email(&email, &code) {    Ok(()) => { /* licensed: read status() */ }    Err(error) => match error.code() {        "wrong-code" => { /* ask again */ }        "code-expired" => { /* license.pick_up(&email) for a new code */ }        "too-many-attempts" | "try-again" => { /* wait error.retry_after() seconds */ }        "no-key" => { /* no key under that address */ }        _ => {}    },}

use std::sync::Arc;
use std::io::Read;use std::path::Path;
use keygrant::license_file::MAX_LICENSE_FILE_BYTES;use keygrant::{ImportedLicenseFile, License, LicenseConfig, LICENSE_FILE_EXTENSION};use tauri::{DragDropEvent, Emitter, WindowEvent};
const PUBLIC_KEYS: &str = include_str!("../keygrant-keys.json");
// The front end hands over a file's bytes: from a drop on a web view, or an// <input type="file" accept=".kglicense">, as Array.from(new Uint8Array(await file.arrayBuffer())).#[tauri::command]async fn import_license_file(    license: tauri::State<'_, Arc<License>>,    bytes: Vec<u8>,) -> Result<ImportedLicenseFile, String> {    let license = Arc::clone(&license);    tauri::async_runtime::spawn_blocking(move || license.import_license_file(bytes))        .await        .map_err(|e| e.to_string())?        // "malformed", "not-a-license-file", "bad-signature", "unknown-key",        // "wrong-product", "revoked-file", "upgrade", "outdated"; for a key file        // what activate() answers; "storage" or "busy": try again.        .map_err(|e| e.code().to_owned())}
/// A file's first `limit` bytes at most.fn read_at_most(path: &Path, limit: usize) -> std::io::Result<Vec<u8>> {    let mut bytes = Vec::new();    std::fs::File::open(path)?.take(limit as u64).read_to_end(&mut bytes)?;    Ok(bytes)}
fn main() {    let license = Arc::new(        License::new(            LicenseConfig::new("sluice", "https://api.keygrant.dev", PUBLIC_KEYS)                .major(3)                // Ids of files that leaked: an update adds them here.                .revoked_license_files(["lf_8Hq2"]),        )        .expect("the license configuration is the developer's to fix"),    );    let on_drop = Arc::clone(&license);    tauri::Builder::default()        .manage(license)        .invoke_handler(tauri::generate_handler![import_license_file])        .on_window_event(move |window, event| {            // A file dropped on the window, read here: the SDK takes content, never a path.            if let WindowEvent::DragDrop(DragDropEvent::Drop { paths, .. }) = event {                let dropped = paths.iter().find(|path| {                    path.extension().and_then(|e| e.to_str()).is_some_and(|e| {                        e.eq_ignore_ascii_case(LICENSE_FILE_EXTENSION.trim_start_matches('.'))                    })                });                if let Some(path) = dropped.cloned() {                    let license = Arc::clone(&on_drop);                    let window = window.clone();                    tauri::async_runtime::spawn_blocking(move || {                        // Never more than a license file can be: a larger one is refused unread.                        let imported = read_at_most(&path, MAX_LICENSE_FILE_BYTES + 1)                            .map_err(|e| e.to_string())                            .and_then(|bytes| {                                license.import_license_file(bytes).map_err(|e| e.code().to_owned())                            });                        let _ = window.emit("license-file", imported);                    });                }            }        })        .run(tauri::generate_context!())        .expect("error while running the app");}

use keygrant::UseError;
let spent = license.use_meter("exports", 1); // use_meter("exports", 40) spends forty at once, whole or noneif spent.ok {    run_export(); // spent.left: what is left now, net of this device's unsynced spends} else {    match spent.error {        // The server's word: fewer left than asked (spent.left says how many, when it gave a number).        Some(UseError::UsedUp) => offer_more_exports(spent.left),        // KeyGrant could not be reached, and this is past what this device may spend without it.        Some(UseError::OfflineLimit) => ask_to_connect(),        // NoMeter, NotLicensed, Revoked, Device, Upgrade, Outdated, Storage, InvalidAmount.        other => show_meter_problem(other),    }}
let status = license.status(false); // offline, from the leasestatus.meters["exports"]; // MeterStatus { left: 950, total: 1000, offline: 100, unsynced: 0, resets: false }

#[tauri::command]async fn export_spend(license: tauri::State<'_, Arc<License>>) -> Result<UseResult, String> {    let license = Arc::clone(&license);    tauri::async_runtime::spawn_blocking(move || license.use_meter("exports", 1))        .await        .map_err(|e| e.to_string())}

// The Buy button, while the app holds no key.open_in_browser("https://buy.stripe.com/your-payment-link");
// The customer types the key from the delivery email:if license.activate(&entered_key).is_ok() {    show_thanks();}

use keygrant::LicenseConfig;
let config = LicenseConfig::new("my-product", "https://api.keygrant.dev", PUBLIC_KEYS);
#[cfg(windows)]let config = config.registry(std::sync::Arc::new(keygrant::WindowsRegistryStash::new("my-product")));