feat: track Handshake domain resource updates (#455)

Signed-off-by: Aurora Gaffney <[email protected]>

Author: agaffney

internal/indexer/handshake.go

@@ -7,13 +7,15 @@
 package indexer
 
 import (
+	"encoding/base32"
 	"fmt"
 	"log/slog"
 	"time"
 
 	"github.com/blinklabs-io/cdnsd/handshake"
 	"github.com/blinklabs-io/cdnsd/internal/config"
 	"github.com/blinklabs-io/cdnsd/internal/state"
+	"github.com/miekg/dns"
 )
 
 type handshakeState struct {
@@ -127,14 +129,164 @@ func (i *Indexer) handshakeHandleSync(block *handshake.Block) error {
 					return err
 				}
 				slog.Debug("Handshake domain registration", "name", name, "resdata", c.ResourceData)
+				records, err := handshakeResourceDataToDomainRecords(name, c.ResourceData)
+				if err != nil {
+					return err
+				}
+				if err := state.GetState().UpdateHandshakeDomain(name, records); err != nil {
+					return err
+				}
 			case *handshake.UpdateCovenant:
 				name, err := state.GetState().GetHandshakeNameByHash(c.NameHash)
 				if err != nil {
 					return err
 				}
 				slog.Debug("Handshake domain update", "name", name, "resdata", c.ResourceData)
+				records, err := handshakeResourceDataToDomainRecords(name, c.ResourceData)
+				if err != nil {
+					return err
+				}
+				if err := state.GetState().UpdateHandshakeDomain(name, records); err != nil {
+					return err
+				}
 			}
 		}
 	}
 	return nil
 }
+
+func handshakeResourceDataToDomainRecords(domainName string, resData handshake.DomainResourceData) ([]state.DomainRecord, error) {
+	// The return may be larger than this, but it will be at least as large
+	ret := make([]state.DomainRecord, 0, len(resData.Records))
+	for _, record := range resData.Records {
+		switch r := record.(type) {
+		case *handshake.DsDomainRecord:
+			ret = append(
+				ret,
+				state.DomainRecord{
+					Lhs:  dns.CanonicalName(domainName),
+					Type: "DS",
+					Rhs: fmt.Sprintf(
+						"%d %d %d %x",
+						r.KeyTag,
+						r.Algorithm,
+						r.DigestType,
+						r.Digest,
+					),
+				},
+			)
+		case *handshake.NsDomainRecord:
+			ret = append(
+				ret,
+				state.DomainRecord{
+					Lhs:  dns.CanonicalName(domainName),
+					Type: "NS",
+					Rhs:  r.Name,
+				},
+			)
+		case *handshake.Glue4DomainRecord:
+			ret = append(
+				ret,
+				state.DomainRecord{
+					Lhs:  dns.CanonicalName(domainName),
+					Type: "NS",
+					Rhs:  r.Name,
+				},
+			)
+			ret = append(
+				ret,
+				state.DomainRecord{
+					Lhs:  dns.CanonicalName(r.Name),
+					Type: "A",
+					Rhs:  r.Address.String(),
+				},
+			)
+		case *handshake.Glue6DomainRecord:
+			ret = append(
+				ret,
+				state.DomainRecord{
+					Lhs:  dns.CanonicalName(domainName),
+					Type: "NS",
+					Rhs:  r.Name,
+				},
+			)
+			ret = append(
+				ret,
+				state.DomainRecord{
+					Lhs:  dns.CanonicalName(r.Name),
+					Type: "AAAA",
+					Rhs:  r.Address.String(),
+				},
+			)
+		case *handshake.Synth4DomainRecord:
+			ip4 := r.Address.To4()
+			if ip4 == nil {
+				return nil, fmt.Errorf("Synth4 record has invalid IPv4 address: %s", r.Address.String())
+			}
+			nsName := fmt.Sprintf(
+				"_%s._synth.",
+				base32.HexEncoding.EncodeToString(
+					ip4,
+				),
+			)
+			ret = append(
+				ret,
+				state.DomainRecord{
+					Lhs:  dns.CanonicalName(domainName),
+					Type: "NS",
+					Rhs:  nsName,
+				},
+			)
+			ret = append(
+				ret,
+				state.DomainRecord{
+					Lhs:  nsName,
+					Type: "A",
+					Rhs:  r.Address.String(),
+				},
+			)
+		case *handshake.Synth6DomainRecord:
+			nsName := fmt.Sprintf(
+				"_%s._synth.",
+				base32.HexEncoding.EncodeToString(
+					r.Address,
+				),
+			)
+			ret = append(
+				ret,
+				state.DomainRecord{
+					Lhs:  dns.CanonicalName(domainName),
+					Type: "NS",
+					Rhs:  nsName,
+				},
+			)
+			ret = append(
+				ret,
+				state.DomainRecord{
+					Lhs:  nsName,
+					Type: "AAAA",
+					Rhs:  r.Address.String(),
+				},
+			)
+		case *handshake.TextDomainRecord:
+			var txtVal string
+			for _, item := range r.Items {
+				if txtVal != "" {
+					txtVal += " "
+				}
+				txtVal += `"` + string(item) + `"`
+			}
+			ret = append(
+				ret,
+				state.DomainRecord{
+					Lhs:  dns.CanonicalName(domainName),
+					Type: "TXT",
+					Rhs:  txtVal,
+				},
+			)
+		default:
+			return nil, fmt.Errorf("unsupported record type: %T", record)
+		}
+	}
+	return ret, nil
+}

