multi: cap anchors feerate at configurable maximum

This commit caps the update fee the initiator will send when the anchors
channel type is used. We do not limit anything on the receiver side.

10 sat/vbyte is the current default max fee rate we use. This should be
enough to ensure propagation before anchoring down the commitment
transaction.

lnwallet/channel.go

@@ -6809,11 +6809,14 @@ func (lc *LightningChannel) CalcFee(feeRate chainfee.SatPerKWeight) btcutil.Amou
 
 // MaxFeeRate returns the maximum fee rate given an allocation of the channel
 // initiator's spendable balance. This can be useful to determine when we should
-// stop proposing fee updates that exceed our maximum allocation.
+// stop proposing fee updates that exceed our maximum allocation. We also take
+// a fee rate cap that should be used for anchor type channels.
 //
 // NOTE: This should only be used for channels in which the local commitment is
 // the initiator.
-func (lc *LightningChannel) MaxFeeRate(maxAllocation float64) chainfee.SatPerKWeight {
+func (lc *LightningChannel) MaxFeeRate(maxAllocation float64,
+	maxAnchorFeeRate chainfee.SatPerKWeight) chainfee.SatPerKWeight {
+
 	lc.RLock()
 	defer lc.RUnlock()
 
@@ -6828,9 +6831,16 @@ func (lc *LightningChannel) MaxFeeRate(maxAllocation float64) chainfee.SatPerKWe
 	// Ensure the fee rate doesn't dip below the fee floor.
 	_, weight := lc.availableBalance()
 	maxFeeRate := maxFee / (float64(weight) / 1000)
-	return chainfee.SatPerKWeight(
+	feeRate := chainfee.SatPerKWeight(
 		math.Max(maxFeeRate, float64(chainfee.FeePerKwFloor)),
 	)
+
+	// Cap anchor fee rates.
+	if lc.channelState.ChanType.HasAnchors() && feeRate > maxAnchorFeeRate {
+		return maxAnchorFeeRate
+	}
+
+	return feeRate
 }
 
 // RemoteNextRevocation returns the channelState's RemoteNextRevocation.

lnwallet/channel_test.go

@@ -7996,6 +7996,19 @@ func TestForceCloseBorkedState(t *testing.T) {
 func TestChannelMaxFeeRate(t *testing.T) {
 	t.Parallel()
 
+	assertMaxFeeRate := func(c *LightningChannel,
+		maxAlloc float64, anchorMax, expFeeRate chainfee.SatPerKWeight) {
+
+		t.Helper()
+
+		maxFeeRate := c.MaxFeeRate(maxAlloc, anchorMax)
+		if maxFeeRate != expFeeRate {
+			t.Fatalf("expected max fee rate of %v with max "+
+				"allocation of %v, got %v", expFeeRate,
+				maxAlloc, maxFeeRate)
+		}
+	}
+
 	aliceChannel, _, cleanUp, err := CreateTestChannels(
 		channeldb.SingleFunderTweaklessBit,
 	)
@@ -8004,21 +8017,32 @@ func TestChannelMaxFeeRate(t *testing.T) {
 	}
 	defer cleanUp()
 
-	assertMaxFeeRate := func(maxAlloc float64,
-		expFeeRate chainfee.SatPerKWeight) {
+	assertMaxFeeRate(aliceChannel, 1.0, 0, 690607734)
+	assertMaxFeeRate(aliceChannel, 0.001, 0, 690607)
+	assertMaxFeeRate(aliceChannel, 0.000001, 0, 690)
+	assertMaxFeeRate(aliceChannel, 0.0000001, 0, chainfee.FeePerKwFloor)
 
-		maxFeeRate := aliceChannel.MaxFeeRate(maxAlloc)
-		if maxFeeRate != expFeeRate {
-			t.Fatalf("expected max fee rate of %v with max "+
-				"allocation of %v, got %v", expFeeRate,
-				maxAlloc, maxFeeRate)
-		}
+	// Check that anchor channels are capped at their max fee rate.
+	anchorChannel, _, cleanUp, err := CreateTestChannels(
+		channeldb.SingleFunderTweaklessBit | channeldb.AnchorOutputsBit,
+	)
+	if err != nil {
+		t.Fatalf("unable to create test channels: %v", err)
 	}
+	defer cleanUp()
 
-	assertMaxFeeRate(1.0, 690607734)
-	assertMaxFeeRate(0.001, 690607)
-	assertMaxFeeRate(0.000001, 690)
-	assertMaxFeeRate(0.0000001, chainfee.FeePerKwFloor)
+	// Anchor commitments are heavier, hence will the same allocation lead
+	// to slightly lower fee rates.
+	assertMaxFeeRate(
+		anchorChannel, 1.0, chainfee.FeePerKwFloor,
+		chainfee.FeePerKwFloor,
+	)
+	assertMaxFeeRate(anchorChannel, 0.001, 1000000, 444839)
+	assertMaxFeeRate(anchorChannel, 0.001, 300000, 300000)
+	assertMaxFeeRate(anchorChannel, 0.000001, 700, 444)
+	assertMaxFeeRate(
+		anchorChannel, 0.0000001, 1000000, chainfee.FeePerKwFloor,
+	)
 }
 
 // TestChannelFeeRateFloor asserts that valid commitments can be proposed and

lnwallet/commitment.go

@@ -17,6 +17,11 @@ import (
 // anchorSize is the constant anchor output size.
 const anchorSize = btcutil.Amount(330)
 
+// DefaultAnchorsCommitMaxFeeRateSatPerVByte is the default max fee rate in
+// sat/vbyte the initiator will use for anchor channels. This should be enough
+// to ensure propagation before anchoring down the commitment transaction.
+const DefaultAnchorsCommitMaxFeeRateSatPerVByte = 10
+
 // CommitmentKeyRing holds all derived keys needed to construct commitment and
 // HTLC transactions. The keys are derived differently depending whether the
 // commitment transaction is ours or the remote peer's. Private keys associated