ScaleGate.Licensing.SDK 1.0.0

ScaleGate.Licensing.SDK

Official .NET client SDK for the Universal Licensing System (ULS) — a multi-tenant SaaS licensing platform by ScaleGate.

Targets .NET Standard 2.0 — works with .NET Framework 4.6.1+, .NET 6/7/8/9, WPF, and WinForms.

Installation

dotnet add package ScaleGate.Licensing.SDK

Quick Start

using Licensing.SDK;

// Build and activate in one call
var client = await LicenseClient
    .Create("my-app", "XXXX-XXXX-XXXX-XXXX")
    .WithApiUrl("https://acme.uls.scalegate.io")
    .WithOfflineValidation(true)
    .WithGracePeriod(7)                  // days of offline use allowed
    .WithAutoRevalidation(true, 30)      // re-check every 30 minutes
    .WithTimeout(15)                     // HTTP timeout in seconds
    .BuildAndActivateAsync();

if (client.IsValid)
{
    // App is licensed — launch main window
    Console.WriteLine($"Plan: {client.CurrentStatus.PlanName}");
    Console.WriteLine($"Expires: {client.CurrentStatus.ExpiryDate:yyyy-MM-dd}");
    Console.WriteLine($"Devices: {client.CurrentStatus.ActiveDevices}/{client.CurrentStatus.MaxDevices}");
}
else
{
    Console.WriteLine($"License error: {client.CurrentStatus.Message}");
}

Builder Methods

Build Strategies

// Option 1: Build only (no network call)
var client = LicenseClient.Create(appId, key).Build();

// Option 2: Build + validate (checks license, no device registration)
var client = await LicenseClient.Create(appId, key).BuildAndValidateAsync();

// Option 3: Build + activate (registers device + validates)
var client = await LicenseClient.Create(appId, key).BuildAndActivateAsync();

Core Operations

// Validate (online with offline fallback)
LicenseValidationResult result = await client.ValidateAsync();

// Validate offline only (no network)
LicenseValidationResult offline = await client.ValidateOfflineAsync();

// Activate (register this device)
LicenseValidationResult activation = await client.ActivateAsync();

// Revoke (deregister this device, frees a slot)
LicenseValidationResult revocation = await client.RevokeAsync();

// Renew with a new plan
LicenseValidationResult renewal = await client.RenewAsync(planId: 3);

Events

// License status transitions (Active → GracePeriod → Expired)
client.LicenseStatusChanged += (sender, e) =>
{
    Console.WriteLine($"{e.PreviousStatus} → {e.NewStatus}");
    Console.WriteLine(e.ValidationResult.Message);
};

// After every validation attempt
client.ValidationCompleted += (sender, result) =>
{
    Console.WriteLine($"Valid: {result.IsValid}, Offline: {result.IsOfflineValidation}");
};

// New version detected during auto-update checks
client.UpdateAvailable += (sender, e) =>
{
    Console.WriteLine($"v{e.CurrentVersion} → v{e.LatestVersion}");
    Console.WriteLine(e.ReleaseNotes);
};

// Download progress during updates
client.UpdateProgress += (sender, e) =>
{
    Console.WriteLine($"Stage: {e.Stage}, Progress: {e.ProgressPercentage:F1}%");
};

Self-Update

// Check for updates
UpdateCheckResult update = await client.CheckForUpdateAsync("1.0.0");
if (update.UpdateAvailable)
{
    Console.WriteLine($"New version: {update.LatestVersion}");
    Console.WriteLine(update.ReleaseNotes);
}

// Download update binary
UpdateDownloadResult download = await client.DownloadUpdateAsync("C:\\Updates");
if (download.Success)
    Console.WriteLine($"Downloaded: {download.FilePath}");

// Full self-update: check + download + generate restart script
SelfUpdateResult selfUpdate = await client.PrepareSelfUpdateAsync("1.0.0");
if (selfUpdate.ReadyToApply)
{
    // Replaces current .exe, restarts the app
    SelfUpdater.ApplyAndRestart(
        Environment.ProcessPath,
        selfUpdate.DownloadedFilePath,
        arguments: null);
}

Extension Methods

// Throws LicenseValidationException if invalid
var client = await LicenseClient.Create(appId, key)
    .BuildAndValidateAsync()
    .EnsureValidAsync();

// Throws if activation fails
var client = await LicenseClient.Create(appId, key)
    .Build()
    .EnsureActivatedAsync();

License Status Values

Device Fingerprinting

The SDK automatically generates a hardware fingerprint from:

• CPU ID (via WMI)
• Motherboard serial number (via WMI)
• Windows Machine SID

The fingerprint is SHA-256 hashed and cached locally. Use DeviceFingerprint.RegenerateFingerprint() to force a new fingerprint if hardware changes.

Offline Cache

When WithOfflineValidation(true) is set, the SDK stores an AES-256 encrypted license cache at:

%LocalAppData%\Licensing\{appId}\license.dat

The cache includes the last successful validation result, expiry date, and plan details. During offline periods, the SDK validates against this cache and respects the configured grace period.

Requirements

• .NET Standard 2.0 compatible runtime
• Windows (required for WMI-based hardware fingerprinting)
• Network access to your ULS tenant API (for online validation)

License

MIT License - Copyright (c) 2026 Wise & Agile Solutions