internal/state/state.go

@@ -28,9 +28,11 @@ const (
 	discoveredAddrKey  = "discovered_addresses"
 	fingerprintKey     = "config_fingerprint"
 
-	recordKeyPrefix            = "r_"
-	domainKeyPrefix            = "d_"
+	cardanoRecordKeyPrefix     = "r_"
+	cardanoDomainKeyPrefix     = "d_"
 	handshakeNameHashKeyPrefix = "hs_name_hash_"
+	handshakeDomainKeyPrefix   = "hs_d_"
+	handshakeRecordKeyPrefix   = "hs_r_"
 )
 
 type State struct {
@@ -221,6 +223,20 @@ func (s *State) GetDiscoveredAddresses() ([]DiscoveredAddress, error) {
 func (s *State) UpdateDomain(
 	domainName string,
 	records []DomainRecord,
+) error {
+	return s.updateDomain(
+		domainName,
+		records,
+		cardanoDomainKeyPrefix,
+		cardanoRecordKeyPrefix,
+	)
+}
+
+func (s *State) updateDomain(
+	domainName string,
+	records []DomainRecord,
+	domainKeyPrefix string,
+	recordKeyPrefix string,
 ) error {
 	err := s.db.Update(func(txn *badger.Txn) error {
 		// Add new records
@@ -290,6 +306,18 @@ func (s *State) UpdateDomain(
 func (s *State) LookupRecords(
 	recordTypes []string,
 	recordName string,
+) ([]DomainRecord, error) {
+	return s.lookupRecords(
+		recordTypes,
+		recordName,
+		cardanoRecordKeyPrefix,
+	)
+}
+
+func (s *State) lookupRecords(
+	recordTypes []string,
+	recordName string,
+	recordKeyPrefix string,
 ) ([]DomainRecord, error) {
 	ret := []DomainRecord{}
 	recordName = strings.Trim(recordName, `.`)
@@ -367,6 +395,29 @@ func (s *State) GetHandshakeNameByHash(nameHash []byte) (string, error) {
 	return ret, nil
 }
 
+func (s *State) UpdateHandshakeDomain(
+	domainName string,
+	records []DomainRecord,
+) error {
+	return s.updateDomain(
+		domainName,
+		records,
+		handshakeDomainKeyPrefix,
+		handshakeRecordKeyPrefix,
+	)
+}
+
+func (s *State) LookupHandshakeRecords(
+	recordTypes []string,
+	recordName string,
+) ([]DomainRecord, error) {
+	return s.lookupRecords(
+		recordTypes,
+		recordName,
+		handshakeRecordKeyPrefix,
+	)
+}
+
 func GetState() *State {
 	return globalState
 }