tapchannel: update registerAndBroadcastSweep for HTLC sweeps

In this commit, we update `registerAndBroadcastSweep` to be able to
handle HTLC sweeps.

First, we only need to set the anchor for first level sweeps.

We weren't able to sign the 2nd level sweeps earlier as we didn't know
the txid of the transaction that swept them. Now that we're about to
broadcast, we know the sweeping transaction so we can set the prevID
properly, then sign the sweeping transaction.

If the sweeper is broadcasting _just_ a second level txn with an asset,
then we won't have an extra change output. This transaction also already
has its internal key bound.

Author: Roasbeef

tapchannel/aux_sweeper.go

@@ -446,6 +446,20 @@ type vPktsWithInput struct {
 	tapSigDesc lfn.Option[cmsg.TapscriptSigDesc]
 }
 
+// isPresigned returns true if the vPktsWithInput is presigned. This will be the
+// for an HTLC spent directly from our local commitment transaction.
+func (v vPktsWithInput) isPresigned() bool {
+	witType := v.btcInput.WitnessType()
+	switch witType {
+	case input.TaprootHtlcAcceptedLocalSuccess:
+		return true
+	case input.TaprootHtlcLocalOfferedTimeout:
+		return true
+	default:
+		return false
+	}
+}
+
 // sweepVpkts contains the set of vPkts needed for sweeping an output. Most
 // outputs will only have the first level specified. The second level is needed
 // for HTLC outputs on our local commitment transaction.
@@ -487,6 +501,27 @@ func (s sweepVpkts) allPkts() []*tappsbt.VPacket {
 	return append(s.firstLevelPkts(), s.secondLevelPkts()...)
 }
 
+// allVpktsWithInput returns a slice of all vPktsWithInput.
+func (s sweepVpkts) allVpktsWithInput() []vPktsWithInput {
+	return append(s.firstLevel, s.secondLevel...)
+}
+
+// directSpendPkts returns the slice of all vPkts that are a direct spend from
+// the commitment transaction. This excludes vPkts that are the pre-signed 2nd
+// level transaction variant.
+func (s sweepVpkts) directSpendPkts() []*tappsbt.VPacket {
+	directSpends := lfn.Filter(func(vi vPktsWithInput) bool {
+		return !vi.isPresigned()
+	}, s.allVpktsWithInput())
+	directPkts := fn.FlatMap(
+		directSpends, func(v vPktsWithInput) []*tappsbt.VPacket {
+			return v.vPkts
+		},
+	)
+
+	return directPkts
+}
+
 // createAndSignSweepVpackets creates vPackets that sweep the funds from the
 // channel to the wallet, and then signs them as well.
 func (a *AuxSweeper) createAndSignSweepVpackets(
@@ -1726,6 +1761,7 @@ func (a *AuxSweeper) resolveContract(
 	default:
 		return lfn.Errf[returnType]("unknown resolution type: %v",
 			req.Type)
+		// TODO(roasbeef): need to do HTLC revocation casesj:w
 	}
 
 	// The input proofs above were made originally using the fake commit tx
@@ -1980,6 +2016,7 @@ func prepVpkts(bRes lfn.Result[blobWithWitnessInfo],
 // none of the inputs have any resolution blobs. Then an empty slice will be
 // returned.
 func extractInputVPackets(inputs []input.Input) lfn.Result[sweepVpkts] {
+
 	type returnType = sweepVpkts
 
 	// Otherwise, we'll extract the set of resolution blobs from the inputs
@@ -2207,34 +2244,86 @@ func (a *AuxSweeper) registerAndBroadcastSweep(req *sweep.BumpRequest,
 		return nil
 	}
 
-	ourSweepOutput, err := req.ExtraTxOut.UnwrapOrErr(
-		fmt.Errorf("extra tx out not populated"),
+	// If this is a transaction that's only sweeping HTLC outputs via a
+	// pre-signed transaction, then we won't actually have an extra sweep
+	// output.
+	err = lfn.MapOptionZ(
+		req.ExtraTxOut,
+		func(extraTxOut sweep.SweepOutput) error {
+			ourSweepOutput, err := req.ExtraTxOut.UnwrapOrErr(
+				fmt.Errorf("extra tx out not populated"),
+			)
+			if err != nil {
+				return err
+			}
+			iKey, err := ourSweepOutput.InternalKey.UnwrapOrErr(
+				fmt.Errorf("internal key not populated"),
+			)
+			if err != nil {
+				return err
+			}
+
+			// We'll also use the passed in context to set the
+			// anchor key again for all the vOuts, but only for
+			// first level vPkts, as second level packets already
+			// commit to the internal key of the vOut.
+			vPkts := vPkts.directSpendPkts()
+			for idx := range vPkts {
+				for _, vOut := range vPkts[idx].Outputs {
+					vOut.SetAnchorInternalKey(
+						iKey,
+						a.cfg.ChainParams.HDCoinType,
+					)
+				}
+			}
+
+			return nil
+		},
 	)
 	if err != nil {
 		return err
 	}
-	internalKey, err := ourSweepOutput.InternalKey.UnwrapOrErr(
-		fmt.Errorf("internal key not populated"),
-	)
-	if err != nil {
-		return err
+
+	// For any second level outputs we're sweeping, we'll need to sign for
+	// it, as now we know the txid of the sweeping transaction.
+	for _, sweepSet := range vPkts.secondLevel {
+		for _, vPkt := range sweepSet.vPkts {
+			for _, vIn := range vPkt.Inputs {
+				vIn.PrevID.OutPoint = sweepSet.btcInput.OutPoint()
+			}
+
+			for _, vOut := range vPkt.Outputs {
+				vOut.Asset.PrevWitnesses[0].PrevID.OutPoint = sweepSet.btcInput.OutPoint()
+			}
+		}
 	}
 
-	log.Infof("Using %x for internal key: ",
-		internalKey.PubKey.SerializeCompressed())
+	// If we have second level vPkts, then we'll need to sign them here, as
+	// now we know the input we're spending which was set above.
+	for _, sweepSet := range vPkts.secondLevel {
+		tapSigDesc, err := sweepSet.tapSigDesc.UnwrapOrErr(
+			fmt.Errorf("tap sig desc not populated"),
+		)
+		if err != nil {
+			return err
+		}
 
-	// We'll also use the passed in context to set the anchor key again for
-	// all the vOuts.
-	for idx := range vPkts.firstLevelPkts() {
-		for _, vOut := range vPkts.firstLevelPkts()[idx].Outputs {
-			vOut.SetAnchorInternalKey(
-				internalKey, a.cfg.ChainParams.HDCoinType,
-			)
+		err = a.signSweepVpackets(
+			sweepSet.vPkts, *sweepSet.btcInput.SignDesc(),
+			tapSigDesc.TapTweak.Val, tapSigDesc.CtrlBlock.Val,
+			lfn.None[lnwallet.AuxSigDesc](),
+			lfn.None[uint32](),
+		)
+		if err != nil {
+			return fmt.Errorf("unable to sign second level "+
+				"vPkts: %w", err)
 		}
 	}
 
 	// Now that we have our vPkts, we'll re-create the output commitments.
-	outCommitments, err := tapsend.CreateOutputCommitments(vPkts.allPkts())
+	outCommitments, err := tapsend.CreateOutputCommitments(
+		vPkts.allPkts(),
+	)
 	if err != nil {
 		return fmt.Errorf("unable to create output "+
 			"commitments: %w", err)