tapchannel: include stxo proofs on channel funding

This commit updates the aux funding controller to conditionally use stxo
proofs, depending on whether the feature bit was negotiated or not with
the remote peer. Our funding commitment will now include the alt leaves
for stxos if the flag is set.

The funder needs to construct the correct tapscript early on, as LND
will query the tapscript root before we reach the finalization phase.
That's why we manually calculate and merge the stxo alt leaves in the
funding process.

The fundee now also needs to calculate and merge the alt leaves that
result from the asset outputs, in order to arrive to the same tapscript
root.

Author: GeorgeTsagk

tapcfg/server.go

@@ -628,6 +628,7 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 			AssetSyncer:        addrBook,
 			FeatureBits:        lndFeatureBitsVerifier,
 			IgnoreChecker:      ignoreCheckerOpt,
+			AuxChanNegotiator:  auxChanNegotiator,
 			ErrChan:            mainErrChan,
 		},
 	)

tapchannel/aux_funding_controller.go

@@ -28,6 +28,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/rfq"
 	cmsg "github.com/lightninglabs/taproot-assets/tapchannelmsg"
 	"github.com/lightninglabs/taproot-assets/tapdb"
+	"github.com/lightninglabs/taproot-assets/tapfeatures"
 	"github.com/lightninglabs/taproot-assets/tapfreighter"
 	"github.com/lightninglabs/taproot-assets/tapgarden"
 	"github.com/lightninglabs/taproot-assets/tappsbt"
