tapchannel+tapchannelmsg: check quote vs. channel compat

During pathfinding, when an HTLC doesn't have an asset ID or group key
encoded, we can only find out if a channel is compatible after looking
at the specifier of the quote.
We add that to make sure pathfinding doesn't give false positives for
channels that then can't be used because they're not compatible.

Author: guggero

tapchannel/aux_traffic_shaper.go

@@ -228,7 +228,7 @@ func (s *AuxTrafficShaper) PaymentBandwidth(fundingBlob, htlcBlob,
 	// Otherwise, we derive the available bandwidth from the HTLC's RFQ and
 	// the asset units in our local balance.
 	return s.paymentBandwidth(
-		htlc, computedLocal, linkBandwidth, minHtlcAmt,
+		htlc, computedLocal, linkBandwidth, minHtlcAmt, fundingChan,
 	)
 }
 
@@ -279,8 +279,8 @@ func paymentBandwidthAssetUnits(htlcAssetAmount, computedLocal uint64,
 // on the asset rate of the RFQ quote that is included in the HTLC and the asset
 // units of the local balance.
 func (s *AuxTrafficShaper) paymentBandwidth(htlc *rfqmsg.Htlc,
-	localBalance uint64, linkBandwidth,
-	minHtlcAmt lnwire.MilliSatoshi) (lnwire.MilliSatoshi, error) {
+	localBalance uint64, linkBandwidth, minHtlcAmt lnwire.MilliSatoshi,
+	fundingChan *cmsg.OpenChannel) (lnwire.MilliSatoshi, error) {
 
 	// If the HTLC doesn't have an RFQ ID, it's incomplete, and we cannot
 	// determine the bandwidth.
@@ -301,19 +301,34 @@ func (s *AuxTrafficShaper) paymentBandwidth(htlc *rfqmsg.Htlc,
 	sellQuote, isSellQuote := acceptedSellQuotes[rfqID.Scid()]
 	buyQuote, isBuyQuote := acceptedBuyQuotes[rfqID.Scid()]
 
-	var rate rfqmsg.AssetRate
+	var (
+		rate      rfqmsg.AssetRate
+		specifier asset.Specifier
+	)
 	switch {
 	case isSellQuote:
 		rate = sellQuote.AssetRate
+		specifier = sellQuote.Request.AssetSpecifier
 
 	case isBuyQuote:
 		rate = buyQuote.AssetRate
+		specifier = buyQuote.Request.AssetSpecifier
 
 	default:
 		return 0, fmt.Errorf("no accepted quote found for RFQ ID "+
 			"%x (SCID %d)", rfqID[:], rfqID.Scid())
 	}
 
+	// Now that we found the quote, we can determine if this quote is even
+	// compatible with this channel. If not, we cannot forward the HTLC
+	// and should return 0 bandwidth.
+	if !fundingChan.Compatible(specifier) {
+		log.Tracef("Quote with ID %x (SCID %d) not compatible with "+
+			"channel assets, returning 0 bandwidth", rfqID[:],
+			rfqID.Scid())
+		return 0, nil
+	}
+
 	// Calculate the local available balance in the local asset unit,
 	// expressed in milli-satoshis.
 	localBalanceFp := rfqmath.NewBigIntFixedPoint(localBalance, 0)

tapchannelmsg/records.go

@@ -229,6 +229,34 @@ func (o *OpenChannel) HasAllAssetIDs(ids fn.Set[asset.ID]) bool {
 	return ids.Subset(availableIDs)
 }
 
+// Compatible checks if the OpenChannel is compatible with the given asset
+// specifier.
+func (o *OpenChannel) Compatible(specifier asset.Specifier) bool {
+	switch {
+	case specifier.HasGroupPubKey():
+		targetGroupKey := specifier.UnwrapGroupKeyToPtr()
+		if targetGroupKey == nil {
+			return false
+		}
+
+		// If the specifier has a group key, then we must have a group
+		// key set on the OpenChannel.
+		return lfn.MapOptionZ(
+			o.GroupKey.ValOpt(),
+			func(groupKey *btcec.PublicKey) bool {
+				return targetGroupKey.IsEqual(groupKey)
+			},
+		)
+
+	default:
+		// If the specifier has an asset ID, we check if that ID is
+		// contained within the OpenChannel's assets.
+		return fn.MapOptionZ(specifier.ID(), func(id asset.ID) bool {
+			return o.HasAllAssetIDs(fn.NewSet(id))
+		})
+	}
+}
+
 // DecodeOpenChannel deserializes an OpenChannel from the given blob.
 func DecodeOpenChannel(blob tlv.Blob) (*OpenChannel, error) {
 	var o OpenChannel