Any language can activate and verify a license

function isValid(token, now):
    parts = token.split(".")                     # exactly two non-empty parts
    payload = json(base64url_decode(parts[0]))   # read kid; don't trust it yet
    publicKey = EMBEDDED_KEYS[payload.kid]       # unknown kid → invalid
    if not ed25519_verify(publicKey, base64url_decode(parts[1]), ascii(parts[0])): return NO
    if payload.v != 1 or payload.app != THIS_APP:       return NO
    if payload.dev != deviceHash(THIS_APP):         return NO
    if payload.lic in savedRevokedList:                return NO
    if payload.exp != null and payload.exp <= now:     return EXPIRED   # try /v1/refresh
    return YES(pro = payload.plan != "free", units = payload.qty, features = payload.feat)

// WebCrypto (Node 20+, Deno, Bun or a modern browser). Works as is.
const b64url = (s) =>
  Uint8Array.from(atob(s.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(s.length / 4) * 4, "=")), (ch) => ch.charCodeAt(0));

async function verify(token, publicKeyB64) {
  const [body, sig] = token.split(".");
  if (!body || !sig) return null;
  const raw = Uint8Array.from(atob(publicKeyB64), (ch) => ch.charCodeAt(0));
  const key = await crypto.subtle.importKey("raw", raw, { name: "Ed25519" }, false, ["verify"]);
  // The signature covers the payload characters exactly as received.
  const ok = await crypto.subtle.verify({ name: "Ed25519" }, key, b64url(sig), new TextEncoder().encode(body));
  return ok ? JSON.parse(new TextDecoder().decode(b64url(body))) : null;
}

// Illustrative: what the C# SDK is meant to look like. The API may change.
var licensing = new OwnLicenseClient(
    baseUrl: new Uri("https://licenses.example.com"),
    app: "myapp",
    publicKeys: new() { ["myapp-live-1"] = "BASE64_PUBLIC_KEY" });

// Activate once, with the email and key the customer typed.
var result = await licensing.ActivateAsync(email, key);
if (!result.Ok) ShowError(result.Error); // invalid_key, seats_exhausted…

// On every launch: verify offline, renew in the background.
var license = licensing.Current();        // null = free mode
_ = licensing.RefreshIfNeededAsync();

// Illustrative: verification with Apple's CryptoKit; the Swift SDK will wrap it.
import CryptoKit
import Foundation

func base64URLDecode(_ s: String) -> Data? {
    var b = s.replacingOccurrences(of: "-", with: "+").replacingOccurrences(of: "_", with: "/")
    b += String(repeating: "=", count: (4 - b.count % 4) % 4)
    return Data(base64Encoded: b)
}

func verify(token: String, publicKeyBase64: String) -> [String: Any]? {
    let parts = token.split(separator: ".").map(String.init)
    guard parts.count == 2,
          let keyData = Data(base64Encoded: publicKeyBase64),
          let key = try? Curve25519.Signing.PublicKey(rawRepresentation: keyData),
          let signature = base64URLDecode(parts[1]),
          key.isValidSignature(signature, for: Data(parts[0].utf8)),
          let body = base64URLDecode(parts[0]) else { return nil }
    return try? JSONSerialization.jsonObject(with: body) as? [String: Any]
}