multi: make updatechanpolicy fields optional with *_specified flags

This commit makes the base_fee_msat, fee_rate/fee_rate_ppm, and
time_lock_delta fields optional in the UpdateChannelPolicy RPC,
following the existing pattern used by min_htlc_msat_specified.

Previously, these fields were required on every invocation, even when
users only wanted to update a single field. This was a common pain
point reported in issue #1523.

Protocol changes (lnrpc/lightning.proto):
- Add base_fee_msat_specified (field 12)
- Add fee_rate_specified (field 13)
- Add time_lock_delta_specified (field 14)

Internal API changes (routing/router.go):
- FeeSchema.BaseFee: changed from value to pointer (*lnwire.MilliSatoshi)
- FeeSchema.FeeRate: changed from value to pointer (*uint32)
- ChannelPolicy.TimeLockDelta: changed from value to pointer (*uint32)

RPC server changes (rpcserver.go):
- Only validate and apply fields when their *_specified flag is true
- When a field is not specified, the existing channel value is retained

CLI changes (cmd/commands/commands.go):
- Fields are now truly optional (no "argument missing" errors)
- ctx.IsSet() determines whether to set *_specified flags
- Default values shown in help text from chainreg constants
- Help text updated to say "If unset, existing value is retained"

Local channel manager changes (routing/localchans/manager.go):
- updateEdge() only updates fields when pointers are non-nil
- Follows the same pattern already used for MinHTLC

This enables users to update individual policy fields independently:
  lncli updatechanpolicy --base_fee_msat 1000 --chan_point abc:0

Without needing to specify all other fields.

NOTE: Proto regeneration required (make rpc).

Fixes #1523

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: yashbhutwala

cmd/commands/commands.go

@@ -20,6 +20,7 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/jessevdk/go-flags"
 	"github.com/lightningnetwork/lnd"
