dotnet-cqrs/Svrnty.CQRS.Altcha.Grpc/AltchaGrpcChallengeProvider.cs

using Grpc.Core;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Svrnty.CQRS.Altcha.Abstractions;

namespace Svrnty.CQRS.Altcha.Grpc;

/// <summary>
/// Default <see cref="IAltchaChallengeProvider"/> backed by gRPC. Calls
/// <c>AltchaService.CreateChallenge</c> on the configured endpoint and
/// projects the response onto <see cref="AltchaChallenge"/>.
/// </summary>
public sealed class AltchaGrpcChallengeProvider : IAltchaChallengeProvider
{
    private readonly AltchaService.AltchaServiceClient _client;
    private readonly IOptions<AltchaGrpcOptions> _options;
    private readonly IAltchaDifficultyAdvisor _advisor;
    private readonly ILogger<AltchaGrpcChallengeProvider> _logger;

    public AltchaGrpcChallengeProvider(
        AltchaService.AltchaServiceClient client,
        IOptions<AltchaGrpcOptions> options,
        IAltchaDifficultyAdvisor advisor,
        ILogger<AltchaGrpcChallengeProvider> logger)
    {
        _client = client;
        _options = options;
        _advisor = advisor;
        _logger = logger;
    }

    public async Task<AltchaChallenge> CreateAsync(CancellationToken cancellationToken = default)
    {
        var opts = _options.Value;
        var metadata = await AltchaCallCredentials.BuildMetadataAsync(opts, cancellationToken);
        var deadline = DateTime.UtcNow.Add(opts.CallTimeout);

        var request = new CreateChallengeRequest();
        var advisedComplexity = await _advisor.GetComplexityAsync(cancellationToken);
        if (advisedComplexity is uint complexity)
        {
            request.Complexity = complexity;
            _logger.LogDebug("Altcha advisor requested complexity {Complexity}", complexity);
        }

        try
        {
            var response = await _client.CreateChallengeAsync(
                request,
                headers: metadata,
                deadline: deadline,
                cancellationToken: cancellationToken);

            return new AltchaChallenge
            {
                Algorithm = response.Algorithm,
                Challenge = response.ChallengeHash,
                Salt = response.Salt,
                Signature = response.Signature,
                MaxNumber = response.Maxnumber
            };
        }
        catch (RpcException ex)
        {
            _logger.LogError(ex, "Altcha create-challenge failed against {Endpoint}: {Status}", opts.Endpoint, ex.StatusCode);
            throw;
        }
    }
}