From 79cfb8bbcd5efbae5630d18031ef2cbb4f1e6a62 Mon Sep 17 00:00:00 2001 From: Andres Uribe Date: Tue, 3 Oct 2023 11:27:19 -0400 Subject: [PATCH] Refactoring so error causality is easier to follow (#672) Co-authored-by: Gabe <7622243+decentralgabe@users.noreply.github.com> --- integration/common.go | 8 ++++---- internal/credential/model.go | 8 ++++---- internal/keyaccess/dataintegrity.go | 6 +++--- internal/keyaccess/jwt.go | 6 +++--- internal/util/crypto.go | 8 ++++---- internal/verification/verification.go | 2 +- pkg/server/framework/util.go | 16 ---------------- pkg/server/router/credential.go | 2 +- pkg/server/router/did_test.go | 2 +- pkg/server/router/issuance.go | 2 +- pkg/server/router/keystore.go | 4 ++-- pkg/server/router/manifest.go | 16 ++++++++-------- pkg/server/router/presentation.go | 4 ++-- pkg/server/router/schema.go | 2 +- pkg/server/router/webhook.go | 2 +- pkg/server/server_presentation_test.go | 2 +- pkg/server/server_schema_test.go | 2 +- pkg/service/common/storage.go | 2 +- pkg/service/credential/service.go | 2 +- pkg/service/credential/storage.go | 4 ++-- pkg/service/did/batch.go | 2 +- pkg/service/did/ion.go | 18 +++++++++--------- pkg/service/did/key.go | 10 +++++----- pkg/service/did/service.go | 2 +- pkg/service/did/storage.go | 4 ++-- pkg/service/did/web.go | 12 ++++++------ pkg/service/keystore/storage.go | 2 +- pkg/service/manifest/service.go | 8 ++++---- pkg/service/presentation/service.go | 8 ++++---- pkg/service/presentation/storage.go | 2 +- pkg/service/schema/service.go | 2 +- pkg/service/schema/storage.go | 2 +- pkg/service/well-known/did_configuration.go | 2 +- pkg/storage/bolt.go | 2 +- pkg/storage/db_test.go | 2 +- pkg/storage/redis.go | 6 +++--- pkg/storage/sql.go | 2 +- 37 files changed, 85 insertions(+), 101 deletions(-) diff --git a/integration/common.go b/integration/common.go index e5ff625ad..ddb046182 100644 --- a/integration/common.go +++ b/integration/common.go @@ -202,7 +202,7 @@ func CreateVerifiableCredential(credentialInput credInputParams) (string, error) }, expBackoff) if err != nil { - return "", errors.Wrap(err, "error after retrying") + return "", errors.Wrap(err, "after retrying") } return output, nil @@ -230,7 +230,7 @@ func BatchCreateVerifiableCredentials(credentialInput batchCredInputParams) (str output, err := put(endpoint+version+"credentials/batch", credentialJSON) if err != nil { - return "", errors.Wrap(err, "error writing batch credentials") + return "", errors.Wrap(err, "writing batch credentials") } return output, nil @@ -253,7 +253,7 @@ func BatchUpdateVerifiableCredentialStatuses(updateStatusInput batchUpdateStatus output, err := put(endpoint+version+"credentials/status/batch", updateStatusesJSON) if err != nil { - return "", errors.Wrap(err, "error writing batch update status") + return "", errors.Wrap(err, "writing batch update status") } return output, nil @@ -292,7 +292,7 @@ func BatchCreate100VerifiableCredentials(credentialInput credInputParams) (strin output, err := put(endpoint+version+"credentials/batch", string(batchCreateData)) if err != nil { - return "", errors.Wrap(err, "error writing batch credentials") + return "", errors.Wrap(err, "writing batch credentials") } return output, nil diff --git a/internal/credential/model.go b/internal/credential/model.go index 35749f19c..7e688c5f5 100644 --- a/internal/credential/model.go +++ b/internal/credential/model.go @@ -63,7 +63,7 @@ func (c Container) HasJWTCredential() bool { func NewCredentialContainerFromJWT(credentialJWT string) (*Container, error) { _, _, cred, err := parsing.ToCredential(credentialJWT) if err != nil { - return nil, errors.Wrap(err, "could not parse credential from JWT") + return nil, errors.Wrap(err, "parsing credential from JWT") } return &Container{ Credential: cred, @@ -76,7 +76,7 @@ func NewCredentialContainerFromJWT(credentialJWT string) (*Container, error) { func NewCredentialContainerFromMap(credMap map[string]any) (*Container, error) { _, _, cred, err := parsing.ToCredential(credMap) if err != nil { - return nil, errors.Wrap(err, "could not parse credential from map") + return nil, errors.Wrap(err, "parsing credential from map") } container := Container{ Credential: cred, @@ -109,14 +109,14 @@ func NewCredentialContainerFromArray(creds []any) ([]Container, error) { // JWT container, err := NewCredentialContainerFromJWT(v) if err != nil { - return nil, errors.Wrap(err, "could not parse credential from JWT") + return nil, errors.Wrap(err, "parsing credential from JWT") } containers = append(containers, *container) case map[string]any: // JSON container, err := NewCredentialContainerFromMap(v) if err != nil { - return nil, errors.Wrap(err, "could not parse credential from JSON") + return nil, errors.Wrap(err, "parsing credential from JSON") } containers = append(containers, *container) default: diff --git a/internal/keyaccess/dataintegrity.go b/internal/keyaccess/dataintegrity.go index c12b4bbaa..ef88aebd7 100644 --- a/internal/keyaccess/dataintegrity.go +++ b/internal/keyaccess/dataintegrity.go @@ -60,11 +60,11 @@ func (ka DataIntegrityKeyAccess) Sign(payload cryptosuite.WithEmbeddedProof) (*D return nil, errors.New("payload cannot be nil") } if err := ka.CryptoSuite.Sign(&ka.Signer, payload); err != nil { - return nil, errors.Wrap(err, "could not sign payload") + return nil, errors.Wrap(err, "signing payload") } signedJSONBytes, err := json.Marshal(payload) if err != nil { - return nil, errors.Wrap(err, "could not marshal signed payload") + return nil, errors.Wrap(err, "marshaling signed payload") } return &DataIntegrityJSON{Data: signedJSONBytes}, nil } @@ -74,7 +74,7 @@ func (ka DataIntegrityKeyAccess) Verify(payload cryptosuite.WithEmbeddedProof) e return errors.New("payload cannot be nil") } if err := ka.CryptoSuite.Verify(&ka.Verifier, payload); err != nil { - return errors.Wrap(err, "could not verify payload") + return errors.Wrap(err, "verifying payload") } return nil } diff --git a/internal/keyaccess/jwt.go b/internal/keyaccess/jwt.go index ed42b0d12..46c3de46f 100644 --- a/internal/keyaccess/jwt.go +++ b/internal/keyaccess/jwt.go @@ -103,7 +103,7 @@ func (ka JWKKeyAccess) Sign(payload map[string]any) (*JWT, error) { } tokenBytes, err := ka.SignWithDefaults(payload) if err != nil { - return nil, errors.Wrap(err, "could not sign payload") + return nil, errors.Wrap(err, "signing payload") } return JWT(tokenBytes).Ptr(), nil } @@ -125,7 +125,7 @@ func (ka JWKKeyAccess) SignVerifiableCredential(cred credential.VerifiableCreden tokenBytes, err := integrity.SignVerifiableCredentialJWT(*ka.Signer, cred) if err != nil { - return nil, errors.Wrap(err, "could not sign cred") + return nil, errors.Wrap(err, "signing cred") } return JWT(tokenBytes).Ptr(), nil } @@ -147,7 +147,7 @@ func (ka JWKKeyAccess) SignVerifiablePresentation(audience string, presentation } tokenBytes, err := integrity.SignVerifiablePresentationJWT(*ka.Signer, &integrity.JWTVVPParameters{Audience: []string{audience}}, presentation) if err != nil { - return nil, errors.Wrap(err, "could not sign presentation") + return nil, errors.Wrap(err, "signing presentation") } return JWT(tokenBytes).Ptr(), nil } diff --git a/internal/util/crypto.go b/internal/util/crypto.go index 027ae39fc..3da108c90 100644 --- a/internal/util/crypto.go +++ b/internal/util/crypto.go @@ -29,13 +29,13 @@ const ( func XChaCha20Poly1305Encrypt(key, data []byte) ([]byte, error) { aead, err := chacha20poly1305.NewX(key) if err != nil { - return nil, errors.Wrap(err, "could not create aead with provided key") + return nil, errors.Wrap(err, "creating aead with provided key") } // generate a random nonce, leaving room for the ciphertext nonce := make([]byte, aead.NonceSize(), aead.NonceSize()+len(data)+aead.Overhead()) if _, err = rand.Read(nonce); err != nil { - return nil, errors.Wrap(err, "could not generate nonce for encryption") + return nil, errors.Wrap(err, "generating nonce for encryption") } encrypted := aead.Seal(nonce, nonce, data, nil) @@ -46,7 +46,7 @@ func XChaCha20Poly1305Encrypt(key, data []byte) ([]byte, error) { func XChaCha20Poly1305Decrypt(key, data []byte) ([]byte, error) { aead, err := chacha20poly1305.NewX(key) if err != nil { - return nil, errors.Wrap(err, "could not create aead with provided key") + return nil, errors.Wrap(err, "creating aead with provided key") } if len(data) < aead.NonceSize() { @@ -59,7 +59,7 @@ func XChaCha20Poly1305Decrypt(key, data []byte) ([]byte, error) { // Decrypt the message and check it wasn't tampered with. decrypted, err := aead.Open(nil, nonce, ciphertext, nil) if err != nil { - return nil, errors.Wrap(err, "could not decrypt data") + return nil, errors.Wrap(err, "decrypting data") } return decrypted, nil } diff --git a/internal/verification/verification.go b/internal/verification/verification.go index baf5bef35..3d8ea82bd 100644 --- a/internal/verification/verification.go +++ b/internal/verification/verification.go @@ -40,7 +40,7 @@ func NewVerifiableDataVerifier(didResolver resolution.Resolver, schemaResolver s validators := validation.GetKnownVerifiers() validator, err := validation.NewCredentialValidator(validators) if err != nil { - return nil, errors.Wrap(err, "failed to create static validator") + return nil, errors.Wrap(err, "creating static validator") } return &Verifier{ validator: validator, diff --git a/pkg/server/framework/util.go b/pkg/server/framework/util.go index 48c1bec24..e7aed6bd9 100644 --- a/pkg/server/framework/util.go +++ b/pkg/server/framework/util.go @@ -1,12 +1,7 @@ package framework import ( - "bytes" - "io" - "net/http" - "github.com/gin-gonic/gin" - "github.com/pkg/errors" ) // GetParam is a utility to get a path parameter from context, nil if not found @@ -30,14 +25,3 @@ func GetQueryValue(c *gin.Context, param string) *string { } return &got } - -// PeekRequestBody reads a request's body without emptying the buffer -func PeekRequestBody(r *http.Request) (string, error) { - bodyBytes, err := io.ReadAll(r.Body) - if err != nil { - return "", errors.Wrap(err, "could not ready request body") - } - result := string(bodyBytes) - r.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) - return result, nil -} diff --git a/pkg/server/router/credential.go b/pkg/server/router/credential.go index ca09e4f3e..8191cc7da 100644 --- a/pkg/server/router/credential.go +++ b/pkg/server/router/credential.go @@ -657,7 +657,7 @@ func (cr CredentialRouter) DeleteCredential(c *gin.Context) { } if err := cr.service.DeleteCredential(c, credential.DeleteCredentialRequest{ID: *id}); err != nil { - errMsg := fmt.Sprintf("could not delete credential with id: %s", *id) + errMsg := fmt.Sprintf("deleting credential with id: %s", *id) framework.LoggingRespondErrWithMsg(c, err, errMsg, http.StatusInternalServerError) return } diff --git a/pkg/server/router/did_test.go b/pkg/server/router/did_test.go index 41f5f18a6..c1a6e1aa5 100644 --- a/pkg/server/router/did_test.go +++ b/pkg/server/router/did_test.go @@ -105,7 +105,7 @@ func TestDIDRouter(t *testing.T) { // bad key type _, err = didService.CreateDIDByMethod(context.Background(), did.CreateDIDRequest{Method: didsdk.KeyMethod, KeyType: "bad"}) assert.Error(tt, err) - assert.Contains(tt, err.Error(), "could not create did:key") + assert.Contains(tt, err.Error(), "unsupported did:key type: bad") // good key type createDIDResponse, err := didService.CreateDIDByMethod(context.Background(), did.CreateDIDRequest{Method: didsdk.KeyMethod, KeyType: crypto.Ed25519}) diff --git a/pkg/server/router/issuance.go b/pkg/server/router/issuance.go index 82380103e..f8fdd9dc1 100644 --- a/pkg/server/router/issuance.go +++ b/pkg/server/router/issuance.go @@ -111,7 +111,7 @@ func (ir IssuanceRouter) DeleteIssuanceTemplate(c *gin.Context) { } if err := ir.service.DeleteIssuanceTemplate(c, &issuance.DeleteIssuanceTemplateRequest{ID: *id}); err != nil { - errMsg := fmt.Sprintf("could not delete issuance template with id: %s", *id) + errMsg := fmt.Sprintf("deleting issuance template with id: %s", *id) framework.LoggingRespondErrWithMsg(c, err, errMsg, http.StatusInternalServerError) return } diff --git a/pkg/server/router/keystore.go b/pkg/server/router/keystore.go index 11147dd5d..825e5e24c 100644 --- a/pkg/server/router/keystore.go +++ b/pkg/server/router/keystore.go @@ -51,10 +51,10 @@ func (sk StoreKeyRequest) ToServiceRequest() (*keystore.StoreKeyRequest, error) // make sure we can decode and re-encode the key before storing it privateKeyBytes, err := base58.Decode(sk.PrivateKeyBase58) if err != nil { - return nil, errors.Wrap(err, "could not decode base58 private key") + return nil, errors.Wrap(err, "decoding base58 private key") } if _, err = crypto.BytesToPrivKey(privateKeyBytes, sk.Type); err != nil { - return nil, errors.Wrap(err, "could not convert bytes to private key") + return nil, errors.Wrap(err, "converting bytes to private key") } return &keystore.StoreKeyRequest{ ID: sk.ID, diff --git a/pkg/server/router/manifest.go b/pkg/server/router/manifest.go index a5d75641d..1372442a1 100644 --- a/pkg/server/router/manifest.go +++ b/pkg/server/router/manifest.go @@ -235,7 +235,7 @@ func (mr ManifestRouter) DeleteManifest(c *gin.Context) { } if err := mr.service.DeleteManifest(c, model.DeleteManifestRequest{ID: *id}); err != nil { - errMsg := fmt.Sprintf("could not delete manifest with id: %s", *id) + errMsg := fmt.Sprintf("deleting manifest with id: %s", *id) framework.LoggingRespondErrWithMsg(c, err, errMsg, http.StatusInternalServerError) return } @@ -258,7 +258,7 @@ const ( func (sar SubmitApplicationRequest) toServiceRequest() (*model.SubmitApplicationRequest, error) { _, token, err := util.ParseJWT(sar.ApplicationJWT) if err != nil { - return nil, errors.Wrap(err, "could not parse application JWT") + return nil, errors.Wrap(err, "parsing application JWT") } iss := token.Issuer() if iss == "" { @@ -287,16 +287,16 @@ func (sar SubmitApplicationRequest) toServiceRequest() (*model.SubmitApplication } applicationTokenBytes, err := json.Marshal(credAppJSON) if err != nil { - return nil, errors.Wrap(err, "could not marshal Credential Application credAppJSON") + return nil, errors.Wrap(err, "marshalling Credential Application credAppJSON") } var application manifestsdk.CredentialApplication if err = json.Unmarshal(applicationTokenBytes, &application); err != nil { - return nil, errors.Wrap(err, "could not reconstruct Credential Application") + return nil, errors.Wrap(err, "reconstructing Credential Application") } credContainer, err := credential.NewCredentialContainerFromArray(creds) if err != nil { - return nil, errors.Wrap(err, "could not parse submitted credentials") + return nil, errors.Wrap(err, "parsing submitted credentials") } return &model.SubmitApplicationRequest{ ApplicantDID: iss, @@ -438,7 +438,7 @@ func (mr ManifestRouter) DeleteApplication(c *gin.Context) { } if err := mr.service.DeleteApplication(c, model.DeleteApplicationRequest{ID: *id}); err != nil { - errMsg := fmt.Sprintf("could not delete application with id: %s", *id) + errMsg := fmt.Sprintf("deleting application with id: %s", *id) framework.LoggingRespondErrWithMsg(c, err, errMsg, http.StatusInternalServerError) return } @@ -535,7 +535,7 @@ func (mr ManifestRouter) DeleteResponse(c *gin.Context) { } if err := mr.service.DeleteResponse(c, model.DeleteResponseRequest{ID: *id}); err != nil { - errMsg := fmt.Sprintf("could not delete response with id: %s", *id) + errMsg := fmt.Sprintf("deleting response with id: %s", *id) framework.LoggingRespondErrWithMsg(c, err, errMsg, http.StatusInternalServerError) return } @@ -744,7 +744,7 @@ func (mr ManifestRouter) DeleteRequest(c *gin.Context) { } if err := mr.service.DeleteRequest(c, model.DeleteRequestRequest{ID: *id}); err != nil { - errMsg := fmt.Sprintf("could not delete manifest request with id: %s", *id) + errMsg := fmt.Sprintf("deleting manifest request with id: %s", *id) framework.LoggingRespondErrWithMsg(c, err, errMsg, http.StatusInternalServerError) return } diff --git a/pkg/server/router/presentation.go b/pkg/server/router/presentation.go index e73e8961b..9e5bac12e 100644 --- a/pkg/server/router/presentation.go +++ b/pkg/server/router/presentation.go @@ -271,7 +271,7 @@ func (pr PresentationRouter) DeleteDefinition(c *gin.Context) { } if err := pr.service.DeletePresentationDefinition(c, model.DeletePresentationDefinitionRequest{ID: *id}); err != nil { - errMsg := fmt.Sprintf("could not delete presentation with id: %s", *id) + errMsg := fmt.Sprintf("deleting presentation with id: %s", *id) framework.LoggingRespondErrWithMsg(c, err, errMsg, http.StatusInternalServerError) return } @@ -681,7 +681,7 @@ func (pr PresentationRouter) DeleteRequest(c *gin.Context) { } if err := pr.service.DeleteRequest(c, model.DeleteRequestRequest{ID: *id}); err != nil { - errMsg := fmt.Sprintf("could not delete presentation request with id: %s", *id) + errMsg := fmt.Sprintf("deleting presentation request with id: %s", *id) framework.LoggingRespondErrWithMsg(c, err, errMsg, http.StatusInternalServerError) return } diff --git a/pkg/server/router/schema.go b/pkg/server/router/schema.go index 3ddb55a71..d6a8d7e27 100644 --- a/pkg/server/router/schema.go +++ b/pkg/server/router/schema.go @@ -263,7 +263,7 @@ func (sr SchemaRouter) DeleteSchema(c *gin.Context) { } if err := sr.service.DeleteSchema(c, schema.DeleteSchemaRequest{ID: *id}); err != nil { - errMsg := fmt.Sprintf("could not delete schema with id: %s", *id) + errMsg := fmt.Sprintf("deleting schema with id: %s", *id) framework.LoggingRespondErrWithMsg(c, err, errMsg, http.StatusInternalServerError) return } diff --git a/pkg/server/router/webhook.go b/pkg/server/router/webhook.go index 29c35c3f5..80e650493 100644 --- a/pkg/server/router/webhook.go +++ b/pkg/server/router/webhook.go @@ -194,7 +194,7 @@ func (wr WebhookRouter) DeleteWebhook(c *gin.Context) { } if err := wr.service.DeleteWebhook(c, req); err != nil { - errMsg := fmt.Sprintf("could not delete webhook with id: %s-%s-%s", request.Noun, request.Verb, request.URL) + errMsg := fmt.Sprintf("deleting webhook with id: %s-%s-%s", request.Noun, request.Verb, request.URL) framework.LoggingRespondErrWithMsg(c, err, errMsg, http.StatusInternalServerError) return } diff --git a/pkg/server/server_presentation_test.go b/pkg/server/server_presentation_test.go index 93438b06b..afc08143e 100644 --- a/pkg/server/server_presentation_test.go +++ b/pkg/server/server_presentation_test.go @@ -379,7 +379,7 @@ func TestPresentationAPI(t *testing.T) { w := httptest.NewRecorder() c := newRequestContextWithParams(w, req, map[string]string{"id": pd.ID}) pRouter.DeleteDefinition(c) - assert.Contains(ttt, w.Body.String(), fmt.Sprintf("could not delete presentation definition with id: %s", pd.ID)) + assert.Contains(ttt, w.Body.String(), fmt.Sprintf("deleting presentation definition with id: %s", pd.ID)) }) tt.Run("Submission endpoints", func(ttt *testing.T) { diff --git a/pkg/server/server_schema_test.go b/pkg/server/server_schema_test.go index 5005c1b29..2dd18b4e9 100644 --- a/pkg/server/server_schema_test.go +++ b/pkg/server/server_schema_test.go @@ -249,7 +249,7 @@ func TestSchemaAPI(t *testing.T) { req := httptest.NewRequest(http.MethodDelete, "https://ssi-service.com/v1/schemas/bad", nil) c := newRequestContextWithParams(w, req, map[string]string{"id": "bad"}) schemaService.DeleteSchema(c) - assert.Contains(tt, w.Body.String(), "could not delete schema with id: bad") + assert.Contains(tt, w.Body.String(), "deleting schema with id: bad") // create a schema simpleSchema := getTestSchema() diff --git a/pkg/service/common/storage.go b/pkg/service/common/storage.go index cef1ae51c..2fb9eb645 100644 --- a/pkg/service/common/storage.go +++ b/pkg/service/common/storage.go @@ -65,7 +65,7 @@ func (s *requestStorage) GetRequest(ctx context.Context, id string) (*StoredRequ func (s *requestStorage) DeleteRequest(ctx context.Context, id string) error { if err := s.db.Delete(ctx, s.namespace, id); err != nil { - return util.LoggingNewErrorf("could not delete request: %s", id) + return util.LoggingNewErrorf("deleting request: %s", id) } return nil } diff --git a/pkg/service/credential/service.go b/pkg/service/credential/service.go index 6574ccc06..3d094181a 100644 --- a/pkg/service/credential/service.go +++ b/pkg/service/credential/service.go @@ -592,7 +592,7 @@ func (s Service) DeleteCredential(ctx context.Context, request DeleteCredentialR logrus.Debugf("deleting credential: %s", request.ID) if err := s.storage.DeleteCredential(ctx, request.ID); err != nil { - return sdkutil.LoggingErrorMsgf(err, "could not delete credential with id: %s", request.ID) + return sdkutil.LoggingErrorMsgf(err, "deleting credential with id: %s", request.ID) } return nil diff --git a/pkg/service/credential/storage.go b/pkg/service/credential/storage.go index f645fdab7..a35abb1c8 100644 --- a/pkg/service/credential/storage.go +++ b/pkg/service/credential/storage.go @@ -308,7 +308,7 @@ func buildStoredCredential(request StoreCredentialRequest) (*StoredCredential, e if request.HasJWTCredential() { _, _, parsedCred, err := integrity.ParseVerifiableCredentialFromJWT(request.CredentialJWT.String()) if err != nil { - return nil, errors.Wrap(err, "could not parse credential from jwt") + return nil, errors.Wrap(err, "parsing credential from jwt") } // if we have a JWT credential, update the reference @@ -524,7 +524,7 @@ func (cs *Storage) deleteCredential(ctx context.Context, id string, namespace st // re-create the prefix key to delete prefix := createPrefixKey(id, gotCred.Issuer, gotCred.Subject, gotCred.Schema) if err = cs.db.Delete(ctx, namespace, prefix); err != nil { - return sdkutil.LoggingErrorMsgf(err, "could not delete credential: %s", id) + return sdkutil.LoggingErrorMsgf(err, "deleting credential: %s", id) } return nil } diff --git a/pkg/service/did/batch.go b/pkg/service/did/batch.go index a9429dc29..bf7bd9131 100644 --- a/pkg/service/did/batch.go +++ b/pkg/service/did/batch.go @@ -23,7 +23,7 @@ type BatchService struct { func NewBatchDIDService(config config.DIDServiceConfig, s storage.ServiceStorage, factory keystore.ServiceFactory) (*BatchService, error) { didStorage, err := NewDIDStorage(s) if err != nil { - return nil, errors.Wrap(err, "could not instantiate DID storage for the DID service") + return nil, errors.Wrap(err, "instantiating DID storage for the DID service") } service := BatchService{ diff --git a/pkg/service/did/ion.go b/pkg/service/did/ion.go index ceb83d26a..f919ca8b2 100644 --- a/pkg/service/did/ion.go +++ b/pkg/service/did/ion.go @@ -203,7 +203,7 @@ func (h *ionHandler) applyUpdate(id string) func(ctx context.Context, tx storage return nil, errors.Wrap(err, "converting update private key to store request") } if err := keyStore.StoreKey(ctx, *updateStoreRequest); err != nil { - return nil, errors.Wrap(err, "could not store did:ion update private key") + return nil, errors.Wrap(err, "storing did:ion update private key") } didStorage, err := h.didStorageFactory(tx) @@ -272,7 +272,7 @@ func (h *ionHandler) prepareUpdate(request UpdateIONDIDRequest) func(ctx context return nil, errors.Wrap(err, "converting update private key to store request") } if err := keyStore.StoreKey(ctx, *storeRequestForUpdateKey); err != nil { - return nil, errors.Wrap(err, "could not store did:ion update private key") + return nil, errors.Wrap(err, "storing did:ion update private key") } storedDID := new(ionStoredDID) @@ -398,11 +398,11 @@ func (h *ionHandler) CreateDID(ctx context.Context, request CreateDIDRequest) (* // create a key for the docs _, privKey, err := crypto.GenerateKeyByKeyType(request.KeyType) if err != nil { - return nil, errors.Wrap(err, "could not generate key for ion DID") + return nil, errors.Wrap(err, "generating key for ion DID") } pubKeyJWK, privKeyJWK, err := jwx.PrivateKeyToPrivateKeyJWK(uuid.NewString(), privKey) if err != nil { - return nil, errors.Wrap(err, "could not convert key to JWK") + return nil, errors.Wrap(err, "converting key to JWK") } keyID := uuid.NewString() pubKeys := []ion.PublicKey{ @@ -460,7 +460,7 @@ func (h *ionHandler) CreateDID(ctx context.Context, request CreateDIDRequest) (* return nil, errors.Wrap(err, "converting private key to store request") } if err = h.keyStore.StoreKey(ctx, *keyStoreRequest); err != nil { - return nil, errors.Wrap(err, "could not store did:ion private key") + return nil, errors.Wrap(err, "storing did:ion private key") } return &CreateDIDResponse{DID: *didDoc}, nil @@ -475,7 +475,7 @@ func (h *ionHandler) storeKeys(ctx context.Context, ionDID *ion.DID) error { return errors.Wrap(err, "converting update private key to store request") } if err = h.keyStore.StoreKey(ctx, *updateStoreRequest); err != nil { - return errors.Wrap(err, "could not store did:ion update private key") + return errors.Wrap(err, "storing did:ion update private key") } recoveryStoreRequest, err := keyToStoreRequest(recoveryKeyID(ionDID.ID()), ionDID.GetRecoveryPrivateKey(), ionDID.ID()) @@ -483,7 +483,7 @@ func (h *ionHandler) storeKeys(ctx context.Context, ionDID *ion.DID) error { return errors.Wrap(err, "converting recovery private key to store request") } if err = h.keyStore.StoreKey(ctx, *recoveryStoreRequest); err != nil { - return errors.Wrap(err, "could not store did:ion recovery private key") + return errors.Wrap(err, "storing did:ion recovery private key") } return nil @@ -501,7 +501,7 @@ func keyToStoreRequest(kid string, privateKeyJWK jwx.PrivateKeyJWK, controller s // convert to a serialized format privateKeyBytes, err := crypto.PrivKeyToBytes(privateKey) if err != nil { - return nil, errors.Wrap(err, "could not encode private key as base58 string") + return nil, errors.Wrap(err, "encoding private key as base58 string") } privateKeyBase58 := base58.Encode(privateKeyBytes) return &keystore.StoreKeyRequest{ @@ -538,7 +538,7 @@ func (h *ionHandler) GetDID(ctx context.Context, request GetDIDRequest) (*GetDID func (h *ionHandler) ListDIDs(ctx context.Context, page *common.Page) (*ListDIDsResponse, error) { gotDIDs, err := h.storage.ListDIDsPage(ctx, did.IONMethod.String(), page, new(ionStoredDID)) if err != nil { - return nil, errors.Wrap(err, "error getting did:ion DIDs") + return nil, errors.Wrap(err, "getting did:ion DIDs") } dids := make([]did.Document, 0, len(gotDIDs.DIDs)) for _, gotDID := range gotDIDs.DIDs { diff --git a/pkg/service/did/key.go b/pkg/service/did/key.go index 421b4238a..a79cf9496 100644 --- a/pkg/service/did/key.go +++ b/pkg/service/did/key.go @@ -42,13 +42,13 @@ func (h *keyHandler) CreateDID(ctx context.Context, request CreateDIDRequest) (* // create the DID privKey, doc, err := key.GenerateDIDKey(request.KeyType) if err != nil { - return nil, errors.Wrap(err, "could not create did:key") + return nil, errors.Wrap(err, "creating did:key") } // expand it to the full docs for storage expanded, err := doc.Expand() if err != nil { - return nil, errors.Wrap(err, "error generating did:key document") + return nil, errors.Wrap(err, "generating did:key document") } // store metadata in DID storage @@ -59,13 +59,13 @@ func (h *keyHandler) CreateDID(ctx context.Context, request CreateDIDRequest) (* SoftDeleted: false, } if err = h.storage.StoreDID(ctx, storedDID); err != nil { - return nil, errors.Wrap(err, "could not store did:key value") + return nil, errors.Wrap(err, "storing did:key value") } // convert to a serialized format for return to the client privKeyBytes, err := crypto.PrivKeyToBytes(privKey) if err != nil { - return nil, errors.Wrap(err, "could not encode private key as base58") + return nil, errors.Wrap(err, "encoding private key as base58") } privKeyBase58 := base58.Encode(privKeyBytes) @@ -78,7 +78,7 @@ func (h *keyHandler) CreateDID(ctx context.Context, request CreateDIDRequest) (* } if err = h.keyStore.StoreKey(ctx, keyStoreRequest); err != nil { - return nil, errors.Wrap(err, "could not store did:key private key") + return nil, errors.Wrap(err, "storing did:key private key") } return &CreateDIDResponse{DID: storedDID.DID}, nil } diff --git a/pkg/service/did/service.go b/pkg/service/did/service.go index d3608bcc7..90868d475 100644 --- a/pkg/service/did/service.go +++ b/pkg/service/did/service.go @@ -71,7 +71,7 @@ func (s *Service) GetResolver() didresolution.Resolver { func NewDIDService(config config.DIDServiceConfig, s storage.ServiceStorage, keyStore *keystore.Service, factory keystore.ServiceFactory) (*Service, error) { didStorage, err := NewDIDStorage(s) if err != nil { - return nil, errors.Wrap(err, "could not instantiate DID storage for the DID service") + return nil, errors.Wrap(err, "instantiating DID storage for the DID service") } service := Service{ diff --git a/pkg/service/did/storage.go b/pkg/service/did/storage.go index a1fc0f943..6f7fea4ff 100644 --- a/pkg/service/did/storage.go +++ b/pkg/service/did/storage.go @@ -214,13 +214,13 @@ func (ds *Storage) ListDIDsDefault(ctx context.Context, method string) ([]Defaul } func (ds *Storage) DeleteDID(ctx context.Context, id string) error { - couldNotGetDIDErr := fmt.Sprintf("could not delete DID: %s", id) + couldNotGetDIDErr := fmt.Sprintf("deleting DID: %s", id) ns, err := getNamespaceForDID(id) if err != nil { return sdkutil.LoggingErrorMsg(err, couldNotGetDIDErr) } if err = ds.db.Delete(ctx, ns, id); err != nil { - return sdkutil.LoggingErrorMsgf(err, "could not delete DID: %s", id) + return sdkutil.LoggingErrorMsgf(err, "deleting DID: %s", id) } return nil } diff --git a/pkg/service/did/web.go b/pkg/service/did/web.go index 381f36bf7..d5c863129 100644 --- a/pkg/service/did/web.go +++ b/pkg/service/did/web.go @@ -82,17 +82,17 @@ func (h *webHandler) CreateDID(ctx context.Context, request CreateDIDRequest) (* pubKey, privKey, err := crypto.GenerateKeyByKeyType(request.KeyType) if err != nil { - return nil, errors.Wrap(err, "could not generate key for did:web") + return nil, errors.Wrap(err, "generating key for did:web") } pubKeyBytes, err := crypto.PubKeyToBytes(pubKey) if err != nil { - return nil, errors.Wrap(err, "could not convert public key to byte") + return nil, errors.Wrap(err, "converting public key to byte") } doc, err := didWeb.CreateDoc(request.KeyType, pubKeyBytes) if err != nil { - return nil, errors.Wrap(err, "could not create did:web docs") + return nil, errors.Wrap(err, "creating did:web docs") } // store metadata in DID storage @@ -103,13 +103,13 @@ func (h *webHandler) CreateDID(ctx context.Context, request CreateDIDRequest) (* SoftDeleted: false, } if err = h.storage.StoreDID(ctx, storedDID); err != nil { - return nil, errors.Wrap(err, "could not store did:web value") + return nil, errors.Wrap(err, "storing did:web value") } // convert to a serialized format for return to the client privKeyBytes, err := crypto.PrivKeyToBytes(privKey) if err != nil { - return nil, errors.Wrap(err, "could not encode private key as base58") + return nil, errors.Wrap(err, "encoding private key as base58") } privKeyBase58 := base58.Encode(privKeyBytes) @@ -122,7 +122,7 @@ func (h *webHandler) CreateDID(ctx context.Context, request CreateDIDRequest) (* } if err = h.keyStore.StoreKey(ctx, keyStoreRequest); err != nil { - return nil, errors.Wrap(err, "could not store did:web private key") + return nil, errors.Wrap(err, "storing did:web private key") } return &CreateDIDResponse{DID: storedDID.DID}, nil } diff --git a/pkg/service/keystore/storage.go b/pkg/service/keystore/storage.go index 393f8e0aa..0047580c8 100644 --- a/pkg/service/keystore/storage.go +++ b/pkg/service/keystore/storage.go @@ -176,7 +176,7 @@ func getServiceKey(ctx context.Context, db storage.ServiceStorage, namespace, sk keyBytes, err := base58.Decode(stored.Base58Key) if err != nil { - return nil, errors.Wrap(err, "could not decode service key") + return nil, errors.Wrap(err, "decoding service key") } return keyBytes, nil diff --git a/pkg/service/manifest/service.go b/pkg/service/manifest/service.go index fc13cfcc4..c993c6a1f 100644 --- a/pkg/service/manifest/service.go +++ b/pkg/service/manifest/service.go @@ -253,7 +253,7 @@ func (s Service) DeleteManifest(ctx context.Context, request model.DeleteManifes logrus.Debugf("deleting manifest: %s", request.ID) if err := s.storage.DeleteManifest(ctx, request.ID); err != nil { - return sdkutil.LoggingErrorMsgf(err, "could not delete manifest with id: %s", request.ID) + return sdkutil.LoggingErrorMsgf(err, "deleting manifest with id: %s", request.ID) } return nil @@ -495,7 +495,7 @@ func (s Service) DeleteApplication(ctx context.Context, request model.DeleteAppl logrus.Debugf("deleting application: %s", request.ID) if err := s.storage.DeleteApplication(ctx, request.ID); err != nil { - return sdkutil.LoggingErrorMsgf(err, "could not delete application with id: %s", request.ID) + return sdkutil.LoggingErrorMsgf(err, "deleting application with id: %s", request.ID) } return nil @@ -538,7 +538,7 @@ func (s Service) DeleteResponse(ctx context.Context, request model.DeleteRespons logrus.Debugf("deleting response: %s", request.ID) if err := s.storage.DeleteResponse(ctx, request.ID); err != nil { - return sdkutil.LoggingErrorMsgf(err, "could not delete response with id: %s", request.ID) + return sdkutil.LoggingErrorMsgf(err, "deleting response with id: %s", request.ID) } return nil @@ -606,7 +606,7 @@ func (s Service) DeleteRequest(ctx context.Context, request model.DeleteRequestR logrus.Debugf("deleting manifest request: %s", request.ID) if err := s.reqStorage.DeleteRequest(ctx, request.ID); err != nil { - return sdkutil.LoggingNewErrorf("could not delete manifest request with id: %s", request.ID) + return sdkutil.LoggingNewErrorf("deleting manifest request with id: %s", request.ID) } return nil diff --git a/pkg/service/presentation/service.go b/pkg/service/presentation/service.go index d3b99aa65..6a2b801cd 100644 --- a/pkg/service/presentation/service.go +++ b/pkg/service/presentation/service.go @@ -183,7 +183,7 @@ func (s Service) DeletePresentationDefinition(ctx context.Context, request model logrus.Debugf("deleting presentation definition: %s", request.ID) if err := s.storage.DeleteDefinition(ctx, request.ID); err != nil { - return sdkutil.LoggingNewErrorf("could not delete presentation definition with id: %s", request.ID) + return sdkutil.LoggingNewErrorf("deleting presentation definition with id: %s", request.ID) } return nil @@ -257,7 +257,7 @@ func (s Service) CreateSubmission(ctx context.Context, request model.CreateSubmi // TODO(andres): IO requests should be done in parallel, once we have context wired up. if err = s.storage.StoreSubmission(ctx, storedSubmission); err != nil { - return nil, errors.Wrap(err, "could not store presentation") + return nil, errors.Wrap(err, "storing presentation") } sub, ok := storedSubmission.VerifiablePresentation.PresentationSubmission.(exchange.PresentationSubmission) @@ -270,7 +270,7 @@ func (s Service) CreateSubmission(ctx context.Context, request model.CreateSubmi Done: false, } if err = s.opsStorage.StoreOperation(ctx, storedOp); err != nil { - return nil, errors.Wrap(err, "could not store operation") + return nil, errors.Wrap(err, "storing operation") } return &operation.Operation{ @@ -393,7 +393,7 @@ func (s Service) DeleteRequest(ctx context.Context, request model.DeleteRequestR logrus.Debugf("deleting presentation request: %s", request.ID) if err := s.reqStorage.DeleteRequest(ctx, request.ID); err != nil { - return sdkutil.LoggingNewErrorf("could not delete presentation request with id: %s", request.ID) + return sdkutil.LoggingNewErrorf("deleting presentation request with id: %s", request.ID) } return nil diff --git a/pkg/service/presentation/storage.go b/pkg/service/presentation/storage.go index 431154d15..ba423be9d 100644 --- a/pkg/service/presentation/storage.go +++ b/pkg/service/presentation/storage.go @@ -136,7 +136,7 @@ func (ps *Storage) GetDefinition(ctx context.Context, id string) (*prestorage.St func (ps *Storage) DeleteDefinition(ctx context.Context, id string) error { if err := ps.db.Delete(ctx, presentationDefinitionNamespace, id); err != nil { - return sdkutil.LoggingNewErrorf("could not delete presentation definition: %s", id) + return sdkutil.LoggingNewErrorf("deleting presentation definition: %s", id) } return nil } diff --git a/pkg/service/schema/service.go b/pkg/service/schema/service.go index 4c183021b..b188f34c2 100644 --- a/pkg/service/schema/service.go +++ b/pkg/service/schema/service.go @@ -238,7 +238,7 @@ func (s Service) DeleteSchema(ctx context.Context, request DeleteSchemaRequest) logrus.Debugf("deleting schema: %s", request.ID) if err := s.storage.DeleteSchema(ctx, request.ID); err != nil { - return sdkutil.LoggingErrorMsgf(err, "could not delete schema with id: %s", request.ID) + return sdkutil.LoggingErrorMsgf(err, "deleting schema with id: %s", request.ID) } return nil diff --git a/pkg/service/schema/storage.go b/pkg/service/schema/storage.go index 07a86f76b..96a7368c3 100644 --- a/pkg/service/schema/storage.go +++ b/pkg/service/schema/storage.go @@ -93,7 +93,7 @@ func (s *Storage) ListSchemas(ctx context.Context, page common.Page) (*StoredSch func (s *Storage) DeleteSchema(ctx context.Context, id string) error { if err := s.db.Delete(ctx, namespace, id); err != nil { - return util.LoggingErrorMsgf(err, "could not delete schema: %s", id) + return util.LoggingErrorMsgf(err, "deleting schema: %s", id) } return nil } diff --git a/pkg/service/well-known/did_configuration.go b/pkg/service/well-known/did_configuration.go index 568b666c6..37c78e425 100644 --- a/pkg/service/well-known/did_configuration.go +++ b/pkg/service/well-known/did_configuration.go @@ -36,7 +36,7 @@ func NewDIDConfigurationService(keyStoreService *keystore.Service, didResolver r client := &http.Client{Transport: otelhttp.NewTransport(http.DefaultTransport)} verifier, err := verification.NewVerifiableDataVerifier(didResolver, schema) if err != nil { - return nil, errors.Wrap(err, "could not instantiate verifier for the credential service") + return nil, errors.Wrap(err, "instantiating verifier for the credential service") } return &DIDConfigurationService{ diff --git a/pkg/storage/bolt.go b/pkg/storage/bolt.go index 2b964432a..4a1b32fd3 100644 --- a/pkg/storage/bolt.go +++ b/pkg/storage/bolt.go @@ -303,7 +303,7 @@ func (b *BoltDB) Delete(_ context.Context, namespace, key string) error { func (b *BoltDB) DeleteNamespace(_ context.Context, namespace string) error { return b.db.Update(func(tx *bolt.Tx) error { if err := tx.DeleteBucket([]byte(namespace)); err != nil { - return sdkutil.LoggingErrorMsgf(err, "could not delete namespace<%s>", namespace) + return sdkutil.LoggingErrorMsgf(err, "deleting namespace<%s>", namespace) } return nil }) diff --git a/pkg/storage/db_test.go b/pkg/storage/db_test.go index 72907bc0a..dd4a011d4 100644 --- a/pkg/storage/db_test.go +++ b/pkg/storage/db_test.go @@ -185,7 +185,7 @@ func TestDB(t *testing.T) { // delete a namespace that doesn't exist err = db.DeleteNamespace(context.Background(), "bad") assert.Error(t, err) - assert.Contains(t, err.Error(), "could not delete namespace") + assert.Contains(t, err.Error(), "deleting namespace") // delete namespace err = db.DeleteNamespace(context.Background(), namespace) diff --git a/pkg/storage/redis.go b/pkg/storage/redis.go index 9834a13bb..1c5166f1f 100644 --- a/pkg/storage/redis.go +++ b/pkg/storage/redis.go @@ -182,7 +182,7 @@ func (b *RedisDB) Execute(ctx context.Context, businessLogicFunc BusinessLogicFu if err != nil { logrus.Errorf("error after retrying: %v", err) - return nil, errors.Wrap(err, "failed to execute after retrying") + return nil, errors.Wrap(err, "executing after retrying") } return finalOutput, nil @@ -366,7 +366,7 @@ func (b *RedisDB) DeleteNamespace(ctx context.Context, namespace string) error { } if len(keys) == 0 { - return errors.Errorf("could not delete namespace<%s>, namespace does not exist", namespace) + return errors.Errorf("deleting namespace<%s>, namespace does not exist", namespace) } return b.db.Del(ctx, keys...).Err() @@ -399,7 +399,7 @@ func (b *RedisDB) UpdateValueAndOperation(ctx context.Context, namespace, key st }) if err != nil { - return nil, nil, errors.Wrap(err, "failed to execute transaction") + return nil, nil, errors.Wrap(err, "executing transaction") } return first, op, err diff --git a/pkg/storage/sql.go b/pkg/storage/sql.go index 7a0a7c258..54101f5c2 100644 --- a/pkg/storage/sql.go +++ b/pkg/storage/sql.go @@ -355,7 +355,7 @@ func (s *SQLDB) DeleteNamespace(ctx context.Context, namespace string) error { row := s.db.QueryRowContext(ctx, "DELETE FROM namespaces WHERE namespace = $1 RETURNING *", namespace) var namespaceRemoved string if err := row.Scan(&namespaceRemoved); err != nil { - return errors.Wrap(err, "could not delete namespace") + return errors.Wrap(err, "deleting namespace") } _, err := s.db.ExecContext(ctx, "DELETE FROM key_values WHERE key LIKE $1", Join(namespace, "%"))