feat: covclaimd reveal on the intents receive legs

.env.regtest

@@ -39,7 +39,12 @@ INTENT_SOLVER_IMAGE=ghcr.io/arkade-os/intent-solver:0.3.2
 # in. The onchain suites read their claim key off :7271 before they negotiate, so without this
 # every one of them dies on a refused connection rather than on anything about a corridor.
 #
-# rc.4, not the compose fallback rc.1: the corridors build VHTLC **v2**, whose preimage leaf
+# rc.5, not the compose fallback rc.1: the corridors build VHTLC **v2**, whose preimage leaf
 # carries `OP_SIZE 32 OP_EQUALVERIFY` ahead of the hash check, and rc.3 is where covclaimd's
 # `findClaimClosure` started matching that shape byte for byte.
-COVCLAIMD_IMAGE=ghcr.io/arkade-os/covclaimd:v0.0.1-rc.4
+#
+# rc.5 rather than rc.4 since the receive suites started asserting a claim the DAEMON lands: rc.5
+# attaches `PrevArkTx` to its claim transactions (covclaimd#8), which is what the emulator reads for
+# the introspection opcodes in that leaf. On rc.4 the registration is accepted and the claim then
+# fails inside the emulator, which reads as covclaimd having done nothing at all.
+COVCLAIMD_IMAGE=ghcr.io/arkade-os/covclaimd:v0.0.1-rc.5

NArk.Abstractions/Helpers/PsbtHelpers.cs

@@ -135,10 +135,19 @@ ex is EndOfStreamException or FormatException or OverflowException
     }
 
 
