temp: contractcourt+lnrpc: supply budget when sweeping inputs

Need more work here to determine the proper budget.

Author: yyforyongyu

contractcourt/anchor_resolver.go

@@ -118,6 +118,13 @@ func (c *anchorResolver) Resolve() (ContractResolver, error) {
 			Fee: sweep.FeeEstimateInfo{
 				FeeRate: relayFeeRate,
 			},
+			// For normal anchor sweeping ,the budget is 330 sats.
+			Budget: btcutil.Amount(
+				anchorInput.SignDesc().Output.Value,
+			),
+
+			// TODO(yy): specify a no deadline here.
+			// DeadlineHeight: ,
 		},
 	)
 	if err != nil {

contractcourt/channel_arbitrator.go

@@ -1364,6 +1364,16 @@ func (c *ChannelArbitrator) sweepAnchors(anchors *lnwallet.AnchorResolutions,
 				},
 				Force:          force,
 				ExclusiveGroup: &exclusiveGroup,
+
+				// TODO(yy): we need to figure out what the
+				// budget is here based on the context - for
+				// CPFP purpose, the budget is the total value
+				// under protection.
+				Budget: anchor.CommitFee,
+
+				// For CPFP purpose anchors, the deadline is
+				// defined above.
+				DeadlineHeight: int32(deadline + heightHint),
 			},
 		)
 		if err != nil {

contractcourt/commit_sweep_resolver.go

@@ -352,7 +352,19 @@ func (c *commitSweepResolver) Resolve() (ContractResolver, error) {
 	c.log.Infof("sweeping commit output")
 
 	feePref := sweep.FeeEstimateInfo{ConfTarget: commitOutputConfTarget}
-	resultChan, err := c.Sweeper.SweepInput(inp, sweep.Params{Fee: feePref})
+	resultChan, err := c.Sweeper.SweepInput(
+		inp, sweep.Params{
+			Fee: feePref,
+
+			// TODO(yy): make this configurable as the budget can
+			// be large here.
+			Budget: btcutil.Amount(inp.SignDesc().Output.Value),
+
+			// TODO(yy): specify a default deadline here as there's
+			// no time pressure.
+			// DeadlineHeight: ,
+		},
+	)
 	if err != nil {
 		c.log.Errorf("unable to sweep input: %v", err)
 

contractcourt/htlc_success_resolver.go

@@ -266,6 +266,16 @@ func (h *htlcSuccessResolver) broadcastReSignedSuccessTx() (
 				Fee: sweep.FeeEstimateInfo{
 					ConfTarget: secondLevelConfTarget,
 				},
+
+				// TODO(yy): make this a user-config option.
+				Budget: btcutil.Amount(
+					secondLevelInput.SignDesc().Output.Value,
+				),
+
+				// TODO(yy): find the deadline - for first
+				// level success tx, it needs to be confirmed
+				// before the to remote CLTV.
+				// DeadlineHeight:
 			},
 		)
 		if err != nil {
@@ -378,6 +388,13 @@ func (h *htlcSuccessResolver) broadcastReSignedSuccessTx() (
 			Fee: sweep.FeeEstimateInfo{
 				ConfTarget: sweepConfTarget,
 			},
+
+			// TODO(yy): make this a user-config option.
+			Budget: btcutil.Amount(inp.SignDesc().Output.Value),
+
+			// TODO(yy): find the deadline here - for second level
+			// success tx, there's no rush to get it confirmed.
+			// DeadlineHeight:
 		},
 	)
 	if err != nil {

contractcourt/htlc_timeout_resolver.go

@@ -483,13 +483,20 @@ func (h *htlcTimeoutResolver) sweepSecondLevelTx() error {
 			h.broadcastHeight,
 		))
 	}
+
 	_, err := h.Sweeper.SweepInput(
 		inp,
 		sweep.Params{
 			Fee: sweep.FeeEstimateInfo{
 				ConfTarget: secondLevelConfTarget,
 			},
 			Force: true,
+
+			// TODO(yy): make this a user-config option.
+			Budget: btcutil.Amount(inp.SignDesc().Output.Value),
+
+			// TODO(yy): specify a no-deadline here.
+			// DeadlineHeight:
 		},
 	)
 	if err != nil {
@@ -699,12 +706,38 @@ func (h *htlcTimeoutResolver) handleCommitSpend(
 			h.htlcResolution.CsvDelay, h.broadcastHeight,
 			h.htlc.RHash,
 		)
+		// Get the tx-level nLocktime for this HTLC.
+		nLocktime, required := inp.RequiredLockTime()
+		if !required {
+			log.Errorf("%T(%x): second level tx not timelocked", h,
+				h.htlc.RHash[:])
+		}
+
 		_, err = h.Sweeper.SweepInput(
 			inp,
 			sweep.Params{
 				Fee: sweep.FeeEstimateInfo{
 					ConfTarget: sweepConfTarget,
 				},
+
+				// TODO(yy): make this a user-config option.
+				Budget: btcutil.Amount(
+					inp.SignDesc().Output.Value,
+				),
+
+				// For first level timeout tx, we'll use the
+				// nLocktime as the deadline, tho the actual
+				// deadline should be the CTLV inside this
+				// HTLC's corresponding incoming HTLC. It's ok
+				// if the tx is not cofnirmed by nLocktime, as
+				// if the remote decides to go with the
+				// preimage path, we will notice the preimage
+				// and settled the incoming HTLC anyway. We
+				// still need to set a deadline here, as it's
+				// required that when grouping
+				// SINGLE|ANYONECANPAY txes, the nLocktime of
+				// all inputs must be the same.
+				DeadlineHeight: int32(nLocktime),
 			},
 		)
 		if err != nil {

contractcourt/utxonursery.go

@@ -830,8 +830,14 @@ func (u *UtxoNursery) sweepMatureOutputs(classHeight uint32,
 		local := output
 
 		resultChan, err := u.cfg.SweepInput(&local, sweep.Params{
-			Fee:   feePref,
-			Force: true,
+			Fee:    feePref,
+			Force:  true,
+			Budget: local.Amount(),
+			// TODO(yy): specify a default deadline here as there's
+			// no time pressure.
+			//
+			// TODO(yy): unify UtxoSweeper and UtxoNursery.
+			// DeadlineHeight: ,
 		})
 		if err != nil {
 			return err

lnrpc/walletrpc/walletkit_server.go

@@ -938,6 +938,8 @@ func UnmarshallOutPoint(op *lnrpc.OutPoint) (*wire.OutPoint, error) {
 // the output should be swept on-chain within. If a fee preference is not
 // explicitly specified, then an error is returned. The status of the input
 // sweep can be checked through the PendingSweeps RPC.
+//
+// TODO(yy): redefine this method to provide a guaranteed fee bumping.
 func (w *WalletKit) BumpFee(ctx context.Context,
 	in *BumpFeeRequest) (*BumpFeeResponse, error) {