tapchannel: check for feature bits before opening chans

With the way the protocol works as is, we signal the optional feature
bit, so connections can be made with older peers. Rather than timeout
after they don't recognize our custom message, we'll instead use the
feature bits to detect early if they don't understand the new protocol.

Fixes #1038

Author: Roasbeef

feature_bit_verifier.go

@@ -0,0 +1,54 @@
+package taprootassets
+
+import (
+	"context"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/lightninglabs/lndclient"
+	"github.com/lightninglabs/taproot-assets/tapchannel"
+	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/lightningnetwork/lnd/routing/route"
+)
+
+// LndFeatureBitVerifier is a struct that verifies that the feature bits of a
+// target connected peer, using our registered lnd node.
+type LndFeatureBitVerifier struct {
+	lnd *lndclient.LndServices
+}
+
+// NewLndFeatureBitVerifier creates a new LndFeatureBitVerifier instance.
+func NewLndFeatureBitVerifier(
+	lnd *lndclient.LndServices) *LndFeatureBitVerifier {
+
+	return &LndFeatureBitVerifier{
+		lnd: lnd,
+	}
+}
+
+// HasFeature returns true if the peer has the given feature bit set. If the
+// peer can't be found, then ErrNoPeer is returned.
+func (l *LndFeatureBitVerifier) HasFeature(ctx context.Context,
+	peerPub btcec.PublicKey, bit lnwire.FeatureBit) (bool, error) {
+
+	peerBytes := route.NewVertex(&peerPub)
+
+	peers, err := l.lnd.Client.ListPeers(ctx)
+	if err != nil {
+		return false, err
+	}
+
+	for _, peer := range peers {
+		if peer.Pubkey != peerBytes {
+			continue
+		}
+
+		return peer.Features.HasFeature(bit), nil
+	}
+
+	// If we get to this point, we weren't able to find the peer.
+	return false, tapchannel.ErrNoPeer
+}
+
+// A compile-time check to ensure that LndFeatureBitVerifier implements the
+// FeatureBitVerifier interface.
+var _ tapchannel.FeatureBitVerifer = (*LndFeatureBitVerifier)(nil)

tapcfg/server.go

@@ -102,6 +102,7 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 	msgTransportClient := tap.NewLndMsgTransportClient(lndServices)
 	lndRouterClient := tap.NewLndRouterClient(lndServices)
 	lndInvoicesClient := tap.NewLndInvoicesClient(lndServices)
+	lndFeatureBitsVerifier := tap.NewLndFeatureBitVerifier(lndServices)
 
 	uniDB := tapdb.NewTransactionExecutor(
 		db, func(tx *sql.Tx) tapdb.BaseUniverseStore {
@@ -434,6 +435,7 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 			TxSender:           chainPorter,
 			DefaultCourierAddr: proofCourierAddr,
 			AssetSyncer:        addrBook,
+			FeatureBits:        lndFeatureBitsVerifier,
 		},
 	)
 	auxTrafficShaper := tapchannel.NewAuxTrafficShaper(

tapchannel/aux_funding_controller.go

@@ -70,6 +70,18 @@ type PeerMessenger interface {
 		msg lnwire.Message) error
 }
 
+// ErrNoPeer is returned when a peer can't be found.
+var ErrNoPeer = errors.New("peer not found")
+
+// FeatureBitVerifer is an interface that allows us to verify that a peer has a
+// given feature bit set.
+type FeatureBitVerifer interface {
+	// HasFeature returns true if the peer has the given feature bit set.
+	// If the peer can't be found, then ErrNoPeer is returned.
+	HasFeature(ctx context.Context, peerPub btcec.PublicKey,
+		bit lnwire.FeatureBit) (bool, error)
+}
+
 // OpenChanReq is a request to open a new asset channel with a remote peer.
 type OpenChanReq struct {
 	// ChanAmt is the amount of BTC to put into the channel. Some BTC is
@@ -200,6 +212,10 @@ type FundingControllerCfg struct {
 	// AssetSyncer is used to ensure that we've already verified the asset
 	// genesis for any assets used within channels.
 	AssetSyncer AssetSyncer
+
+	// FeatureBits is used to verify that the peer has the required feature
+	// to fund asset channels.
+	FeatureBits FeatureBitVerifer
 }
 
 // bindFundingReq is a request to bind a pending channel ID to a complete aux
@@ -1321,6 +1337,21 @@ func (f *FundingController) processFundingMsg(ctx context.Context,
 func (f *FundingController) processFundingReq(fundingFlows fundingFlowIndex,
 	fundReq *FundReq) error {
 
+	// Before we even attempt funding, let's make sure that the remote peer
+	// actually supports the feature bit.
+	supportsAssetChans, err := f.cfg.FeatureBits.HasFeature(
+		fundReq.ctx, fundReq.PeerPub,
+		lnwire.SimpleTaprootOverlayChansOptional,
+	)
+	if err != nil {
+		return fmt.Errorf("unable to query peer feature bits: %w", err)
+	}
+
+	if !supportsAssetChans {
+		return fmt.Errorf("peer %x does not support asset channels",
+			fundReq.PeerPub.SerializeCompressed())
+	}
+
 	// To start, we'll make a new pending asset funding desc. This'll be
 	// our scratch pad during the asset funding process.
 	tempPID, err := newPendingChanID()