-    // Encodes taproot script leaves per PSBT spec: {depth version script_length script}* (no leaf count prefix).
-    // Param: leaves — array of tapscript byte arrays.
-    /// <returns>Encoded taproot tree as byte array</returns>
-    private static byte[] EncodeTaprootTree(TapScript[] leaves)
+    /// <summary>
+    /// Encodes taproot script leaves per the PSBT spec: <c>{depth version script_length script}*</c>,
+    /// with no leaf-count prefix.
+    /// </summary>
+    /// <param name="leaves">The tapscript leaves, in the order that fixes the merkle root.</param>
+    /// <returns>The encoded taproot tree.</returns>
+    /// <remarks>
+    /// Public because covclaimd takes this same encoding in a reveal, where it binds a registered
+    /// claim to its address. <b>Every leaf is encoded at depth 1, so this is only correct for a flat
+    /// taptree</b> — which every Arkade covenant is; a nested one would encode to something that does
+    /// not hash to its address, first visible as a counterparty refusing a well-formed-looking reveal.
+    /// </remarks>
+    public static byte[] EncodeTaprootTree(TapScript[] leaves)
     {
         return leaves.SelectMany(EncodeLeaf).ToArray();
 

NArk.ArkadeIntents/Covclaim/CovclaimdClient.cs

@@ -0,0 +1,249 @@
+using System.Net.Http.Json;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using NArk.Abstractions.Helpers;
+using NArk.ArkadeIntents.Lightning;
+using NBitcoin;
+using NBitcoin.Secp256k1;
+
+namespace NArk.ArkadeIntents.Covclaim;
+
+/// <summary><see cref="ICovclaimdClient"/> over covclaimd's REST gateway.</summary>
+/// <remarks>
+/// Every failure surfaces as <see cref="CovclaimdException"/>, including transport noise: callers on
+/// this path catch and carry on, which is only reasonable if the failures have one shape.
+/// </remarks>
+public sealed class CovclaimdClient : ICovclaimdClient
+{
+    private const string KeysPath = "v1/preimage/covclaimd-pubkey";
+    private const string RevealPath = "v1/reveal";
+    private const int PreimageLength = 32;
+
+    private readonly HttpClient _httpClient;
+    private readonly CovclaimdOptions _options;
+    private readonly IAesGcmCipher _cipher;
+    private readonly ILogger<CovclaimdClient>? _logger;
+    private readonly SemaphoreSlim _keysLock = new(1, 1);
+    private CovclaimdKeys? _cachedKeys;
+
+    /// <summary>Creates the client.</summary>
+    /// <param name="httpClient">Transport. Its base address is set from the options when unset.</param>
+    /// <param name="options">Where the daemon is, and how patient to be with it.</param>
+    /// <param name="cipher">
+    /// Supplies AES-GCM for sealing. Defaults to the platform's, which is right everywhere except a
+    /// browser — see <see cref="IAesGcmCipher"/>.
+    /// </param>
+    /// <param name="logger">Optional log sink.</param>
+    public CovclaimdClient(
+        HttpClient httpClient,
+        IOptions<CovclaimdOptions> options,
+        IAesGcmCipher? cipher = null,
+        ILogger<CovclaimdClient>? logger = null)
+    {
+        ArgumentNullException.ThrowIfNull(httpClient);
+        ArgumentNullException.ThrowIfNull(options);
+
+        _httpClient = httpClient;
+        _options = options.Value;
+        _cipher = cipher ?? new AesGcmCipher();
+        _logger = logger;
+
+        _httpClient.BaseAddress ??= _options.BaseAddress
+            ?? throw new InvalidOperationException(
+                $"{nameof(CovclaimdOptions)}.{nameof(CovclaimdOptions.BaseAddress)} must be set.");
+
+        AssertTransportSecure(_httpClient.BaseAddress, _options.AllowInsecureHttp);
+    }
+
+    /// <summary>
+    /// Refuse a daemon reachable only over plain HTTP, unless it is on this machine or the caller
+    /// has said otherwise.
+    /// </summary>
+    /// <remarks>
+    /// The trust anchor, not transport hygiene: whatever answers this address serves the key every
+    /// preimage is sealed to, and a leaked preimage settles the payer's invoice without this wallet
+    /// ever claiming. Loopback is exempt — nothing crosses a wire to intercept.
+    /// </remarks>
+    private static void AssertTransportSecure(Uri baseAddress, bool allowInsecureHttp)
+    {
+        if (baseAddress.Scheme == Uri.UriSchemeHttps || allowInsecureHttp || baseAddress.IsLoopback)
+        {
+            return;
+        }
+
+        throw new InvalidOperationException(
+            $"covclaimd must be reached over https (got {baseAddress.Scheme}://{baseAddress.Host}): " +
+            "the key it serves is the one every preimage gets sealed to. Set " +
+            $"{nameof(CovclaimdOptions)}.{nameof(CovclaimdOptions.AllowInsecureHttp)} to override.");
+    }
+
+    /// <inheritdoc />
+    public async Task<CovclaimdKeys> GetKeysAsync(CancellationToken cancellationToken = default)
+    {
+        if (_options.CacheKeys && _cachedKeys is { } cached)
+        {
+            return cached;
+        }
+
+        await _keysLock.WaitAsync(cancellationToken);
+        try
+        {
+            if (_options.CacheKeys && _cachedKeys is { } raced)
+            {
+                return raced;
+            }
+
+            var body = await SendAsync(async ct =>
+                {
+                    using var response = await _httpClient.GetAsync(KeysPath, ct);
+                    await EnsureSuccessAsync(response, "fetch daemon keys", ct);
+                    return await response.Content.ReadFromJsonAsync<CovclaimdKeysResponse>(ct);
+                }, "fetch daemon keys", cancellationToken)
+                ?? throw new CovclaimdException("covclaimd returned an empty key response.");
+
+            var keys = new CovclaimdKeys(
+                ParsePubKey(body.CovclaimdPubKey, "covclaimd_pub_key"),
+                ParsePubKey(body.EmulatorPubKey, "emulator_pub_key"));
+
+            if (_options.CacheKeys)
+            {
+                _cachedKeys = keys;
+            }
+            return keys;
+        }
+        finally
+        {
+            _keysLock.Release();
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task RevealAsync(
+        string swapAddress,
+        byte[] preimage,
+        byte[] arkadeScript,
+        TapScript[] taptree,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(swapAddress);
+        ArgumentNullException.ThrowIfNull(preimage);
+        ArgumentNullException.ThrowIfNull(arkadeScript);
+        ArgumentNullException.ThrowIfNull(taptree);
+
+        if (preimage.Length != PreimageLength)
+        {
+            throw new ArgumentException(
+                $"a preimage is {PreimageLength} bytes, got {preimage.Length}", nameof(preimage));
+        }
+        if (arkadeScript.Length == 0)
+        {
+            throw new ArgumentException("the covenant's claim script is empty", nameof(arkadeScript));
+        }
+        if (taptree.Length == 0)
+        {
+            throw new ArgumentException(
+                "a taptree with no leaves cannot hash to the address it claims to describe",
+                nameof(taptree));
+        }
+
+        var keys = await GetKeysAsync(cancellationToken);
+
+        // Only the preimage is sealed: the arkade script says where the claim must pay, which the
+        // solver already knows.
+        var sealed_ = await ClaimPacket.SealAsync(
+            preimage,
+            Convert.ToHexString(keys.CovclaimdPubKey.ToBytes(true)).ToLowerInvariant(),
+            _cipher,
+            cancellationToken);
+
+        var request = new RevealRequestBody
+        {
+            SwapAddress = swapAddress,
+            Packet = new RevealPacketBody
+            {
+                Ciphertext = sealed_.Packet,
+                ArkadeScript = Convert.ToBase64String(arkadeScript),
+            },
+            Taptree = Convert.ToHexString(PsbtHelpers.EncodeTaprootTree(taptree)).ToLowerInvariant(),
+        };
+
+        await SendAsync<object?>(async ct =>
+        {
+            using var response = await _httpClient.PostAsJsonAsync(RevealPath, request, ct);
+            await EnsureSuccessAsync(response, $"register a claim for {swapAddress}", ct);
+            return null;
+        }, $"register a claim for {swapAddress}", cancellationToken);
+
+        _logger?.LogInformation(
+            "covclaimd accepted a claim registration for {SwapAddress} ({LeafCount} taptree leaves)",
+            swapAddress, taptree.Length);
+    }
+
+    private async Task<T> SendAsync<T>(
+        Func<CancellationToken, Task<T>> send, string operation, CancellationToken cancellationToken)
+    {
+        using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        timeoutCts.CancelAfter(_options.RequestTimeout);
+        try
+        {
+            return await send(timeoutCts.Token);
+        }
+        // The caller's own cancellation is theirs to see; only our timeout speaks for covclaimd.
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            throw;
+        }
+        catch (OperationCanceledException ex)
+        {
+            throw new CovclaimdException(
+                $"covclaimd did not answer within {_options.RequestTimeout.TotalSeconds:0.#}s " +
+                $"while trying to {operation}.", null, ex);
+        }
+        catch (HttpRequestException ex)
+        {
+            throw new CovclaimdException($"covclaimd is unreachable: could not {operation}.", null, ex);
+        }
+    }
+
+    private static async Task EnsureSuccessAsync(
+        HttpResponseMessage response, string operation, CancellationToken cancellationToken)
+    {
+        if (response.IsSuccessStatusCode)
+        {
+            return;
+        }
+
+        var status = (int)response.StatusCode;
+        string? detail = null;
+        try
+        {
+            var error = await response.Content.ReadFromJsonAsync<CovclaimdErrorBody>(cancellationToken);
+            detail = error?.Error;
+        }
+        catch
+        {
+            // A gateway that fails without a JSON body still has a status, which is the half that
+            // says whether to retry.
+        }
+
+        throw new CovclaimdException(
+            $"covclaimd refused to {operation}: HTTP {status}{(detail is null ? "" : $" — {detail}")}",
+            status);
+    }
+
+    private static ECPubKey ParsePubKey(string? hex, string field)
+    {
+        if (hex is not { Length: > 0 })
+        {
+            throw new CovclaimdException($"covclaimd returned no {field}.");
+        }
+        try
+        {
+            return ECPubKey.Create(Convert.FromHexString(hex));
+        }
+        catch (Exception ex) when (ex is FormatException or ArgumentException)
+        {
+            throw new CovclaimdException($"covclaimd returned an unparseable {field}: '{hex}'.", null, ex);
+        }
+    }
+}

NArk.ArkadeIntents/Covclaim/CovclaimdModels.cs

@@ -0,0 +1,64 @@
+using System.Text.Json.Serialization;
+using NBitcoin;
+using NBitcoin.Secp256k1;
+
+namespace NArk.ArkadeIntents.Covclaim;
+
+/// <summary>The two keys a covclaimd instance publishes.</summary>
+/// <param name="CovclaimdPubKey">
+/// What a preimage is sealed to. Read live: the daemon generates it at startup.
+/// </param>
+/// <param name="EmulatorPubKey">
+/// The covenant co-signer the daemon will claim through. Read even though this SDK pins its own per
+/// network: a daemon on a different emulator cannot claim anything we build, and comparing the two
+/// turns that into an error at registration rather than a lockup nobody touches.
+/// </param>
+public sealed record CovclaimdKeys(ECPubKey CovclaimdPubKey, ECPubKey EmulatorPubKey)
+{
+    /// <summary>The emulator key in the x-only form the covenant commits to.</summary>
+    public TaprootPubKey EmulatorTaprootPubKey => new(EmulatorPubKey.ToXOnlyPubKey().ToBytes());
+}
+
+/// <summary>Wire shape of <c>GET /v1/preimage/covclaimd-pubkey</c>.</summary>
+internal sealed class CovclaimdKeysResponse
+{
+    [JsonPropertyName("covclaimd_pub_key")]
+    public string? CovclaimdPubKey { get; set; }
+
+    [JsonPropertyName("emulator_pub_key")]
+    public string? EmulatorPubKey { get; set; }
+}
+
+/// <summary>Wire shape of <c>POST /v1/reveal</c>, mirroring <c>covclaimd.v1.RevealRequest</c>.</summary>
+internal sealed class RevealRequestBody
+{
+    [JsonPropertyName("swap_address")]
+    public string SwapAddress { get; set; } = "";
+
+    [JsonPropertyName("packet")]
+    public RevealPacketBody Packet { get; set; } = new();
+
+    [JsonPropertyName("taptree")]
+    public string Taptree { get; set; } = "";
+}
+
+/// <summary>The claim packet a reveal carries; both fields are standard base64.</summary>
+/// <remarks>
+/// Two fields and no third: the extension path's packet also names which covclaimd may open it,
+/// because there the packet is found on a public stream. Here there is one named daemon.
+/// </remarks>
+internal sealed class RevealPacketBody
+{
+    [JsonPropertyName("ciphertext")]
+    public string Ciphertext { get; set; } = "";
+
+    [JsonPropertyName("arkade_script")]
+    public string ArkadeScript { get; set; } = "";
+}
+
+/// <summary>Error body returned by the REST gateway on a non-2xx response.</summary>
+internal sealed class CovclaimdErrorBody
+{
+    [JsonPropertyName("error")]
+    public string? Error { get; set; }
+}