rfqmsg+tapchannelmsg: add new custom channel data fields to parser

We now get custom_channel_data fields in the ListInvoices/LookupInvoice
as well as in the ListPayments RPC. We add those fields to our data
parser implementation.

Author: guggero

rfqmsg/custom_channel_data.go

@@ -56,3 +56,17 @@ type JsonCloseOutput struct {
 	AssetInternalKey string            `json:"asset_internal_key"`
 	ScriptKeys       map[string]string `json:"script_keys"`
 }
+
+// JsonHtlcBalance is a struct that represents the balance of a single asset
+// HTLC.
+type JsonHtlcBalance struct {
+	AssetID string `json:"asset_id"`
+	Amount  uint64 `json:"amount"`
+}
+
+// JsonHtlc is a struct that represents the asset information that can be
+// transferred via an HTLC.
+type JsonHtlc struct {
+	Balances []*JsonHtlcBalance `json:"balances"`
+	RfqID    string             `json:"rfq_id"`
+}

rfqmsg/records.go

@@ -2,6 +2,8 @@ package rfqmsg
 
 import (
 	"bytes"
+	"encoding/hex"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -137,6 +139,31 @@ func (h *Htlc) Bytes() []byte {
 	return buf.Bytes()
 }
 
+// ToCustomRecords converts the Htlc record to a map of custom records.
+func (h *Htlc) ToCustomRecords() (lnwire.CustomRecords, error) {
+	return tlv.RecordsToMap(h.Records())
+}
+
+// AsJson returns the Htlc record as a JSON blob.
+func (h *Htlc) AsJson() ([]byte, error) {
+	j := &JsonHtlc{
+		Balances: make([]*JsonHtlcBalance, len(h.Balances())),
+	}
+
+	h.RfqID.ValOpt().WhenSome(func(id ID) {
+		j.RfqID = hex.EncodeToString(id[:])
+	})
+
+	for idx, balance := range h.Balances() {
+		j.Balances[idx] = &JsonHtlcBalance{
+			AssetID: hex.EncodeToString(balance.AssetID.Val[:]),
+			Amount:  balance.Amount.Val,
+		}
+	}
+
+	return json.Marshal(j)
+}
+
 // DecodeHtlc deserializes a Htlc from the given blob.
 func DecodeHtlc(blob tlv.Blob) (*Htlc, error) {
 	var h Htlc

rfqmsg/records_test.go

@@ -2,6 +2,7 @@ package rfqmsg
 
 import (
 	"bytes"
+	"encoding/json"
 	"testing"
 
 	"github.com/lightninglabs/taproot-assets/fn"
@@ -13,25 +14,54 @@ func TestHtlc(t *testing.T) {
 	t.Parallel()
 
 	testCases := []struct {
-		name string
-		htlc *Htlc
+		name         string
+		htlc         *Htlc
+		expectedJSON string
 	}{
 		{
 			name: "empty HTLC",
 			htlc: &Htlc{},
+			expectedJSON: `{
+  "balances": [],
+  "rfq_id": ""
+}`,
 		},
 		{
 			name: "HTLC with balance asset",
 			htlc: NewHtlc([]*AssetBalance{
 				NewAssetBalance([32]byte{1}, 1000),
 			}, fn.None[ID]()),
+			//nolint:lll
+			expectedJSON: `{
+  "balances": [
+    {
+      "asset_id": "0100000000000000000000000000000000000000000000000000000000000000",
+      "amount": 1000
+    }
+  ],
+  "rfq_id": ""
+}`,
 		},
 		{
 			name: "channel with multiple balance assets",
 			htlc: NewHtlc([]*AssetBalance{
 				NewAssetBalance([32]byte{1}, 1000),
 				NewAssetBalance([32]byte{2}, 2000),
 			}, fn.Some(ID{0, 1, 2, 3, 4, 5, 6, 7})),
+			//nolint:lll
+			expectedJSON: `{
+  "balances": [
+    {
+      "asset_id": "0100000000000000000000000000000000000000000000000000000000000000",
+      "amount": 1000
+    },
+    {
+      "asset_id": "0200000000000000000000000000000000000000000000000000000000000000",
+      "amount": 2000
+    }
+  ],
+  "rfq_id": "0001020304050607000000000000000000000000000000000000000000000000"
+}`,
 		},
 	}
 
@@ -47,6 +77,15 @@ func TestHtlc(t *testing.T) {
 			require.NoError(t, err)
 
 			require.Equal(t, tc.htlc, deserializedHtlc)
+
+			jsonBytes, err := deserializedHtlc.AsJson()
+			require.NoError(t, err)
+
+			var formatted bytes.Buffer
+			err = json.Indent(&formatted, jsonBytes, "", "  ")
+			require.NoError(t, err)
+
+			require.Equal(t, tc.expectedJSON, formatted.String())
 		})
 	}
 }

tapchannelmsg/custom_channel_data.go

@@ -356,7 +356,7 @@ func ParseCustomChannelData(msg proto.Message) error {
 				continue
 			}
 
-			if rpcChannel.CustomChannelData == nil {
+			if len(rpcChannel.CustomChannelData) == 0 {
 				continue
 			}
 
@@ -398,6 +398,46 @@ func ParseCustomChannelData(msg proto.Message) error {
 					"custom close data: %w", err)
 			}
 		}
+
+	case *lnrpc.Route:
+		if len(m.CustomChannelData) == 0 {
+			return nil
+		}
+
+		parsedHtlc, err := rfqmsg.DecodeHtlc(m.CustomChannelData)
+		if err != nil {
+			return fmt.Errorf("error parsing custom "+
+				"channel data: %w", err)
+		}
+
+		m.CustomChannelData, err = parsedHtlc.AsJson()
+		if err != nil {
+			return fmt.Errorf("error converting custom "+
+				"channel data to JSON: %w", err)
+		}
+
+	case *lnrpc.Invoice:
+		for idx := range m.Htlcs {
+			htlc := m.Htlcs[idx]
+
+			if len(htlc.CustomChannelData) == 0 {
+				continue
+			}
+
+			parsedHtlc, err := rfqmsg.DecodeHtlc(
+				htlc.CustomChannelData,
+			)
+			if err != nil {
+				return fmt.Errorf("error parsing custom "+
+					"channel data: %w", err)
+			}
+
+			htlc.CustomChannelData, err = parsedHtlc.AsJson()
+			if err != nil {
+				return fmt.Errorf("error converting custom "+
+					"channel data to JSON: %w", err)
+			}
+		}
 	}
 
 	return nil