+	"github.com/lightningnetwork/lnd/chainreg"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing"
@@ -2525,7 +2526,9 @@ var updateChannelPolicyCommand = cli.Command{
 			Name: "base_fee_msat",
 			Usage: "the base fee in milli-satoshis that will be " +
 				"charged for each forwarded HTLC, regardless " +
-				"of payment size",
+				"of payment size. If unset, the existing " +
+				"base fee is retained",
+			Value: int64(chainreg.DefaultBitcoinBaseFeeMSat),
 		},
 		cli.StringFlag{
 			Name: "fee_rate",
@@ -2534,7 +2537,8 @@ var updateChannelPolicyCommand = cli.Command{
 				"forwarded HTLC, the lowest possible rate is " +
 				"0 with a granularity of 0.000001 " +
 				"(millionths). Can not be set at the same " +
-				"time as fee_rate_ppm",
+				"time as fee_rate_ppm. If unset, the " +
+				"existing fee rate is retained",
 		},
 		cli.Uint64Flag{
 			Name: "fee_rate_ppm",
@@ -2543,7 +2547,9 @@ var updateChannelPolicyCommand = cli.Command{
 				"value of each forwarded HTLC, the lowest " +
 				"possible rate is 0 with a granularity of " +
 				"0.000001 (millionths). Can not be set at " +
-				"the same time as fee_rate",
+				"the same time as fee_rate. If unset, the " +
+				"existing fee rate is retained",
+			Value: uint64(chainreg.DefaultBitcoinFeeRate),
 		},
 		cli.Int64Flag{
 			Name: "inbound_base_fee_msat",
@@ -2573,7 +2579,10 @@ var updateChannelPolicyCommand = cli.Command{
 		cli.Uint64Flag{
 			Name: "time_lock_delta",
 			Usage: "the CLTV delta that will be applied to all " +
-				"forwarded HTLCs",
+				"forwarded HTLCs. Must be between 18 and " +
+				"65535. If unset, the existing time lock " +
+				"delta is retained",
+			Value: uint64(chainreg.DefaultBitcoinTimeLockDelta),
 		},
 		cli.Uint64Flag{
 			Name: "min_htlc_msat",
@@ -2660,62 +2669,69 @@ func updateChannelPolicy(ctx *cli.Context) error {
 	defer cleanUp()
 
 	var (
-		baseFee       int64
-		feeRate       float64
-		feeRatePpm    uint64
-		timeLockDelta uint16
-		err           error
+		baseFee                 int64
+		baseFeeMsatSpecified    bool
+		feeRate                 float64
+		feeRatePpm              uint64
+		feeRateSpecified        bool
+		timeLockDelta           uint32
+		timeLockDeltaSpecified  bool
+		err                     error
 	)
 	args := ctx.Args()
 
+	// Parse base_fee_msat. If explicitly set, mark as specified.
 	switch {
 	case ctx.IsSet("base_fee_msat"):
 		baseFee = ctx.Int64("base_fee_msat")
+		baseFeeMsatSpecified = true
 	case args.Present():
 		baseFee, err = strconv.ParseInt(args.First(), 10, 64)
 		if err != nil {
 			return fmt.Errorf("unable to decode base_fee_msat: %w",
 				err)
 		}
+		baseFeeMsatSpecified = true
 		args = args.Tail()
-	default:
-		return fmt.Errorf("base_fee_msat argument missing")
 	}
 
+	// Parse fee_rate or fee_rate_ppm. If explicitly set, mark as specified.
 	switch {
 	case ctx.IsSet("fee_rate") && ctx.IsSet("fee_rate_ppm"):
 		return fmt.Errorf("fee_rate or fee_rate_ppm can not both be set")
 	case ctx.IsSet("fee_rate"):
 		feeRate = ctx.Float64("fee_rate")
+		feeRateSpecified = true
 	case ctx.IsSet("fee_rate_ppm"):
 		feeRatePpm = ctx.Uint64("fee_rate_ppm")
+		feeRateSpecified = true
 	case args.Present():
 		feeRate, err = strconv.ParseFloat(args.First(), 64)
 		if err != nil {
 			return fmt.Errorf("unable to decode fee_rate: %w", err)
 		}
-
+		feeRateSpecified = true
 		args = args.Tail()
-	default:
-		return fmt.Errorf("fee_rate or fee_rate_ppm argument missing")
 	}
 
+	// Parse time_lock_delta. If explicitly set, mark as specified.
 	switch {
 	case ctx.IsSet("time_lock_delta"):
 		timeLockDeltaStr := ctx.String("time_lock_delta")
-		timeLockDelta, err = parseTimeLockDelta(timeLockDeltaStr)
+		tld, err := parseTimeLockDelta(timeLockDeltaStr)
 		if err != nil {
 			return err
 		}
+		timeLockDelta = uint32(tld)
+		timeLockDeltaSpecified = true
 	case args.Present():
-		timeLockDelta, err = parseTimeLockDelta(args.First())
+		tld, err := parseTimeLockDelta(args.First())
 		if err != nil {
 			return err
 		}
-
+		timeLockDelta = uint32(tld)
+		timeLockDeltaSpecified = true
 		args = args.Tail()
-	default:
-		return fmt.Errorf("time_lock_delta argument missing")
 	}
 
 	var (
@@ -2771,11 +2787,14 @@ func updateChannelPolicy(ctx *cli.Context) error {
 	createMissingEdge := ctx.Bool("create_missing_edge")
 
 	req := &lnrpc.PolicyUpdateRequest{
-		BaseFeeMsat:       baseFee,
-		TimeLockDelta:     uint32(timeLockDelta),
-		MaxHtlcMsat:       ctx.Uint64("max_htlc_msat"),
-		InboundFee:        inboundFee,
-		CreateMissingEdge: createMissingEdge,
+		BaseFeeMsat:            baseFee,
+		BaseFeeMsatSpecified:   baseFeeMsatSpecified,
+		TimeLockDelta:          timeLockDelta,
+		TimeLockDeltaSpecified: timeLockDeltaSpecified,
+		FeeRateSpecified:       feeRateSpecified,
+		MaxHtlcMsat:            ctx.Uint64("max_htlc_msat"),
+		InboundFee:             inboundFee,
+		CreateMissingEdge:      createMissingEdge,
 	}
 
 	if ctx.IsSet("min_htlc_msat") {
@@ -2793,10 +2812,13 @@ func updateChannelPolicy(ctx *cli.Context) error {
 		}
 	}
 
-	if feeRate != 0 {
-		req.FeeRate = feeRate
-	} else if feeRatePpm != 0 {
-		req.FeeRatePpm = uint32(feeRatePpm)
+	// Set fee rate values if specified.
+	if feeRateSpecified {
+		if feeRate != 0 {
+			req.FeeRate = feeRate
+		} else if feeRatePpm != 0 {
+			req.FeeRatePpm = uint32(feeRatePpm)
+		}
 	}
 
 	resp, err := client.UpdateChannelPolicy(ctxc, req)

lnrpc/lightning.pb.go

@@ -4737,18 +4737,34 @@ message PolicyUpdateRequest {
     }
 
     // The base fee charged regardless of the number of milli-satoshis sent.
+    // Only applied if base_fee_msat_specified is true.
     int64 base_fee_msat = 3;
 
+    // If true, base_fee_msat is applied. If false, the existing base fee is
+    // retained.
+    bool base_fee_msat_specified = 12;
+
     // The effective fee rate in milli-satoshis. The precision of this value
-    // goes up to 6 decimal places, so 1e-6.
+    // goes up to 6 decimal places, so 1e-6. Only applied if fee_rate_specified
+    // is true.
     double fee_rate = 4;
 
-    // The effective fee rate in micro-satoshis (parts per million).
+    // The effective fee rate in micro-satoshis (parts per million). Only
+    // applied if fee_rate_specified is true.
     uint32 fee_rate_ppm = 9;
 
-    // The required timelock delta for HTLCs forwarded over the channel.
+    // If true, fee_rate or fee_rate_ppm is applied. If false, the existing fee
+    // rate is retained.
+    bool fee_rate_specified = 13;
+
+    // The required timelock delta for HTLCs forwarded over the channel. Only
+    // applied if time_lock_delta_specified is true.
     uint32 time_lock_delta = 5;
 
+    // If true, time_lock_delta is applied. If false, the existing time lock
+    // delta is retained.
+    bool time_lock_delta_specified = 14;
+
     // If set, the maximum HTLC size in milli-satoshis. If unset, the maximum
     // HTLC will be unchanged.
     uint64 max_htlc_msat = 6;

lnrpc/lightning.proto

@@ -372,11 +372,15 @@ func (r *Manager) updateEdge(chanPoint wire.OutPoint,
 		return err
 	}
 
-	// Update forwarding fee scheme and required time lock delta.
-	edge.FeeBaseMSat = newSchema.BaseFee
-	edge.FeeProportionalMillionths = lnwire.MilliSatoshi(
-		newSchema.FeeRate,
-	)
+	// Update forwarding fee scheme if specified.
+	if newSchema.BaseFee != nil {
+		edge.FeeBaseMSat = *newSchema.BaseFee
+	}
+	if newSchema.FeeRate != nil {
+		edge.FeeProportionalMillionths = lnwire.MilliSatoshi(
+			*newSchema.FeeRate,
+		)
+	}
 
 	// If inbound fees are set, we update the edge with them.
 	err = fn.MapOptionZ(newSchema.InboundFee,
@@ -392,7 +396,10 @@ func (r *Manager) updateEdge(chanPoint wire.OutPoint,
 		return err
 	}
 
-	edge.TimeLockDelta = uint16(newSchema.TimeLockDelta)
+	// Update time lock delta if specified.
+	if newSchema.TimeLockDelta != nil {
+		edge.TimeLockDelta = uint16(*newSchema.TimeLockDelta)
+	}
 
 	// Retrieve negotiated channel htlc amt limits.
 	amtMin, amtMax, err := r.getHtlcAmtLimits(channel)

routing/localchans/manager.go

@@ -54,12 +54,15 @@ func TestManager(t *testing.T) {
 	localMultisigKey := localMultisigPrivKey.PubKey()
 	remoteMultisigPrivKey, _ := btcec.NewPrivateKey()
 	remoteMultisigKey := remoteMultisigPrivKey.PubKey()
+	baseFee := lnwire.MilliSatoshi(100)
+	feeRate := uint32(200)
+	timeLockDelta := uint32(80)
 	newPolicy := routing.ChannelPolicy{
 		FeeSchema: routing.FeeSchema{
-			BaseFee: 100,
-			FeeRate: 200,
+			BaseFee: &baseFee,
+			FeeRate: &feeRate,
 		},
-		TimeLockDelta: 80,
+		TimeLockDelta: &timeLockDelta,
 		MaxHTLC:       5000,
 	}
 
@@ -80,13 +83,13 @@ func TestManager(t *testing.T) {
 		}
 
 		policy := chanPolicies[chanPointValid]
-		if policy.TimeLockDelta != newPolicy.TimeLockDelta {
+		if policy.TimeLockDelta != *newPolicy.TimeLockDelta {
 			t.Fatal("unexpected time lock delta")
 		}
-		if policy.BaseFee != newPolicy.BaseFee {
+		if policy.BaseFee != *newPolicy.BaseFee {
 			t.Fatal("unexpected base fee")
 		}
-		if uint32(policy.FeeRate) != newPolicy.FeeRate {
+		if uint32(policy.FeeRate) != *newPolicy.FeeRate {
 			t.Fatal("unexpected base fee")
 		}
 		if policy.MaxHTLC != newPolicy.MaxHTLC {
@@ -108,13 +111,13 @@ func TestManager(t *testing.T) {
 			if !policy.MessageFlags.HasMaxHtlc() {
 				t.Fatal("expected max htlc flag")
 			}
-			if policy.TimeLockDelta != uint16(newPolicy.TimeLockDelta) {
+			if policy.TimeLockDelta != uint16(*newPolicy.TimeLockDelta) {
 				t.Fatal("unexpected time lock delta")
 			}
-			if policy.FeeBaseMSat != newPolicy.BaseFee {
+			if policy.FeeBaseMSat != *newPolicy.BaseFee {
 				t.Fatal("unexpected base fee")
 			}
-			if uint32(policy.FeeProportionalMillionths) != newPolicy.FeeRate {
+			if uint32(policy.FeeProportionalMillionths) != *newPolicy.FeeRate {
 				t.Fatal("unexpected base fee")
 			}
 			if policy.MaxHTLC != newPolicy.MaxHTLC {

routing/localchans/manager_test.go

@@ -189,16 +189,16 @@ type MissionControlQuerier interface {
 // Using the coefficients described within the schema, the required fee to
 // forward outgoing payments can be derived.
 type FeeSchema struct {
-	// BaseFee is the base amount of milli-satoshis that will be chained
-	// for ANY payment forwarded.
-	BaseFee lnwire.MilliSatoshi
+	// BaseFee is the base amount of milli-satoshis that will be charged
+	// for ANY payment forwarded. If nil, the existing base fee is retained.
+	BaseFee *lnwire.MilliSatoshi
 
 	// FeeRate is the rate that will be charged for forwarding payments.
 	// This value should be interpreted as the numerator for a fraction
 	// (fixed point arithmetic) whose denominator is 1 million. As a result
 	// the effective fee rate charged per mSAT will be: (amount *
-	// FeeRate/1,000,000).
-	FeeRate uint32
+	// FeeRate/1,000,000). If nil, the existing fee rate is retained.
+	FeeRate *uint32
 
 	// InboundFee is the inbound fee schedule that applies to forwards
 	// coming in through a channel to which this FeeSchema pertains.
@@ -213,8 +213,9 @@ type ChannelPolicy struct {
 	FeeSchema
 
 	// TimeLockDelta is the required HTLC timelock delta to be used
-	// when forwarding payments.
-	TimeLockDelta uint32
+	// when forwarding payments. If nil, the existing time lock delta is
+	// retained.
+	TimeLockDelta *uint32
 
 	// MaxHTLC is the maximum HTLC size including fees we are allowed to
 	// forward over this channel.