invoices: replay awareness

Previously the invoice registry wasn't aware of replayed htlcs. This was
dealt with by keeping the invoice accept/settle logic idempotent, so
that a replay wouldn't have an effect.

This mechanism has two limitations:

1. No accurate tracking of the total amount paid to an invoice. The total
amount couldn't just be increased with every htlc received, because it
could be a replay which would lead to counting the htlc amount multiple
times. Therefore the total amount was set to the amount of the first
htlc that was received, even though there may have been multiple htlcs
paying to the invoice.

2. Impossible to check htlc expiry consistently for hodl invoices. When
an htlc is new, its expiry needs to be checked against the invoice cltv
delta. But for a replay, that check must be skipped. The htlc was
accepted in time, the invoice was moved to the accepted state and a
replay some blocks later shouldn't lead to that htlc being cancelled.
Because the invoice registry couldn't recognize replays, it stopped
checking htlc expiry heights when the invoice reached the accepted
state. This prevents hold htlcs from being cancelled after a restart.
But unfortunately this also caused additional htlcs to be accepted on an
already accepted invoice without their expiry being checked.

In this commit, the invoice registry starts to persistently track htlcs
so that replays can be recognized. For replays, an htlc resolution
action is returned early. This fixes both limitations mentioned above.

invoices/invoiceregistry_test.go

@@ -199,13 +199,14 @@ func TestSettleInvoice(t *testing.T) {
 		t.Fatal("expected cancel event")
 	}
 
-	// Check that settled amount remains unchanged.
+	// Check that settled amount is equal to the sum of values of the htlcs
+	// 0 and 1.
 	inv, err := registry.LookupInvoice(hash)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if inv.AmtPaid != amtPaid {
-		t.Fatal("expected amount to be unchanged")
+	if inv.AmtPaid != amtPaid+amtPaid+600 {
+		t.Fatal("amount incorrect")
 	}
 
 	// Try to cancel.
@@ -426,8 +427,7 @@ func TestHoldInvoice(t *testing.T) {
 	}
 
 	// Test a new htlc coming in that doesn't meet the final cltv delta
-	// requirement. It should be rejected, but because invoice registry
-	// doesn't track individual htlcs it is accepted.
+	// requirement. It should be rejected.
 	event, err = registry.NotifyExitHopHtlc(
 		hash, amtPaid, 1, testCurrentHeight,
 		getCircuitKey(1), hodlChan, nil,
@@ -435,8 +435,8 @@ func TestHoldInvoice(t *testing.T) {
 	if err != nil {
 		t.Fatalf("expected settle to succeed but got %v", err)
 	}
-	if event != nil {
-		t.Fatalf("expected htlc to be held")
+	if event == nil || event.Preimage != nil {
+		t.Fatalf("expected htlc to be cancelled")
 	}
 
 	// We expect the accepted state to be sent to the single invoice