@@ -41,6 +42,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/msgmux"
+	"github.com/lightningnetwork/lnd/routing/route"
 )
 
 const (
@@ -269,6 +271,11 @@ type FundingControllerCfg struct {
 	// a proof should be ignored.
 	IgnoreChecker lfn.Option[proof.IgnoreChecker]
 
+	// AuxChanNegotiator is responsible for producing the extra tlv blob
+	// that is encapsulated in the init and reestablish peer messages. This
+	// helps us communicate custom feature bits with our peer.
+	AuxChanNegotiator *tapfeatures.AuxChannelNegotiator
+
 	// ErrChan is used to report errors back to the main server.
 	ErrChan chan<- error
 }
@@ -419,6 +426,8 @@ type pendingAssetFunding struct {
 
 	initiator bool
 
+	stxo bool
+
 	amt uint64
 
 	pushAmt btcutil.Amount
@@ -462,14 +471,32 @@ func (p *pendingAssetFunding) assetOutputs() []*cmsg.AssetOutput {
 }
 
 // addToFundingCommitment adds a new asset to the funding commitment.
-func (p *pendingAssetFunding) addToFundingCommitment(a *asset.Asset) error {
+func (p *pendingAssetFunding) addToFundingCommitment(a *asset.Asset,
+	stxo bool) error {
+
 	newCommitment, err := commitment.FromAssets(
 		fn.Ptr(commitment.TapCommitmentV2), a,
 	)
 	if err != nil {
 		return fmt.Errorf("unable to create commitment: %w", err)
 	}
 
+	// If our peer supports STXO we go ahead and append the
+	// appropriate alt leaves to the VOutput.
+	if stxo {
+		altLeaves, err := asset.CollectSTXO(a)
+		if err != nil {
+			return err
+		}
+
+		err = newCommitment.MergeAltLeaves(altLeaves)
+		if err != nil {
+			return err
+		}
+
+		p.stxo = stxo
+	}
+
 	newCommitment, err = commitment.TrimSplitWitnesses(
 		&newCommitment.Version, newCommitment,
 	)
@@ -524,7 +551,8 @@ func (p *pendingAssetFunding) addInputProofChunk(
 func newCommitBlobAndLeaves(pendingFunding *pendingAssetFunding,
 	lndOpenChan lnwallet.AuxChanState, assetOpenChan *cmsg.OpenChannel,
 	keyRing lntypes.Dual[lnwallet.CommitmentKeyRing],
-	whoseCommit lntypes.ChannelParty) ([]byte, lnwallet.CommitAuxLeaves,
+	whoseCommit lntypes.ChannelParty,
+	stxo bool) ([]byte, lnwallet.CommitAuxLeaves,
 	error) {
 
 	chanAssets := assetOpenChan.FundedAssets.Val.Outputs
@@ -571,7 +599,7 @@ func newCommitBlobAndLeaves(pendingFunding *pendingAssetFunding,
 		fakePrevState, lndOpenChan, assetOpenChan, whoseCommit,
 		localSatBalance, remoteSatBalance, fakeView,
 		pendingFunding.chainParams, keyRing.GetForParty(whoseCommit),
-		false,
+		stxo,
 	)
 	if err != nil {
 		return nil, lnwallet.CommitAuxLeaves{}, err
@@ -614,12 +642,14 @@ func (p *pendingAssetFunding) toAuxFundingDesc(req *bindFundingReq,
 	// This will be the information for the very first state (state 0).
 	localCommitBlob, localAuxLeaves, err := newCommitBlobAndLeaves(
 		p, req.openChan, openChanDesc, req.keyRing, lntypes.Local,
+		p.stxo,
 	)
 	if err != nil {
 		return nil, err
 	}
 	remoteCommitBlob, remoteAuxLeaves, err := newCommitBlobAndLeaves(
 		p, req.openChan, openChanDesc, req.keyRing, lntypes.Remote,
+		p.stxo,
 	)
 	if err != nil {
 		return nil, err
@@ -1087,14 +1117,19 @@ func (f *FundingController) signAllVPackets(ctx context.Context,
 // complete, but unsigned PSBT packet that can be used to create out asset
 // channel.
 func (f *FundingController) anchorVPackets(fundedPkt *tapsend.FundedPsbt,
-	allPackets []*tappsbt.VPacket) ([]*proof.Proof, error) {
+	allPackets []*tappsbt.VPacket, stxo bool) ([]*proof.Proof, error) {
 
 	log.Infof("Anchoring funding vPackets to funding PSBT")
 
+	var opts []tapsend.OutputCommitmentOption
+	if !stxo {
+		opts = append(opts, tapsend.WithNoSTXOProofs())
+	}
+
 	// 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, tapsend.WithNoSTXOProofs(),
+		allPackets, opts...,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("unable to create new output "+
@@ -1123,11 +1158,16 @@ func (f *FundingController) anchorVPackets(fundedPkt *tapsend.FundedPsbt,
 	for idx := range allPackets {
 		vPkt := allPackets[idx]
 
+		var opts []proof.GenOption
+		if !stxo {
+			opts = append(opts, proof.WithNoSTXOProofs())
+		}
+
 		for vOutIdx := range vPkt.Outputs {
 			proofSuffix, err := tapsend.CreateProofSuffix(
 				fundedPkt.Pkt.UnsignedTx, fundedPkt.Pkt.Outputs,
 				vPkt, outputCommitments, vOutIdx, allPackets,
-				proof.WithNoSTXOProofs(),
+				opts...,
 			)
 			if err != nil {
 				return nil, fmt.Errorf("unable to create "+
@@ -1220,7 +1260,8 @@ func (f *FundingController) sendAssetFundingCreated(ctx context.Context,
 // ultimately broadcasting the funding transaction.
 func (f *FundingController) completeChannelFunding(ctx context.Context,
 	fundingState *pendingAssetFunding,
-	fundedVpkt *tapfreighter.FundedVPacket) (*wire.OutPoint, error) {
+	fundedVpkt *tapfreighter.FundedVPacket,
+	stxoEnabled bool) (*wire.OutPoint, error) {
 
 	log.Debugf("Finalizing funding vPackets and PSBT...")
 
@@ -1331,7 +1372,7 @@ func (f *FundingController) completeChannelFunding(ctx context.Context,
 	// PSBT. This'll update all the pkScripts for our funding output and
 	// change.
 	fundingOutputProofs, err := f.anchorVPackets(
-		finalFundedPsbt, signedPkts,
+		finalFundedPsbt, signedPkts, stxoEnabled,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("unable to anchor vPackets: %w", err)
@@ -1546,11 +1587,17 @@ func (f *FundingController) processFundingMsg(ctx context.Context,
 				"proof: %w", err)
 		}
 
+		features := f.cfg.AuxChanNegotiator.GetPeerFeatures(
+			route.Vertex(msg.PeerPub.SerializeCompressed()),
+		)
+
+		supportSTXO := features.HasFeature(tapfeatures.STXOOptional)
+
 		// If we reached this point, then the asset output and all
 		// inputs are valid, so we'll store the funding asset
 		// commitment.
 		err = assetFunding.addToFundingCommitment(
-			&assetProof.AssetOutput.Val,
+			&assetProof.AssetOutput.Val, supportSTXO,
 		)
 		if err != nil {
 			return tempPID, fmt.Errorf("unable to create "+
@@ -1739,6 +1786,15 @@ func (f *FundingController) processFundingReq(fundingFlows fundingFlowIndex,
 			maxNumAssetIDs)
 	}
 
+	// Now let's see if we should be using STXOs for this channel funding.
+	features := f.cfg.AuxChanNegotiator.GetPeerFeatures(
+		route.Vertex(fundReq.PeerPub.SerializeCompressed()),
+	)
+
+	supportSTXO := features.HasFeature(tapfeatures.STXOOptional)
+
+	fundingState.stxo = supportSTXO
+
 	// Now that we know the final funding asset root along with the splits,
 	// we can derive the tapscript root that'll be used alongside the
 	// internal key (which we'll only learn from lnd later as we finalize
@@ -1751,7 +1807,7 @@ func (f *FundingController) processFundingReq(fundingFlows fundingFlowIndex,
 		}
 
 		err = fundingState.addToFundingCommitment(
-			fundingOut.Asset.Copy(),
+			fundingOut.Asset.Copy(), supportSTXO,
 		)
 		if err != nil {
 			return fmt.Errorf("unable to add asset to funding "+
@@ -1815,7 +1871,7 @@ func (f *FundingController) processFundingReq(fundingFlows fundingFlowIndex,
 		}
 
 		chanPoint, err := f.completeChannelFunding(
-			fundReq.ctx, fundingState, fundingVpkt,
+			fundReq.ctx, fundingState, fundingVpkt, supportSTXO,
 		)
 		if err != nil {
 			// If anything went wrong during the funding process,