loopin: cancel the swap invoice before the timeout refund

[starius]

A Loop In published its timeout refund at the HTLC expiry while the swap invoice was still open, and canceled the invoice only after the refund confirmed. A server payment arriving in between settled the invoice and gave the server the preimage, while the client's refund could still win the race for the HTLC.

Commits

• loopin: reveal the internal HTLC key only for a settled invoice. A MuSig2 Loop In reveals its internal HTLC key to the server after the swap, so that the server can sweep through the key path. With the key the server can spend the HTLC on its own. The client revealed it whenever the invoice was finalized, which includes a canceled invoice. In the normal flow the invoice was only canceled after the refund confirmed, so the reveal came too late to matter. An invoice canceled while the HTLC is still unspent, for example by hand, handed over the key to an unpaid HTLC. The key is now only revealed for a settled invoice. The next commit relies on this.

• loopin: cancel the invoice before publishing a timeout refund. Before any refund, the client calls CancelInvoice, which resolves the race with a settlement atomically:

  • If the cancellation succeeds, the refund is published. So it is if lnd no longer knows the invoice (NotFound): lnd only deletes canceled invoices, for example through its garbage collection, so a deleted invoice can't be paid either.
  • If the invoice is already settled, the refund is blocked, the swap moves to InvoiceSettled, and the paid amount is read from the invoice. The swap can complete before the invoice update that reports the amount.
  • Any other error defers the refund to the next block.

  After a restart the invoice is simply canceled again, so no new swap state is persisted. The cancellation after the refund also accepts NotFound, and the swap completes without waiting for an update that a deleted invoice never sends.

Tests

• TestLoopInCanceledInvoiceKeepsHtlcKey: a canceled invoice never reveals the key. It fails before the first commit.
• TestLoopInTimeout now expects the cancellation before the refund.
• TestLoopInRefundGateSettledInvoice: a settled invoice blocks the refund, and the server cost is recorded without the invoice update.
• TestLoopInRefundGateUnresolvedCancellation: an unclear cancellation error defers the refund.
• TestLoopInRefundGateDeletedInvoice: NotFound before and after the refund. The swap refunds and completes without an invoice update.

Pull Request Checklist

• Add an entry to docs/release-notes/release-notes-next.md, or apply the
  no-changelog label (required by CI)

[hieblmi]

This looks good to me, I just have two minor suggestions.

[hieblmi]

👍

[hieblmi]

in the branch below

case invpkg.ContractCanceled:
				invoiceFinalized = true
			}

we also should set the s.InvoiceCancelled = true, so we save a cancel call in publishTimoutTx.

[hieblmi]

I think we should return the error here and wait for the next block so that the server cost can be looked up.
Not that the invoice marked as settled, but we don't know the server cost:

invoice, lookupErr := s.lnd.Client.LookupInvoice(ctx, s.hash)
if lookupErr != nil {
    s.log.Warnf(
        "Unable to look up settled invoice, retrying at the "+
            "next block: %v", lookupErr,
    )

    return false, nil
}

s.cost.Server = s.AmountRequested -
    invoice.AmountPaid.ToSatoshis()
s.invoiceSettled = true

if s.state == loopdb.StateHtlcPublished {
    s.setState(loopdb.StateInvoiceSettled)

    return false, s.persistAndAnnounceState(ctx)
}