tapchannel+tapchannelmsg: add group key to funding blob

To be able to detect certain asset related routing conditions, we'll
want to commit the group key of assets into the funding blob of the
channel.

Author: guggero

rfqmsg/custom_channel_data.go

@@ -37,6 +37,7 @@ type JsonAssetChannel struct {
 	OutgoingHtlcs       []JsonAssetTranche `json:"outgoing_htlcs"`
 	IncomingHtlcs       []JsonAssetTranche `json:"incoming_htlcs"`
 	Capacity            uint64             `json:"capacity"`
+	GroupKey            string             `json:"group_key,omitempty"`
 	LocalBalance        uint64             `json:"local_balance"`
 	RemoteBalance       uint64             `json:"remote_balance"`
 	OutgoingHtlcBalance uint64             `json:"outgoing_htlc_balance"`

tapchannel/aux_funding_controller.go

@@ -576,15 +576,18 @@ func newCommitBlobAndLeaves(pendingFunding *pendingAssetFunding,
 // both sides are able to construct the funding output, and will be able to
 // store the appropriate funding blobs.
 func (p *pendingAssetFunding) toAuxFundingDesc(req *bindFundingReq,
-	decimalDisplay uint8) (*lnwallet.AuxFundingDesc, error) {
+	decimalDisplay uint8,
+	groupKey *btcec.PublicKey) (*lnwallet.AuxFundingDesc, error) {
 
 	// First, we'll map all the assets into asset outputs that'll be stored
 	// in the open channel struct on the lnd side.
 	assetOutputs := p.assetOutputs()
 
 	// With all the outputs assembled, we'll now map that to the open
 	// channel wrapper that'll go in the set of TLV blobs.
-	openChanDesc := cmsg.NewOpenChannel(assetOutputs, decimalDisplay)
+	openChanDesc := cmsg.NewOpenChannel(
+		assetOutputs, decimalDisplay, groupKey,
+	)
 
 	// Now we'll encode the 3 TLV blobs that lnd will store: the main one
 	// for the funding details, and then the blobs for the local and remote
@@ -1933,8 +1936,20 @@ func (f *FundingController) chanFunder() {
 				continue
 			}
 
+			groupKey, err := f.fundingAssetGroupKey(
+				ctxc, fundingFlow.assetOutputs(),
+			)
+			if err != nil {
+				fErr := fmt.Errorf("unable to determine group "+
+					"key: %w", err)
+				f.cfg.ErrReporter.ReportError(
+					ctxc, fundingFlow.peerPub, pid, fErr,
+				)
+				continue
+			}
+
 			fundingDesc, err := fundingFlow.toAuxFundingDesc(
-				req, decimalDisplay,
+				req, decimalDisplay, groupKey,
 			)
 			if err != nil {
 				fErr := fmt.Errorf("unable to create aux "+
@@ -2029,6 +2044,65 @@ func (f *FundingController) fundingAssetDecimalDisplay(ctx context.Context,
 	return decimalDisplay, nil
 }
 
+// fundingAssetGroupKey determines the group key of the funding asset(s). If no
+// group key was used to fund the channel, then nil is returned.
+func (f *FundingController) fundingAssetGroupKey(ctx context.Context,
+	assetOutputs []*cmsg.AssetOutput) (*btcec.PublicKey, error) {
+
+	// We now check the group key of each funding asset, to make sure we
+	// know the meta information for each asset. And we also verify that
+	// each asset tranche has the same group key.
+	var groupKey *btcec.PublicKey
+	for _, a := range assetOutputs {
+		info, err := f.cfg.AssetSyncer.QueryAssetInfo(
+			ctx, a.AssetID.Val,
+		)
+		switch {
+		// If the asset isn't a grouped asset (or we don't know the
+		// asset), then we just continue.
+		case errors.Is(err, address.ErrAssetGroupUnknown):
+			continue
+
+		case err != nil:
+			return nil, fmt.Errorf("unable to fetch group info: %w",
+				err)
+		}
+
+		switch {
+		// We haven't set the group key before and have found one now,
+		// perfect. Let's assume that's our group key we'll use.
+		case groupKey == nil && info.GroupKey != nil:
+			groupKey = &info.GroupKey.GroupPubKey
+
+		// If we already have a group key, then we need to verify that
+		// the group key of this asset matches the one we already have.
+		case groupKey != nil && info.GroupKey != nil:
+			if !groupKey.IsEqual(&info.GroupKey.GroupPubKey) {
+				return nil, fmt.Errorf("group key mismatch: "+
+					"expected %x, got %x",
+					groupKey.SerializeCompressed(),
+					info.GroupPubKey.SerializeCompressed())
+			}
+
+		// If a previous asset resulted in a group key, every following
+		// one must also result in the same one. If we can't find one
+		// now, it means we either don't know about the asset (not
+		// synced) or it's not a grouped asset.
+		case groupKey != nil && info.GroupKey == nil:
+			return nil, fmt.Errorf("group key mismatch: "+
+				"expected %x, got nil",
+				groupKey.SerializeCompressed())
+
+		// If we don't have a group key yet, and the asset isn't a
+		// grouped asset, then we just continue.
+		case groupKey == nil && info.GroupKey == nil:
+			continue
+		}
+	}
+
+	return groupKey, nil
+}
+
 // channelAcceptor is a callback that's called by the lnd client when a new
 // channel is proposed. This function is responsible for deciding whether to
 // accept the channel based on the channel parameters, and to also set some

tapchannelmsg/custom_channel_data.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"io"
 
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/taproot-assets/rfqmsg"
 	"github.com/lightningnetwork/lnd/lnrpc"
@@ -84,6 +85,14 @@ func (c *ChannelCustomData) AsJson() ([]byte, error) {
 		IncomingHtlcBalance: c.LocalCommit.IncomingHtlcAssets.Val.Sum(),
 	}
 
+	c.OpenChan.GroupKey.ValOpt().WhenSome(func(key *btcec.PublicKey) {
+		if key != nil {
+			resp.GroupKey = hex.EncodeToString(
+				key.SerializeCompressed(),
+			)
+		}
+	})
+
 	// First, we encode the funding state, which lists all assets committed
 	// to the channel at the time of channel opening.
 	for _, output := range c.OpenChan.Assets() {

tapchannelmsg/custom_channel_data_test.go

@@ -39,7 +39,9 @@ func TestReadChannelCustomData(t *testing.T) {
 	output3 := NewAssetOutput(assetID3, 3000, proof3)
 	output4 := NewAssetOutput(assetID4, 4000, proof4)
 
-	fundingState := NewOpenChannel([]*AssetOutput{output1, output2}, 11)
+	fundingState := NewOpenChannel(
+		[]*AssetOutput{output1, output2}, 11, nil,
+	)
 	commitState := NewCommitment(
 		[]*AssetOutput{output1}, []*AssetOutput{output2},
 		map[input.HtlcIndex][]*AssetOutput{

tapchannelmsg/records.go

@@ -94,11 +94,23 @@ type OpenChannel struct {
 	// this value needs to be the same for all assets. Otherwise, they would
 	// not be fungible.
 	DecimalDisplay tlv.RecordT[tlv.TlvType1, uint8]
+
+	// GroupKey is the optional group key used to fund this channel.
+	GroupKey tlv.OptionalRecordT[tlv.TlvType2, *btcec.PublicKey]
 }
 
 // NewOpenChannel creates a new OpenChannel record with the given funded assets.
-func NewOpenChannel(fundedAssets []*AssetOutput,
-	decimalDisplay uint8) *OpenChannel {
+func NewOpenChannel(fundedAssets []*AssetOutput, decimalDisplay uint8,
+	groupKey *btcec.PublicKey) *OpenChannel {
+
+	var optGroupRecord tlv.OptionalRecordT[tlv.TlvType2, *btcec.PublicKey]
+	if groupKey != nil {
+		optGroupRecord = tlv.SomeRecordT[tlv.TlvType2](
+			tlv.NewPrimitiveRecord[tlv.TlvType2](
+				groupKey,
+			),
+		)
+	}
 
 	return &OpenChannel{
 		FundedAssets: tlv.NewRecordT[tlv.TlvType0](
@@ -109,6 +121,7 @@ func NewOpenChannel(fundedAssets []*AssetOutput,
 		DecimalDisplay: tlv.NewPrimitiveRecord[tlv.TlvType1](
 			decimalDisplay,
 		),
+		GroupKey: optGroupRecord,
 	}
 }
 
@@ -118,17 +131,18 @@ func (o *OpenChannel) Assets() []*AssetOutput {
 	return o.FundedAssets.Val.Outputs
 }
 
-// records returns the records that make up the OpenChannel.
-func (o *OpenChannel) records() []tlv.Record {
-	return []tlv.Record{
+// Encode serializes the OpenChannel to the given io.Writer.
+func (o *OpenChannel) Encode(w io.Writer) error {
+	tlvRecords := []tlv.Record{
 		o.FundedAssets.Record(),
 		o.DecimalDisplay.Record(),
 	}
-}
 
-// Encode serializes the OpenChannel to the given io.Writer.
-func (o *OpenChannel) Encode(w io.Writer) error {
-	tlvRecords := o.records()
+	o.GroupKey.WhenSome(
+		func(r tlv.RecordT[tlv.TlvType2, *btcec.PublicKey]) {
+			tlvRecords = append(tlvRecords, r.Record())
+		},
+	)
 
 	// Create the tlv stream.
 	tlvStream, err := tlv.NewStream(tlvRecords...)
@@ -141,13 +155,30 @@ func (o *OpenChannel) Encode(w io.Writer) error {
 
 // Decode deserializes the OpenChannel from the given io.Reader.
 func (o *OpenChannel) Decode(r io.Reader) error {
+	groupKey := o.GroupKey.Zero()
+
+	tlvRecords := []tlv.Record{
+		o.FundedAssets.Record(),
+		o.DecimalDisplay.Record(),
+		groupKey.Record(),
+	}
+
 	// Create the tlv stream.
-	tlvStream, err := tlv.NewStream(o.records()...)
+	tlvStream, err := tlv.NewStream(tlvRecords...)
 	if err != nil {
 		return err
 	}
 
-	return tlvStream.Decode(r)
+	tlvs, err := tlvStream.DecodeWithParsedTypes(r)
+	if err != nil {
+		return err
+	}
+
+	if _, ok := tlvs[groupKey.TlvType()]; ok {
+		o.GroupKey = tlv.SomeRecordT(groupKey)
+	}
+
+	return nil
 }
 
 // Bytes returns the serialized OpenChannel record.

tapchannelmsg/records_test.go

@@ -65,6 +65,7 @@ func TestOpenChannel(t *testing.T) {
 	require.NoError(t, err)
 	randProof, err := proof.Decode(proofBytes)
 	require.NoError(t, err)
+	randGroupKey := test.RandPubKey(t)
 
 	testCases := []struct {
 		name    string
@@ -78,14 +79,22 @@ func TestOpenChannel(t *testing.T) {
 			name: "channel with funded asset",
 			channel: NewOpenChannel([]*AssetOutput{
 				NewAssetOutput([32]byte{1}, 1000, *randProof),
-			}, 0),
+			}, 0, nil),
 		},
 		{
 			name: "channel with multiple funded assets",
 			channel: NewOpenChannel([]*AssetOutput{
 				NewAssetOutput([32]byte{1}, 1000, *randProof),
 				NewAssetOutput([32]byte{2}, 2000, *randProof),
-			}, 11),
+			}, 11, nil),
+		},
+		{
+			name: "channel with multiple funded assets and group " +
+				"key",
+			channel: NewOpenChannel([]*AssetOutput{
+				NewAssetOutput([32]byte{1}, 1000, *randProof),
+				NewAssetOutput([32]byte{2}, 2000, *randProof),
+			}, 11, randGroupKey),
 		},
 	}