ProblemDetails no longer implements Error

aarongable · aarongable · commit 474e9d5c9e1d · 2025-03-26T16:09:23.000-07:00
diff --git a/errors/errors.go b/errors/errors.go
@@ -1,13 +1,23 @@
-// Package errors provides internal-facing error types for use in Boulder. Many
-// of these are transformed directly into Problem Details documents by the WFE.
-// Some, like NotFound, may be handled internally. We avoid using Problem
-// Details documents as part of our internal error system to avoid layering
-// confusions.
+// Package errors provide a special error type for use in Boulder. This error
+// type carries additional type information with it, and has two special powers:
 //
-// These errors are specifically for use in errors that cross RPC boundaries.
-// An error type that does not need to be passed through an RPC can use a plain
-// Go type locally. Our gRPC code is aware of these error types and will
-// serialize and deserialize them automatically.
+// 1. It is recognized by our gRPC code, and the type metadata and detail string
+// will cross gRPC boundaries intact.
+//
+// 2. It is recognized by our frontend API "rendering" code, and will be
+// automatically converted to the corresponding urn:ietf:params:acme:error:...
+// ACME Problem Document.
+//
+// This means that a deeply-nested service (such as the SA) that wants to ensure
+// that the ACME client sees a particular problem document (such as NotFound)
+// can return a BoulderError and be sure that it will be propagated all the way
+// to the client.
+//
+// Note, however, that any additional context wrapped *around* the BoulderError
+// (such as by fmt.Errorf("oops: %w")) will be lost when the error is converted
+// into a problem document. Similarly, any type information wrapped *by* a
+// BoulderError (such as a sql.ErrNoRows) is lost at the gRPC serialization
+// boundary.
 package errors
 
 import (
@@ -85,10 +95,15 @@ type SubBoulderError struct {
 	Identifier identifier.ACMEIdentifier
 }
 
+// Error implements the error interface, returning a string representation of
+// this error.
 func (be *BoulderError) Error() string {
 	return be.Detail
 }
 
+// Unwrap implements the optional error-unwrapping interface. It returns the
+// underlying type, all of when themselves implement the error interface, so
+// that `if errors.Is(someError, berrors.Malformed)` works.
 func (be *BoulderError) Unwrap() error {
 	return be.Type
 }
@@ -164,134 +179,134 @@ func New(errType ErrorType, msg string) error {
 
 // newf is a convenience function for creating a new BoulderError with a
 // formatted message.
-func newf(errType ErrorType, msg string, args ...interface{}) error {
+func newf(errType ErrorType, msg string, args ...any) error {
 	return &BoulderError{
 		Type:   errType,
 		Detail: fmt.Sprintf(msg, args...),
 	}
 }
 
-func InternalServerError(msg string, args ...interface{}) error {
+func InternalServerError(msg string, args ...any) error {
 	return newf(InternalServer, msg, args...)
 }
 
-func MalformedError(msg string, args ...interface{}) error {
+func MalformedError(msg string, args ...any) error {
 	return newf(Malformed, msg, args...)
 }
 
-func UnauthorizedError(msg string, args ...interface{}) error {
+func UnauthorizedError(msg string, args ...any) error {
 	return newf(Unauthorized, msg, args...)
 }
 
-func NotFoundError(msg string, args ...interface{}) error {
+func NotFoundError(msg string, args ...any) error {
 	return newf(NotFound, msg, args...)
 }
 
-func RateLimitError(retryAfter time.Duration, msg string, args ...interface{}) error {
+func RateLimitError(retryAfter time.Duration, msg string, args ...any) error {
 	return &BoulderError{
 		Type:       RateLimit,
 		Detail:     fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/", args...),
 		RetryAfter: retryAfter,
 	}
 }
 
-func RegistrationsPerIPAddressError(retryAfter time.Duration, msg string, args ...interface{}) error {
+func RegistrationsPerIPAddressError(retryAfter time.Duration, msg string, args ...any) error {
 	return &BoulderError{
 		Type:       RateLimit,
 		Detail:     fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#new-registrations-per-ip-address", args...),
 		RetryAfter: retryAfter,
 	}
 }
 
-func RegistrationsPerIPv6RangeError(retryAfter time.Duration, msg string, args ...interface{}) error {
+func RegistrationsPerIPv6RangeError(retryAfter time.Duration, msg string, args ...any) error {
 	return &BoulderError{
 		Type:       RateLimit,
 		Detail:     fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#new-registrations-per-ipv6-range", args...),
 		RetryAfter: retryAfter,
 	}
 }
 
-func NewOrdersPerAccountError(retryAfter time.Duration, msg string, args ...interface{}) error {
+func NewOrdersPerAccountError(retryAfter time.Duration, msg string, args ...any) error {
 	return &BoulderError{
 		Type:       RateLimit,
 		Detail:     fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#new-orders-per-account", args...),
 		RetryAfter: retryAfter,
 	}
 }
 
-func CertificatesPerDomainError(retryAfter time.Duration, msg string, args ...interface{}) error {
+func CertificatesPerDomainError(retryAfter time.Duration, msg string, args ...any) error {
 	return &BoulderError{
 		Type:       RateLimit,
 		Detail:     fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#new-certificates-per-registered-domain", args...),
 		RetryAfter: retryAfter,
 	}
 }
 
-func CertificatesPerFQDNSetError(retryAfter time.Duration, msg string, args ...interface{}) error {
+func CertificatesPerFQDNSetError(retryAfter time.Duration, msg string, args ...any) error {
 	return &BoulderError{
 		Type:       RateLimit,
 		Detail:     fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#new-certificates-per-exact-set-of-hostnames", args...),
 		RetryAfter: retryAfter,
 	}
 }
 
-func FailedAuthorizationsPerDomainPerAccountError(retryAfter time.Duration, msg string, args ...interface{}) error {
+func FailedAuthorizationsPerDomainPerAccountError(retryAfter time.Duration, msg string, args ...any) error {
 	return &BoulderError{
 		Type:       RateLimit,
 		Detail:     fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#authorization-failures-per-hostname-per-account", args...),
 		RetryAfter: retryAfter,
 	}
 }
 
-func RejectedIdentifierError(msg string, args ...interface{}) error {
+func RejectedIdentifierError(msg string, args ...any) error {
 	return newf(RejectedIdentifier, msg, args...)
 }
 
-func InvalidEmailError(msg string, args ...interface{}) error {
+func InvalidEmailError(msg string, args ...any) error {
 	return newf(InvalidEmail, msg, args...)
 }
 
-func UnsupportedContactError(msg string, args ...interface{}) error {
+func UnsupportedContactError(msg string, args ...any) error {
 	return newf(UnsupportedContact, msg, args...)
 }
 
-func ConnectionFailureError(msg string, args ...interface{}) error {
+func ConnectionFailureError(msg string, args ...any) error {
 	return newf(ConnectionFailure, msg, args...)
 }
 
-func CAAError(msg string, args ...interface{}) error {
+func CAAError(msg string, args ...any) error {
 	return newf(CAA, msg, args...)
 }
 
-func MissingSCTsError(msg string, args ...interface{}) error {
+func MissingSCTsError(msg string, args ...any) error {
 	return newf(MissingSCTs, msg, args...)
 }
 
-func DuplicateError(msg string, args ...interface{}) error {
+func DuplicateError(msg string, args ...any) error {
 	return newf(Duplicate, msg, args...)
 }
 
-func OrderNotReadyError(msg string, args ...interface{}) error {
+func OrderNotReadyError(msg string, args ...any) error {
 	return newf(OrderNotReady, msg, args...)
 }
 
-func DNSError(msg string, args ...interface{}) error {
+func DNSError(msg string, args ...any) error {
 	return newf(DNS, msg, args...)
 }
 
-func BadPublicKeyError(msg string, args ...interface{}) error {
+func BadPublicKeyError(msg string, args ...any) error {
 	return newf(BadPublicKey, msg, args...)
 }
 
-func BadCSRError(msg string, args ...interface{}) error {
+func BadCSRError(msg string, args ...any) error {
 	return newf(BadCSR, msg, args...)
 }
 
-func AlreadyReplacedError(msg string, args ...interface{}) error {
+func AlreadyReplacedError(msg string, args ...any) error {
 	return newf(AlreadyReplaced, msg, args...)
 }
 
-func AlreadyRevokedError(msg string, args ...interface{}) error {
+func AlreadyRevokedError(msg string, args ...any) error {
 	return newf(AlreadyRevoked, msg, args...)
 }
 
@@ -303,18 +318,18 @@ func UnknownSerialError() error {
 	return newf(UnknownSerial, "unknown serial")
 }
 
-func InvalidProfileError(msg string, args ...interface{}) error {
+func InvalidProfileError(msg string, args ...any) error {
 	return newf(InvalidProfile, msg, args...)
 }
 
-func BadSignatureAlgorithmError(msg string, args ...interface{}) error {
+func BadSignatureAlgorithmError(msg string, args ...any) error {
 	return newf(BadSignatureAlgorithm, msg, args...)
 }
 
-func AccountDoesNotExistError(msg string, args ...interface{}) error {
+func AccountDoesNotExistError(msg string, args ...any) error {
 	return newf(AccountDoesNotExist, msg, args...)
 }
 
-func BadNonceError(msg string, args ...interface{}) error {
+func BadNonceError(msg string, args ...any) error {
 	return newf(BadNonce, msg, args...)
 }
diff --git a/probs/probs.go b/probs/probs.go
@@ -70,7 +70,7 @@ type SubProblemDetails struct {
 	Identifier identifier.ACMEIdentifier `json:"identifier"`
 }
 
-func (pd *ProblemDetails) Error() string {
+func (pd *ProblemDetails) String() string {
 	return fmt.Sprintf("%s :: %s", pd.Type, pd.Detail)
 }
 
@@ -329,26 +329,6 @@ func Conflict(detail string) *ProblemDetails {
 	}
 }
 
-// ContentLengthRequired returns a ProblemDetails representing a missing
-// Content-Length header error
-func ContentLengthRequired() *ProblemDetails {
-	return &ProblemDetails{
-		Type:       MalformedProblem,
-		Detail:     "missing Content-Length header",
-		HTTPStatus: http.StatusLengthRequired,
-	}
-}
-
-// InvalidContentType returns a ProblemDetails suitable for a missing
-// ContentType header, or an incorrect ContentType header
-func InvalidContentType(detail string) *ProblemDetails {
-	return &ProblemDetails{
-		Type:       MalformedProblem,
-		Detail:     detail,
-		HTTPStatus: http.StatusUnsupportedMediaType,
-	}
-}
-
 // MethodNotAllowed returns a ProblemDetails representing a disallowed HTTP
 // method error.
 func MethodNotAllowed() *ProblemDetails {
diff --git a/probs/probs_test.go b/probs/probs_test.go
@@ -15,7 +15,7 @@ func TestProblemDetails(t *testing.T) {
 		Detail:     "Wat? o.O",
 		HTTPStatus: 403,
 	}
-	test.AssertEquals(t, pd.Error(), "malformed :: Wat? o.O")
+	test.AssertEquals(t, pd.String(), "malformed :: Wat? o.O")
 }
 
 func TestProblemDetailsConvenience(t *testing.T) {
diff --git a/ra/ra_test.go b/ra/ra_test.go
@@ -851,7 +851,7 @@ func TestPerformValidationVAError(t *testing.T) {
 	challenge, err := bgrpc.PBToChallenge(dbAuthzPB.Challenges[challIdx])
 	test.AssertNotError(t, err, "Failed to marshall corepb.Challenge to core.Challenge.")
 	test.Assert(t, challenge.Status == core.StatusInvalid, "challenge was not marked as invalid")
-	test.AssertContains(t, challenge.Error.Error(), "Could not communicate with VA")
+	test.AssertContains(t, challenge.Error.String(), "Could not communicate with VA")
 	test.Assert(t, challenge.ValidationRecord == nil, "challenge had a ValidationRecord")
 
 	// Check that validated timestamp was recorded, stored, and retrieved
diff --git a/va/caa.go b/va/caa.go
@@ -2,6 +2,7 @@ package va
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net/url"
 	"regexp"
@@ -70,7 +71,7 @@ func (va *ValidationAuthorityImpl) DoCAA(ctx context.Context, req *vapb.IsCAAVal
 		if prob != nil {
 			// CAA check failed.
 			probType = string(prob.Type)
-			logEvent.Error = prob.Error()
+			logEvent.Error = prob.String()
 		} else {
 			// CAA check passed.
 			outcome = pass
@@ -145,7 +146,7 @@ func (va *ValidationAuthorityImpl) checkCAA(
 	identifier identifier.ACMEIdentifier,
 	params *caaParams) error {
 	if core.IsAnyNilOrZero(params, params.validationMethod, params.accountURIID) {
-		return probs.ServerInternal("expected validationMethod or accountURIID not provided to checkCAA")
+		return errors.New("expected validationMethod or accountURIID not provided to checkCAA")
 	}
 
 	foundAt, valid, response, err := va.checkCAARecords(ctx, identifier, params)
diff --git a/va/caa_test.go b/va/caa_test.go
@@ -1139,7 +1139,7 @@ func TestCAAFailure(t *testing.T) {
 	}
 	prob := detailedError(err)
 	test.AssertEquals(t, prob.Type, probs.DNSProblem)
-	test.AssertContains(t, prob.Error(), "NXDOMAIN")
+	test.AssertContains(t, prob.String(), "NXDOMAIN")
 }
 
 func TestFilterCAA(t *testing.T) {
diff --git a/va/dns_test.go b/va/dns_test.go
@@ -24,7 +24,7 @@ func TestDNSValidationWrong(t *testing.T) {
 		t.Fatalf("Successful DNS validation with wrong TXT record")
 	}
 	prob := detailedError(err)
-	test.AssertEquals(t, prob.Error(), "unauthorized :: Incorrect TXT record \"a\" found at _acme-challenge.wrong-dns01.com")
+	test.AssertEquals(t, prob.String(), "unauthorized :: Incorrect TXT record \"a\" found at _acme-challenge.wrong-dns01.com")
 }
 
 func TestDNSValidationWrongMany(t *testing.T) {
@@ -35,7 +35,7 @@ func TestDNSValidationWrongMany(t *testing.T) {
 		t.Fatalf("Successful DNS validation with wrong TXT record")
 	}
 	prob := detailedError(err)
-	test.AssertEquals(t, prob.Error(), "unauthorized :: Incorrect TXT record \"a\" (and 4 more) found at _acme-challenge.wrong-many-dns01.com")
+	test.AssertEquals(t, prob.String(), "unauthorized :: Incorrect TXT record \"a\" (and 4 more) found at _acme-challenge.wrong-many-dns01.com")
 }
 
 func TestDNSValidationWrongLong(t *testing.T) {
@@ -46,7 +46,7 @@ func TestDNSValidationWrongLong(t *testing.T) {
 		t.Fatalf("Successful DNS validation with wrong TXT record")
 	}
 	prob := detailedError(err)
-	test.AssertEquals(t, prob.Error(), "unauthorized :: Incorrect TXT record \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...\" found at _acme-challenge.long-dns01.com")
+	test.AssertEquals(t, prob.String(), "unauthorized :: Incorrect TXT record \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...\" found at _acme-challenge.long-dns01.com")
 }
 
 func TestDNSValidationFailure(t *testing.T) {
diff --git a/va/tlsalpn_test.go b/va/tlsalpn_test.go
@@ -254,7 +254,7 @@ func TestTLSALPN01TalkingToHTTP(t *testing.T) {
 	test.AssertError(t, err, "TLS-SNI-01 validation passed when talking to a HTTP-only server")
 	prob := detailedError(err)
 	expected := "Server only speaks HTTP, not TLS"
-	if !strings.HasSuffix(prob.Error(), expected) {
+	if !strings.HasSuffix(prob.String(), expected) {
 		t.Errorf("Got wrong error detail. Expected %q, got %q", expected, prob)
 	}
 }
@@ -780,7 +780,7 @@ func TestTLSALPN01ExtraSANs(t *testing.T) {
 	// In go >= 1.19, the TLS client library detects that the certificate has
 	// a duplicate extension and terminates the connection itself.
 	prob := detailedError(err)
-	test.AssertContains(t, prob.Error(), "Error getting validation data")
+	test.AssertContains(t, prob.String(), "Error getting validation data")
 }
 
 func TestTLSALPN01ExtraAcmeExtensions(t *testing.T) {
@@ -795,7 +795,7 @@ func TestTLSALPN01ExtraAcmeExtensions(t *testing.T) {
 	// In go >= 1.19, the TLS client library detects that the certificate has
 	// a duplicate extension and terminates the connection itself.
 	prob := detailedError(err)
-	test.AssertContains(t, prob.Error(), "Error getting validation data")
+	test.AssertContains(t, prob.String(), "Error getting validation data")
 }
 
 func TestAcceptableExtensions(t *testing.T) {
@@ -857,7 +857,7 @@ func TestTLSALPN01BadIdentifier(t *testing.T) {
 	_, err := va.validateTLSALPN01(ctx, identifier.ACMEIdentifier{Type: "smime", Value: "dobber@bad.horse"}, expectedKeyAuthorization)
 	test.AssertError(t, err, "Server accepted a hypothetical S/MIME identifier")
 	prob := detailedError(err)
-	test.AssertContains(t, prob.Error(), "Identifier type for TLS-ALPN-01 challenge was not DNS or IP")
+	test.AssertContains(t, prob.String(), "Identifier type for TLS-ALPN-01 challenge was not DNS or IP")
 }
 
 // TestTLSALPN01ServerName tests compliance with RFC 8737, Sec. 3 (step 3) & RFC
diff --git a/va/va.go b/va/va.go
@@ -703,7 +703,7 @@ func (va *ValidationAuthorityImpl) DoDCV(ctx context.Context, req *vapb.PerformV
 		outcome := fail
 		if prob != nil {
 			probType = string(prob.Type)
-			logEvent.Error = prob.Error()
+			logEvent.Error = prob.String()
 			logEvent.Challenge.Error = prob
 			logEvent.Challenge.Status = core.StatusInvalid
 		} else {
diff --git a/web/probs.go b/web/probs.go
diff --git a/web/probs_test.go b/web/probs_test.go
diff --git a/wfe2/wfe.go b/wfe2/wfe.go
diff --git a/wfe2/wfe_test.go b/wfe2/wfe_test.go

Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,23 @@`
`1`		`-// Package errors provides internal-facing error types for use in Boulder. Many`
`2`		`-// of these are transformed directly into Problem Details documents by the WFE.`
`3`		`-// Some, like NotFound, may be handled internally. We avoid using Problem`
`4`		`-// Details documents as part of our internal error system to avoid layering`
`5`		`-// confusions.`
	`1`	`+// Package errors provide a special error type for use in Boulder. This error`
	`2`	`+// type carries additional type information with it, and has two special powers:`
`6`	`3`	`//`
`7`		`-// These errors are specifically for use in errors that cross RPC boundaries.`
`8`		`-// An error type that does not need to be passed through an RPC can use a plain`
`9`		`-// Go type locally. Our gRPC code is aware of these error types and will`
`10`		`-// serialize and deserialize them automatically.`
	`4`	`+// 1. It is recognized by our gRPC code, and the type metadata and detail string`
	`5`	`+// will cross gRPC boundaries intact.`
	`6`	`+//`
	`7`	`+// 2. It is recognized by our frontend API "rendering" code, and will be`
	`8`	`+// automatically converted to the corresponding urn:ietf:params:acme:error:...`
	`9`	`+// ACME Problem Document.`
	`10`	`+//`
	`11`	`+// This means that a deeply-nested service (such as the SA) that wants to ensure`
	`12`	`+// that the ACME client sees a particular problem document (such as NotFound)`
	`13`	`+// can return a BoulderError and be sure that it will be propagated all the way`
	`14`	`+// to the client.`
	`15`	`+//`
	`16`	`+// Note, however, that any additional context wrapped around the BoulderError`
	`17`	`+// (such as by fmt.Errorf("oops: %w")) will be lost when the error is converted`
	`18`	`+// into a problem document. Similarly, any type information wrapped by a`
	`19`	`+// BoulderError (such as a sql.ErrNoRows) is lost at the gRPC serialization`
	`20`	`+// boundary.`
`11`	`21`	`package errors`
`12`	`22`
`13`	`23`	`import (`
`@@ -85,10 +95,15 @@ type SubBoulderError struct {`
`85`	`95`	`Identifier identifier.ACMEIdentifier`
`86`	`96`	`}`
`87`	`97`
	`98`	`+// Error implements the error interface, returning a string representation of`
	`99`	`+// this error.`
`88`	`100`	`func (be *BoulderError) Error() string {`
`89`	`101`	`return be.Detail`
`90`	`102`	`}`
`91`	`103`
	`104`	`+// Unwrap implements the optional error-unwrapping interface. It returns the`
	`105`	`+// underlying type, all of when themselves implement the error interface, so`
	`106`	+// that `if errors.Is(someError, berrors.Malformed)` works.
`92`	`107`	`func (be *BoulderError) Unwrap() error {`
`93`	`108`	`return be.Type`
`94`	`109`	`}`
`@@ -164,134 +179,134 @@ func New(errType ErrorType, msg string) error {`
`164`	`179`
`165`	`180`	`// newf is a convenience function for creating a new BoulderError with a`
`166`	`181`	`// formatted message.`
`167`		`-func newf(errType ErrorType, msg string, args ...interface{}) error {`
	`182`	`+func newf(errType ErrorType, msg string, args ...any) error {`
`168`	`183`	`return &BoulderError{`
`169`	`184`	`Type: errType,`
`170`	`185`	`Detail: fmt.Sprintf(msg, args...),`
`171`	`186`	`}`
`172`	`187`	`}`
`173`	`188`
`174`		`-func InternalServerError(msg string, args ...interface{}) error {`
	`189`	`+func InternalServerError(msg string, args ...any) error {`
`175`	`190`	`return newf(InternalServer, msg, args...)`
`176`	`191`	`}`
`177`	`192`
`178`		`-func MalformedError(msg string, args ...interface{}) error {`
	`193`	`+func MalformedError(msg string, args ...any) error {`
`179`	`194`	`return newf(Malformed, msg, args...)`
`180`	`195`	`}`
`181`	`196`
`182`		`-func UnauthorizedError(msg string, args ...interface{}) error {`
	`197`	`+func UnauthorizedError(msg string, args ...any) error {`
`183`	`198`	`return newf(Unauthorized, msg, args...)`
`184`	`199`	`}`
`185`	`200`
`186`		`-func NotFoundError(msg string, args ...interface{}) error {`
	`201`	`+func NotFoundError(msg string, args ...any) error {`
`187`	`202`	`return newf(NotFound, msg, args...)`
`188`	`203`	`}`
`189`	`204`
`190`		`-func RateLimitError(retryAfter time.Duration, msg string, args ...interface{}) error {`
	`205`	`+func RateLimitError(retryAfter time.Duration, msg string, args ...any) error {`
`191`	`206`	`return &BoulderError{`
`192`	`207`	`Type: RateLimit,`
`193`	`208`	`Detail: fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/", args...),`
`194`	`209`	`RetryAfter: retryAfter,`
`195`	`210`	`}`
`196`	`211`	`}`
`197`	`212`
`198`		`-func RegistrationsPerIPAddressError(retryAfter time.Duration, msg string, args ...interface{}) error {`
	`213`	`+func RegistrationsPerIPAddressError(retryAfter time.Duration, msg string, args ...any) error {`
`199`	`214`	`return &BoulderError{`
`200`	`215`	`Type: RateLimit,`
`201`	`216`	`Detail: fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#new-registrations-per-ip-address", args...),`
`202`	`217`	`RetryAfter: retryAfter,`
`203`	`218`	`}`
`204`	`219`	`}`
`205`	`220`
`206`		`-func RegistrationsPerIPv6RangeError(retryAfter time.Duration, msg string, args ...interface{}) error {`
	`221`	`+func RegistrationsPerIPv6RangeError(retryAfter time.Duration, msg string, args ...any) error {`
`207`	`222`	`return &BoulderError{`
`208`	`223`	`Type: RateLimit,`
`209`	`224`	`Detail: fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#new-registrations-per-ipv6-range", args...),`
`210`	`225`	`RetryAfter: retryAfter,`
`211`	`226`	`}`
`212`	`227`	`}`
`213`	`228`
`214`		`-func NewOrdersPerAccountError(retryAfter time.Duration, msg string, args ...interface{}) error {`
	`229`	`+func NewOrdersPerAccountError(retryAfter time.Duration, msg string, args ...any) error {`
`215`	`230`	`return &BoulderError{`
`216`	`231`	`Type: RateLimit,`
`217`	`232`	`Detail: fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#new-orders-per-account", args...),`
`218`	`233`	`RetryAfter: retryAfter,`
`219`	`234`	`}`
`220`	`235`	`}`
`221`	`236`
`222`		`-func CertificatesPerDomainError(retryAfter time.Duration, msg string, args ...interface{}) error {`
	`237`	`+func CertificatesPerDomainError(retryAfter time.Duration, msg string, args ...any) error {`
`223`	`238`	`return &BoulderError{`
`224`	`239`	`Type: RateLimit,`
`225`	`240`	`Detail: fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#new-certificates-per-registered-domain", args...),`
`226`	`241`	`RetryAfter: retryAfter,`
`227`	`242`	`}`
`228`	`243`	`}`
`229`	`244`
`230`		`-func CertificatesPerFQDNSetError(retryAfter time.Duration, msg string, args ...interface{}) error {`
	`245`	`+func CertificatesPerFQDNSetError(retryAfter time.Duration, msg string, args ...any) error {`
`231`	`246`	`return &BoulderError{`
`232`	`247`	`Type: RateLimit,`
`233`	`248`	`Detail: fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#new-certificates-per-exact-set-of-hostnames", args...),`
`234`	`249`	`RetryAfter: retryAfter,`
`235`	`250`	`}`
`236`	`251`	`}`
`237`	`252`
`238`		`-func FailedAuthorizationsPerDomainPerAccountError(retryAfter time.Duration, msg string, args ...interface{}) error {`
	`253`	`+func FailedAuthorizationsPerDomainPerAccountError(retryAfter time.Duration, msg string, args ...any) error {`
`239`	`254`	`return &BoulderError{`
`240`	`255`	`Type: RateLimit,`
`241`	`256`	`Detail: fmt.Sprintf(msg+": see https://letsencrypt.org/docs/rate-limits/#authorization-failures-per-hostname-per-account", args...),`
`242`	`257`	`RetryAfter: retryAfter,`
`243`	`258`	`}`
`244`	`259`	`}`
`245`	`260`
`246`		`-func RejectedIdentifierError(msg string, args ...interface{}) error {`
	`261`	`+func RejectedIdentifierError(msg string, args ...any) error {`
`247`	`262`	`return newf(RejectedIdentifier, msg, args...)`
`248`	`263`	`}`
`249`	`264`
`250`		`-func InvalidEmailError(msg string, args ...interface{}) error {`
	`265`	`+func InvalidEmailError(msg string, args ...any) error {`
`251`	`266`	`return newf(InvalidEmail, msg, args...)`
`252`	`267`	`}`
`253`	`268`
`254`		`-func UnsupportedContactError(msg string, args ...interface{}) error {`
	`269`	`+func UnsupportedContactError(msg string, args ...any) error {`
`255`	`270`	`return newf(UnsupportedContact, msg, args...)`
`256`	`271`	`}`
`257`	`272`
`258`		`-func ConnectionFailureError(msg string, args ...interface{}) error {`
	`273`	`+func ConnectionFailureError(msg string, args ...any) error {`
`259`	`274`	`return newf(ConnectionFailure, msg, args...)`
`260`	`275`	`}`
`261`	`276`
`262`		`-func CAAError(msg string, args ...interface{}) error {`
	`277`	`+func CAAError(msg string, args ...any) error {`
`263`	`278`	`return newf(CAA, msg, args...)`
`264`	`279`	`}`
`265`	`280`
`266`		`-func MissingSCTsError(msg string, args ...interface{}) error {`
	`281`	`+func MissingSCTsError(msg string, args ...any) error {`
`267`	`282`	`return newf(MissingSCTs, msg, args...)`
`268`	`283`	`}`
`269`	`284`
`270`		`-func DuplicateError(msg string, args ...interface{}) error {`
	`285`	`+func DuplicateError(msg string, args ...any) error {`
`271`	`286`	`return newf(Duplicate, msg, args...)`
`272`	`287`	`}`
`273`	`288`
`274`		`-func OrderNotReadyError(msg string, args ...interface{}) error {`
	`289`	`+func OrderNotReadyError(msg string, args ...any) error {`
`275`	`290`	`return newf(OrderNotReady, msg, args...)`
`276`	`291`	`}`
`277`	`292`
`278`		`-func DNSError(msg string, args ...interface{}) error {`
	`293`	`+func DNSError(msg string, args ...any) error {`
`279`	`294`	`return newf(DNS, msg, args...)`
`280`	`295`	`}`
`281`	`296`
`282`		`-func BadPublicKeyError(msg string, args ...interface{}) error {`
	`297`	`+func BadPublicKeyError(msg string, args ...any) error {`
`283`	`298`	`return newf(BadPublicKey, msg, args...)`
`284`	`299`	`}`
`285`	`300`
`286`		`-func BadCSRError(msg string, args ...interface{}) error {`
	`301`	`+func BadCSRError(msg string, args ...any) error {`
`287`	`302`	`return newf(BadCSR, msg, args...)`
`288`	`303`	`}`
`289`	`304`
`290`		`-func AlreadyReplacedError(msg string, args ...interface{}) error {`
	`305`	`+func AlreadyReplacedError(msg string, args ...any) error {`
`291`	`306`	`return newf(AlreadyReplaced, msg, args...)`
`292`	`307`	`}`
`293`	`308`
`294`		`-func AlreadyRevokedError(msg string, args ...interface{}) error {`
	`309`	`+func AlreadyRevokedError(msg string, args ...any) error {`
`295`	`310`	`return newf(AlreadyRevoked, msg, args...)`
`296`	`311`	`}`
`297`	`312`
`@@ -303,18 +318,18 @@ func UnknownSerialError() error {`
`303`	`318`	`return newf(UnknownSerial, "unknown serial")`
`304`	`319`	`}`
`305`	`320`
`306`		`-func InvalidProfileError(msg string, args ...interface{}) error {`
	`321`	`+func InvalidProfileError(msg string, args ...any) error {`
`307`	`322`	`return newf(InvalidProfile, msg, args...)`
`308`	`323`	`}`
`309`	`324`
`310`		`-func BadSignatureAlgorithmError(msg string, args ...interface{}) error {`
	`325`	`+func BadSignatureAlgorithmError(msg string, args ...any) error {`
`311`	`326`	`return newf(BadSignatureAlgorithm, msg, args...)`
`312`	`327`	`}`
`313`	`328`
`314`		`-func AccountDoesNotExistError(msg string, args ...interface{}) error {`
	`329`	`+func AccountDoesNotExistError(msg string, args ...any) error {`
`315`	`330`	`return newf(AccountDoesNotExist, msg, args...)`
`316`	`331`	`}`
`317`	`332`
`318`		`-func BadNonceError(msg string, args ...interface{}) error {`
	`333`	`+func BadNonceError(msg string, args ...any) error {`
`319`	`334`	`return newf(BadNonce, msg, args...)`
`320`	`335`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ func TestProblemDetails(t *testing.T) {`
`15`	`15`	`Detail: "Wat? o.O",`
`16`	`16`	`HTTPStatus: 403,`
`17`	`17`	`}`
`18`		`- test.AssertEquals(t, pd.Error(), "malformed :: Wat? o.O")`
	`18`	`+ test.AssertEquals(t, pd.String(), "malformed :: Wat? o.O")`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`func TestProblemDetailsConvenience(t *testing.T) {`
Original file line number	Diff line number	Diff line change
`@@ -1139,7 +1139,7 @@ func TestCAAFailure(t *testing.T) {`
`1139`	`1139`	`}`
`1140`	`1140`	`prob := detailedError(err)`
`1141`	`1141`	`test.AssertEquals(t, prob.Type, probs.DNSProblem)`
`1142`		`- test.AssertContains(t, prob.Error(), "NXDOMAIN")`
	`1142`	`+ test.AssertContains(t, prob.String(), "NXDOMAIN")`
`1143`	`1143`	`}`
`1144`	`1144`
`1145`	`1145`	`func TestFilterCAA(t *testing.T) {`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ func TestDNSValidationWrong(t *testing.T) {`
`24`	`24`	`t.Fatalf("Successful DNS validation with wrong TXT record")`
`25`	`25`	`}`
`26`	`26`	`prob := detailedError(err)`
`27`		`- test.AssertEquals(t, prob.Error(), "unauthorized :: Incorrect TXT record \"a\" found at _acme-challenge.wrong-dns01.com")`
	`27`	`+ test.AssertEquals(t, prob.String(), "unauthorized :: Incorrect TXT record \"a\" found at _acme-challenge.wrong-dns01.com")`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`func TestDNSValidationWrongMany(t *testing.T) {`
`@@ -35,7 +35,7 @@ func TestDNSValidationWrongMany(t *testing.T) {`
`35`	`35`	`t.Fatalf("Successful DNS validation with wrong TXT record")`
`36`	`36`	`}`
`37`	`37`	`prob := detailedError(err)`
`38`		`- test.AssertEquals(t, prob.Error(), "unauthorized :: Incorrect TXT record \"a\" (and 4 more) found at _acme-challenge.wrong-many-dns01.com")`
	`38`	`+ test.AssertEquals(t, prob.String(), "unauthorized :: Incorrect TXT record \"a\" (and 4 more) found at _acme-challenge.wrong-many-dns01.com")`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`func TestDNSValidationWrongLong(t *testing.T) {`
`@@ -46,7 +46,7 @@ func TestDNSValidationWrongLong(t *testing.T) {`
`46`	`46`	`t.Fatalf("Successful DNS validation with wrong TXT record")`
`47`	`47`	`}`
`48`	`48`	`prob := detailedError(err)`
`49`		`- test.AssertEquals(t, prob.Error(), "unauthorized :: Incorrect TXT record \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...\" found at _acme-challenge.long-dns01.com")`
	`49`	`+ test.AssertEquals(t, prob.String(), "unauthorized :: Incorrect TXT record \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...\" found at _acme-challenge.long-dns01.com")`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`func TestDNSValidationFailure(t *testing.T) {`