Sidub.Licensing.Client 2.0.10

Sidub.Licensing.Client

.NET client SDK for Monaiq licensing by Sidub — license enforcement, feature gating, rate limiting, and metered consumption reporting for applications that hold a Monaiq license.

Install

dotnet add package Sidub.Licensing.Client

Targets netstandard2.1 — usable from .NET Core 3.0+, .NET 5+ and modern .NET.

Setup

Register the SDK and bind your credential. The encoded credential (SIDUB_LIC_…) comes from the Monaiq portal or your license-delivery email and bundles everything the SDK needs.

using Sidub.Licensing;
using Sidub.Licensing.Client;

builder.Services.Configure<LicensingServiceOptions>(options =>
{
    options.LicenseServiceUri = "https://api.monaiq.com/licensing";
    options.ConsumptionServiceUri = "https://api.monaiq.com/consumption";
    options.EncodedCredential = builder.Configuration["Licensing:EncodedCredential"];
});

builder.Services.AddSidubLicensing();

Check a license

ILicensingService is the enforcement surface: fetch a signed authorization, gate features against it, and record metered operations. The LicensingContextAccessor resolves the configured credential.

using Sidub.Licensing;
using Sidub.Licensing.Context;
using Sidub.Licensing.Exceptions;
using Sidub.Licensing.Features;
using Sidub.Licensing.Services;

public sealed class ReportService(ILicensingService licensing, LicensingContextAccessor contextAccessor)
{
    private static readonly LicensingServiceReference ServiceReference = new();

    public async Task RunAsync()
    {
        var context = await contextAccessor.GetContextAsync()
            ?? throw new InvalidOperationException("No license is configured.");

        // A cryptographically signed, cached authorization for the configured license.
        var authorization = await licensing.GetAuthorization(ServiceReference, context);

        // Gate a rate-limited feature; the sliding window is enforced locally.
        // GetLicenseFeature returns null when the license does not carry the feature —
        // handle that as "not licensed", never suppress it with the ! operator.
        var feature = await licensing.GetLicenseFeature<RateLimitLicenseFeature>(
            ServiceReference, context, "reports.generate");

        if (feature is null)
        {
            // The feature is not on this license — surface an upgrade path to the user.
            return;
        }

        try
        {
            await licensing.PerformOperation<RateLimitLicenseFeature, RateLimitLicenseFeatureState>(
                ServiceReference, context, new RateLimitLicenseFeatureOperation(feature, 1));
        }
        catch (RateLimitException)
        {
            // The throw IS the enforcement signal — surface an upgrade path to the user.
        }
    }
}

AssertLicense evaluates declarative assertions (feature existence, service access, rate limits) against an authorization; rate-limit violations throw RateLimitException rather than returning false.

Sell from inside your app

An application you distribute — desktop, mobile, CLI — can sell your offerings from inside itself with IPurchaseClient. The buyer signs in with their Monaiq identity and buys with their own token; no key of yours ships with the app, and the client never sends one.

using Sidub.Licensing.Checkout;
using Sidub.Licensing.Client;
using Sidub.Licensing.Client.Purchase;

builder.Services.AddSidubLicensingPurchaseClient(options =>
{
    options.PurchaseServiceUri = "https://api.monaiq.com/purchase";
    options.AccessTokenProvider = ct => signIn.AcquireAccessTokenAsync(ct); // MSAL (desktop) or native auth (mobile)
});

// Read the catalog live (anonymous), then buy as the signed-in buyer.
var catalog = await purchase.ListOfferingsAsync(issuerClientId);
var session = await purchase.CreateCheckoutAsync(new PurchaseCheckoutRequest
{
    RequestId = Guid.NewGuid(),           // idempotency key — reuse on retry
    OfferingId = offering.Id,
    IssuerClientId = issuerClientId
});
if (session.SessionUrl is not null)
    OpenSystemBrowser(session.SessionUrl); // paid: Stripe Checkout; free: null, license already minted
var result = await purchase.PollResultAsync(session.SessionId);
// result.EncodedCredential is the credential the runtime SDK takes.

The guide, the sign-in options and the raw HTTP contract: https://docs.monaiq.com/integrate/in-app-purchase/

Resilience built in

• Authorization fetches retry transient failures with bounded backoff and a per-attempt timeout; exhaustion surfaces as a typed LicenseAuthorizationUnavailableException.
• The last signature-verified authorization bridges brief API outages inside a bounded grace window — denials and revocations are never bridged.
• Metered consumption is buffered, aggregated, and delivered with exactly-once submission identity; buffered usage flushes on shutdown.

Structured errors

API failures surface as LicensingApiException carrying the server's error contract: a machine-readable Code (PascalCase, e.g. ValidationError, AuthorizationDenied), the CorrelationId to quote when contacting support, the HTTP StatusCode, structured Details, and the server's Retry-After hint when backpressure applies. Branch on Code, not on message text.

Learn more

• Documentation: https://docs.monaiq.com
• Getting started: https://docs.monaiq.com/integrate/
• .NET quickstart: https://docs.monaiq.com/integrate/dotnet/
• Support: https://docs.monaiq.com/resources/legal-and-support/

© Sidub Inc. Proprietary license — see the LICENSE file.