Merge pull request #4704 from yyforyongyu/4308-fix-sats-vbyte

lnrpc+lncli: fix sat per virtual byte

cmd/lncli/cmd_open_channel.go

@@ -84,7 +84,7 @@ var openChannelCommand = cli.Command{
 	another address.
 
 	One can manually set the fee to be used for the funding transaction via either
-	the --conf_target or --sat_per_byte arguments. This is optional.`,
+	the --conf_target or --sat_per_vbyte arguments. This is optional.`,
 	ArgsUsage: "node-key local-amt push-amt",
 	Flags: []cli.Flag{
 		cli.StringFlag{
@@ -119,9 +119,14 @@ var openChannelCommand = cli.Command{
 				"used for fee estimation",
 		},
 		cli.Int64Flag{
-			Name: "sat_per_byte",
+			Name:   "sat_per_byte",
+			Usage:  "Deprecated, use sat_per_vbyte instead.",
+			Hidden: true,
+		},
+		cli.Int64Flag{
+			Name: "sat_per_vbyte",
 			Usage: "(optional) a manual fee expressed in " +
-				"sat/byte that should be used when crafting " +
+				"sat/vbyte that should be used when crafting " +
 				"the transaction",
 		},
 		cli.BoolFlag{
@@ -214,10 +219,19 @@ func openChannel(ctx *cli.Context) error {
 		return nil
 	}
 
+	// Check that only the field sat_per_vbyte or the deprecated field
+	// sat_per_byte is used.
+	feeRateFlag, err := checkNotBothSet(
+		ctx, "sat_per_vbyte", "sat_per_byte",
+	)
+	if err != nil {
+		return err
+	}
+
 	minConfs := int32(ctx.Uint64("min_confs"))
 	req := &lnrpc.OpenChannelRequest{
 		TargetConf:                 int32(ctx.Int64("conf_target")),
-		SatPerByte:                 ctx.Int64("sat_per_byte"),
+		SatPerVbyte:                ctx.Uint64(feeRateFlag),
 		MinHtlcMsat:                ctx.Int64("min_htlc_msat"),
 		RemoteCsvDelay:             uint32(ctx.Uint64("remote_csv_delay")),
 		MinConfs:                   minConfs,
@@ -730,7 +744,7 @@ func checkPsbtFlags(req *lnrpc.OpenChannelRequest) error {
 		return fmt.Errorf("specifying minimum confirmations for PSBT " +
 			"funding is not supported")
 	}
-	if req.TargetConf != 0 || req.SatPerByte != 0 {
+	if req.TargetConf != 0 || req.SatPerByte != 0 || req.SatPerVbyte != 0 {
 		return fmt.Errorf("setting fee estimation parameters not " +
 			"supported for PSBT funding")
 	}

cmd/lncli/commands.go

@@ -225,7 +225,7 @@ var sendCoinsCommand = cli.Command{
 	Send amt coins in satoshis to the base58 or bech32 encoded bitcoin address addr.
 
 	Fees used when sending the transaction can be specified via the --conf_target, or
-	--sat_per_byte optional flags.
+	--sat_per_vbyte optional flags.
 
 	Positional arguments and flags can be used interchangeably but not at the same time!
 	`,
@@ -253,9 +253,14 @@ var sendCoinsCommand = cli.Command{
 				"used for fee estimation",
 		},
 		cli.Int64Flag{
-			Name: "sat_per_byte",
+			Name:   "sat_per_byte",
+			Usage:  "Deprecated, use sat_per_vbyte instead.",
+			Hidden: true,
+		},
+		cli.Int64Flag{
+			Name: "sat_per_vbyte",
 			Usage: "(optional) a manual fee expressed in " +
-				"sat/byte that should be used when crafting " +
+				"sat/vbyte that should be used when crafting " +
 				"the transaction",
 		},
 		cli.Uint64Flag{
@@ -284,9 +289,20 @@ func sendCoins(ctx *cli.Context) error {
 		return nil
 	}
 
-	if ctx.IsSet("conf_target") && ctx.IsSet("sat_per_byte") {
+	// Check that only the field sat_per_vbyte or the deprecated field
-		return fmt.Errorf("either conf_target or sat_per_byte should be " +
+	// sat_per_byte is used.
-			"set, but not both")
+	feeRateFlag, err := checkNotBothSet(
+		ctx, "sat_per_vbyte", "sat_per_byte",
+	)
+	if err != nil {
+		return err
+	}
+
+	// Only fee rate flag or conf_target should be set, not both.
+	if _, err := checkNotBothSet(
+		ctx, feeRateFlag, "conf_target",
+	); err != nil {
+		return err
 	}
 
 	switch {
@@ -324,7 +340,7 @@ func sendCoins(ctx *cli.Context) error {
 		Addr:             addr,
 		Amount:           amt,
 		TargetConf:       int32(ctx.Int64("conf_target")),
-		SatPerByte:       ctx.Int64("sat_per_byte"),
+		SatPerVbyte:      ctx.Uint64(feeRateFlag),
 		SendAll:          ctx.Bool("sweepall"),
 		Label:            ctx.String(txLabelFlag.Name),
 		MinConfs:         minConfs,
@@ -464,7 +480,7 @@ var sendManyCommand = cli.Command{
 	Name:      "sendmany",
 	Category:  "On-chain",
 	Usage:     "Send bitcoin on-chain to multiple addresses.",
-	ArgsUsage: "send-json-string [--conf_target=N] [--sat_per_byte=P]",
+	ArgsUsage: "send-json-string [--conf_target=N] [--sat_per_vbyte=P]",
 	Description: `
 	Create and broadcast a transaction paying the specified amount(s) to the passed address(es).
 
@@ -480,9 +496,15 @@ var sendManyCommand = cli.Command{
 				"confirm in, will be used for fee estimation",
 		},
 		cli.Int64Flag{
-			Name: "sat_per_byte",
+			Name:   "sat_per_byte",
-			Usage: "(optional) a manual fee expressed in sat/byte that should be " +
+			Usage:  "Deprecated, use sat_per_vbyte instead.",
-				"used when crafting the transaction",
+			Hidden: true,
+		},
+		cli.Int64Flag{
+			Name: "sat_per_vbyte",
+			Usage: "(optional) a manual fee expressed in " +
+				"sat/vbyte that should be used when crafting " +
+				"the transaction",
 		},
 		cli.Uint64Flag{
 			Name: "min_confs",
@@ -505,9 +527,20 @@ func sendMany(ctx *cli.Context) error {
 		return err
 	}
 
-	if ctx.IsSet("conf_target") && ctx.IsSet("sat_per_byte") {
+	// Check that only the field sat_per_vbyte or the deprecated field
-		return fmt.Errorf("either conf_target or sat_per_byte should be " +
+	// sat_per_byte is used.
-			"set, but not both")
+	feeRateFlag, err := checkNotBothSet(
+		ctx, "sat_per_vbyte", "sat_per_byte",
+	)
+	if err != nil {
+		return err
+	}
+
+	// Only fee rate flag or conf_target should be set, not both.
+	if _, err := checkNotBothSet(
+		ctx, feeRateFlag, "conf_target",
+	); err != nil {
+		return err
 	}
 
 	client, cleanUp := getClient(ctx)
@@ -517,7 +550,7 @@ func sendMany(ctx *cli.Context) error {
 	txid, err := client.SendMany(ctxc, &lnrpc.SendManyRequest{
 		AddrToAmount:     amountToAddr,
 		TargetConf:       int32(ctx.Int64("conf_target")),
-		SatPerByte:       ctx.Int64("sat_per_byte"),
+		SatPerVbyte:      ctx.Uint64(feeRateFlag),
 		Label:            ctx.String(txLabelFlag.Name),
 		MinConfs:         minConfs,
 		SpendUnconfirmed: minConfs == 0,
@@ -651,7 +684,7 @@ var closeChannelCommand = cli.Command{
 
 	In the case of a cooperative closure, one can manually set the fee to
 	be used for the closing transaction via either the --conf_target or
-	--sat_per_byte arguments. This will be the starting value used during
+	--sat_per_vbyte arguments. This will be the starting value used during
 	fee negotiation. This is optional.
 
 	In the case of a cooperative closure, one can manually set the address
@@ -690,9 +723,14 @@ var closeChannelCommand = cli.Command{
 				"lnd config will be used.",
 		},
 		cli.Int64Flag{
-			Name: "sat_per_byte",
+			Name:   "sat_per_byte",
+			Usage:  "Deprecated, use sat_per_vbyte instead.",
+			Hidden: true,
+		},
+		cli.Int64Flag{
+			Name: "sat_per_vbyte",
 			Usage: "(optional) a manual fee expressed in " +
-				"sat/byte that should be used when crafting " +
+				"sat/vbyte that should be used when crafting " +
 				"the transaction",
 		},
 		cli.StringFlag{
@@ -717,6 +755,15 @@ func closeChannel(ctx *cli.Context) error {
 		return nil
 	}
 
+	// Check that only the field sat_per_vbyte or the deprecated field
+	// sat_per_byte is used.
+	feeRateFlag, err := checkNotBothSet(
+		ctx, "sat_per_vbyte", "sat_per_byte",
+	)
+	if err != nil {
+		return err
+	}
+
 	channelPoint, err := parseChannelPoint(ctx)
 	if err != nil {
 		return err
@@ -727,7 +774,7 @@ func closeChannel(ctx *cli.Context) error {
 		ChannelPoint:    channelPoint,
 		Force:           ctx.Bool("force"),
 		TargetConf:      int32(ctx.Int64("conf_target")),
-		SatPerByte:      ctx.Int64("sat_per_byte"),
+		SatPerVbyte:     ctx.Uint64(feeRateFlag),
 		DeliveryAddress: ctx.String("delivery_addr"),
 	}
 
@@ -824,7 +871,7 @@ var closeAllChannelsCommand = cli.Command{
 
 	In the case of cooperative closures, one can manually set the fee to
 	be used for the closing transactions via either the --conf_target or
-	--sat_per_byte arguments. This will be the starting value used during
+	--sat_per_vbyte arguments. This will be the starting value used during
 	fee negotiation. This is optional.`,
 	Flags: []cli.Flag{
 		cli.BoolFlag{
@@ -843,9 +890,14 @@ var closeAllChannelsCommand = cli.Command{
 				"used for fee estimation",
 		},
 		cli.Int64Flag{
-			Name: "sat_per_byte",
+			Name:   "sat_per_byte",
+			Usage:  "Deprecated, use sat_per_vbyte instead.",
+			Hidden: true,
+		},
+		cli.Int64Flag{
+			Name: "sat_per_vbyte",
 			Usage: "(optional) a manual fee expressed in " +
-				"sat/byte that should be used when crafting " +
+				"sat/vbyte that should be used when crafting " +
 				"the closing transactions",
 		},
 	},
@@ -857,6 +909,15 @@ func closeAllChannels(ctx *cli.Context) error {
 	client, cleanUp := getClient(ctx)
 	defer cleanUp()
 
+	// Check that only the field sat_per_vbyte or the deprecated field
+	// sat_per_byte is used.
+	feeRateFlag, err := checkNotBothSet(
+		ctx, "sat_per_vbyte", "sat_per_byte",
+	)
+	if err != nil {
+		return err
+	}
+
 	listReq := &lnrpc.ListChannelsRequest{}
 	openChannels, err := client.ListChannels(ctxc, listReq)
 	if err != nil {
@@ -983,9 +1044,9 @@ func closeAllChannels(ctx *cli.Context) error {
 					},
 					OutputIndex: uint32(index),
 				},
-				Force:      !channel.GetActive(),
+				Force:       !channel.GetActive(),
-				TargetConf: int32(ctx.Int64("conf_target")),
+				TargetConf:  int32(ctx.Int64("conf_target")),
-				SatPerByte: ctx.Int64("sat_per_byte"),
+				SatPerVbyte: ctx.Uint64(feeRateFlag),
 			}
 
 			txidChan := make(chan string, 1)

cmd/lncli/main.go

@@ -240,6 +240,23 @@ func extractPathArgs(ctx *cli.Context) (string, string, error) {
 	return tlsCertPath, macPath, nil
 }
 
+// checkNotBothSet accepts two flag names, a and b, and checks that only flag a
+// or flag b can be set, but not both. It returns the name of the flag or an
+// error.
+func checkNotBothSet(ctx *cli.Context, a, b string) (string, error) {
+	if ctx.IsSet(a) && ctx.IsSet(b) {
+		return "", fmt.Errorf(
+			"either %s or %s should be set, but not both", a, b,
+		)
+	}
+
+	if ctx.IsSet(a) {
+		return a, nil
+	}
+
+	return b, nil
+}
+
 func main() {
 	app := cli.NewApp()
 	app.Name = "lncli"

cmd/lncli/walletrpc_active.go

@@ -88,8 +88,8 @@ func pendingSweeps(ctx *cli.Context) error {
 
 	// Sort them in ascending fee rate order for display purposes.
 	sort.Slice(resp.PendingSweeps, func(i, j int) bool {
-		return resp.PendingSweeps[i].SatPerByte <
+		return resp.PendingSweeps[i].SatPerVbyte <
-			resp.PendingSweeps[j].SatPerByte
+			resp.PendingSweeps[j].SatPerVbyte
 	})
 
 	var pendingSweepsResp = struct {
@@ -134,7 +134,7 @@ var bumpFeeCommand = cli.Command{
 	fee transaction that is under the control of the wallet.
 
 	A fee preference must be provided, either through the conf_target or
-	sat_per_byte parameters.
+	sat_per_vbyte parameters.
 
 	Note that this command currently doesn't perform any validation checks
 	on the fee preference being provided. For now, the responsibility of
@@ -153,8 +153,13 @@ var bumpFeeCommand = cli.Command{
 				"be swept on-chain within",
 		},
 		cli.Uint64Flag{
-			Name: "sat_per_byte",
+			Name:   "sat_per_byte",
-			Usage: "a manual fee expressed in sat/byte that " +
+			Usage:  "Deprecated, use sat_per_vbyte instead.",
+			Hidden: true,
+		},
+		cli.Uint64Flag{
+			Name: "sat_per_vbyte",
+			Usage: "a manual fee expressed in sat/vbyte that " +
 				"should be used when sweeping the output",
 		},
 		cli.BoolFlag{
@@ -174,6 +179,15 @@ func bumpFee(ctx *cli.Context) error {
 		return cli.ShowCommandHelp(ctx, "bumpfee")
 	}
 
+	// Check that only the field sat_per_vbyte or the deprecated field
+	// sat_per_byte is used.
+	feeRateFlag, err := checkNotBothSet(
+		ctx, "sat_per_vbyte", "sat_per_byte",
+	)
+	if err != nil {
+		return err
+	}
+
 	// Validate and parse the relevant arguments/flags.
 	protoOutPoint, err := NewProtoOutPoint(ctx.Args().Get(0))
 	if err != nil {
@@ -184,10 +198,10 @@ func bumpFee(ctx *cli.Context) error {
 	defer cleanUp()
 
 	resp, err := client.BumpFee(ctxc, &walletrpc.BumpFeeRequest{
-		Outpoint:   protoOutPoint,
+		Outpoint:    protoOutPoint,
-		TargetConf: uint32(ctx.Uint64("conf_target")),
+		TargetConf:  uint32(ctx.Uint64("conf_target")),
-		SatPerByte: uint32(ctx.Uint64("sat_per_byte")),
+		SatPerVbyte: ctx.Uint64(feeRateFlag),
-		Force:      ctx.Bool("force"),
+		Force:       ctx.Bool("force"),
 	})
 	if err != nil {
 		return err
@@ -216,8 +230,13 @@ var bumpCloseFeeCommand = cli.Command{
 				"be swept on-chain within",
 		},
 		cli.Uint64Flag{
-			Name: "sat_per_byte",
+			Name:   "sat_per_byte",
-			Usage: "a manual fee expressed in sat/byte that " +
+			Usage:  "Deprecated, use sat_per_vbyte instead.",
+			Hidden: true,
+		},
+		cli.Uint64Flag{
+			Name: "sat_per_vbyte",
+			Usage: "a manual fee expressed in sat/vbyte that " +
 				"should be used when sweeping the output",
 		},
 	},
@@ -233,9 +252,18 @@ func bumpCloseFee(ctx *cli.Context) error {
 		return cli.ShowCommandHelp(ctx, "bumpclosefee")
 	}
 
+	// Check that only the field sat_per_vbyte or the deprecated field
+	// sat_per_byte is used.
+	feeRateFlag, err := checkNotBothSet(
+		ctx, "sat_per_vbyte", "sat_per_byte",
+	)
+	if err != nil {
+		return err
+	}
+
 	// Validate the channel point.
 	channelPoint := ctx.Args().Get(0)
-	_, err := NewProtoOutPoint(channelPoint)
+	_, err = NewProtoOutPoint(channelPoint)
 	if err != nil {
 		return err
 	}
@@ -291,10 +319,10 @@ func bumpCloseFee(ctx *cli.Context) error {
 			sweepTxID, sweep.Outpoint.OutputIndex)
 
 		_, err = walletClient.BumpFee(ctxc, &walletrpc.BumpFeeRequest{
-			Outpoint:   sweep.Outpoint,
+			Outpoint:    sweep.Outpoint,
-			TargetConf: uint32(ctx.Uint64("conf_target")),
+			TargetConf:  uint32(ctx.Uint64("conf_target")),
-			SatPerByte: uint32(ctx.Uint64("sat_per_byte")),
+			SatPerVbyte: ctx.Uint64(feeRateFlag),
-			Force:      true,
+			Force:       true,
 		})
 		if err != nil {
 			return err
@@ -595,7 +623,7 @@ func fundPsbt(ctx *cli.Context) error {
 
 	case ctx.Uint64("sat_per_vbyte") > 0:
 		req.Fees = &walletrpc.FundPsbtRequest_SatPerVbyte{
-			SatPerVbyte: uint32(ctx.Uint64("sat_per_vbyte")),
+			SatPerVbyte: ctx.Uint64("sat_per_vbyte"),
 		}
 	}
 

cmd/lncli/walletrpc_types.go

@@ -5,29 +5,29 @@ import "github.com/lightningnetwork/lnd/lnrpc/walletrpc"
 // PendingSweep is a CLI-friendly type of the walletrpc.PendingSweep proto. We
 // use this to show more useful string versions of byte slices and enums.
 type PendingSweep struct {
-	OutPoint            OutPoint `json:"outpoint"`
+	OutPoint             OutPoint `json:"outpoint"`
-	WitnessType         string   `json:"witness_type"`
+	WitnessType          string   `json:"witness_type"`
-	AmountSat           uint32   `json:"amount_sat"`
+	AmountSat            uint32   `json:"amount_sat"`
-	SatPerByte          uint32   `json:"sat_per_byte"`
+	SatPerVByte          uint32   `json:"sat_per_vbyte"`
-	BroadcastAttempts   uint32   `json:"broadcast_attempts"`
+	BroadcastAttempts    uint32   `json:"broadcast_attempts"`
-	NextBroadcastHeight uint32   `json:"next_broadcast_height"`
+	NextBroadcastHeight  uint32   `json:"next_broadcast_height"`
-	RequestedSatPerByte uint32   `json:"requested_sat_per_byte"`
+	RequestedSatPerVByte uint32   `json:"requested_sat_per_vbyte"`
-	RequestedConfTarget uint32   `json:"requested_conf_target"`
+	RequestedConfTarget  uint32   `json:"requested_conf_target"`
-	Force               bool     `json:"force"`
+	Force                bool     `json:"force"`
 }
 
 // NewPendingSweepFromProto converts the walletrpc.PendingSweep proto type into
 // its corresponding CLI-friendly type.
 func NewPendingSweepFromProto(pendingSweep *walletrpc.PendingSweep) *PendingSweep {
 	return &PendingSweep{
-		OutPoint:            NewOutPointFromProto(pendingSweep.Outpoint),
+		OutPoint:             NewOutPointFromProto(pendingSweep.Outpoint),
-		WitnessType:         pendingSweep.WitnessType.String(),
+		WitnessType:          pendingSweep.WitnessType.String(),
-		AmountSat:           pendingSweep.AmountSat,
+		AmountSat:            pendingSweep.AmountSat,
-		SatPerByte:          pendingSweep.SatPerByte,
+		SatPerVByte:          uint32(pendingSweep.SatPerVbyte),
-		BroadcastAttempts:   pendingSweep.BroadcastAttempts,
+		BroadcastAttempts:    pendingSweep.BroadcastAttempts,
-		NextBroadcastHeight: pendingSweep.NextBroadcastHeight,
+		NextBroadcastHeight:  pendingSweep.NextBroadcastHeight,
-		RequestedSatPerByte: pendingSweep.RequestedSatPerByte,
+		RequestedSatPerVByte: uint32(pendingSweep.RequestedSatPerVbyte),
-		RequestedConfTarget: pendingSweep.RequestedConfTarget,
+		RequestedConfTarget:  pendingSweep.RequestedConfTarget,
-		Force:               pendingSweep.Force,
+		Force:                pendingSweep.Force,
 	}
 }

docs/watchtower.md

@@ -209,7 +209,7 @@ To obtain information about the watchtower's sessions, users can use the
                         "num_backups": 0,
                         "num_pending_backups": 0,
                         "max_backups": 1024,
-                        "sweep_sat_per_byte": 10
+                        "sweep_sat_per_vbyte": 10
                 }
         ]
 }

lnrpc/rpc.proto

@@ -58,7 +58,7 @@ service Lightning {
     /* lncli: `sendcoins`
     SendCoins executes a request to send coins to a particular address. Unlike
     SendMany, this RPC call only allows creating a single output at a time. If
-    neither target_conf, or sat_per_byte are set, then the internal wallet will
+    neither target_conf, or sat_per_vbyte are set, then the internal wallet will
     consult its fee model to determine a fee for the default confirmation
     target.
     */
@@ -82,7 +82,7 @@ service Lightning {
 
     /* lncli: `sendmany`
     SendMany handles a request for a transaction that creates multiple specified
-    outputs in parallel. If neither target_conf, or sat_per_byte are set, then
+    outputs in parallel. If neither target_conf, or sat_per_vbyte are set, then
     the internal wallet will consult its fee model to determine a fee for the
     default confirmation target.
     */
@@ -902,8 +902,12 @@ message EstimateFeeResponse {
     // The total fee in satoshis.
     int64 fee_sat = 1;
 
-    // The fee rate in satoshi/byte.
+    // Deprecated, use sat_per_vbyte.
-    int64 feerate_sat_per_byte = 2;
+    // The fee rate in satoshi/vbyte.
+    int64 feerate_sat_per_byte = 2 [deprecated = true];
+
+    // The fee rate in satoshi/vbyte.
+    uint64 sat_per_vbyte = 3;
 }
 
 message SendManyRequest {
@@ -914,9 +918,14 @@ message SendManyRequest {
     // by.
     int32 target_conf = 3;
 
-    // A manual fee rate set in sat/byte that should be used when crafting the
+    // A manual fee rate set in sat/vbyte that should be used when crafting the
     // transaction.
-    int64 sat_per_byte = 5;
+    uint64 sat_per_vbyte = 4;
+
+    // Deprecated, use sat_per_vbyte.
+    // A manual fee rate set in sat/vbyte that should be used when crafting the
+    // transaction.
+    int64 sat_per_byte = 5 [deprecated = true];
 
     // An optional label for the transaction, limited to 500 characters.
     string label = 6;
@@ -944,9 +953,14 @@ message SendCoinsRequest {
     // by.
     int32 target_conf = 3;
 
-    // A manual fee rate set in sat/byte that should be used when crafting the
+    // A manual fee rate set in sat/vbyte that should be used when crafting the
     // transaction.
-    int64 sat_per_byte = 5;
+    uint64 sat_per_vbyte = 4;
+
+    // Deprecated, use sat_per_vbyte.
+    // A manual fee rate set in sat/vbyte that should be used when crafting the
+    // transaction.
+    int64 sat_per_byte = 5 [deprecated = true];
 
     /*
     If set, then the amount field will be ignored, and lnd will attempt to
@@ -1685,9 +1699,10 @@ message CloseChannelRequest {
     // confirmed by.
     int32 target_conf = 3;
 
-    // A manual fee rate set in sat/byte that should be used when crafting the
+    // Deprecated, use sat_per_vbyte.
+    // A manual fee rate set in sat/vbyte that should be used when crafting the
     // closure transaction.
-    int64 sat_per_byte = 4;
+    int64 sat_per_byte = 4 [deprecated = true];
 
     /*
     An optional address to send funds to in the case of a cooperative close.
@@ -1696,6 +1711,10 @@ message CloseChannelRequest {
     to the upfront shutdown addresss.
     */
     string delivery_address = 5;
+
+    // A manual fee rate set in sat/vbyte that should be used when crafting the
+    // closure transaction.
+    uint64 sat_per_vbyte = 6;
 }
 
 message CloseStatusUpdate {
@@ -1733,6 +1752,10 @@ message ReadyForPsbtFunding {
 }
 
 message OpenChannelRequest {
+    // A manual fee rate set in sat/vbyte that should be used when crafting the
+    // funding transaction.
+    uint64 sat_per_vbyte = 1;
+
     /*
     The pubkey of the node to open a channel with. When using REST, this field
     must be encoded as base64.
@@ -1756,9 +1779,10 @@ message OpenChannelRequest {
     // confirmed by.
     int32 target_conf = 6;
 
-    // A manual fee rate set in sat/byte that should be used when crafting the
+    // Deprecated, use sat_per_vbyte.
+    // A manual fee rate set in sat/vbyte that should be used when crafting the
     // funding transaction.
-    int64 sat_per_byte = 7;
+    int64 sat_per_byte = 7 [deprecated = true];
 
     // Whether this channel should be private, not announced to the greater
     // network.

lnrpc/rpc.swagger.json

@@ -672,7 +672,7 @@
           },
           {
             "name": "sat_per_byte",
-            "description": "A manual fee rate set in sat/byte that should be used when crafting the\nclosure transaction.",
+            "description": "Deprecated, use sat_per_vbyte.\nA manual fee rate set in sat/vbyte that should be used when crafting the\nclosure transaction.",
             "in": "query",
             "required": false,
             "type": "string",
@@ -684,6 +684,14 @@
             "in": "query",
             "required": false,
             "type": "string"
+          },
+          {
+            "name": "sat_per_vbyte",
+            "description": "A manual fee rate set in sat/vbyte that should be used when crafting the\nclosure transaction.",
+            "in": "query",
+            "required": false,
+            "type": "string",
+            "format": "uint64"
           }
         ],
         "tags": [
@@ -1954,7 +1962,7 @@
         ]
       },
       "post": {
-        "summary": "lncli: `sendcoins`\nSendCoins executes a request to send coins to a particular address. Unlike\nSendMany, this RPC call only allows creating a single output at a time. If\nneither target_conf, or sat_per_byte are set, then the internal wallet will\nconsult its fee model to determine a fee for the default confirmation\ntarget.",
+        "summary": "lncli: `sendcoins`\nSendCoins executes a request to send coins to a particular address. Unlike\nSendMany, this RPC call only allows creating a single output at a time. If\nneither target_conf, or sat_per_vbyte are set, then the internal wallet will\nconsult its fee model to determine a fee for the default confirmation\ntarget.",
         "operationId": "SendCoins",
         "responses": {
           "200": {
@@ -2021,7 +2029,7 @@
     },
     "/v1/transactions/many": {
       "post": {
-        "summary": "lncli: `sendmany`\nSendMany handles a request for a transaction that creates multiple specified\noutputs in parallel. If neither target_conf, or sat_per_byte are set, then\nthe internal wallet will consult its fee model to determine a fee for the\ndefault confirmation target.",
+        "summary": "lncli: `sendmany`\nSendMany handles a request for a transaction that creates multiple specified\noutputs in parallel. If neither target_conf, or sat_per_vbyte are set, then\nthe internal wallet will consult its fee model to determine a fee for the\ndefault confirmation target.",
         "operationId": "SendMany",
         "responses": {
           "200": {
@@ -3397,7 +3405,12 @@
         "feerate_sat_per_byte": {
           "type": "string",
           "format": "int64",
-          "description": "The fee rate in satoshi/byte."
+          "description": "Deprecated, use sat_per_vbyte.\nThe fee rate in satoshi/vbyte."
+        },
+        "sat_per_vbyte": {
+          "type": "string",
+          "format": "uint64",
+          "description": "The fee rate in satoshi/vbyte."
         }
       }
     },
@@ -4640,6 +4653,11 @@
     "lnrpcOpenChannelRequest": {
       "type": "object",
       "properties": {
+        "sat_per_vbyte": {
+          "type": "string",
+          "format": "uint64",
+          "description": "A manual fee rate set in sat/vbyte that should be used when crafting the\nfunding transaction."
+        },
         "node_pubkey": {
           "type": "string",
           "format": "byte",
@@ -4667,7 +4685,7 @@
         "sat_per_byte": {
           "type": "string",
           "format": "int64",
-          "description": "A manual fee rate set in sat/byte that should be used when crafting the\nfunding transaction."
+          "description": "Deprecated, use sat_per_vbyte.\nA manual fee rate set in sat/vbyte that should be used when crafting the\nfunding transaction."
         },
         "private": {
           "type": "boolean",
@@ -5344,10 +5362,15 @@
           "format": "int32",
           "description": "The target number of blocks that this transaction should be confirmed\nby."
         },
+        "sat_per_vbyte": {
+          "type": "string",
+          "format": "uint64",
+          "description": "A manual fee rate set in sat/vbyte that should be used when crafting the\ntransaction."
+        },
         "sat_per_byte": {
           "type": "string",
           "format": "int64",
-          "description": "A manual fee rate set in sat/byte that should be used when crafting the\ntransaction."
+          "description": "Deprecated, use sat_per_vbyte.\nA manual fee rate set in sat/vbyte that should be used when crafting the\ntransaction."
         },
         "send_all": {
           "type": "boolean",
@@ -5395,10 +5418,15 @@
           "format": "int32",
           "description": "The target number of blocks that this transaction should be confirmed\nby."
         },
+        "sat_per_vbyte": {
+          "type": "string",
+          "format": "uint64",
+          "description": "A manual fee rate set in sat/vbyte that should be used when crafting the\ntransaction."
+        },
         "sat_per_byte": {
           "type": "string",
           "format": "int64",
-          "description": "A manual fee rate set in sat/byte that should be used when crafting the\ntransaction."
+          "description": "Deprecated, use sat_per_vbyte.\nA manual fee rate set in sat/vbyte that should be used when crafting the\ntransaction."
         },
         "label": {
           "type": "string",

lnrpc/walletrpc/walletkit.pb.go

@@ -839,10 +839,11 @@ type PendingSweep struct {
 	// The value of the output we're attempting to sweep.
 	AmountSat uint32 `protobuf:"varint,3,opt,name=amount_sat,json=amountSat,proto3" json:"amount_sat,omitempty"`
 	//
-	//The fee rate we'll use to sweep the output. The fee rate is only determined
+	//Deprecated, use sat_per_vbyte.
-	//once a sweeping transaction for the output is created, so it's possible for
+	//The fee rate we'll use to sweep the output, expressed in sat/vbyte. The fee
-	//this to be 0 before this.
+	//rate is only determined once a sweeping transaction for the output is
-	SatPerByte uint32 `protobuf:"varint,4,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"`
+	//created, so it's possible for this to be 0 before this.
+	SatPerByte uint32 `protobuf:"varint,4,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"` // Deprecated: Do not use.
 	// The number of broadcast attempts we've made to sweep the output.
 	BroadcastAttempts uint32 `protobuf:"varint,5,opt,name=broadcast_attempts,json=broadcastAttempts,proto3" json:"broadcast_attempts,omitempty"`
 	//
@@ -851,8 +852,16 @@ type PendingSweep struct {
 	NextBroadcastHeight uint32 `protobuf:"varint,6,opt,name=next_broadcast_height,json=nextBroadcastHeight,proto3" json:"next_broadcast_height,omitempty"`
 	// The requested confirmation target for this output.
 	RequestedConfTarget uint32 `protobuf:"varint,8,opt,name=requested_conf_target,json=requestedConfTarget,proto3" json:"requested_conf_target,omitempty"`
-	// The requested fee rate, expressed in sat/byte, for this output.
+	// Deprecated, use requested_sat_per_vbyte.
-	RequestedSatPerByte uint32 `protobuf:"varint,9,opt,name=requested_sat_per_byte,json=requestedSatPerByte,proto3" json:"requested_sat_per_byte,omitempty"`
+	// The requested fee rate, expressed in sat/vbyte, for this output.
+	RequestedSatPerByte uint32 `protobuf:"varint,9,opt,name=requested_sat_per_byte,json=requestedSatPerByte,proto3" json:"requested_sat_per_byte,omitempty"` // Deprecated: Do not use.
+	//
+	//The fee rate we'll use to sweep the output, expressed in sat/vbyte. The fee
+	//rate is only determined once a sweeping transaction for the output is
+	//created, so it's possible for this to be 0 before this.
+	SatPerVbyte uint64 `protobuf:"varint,10,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"`
+	// The requested fee rate, expressed in sat/vbyte, for this output.
+	RequestedSatPerVbyte uint64 `protobuf:"varint,11,opt,name=requested_sat_per_vbyte,json=requestedSatPerVbyte,proto3" json:"requested_sat_per_vbyte,omitempty"`
 	//
 	//Whether this input must be force-swept. This means that it is swept even
 	//if it has a negative yield.
@@ -908,6 +917,7 @@ func (m *PendingSweep) GetAmountSat() uint32 {
 	return 0
 }
 
+// Deprecated: Do not use.
 func (m *PendingSweep) GetSatPerByte() uint32 {
 	if m != nil {
 		return m.SatPerByte
@@ -936,6 +946,7 @@ func (m *PendingSweep) GetRequestedConfTarget() uint32 {
 	return 0
 }
 
+// Deprecated: Do not use.
 func (m *PendingSweep) GetRequestedSatPerByte() uint32 {
 	if m != nil {
 		return m.RequestedSatPerByte
@@ -943,6 +954,20 @@ func (m *PendingSweep) GetRequestedSatPerByte() uint32 {
 	return 0
 }
 
+func (m *PendingSweep) GetSatPerVbyte() uint64 {
+	if m != nil {
+		return m.SatPerVbyte
+	}
+	return 0
+}
+
+func (m *PendingSweep) GetRequestedSatPerVbyte() uint64 {
+	if m != nil {
+		return m.RequestedSatPerVbyte
+	}
+	return 0
+}
+
 func (m *PendingSweep) GetForce() bool {
 	if m != nil {
 		return m.Force
@@ -1028,13 +1053,18 @@ type BumpFeeRequest struct {
 	// The target number of blocks that the input should be spent within.
 	TargetConf uint32 `protobuf:"varint,2,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"`
 	//
-	//The fee rate, expressed in sat/byte, that should be used to spend the input
+	//Deprecated, use sat_per_vbyte.
+	//The fee rate, expressed in sat/vbyte, that should be used to spend the input
 	//with.
-	SatPerByte uint32 `protobuf:"varint,3,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"`
+	SatPerByte uint32 `protobuf:"varint,3,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"` // Deprecated: Do not use.
 	//
 	//Whether this input must be force-swept. This means that it is swept even
 	//if it has a negative yield.
-	Force                bool     `protobuf:"varint,4,opt,name=force,proto3" json:"force,omitempty"`
+	Force bool `protobuf:"varint,4,opt,name=force,proto3" json:"force,omitempty"`
+	//
+	//The fee rate, expressed in sat/vbyte, that should be used to spend the input
+	//with.
+	SatPerVbyte          uint64   `protobuf:"varint,5,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1079,6 +1109,7 @@ func (m *BumpFeeRequest) GetTargetConf() uint32 {
 	return 0
 }
 
+// Deprecated: Do not use.
 func (m *BumpFeeRequest) GetSatPerByte() uint32 {
 	if m != nil {
 		return m.SatPerByte
@@ -1093,6 +1124,13 @@ func (m *BumpFeeRequest) GetForce() bool {
 	return false
 }
 
+func (m *BumpFeeRequest) GetSatPerVbyte() uint64 {
+	if m != nil {
+		return m.SatPerVbyte
+	}
+	return 0
+}
+
 type BumpFeeResponse struct {
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -1464,7 +1502,7 @@ type FundPsbtRequest_TargetConf struct {
 }
 
 type FundPsbtRequest_SatPerVbyte struct {
-	SatPerVbyte uint32 `protobuf:"varint,4,opt,name=sat_per_vbyte,json=satPerVbyte,proto3,oneof"`
+	SatPerVbyte uint64 `protobuf:"varint,4,opt,name=sat_per_vbyte,json=satPerVbyte,proto3,oneof"`
 }
 
 func (*FundPsbtRequest_TargetConf) isFundPsbtRequest_Fees() {}
@@ -1485,7 +1523,7 @@ func (m *FundPsbtRequest) GetTargetConf() uint32 {
 	return 0
 }
 
-func (m *FundPsbtRequest) GetSatPerVbyte() uint32 {
+func (m *FundPsbtRequest) GetSatPerVbyte() uint64 {
 	if x, ok := m.GetFees().(*FundPsbtRequest_SatPerVbyte); ok {
 		return x.SatPerVbyte
 	}
@@ -1885,123 +1923,125 @@ func init() {
 func init() { proto.RegisterFile("walletrpc/walletkit.proto", fileDescriptor_6cc6942ac78249e5) }
 
 var fileDescriptor_6cc6942ac78249e5 = []byte{
-	// 1851 bytes of a gzipped FileDescriptorProto
+	// 1887 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x5f, 0x73, 0xe2, 0xc8,
-	0x11, 0x5f, 0x0c, 0xc6, 0xd0, 0x80, 0x8d, 0x07, 0xbc, 0x66, 0x59, 0xef, 0xd9, 0xab, 0x4b, 0x72,
+	0x11, 0x5f, 0xfe, 0x98, 0x85, 0x16, 0xd8, 0x78, 0xc0, 0x6b, 0x96, 0xf5, 0x9e, 0xbd, 0xba, 0x24,
-	0x4e, 0xee, 0x0e, 0x57, 0xbc, 0x75, 0x97, 0x3d, 0x27, 0x95, 0x8a, 0x8d, 0xe5, 0xc2, 0x05, 0x06,
+	0xe7, 0xe4, 0xee, 0x70, 0xc5, 0x57, 0x7b, 0xb7, 0xb7, 0x49, 0xa5, 0x62, 0x63, 0xb9, 0x70, 0x81,
-	0x67, 0xc0, 0xeb, 0xda, 0xe4, 0x41, 0x25, 0xd0, 0xd8, 0x56, 0x19, 0x24, 0x9d, 0x34, 0x18, 0xc8,
+	0xc1, 0x11, 0x78, 0x5d, 0x9b, 0x3c, 0xa8, 0x04, 0x1a, 0xdb, 0x2a, 0x83, 0xa4, 0x93, 0x06, 0x03,
-	0xd3, 0x7d, 0x8a, 0x54, 0x5d, 0x55, 0xbe, 0xc3, 0x3d, 0xe4, 0x35, 0x1f, 0x2e, 0x35, 0x7f, 0x10,
+	0x79, 0xba, 0xaf, 0x91, 0xaa, 0x7c, 0x87, 0x7b, 0xc8, 0x6b, 0x2a, 0x9f, 0x2c, 0x0f, 0xa9, 0xf9,
-	0x23, 0x81, 0x6f, 0x93, 0x4a, 0x9e, 0xd0, 0xf4, 0xaf, 0xbb, 0xa7, 0xa7, 0xbb, 0x67, 0xba, 0x1b,
+	0x83, 0x34, 0x12, 0xf8, 0x2e, 0xa9, 0xdc, 0x93, 0x51, 0xff, 0xba, 0x7b, 0xfa, 0xdf, 0x4c, 0x77,
-	0x78, 0x35, 0x31, 0x87, 0x43, 0x42, 0x7d, 0x6f, 0x70, 0x24, 0xbe, 0x1e, 0x6d, 0x5a, 0xf3, 0x7c,
+	0x1b, 0x5e, 0xce, 0xcc, 0xf1, 0x18, 0x13, 0xdf, 0x1b, 0x1d, 0xf1, 0x5f, 0x0f, 0x36, 0x69, 0x78,
-	0x97, 0xba, 0x28, 0x1b, 0x42, 0xd5, 0xac, 0xef, 0x0d, 0x04, 0xb5, 0x5a, 0x0e, 0xec, 0x7b, 0x87,
+	0xbe, 0x4b, 0x5c, 0x54, 0x08, 0xa1, 0x7a, 0xc1, 0xf7, 0x46, 0x9c, 0x5a, 0xaf, 0x06, 0xf6, 0x9d,
-	0xb1, 0xb3, 0x5f, 0xe2, 0x0b, 0xaa, 0xd6, 0x06, 0xd4, 0xb2, 0x03, 0x7a, 0xe3, 0x04, 0x1e, 0x71,
+	0x43, 0xd9, 0xe9, 0x5f, 0xec, 0x73, 0xaa, 0xda, 0x05, 0xd4, 0xb1, 0x03, 0x72, 0xed, 0x04, 0x1e,
-	0x28, 0x26, 0xdf, 0x8f, 0x49, 0x40, 0xd1, 0x6b, 0xc8, 0x8e, 0x6c, 0xc7, 0x18, 0xb8, 0xce, 0x5d,
+	0x76, 0x88, 0x8e, 0xbf, 0x9b, 0xe2, 0x80, 0xa0, 0x57, 0x50, 0x98, 0xd8, 0x8e, 0x31, 0x72, 0x9d,
-	0x50, 0x49, 0x1c, 0x24, 0x0e, 0xd7, 0x71, 0x66, 0x64, 0x3b, 0x75, 0xb6, 0xe6, 0xa0, 0x39, 0x95,
+	0xdb, 0xa0, 0x96, 0x3a, 0x48, 0x1d, 0x6e, 0xe8, 0xf9, 0x89, 0xed, 0x34, 0xe9, 0x37, 0x03, 0xcd,
-	0xe0, 0x9a, 0x04, 0xcd, 0x29, 0x07, 0xb5, 0xf7, 0x50, 0x8a, 0xe8, 0x0b, 0x3c, 0xd7, 0x09, 0x08,
+	0xb9, 0x00, 0xd3, 0x02, 0x34, 0xe7, 0x0c, 0x54, 0xdf, 0x41, 0x25, 0xa6, 0x2f, 0xf0, 0x5c, 0x27,
-	0x7a, 0x0b, 0xeb, 0x63, 0x3a, 0x75, 0x99, 0xb2, 0xe4, 0x61, 0xee, 0x38, 0x57, 0x1b, 0x32, 0x53,
+	0xc0, 0xe8, 0x0d, 0x6c, 0x4c, 0xc9, 0xdc, 0xa5, 0xca, 0x32, 0x87, 0xca, 0xb1, 0xd2, 0x18, 0x53,
-	0x6a, 0x37, 0x74, 0xea, 0x62, 0x81, 0x68, 0x3f, 0x24, 0x00, 0xb5, 0x88, 0x19, 0x90, 0xce, 0x98,
+	0x53, 0x1a, 0xd7, 0x64, 0xee, 0xea, 0x1c, 0x51, 0xbf, 0x4f, 0x01, 0xea, 0x60, 0x33, 0xc0, 0xbd,
-	0x7a, 0xe3, 0xd0, 0x94, 0x4d, 0x58, 0xb3, 0x2d, 0x6e, 0x43, 0x1e, 0xaf, 0xd9, 0x16, 0xfa, 0x12,
+	0x29, 0xf1, 0xa6, 0xa1, 0x29, 0x9b, 0x90, 0xb6, 0x2d, 0x66, 0x43, 0x51, 0x4f, 0xdb, 0x16, 0xfa,
-	0x32, 0xee, 0x98, 0x7a, 0xae, 0xed, 0x50, 0xbe, 0x79, 0xee, 0x78, 0x4b, 0x2a, 0xeb, 0x8c, 0xe9,
+	0x1c, 0xf2, 0xee, 0x94, 0x78, 0xae, 0xed, 0x10, 0x76, 0xb8, 0x72, 0xbc, 0x25, 0x94, 0xf5, 0xa6,
-	0x35, 0x23, 0xe3, 0x90, 0x01, 0x7d, 0x0d, 0x88, 0x4c, 0x3d, 0xdb, 0x37, 0xa9, 0xed, 0x3a, 0x46,
+	0xe4, 0x8a, 0x92, 0xf5, 0x90, 0x01, 0x7d, 0x09, 0x08, 0xcf, 0x3d, 0xdb, 0x37, 0x89, 0xed, 0x3a,
-	0x40, 0x06, 0xae, 0x63, 0x05, 0x95, 0xe4, 0x41, 0xe2, 0x30, 0x85, 0xb7, 0x17, 0x48, 0x57, 0x00,
+	0x46, 0x80, 0x47, 0xae, 0x63, 0x05, 0xb5, 0xcc, 0x41, 0xea, 0x30, 0xab, 0x6f, 0x47, 0x48, 0x9f,
-	0xda, 0x37, 0x50, 0x8a, 0x58, 0x20, 0x8d, 0xff, 0x0c, 0x60, 0xc1, 0xcb, 0x4d, 0x49, 0x61, 0x85,
+	0x03, 0xea, 0x5b, 0xa8, 0xc4, 0x2c, 0x10, 0xc6, 0x7f, 0x02, 0x10, 0xf1, 0x32, 0x53, 0xb2, 0xba,
-	0xa2, 0x75, 0xa1, 0x8c, 0xc9, 0xf0, 0xff, 0x6b, 0xba, 0xb6, 0x0b, 0x3b, 0x31, 0xa5, 0xc2, 0x1a,
+	0x44, 0x51, 0xfb, 0x50, 0xd5, 0xf1, 0xf8, 0xe7, 0x35, 0x5d, 0xdd, 0x85, 0x9d, 0x84, 0x52, 0x6e,
-	0xed, 0xcf, 0x90, 0x6e, 0x92, 0x19, 0x26, 0xdf, 0xa3, 0x43, 0x28, 0x3e, 0x92, 0x99, 0x71, 0x67,
+	0x8d, 0xfa, 0x27, 0xc8, 0xb5, 0xf1, 0x42, 0xc7, 0xdf, 0xa1, 0x43, 0x28, 0x3f, 0xe0, 0x85, 0x71,
-	0x3b, 0xf7, 0xc4, 0x37, 0x3c, 0x9f, 0xe9, 0x15, 0xc1, 0xda, 0x7c, 0x24, 0xb3, 0x0b, 0x4e, 0xbe,
+	0x6b, 0x3b, 0x77, 0xd8, 0x37, 0x3c, 0x9f, 0xea, 0xe5, 0xc9, 0xda, 0x7c, 0xc0, 0x8b, 0x73, 0x46,
-	0x66, 0x54, 0xf4, 0x06, 0x80, 0x73, 0x9a, 0x23, 0x7b, 0x38, 0x93, 0x31, 0xcb, 0x32, 0x1e, 0x4e,
+	0xbe, 0xa2, 0x54, 0xf4, 0x1a, 0x80, 0x71, 0x9a, 0x13, 0x7b, 0xbc, 0x10, 0x39, 0x2b, 0x50, 0x1e,
-	0xd0, 0x0a, 0x90, 0x3b, 0xb5, 0x2c, 0x5f, 0xda, 0xad, 0x69, 0x90, 0x17, 0x4b, 0x79, 0x7e, 0x04,
+	0x46, 0x50, 0x4b, 0xa0, 0x9c, 0x58, 0x96, 0x2f, 0xec, 0x56, 0x55, 0x28, 0xf2, 0x4f, 0xe1, 0x3f,
-	0x29, 0xd3, 0xb2, 0x7c, 0xae, 0x3b, 0x8b, 0xf9, 0xb7, 0x76, 0x02, 0xb9, 0x9e, 0x6f, 0x3a, 0x81,
+	0x82, 0xac, 0x69, 0x59, 0x3e, 0xd3, 0x5d, 0xd0, 0xd9, 0x6f, 0xf5, 0x3d, 0x28, 0x03, 0xdf, 0x74,
-	0x39, 0x60, 0x2e, 0x40, 0x3b, 0x90, 0xa6, 0x53, 0xe3, 0x81, 0x4c, 0xe5, 0x71, 0xd7, 0xe9, 0xb4,
+	0x02, 0x73, 0x44, 0x43, 0x80, 0x76, 0x20, 0x47, 0xe6, 0xc6, 0x3d, 0x9e, 0x0b, 0x77, 0x37, 0xc8,
-	0x41, 0xa6, 0xa8, 0x0c, 0xeb, 0x43, 0xb3, 0x4f, 0x86, 0x7c, 0xcb, 0x2c, 0x16, 0x0b, 0xed, 0x5b,
+	0xbc, 0x85, 0xe7, 0xa8, 0x0a, 0x1b, 0x63, 0x73, 0x88, 0xc7, 0xec, 0xc8, 0x82, 0xce, 0x3f, 0xd4,
-	0xd8, 0xba, 0x1e, 0xf7, 0x87, 0x76, 0xf0, 0x10, 0x6e, 0xf1, 0x39, 0x14, 0x3c, 0x41, 0x32, 0x88,
+	0xaf, 0x61, 0xeb, 0x6a, 0x3a, 0x1c, 0xdb, 0xc1, 0x7d, 0x78, 0xc4, 0xa7, 0x50, 0xf2, 0x38, 0xc9,
-	0xef, 0xbb, 0xf3, 0xbd, 0xf2, 0x92, 0xa8, 0x33, 0x9a, 0xf6, 0xaf, 0x04, 0xa0, 0x2e, 0x71, 0x2c,
+	0xc0, 0xbe, 0xef, 0x2e, 0xcf, 0x2a, 0x0a, 0xa2, 0x46, 0x69, 0xea, 0x3f, 0x53, 0x80, 0xfa, 0xd8,
-	0xe1, 0x90, 0x60, 0xee, 0xe6, 0x3d, 0x80, 0xc0, 0xa4, 0x86, 0x47, 0x7c, 0xe3, 0x71, 0xc2, 0x05,
+	0xb1, 0x78, 0x40, 0x82, 0x65, 0x98, 0xf7, 0x00, 0x02, 0x93, 0x18, 0x1e, 0xf6, 0x8d, 0x87, 0x19,
-	0x93, 0x38, 0x13, 0x98, 0xf4, 0x9a, 0xf8, 0xcd, 0x09, 0x3a, 0x84, 0x0d, 0x57, 0xf0, 0x57, 0xd6,
+	0x13, 0xcc, 0xe8, 0xf9, 0xc0, 0x24, 0x57, 0xd8, 0x6f, 0xcf, 0xd0, 0x21, 0x3c, 0x77, 0x39, 0x7f,
-	0x78, 0xee, 0x6d, 0xd6, 0xe4, 0x45, 0xa8, 0xf5, 0xa6, 0x9d, 0x31, 0xc5, 0x73, 0x78, 0x61, 0x6c,
+	0x2d, 0xcd, 0x6a, 0x6f, 0xb3, 0x21, 0x2e, 0x42, 0x63, 0x30, 0xef, 0x4d, 0x89, 0xbe, 0x84, 0x23,
-	0x52, 0x31, 0x36, 0x7a, 0x15, 0x52, 0xb1, 0xab, 0xf0, 0x25, 0x6c, 0xb3, 0x3c, 0xb7, 0x8c, 0xb1,
+	0x63, 0x33, 0x92, 0xb1, 0xf1, 0xab, 0x90, 0x4d, 0x5c, 0x85, 0xcf, 0x61, 0x9b, 0xd6, 0xb9, 0x65,
-	0xc3, 0x18, 0x6c, 0x7f, 0x44, 0xac, 0xca, 0xfa, 0x41, 0xe2, 0x30, 0x83, 0x8b, 0x1c, 0xb8, 0x59,
+	0x4c, 0x1d, 0xca, 0x60, 0xfb, 0x13, 0x6c, 0xd5, 0x36, 0x0e, 0x52, 0x87, 0x79, 0xbd, 0xcc, 0x80,
-	0xd0, 0xb5, 0xaf, 0xa0, 0x14, 0xb1, 0x5e, 0x1e, 0x7d, 0x07, 0xd2, 0xbe, 0x39, 0x31, 0x68, 0xe8,
+	0xeb, 0x88, 0xae, 0x7e, 0x01, 0x95, 0x98, 0xf5, 0xc2, 0xf5, 0x1d, 0xc8, 0xf9, 0xe6, 0xcc, 0x20,
-	0x3a, 0xdf, 0x9c, 0xf4, 0xa6, 0xda, 0x37, 0x80, 0xf4, 0x80, 0xda, 0x23, 0x93, 0x92, 0x0b, 0x42,
+	0x61, 0xe8, 0x7c, 0x73, 0x36, 0x98, 0xab, 0x6f, 0x01, 0x69, 0x01, 0xb1, 0x27, 0x26, 0xc1, 0xe7,
-	0xe6, 0x67, 0xdd, 0x87, 0x1c, 0x53, 0x68, 0x50, 0xd3, 0xbf, 0x27, 0xf3, 0x68, 0x03, 0x23, 0xf5,
+	0x18, 0x2f, 0x7d, 0xdd, 0x07, 0x85, 0x2a, 0x34, 0x88, 0xe9, 0xdf, 0xe1, 0x65, 0xb6, 0x81, 0x92,
-	0x38, 0x45, 0x7b, 0x07, 0xa5, 0x88, 0x98, 0xdc, 0xe4, 0x67, 0x7d, 0xa4, 0xfd, 0x98, 0x84, 0xfc,
+	0x06, 0x8c, 0xa2, 0x7e, 0x05, 0x95, 0x98, 0x98, 0x38, 0xe4, 0x47, 0x63, 0xa4, 0xfe, 0x3b, 0x03,
-	0x35, 0x71, 0x2c, 0xdb, 0xb9, 0xef, 0x4e, 0x08, 0xf1, 0x22, 0x99, 0x9a, 0xf8, 0xd4, 0x25, 0xfb,
+	0xc5, 0x2b, 0xec, 0x58, 0xb6, 0x73, 0xd7, 0x9f, 0x61, 0xec, 0xc5, 0x2a, 0x35, 0xf5, 0x53, 0x97,
-	0x0e, 0xf2, 0x13, 0x9b, 0x3a, 0x24, 0x08, 0x0c, 0x3a, 0xf3, 0x08, 0x8f, 0xf5, 0xe6, 0xf1, 0xcb,
+	0xec, 0x5b, 0x28, 0xce, 0x6c, 0xe2, 0xe0, 0x20, 0x30, 0xc8, 0xc2, 0xc3, 0x2c, 0xd7, 0x9b, 0xc7,
-	0x5a, 0xf8, 0x0a, 0xd5, 0x6e, 0x05, 0xdc, 0x9b, 0x79, 0x04, 0xe7, 0x26, 0x8b, 0x05, 0xcb, 0x4b,
+	0x2f, 0x1a, 0xe1, 0x2b, 0xd4, 0xb8, 0xe1, 0xf0, 0x60, 0xe1, 0x61, 0x5d, 0x99, 0x45, 0x1f, 0xb4,
-	0x73, 0xe4, 0x8e, 0x1d, 0x6a, 0x04, 0x26, 0xe5, 0x7e, 0x2f, 0xe0, 0xac, 0xa0, 0x74, 0x4d, 0x8a,
+	0x2e, 0xcd, 0x89, 0x3b, 0x75, 0x88, 0x11, 0x98, 0x84, 0xc5, 0xbd, 0xa4, 0x17, 0x38, 0xa5, 0x6f,
-	0x0e, 0x20, 0x3f, 0xb7, 0xba, 0x3f, 0xa3, 0x84, 0xbb, 0xbf, 0x80, 0x41, 0xd8, 0x7d, 0x36, 0xa3,
+	0x12, 0xf4, 0x0b, 0x28, 0x2e, 0xad, 0x1e, 0x2e, 0x08, 0x66, 0xe1, 0x2f, 0x9d, 0xa6, 0x6b, 0x29,
-	0x84, 0x5d, 0xf0, 0xbe, 0xef, 0x9a, 0xd6, 0xc0, 0x0c, 0xa8, 0x61, 0x52, 0x4a, 0x46, 0x1e, 0x0d,
+	0x1d, 0xb8, 0xed, 0xa7, 0x0b, 0x82, 0xe9, 0x25, 0x1f, 0xfa, 0xae, 0x69, 0x8d, 0xcc, 0x80, 0x18,
-	0x78, 0x04, 0x0a, 0x78, 0x3b, 0x44, 0x4e, 0x25, 0x80, 0x8e, 0x61, 0xc7, 0x21, 0x53, 0x6a, 0x2c,
+	0x26, 0x21, 0x78, 0xe2, 0x91, 0x80, 0x65, 0xa1, 0xa4, 0x6f, 0x87, 0xc8, 0x89, 0x00, 0xd0, 0x31,
-	0x64, 0x1e, 0x88, 0x7d, 0xff, 0x40, 0x2b, 0x69, 0x2e, 0x51, 0x62, 0xe0, 0xd9, 0x1c, 0x6b, 0x70,
+	0xec, 0x38, 0x78, 0x4e, 0x8c, 0x48, 0xe6, 0x1e, 0xdb, 0x77, 0xf7, 0xa4, 0x96, 0x63, 0x12, 0x15,
-	0x88, 0xc9, 0xf8, 0xc2, 0xfb, 0xc4, 0x32, 0x54, 0xe7, 0x67, 0x84, 0x4c, 0x08, 0xd6, 0xc3, 0x28,
+	0x0a, 0x9e, 0x2e, 0xb1, 0x16, 0x83, 0xa8, 0x8c, 0xcf, 0x33, 0x80, 0x2d, 0x43, 0x4e, 0x40, 0x9e,
-	0xa0, 0x77, 0xf0, 0x72, 0x21, 0x13, 0x39, 0x42, 0x36, 0x26, 0xd4, 0x5d, 0x9c, 0xa5, 0x0c, 0xeb,
+	0xcb, 0x84, 0x60, 0x33, 0xcc, 0x04, 0xfa, 0x06, 0x5e, 0x44, 0x32, 0x31, 0x37, 0x0a, 0xa1, 0x1b,
-	0x77, 0xae, 0x3f, 0x20, 0x95, 0x0d, 0x9e, 0x40, 0x62, 0xa1, 0xbd, 0x84, 0xb2, 0x1a, 0x9a, 0x79,
+	0x91, 0x60, 0x3f, 0xf2, 0x47, 0x85, 0xd2, 0x92, 0xfd, 0x91, 0xf1, 0x03, 0x7b, 0x71, 0x14, 0xee,
-	0xd6, 0x6b, 0xb7, 0xb0, 0x13, 0xa3, 0xcb, 0x50, 0xff, 0x11, 0x36, 0x3d, 0x01, 0x18, 0x01, 0x47,
+	0xf2, 0x07, 0x4a, 0x42, 0x6f, 0x61, 0x77, 0x55, 0x39, 0xe7, 0x56, 0x18, 0x77, 0x35, 0xa1, 0x99,
-	0xe4, 0x9b, 0xbb, 0xab, 0x04, 0x44, 0x95, 0xc4, 0x05, 0x4f, 0xd5, 0xa3, 0xfd, 0x3d, 0x01, 0x9b,
+	0x8b, 0x55, 0x61, 0xe3, 0xd6, 0xf5, 0x47, 0xb8, 0xf6, 0x9c, 0xd5, 0x28, 0xff, 0x50, 0x5f, 0x40,
-	0x67, 0xe3, 0x91, 0xa7, 0x64, 0xdd, 0x7f, 0x95, 0x0e, 0xfb, 0x90, 0x13, 0x0e, 0xe2, 0xce, 0xe2,
+	0x55, 0xce, 0xfe, 0xf2, 0x62, 0xa9, 0x37, 0xb0, 0x93, 0xa0, 0x8b, 0x6a, 0xfa, 0x03, 0x6c, 0x7a,
-	0xd9, 0x50, 0xc0, 0x20, 0x48, 0xcc, 0x45, 0x4b, 0x51, 0x4d, 0x2e, 0x45, 0x35, 0xf4, 0x44, 0x4a,
+	0x1c, 0x30, 0x02, 0x86, 0x88, 0x67, 0x7d, 0x57, 0xca, 0xb9, 0x2c, 0xa9, 0x97, 0x3c, 0x59, 0x8f,
-	0xf5, 0xc4, 0x36, 0x6c, 0x85, 0x76, 0xc9, 0xb7, 0xf0, 0x6b, 0xd8, 0x66, 0xd5, 0x26, 0xe2, 0x19,
+	0xfa, 0xaf, 0x14, 0x6c, 0x9e, 0x4e, 0x27, 0x9e, 0x54, 0xd8, 0xff, 0x53, 0xc5, 0xed, 0x83, 0xc2,
-	0x54, 0x81, 0x8d, 0x27, 0xe2, 0xf7, 0xdd, 0x80, 0x70, 0x63, 0x33, 0x78, 0xbe, 0xd4, 0x7e, 0x58,
+	0xe3, 0xcf, 0x72, 0xc1, 0x0a, 0xae, 0xa4, 0x03, 0x27, 0xd1, 0x0c, 0xac, 0x14, 0x4e, 0x66, 0x6d,
-	0x13, 0xd5, 0x2e, 0xe6, 0xb1, 0x16, 0x94, 0xe8, 0xe2, 0x2d, 0x33, 0x2c, 0x42, 0x4d, 0x7b, 0x18,
+	0xe1, 0x84, 0xd1, 0xc8, 0x4a, 0xd1, 0x58, 0x0d, 0xff, 0xc6, 0x4a, 0xf8, 0xd5, 0x6d, 0xd8, 0x0a,
-	0xc8, 0x93, 0xbe, 0x92, 0x27, 0x55, 0x5e, 0xbb, 0x73, 0xc1, 0xd0, 0x78, 0x81, 0x11, 0x5d, 0xa2,
+	0xed, 0x17, 0xcf, 0xf2, 0x97, 0xb0, 0x4d, 0x1b, 0x5f, 0x2c, 0x82, 0xa8, 0x06, 0xcf, 0x1f, 0xb1,
-	0xa2, 0x5b, 0xd8, 0x52, 0xb5, 0xd9, 0x56, 0x20, 0x1f, 0xfb, 0xaf, 0x94, 0x00, 0x2c, 0x5b, 0xa1,
+	0x3f, 0x74, 0x03, 0xcc, 0x9c, 0xca, 0xeb, 0xcb, 0x4f, 0xf5, 0xfb, 0x34, 0x6f, 0xbc, 0x89, 0xc8,
-	0x6e, 0x70, 0x79, 0xce, 0x94, 0x6f, 0x2a, 0x6a, 0x2e, 0xad, 0xa0, 0xfa, 0x1d, 0x6c, 0x46, 0x79,
+	0x76, 0xa0, 0x42, 0xa2, 0x67, 0xd5, 0xb0, 0x30, 0x31, 0xed, 0x71, 0x20, 0x22, 0xf2, 0x52, 0x44,
-	0xd0, 0x17, 0xcb, 0x5b, 0xb1, 0x58, 0x67, 0xe3, 0xa2, 0x67, 0x19, 0x48, 0x8b, 0x5c, 0xd0, 0x4c,
+	0x44, 0x7a, 0x78, 0xcf, 0x38, 0x43, 0xeb, 0x99, 0x8e, 0xc8, 0x0a, 0x15, 0xdd, 0xc0, 0x96, 0xac,
-	0xd8, 0x6d, 0xb1, 0x77, 0x4d, 0xd1, 0x34, 0xf7, 0x1b, 0x82, 0x14, 0x9d, 0x86, 0x05, 0x8b, 0x7f,
+	0xcd, 0xb6, 0x02, 0xd1, 0x77, 0xbe, 0x90, 0x12, 0xb5, 0x6a, 0x85, 0x7c, 0xc0, 0xc5, 0x19, 0x55,
-	0xaf, 0x7e, 0xc0, 0xd1, 0x1e, 0x64, 0xdd, 0x27, 0xe2, 0x4f, 0x7c, 0x5b, 0x86, 0x2f, 0x83, 0x17,
+	0xbe, 0x29, 0xa9, 0xb9, 0xb0, 0x82, 0xfa, 0xb7, 0xb0, 0x19, 0xe7, 0x41, 0x9f, 0xad, 0x1e, 0x45,
-	0x04, 0xad, 0x0a, 0x95, 0xe5, 0x2d, 0x64, 0xc0, 0x7e, 0x4a, 0xc0, 0xd6, 0xc5, 0xd8, 0xb1, 0xae,
+	0x6b, 0xa2, 0x90, 0x14, 0x3d, 0xcd, 0x43, 0x8e, 0xd7, 0x8c, 0x6a, 0xc2, 0x6e, 0x87, 0x3e, 0xb1,
-	0x83, 0x7e, 0x58, 0x26, 0xcb, 0x90, 0xf2, 0x82, 0xbe, 0xc8, 0xac, 0x7c, 0xe3, 0x05, 0xe6, 0x2b,
+	0x92, 0xa6, 0x65, 0xdc, 0x10, 0x64, 0xc9, 0x3c, 0xec, 0x9d, 0xec, 0xf7, 0xfa, 0x5e, 0x82, 0xf6,
-	0xf4, 0x6b, 0x48, 0xfa, 0xe6, 0x44, 0xba, 0x6e, 0x47, 0x71, 0x5d, 0x6f, 0xda, 0x23, 0x23, 0x6f,
+	0xa0, 0xe0, 0x3e, 0x62, 0x7f, 0xe6, 0xdb, 0x22, 0xcd, 0x79, 0x3d, 0x22, 0xa8, 0x75, 0xa8, 0xad,
-	0x68, 0x52, 0xd2, 0x78, 0x81, 0x19, 0x0f, 0x7a, 0x1b, 0xcd, 0x38, 0x9e, 0x4f, 0x8d, 0x44, 0x24,
+	0x1e, 0x21, 0x12, 0xf6, 0x43, 0x0a, 0xb6, 0xce, 0xa7, 0x8e, 0x75, 0x15, 0x0c, 0xc3, 0x8e, 0x5d,
-	0xe7, 0x7e, 0x01, 0x85, 0x79, 0xce, 0x3d, 0x2d, 0x9e, 0x92, 0x46, 0x02, 0xe7, 0x44, 0xda, 0x7d,
+	0x85, 0xac, 0x17, 0x0c, 0x79, 0x05, 0x16, 0x5b, 0xcf, 0x74, 0xf6, 0x85, 0x7e, 0x0d, 0x19, 0xdf,
-	0x60, 0xc4, 0x33, 0x80, 0x0c, 0x95, 0xba, 0xcf, 0xd2, 0x90, 0xba, 0x23, 0x24, 0xd0, 0xfe, 0x91,
+	0x9c, 0x89, 0xd0, 0xed, 0x48, 0xa1, 0x1b, 0xcc, 0x07, 0x78, 0xe2, 0x8d, 0x4d, 0x82, 0x5b, 0xcf,
-	0x80, 0xe2, 0xc2, 0x62, 0x99, 0x31, 0xfb, 0x90, 0xbb, 0x1b, 0x3b, 0x16, 0xb1, 0x8c, 0x85, 0xe5,
+	0x74, 0xca, 0x83, 0xde, 0xc4, 0x2b, 0x93, 0xd5, 0x5d, 0x2b, 0x95, 0xa8, 0xcd, 0x44, 0x7d, 0xd1,
-	0x18, 0x04, 0x89, 0x31, 0xa2, 0x1a, 0x94, 0x06, 0x0f, 0xa6, 0x73, 0x4f, 0x0c, 0x51, 0x5d, 0x0c,
+	0xea, 0xcb, 0xb6, 0x52, 0xb1, 0x0a, 0x3b, 0x05, 0xc8, 0x13, 0xa1, 0xfb, 0x34, 0x07, 0xd9, 0x5b,
-	0xdb, 0xb1, 0xc8, 0x54, 0x56, 0xde, 0x6d, 0x01, 0x89, 0x42, 0x70, 0xc9, 0x00, 0xf4, 0x3b, 0xc8,
+	0x8c, 0x03, 0xf5, 0xef, 0x29, 0x28, 0x47, 0x16, 0x8b, 0x8a, 0xd9, 0x07, 0xe5, 0x76, 0xea, 0x58,
-	0x0f, 0xdd, 0xc1, 0x23, 0xb1, 0x0c, 0xd1, 0x26, 0x25, 0xf9, 0x95, 0x2d, 0x2b, 0xc7, 0x66, 0xad,
+	0xd8, 0x32, 0x22, 0xcb, 0x75, 0xe0, 0x24, 0xca, 0x88, 0x1a, 0x50, 0x19, 0xdd, 0x9b, 0xce, 0x1d,
-	0x12, 0x6f, 0x4e, 0x70, 0x4e, 0x70, 0xde, 0xf0, 0xae, 0xe9, 0xa7, 0x04, 0xc0, 0xc2, 0x23, 0xe8,
+	0x36, 0x78, 0xa3, 0x33, 0x6c, 0xc7, 0xc2, 0x73, 0x31, 0x04, 0x6c, 0x73, 0x88, 0xf7, 0xa4, 0x0b,
-	0x0b, 0x48, 0xdb, 0x0e, 0x2f, 0x76, 0xe2, 0xd2, 0x2f, 0xdd, 0x53, 0x09, 0xa3, 0x3f, 0xc4, 0xcb,
+	0x0a, 0xa0, 0x6f, 0xa0, 0x38, 0x76, 0x47, 0x0f, 0xd8, 0x32, 0xf8, 0xc4, 0x96, 0x61, 0x57, 0xbb,
-	0xa2, 0xb6, 0xd2, 0xc5, 0x35, 0x59, 0xad, 0x74, 0x87, 0xfa, 0xb3, 0xb0, 0x54, 0x56, 0x4f, 0x20,
+	0x2a, 0xb9, 0x4d, 0xa7, 0x36, 0x36, 0x27, 0xe9, 0x0a, 0xe7, 0xbc, 0x66, 0x03, 0xdc, 0x0f, 0x29,
-	0xaf, 0x02, 0xa8, 0x08, 0xc9, 0x47, 0x32, 0x93, 0x45, 0x9b, 0x7d, 0xb2, 0xc4, 0x79, 0x32, 0x87,
+	0x80, 0x28, 0x22, 0xe8, 0x33, 0xc8, 0xd9, 0x0e, 0xeb, 0xbb, 0xfc, 0x71, 0x58, 0xb9, 0xcf, 0x02,
-	0x63, 0x51, 0x0d, 0x52, 0x58, 0x2c, 0x4e, 0xd6, 0xde, 0x27, 0xb4, 0x07, 0xc8, 0x86, 0x67, 0xf9,
+	0x46, 0xbf, 0x4f, 0x76, 0x68, 0x75, 0x6d, 0x88, 0x1b, 0xa2, 0x71, 0x6a, 0x0e, 0xf1, 0x17, 0x61,
-	0xdf, 0xba, 0xbb, 0x68, 0x5f, 0x96, 0x5c, 0xea, 0xcb, 0xbe, 0x85, 0xd2, 0x85, 0xed, 0x98, 0x43,
+	0xd7, 0xae, 0xbf, 0x87, 0xa2, 0x0c, 0xa0, 0x32, 0x64, 0x1e, 0xf0, 0x42, 0xcc, 0x0f, 0xf4, 0x27,
-	0xfb, 0x6f, 0x44, 0xcd, 0xb7, 0x4f, 0x05, 0x4f, 0xfb, 0x08, 0xe5, 0xa8, 0xdc, 0x22, 0xea, 0xbc,
+	0x2d, 0x9c, 0x47, 0x73, 0x3c, 0xe5, 0x8d, 0x29, 0xab, 0xf3, 0x8f, 0xf7, 0xe9, 0x77, 0x29, 0xf5,
-	0x77, 0x8e, 0x0a, 0x0a, 0x12, 0x8f, 0xfa, 0x01, 0xe4, 0x59, 0x29, 0xbf, 0x63, 0xc2, 0xac, 0xa0,
+	0x1e, 0x0a, 0xa1, 0x2f, 0xff, 0xdf, 0xa0, 0x19, 0x1f, 0x11, 0x33, 0x2b, 0x23, 0xe2, 0xd7, 0x50,
-	0xaf, 0x09, 0x0e, 0xdf, 0x9c, 0x70, 0x7d, 0xbd, 0xa9, 0x56, 0x12, 0x0f, 0x16, 0x3f, 0x7c, 0xf8,
+	0x39, 0xb7, 0x1d, 0x73, 0x6c, 0xff, 0x15, 0xcb, 0xf5, 0xf6, 0x53, 0xc9, 0x53, 0x3f, 0x42, 0x35,
-	0x94, 0x5f, 0x89, 0x57, 0x69, 0x4e, 0x94, 0xbb, 0xc5, 0x53, 0x22, 0xf1, 0x1f, 0xa6, 0xc4, 0x6f,
+	0x2e, 0x17, 0x65, 0x9d, 0x8d, 0xf1, 0x71, 0x41, 0x4e, 0x62, 0x59, 0x3f, 0x80, 0x22, 0x9d, 0x2a,
-	0x7e, 0x4c, 0x42, 0x4e, 0xa9, 0xb8, 0xa8, 0x04, 0x5b, 0x37, 0xed, 0x66, 0xbb, 0x73, 0xdb, 0x36,
+	0x6e, 0xa9, 0x30, 0x9d, 0x2d, 0xd2, 0x9c, 0xc3, 0x37, 0x67, 0x4c, 0xdf, 0x60, 0xae, 0x56, 0xf8,
-	0x6e, 0x2f, 0x7b, 0x6d, 0xbd, 0xdb, 0x2d, 0xbe, 0x40, 0x15, 0x28, 0xd7, 0x3b, 0x57, 0x57, 0x97,
+	0x83, 0xc5, 0x9c, 0x0f, 0x9f, 0xfc, 0x4b, 0xfe, 0x2a, 0x2d, 0x89, 0xe2, 0xb4, 0x64, 0x49, 0xa4,
-	0xbd, 0x2b, 0xbd, 0xdd, 0x33, 0x7a, 0x97, 0x57, 0xba, 0xd1, 0xea, 0xd4, 0x9b, 0xc5, 0x04, 0xda,
+	0xfe, 0xcb, 0x92, 0xf8, 0xcd, 0xdf, 0x32, 0xa0, 0x48, 0xcd, 0x1f, 0x55, 0x60, 0xeb, 0xba, 0xdb,
-	0x85, 0x92, 0x82, 0xb4, 0x3b, 0xc6, 0xb9, 0xde, 0x3a, 0xfd, 0x58, 0x5c, 0x43, 0x3b, 0xb0, 0xad,
+	0xee, 0xf6, 0x6e, 0xba, 0xc6, 0xcd, 0xc5, 0xa0, 0xab, 0xf5, 0xfb, 0xe5, 0x67, 0xa8, 0x06, 0xd5,
-	0x00, 0x58, 0xff, 0xd0, 0x69, 0xea, 0xc5, 0x24, 0xe3, 0x6f, 0xf4, 0x5a, 0x75, 0xa3, 0x73, 0x71,
+	0x66, 0xef, 0xf2, 0xf2, 0x62, 0x70, 0xa9, 0x75, 0x07, 0xc6, 0xe0, 0xe2, 0x52, 0x33, 0x3a, 0xbd,
-	0xa1, 0x63, 0xfd, 0x7c, 0x0e, 0xa4, 0xd8, 0x16, 0x1c, 0x38, 0xad, 0xd7, 0xf5, 0xeb, 0xde, 0x02,
+	0x66, 0xbb, 0x9c, 0x42, 0xbb, 0x50, 0x91, 0x90, 0x6e, 0xcf, 0x38, 0xd3, 0x3a, 0x27, 0x1f, 0xcb,
-	0x59, 0x47, 0xbf, 0x84, 0xb7, 0x11, 0x11, 0xb6, 0x7d, 0xe7, 0xa6, 0x67, 0x74, 0xf5, 0x7a, 0xa7,
+	0x69, 0xb4, 0x03, 0xdb, 0x12, 0xa0, 0x6b, 0x1f, 0x7a, 0x6d, 0xad, 0x9c, 0xa1, 0xfc, 0xad, 0x41,
-	0x7d, 0x6e, 0xb4, 0xf4, 0x0f, 0x7a, 0xab, 0x98, 0x46, 0xbf, 0x02, 0x2d, 0xaa, 0xa0, 0x7b, 0x53,
+	0xa7, 0x69, 0xf4, 0xce, 0xcf, 0x35, 0x5d, 0x3b, 0x5b, 0x02, 0x59, 0x7a, 0x04, 0x03, 0x4e, 0x9a,
-	0xaf, 0xeb, 0xdd, 0x6e, 0x94, 0x6f, 0x03, 0xed, 0xc3, 0xeb, 0x98, 0x05, 0x57, 0x9d, 0x9e, 0x3e,
+	0x4d, 0xed, 0x6a, 0x10, 0x21, 0x1b, 0xe8, 0x97, 0xf0, 0x26, 0x26, 0x42, 0x8f, 0xef, 0x5d, 0x0f,
-	0xd7, 0x5a, 0xcc, 0xa0, 0x03, 0xd8, 0x8b, 0x5b, 0xc2, 0x39, 0xa4, 0xbe, 0x62, 0x16, 0xed, 0x41,
+	0x8c, 0xbe, 0xd6, 0xec, 0x75, 0xcf, 0x8c, 0x8e, 0xf6, 0x41, 0xeb, 0x94, 0x73, 0xe8, 0x57, 0xa0,
-	0x85, 0x73, 0xa8, 0x9a, 0xe7, 0xf6, 0x02, 0x2a, 0x43, 0x51, 0x7a, 0xce, 0x68, 0xea, 0x1f, 0x8d,
+	0xc6, 0x15, 0xf4, 0xaf, 0x9b, 0x4d, 0xad, 0xdf, 0x8f, 0xf3, 0x3d, 0x47, 0xfb, 0xf0, 0x2a, 0x61,
-	0xc6, 0x69, 0xb7, 0x51, 0xcc, 0xa1, 0xd7, 0xb0, 0xdb, 0xd6, 0xbb, 0x4c, 0xdd, 0x12, 0x98, 0x8f,
+	0xc1, 0x65, 0x6f, 0xa0, 0x2d, 0xb5, 0x96, 0xf3, 0xe8, 0x00, 0xf6, 0x92, 0x96, 0x30, 0x0e, 0xa1,
-	0x39, 0xeb, 0xb4, 0x5d, 0x6f, 0x74, 0x70, 0xb1, 0x70, 0xfc, 0xcf, 0x2c, 0x64, 0x6f, 0x79, 0x00,
+	0xaf, 0x5c, 0x40, 0x7b, 0x50, 0x63, 0x1c, 0xb2, 0xe6, 0xa5, 0xbd, 0x80, 0xaa, 0x50, 0x16, 0x91,
-	0x9b, 0x36, 0x45, 0x2d, 0xc8, 0x29, 0xc3, 0x12, 0x7a, 0x13, 0x2b, 0x10, 0xd1, 0xa1, 0xac, 0xfa,
+	0x33, 0xda, 0xda, 0x47, 0xa3, 0x75, 0xd2, 0x6f, 0x95, 0x15, 0xf4, 0x0a, 0x76, 0xbb, 0x5a, 0x9f,
-	0xd9, 0x73, 0x70, 0x58, 0xc6, 0x72, 0xca, 0xf4, 0x12, 0xd5, 0xb6, 0x34, 0x9c, 0x44, 0xb5, 0xad,
+	0xaa, 0x5b, 0x01, 0x8b, 0x89, 0x60, 0x9d, 0x74, 0x9b, 0xad, 0x9e, 0x5e, 0x2e, 0x1d, 0xff, 0xa3,
-	0x18, 0x7a, 0x30, 0x14, 0x22, 0xf3, 0x07, 0xda, 0x57, 0x04, 0x56, 0x8d, 0x3b, 0xd5, 0x83, 0xe7,
+	0x00, 0x85, 0x1b, 0x96, 0xc0, 0xb6, 0x4d, 0x50, 0x07, 0x14, 0x69, 0x6f, 0x43, 0xaf, 0x13, 0x0d,
-	0x19, 0xa4, 0xce, 0x4b, 0x80, 0x45, 0xa2, 0xa3, 0xbd, 0xd8, 0x79, 0x22, 0x97, 0xa2, 0xfa, 0xe6,
+	0x22, 0xbe, 0x1f, 0xd6, 0x3f, 0x79, 0x0a, 0x0e, 0xdb, 0x98, 0x22, 0x2d, 0x52, 0x71, 0x6d, 0x2b,
-	0x19, 0x54, 0xaa, 0x3a, 0x81, 0xc2, 0x39, 0xf1, 0xed, 0x27, 0xd2, 0x26, 0x53, 0xda, 0x24, 0x33,
+	0x7b, 0x52, 0x5c, 0xdb, 0x9a, 0xfd, 0x4b, 0x87, 0x52, 0x6c, 0x15, 0x42, 0xfb, 0x92, 0xc0, 0xba,
-	0xb4, 0xad, 0xf0, 0x8b, 0xf9, 0xa8, 0xfa, 0x32, 0xec, 0xf4, 0x9b, 0x64, 0x76, 0x4e, 0x82, 0x81,
+	0xcd, 0xab, 0x7e, 0xf0, 0x34, 0x83, 0xd0, 0x79, 0x01, 0x10, 0x15, 0x3a, 0xda, 0x4b, 0xf8, 0x13,
-	0x6f, 0x7b, 0xd4, 0xf5, 0xd1, 0x7b, 0xc8, 0x0a, 0x59, 0x26, 0x57, 0x52, 0x99, 0x5a, 0xee, 0xc0,
+	0xbb, 0x14, 0xf5, 0xd7, 0x4f, 0xa0, 0x42, 0xd5, 0x7b, 0x28, 0x9d, 0x61, 0xdf, 0x7e, 0xc4, 0x5d,
-	0xa4, 0xae, 0xff, 0xac, 0xe4, 0xef, 0x21, 0xc3, 0xf6, 0x63, 0xd3, 0x11, 0x52, 0x1b, 0x5c, 0x65,
+	0x3c, 0x27, 0x6d, 0xbc, 0x40, 0xdb, 0x12, 0x3f, 0x5f, 0xd5, 0xea, 0x2f, 0xc2, 0xa5, 0xa3, 0x8d,
-	0x7a, 0xaa, 0xee, 0x2e, 0xd1, 0xa5, 0xc9, 0x0d, 0x40, 0x72, 0xec, 0x51, 0x27, 0x27, 0x55, 0x8d,
+	0x17, 0x67, 0x38, 0x18, 0xf9, 0xb6, 0x47, 0x5c, 0x1f, 0xbd, 0x83, 0x02, 0x97, 0xa5, 0x72, 0x15,
-	0x42, 0xaf, 0x56, 0xd5, 0x76, 0x2d, 0x36, 0x2d, 0xb5, 0x20, 0xa7, 0x4c, 0x12, 0x91, 0x48, 0x2f,
+	0x99, 0xa9, 0xe3, 0x8e, 0x4c, 0xe2, 0xfa, 0x4f, 0x4a, 0xfe, 0x0e, 0xf2, 0xf4, 0x3c, 0xba, 0xa8,
-	0xcf, 0x47, 0x91, 0x48, 0xaf, 0x1a, 0x40, 0x5a, 0x90, 0x53, 0x46, 0x86, 0x88, 0xb6, 0xe5, 0x09,
+	0x21, 0x79, 0xd6, 0x96, 0x16, 0xb9, 0xfa, 0xee, 0x0a, 0x5d, 0x98, 0xdc, 0x02, 0x24, 0x36, 0x30,
-	0x24, 0xa2, 0x6d, 0xd5, 0xa4, 0x81, 0xa1, 0x10, 0xe9, 0x4b, 0x23, 0x79, 0xb3, 0xaa, 0x93, 0x8d,
+	0x79, 0x89, 0x93, 0xd5, 0x48, 0xf4, 0x7a, 0x5d, 0x1e, 0xeb, 0x12, 0x8b, 0x5b, 0x07, 0x14, 0x69,
-	0xe4, 0xcd, 0xea, 0x96, 0xf6, 0x4f, 0xb0, 0x21, 0x3b, 0x3f, 0xf4, 0x4a, 0x61, 0x8e, 0x76, 0xa9,
+	0xa9, 0x89, 0x65, 0x7a, 0x75, 0x55, 0x8b, 0x65, 0x7a, 0xdd, 0x2e, 0xd4, 0x01, 0x45, 0xda, 0x5e,
-	0x11, 0x8f, 0xc5, 0x1a, 0xc5, 0x79, 0xe6, 0x49, 0x93, 0xf6, 0x9e, 0xe9, 0xc4, 0x56, 0x67, 0x5e,
+	0x62, 0xda, 0x56, 0x97, 0xa1, 0x98, 0xb6, 0x75, 0x4b, 0x8f, 0x0e, 0xa5, 0xd8, 0xfc, 0x1a, 0xab,
-	0xcc, 0x98, 0xbf, 0x42, 0x31, 0xde, 0xde, 0x20, 0xb5, 0x78, 0x3e, 0xd3, 0x5e, 0x55, 0x3f, 0xff,
+	0x9b, 0x75, 0x13, 0x6f, 0xac, 0x6e, 0xd6, 0x8f, 0xbe, 0x7f, 0x84, 0xe7, 0x62, 0xf2, 0x43, 0x2f,
-	0x59, 0x1e, 0xa9, 0xbc, 0x0e, 0x99, 0x79, 0xb3, 0x81, 0xd4, 0xf3, 0xc4, 0x7a, 0xa6, 0xea, 0xeb,
+	0x25, 0xe6, 0xf8, 0x34, 0x1b, 0x8b, 0x58, 0x62, 0x50, 0x5c, 0x56, 0x9e, 0x30, 0x69, 0xef, 0x89,
-	0x95, 0x98, 0x54, 0xd2, 0x81, 0xbc, 0x5a, 0xbf, 0x90, 0x1a, 0xb2, 0x15, 0x05, 0xb1, 0xba, 0xff,
+	0x49, 0x6c, 0x7d, 0xe5, 0x25, 0x8c, 0xf9, 0x0b, 0x94, 0x93, 0xe3, 0x0d, 0x92, 0x9b, 0xe7, 0x13,
-	0x2c, 0x2e, 0x14, 0x9e, 0xfd, 0xf6, 0x2f, 0x47, 0xf7, 0x36, 0x7d, 0x18, 0xf7, 0x6b, 0x03, 0x77,
+	0xe3, 0x55, 0xfd, 0xd3, 0x1f, 0xe5, 0x11, 0xca, 0x9b, 0x90, 0x5f, 0x0e, 0x1b, 0x48, 0xf6, 0x27,
-	0x74, 0x34, 0x64, 0x63, 0x91, 0x63, 0x3b, 0xf7, 0x0e, 0xa1, 0x13, 0xd7, 0x7f, 0x3c, 0x1a, 0x3a,
+	0x31, 0x33, 0xd5, 0x5f, 0xad, 0xc5, 0x84, 0x92, 0x1e, 0x14, 0xe5, 0xfe, 0x85, 0xe4, 0x94, 0xad,
-	0xd6, 0x11, 0x2f, 0xd2, 0x47, 0xa1, 0x9e, 0x7e, 0x9a, 0xff, 0xbd, 0xf4, 0xee, 0xdf, 0x01, 0x00,
+	0x69, 0x88, 0xf5, 0xfd, 0x27, 0x71, 0xae, 0xf0, 0xf4, 0xb7, 0x7f, 0x3e, 0xba, 0xb3, 0xc9, 0xfd,
-	0x00, 0xff, 0xff, 0xad, 0x1e, 0xe8, 0xf0, 0xa7, 0x12, 0x00, 0x00,
+	0x74, 0xd8, 0x18, 0xb9, 0x93, 0xa3, 0x31, 0xdd, 0xce, 0x1c, 0xdb, 0xb9, 0x73, 0x30, 0x99, 0xb9,
+	0xfe, 0xc3, 0xd1, 0xd8, 0xb1, 0x8e, 0x58, 0x93, 0x3e, 0x0a, 0xf5, 0x0c, 0x73, 0xec, 0x3f, 0x5d,
+	0x5f, 0xfd, 0x27, 0x00, 0x00, 0xff, 0xff, 0x6b, 0x20, 0xb6, 0x46, 0x32, 0x13, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.

lnrpc/walletrpc/walletkit.proto

@@ -409,11 +409,12 @@ message PendingSweep {
     uint32 amount_sat = 3;
 
     /*
-    The fee rate we'll use to sweep the output. The fee rate is only determined
+    Deprecated, use sat_per_vbyte.
-    once a sweeping transaction for the output is created, so it's possible for
+    The fee rate we'll use to sweep the output, expressed in sat/vbyte. The fee
-    this to be 0 before this.
+    rate is only determined once a sweeping transaction for the output is
+    created, so it's possible for this to be 0 before this.
     */
-    uint32 sat_per_byte = 4;
+    uint32 sat_per_byte = 4 [deprecated = true];
 
     // The number of broadcast attempts we've made to sweep the output.
     uint32 broadcast_attempts = 5;
@@ -427,8 +428,19 @@ message PendingSweep {
     // The requested confirmation target for this output.
     uint32 requested_conf_target = 8;
 
-    // The requested fee rate, expressed in sat/byte, for this output.
+    // Deprecated, use requested_sat_per_vbyte.
-    uint32 requested_sat_per_byte = 9;
+    // The requested fee rate, expressed in sat/vbyte, for this output.
+    uint32 requested_sat_per_byte = 9 [deprecated = true];
+
+    /*
+    The fee rate we'll use to sweep the output, expressed in sat/vbyte. The fee
+    rate is only determined once a sweeping transaction for the output is
+    created, so it's possible for this to be 0 before this.
+    */
+    uint64 sat_per_vbyte = 10;
+
+    // The requested fee rate, expressed in sat/vbyte, for this output.
+    uint64 requested_sat_per_vbyte = 11;
 
     /*
     Whether this input must be force-swept. This means that it is swept even
@@ -455,16 +467,23 @@ message BumpFeeRequest {
     uint32 target_conf = 2;
 
     /*
-    The fee rate, expressed in sat/byte, that should be used to spend the input
+    Deprecated, use sat_per_vbyte.
+    The fee rate, expressed in sat/vbyte, that should be used to spend the input
     with.
     */
-    uint32 sat_per_byte = 3;
+    uint32 sat_per_byte = 3 [deprecated = true];
 
     /*
     Whether this input must be force-swept. This means that it is swept even
     if it has a negative yield.
     */
     bool force = 4;
+
+    /*
+    The fee rate, expressed in sat/vbyte, that should be used to spend the input
+    with.
+    */
+    uint64 sat_per_vbyte = 5;
 }
 
 message BumpFeeResponse {
@@ -539,7 +558,7 @@ message FundPsbtRequest {
         The fee rate, expressed in sat/vbyte, that should be used to spend the
         input with.
         */
-        uint32 sat_per_vbyte = 4;
+        uint64 sat_per_vbyte = 4;
     }
 }
 message FundPsbtResponse {

lnrpc/walletrpc/walletkit.swagger.json

@@ -758,12 +758,17 @@
         "sat_per_byte": {
           "type": "integer",
           "format": "int64",
-          "description": "The fee rate, expressed in sat/byte, that should be used to spend the input\nwith."
+          "description": "Deprecated, use sat_per_vbyte.\nThe fee rate, expressed in sat/vbyte, that should be used to spend the input\nwith."
         },
         "force": {
           "type": "boolean",
           "format": "boolean",
           "description": "Whether this input must be force-swept. This means that it is swept even\nif it has a negative yield."
+        },
+        "sat_per_vbyte": {
+          "type": "string",
+          "format": "uint64",
+          "description": "The fee rate, expressed in sat/vbyte, that should be used to spend the input\nwith."
         }
       }
     },
@@ -823,8 +828,8 @@
           "description": "The target number of blocks that the transaction should be confirmed in."
         },
         "sat_per_vbyte": {
-          "type": "integer",
+          "type": "string",
-          "format": "int64",
+          "format": "uint64",
           "description": "The fee rate, expressed in sat/vbyte, that should be used to spend the\ninput with."
         }
       }
@@ -971,7 +976,7 @@
         "sat_per_byte": {
           "type": "integer",
           "format": "int64",
-          "description": "The fee rate we'll use to sweep the output. The fee rate is only determined\nonce a sweeping transaction for the output is created, so it's possible for\nthis to be 0 before this."
+          "description": "Deprecated, use sat_per_vbyte.\nThe fee rate we'll use to sweep the output, expressed in sat/vbyte. The fee\nrate is only determined once a sweeping transaction for the output is\ncreated, so it's possible for this to be 0 before this."
         },
         "broadcast_attempts": {
           "type": "integer",
@@ -991,7 +996,17 @@
         "requested_sat_per_byte": {
           "type": "integer",
           "format": "int64",
-          "description": "The requested fee rate, expressed in sat/byte, for this output."
+          "description": "Deprecated, use requested_sat_per_vbyte.\nThe requested fee rate, expressed in sat/vbyte, for this output."
+        },
+        "sat_per_vbyte": {
+          "type": "string",
+          "format": "uint64",
+          "description": "The fee rate we'll use to sweep the output, expressed in sat/vbyte. The fee\nrate is only determined once a sweeping transaction for the output is\ncreated, so it's possible for this to be 0 before this."
+        },
+        "requested_sat_per_vbyte": {
+          "type": "string",
+          "format": "uint64",
+          "description": "The requested fee rate, expressed in sat/vbyte, for this output."
         },
         "force": {
           "type": "boolean",

lnrpc/walletrpc/walletkit_server.go

@@ -668,23 +668,23 @@ func (w *WalletKit) PendingSweeps(ctx context.Context,
 			OutputIndex: pendingInput.OutPoint.Index,
 		}
 		amountSat := uint32(pendingInput.Amount)
-		satPerByte := uint32(pendingInput.LastFeeRate.FeePerKVByte() / 1000)
+		satPerVbyte := uint64(pendingInput.LastFeeRate.FeePerKVByte() / 1000)
 		broadcastAttempts := uint32(pendingInput.BroadcastAttempts)
 		nextBroadcastHeight := uint32(pendingInput.NextBroadcastHeight)
 
 		requestedFee := pendingInput.Params.Fee
-		requestedFeeRate := uint32(requestedFee.FeeRate.FeePerKVByte() / 1000)
+		requestedFeeRate := uint64(requestedFee.FeeRate.FeePerKVByte() / 1000)
 
 		rpcPendingSweeps = append(rpcPendingSweeps, &PendingSweep{
-			Outpoint:            op,
+			Outpoint:             op,
-			WitnessType:         witnessType,
+			WitnessType:          witnessType,
-			AmountSat:           amountSat,
+			AmountSat:            amountSat,
-			SatPerByte:          satPerByte,
+			SatPerVbyte:          satPerVbyte,
-			BroadcastAttempts:   broadcastAttempts,
+			BroadcastAttempts:    broadcastAttempts,
-			NextBroadcastHeight: nextBroadcastHeight,
+			NextBroadcastHeight:  nextBroadcastHeight,
-			RequestedSatPerByte: requestedFeeRate,
+			RequestedSatPerVbyte: requestedFeeRate,
-			RequestedConfTarget: requestedFee.ConfTarget,
+			RequestedConfTarget:  requestedFee.ConfTarget,
-			Force:               pendingInput.Params.Force,
+			Force:                pendingInput.Params.Force,
 		})
 	}
 
@@ -742,8 +742,19 @@ func (w *WalletKit) BumpFee(ctx context.Context,
 		return nil, err
 	}
 
+	// We only allow using either the deprecated field or the new field.
+	if in.SatPerByte != 0 && in.SatPerVbyte != 0 {
+		return nil, fmt.Errorf("either SatPerByte or " +
+			"SatPerVbyte should be set, but not both")
+	}
+
 	// Construct the request's fee preference.
-	satPerKw := chainfee.SatPerKVByte(in.SatPerByte * 1000).FeePerKWeight()
+	satPerKw := chainfee.SatPerKVByte(in.SatPerVbyte * 1000).FeePerKWeight()
+	if in.SatPerByte != 0 {
+		satPerKw = chainfee.SatPerKVByte(
+			in.SatPerByte * 1000,
+		).FeePerKWeight()
+	}
 	feePreference := sweep.FeePreference{
 		ConfTarget: uint32(in.TargetConf),
 		FeeRate:    satPerKw,

lnrpc/wtclientrpc/wtclient.go

@@ -370,8 +370,15 @@ func (c *WatchtowerClient) Policy(ctx context.Context,
 	}
 
 	return &PolicyResponse{
-		MaxUpdates:      uint32(policy.MaxUpdates),
+		MaxUpdates: uint32(policy.MaxUpdates),
-		SweepSatPerByte: uint32(policy.SweepFeeRate.FeePerKVByte() / 1000),
+		SweepSatPerVbyte: uint32(
+			policy.SweepFeeRate.FeePerKVByte() / 1000,
+		),
+
+		// Deprecated field.
+		SweepSatPerByte: uint32(
+			policy.SweepFeeRate.FeePerKVByte() / 1000,
+		),
 	}, nil
 }
 
@@ -387,12 +394,15 @@ func marshallTower(tower *wtclient.RegisteredTower, includeSessions bool) *Tower
 	if includeSessions {
 		rpcSessions = make([]*TowerSession, 0, len(tower.Sessions))
 		for _, session := range tower.Sessions {
-			satPerByte := session.Policy.SweepFeeRate.FeePerKVByte() / 1000
+			satPerVByte := session.Policy.SweepFeeRate.FeePerKVByte() / 1000
 			rpcSessions = append(rpcSessions, &TowerSession{
 				NumBackups:        uint32(len(session.AckedUpdates)),
 				NumPendingBackups: uint32(len(session.CommittedUpdates)),
 				MaxBackups:        uint32(session.Policy.MaxUpdates),
-				SweepSatPerByte:   uint32(satPerByte),
+				SweepSatPerVbyte:  uint32(satPerVByte),
+
+				// Deprecated field.
+				SweepSatPerByte: uint32(satPerVByte),
 			})
 		}
 	}

lnrpc/wtclientrpc/wtclient.pb.go

@@ -275,9 +275,14 @@ type TowerSession struct {
 	// The maximum number of backups allowed by the watchtower session.
 	MaxBackups uint32 `protobuf:"varint,3,opt,name=max_backups,json=maxBackups,proto3" json:"max_backups,omitempty"`
 	//
+	//Deprecated, use sweep_sat_per_vbyte.
 	//The fee rate, in satoshis per vbyte, that will be used by the watchtower for
 	//the justice transaction in the event of a channel breach.
-	SweepSatPerByte      uint32   `protobuf:"varint,4,opt,name=sweep_sat_per_byte,json=sweepSatPerByte,proto3" json:"sweep_sat_per_byte,omitempty"`
+	SweepSatPerByte uint32 `protobuf:"varint,4,opt,name=sweep_sat_per_byte,json=sweepSatPerByte,proto3" json:"sweep_sat_per_byte,omitempty"` // Deprecated: Do not use.
+	//
+	//The fee rate, in satoshis per vbyte, that will be used by the watchtower for
+	//the justice transaction in the event of a channel breach.
+	SweepSatPerVbyte     uint32   `protobuf:"varint,5,opt,name=sweep_sat_per_vbyte,json=sweepSatPerVbyte,proto3" json:"sweep_sat_per_vbyte,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -329,6 +334,7 @@ func (m *TowerSession) GetMaxBackups() uint32 {
 	return 0
 }
 
+// Deprecated: Do not use.
 func (m *TowerSession) GetSweepSatPerByte() uint32 {
 	if m != nil {
 		return m.SweepSatPerByte
@@ -336,6 +342,13 @@ func (m *TowerSession) GetSweepSatPerByte() uint32 {
 	return 0
 }
 
+func (m *TowerSession) GetSweepSatPerVbyte() uint32 {
+	if m != nil {
+		return m.SweepSatPerVbyte
+	}
+	return 0
+}
+
 type Tower struct {
 	// The identifying public key of the watchtower.
 	Pubkey []byte `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
@@ -652,9 +665,14 @@ type PolicyResponse struct {
 	//should allow.
 	MaxUpdates uint32 `protobuf:"varint,1,opt,name=max_updates,json=maxUpdates,proto3" json:"max_updates,omitempty"`
 	//
+	//Deprecated, use sweep_sat_per_vbyte.
 	//The fee rate, in satoshis per vbyte, that will be used by watchtowers for
 	//justice transactions in response to channel breaches.
-	SweepSatPerByte      uint32   `protobuf:"varint,2,opt,name=sweep_sat_per_byte,json=sweepSatPerByte,proto3" json:"sweep_sat_per_byte,omitempty"`
+	SweepSatPerByte uint32 `protobuf:"varint,2,opt,name=sweep_sat_per_byte,json=sweepSatPerByte,proto3" json:"sweep_sat_per_byte,omitempty"` // Deprecated: Do not use.
+	//
+	//The fee rate, in satoshis per vbyte, that will be used by watchtowers for
+	//justice transactions in response to channel breaches.
+	SweepSatPerVbyte     uint32   `protobuf:"varint,3,opt,name=sweep_sat_per_vbyte,json=sweepSatPerVbyte,proto3" json:"sweep_sat_per_vbyte,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -692,6 +710,7 @@ func (m *PolicyResponse) GetMaxUpdates() uint32 {
 	return 0
 }
 
+// Deprecated: Do not use.
 func (m *PolicyResponse) GetSweepSatPerByte() uint32 {
 	if m != nil {
 		return m.SweepSatPerByte
@@ -699,6 +718,13 @@ func (m *PolicyResponse) GetSweepSatPerByte() uint32 {
 	return 0
 }
 
+func (m *PolicyResponse) GetSweepSatPerVbyte() uint32 {
+	if m != nil {
+		return m.SweepSatPerVbyte
+	}
+	return 0
+}
+
 func init() {
 	proto.RegisterEnum("wtclientrpc.PolicyType", PolicyType_name, PolicyType_value)
 	proto.RegisterType((*AddTowerRequest)(nil), "wtclientrpc.AddTowerRequest")
@@ -719,54 +745,55 @@ func init() {
 func init() { proto.RegisterFile("wtclientrpc/wtclient.proto", fileDescriptor_b5f4e7d95a641af2) }
 
 var fileDescriptor_b5f4e7d95a641af2 = []byte{
-	// 739 bytes of a gzipped FileDescriptorProto
+	// 765 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcd, 0x6e, 0xd3, 0x4a,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xdd, 0x6e, 0xda, 0x48,
-	0x14, 0xbe, 0x6e, 0x6e, 0x72, 0xd3, 0x93, 0xb4, 0x4d, 0x27, 0xb7, 0xbd, 0xb9, 0xa6, 0x90, 0x60,
+	0x14, 0x5e, 0xc3, 0xc2, 0x92, 0x03, 0x49, 0xc8, 0xb0, 0xc9, 0xb2, 0xde, 0xec, 0xc2, 0x5a, 0xbd,
-	0xb1, 0x08, 0x05, 0x25, 0x22, 0x05, 0xa9, 0xab, 0x8a, 0x34, 0xb4, 0xa5, 0x52, 0x81, 0xc8, 0x2d,
+	0xa0, 0x51, 0x0b, 0x2a, 0x69, 0xa5, 0x5c, 0x45, 0x05, 0x9a, 0xa4, 0x91, 0xd2, 0x16, 0x39, 0xe9,
-	0xe2, 0x67, 0x81, 0x35, 0xb1, 0xa7, 0x89, 0x55, 0x7b, 0xec, 0xda, 0xe3, 0x26, 0x79, 0x28, 0x1e,
+	0xef, 0x8d, 0x35, 0xd8, 0x13, 0xb0, 0x82, 0xc7, 0x8e, 0x3d, 0x0e, 0xf0, 0x18, 0x7d, 0xa8, 0x3e,
-	0x83, 0x07, 0xe0, 0x6d, 0x58, 0x22, 0x8f, 0xc7, 0x8e, 0xdd, 0x3a, 0x62, 0x01, 0x3b, 0xfb, 0x7c,
+	0x40, 0xdf, 0xa0, 0x8f, 0xd1, 0xcb, 0xca, 0xe3, 0xb1, 0xb1, 0x13, 0xa3, 0xaa, 0x6a, 0xef, 0xec,
-	0xdf, 0x7c, 0x3e, 0xf3, 0x9d, 0x1f, 0x83, 0x3c, 0x65, 0xba, 0x65, 0x12, 0xca, 0x3c, 0x57, 0xef,
+	0xf3, 0x7d, 0xf3, 0x79, 0xce, 0x77, 0x7e, 0x0c, 0xf2, 0x8c, 0xe9, 0x53, 0x93, 0x50, 0xe6, 0x3a,
-	0xc6, 0xcf, 0x1d, 0xd7, 0x73, 0x98, 0x83, 0x2a, 0x29, 0x4c, 0x19, 0xc0, 0x46, 0xdf, 0x30, 0x2e,
+	0x7a, 0x27, 0x7a, 0x6e, 0x3b, 0xae, 0xcd, 0x6c, 0x54, 0x4e, 0x60, 0xca, 0x00, 0x36, 0x7b, 0x86,
-	0x9c, 0x29, 0xf1, 0x54, 0x72, 0x1d, 0x10, 0x9f, 0xa1, 0x6d, 0x28, 0xb9, 0xc1, 0xe8, 0x8a, 0xcc,
+	0x71, 0x61, 0xcf, 0x88, 0xab, 0x92, 0x6b, 0x9f, 0x78, 0x0c, 0xed, 0x40, 0xd1, 0xf1, 0x47, 0x57,
-	0x1b, 0x52, 0x4b, 0x6a, 0x57, 0x55, 0xf1, 0x86, 0x1a, 0xf0, 0x0f, 0x36, 0x0c, 0x8f, 0xf8, 0x7e,
+	0x64, 0x51, 0x97, 0x9a, 0x52, 0xab, 0xa2, 0x8a, 0x37, 0x54, 0x87, 0x3f, 0xb0, 0x61, 0xb8, 0xc4,
-	0x63, 0xa5, 0x25, 0xb5, 0x57, 0xd5, 0xf8, 0x55, 0x41, 0x50, 0x5b, 0x88, 0xf8, 0xae, 0x43, 0x7d,
+	0xf3, 0xea, 0xb9, 0xa6, 0xd4, 0x5a, 0x53, 0xa3, 0x57, 0x05, 0x41, 0x75, 0x29, 0xe2, 0x39, 0x36,
-	0xa2, 0x1c, 0x03, 0x52, 0x89, 0xed, 0xdc, 0x90, 0xdf, 0xd4, 0xde, 0x82, 0x7a, 0x46, 0x47, 0xc8,
+	0xf5, 0x88, 0x72, 0x0c, 0x48, 0x25, 0x96, 0x7d, 0x43, 0x7e, 0x52, 0x7b, 0x1b, 0x6a, 0x29, 0x1d,
-	0x7f, 0x84, 0xfa, 0x09, 0x61, 0x3c, 0x76, 0x4a, 0x2f, 0x9d, 0x5f, 0xe9, 0x3f, 0x86, 0x9a, 0x49,
+	0x21, 0xff, 0x0e, 0x6a, 0x27, 0x84, 0xf1, 0xd8, 0x29, 0xbd, 0xb4, 0xbf, 0xa7, 0x7f, 0x1f, 0xaa,
-	0x75, 0x2b, 0x30, 0x88, 0xe6, 0x13, 0xdf, 0x37, 0x1d, 0x1a, 0x7d, 0xa8, 0xac, 0x6e, 0x88, 0xf8,
+	0x26, 0xd5, 0xa7, 0xbe, 0x41, 0x34, 0x8f, 0x78, 0x9e, 0x69, 0xd3, 0xf0, 0x43, 0x25, 0x75, 0x53,
-	0xb9, 0x08, 0x2b, 0x5f, 0x25, 0xa8, 0x72, 0x5d, 0x11, 0x41, 0x4d, 0xa8, 0xd0, 0xc0, 0xd6, 0x46,
+	0xc4, 0xcf, 0x45, 0x58, 0xf9, 0x22, 0x41, 0x85, 0xeb, 0x8a, 0x08, 0x6a, 0x40, 0x99, 0xfa, 0x96,
-	0x58, 0xbf, 0x0a, 0x5c, 0x9f, 0x0b, 0xaf, 0xa9, 0x40, 0x03, 0xfb, 0x30, 0x8a, 0xa0, 0x0e, 0xd4,
+	0x36, 0xc2, 0xfa, 0x95, 0xef, 0x78, 0x5c, 0x78, 0x5d, 0x05, 0xea, 0x5b, 0xfd, 0x30, 0x82, 0xda,
-	0x43, 0x82, 0x4b, 0xa8, 0x61, 0xd2, 0x71, 0x42, 0x5c, 0xe1, 0xc4, 0x4d, 0x1a, 0xd8, 0xc3, 0x08,
+	0x50, 0x0b, 0x08, 0x0e, 0xa1, 0x86, 0x49, 0xc7, 0x31, 0x31, 0xc7, 0x89, 0x5b, 0xd4, 0xb7, 0x86,
-	0x89, 0xf9, 0x4d, 0xa8, 0xd8, 0x78, 0x96, 0xf0, 0x0a, 0x91, 0xa0, 0x8d, 0x67, 0x31, 0xe1, 0x09,
+	0x21, 0x12, 0xf1, 0x1b, 0x50, 0xb6, 0xf0, 0x3c, 0xe6, 0xe5, 0x43, 0x41, 0x0b, 0xcf, 0x23, 0x42,
-	0x20, 0x7f, 0x4a, 0x88, 0xab, 0xf9, 0x98, 0x69, 0x2e, 0xf1, 0xb4, 0xd1, 0x9c, 0x91, 0xc6, 0xdf,
+	0x07, 0x90, 0x37, 0x23, 0xc4, 0xd1, 0x3c, 0xcc, 0x34, 0x87, 0xb8, 0xda, 0x68, 0xc1, 0x48, 0xfd,
-	0x9c, 0xb7, 0xc1, 0x91, 0x73, 0xcc, 0x86, 0xc4, 0x3b, 0x9c, 0x33, 0xa2, 0x7c, 0x97, 0xa0, 0xc8,
+	0xf7, 0x80, 0xd7, 0xcf, 0xd5, 0x25, 0x75, 0x93, 0xa3, 0xe7, 0x98, 0x0d, 0x89, 0xdb, 0x5f, 0x30,
-	0xf3, 0x5d, 0x7a, 0xf9, 0x1d, 0x58, 0x15, 0x6e, 0x92, 0x30, 0xab, 0x42, 0x7b, 0x55, 0x5d, 0x04,
+	0x82, 0x1e, 0x42, 0x2d, 0x7d, 0xe0, 0x86, 0x9f, 0x28, 0x70, 0xe5, 0x6a, 0x82, 0xfd, 0x26, 0x88,
-	0xd0, 0x3e, 0x34, 0xb0, 0xce, 0xcc, 0x9b, 0xc4, 0x19, 0x4d, 0xc7, 0xd4, 0x30, 0x0d, 0xcc, 0x08,
+	0x2b, 0x9f, 0x25, 0x28, 0xf0, 0x14, 0x57, 0xfa, 0xb5, 0x0b, 0x6b, 0xa2, 0x00, 0x24, 0x48, 0x24,
-	0x4f, 0xad, 0xac, 0x6e, 0x47, 0xb8, 0xf0, 0x63, 0x10, 0xa3, 0xe8, 0x21, 0x54, 0xc3, 0x7b, 0x27,
+	0xdf, 0x5a, 0x53, 0x97, 0x01, 0x74, 0x00, 0x75, 0xac, 0x33, 0xf3, 0x26, 0x36, 0x53, 0xd3, 0x31,
-	0x86, 0x46, 0x09, 0x86, 0x66, 0xc5, 0x66, 0xa2, 0x17, 0x50, 0x4e, 0xe0, 0x62, 0xab, 0xd0, 0xae,
+	0x35, 0x4c, 0x03, 0x33, 0xc2, 0xb3, 0x29, 0xa9, 0x3b, 0x21, 0x2e, 0x2c, 0x1c, 0x44, 0x28, 0xfa,
-	0xf4, 0xfe, 0xef, 0xa4, 0xda, 0xaf, 0x93, 0x36, 0x5a, 0x4d, 0xa8, 0xca, 0x01, 0x6c, 0x9e, 0x99,
+	0x1f, 0x2a, 0x81, 0x55, 0x71, 0x0d, 0x78, 0x4e, 0x6a, 0xe0, 0x6f, 0xe4, 0x3f, 0x7a, 0x02, 0xa5,
-	0x7e, 0x54, 0x5e, 0x3f, 0xae, 0x6d, 0x5e, 0x0d, 0xa5, 0xfc, 0x1a, 0xbe, 0x04, 0x94, 0x3e, 0x1f,
+	0x18, 0x2e, 0x34, 0xf3, 0xad, 0x72, 0xf7, 0xef, 0x76, 0xa2, 0x63, 0xdb, 0xc9, 0xda, 0xa8, 0x31,
-	0xf5, 0x0c, 0xda, 0x85, 0x12, 0xe3, 0x91, 0x86, 0xc4, 0x53, 0x41, 0x77, 0x53, 0x51, 0x05, 0x43,
+	0x55, 0x39, 0x84, 0xad, 0x33, 0xd3, 0x0b, 0x3b, 0xc2, 0x8b, 0xda, 0x21, 0xab, 0xec, 0x52, 0x76,
-	0x59, 0x87, 0xea, 0x39, 0xc3, 0x2c, 0xfe, 0xb8, 0xf2, 0x43, 0x82, 0x35, 0x11, 0x10, 0x6a, 0x7f,
+	0xd9, 0x9f, 0x02, 0x4a, 0x9e, 0x0f, 0xdb, 0x0c, 0xed, 0x41, 0x91, 0xf1, 0x48, 0x5d, 0xe2, 0x57,
-	0xbc, 0x2d, 0x9e, 0x02, 0x0a, 0xf9, 0x97, 0xd8, 0xb4, 0x88, 0x71, 0xab, 0x3b, 0x6a, 0x34, 0xb0,
+	0x41, 0x77, 0xaf, 0xa2, 0x0a, 0x86, 0xb2, 0x01, 0x95, 0x73, 0x86, 0x59, 0xf4, 0x71, 0xe5, 0xab,
-	0x8f, 0x39, 0x10, 0xb3, 0x7b, 0xb0, 0x95, 0x36, 0x5f, 0xc3, 0xfa, 0x75, 0x60, 0x7a, 0xc4, 0x10,
+	0x04, 0xeb, 0x22, 0x20, 0xd4, 0x7e, 0x79, 0x27, 0x3d, 0x00, 0x14, 0xf0, 0x2f, 0xb1, 0x39, 0x25,
-	0x55, 0xa8, 0xa7, 0xaa, 0xd0, 0x17, 0x10, 0x7a, 0x0e, 0xdb, 0x99, 0x33, 0x64, 0x36, 0xc1, 0x81,
+	0xc6, 0xad, 0x86, 0xaa, 0x52, 0xdf, 0x3a, 0xe6, 0x40, 0xc4, 0xee, 0xc2, 0x76, 0xd2, 0x7c, 0x0d,
-	0xcf, 0x88, 0xd1, 0x28, 0xf2, 0x43, 0xff, 0xa6, 0x0e, 0x1d, 0xc5, 0x98, 0x72, 0x0a, 0x6b, 0x43,
+	0xeb, 0xd7, 0xbe, 0xe9, 0x12, 0x43, 0x54, 0xa1, 0x96, 0xa8, 0x42, 0x4f, 0x40, 0xe8, 0x31, 0xec,
-	0xc7, 0x32, 0xf5, 0x79, 0x5c, 0x88, 0x7d, 0xa8, 0xb8, 0x3c, 0xa0, 0xb1, 0xb9, 0x4b, 0xf8, 0xcd,
+	0xa4, 0xce, 0x90, 0xf9, 0x04, 0xfb, 0x1e, 0x23, 0x86, 0x68, 0xae, 0x3f, 0x13, 0x87, 0x8e, 0x22,
-	0xd7, 0x7b, 0xff, 0x65, 0xcc, 0x8c, 0x0e, 0x5c, 0xcc, 0x5d, 0xa2, 0x82, 0x9b, 0x3c, 0x2b, 0x5f,
+	0x4c, 0x39, 0x85, 0xf5, 0xa1, 0x3d, 0x35, 0xf5, 0x45, 0x54, 0x88, 0x03, 0x28, 0x3b, 0x3c, 0xa0,
-	0x60, 0x3d, 0x96, 0x5a, 0xb8, 0x18, 0xce, 0x42, 0xe0, 0x86, 0x1d, 0x95, 0xb8, 0x68, 0xe3, 0xd9,
+	0xb1, 0x85, 0x43, 0x78, 0xe6, 0x1b, 0xdd, 0xbf, 0x52, 0x66, 0x86, 0x07, 0x2e, 0x16, 0x0e, 0x51,
-	0xfb, 0x28, 0xb2, 0x64, 0x16, 0x56, 0x72, 0x67, 0x61, 0xf7, 0x11, 0xc0, 0xe2, 0xcb, 0x08, 0xa0,
+	0xc1, 0x89, 0x9f, 0x95, 0x8f, 0x12, 0x6c, 0x44, 0x5a, 0x4b, 0x1b, 0x83, 0xf9, 0xf1, 0x9d, 0xa0,
-	0x74, 0x76, 0x74, 0xd2, 0x1f, 0x7c, 0xaa, 0xfd, 0x15, 0x3e, 0xf7, 0xdf, 0x0e, 0x5e, 0xbf, 0x53,
+	0xa5, 0x62, 0x1b, 0x2d, 0x3c, 0x7f, 0x1d, 0x46, 0x56, 0xcc, 0x4f, 0xee, 0x87, 0xe7, 0x27, 0x9f,
-	0x6b, 0x52, 0xef, 0x5b, 0x01, 0x6a, 0x1f, 0x30, 0xd3, 0x27, 0xbc, 0xd6, 0x03, 0x9e, 0x34, 0x3a,
+	0x3d, 0x3f, 0x7b, 0xf7, 0x00, 0x96, 0xb7, 0x45, 0x00, 0xc5, 0xb3, 0xa3, 0x93, 0xde, 0xe0, 0x7d,
-	0x81, 0x72, 0xbc, 0xc3, 0xd0, 0x4e, 0xe6, 0x2e, 0xb7, 0xf6, 0xa3, 0x7c, 0x7f, 0x09, 0x2a, 0x6e,
+	0xf5, 0xb7, 0xe0, 0xb9, 0xf7, 0x72, 0xf0, 0xfc, 0x95, 0x5a, 0x95, 0xba, 0x9f, 0xf2, 0x50, 0x7d,
-	0x34, 0x84, 0x4a, 0x6a, 0x61, 0xa1, 0x66, 0x86, 0x7d, 0x77, 0x25, 0xca, 0xad, 0xe5, 0x04, 0xa1,
+	0x8b, 0x99, 0x3e, 0xe1, 0xfd, 0x31, 0xe0, 0x89, 0xa2, 0x13, 0x28, 0x45, 0xab, 0x12, 0xed, 0xa6,
-	0xf8, 0x06, 0x60, 0xd1, 0xcd, 0xe8, 0x41, 0x86, 0x7f, 0x67, 0x4c, 0xe4, 0xe6, 0x52, 0x5c, 0xc8,
+	0xf2, 0xbf, 0xb5, 0x86, 0xe5, 0x7f, 0x57, 0xa0, 0xc2, 0x84, 0x21, 0x94, 0x13, 0x7b, 0x11, 0x35,
-	0xbd, 0x82, 0x6a, 0x7a, 0x75, 0xa2, 0x6c, 0x02, 0x39, 0x5b, 0x55, 0xce, 0x19, 0x14, 0x74, 0x00,
+	0x52, 0xec, 0xbb, 0x9b, 0x57, 0x6e, 0xae, 0x26, 0x08, 0xc5, 0x17, 0x00, 0xcb, 0x09, 0x40, 0xff,
-	0x45, 0x3e, 0x0f, 0x28, 0x3b, 0xd0, 0xe9, 0xa1, 0x91, 0xe5, 0x3c, 0x48, 0x64, 0xd1, 0x87, 0x52,
+	0xa5, 0xf8, 0x77, 0x46, 0x4b, 0x6e, 0xac, 0xc4, 0x85, 0xdc, 0x33, 0xa8, 0x24, 0x37, 0x34, 0x4a,
-	0x54, 0x2a, 0x24, 0xe7, 0x74, 0x4e, 0xac, 0x70, 0x2f, 0x17, 0x8b, 0x24, 0x0e, 0xf7, 0x3e, 0x3f,
+	0x5f, 0x20, 0x63, 0x79, 0xcb, 0x19, 0xc3, 0x85, 0x0e, 0xa1, 0xc0, 0x67, 0x08, 0xa5, 0x97, 0x40,
-	0x1b, 0x9b, 0x6c, 0x12, 0x8c, 0x3a, 0xba, 0x63, 0x77, 0x2d, 0x73, 0x3c, 0x61, 0xd4, 0xa4, 0x63,
+	0x72, 0xd0, 0x64, 0x39, 0x0b, 0x12, 0xb7, 0xe8, 0x41, 0x31, 0x2c, 0x15, 0x92, 0x33, 0xba, 0x2d,
-	0x4a, 0xd8, 0xd4, 0xf1, 0xae, 0xba, 0x16, 0x35, 0xba, 0x16, 0x4d, 0xff, 0x00, 0x3d, 0x57, 0x1f,
+	0x52, 0xf8, 0x27, 0x13, 0x0b, 0x25, 0xfa, 0xfb, 0x1f, 0x1e, 0x8d, 0x4d, 0x36, 0xf1, 0x47, 0x6d,
-	0x95, 0xf8, 0x4f, 0x70, 0xef, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x99, 0x5f, 0xe1, 0x8e, 0x22,
+	0xdd, 0xb6, 0x3a, 0x53, 0x73, 0x3c, 0x61, 0xd4, 0xa4, 0x63, 0x4a, 0xd8, 0xcc, 0x76, 0xaf, 0x3a,
-	0x07, 0x00, 0x00,
+	0x53, 0x6a, 0x74, 0xa6, 0x34, 0xf9, 0x9f, 0x75, 0x1d, 0x7d, 0x54, 0xe4, 0xff, 0xda, 0xfd, 0x6f,
+	0x01, 0x00, 0x00, 0xff, 0xff, 0x49, 0xcd, 0xe9, 0xf8, 0x89, 0x07, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.

lnrpc/wtclientrpc/wtclient.proto

@@ -87,10 +87,17 @@ message TowerSession {
     uint32 max_backups = 3;
 
     /*
+    Deprecated, use sweep_sat_per_vbyte.
     The fee rate, in satoshis per vbyte, that will be used by the watchtower for
     the justice transaction in the event of a channel breach.
     */
-    uint32 sweep_sat_per_byte = 4;
+    uint32 sweep_sat_per_byte = 4 [deprecated = true];
+
+    /*
+    The fee rate, in satoshis per vbyte, that will be used by the watchtower for
+    the justice transaction in the event of a channel breach.
+    */
+    uint32 sweep_sat_per_vbyte = 5;
 }
 
 message Tower {
@@ -172,8 +179,15 @@ message PolicyResponse {
     uint32 max_updates = 1;
 
     /*
+    Deprecated, use sweep_sat_per_vbyte.
     The fee rate, in satoshis per vbyte, that will be used by watchtowers for
     justice transactions in response to channel breaches.
     */
-    uint32 sweep_sat_per_byte = 2;
+    uint32 sweep_sat_per_byte = 2 [deprecated = true];
+
+    /*
+    The fee rate, in satoshis per vbyte, that will be used by watchtowers for
+    justice transactions in response to channel breaches.
+    */
+    uint32 sweep_sat_per_vbyte = 3;
 }

lnrpc/wtclientrpc/wtclient.swagger.json

@@ -289,6 +289,11 @@
           "description": "The maximum number of updates each session we negotiate with watchtowers\nshould allow."
         },
         "sweep_sat_per_byte": {
+          "type": "integer",
+          "format": "int64",
+          "description": "Deprecated, use sweep_sat_per_vbyte.\nThe fee rate, in satoshis per vbyte, that will be used by watchtowers for\njustice transactions in response to channel breaches."
+        },
+        "sweep_sat_per_vbyte": {
           "type": "integer",
           "format": "int64",
           "description": "The fee rate, in satoshis per vbyte, that will be used by watchtowers for\njustice transactions in response to channel breaches."
@@ -390,6 +395,11 @@
           "description": "The maximum number of backups allowed by the watchtower session."
         },
         "sweep_sat_per_byte": {
+          "type": "integer",
+          "format": "int64",
+          "description": "Deprecated, use sweep_sat_per_vbyte.\nThe fee rate, in satoshis per vbyte, that will be used by the watchtower for\nthe justice transaction in the event of a channel breach."
+        },
+        "sweep_sat_per_vbyte": {
           "type": "integer",
           "format": "int64",
           "description": "The fee rate, in satoshis per vbyte, that will be used by the watchtower for\nthe justice transaction in the event of a channel breach."

lntest/itest/lnd_onchain_test.go

@@ -97,8 +97,10 @@ func testCPFP(net *lntest.NetworkHarness, t *harnessTest) {
 	// We'll attempt to bump the fee of this transaction by performing a
 	// CPFP from Alice's point of view.
 	bumpFeeReq := &walletrpc.BumpFeeRequest{
-		Outpoint:   op,
+		Outpoint: op,
-		SatPerByte: uint32(sweep.DefaultMaxFeeRate.FeePerKVByte() / 2000),
+		SatPerVbyte: uint64(
+			sweep.DefaultMaxFeeRate.FeePerKVByte() / 2000,
+		),
 	}
 	ctxt, _ = context.WithTimeout(ctxb, defaultTimeout)
 	_, err = net.Bob.WalletKitClient.BumpFee(ctxt, bumpFeeReq)
@@ -136,9 +138,9 @@ func testCPFP(net *lntest.NetworkHarness, t *harnessTest) {
 		t.Fatalf("expected output index %v, got %v", op.OutputIndex,
 			pendingSweep.Outpoint.OutputIndex)
 	}
-	if pendingSweep.SatPerByte != bumpFeeReq.SatPerByte {
+	if pendingSweep.SatPerVbyte != bumpFeeReq.SatPerVbyte {
-		t.Fatalf("expected sweep sat per byte %v, got %v",
+		t.Fatalf("expected sweep sat per vbyte %v, got %v",
-			bumpFeeReq.SatPerByte, pendingSweep.SatPerByte)
+			bumpFeeReq.SatPerVbyte, pendingSweep.SatPerVbyte)
 	}
 
 	// Mine a block to clean up the unconfirmed transactions.

rpcserver.go

@@ -217,6 +217,45 @@ func stringInSlice(a string, slice []string) bool {
 	return false
 }
 
+// calculateFeeRate uses either satPerByte or satPerVByte, but not both, from a
+// request to calculate the fee rate. It provides compatibility for the
+// deprecated field, satPerByte. Once the field is safe to be removed, the
+// check can then be deleted.
+func calculateFeeRate(satPerByte, satPerVByte uint64, targetConf uint32,
+	estimator chainfee.Estimator) (chainfee.SatPerKWeight, error) {
+
+	var feeRate chainfee.SatPerKWeight
+
+	// We only allow using either the deprecated field or the new field.
+	if satPerByte != 0 && satPerVByte != 0 {
+		return feeRate, fmt.Errorf("either SatPerByte or " +
+			"SatPerVByte should be set, but not both")
+	}
+
+	// Default to satPerVByte, and overwrite it if satPerByte is set.
+	satPerKw := chainfee.SatPerKVByte(satPerVByte * 1000).FeePerKWeight()
+	if satPerByte != 0 {
+		satPerKw = chainfee.SatPerKVByte(
+			satPerByte * 1000,
+		).FeePerKWeight()
+	}
+
+	// Based on the passed fee related parameters, we'll determine an
+	// appropriate fee rate for this transaction.
+	feeRate, err := sweep.DetermineFeePerKw(
+		estimator, sweep.FeePreference{
+			ConfTarget: targetConf,
+			FeeRate:    satPerKw,
+		},
+	)
+	if err != nil {
+		return feeRate, err
+	}
+
+	return feeRate, nil
+
+}
+
 // MainRPCServerPermissions returns a mapping of the main RPC server calls to
 // the permissions they require.
 func MainRPCServerPermissions() map[string][]bakery.Op {
@@ -1053,7 +1092,10 @@ func (r *rpcServer) EstimateFee(ctx context.Context,
 	totalFee := int64(tx.TotalInput) - totalOutput
 
 	resp := &lnrpc.EstimateFeeResponse{
-		FeeSat:            totalFee,
+		FeeSat:      totalFee,
+		SatPerVbyte: uint64(feePerKw.FeePerKVByte() / 1000),
+
+		// Deprecated field.
 		FeerateSatPerByte: int64(feePerKw.FeePerKVByte() / 1000),
 	}
 
@@ -1068,14 +1110,10 @@ func (r *rpcServer) EstimateFee(ctx context.Context,
 func (r *rpcServer) SendCoins(ctx context.Context,
 	in *lnrpc.SendCoinsRequest) (*lnrpc.SendCoinsResponse, error) {
 
-	// Based on the passed fee related parameters, we'll determine an
+	// Calculate an appropriate fee rate for this transaction.
-	// appropriate fee rate for this transaction.
+	feePerKw, err := calculateFeeRate(
-	satPerKw := chainfee.SatPerKVByte(in.SatPerByte * 1000).FeePerKWeight()
+		uint64(in.SatPerByte), in.SatPerVbyte,
-	feePerKw, err := sweep.DetermineFeePerKw(
+		uint32(in.TargetConf), r.server.cc.FeeEstimator,
-		r.server.cc.FeeEstimator, sweep.FeePreference{
-			ConfTarget: uint32(in.TargetConf),
-			FeeRate:    satPerKw,
-		},
 	)
 	if err != nil {
 		return nil, err
@@ -1279,14 +1317,10 @@ func (r *rpcServer) SendCoins(ctx context.Context,
 func (r *rpcServer) SendMany(ctx context.Context,
 	in *lnrpc.SendManyRequest) (*lnrpc.SendManyResponse, error) {
 
-	// Based on the passed fee related parameters, we'll determine an
+	// Calculate an appropriate fee rate for this transaction.
-	// appropriate fee rate for this transaction.
+	feePerKw, err := calculateFeeRate(
-	satPerKw := chainfee.SatPerKVByte(in.SatPerByte * 1000).FeePerKWeight()
+		uint64(in.SatPerByte), in.SatPerVbyte,
-	feePerKw, err := sweep.DetermineFeePerKw(
+		uint32(in.TargetConf), r.server.cc.FeeEstimator,
-		r.server.cc.FeeEstimator, sweep.FeePreference{
-			ConfTarget: uint32(in.TargetConf),
-			FeeRate:    satPerKw,
-		},
 	)
 	if err != nil {
 		return nil, err
@@ -1679,7 +1713,7 @@ func newPsbtAssembler(req *lnrpc.OpenChannelRequest, normalizedMinConfs int32,
 			"minimum confirmation is not supported for PSBT " +
 			"funding")
 	}
-	if req.SatPerByte != 0 || req.TargetConf != 0 {
+	if req.SatPerByte != 0 || req.SatPerVbyte != 0 || req.TargetConf != 0 {
 		return nil, fmt.Errorf("specifying fee estimation parameters " +
 			"is not supported for PSBT funding")
 	}
@@ -1830,14 +1864,10 @@ func (r *rpcServer) parseOpenChannelReq(in *lnrpc.OpenChannelRequest,
 		return nil, fmt.Errorf("cannot open channel to self")
 	}
 
-	// Based on the passed fee related parameters, we'll determine an
+	// Calculate an appropriate fee rate for this transaction.
-	// appropriate fee rate for the funding transaction.
+	feeRate, err := calculateFeeRate(
-	satPerKw := chainfee.SatPerKVByte(in.SatPerByte * 1000).FeePerKWeight()
+		uint64(in.SatPerByte), in.SatPerVbyte,
-	feeRate, err := sweep.DetermineFeePerKw(
+		uint32(in.TargetConf), r.server.cc.FeeEstimator,
-		r.server.cc.FeeEstimator, sweep.FeePreference{
-			ConfTarget: uint32(in.TargetConf),
-			FeeRate:    satPerKw,
-		},
 	)
 	if err != nil {
 		return nil, err
@@ -2039,7 +2069,9 @@ func (r *rpcServer) CloseChannel(in *lnrpc.CloseChannelRequest,
 
 	// If force closing a channel, the fee set in the commitment transaction
 	// is used.
-	if in.Force && (in.SatPerByte != 0 || in.TargetConf != 0) {
+	if in.Force && (in.SatPerByte != 0 || in.SatPerVbyte != 0 ||
+		in.TargetConf != 0) {
+
 		return fmt.Errorf("force closing a channel uses a pre-defined fee")
 	}
 
@@ -2171,14 +2203,9 @@ func (r *rpcServer) CloseChannel(in *lnrpc.CloseChannelRequest,
 		// Based on the passed fee related parameters, we'll determine
 		// an appropriate fee rate for the cooperative closure
 		// transaction.
-		satPerKw := chainfee.SatPerKVByte(
+		feeRate, err := calculateFeeRate(
-			in.SatPerByte * 1000,
+			uint64(in.SatPerByte), in.SatPerVbyte,
-		).FeePerKWeight()
+			uint32(in.TargetConf), r.server.cc.FeeEstimator,
-		feeRate, err := sweep.DetermineFeePerKw(
-			r.server.cc.FeeEstimator, sweep.FeePreference{
-				ConfTarget: uint32(in.TargetConf),
-				FeeRate:    satPerKw,
-			},
 		)
 		if err != nil {
 			return err

server.go

@@ -1245,12 +1245,12 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 		policy := wtpolicy.DefaultPolicy()
 
 		if cfg.WtClient.SweepFeeRate != 0 {
-			// We expose the sweep fee rate in sat/byte, but the
+			// We expose the sweep fee rate in sat/vbyte, but the
 			// tower protocol operations on sat/kw.
-			sweepRateSatPerByte := chainfee.SatPerKVByte(
+			sweepRateSatPerVByte := chainfee.SatPerKVByte(
 				1000 * cfg.WtClient.SweepFeeRate,
 			)
-			policy.SweepFeeRate = sweepRateSatPerByte.FeePerKWeight()
+			policy.SweepFeeRate = sweepRateSatPerVByte.FeePerKWeight()
 		}
 
 		if err := policy.Validate(); err != nil {