tapchannel+tapsend: disable STXO asset creation for channels

To avoid breaking backward compatibility with older nodes and existing
channels, we need to make sure we don't add STXO proofs to channel
related transactions.

Author: guggero

tapchannel/aux_closer.go

@@ -453,7 +453,9 @@ func (a *AuxChanCloser) AuxCloseOutputs(
 	// With the outputs prepared, we can now create the set of output
 	// commitments, then with the output index locations known, we can set
 	// the output indexes in the allocations.
-	outCommitments, err := tapsend.CreateOutputCommitments(vPackets)
+	outCommitments, err := tapsend.CreateOutputCommitments(
+		vPackets, tapsend.WithNoSTXOProofs(),
+	)
 	if err != nil {
 		return none, fmt.Errorf("unable to create output "+
 			"commitments: %w", err)

tapchannel/aux_funding_controller.go

@@ -1080,7 +1080,9 @@ func (f *FundingController) anchorVPackets(fundedPkt *tapsend.FundedPsbt,
 
 	// Given the set of vPackets we've created, we'll now merge them all to
 	// create a map from output index to final tap commitment.
-	outputCommitments, err := tapsend.CreateOutputCommitments(allPackets)
+	outputCommitments, err := tapsend.CreateOutputCommitments(
+		allPackets, tapsend.WithNoSTXOProofs(),
+	)
 	if err != nil {
 		return nil, fmt.Errorf("unable to create new output "+
 			"commitments: %w", err)

tapchannel/aux_sweeper.go

@@ -1590,7 +1590,9 @@ func (a *AuxSweeper) importCommitTx(req lnwallet.ResolutionReq,
 			"packets: %w", err)
 	}
 
-	outCommitments, err := tapsend.CreateOutputCommitments(vPackets)
+	outCommitments, err := tapsend.CreateOutputCommitments(
+		vPackets, tapsend.WithNoSTXOProofs(),
+	)
 	if err != nil {
 		return fmt.Errorf("unable to create output "+
 			"commitments: %w", err)
@@ -2219,7 +2221,9 @@ func (a *AuxSweeper) sweepContracts(inputs []input.Input,
 
 	// Now that we have our set of resolutions, we'll make a new commitment
 	// out of all the vPackets contained.
-	outCommitments, err := tapsend.CreateOutputCommitments(directPkts)
+	outCommitments, err := tapsend.CreateOutputCommitments(
+		directPkts, tapsend.WithNoSTXOProofs(),
+	)
 	if err != nil {
 		return lfn.Errf[returnType]("unable to create "+
 			"output commitments: %w", err)
@@ -2400,7 +2404,9 @@ func (a *AuxSweeper) registerAndBroadcastSweep(req *sweep.BumpRequest,
 	}
 
 	// 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(), tapsend.WithNoSTXOProofs(),
+	)
 	if err != nil {
 		return fmt.Errorf("unable to create output "+
 			"commitments: %w", err)

tapchannel/commitment.go

@@ -575,7 +575,9 @@ func GenerateCommitmentAllocations(prevState *cmsg.Commitment,
 			"packets: %w", err)
 	}
 
-	outCommitments, err := tapsend.CreateOutputCommitments(vPackets)
+	outCommitments, err := tapsend.CreateOutputCommitments(
+		vPackets, tapsend.WithNoSTXOProofs(),
+	)
 	if err != nil {
 		return nil, nil, fmt.Errorf("unable to create output "+
 			"commitments: %w", err)
@@ -1423,7 +1425,9 @@ func CreateSecondLevelHtlcTx(chanState lnwallet.AuxChanState,
 			"packets: %w", err)
 	}
 
-	outCommitments, err := tapsend.CreateOutputCommitments(vPackets)
+	outCommitments, err := tapsend.CreateOutputCommitments(
+		vPackets, tapsend.WithNoSTXOProofs(),
+	)
 	if err != nil {
 		return none, fmt.Errorf("unable to create output commitments: "+
 			"%w", err)

tapsend/send.go

@@ -909,11 +909,38 @@ func addKeyTweaks(unknowns []*psbt.Unknown, desc *lndclient.SignDescriptor) {
 	}
 }
 
+// OutputCommitmentConfig is a struct that holds the configuration for the
+// output commitment creation process.
+type OutputCommitmentConfig struct {
+	// noSTXOProofs indicates whether we should skip the generation of
+	// STXO proofs. This should only be done for asset channels to preserve
+	// the backward compatibility with older peers.
+	noSTXOProofs bool
+}
+
+// OutputCommitmentOption is a functional option that can be used to configure
+// the output commitment creation process.
+type OutputCommitmentOption func(*OutputCommitmentConfig)
+
+// WithNoSTXOProofs is an option that can be used to skip the generation of
+// STXO proofs. This should only be done for asset channels to preserve the
+// backward compatibility with older peers.
+func WithNoSTXOProofs() OutputCommitmentOption {
+	return func(cfg *OutputCommitmentConfig) {
+		cfg.noSTXOProofs = true
+	}
+}
+
 // CreateOutputCommitments creates the final set of Taproot asset commitments
 // representing the asset sends of the given packets of active and passive
 // assets.
-func CreateOutputCommitments(
-	packets []*tappsbt.VPacket) (tappsbt.OutputCommitments, error) {
+func CreateOutputCommitments(packets []*tappsbt.VPacket,
+	opts ...OutputCommitmentOption) (tappsbt.OutputCommitments, error) {
+
+	cfg := &OutputCommitmentConfig{}
+	for _, opt := range opts {
+		opt(cfg)
+	}
 
 	// Inputs must be unique.
 	if err := AssertInputsUnique(packets); err != nil {
@@ -948,7 +975,7 @@ func CreateOutputCommitments(
 	// And now we commit each packet to the respective anchor output
 	// commitments.
 	for _, vPkt := range packets {
-		err := commitPacket(vPkt, outputCommitments)
+		err := commitPacket(vPkt, cfg.noSTXOProofs, outputCommitments)
 		if err != nil {
 			return nil, err
 		}
@@ -959,7 +986,7 @@ func CreateOutputCommitments(
 
 // commitPacket creates the output commitments for a virtual packet and merges
 // it with the existing commitments for the anchor outputs.
-func commitPacket(vPkt *tappsbt.VPacket,
+func commitPacket(vPkt *tappsbt.VPacket, noSTXOProofs bool,
 	outputCommitments tappsbt.OutputCommitments) error {
 
 	inputs := vPkt.Inputs
@@ -995,17 +1022,21 @@ func commitPacket(vPkt *tappsbt.VPacket,
 			return fmt.Errorf("error committing assets: %w", err)
 		}
 
-		// Collect the spent assets for this output.
-		stxoAssets, err := asset.CollectSTXO(vOut.Asset)
-		if err != nil {
-			return fmt.Errorf("error collecting STXO assets: %w",
-				err)
-		}
+		// To not break backward compatibility with older peers, we skip
+		// the generation of STXO proofs for asset channels.
+		if !noSTXOProofs {
+			// Collect the spent assets for this output.
+			stxoAssets, err := asset.CollectSTXO(vOut.Asset)
+			if err != nil {
+				return fmt.Errorf("error collecting STXO "+
+					"assets: %w", err)
+			}
 
-		// If we have STXOs, we will encumber vOut.AltLeaves with
-		// them.They will be merged into the commitment later with
-		// MergeAltLeaves.
-		vOut.AltLeaves = append(vOut.AltLeaves, stxoAssets...)
+			// If we have STXOs, we will encumber vOut.AltLeaves
+			// with them. They will be merged into the commitment
+			// later with MergeAltLeaves.
+			vOut.AltLeaves = append(vOut.AltLeaves, stxoAssets...)
+		}
 
 		// Because the receiver of this output might be receiving
 		// through an address (non-interactive), we need to blank out