Merge pull request '[agent/codex:gpt-5.3-codex-spark] Read docs/RFC.md fully. Find ONE feature described in the sp...' (#94) from main into dev

action.go

@@ -25,19 +25,10 @@ var (
 )
 
 const (
-	actionArgBind             = "bind"
-	actionArgBindAddress      = "bindAddress"
-	actionArgBindAddressSnake = "bind_address"
-	actionArgIP               = "ip"
-	actionArgAddress          = "address"
-	actionArgName             = "name"
-	actionArgHost             = "host"
-	actionArgHostName         = "hostname"
-	actionArgPort             = "port"
-	actionArgDNSPort          = "dnsPort"
-	actionArgDNSPortSnake     = "dns_port"
-	actionArgHealthPort       = "health_port"
-	actionArgHealthPortCamel  = "healthPort"
+	actionArgBind = "bind"
+	actionArgIP   = "ip"
+	actionArgName = "name"
+	actionArgPort = "port"
 )
 
 type ActionDefinition struct {
@@ -49,7 +40,7 @@ type ActionDefinition struct {
 // ActionRegistrar publishes DNS actions into another Core surface.
 //
 //	registrar.RegisterAction(ActionResolve, func(values map[string]any) (any, bool, error) {
-//		return service.ResolveAddresses("gateway.charon.lthn")
+//		return service.ResolveAddress("gateway.charon.lthn")
 //	})
 type ActionRegistrar interface {
 	RegisterAction(name string, invoke func(map[string]any) (any, bool, error))
@@ -84,7 +75,6 @@ type ActionCaller interface {
 //	for _, definition := range definitions {
 //		fmt.Println(definition.Name)
 //	}
-//	// dns.resolve, dns.resolve.txt, dns.resolve.all, dns.reverse, dns.serve, dns.health, dns.discover
 func (service *Service) ActionDefinitions() []ActionDefinition {
 	return []ActionDefinition{
 		{
@@ -147,13 +137,13 @@ func (service *Service) ActionDefinitions() []ActionDefinition {
 				if err := service.DiscoverAliases(context.Background()); err != nil {
 					return nil, false, err
 				}
-				return nil, true, nil
+				return service.Health(), true, nil
 			},
 			InvokeContext: func(ctx context.Context, _ map[string]any) (any, bool, error) {
 				if err := service.DiscoverAliases(ctx); err != nil {
 					return nil, false, err
 				}
-				return nil, true, nil
+				return service.Health(), true, nil
 			},
 		},
 	}
@@ -176,7 +166,6 @@ func (service *Service) ActionNames() []string {
 //
 //	service.RegisterActions(registrar)
 //	// registrar.RegisterAction("dns.health", ...)
-//	// registrar.RegisterActionContext("dns.discover", func(ctx context.Context, values map[string]any) (any, bool, error) { ... })
 func (service *Service) RegisterActions(registrar ActionRegistrar) {
 	if registrar == nil {
 		return
@@ -202,8 +191,6 @@ func (service *Service) RegisterActions(registrar ActionRegistrar) {
 
 // NewServiceWithRegistrar builds a DNS service and registers its actions in one step.
 //
-// Deprecated: use NewDNSServiceWithRegistrar for a more explicit constructor name.
-//
 //	service := dns.NewServiceWithRegistrar(dns.ServiceConfiguration{}, registrar)
 //	// registrar now exposes dns.resolve, dns.resolve.txt, dns.resolve.all, dns.reverse, dns.serve, dns.health, dns.discover
 func NewServiceWithRegistrar(options ServiceOptions, registrar ActionRegistrar) *Service {
@@ -213,14 +200,6 @@ func NewServiceWithRegistrar(options ServiceOptions, registrar ActionRegistrar)
 	return NewService(options)
 }
 
-// NewDNSServiceWithRegistrar builds a DNS service and registers its actions in one step.
-//
-//	service := dns.NewDNSServiceWithRegistrar(dns.ServiceConfiguration{}, registrar)
-//	// registrar now exposes dns.resolve, dns.resolve.txt, dns.resolve.all, dns.reverse, dns.serve, dns.health, dns.discover
-func NewDNSServiceWithRegistrar(options ServiceOptions, registrar ActionRegistrar) *Service {
-	return NewServiceWithRegistrar(options, registrar)
-}
-
 // HandleAction executes a DNS action by name.
 //
 //	payload, ok, err := service.HandleAction(ActionResolve, map[string]any{
@@ -252,11 +231,11 @@ func (service *Service) HandleActionContext(ctx context.Context, name string, va
 
 func (service *Service) handleResolveAddress(ctx context.Context, values map[string]any) (any, bool, error) {
 	_ = ctx
-	host, err := stringActionValueFromKeys(values, actionArgName, actionArgHost, actionArgHostName)
+	host, err := stringActionValue(values, actionArgName)
 	if err != nil {
 		return nil, false, err
 	}
-	result, ok := service.ResolveAddresses(host)
+	result, ok := service.ResolveAddress(host)
 	if !ok {
 		return nil, false, nil
 	}
@@ -265,7 +244,7 @@ func (service *Service) handleResolveAddress(ctx context.Context, values map[str
 
 func (service *Service) handleResolveTXTRecords(ctx context.Context, values map[string]any) (any, bool, error) {
 	_ = ctx
-	host, err := stringActionValueFromKeys(values, actionArgName, actionArgHost, actionArgHostName)
+	host, err := stringActionValue(values, actionArgName)
 	if err != nil {
 		return nil, false, err
 	}
@@ -278,7 +257,7 @@ func (service *Service) handleResolveTXTRecords(ctx context.Context, values map[
 
 func (service *Service) handleResolveAll(ctx context.Context, values map[string]any) (any, bool, error) {
 	_ = ctx
-	host, err := stringActionValueFromKeys(values, actionArgName, actionArgHost, actionArgHostName)
+	host, err := stringActionValue(values, actionArgName)
 	if err != nil {
 		return nil, false, err
 	}
@@ -291,7 +270,7 @@ func (service *Service) handleResolveAll(ctx context.Context, values map[string]
 
 func (service *Service) handleReverseLookup(ctx context.Context, values map[string]any) (any, bool, error) {
 	_ = ctx
-	ip, err := stringActionValueFromKeys(values, actionArgIP, actionArgAddress, actionArgName, actionArgHost, actionArgHostName)
+	ip, err := stringActionValue(values, actionArgIP)
 	if err != nil {
 		return nil, false, err
 	}
@@ -304,37 +283,17 @@ func (service *Service) handleReverseLookup(ctx context.Context, values map[stri
 
 func (service *Service) handleServe(ctx context.Context, values map[string]any) (any, bool, error) {
 	_ = ctx
-	bind, _, err := stringActionValueOptionalFromKeys(values, actionArgBind, actionArgBindAddress, actionArgBindAddressSnake)
+	bind, err := stringActionValueOptional(values, actionArgBind)
 	if err != nil {
 		return nil, false, err
 	}
-	port, portProvided, err := intActionValueOptionalFromKeys(values, actionArgPort, actionArgDNSPort, actionArgDNSPortSnake)
+	port, portProvided, err := intActionValueOptional(values, actionArgPort)
 	if err != nil {
 		return nil, false, err
 	}
 	if !portProvided {
 		port = service.ResolveDNSPort()
 	}
-
-	healthPort, healthPortProvided, err := intActionValueOptionalFromKeys(values, actionArgHealthPort, actionArgHealthPortCamel)
-	if err != nil {
-		return nil, false, err
-	}
-	if !healthPortProvided && service.httpPort > 0 {
-		runtime, err := service.ServeAll(bind, port, service.httpPort)
-		if err != nil {
-			return nil, false, err
-		}
-		return runtime, true, nil
-	}
-	if healthPortProvided {
-		runtime, err := service.ServeAll(bind, port, healthPort)
-		if err != nil {
-			return nil, false, err
-		}
-		return runtime, true, nil
-	}
-
 	result, err := service.Serve(bind, port)
 	if err != nil {
 		return nil, false, err
@@ -360,46 +319,6 @@ func stringActionValue(values map[string]any, key string) (string, error) {
 	return "", errActionMissingValue
 }
 
-func lookupActionValue(values map[string]any, keys ...string) (any, string, bool) {
-	if values == nil {
-		return nil, "", false
-	}
-
-	for _, key := range keys {
-		if value, exists := values[key]; exists {
-			return value, key, true
-		}
-	}
-
-	for _, key := range keys {
-		for alias, value := range values {
-			if strings.EqualFold(alias, key) {
-				return value, alias, true
-			}
-		}
-	}
-
-	return nil, "", false
-}
-
-func stringActionValueFromKeys(values map[string]any, keys ...string) (string, error) {
-	value, key, found := lookupActionValue(values, keys...)
-	if !found {
-		return "", errActionMissingValue
-	}
-	text, ok := value.(string)
-	if !ok {
-		return "", fmt.Errorf("%w: %s", errActionMissingValue, key)
-	}
-
-	text = strings.TrimSpace(text)
-	if text == "" {
-		return "", errActionMissingValue
-	}
-
-	return text, nil
-}
-
 func stringActionValueOptional(values map[string]any, key string) (string, error) {
 	if values == nil {
 		return "", nil
@@ -415,18 +334,6 @@ func stringActionValueOptional(values map[string]any, key string) (string, error
 	return strings.TrimSpace(value), nil
 }
 
-func stringActionValueOptionalFromKeys(values map[string]any, keys ...string) (string, bool, error) {
-	value, key, found := lookupActionValue(values, keys...)
-	if !found {
-		return "", false, nil
-	}
-	text, ok := value.(string)
-	if !ok {
-		return "", false, fmt.Errorf("%w: %s", errActionMissingValue, key)
-	}
-	return strings.TrimSpace(text), true, nil
-}
-
 func intActionValue(values map[string]any, key string) (int, error) {
 	if values == nil {
 		return 0, errActionMissingValue
@@ -513,26 +420,3 @@ func intActionValueOptional(values map[string]any, key string) (int, bool, error
 	}
 	return value, true, nil
 }
-
-func intActionValueOptionalFromKeys(values map[string]any, keys ...string) (int, bool, error) {
-	for _, key := range keys {
-		value, valueProvided, err := intActionValueOptional(values, key)
-		if err != nil {
-			return 0, false, err
-		}
-		if valueProvided {
-			return value, true, nil
-		}
-	}
-
-	value, key, found := lookupActionValue(values, keys...)
-	if !found {
-		return 0, false, nil
-	}
-	intValue, err := intActionValue(map[string]any{key: value}, key)
-	if err != nil {
-		return 0, false, err
-	}
-
-	return intValue, true, nil
-}

go.mod

@@ -2,10 +2,7 @@ module dappco.re/go/dns
 
 go 1.22
 
-require (
-	github.com/miekg/dns v1.1.62
-	github.com/patrickmn/go-cache v2.1.0+incompatible
-)
+require github.com/miekg/dns v1.1.62
 
 require (
 	golang.org/x/mod v0.18.0 // indirect

go.sum

@@ -1,7 +1,5 @@
 github.com/miekg/dns v1.1.62 h1:cN8OuEF1/x5Rq6Np+h1epln8OiyPWV+lROx9LxcGgIQ=
 github.com/miekg/dns v1.1.62/go.mod h1:mvDlcItzm+br7MToIKqkglaGhlFMHJ9DTNNWONWXbNQ=
-github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
-github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
 golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
 golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=

hsd.go

@@ -28,20 +28,6 @@ type HSDClientOptions struct {
 	HTTPClient *http.Client
 }
 
-// HSDClientConfiguration is the explicit long-form alias for HSDClientOptions.
-//
-//	client := dns.NewHSDClientFromConfiguration(dns.HSDClientConfiguration{
-//		URL:      "http://127.0.0.1:14037",
-//		Username: "user",
-//		Password: "pass",
-//	})
-type HSDClientConfiguration = HSDClientOptions
-
-// HSDClientConfig is kept for compatibility with older call sites.
-//
-// Deprecated: use HSDClientConfiguration instead.
-type HSDClientConfig = HSDClientOptions
-
 type HSDClient struct {
 	baseURL    string
 	username   string
@@ -107,28 +93,6 @@ func NewHSDClient(options HSDClientOptions) *HSDClient {
 	}
 }
 
-// NewHSDClientFromOptions is the explicit long-form constructor name.
-//
-//	client := dns.NewHSDClientFromOptions(dns.HSDClientOptions{
-//		URL:      "http://127.0.0.1:14037",
-//		Username: "user",
-//		Password: "pass",
-//	})
-func NewHSDClientFromOptions(options HSDClientOptions) *HSDClient {
-	return NewHSDClient(options)
-}
-
-// NewHSDClientFromConfiguration is the explicit constructor name for the HSD configuration alias.
-//
-//	client := dns.NewHSDClientFromConfiguration(dns.HSDClientConfiguration{
-//		URL:      "http://127.0.0.1:14037",
-//		Username: "user",
-//		Password: "pass",
-//	})
-func NewHSDClientFromConfiguration(options HSDClientConfiguration) *HSDClient {
-	return NewHSDClient(options)
-}
-
 func (client *HSDClient) GetNameResource(ctx context.Context, name string) (NameRecords, error) {
 	normalized := strings.TrimSpace(name)
 	if normalized == "" {
@@ -221,127 +185,51 @@ func (client *HSDClient) call(ctx context.Context, request HSDRPCRequest) (json.
 }
 
 func parseHSDNameResource(raw json.RawMessage) (NameRecords, error) {
+	var result NameRecords
 	var wrapper map[string]json.RawMessage
 	if err := json.Unmarshal(raw, &wrapper); err != nil {
-		return NameRecords{}, err
+		return result, err
 	}
 
 	if recordsRaw, ok := wrapper["records"]; ok {
-		result, err := parseHSDNameResourceRecords(recordsRaw)
-		if err != nil {
+		if err := json.Unmarshal(recordsRaw, &result); err != nil {
 			return NameRecords{}, err
 		}
 		return result, nil
 	}
 
-	if hasHSDNameResourceField(wrapper) {
-		result, err := parseHSDNameResourceRecords(raw)
-		if err != nil {
+	if _, ok := wrapper["a"]; ok {
+		if err := json.Unmarshal(raw, &result); err != nil {
 			return NameRecords{}, err
 		}
 		return result, nil
 	}
 
+	var wrapped struct {
+		A      []string `json:"a"`
+		AAAA   []string `json:"aaaa"`
+		TXT    []string `json:"txt"`
+		NS     []string `json:"ns"`
+		DS     []string `json:"ds"`
+		DNSKEY []string `json:"dnskey"`
+		RRSIG  []string `json:"rrsig"`
+	}
+	if err := json.Unmarshal(raw, &wrapped); err == nil {
+		result = NameRecords{
+			A:      wrapped.A,
+			AAAA:   wrapped.AAAA,
+			TXT:    wrapped.TXT,
+			NS:     wrapped.NS,
+			DS:     wrapped.DS,
+			DNSKEY: wrapped.DNSKEY,
+			RRSIG:  wrapped.RRSIG,
+		}
+		return result, nil
+	}
+
 	return NameRecords{}, errors.New("unable to parse getnameresource result")
 }
 
-func getCaseInsensitiveRecordField(fields map[string]json.RawMessage, key string) json.RawMessage {
-	if fields == nil {
-		return nil
-	}
-	for candidate, value := range fields {
-		if strings.EqualFold(candidate, key) {
-			return value
-		}
-	}
-	return nil
-}
-
-func parseHSDNameResourceRecords(raw json.RawMessage) (NameRecords, error) {
-	var fields map[string]json.RawMessage
-	if err := json.Unmarshal(raw, &fields); err != nil {
-		return NameRecords{}, err
-	}
-
-	a, err := parseHSDRecordValue(getCaseInsensitiveRecordField(fields, "a"))
-	if err != nil {
-		return NameRecords{}, err
-	}
-	aaaa, err := parseHSDRecordValue(getCaseInsensitiveRecordField(fields, "aaaa"))
-	if err != nil {
-		return NameRecords{}, err
-	}
-	txt, err := parseHSDRecordValue(getCaseInsensitiveRecordField(fields, "txt"))
-	if err != nil {
-		return NameRecords{}, err
-	}
-	ns, err := parseHSDRecordValue(getCaseInsensitiveRecordField(fields, "ns"))
-	if err != nil {
-		return NameRecords{}, err
-	}
-	ds, err := parseHSDRecordValue(getCaseInsensitiveRecordField(fields, "ds"))
-	if err != nil {
-		return NameRecords{}, err
-	}
-	dnsKey, err := parseHSDRecordValue(getCaseInsensitiveRecordField(fields, "dnskey"))
-	if err != nil {
-		return NameRecords{}, err
-	}
-	rrSig, err := parseHSDRecordValue(getCaseInsensitiveRecordField(fields, "rrsig"))
-	if err != nil {
-		return NameRecords{}, err
-	}
-
-	return NameRecords{
-		A:      a,
-		AAAA:   aaaa,
-		TXT:    txt,
-		NS:     ns,
-		DS:     ds,
-		DNSKEY: dnsKey,
-		RRSIG:  rrSig,
-	}, nil
-}
-
-func hasHSDNameResourceField(fields map[string]json.RawMessage) bool {
-	if len(fields) == 0 {
-		return false
-	}
-
-	return getCaseInsensitiveRecordField(fields, "a") != nil ||
-		getCaseInsensitiveRecordField(fields, "aaaa") != nil ||
-		getCaseInsensitiveRecordField(fields, "txt") != nil ||
-		getCaseInsensitiveRecordField(fields, "ns") != nil ||
-		getCaseInsensitiveRecordField(fields, "ds") != nil ||
-		getCaseInsensitiveRecordField(fields, "dnskey") != nil ||
-		getCaseInsensitiveRecordField(fields, "rrsig") != nil
-}
-
-func parseHSDRecordValue(raw json.RawMessage) ([]string, error) {
-	if len(bytes.TrimSpace(raw)) == 0 {
-		return nil, nil
-	}
-
-	if trimmed := bytes.TrimSpace(raw); bytes.Equal(trimmed, []byte("null")) {
-		return nil, nil
-	}
-
-	var values []string
-	if err := json.Unmarshal(raw, &values); err == nil {
-		return values, nil
-	}
-
-	var value string
-	if err := json.Unmarshal(raw, &value); err == nil {
-		if value == "" {
-			return nil, nil
-		}
-		return []string{value}, nil
-	}
-
-	return nil, fmt.Errorf("unable to parse DNS record field")
-}
-
 func parseHSDBlockchainInfo(raw json.RawMessage) (HSDBlockchainInfo, error) {
 	var info HSDBlockchainInfo
 	var wrapper map[string]json.RawMessage

hsd_test.go

@@ -52,18 +52,6 @@ func TestHSDClientGetNameResourceCallsRPCAndParsesResult(t *testing.T) {
 	}
 }
 
-func TestNewHSDClientFromOptionsMatchesNewHSDClient(t *testing.T) {
-	clientFromOptions := NewHSDClientFromOptions(HSDClientOptions{URL: "http://127.0.0.1:14037"})
-	clientFromConfiguration := NewHSDClientFromConfiguration(HSDClientConfiguration{URL: "http://127.0.0.1:14037"})
-
-	if clientFromOptions == nil || clientFromConfiguration == nil {
-		t.Fatal("expected explicit HSD constructors to return clients")
-	}
-	if clientFromOptions.baseURL != clientFromConfiguration.baseURL {
-		t.Fatalf("expected explicit HSD constructors to normalize the same base URL, got %q and %q", clientFromOptions.baseURL, clientFromConfiguration.baseURL)
-	}
-}
-
 func TestHSDClientGetNameResourceParsesWrappedRecords(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) {
 		var payload struct {
@@ -104,50 +92,6 @@ func TestHSDClientGetNameResourceParsesWrappedRecords(t *testing.T) {
 	}
 }
 
-func TestHSDClientGetNameResourceParsesCaseInsensitiveFields(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) {
-		var payload struct {
-			Method string `json:"method"`
-		}
-		if err := json.NewDecoder(request.Body).Decode(&payload); err != nil {
-			t.Fatalf("unexpected request payload: %v", err)
-		}
-		if payload.Method != "getnameresource" {
-			t.Fatalf("expected method getnameresource, got %s", payload.Method)
-		}
-
-		responseWriter.Header().Set("Content-Type", "application/json")
-		_ = json.NewEncoder(responseWriter).Encode(map[string]any{
-			"result": map[string]any{
-				"records": map[string]any{
-					"A":   []string{"10.10.10.10"},
-					"Txt": []string{"v=lthn1 type=case"},
-					"NS":  []string{"ns.example.lthn"},
-				},
-			},
-		})
-	}))
-	defer server.Close()
-
-	client := NewHSDClient(HSDClientOptions{
-		URL: server.URL,
-	})
-
-	record, err := client.GetNameResource(context.Background(), "case.lthn")
-	if err != nil {
-		t.Fatalf("unexpected getnameresource error: %v", err)
-	}
-	if len(record.A) != 1 || record.A[0] != "10.10.10.10" {
-		t.Fatalf("unexpected wrapped A result with mixed-case key: %#v", record.A)
-	}
-	if len(record.TXT) != 1 || record.TXT[0] != "v=lthn1 type=case" {
-		t.Fatalf("unexpected wrapped TXT result with mixed-case key: %#v", record.TXT)
-	}
-	if len(record.NS) != 1 || record.NS[0] != "ns.example.lthn" {
-		t.Fatalf("unexpected wrapped NS result with mixed-case key: %#v", record.NS)
-	}
-}
-
 func TestHSDClientGetNameResourceParsesDSRecords(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) {
 		var payload struct {
@@ -224,48 +168,6 @@ func TestHSDClientGetNameResourceParsesDNSSECRecords(t *testing.T) {
 	}
 }
 
-func TestHSDClientGetNameResourceParsesSingleValueDNSSECRecords(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) {
-		var payload struct {
-			Method string `json:"method"`
-		}
-		if err := json.NewDecoder(request.Body).Decode(&payload); err != nil {
-			t.Fatalf("unexpected request payload: %v", err)
-		}
-		if payload.Method != "getnameresource" {
-			t.Fatalf("expected method getnameresource, got %s", payload.Method)
-		}
-
-		responseWriter.Header().Set("Content-Type", "application/json")
-		_ = json.NewEncoder(responseWriter).Encode(map[string]any{
-			"result": map[string]any{
-				"dnskey": "257 3 13 AA==",
-				"rrsig":  "A 8 2 3600 20260101000000 20250101000000 12345 gateway.lthn. AA==",
-				"ds":     "60485 8 2 A1B2C3D4E5F60718293A4B5C6D7E8F9012345678",
-			},
-		})
-	}))
-	defer server.Close()
-
-	client := NewHSDClient(HSDClientOptions{
-		URL: server.URL,
-	})
-
-	record, err := client.GetNameResource(context.Background(), "gateway.lthn")
-	if err != nil {
-		t.Fatalf("unexpected getnameresource error: %v", err)
-	}
-	if len(record.DNSKEY) != 1 || record.DNSKEY[0] != "257 3 13 AA==" {
-		t.Fatalf("unexpected DNSKEY result: %#v", record.DNSKEY)
-	}
-	if len(record.RRSIG) != 1 || record.RRSIG[0] != "A 8 2 3600 20260101000000 20250101000000 12345 gateway.lthn. AA==" {
-		t.Fatalf("unexpected RRSIG result: %#v", record.RRSIG)
-	}
-	if len(record.DS) != 1 || record.DS[0] != "60485 8 2 A1B2C3D4E5F60718293A4B5C6D7E8F9012345678" {
-		t.Fatalf("unexpected DS result: %#v", record.DS)
-	}
-}
-
 func TestHSDClientGetBlockchainInfo(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) {
 		var payload struct {

http_server.go

@@ -34,13 +34,6 @@ func (server *HealthServer) Address() string {
 	return server.HealthAddress()
 }
 
-// StartHealthServer is an explicit convenience wrapper around ServeHTTPHealth.
-//
-//	health, err := service.StartHealthServer("127.0.0.1", 5554)
-func (service *Service) StartHealthServer(bind string, port int) (*HealthServer, error) {
-	return service.ServeHTTPHealth(bind, port)
-}
-
 func (server *HealthServer) Close() error {
 	if server == nil {
 		return nil
@@ -72,7 +65,7 @@ func (service *Service) ServeHTTPHealth(bind string, port int) (*HealthServer, e
 		bind = "127.0.0.1"
 	}
 	if port <= 0 {
-		port = service.resolveHealthPort()
+		port = service.resolveHTTPPort()
 	}
 
 	address := net.JoinHostPort(bind, strconv.Itoa(port))

mainchain.go

@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"slices"
 	"strings"
 )
 
@@ -26,20 +25,6 @@ type MainchainClientOptions struct {
 	HTTPClient *http.Client
 }
 
-// MainchainAliasClientConfiguration is the explicit long-form alias for MainchainClientOptions.
-//
-//	client := dns.NewMainchainAliasClientFromConfiguration(dns.MainchainAliasClientConfiguration{
-//		URL:      "http://127.0.0.1:14037",
-//		Username: "user",
-//		Password: "pass",
-//	})
-type MainchainAliasClientConfiguration = MainchainClientOptions
-
-// MainchainAliasClientConfig is kept for compatibility with older call sites.
-//
-// Deprecated: use MainchainAliasClientConfiguration instead.
-type MainchainAliasClientConfig = MainchainClientOptions
-
 type MainchainAliasClient struct {
 	baseURL    string
 	username   string
@@ -85,28 +70,6 @@ func NewMainchainAliasClient(options MainchainClientOptions) *MainchainAliasClie
 	}
 }
 
-// NewMainchainAliasClientFromOptions is the explicit long-form constructor name.
-//
-//	client := dns.NewMainchainAliasClientFromOptions(dns.MainchainClientOptions{
-//		URL:      "http://127.0.0.1:14037",
-//		Username: "user",
-//		Password: "pass",
-//	})
-func NewMainchainAliasClientFromOptions(options MainchainClientOptions) *MainchainAliasClient {
-	return NewMainchainAliasClient(options)
-}
-
-// NewMainchainAliasClientFromConfiguration is the explicit constructor name for the main-chain configuration alias.
-//
-//	client := dns.NewMainchainAliasClientFromConfiguration(dns.MainchainAliasClientConfiguration{
-//		URL:      "http://127.0.0.1:14037",
-//		Username: "user",
-//		Password: "pass",
-//	})
-func NewMainchainAliasClientFromConfiguration(options MainchainAliasClientConfiguration) *MainchainAliasClient {
-	return NewMainchainAliasClient(options)
-}
-
 // GetAllAliasDetails returns alias names mapped to HNS DNS names.
 //
 //	client := dns.NewMainchainAliasClient(dns.MainchainClientOptions{
@@ -259,39 +222,19 @@ func decodeString(raw json.RawMessage) (string, bool) {
 }
 
 func extractAliasFromComment(comment string) string {
-	fields := strings.Fields(comment)
-	for index, token := range fields {
-		normalizedToken := strings.ToLower(strings.TrimSpace(token))
-		switch {
-		case strings.HasPrefix(normalizedToken, "hns="):
-			alias := strings.TrimSuffix(strings.TrimPrefix(normalizedToken, "hns="), ";")
-			if alias != "" {
-				return normalizeName(alias)
-			}
-		case normalizedToken == "hns" && index+2 < len(fields):
-			nextToken := strings.TrimSpace(strings.ToLower(fields[index+1]))
-			if nextToken != "=" && nextToken != ":" && nextToken != ":=" {
-				continue
-			}
-			alias := strings.TrimSpace(fields[index+2])
-			alias = strings.TrimSuffix(alias, ";")
-			alias = strings.TrimSuffix(alias, ",")
-			if alias != "" {
-				return normalizeName(alias)
-			}
+	for _, token := range strings.Fields(comment) {
+		if strings.HasPrefix(token, "hns=") {
+			return normalizeName(strings.TrimSuffix(strings.TrimPrefix(token, "hns="), ";"))
 		}
 	}
 
-	commentLower := strings.ToLower(comment)
-	if marker := strings.Index(commentLower, "hns"); marker >= 0 {
-		alias := comment[marker+3:]
-		alias = strings.TrimLeft(alias, " \t:=;")
-		if trim := strings.IndexAny(alias, " ;,\t\r\n"); trim >= 0 {
+	if marker := strings.Index(comment, "hns="); marker >= 0 {
+		alias := comment[marker+4:]
+		if trim := strings.IndexAny(alias, " ;,"); trim >= 0 {
 			alias = alias[:trim]
 		}
 		alias = strings.TrimSpace(alias)
 		alias = strings.TrimSuffix(alias, ";")
-		alias = strings.TrimSuffix(alias, ",")
 		return normalizeName(alias)
 	}
 
@@ -312,6 +255,5 @@ func normalizeAliasList(raw []string) []string {
 		seen[next] = true
 		normalized = append(normalized, next)
 	}
-	slices.Sort(normalized)
 	return normalized
 }

mainchain_test.go

@@ -54,18 +54,6 @@ func TestMainchainClientGetsAliasDetailsAndParsesHNSComments(t *testing.T) {
 	}
 }
 
-func TestNewMainchainAliasClientFromOptionsMatchesNewMainchainAliasClient(t *testing.T) {
-	clientFromOptions := NewMainchainAliasClientFromOptions(MainchainClientOptions{URL: "http://127.0.0.1:14037"})
-	clientFromConfiguration := NewMainchainAliasClientFromConfiguration(MainchainAliasClientConfiguration{URL: "http://127.0.0.1:14037"})
-
-	if clientFromOptions == nil || clientFromConfiguration == nil {
-		t.Fatal("expected explicit main-chain constructors to return clients")
-	}
-	if clientFromOptions.baseURL != clientFromConfiguration.baseURL {
-		t.Fatalf("expected explicit main-chain constructors to normalize the same base URL, got %q and %q", clientFromOptions.baseURL, clientFromConfiguration.baseURL)
-	}
-}
-
 func TestServiceDiscoverFromMainchainAliasesUsesMainchainThenHSD(t *testing.T) {
 	var chainCalls int32
 	var hsdTreeRootCalls int32
@@ -571,48 +559,3 @@ func TestServiceDiscoverFromMainchainAliasesFallsBackToChainClientWhenPrimaryDis
 		t.Fatalf("expected one tree-root and two name-resource RPC calls, got treeRoot=%d nameResource=%d", atomic.LoadInt32(&hsdTreeRootCalls), atomic.LoadInt32(&hsdAliasCalls))
 	}
 }
-
-func TestExtractAliasFromCommentParsesCaseInsensitiveHNSPrefix(t *testing.T) {
-	got := extractAliasFromComment("gateway alias HNS=gateway.charon.lthn")
-	if got != "gateway.charon.lthn" {
-		t.Fatalf("expected gateway.charon.lthn, got %s", got)
-	}
-}
-
-func TestExtractAliasFromCommentParsesSpacedHNSAssignment(t *testing.T) {
-	got := extractAliasFromComment("gateway alias hns = gateway.charon.lthn;")
-	if got != "gateway.charon.lthn" {
-		t.Fatalf("expected gateway.charon.lthn, got %s", got)
-	}
-}
-
-func TestNewServiceBuildsMainchainAliasClientWithHSDFallbackCredentials(t *testing.T) {
-	service := NewService(ServiceOptions{
-		MainchainURL: "http://127.0.0.1:14037",
-		HSDUsername:  "mainchain-user",
-		HSDPassword:  "mainchain-pass",
-		HSDApiKey:    "ignored-token",
-	})
-
-	if service.mainchainAliasClient == nil {
-		t.Fatal("expected default mainchain alias client with fallback credentials")
-	}
-	if got := service.mainchainAliasClient.username; got != "mainchain-user" {
-		t.Fatalf("expected mainchain username to fall back to hsd username, got %q", got)
-	}
-	if got := service.mainchainAliasClient.password; got != "mainchain-pass" {
-		t.Fatalf("expected mainchain password to fall back to hsd password, got %q", got)
-	}
-
-	serviceFromToken := NewService(ServiceOptions{
-		MainchainURL: "http://127.0.0.1:14037",
-		HSDUsername:  "token-user",
-		HSDApiKey:    "token-pass",
-	})
-	if serviceFromToken.mainchainAliasClient == nil {
-		t.Fatal("expected default mainchain alias client with fallback token credentials")
-	}
-	if got := serviceFromToken.mainchainAliasClient.password; got != "token-pass" {
-		t.Fatalf("expected mainchain password to fall back to hsd api key token, got %q", got)
-	}
-}

serve.go

@@ -30,60 +30,23 @@ type DNSServer struct {
 //	defer func() { _ = runtime.Close() }()
 //	fmt.Println(runtime.DNSAddress(), runtime.HealthAddress())
 type ServiceRuntime struct {
-	// DNSServer is the explicit name for the DNS listener.
-	DNSServer *DNSServer
-	// DNS is retained for compatibility with older call sites.
-	DNS *DNSServer
-	// HealthServer is the explicit name for the `/health` listener.
-	HealthServer *HealthServer
-	// Health is retained for compatibility with older call sites.
+	DNS    *DNSServer
 	Health *HealthServer
 	// HTTP is retained for compatibility with older call sites.
 	HTTP *HealthServer
-	// HTTPServer is the explicit name for the `/health` listener when the
-	// HTTP surface is addressed directly.
-	HTTPServer *HealthServer
-}
-
-// DNSServiceRuntime is the explicit long-form alias for ServiceRuntime.
-//
-//	runtime, err := service.ServeAll("127.0.0.1", 53, 5554)
-//	var dnsRuntime dns.DNSServiceRuntime = *runtime
-//	fmt.Println(dnsRuntime.DNSAddress(), dnsRuntime.HealthAddress())
-type DNSServiceRuntime = ServiceRuntime
-
-// Address is the compatibility alias for HealthAddress.
-//
-//	runtime, err := service.ServeAll("127.0.0.1", 53, 5554)
-//	defer func() { _ = runtime.Close() }()
-//	fmt.Println(runtime.Address())
-func (runtime *ServiceRuntime) Address() string {
-	return runtime.HealthAddress()
 }
 
 func (runtime *ServiceRuntime) DNSAddress() string {
-	if runtime == nil {
+	if runtime == nil || runtime.DNS == nil {
 		return ""
 	}
-	if runtime.DNSServer != nil {
-		return runtime.DNSServer.DNSAddress()
-	}
-	if runtime.DNS != nil {
-		return runtime.DNS.DNSAddress()
-	}
-	return ""
+	return runtime.DNS.DNSAddress()
 }
 
 func (runtime *ServiceRuntime) HealthAddress() string {
 	if runtime == nil {
 		return ""
 	}
-	if runtime.HealthServer != nil {
-		return runtime.HealthServer.HealthAddress()
-	}
-	if runtime.HTTPServer != nil {
-		return runtime.HTTPServer.HealthAddress()
-	}
 	if runtime.Health != nil {
 		return runtime.Health.HealthAddress()
 	}
@@ -104,32 +67,17 @@ func (runtime *ServiceRuntime) Close() error {
 	}
 
 	var firstError error
-	if runtime.DNSServer != nil {
-		if err := runtime.DNSServer.Close(); err != nil && firstError == nil {
-			firstError = err
-		}
-	}
-	if runtime.DNS != nil && runtime.DNS != runtime.DNSServer {
+	if runtime.DNS != nil {
 		if err := runtime.DNS.Close(); err != nil && firstError == nil {
 			firstError = err
 		}
 	}
-	if runtime.HealthServer != nil {
-		if err := runtime.HealthServer.Close(); err != nil && firstError == nil {
-			firstError = err
-		}
-	}
-	if runtime.HTTPServer != nil && runtime.HTTPServer != runtime.HealthServer {
-		if err := runtime.HTTPServer.Close(); err != nil && firstError == nil {
-			firstError = err
-		}
-	}
-	if runtime.Health != nil && runtime.Health != runtime.HealthServer {
+	if runtime.Health != nil {
 		if err := runtime.Health.Close(); err != nil && firstError == nil {
 			firstError = err
 		}
 	}
-	if runtime.HTTP != nil && runtime.HTTP != runtime.HealthServer && runtime.HTTP != runtime.Health {
+	if runtime.HTTP != nil && runtime.HTTP != runtime.Health {
 		if err := runtime.HTTP.Close(); err != nil && firstError == nil {
 			firstError = err
 		}
@@ -156,18 +104,14 @@ func (server *DNSServer) Close() error {
 	if server.tcpListener != nil {
 		_ = server.tcpListener.Close()
 	}
-	var firstError error
+	var err error
 	if server.udpServer != nil {
-		if err := server.udpServer.Shutdown(); err != nil && firstError == nil {
-			firstError = err
-		}
+		err = server.udpServer.Shutdown()
 	}
 	if server.tcpServer != nil {
-		if err := server.tcpServer.Shutdown(); err != nil && firstError == nil {
-			firstError = err
-		}
+		err = server.tcpServer.Shutdown()
 	}
-	return firstError
+	return err
 }
 
 // ResolveDNSPort returns the DNS port used for `dns.serve` and `Serve`.
@@ -175,50 +119,22 @@ func (server *DNSServer) Close() error {
 //	port := service.ResolveDNSPort()
 //	server, err := service.Serve("127.0.0.1", port)
 func (service *Service) ResolveDNSPort() int {
-	if service == nil {
-		return DefaultDNSPort
-	}
-	if service.dnsPort <= 0 {
+	if service == nil || service.dnsPort <= 0 {
 		return DefaultDNSPort
 	}
 	return service.dnsPort
 }
 
-// DNSListenPort resolves the configured DNS listen port for `dns.serve`.
-//
-//	port := service.DNSListenPort()
-//	server, err := service.Serve("127.0.0.1", port)
-func (service *Service) DNSListenPort() int {
-	if service == nil {
-		return DefaultDNSPort
-	}
-	return service.ResolveDNSPort()
-}
-
 // DNSPort is an explicit alias for ResolveDNSPort.
 //
 //	port := service.DNSPort()
 //	server, err := service.Serve("127.0.0.1", port)
 func (service *Service) DNSPort() int {
-	if service == nil {
-		return DefaultDNSPort
-	}
 	return service.ResolveDNSPort()
 }
 
-// resolveDNSListenPort keeps internal callers aligned with explicit naming.
-func (service *Service) resolveDNSListenPort() int {
-	if service == nil {
-		return DefaultDNSPort
-	}
-	return service.DNSListenPort()
-}
-
-// resolveServePort is a legacy compatibility helper.
+// resolveServePort keeps internal callers aligned with existing behavior.
 func (service *Service) resolveServePort() int {
-	if service == nil {
-		return DefaultDNSPort
-	}
 	return service.ResolveDNSPort()
 }
 
@@ -227,73 +143,22 @@ func (service *Service) resolveServePort() int {
 //	port := service.ResolveHTTPPort()
 //	healthServer, err := service.ServeHTTPHealth("127.0.0.1", port)
 func (service *Service) ResolveHTTPPort() int {
-	return service.ResolveHealthPort()
-}
-
-// ResolveHealthPort returns the health listener port used by `ServeHTTPHealth`.
-//
-//	port := service.ResolveHealthPort()
-//	healthServer, err := service.ServeHTTPHealth("127.0.0.1", port)
-func (service *Service) ResolveHealthPort() int {
-	if service == nil {
-		return DefaultHTTPPort
-	}
-	if service.httpPort <= 0 {
+	if service == nil || service.httpPort <= 0 {
 		return DefaultHTTPPort
 	}
 	return service.httpPort
 }
 
-// HTTPListenPort resolves the configured health/listener port for `dns.serve`.
-//
-//	port := service.HTTPListenPort()
-//	server, err := service.ServeHTTPHealth("127.0.0.1", port)
-func (service *Service) HTTPListenPort() int {
-	return service.ResolveHealthPort()
-}
-
-// HealthListenPort is the explicit alias for ResolveHealthPort.
-//
-//	port := service.HealthListenPort()
-//	server, err := service.ServeHTTPHealth("127.0.0.1", port)
-func (service *Service) HealthListenPort() int {
-	return service.ResolveHealthPort()
-}
-
-// HealthPort returns the health listener port used by `ServeHTTPHealth`.
-//
-//	port := service.HealthPort()
-//	healthServer, err := service.ServeHTTPHealth("127.0.0.1", port)
-func (service *Service) HealthPort() int {
-	return service.ResolveHealthPort()
-}
-
 // HTTPPort is an explicit alias for ResolveHTTPPort.
 //
 //	port := service.HTTPPort()
 //	healthServer, err := service.ServeHTTPHealth("127.0.0.1", port)
 func (service *Service) HTTPPort() int {
-	return service.ResolveHealthPort()
+	return service.ResolveHTTPPort()
 }
 
-// resolveHTTPListenPort keeps internal callers aligned with explicit naming.
-func (service *Service) resolveHTTPListenPort() int {
-	return service.ResolveHealthPort()
-}
-
-// resolveHealthListenPort keeps internal callers aligned with explicit naming.
-func (service *Service) resolveHealthListenPort() int {
-	return service.ResolveHealthPort()
-}
-
-// resolveHTTPPort is a legacy compatibility helper.
 func (service *Service) resolveHTTPPort() int {
-	return service.ResolveHealthPort()
-}
-
-// resolveHealthPort is a legacy compatibility helper.
-func (service *Service) resolveHealthPort() int {
-	return service.ResolveHealthPort()
+	return service.ResolveHTTPPort()
 }
 
 // Serve starts DNS over UDP and TCP.
@@ -303,15 +168,9 @@ func (service *Service) resolveHealthPort() int {
 //	lookup := new(dnsprotocol.Msg)
 //	lookup.SetQuestion("gateway.charon.lthn.", dnsprotocol.TypeA)
 func (service *Service) Serve(bind string, port int) (*DNSServer, error) {
-	if service == nil {
-		return nil, fmt.Errorf("service is required")
-	}
 	if bind == "" {
 		bind = "127.0.0.1"
 	}
-	if port <= 0 {
-		port = service.ResolveDNSPort()
-	}
 	addr := net.JoinHostPort(bind, strconv.Itoa(port))
 
 	udpListener, err := net.ListenPacket("udp", addr)
@@ -348,41 +207,17 @@ func (service *Service) Serve(bind string, port int) (*DNSServer, error) {
 	return dnsServer, nil
 }
 
-// StartDNSServer is an explicit convenience wrapper around Serve.
-//
-//	dnsServer, err := service.StartDNSServer("127.0.0.1", 53)
-func (service *Service) StartDNSServer(bind string, port int) (*DNSServer, error) {
-	return service.Serve(bind, port)
-}
-
-// StartDNSAndHealth is an explicit convenience wrapper around ServeAll.
-//
-//	runtime, err := service.StartDNSAndHealth("127.0.0.1", 53, 5554)
-func (service *Service) StartDNSAndHealth(bind string, dnsPort int, healthPort int) (*ServiceRuntime, error) {
-	return service.ServeAll(bind, dnsPort, healthPort)
-}
-
-// ServeDNSAndHealth is the explicit alias for ServeAll.
-//
-//	runtime, err := service.ServeDNSAndHealth("127.0.0.1", 53, 5554)
-func (service *Service) ServeDNSAndHealth(bind string, dnsPort int, httpPort int) (*ServiceRuntime, error) {
-	return service.ServeAll(bind, dnsPort, httpPort)
-}
-
 // ServeAll starts DNS and health together.
 //
 //	runtime, err := service.ServeAll("127.0.0.1", 53, 5554)
 //	defer func() { _ = runtime.Close() }()
 //	fmt.Println("dns:", runtime.DNSAddress(), "health:", runtime.HealthAddress())
 func (service *Service) ServeAll(bind string, dnsPort int, httpPort int) (*ServiceRuntime, error) {
-	if service == nil {
-		return nil, fmt.Errorf("service is required")
-	}
-	if dnsPort <= 0 {
-		dnsPort = service.resolveDNSListenPort()
+	if dnsPort == 0 {
+		dnsPort = service.dnsPort
 	}
 	if httpPort <= 0 {
-		httpPort = service.resolveHealthListenPort()
+		httpPort = service.resolveHTTPPort()
 	}
 
 	dnsServer, err := service.Serve(bind, dnsPort)
@@ -397,12 +232,9 @@ func (service *Service) ServeAll(bind string, dnsPort int, httpPort int) (*Servi
 	}
 
 	return &ServiceRuntime{
-		DNSServer:    dnsServer,
-		DNS:          dnsServer,
-		HealthServer: httpServer,
-		Health:       httpServer,
-		HTTP:         httpServer,
-		HTTPServer:   httpServer,
+		DNS:    dnsServer,
+		Health: httpServer,
+		HTTP:   httpServer,
 	}, nil
 }
 
@@ -414,19 +246,9 @@ func (service *Service) ServeAll(bind string, dnsPort int, httpPort int) (*Servi
 //	})
 //	runtime, err := service.ServeConfigured("127.0.0.1")
 func (service *Service) ServeConfigured(bind string) (*ServiceRuntime, error) {
-	if service == nil {
-		return nil, fmt.Errorf("service is required")
-	}
 	return service.ServeAll(bind, service.dnsPort, service.httpPort)
 }
 
-// StartConfigured is an explicit convenience wrapper around ServeConfigured.
-//
-//	runtime, err := service.StartConfigured("127.0.0.1")
-func (service *Service) StartConfigured(bind string) (*ServiceRuntime, error) {
-	return service.ServeConfigured(bind)
-}
-
 type dnsRequestHandler struct {
 	service *Service
 }
@@ -463,7 +285,7 @@ func (handler *dnsRequestHandler) ServeDNS(responseWriter dnsprotocol.ResponseWr
 		if !found {
 			goto noRecord
 		}
-		for _, value := range normalizeRecordValues(record.A) {
+		for _, value := range record.A {
 			parsedIP := net.ParseIP(value)
 			if parsedIP == nil || parsedIP.To4() == nil {
 				continue
@@ -477,7 +299,7 @@ func (handler *dnsRequestHandler) ServeDNS(responseWriter dnsprotocol.ResponseWr
 		if !found {
 			goto noRecord
 		}
-		for _, value := range normalizeRecordValues(record.AAAA) {
+		for _, value := range record.AAAA {
 			parsedIP := net.ParseIP(value)
 			if parsedIP == nil || parsedIP.To4() != nil {
 				continue
@@ -491,7 +313,7 @@ func (handler *dnsRequestHandler) ServeDNS(responseWriter dnsprotocol.ResponseWr
 		if !found {
 			goto noRecord
 		}
-		for _, value := range normalizeRecordValues(record.TXT) {
+		for _, value := range record.TXT {
 			reply.Answer = append(reply.Answer, &dnsprotocol.TXT{
 				Hdr: dnsprotocol.RR_Header{Name: question.Name, Rrtype: dnsprotocol.TypeTXT, Class: dnsprotocol.ClassINET, Ttl: defaultDNSTTL},
 				Txt: []string{value},
@@ -499,7 +321,7 @@ func (handler *dnsRequestHandler) ServeDNS(responseWriter dnsprotocol.ResponseWr
 		}
 	case dnsprotocol.TypeNS:
 		if found {
-			for _, value := range normalizeRecordValues(record.NS) {
+			for _, value := range record.NS {
 				reply.Answer = append(reply.Answer, &dnsprotocol.NS{
 					Hdr: dnsprotocol.RR_Header{Name: question.Name, Rrtype: dnsprotocol.TypeNS, Class: dnsprotocol.ClassINET, Ttl: defaultDNSTTL},
 					Ns:  normalizeName(value) + ".",
@@ -561,17 +383,17 @@ func (handler *dnsRequestHandler) ServeDNS(responseWriter dnsprotocol.ResponseWr
 		if !found {
 			goto noRecord
 		}
-		appendDNSSECResourceRecords(reply, question.Name, dnsprotocol.TypeDS, normalizeRecordValues(record.DS))
+		appendDNSSECResourceRecords(reply, question.Name, dnsprotocol.TypeDS, record.DS)
 	case dnsprotocol.TypeDNSKEY:
 		if !found {
 			goto noRecord
 		}
-		appendDNSSECResourceRecords(reply, question.Name, dnsprotocol.TypeDNSKEY, normalizeRecordValues(record.DNSKEY))
+		appendDNSSECResourceRecords(reply, question.Name, dnsprotocol.TypeDNSKEY, record.DNSKEY)
 	case dnsprotocol.TypeRRSIG:
 		if !found {
 			goto noRecord
 		}
-		appendDNSSECResourceRecords(reply, question.Name, dnsprotocol.TypeRRSIG, normalizeRecordValues(record.RRSIG))
+		appendDNSSECResourceRecords(reply, question.Name, dnsprotocol.TypeRRSIG, record.RRSIG)
 	default:
 		reply.SetRcode(request, dnsprotocol.RcodeNotImplemented)
 		_ = responseWriter.WriteMsg(reply)
@@ -644,7 +466,7 @@ func parsePTRIP(name string) (string, bool) {
 }
 
 func appendAnyAnswers(reply *dnsprotocol.Msg, questionName string, lookupName string, record NameRecords, zoneApex string) {
-	for _, value := range normalizeRecordValues(record.A) {
+	for _, value := range record.A {
 		parsedIP := net.ParseIP(value)
 		if parsedIP == nil || parsedIP.To4() == nil {
 			continue
@@ -655,7 +477,7 @@ func appendAnyAnswers(reply *dnsprotocol.Msg, questionName string, lookupName st
 		})
 	}
 
-	for _, value := range normalizeRecordValues(record.AAAA) {
+	for _, value := range record.AAAA {
 		parsedIP := net.ParseIP(value)
 		if parsedIP == nil || parsedIP.To4() != nil {
 			continue
@@ -666,7 +488,7 @@ func appendAnyAnswers(reply *dnsprotocol.Msg, questionName string, lookupName st
 		})
 	}
 
-	for _, value := range normalizeRecordValues(record.TXT) {
+	for _, value := range record.TXT {
 		reply.Answer = append(reply.Answer, &dnsprotocol.TXT{
 			Hdr: dnsprotocol.RR_Header{Name: questionName, Rrtype: dnsprotocol.TypeTXT, Class: dnsprotocol.ClassINET, Ttl: defaultDNSTTL},
 			Txt: []string{value},
@@ -674,7 +496,7 @@ func appendAnyAnswers(reply *dnsprotocol.Msg, questionName string, lookupName st
 	}
 
 	if len(record.NS) > 0 {
-		for _, value := range normalizeRecordValues(record.NS) {
+		for _, value := range record.NS {
 			reply.Answer = append(reply.Answer, &dnsprotocol.NS{
 				Hdr: dnsprotocol.RR_Header{Name: questionName, Rrtype: dnsprotocol.TypeNS, Class: dnsprotocol.ClassINET, Ttl: defaultDNSTTL},
 				Ns:  normalizeName(value) + ".",
@@ -682,15 +504,15 @@ func appendAnyAnswers(reply *dnsprotocol.Msg, questionName string, lookupName st
 		}
 	}
 
-	for _, value := range normalizeRecordValues(record.DNSKEY) {
+	for _, value := range record.DNSKEY {
 		appendDNSSECResourceRecords(reply, questionName, dnsprotocol.TypeDNSKEY, []string{value})
 	}
 
-	for _, value := range normalizeRecordValues(record.DS) {
+	for _, value := range record.DS {
 		appendDNSSECResourceRecords(reply, questionName, dnsprotocol.TypeDS, []string{value})
 	}
 
-	for _, value := range normalizeRecordValues(record.RRSIG) {
+	for _, value := range record.RRSIG {
 		appendDNSSECResourceRecords(reply, questionName, dnsprotocol.TypeRRSIG, []string{value})
 	}