Repository: TBD54566975/ssi-service
Pull request #563 (2023-06-26 19:47:39)

Uptake latest SDK; fix empty Credential JWT fields
- uptake latest SDK, no functional changes
- Credentials had empty fields for mapped properties:

```json
{
  "iat": 1687808049,
  "iss": "did:key:z6MkqxtKEsULH8DaadP1HZegmVS2z91B7No4GzvrVHvpShXM",
  "jti": "http://localhost:3000/v1/credentials/691cd8ba-f7bb-4650-89bb-0e0ddee6caf8",
  "nbf": 1687808049,
  "nonce": "bc6b746a-3ab6-4709-96d5-f18a4962ba26",
  "sub": "did:key:z6MkqxtKEsULH8DaadP1HZegmVS2z91B7No4GzvrVHvpShXM",
  "vc": {
    "@context": [
      "https://www.w3.org/2018/credentials/v1"
    ],
    "type": [
      "VerifiableCredential"
    ],
    "issuer": "",
    "issuanceDate": "",
    "credentialSubject": {
      "firstName": "Test"
    }
  }
}
```

these properties are now removed

decentralgabe: tested for after uptake

```json
{
  "exp": 1687895493,
  "iat": 1687809093,
  "iss": "did:key:z6Mkkh5QmEbDuy7bMteDC134uS8JxMaG8nsS4kVQy5M8P3oS",
  "jti": "https://ssi-service.com/v1/credentials/f52c2e41-fa9d-4f86-a5be-3e4614076da0",
  "nbf": 1687809093,
  "nonce": "3a3114e1-89f2-44c0-9c95-73d94092eb6a",
  "sub": "did:abc:456",
  "vc": {
    "@context": [
      "https://www.w3.org/2018/credentials/v1"
    ],
    "type": [
      "VerifiableCredential"
    ],
    "credentialSubject": {
      "firstName": "Jack",
      "lastName": "Dorsey"
    }
  }
}
```
codecov-commenter: ## [Codecov](https://app.codecov.io/gh/TBD54566975/ssi-service/pull/563?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=TBD54566975) Report
> Merging [#563](https://app.codecov.io/gh/TBD54566975/ssi-service/pull/563?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=TBD54566975) (62ac809) into [main](https://app.codecov.io/gh/TBD54566975/ssi-service/commit/2777a72012c5b402e0920b927f3411a9c0c1e0d5?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=TBD54566975) (2777a72) will **not change** coverage.
> The diff coverage is `80.00%`.

> :exclamation: Current head 62ac809 differs from pull request most recent head f302a61. Consider uploading reports for the commit f302a61 to get more accurate results

```diff
@@           Coverage Diff           @@
##             main     #563   +/-   ##
=======================================
  Coverage   23.92%   23.92%           
=======================================
  Files          46       46           
  Lines        5245     5245           
=======================================
  Hits         1255     1255           
  Misses       3758     3758           
  Partials      232      232           
```


| [Impacted Files](https://app.codecov.io/gh/TBD54566975/ssi-service/pull/563?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=TBD54566975) | Coverage Δ | |
|---|---|---|
| [pkg/server/router/presentation.go](https://app.codecov.io/gh/TBD54566975/ssi-service/pull/563?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=TBD54566975#diff-cGtnL3NlcnZlci9yb3V0ZXIvcHJlc2VudGF0aW9uLmdv) | `2.54% <0.00%> (ø)` | |
| [internal/keyaccess/jwt.go](https://app.codecov.io/gh/TBD54566975/ssi-service/pull/563?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=TBD54566975#diff-aW50ZXJuYWwva2V5YWNjZXNzL2p3dC5nbw==) | `43.69% <100.00%> (ø)` | |


nitro-neal: according to 1.1:
eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJ2YyI6eyJAY29udGV4dCI6WyJodHRwczovL3
d3dy53My5vcmcvMjAxOC9jcmVkZW50aWFscy92MSIsImh0dHBzOi8vd3d3LnczLm9yZy8yMDE4L
2NyZWRlbnRpYWxzL2V4YW1wbGVzL3YxIl0sImlkIjoiaHR0cDovL2V4YW1wbGUuZWR1L2NyZWRl
bnRpYWxzLzM3MzIiLCJ0eXBlIjpbIlZlcmlmaWFibGVDcmVkZW50aWFsIiwiVW5pdmVyc2l0eUR
lZ3JlZUNyZWRlbnRpYWwiXSwiaXNzdWVyIjoiaHR0cHM6Ly9leGFtcGxlLmVkdS9pc3N1ZXJzLz
U2NTA0OSIsImlzc3VhbmNlRGF0ZSI6IjIwMTAtMDEtMDFUMDA6MDA6MDBaIiwiY3JlZGVudGlhb
FN1YmplY3QiOnsiaWQiOiJkaWQ6ZXhhbXBsZTplYmZlYjFmNzEyZWJjNmYxYzI3NmUxMmVjMjEi
LCJkZWdyZWUiOnsidHlwZSI6IkJhY2hlbG9yRGVncmVlIiwibmFtZSI6IkJhY2hlbG9yIG9mIFN
jaWVuY2UgYW5kIEFydHMifX19LCJpc3MiOiJodHRwczovL2V4YW1wbGUuZWR1L2lzc3VlcnMvNT
Y1MDQ5IiwibmJmIjoxMjYyMzA0MDAwLCJqdGkiOiJodHRwOi8vZXhhbXBsZS5lZHUvY3JlZGVud
GlhbHMvMzczMiIsInN1YiI6ImRpZDpleGFtcGxlOmViZmViMWY3MTJlYmM2ZjFjMjc2ZTEyZWMy
MSJ9.giMDNtWUgKbvWL4pteSpSkrh-lhgkhJUZ_gatHdRvEFs9_kB4G9neABvTuuQKfwERzi2KF
Qz3X0nzF-jrOO-5w

{
  "vc": {
    "@context": [
      "https://www.w3.org/2018/credentials/v1",
      "https://www.w3.org/2018/credentials/examples/v1"
    ],
    "id": "http://example.edu/credentials/3732",
    "type": [
      "VerifiableCredential",
      "UniversityDegreeCredential"
    ],
    "issuer": "https://example.edu/issuers/565049",
    "issuanceDate": "2010-01-01T00:00:00Z",
    "credentialSubject": {
      "id": "did:example:ebfeb1f712ebc6f1c276e12ec21",
      "degree": {
        "type": "BachelorDegree",
        "name": "Bachelor of Science and Arts"
      }
    }
  },
  "iss": "https://example.edu/issuers/565049",
  "nbf": 1262304000,
  "jti": "http://example.edu/credentials/3732",
  "sub": "did:example:ebfeb1f712ebc6f1c276e12ec21"
}



decentralgabe: @nitro-neal you're right we still have a bug. needs to be fixed in the SDK
decentralgabe: I'm going to keep it as is since not having duplicated fields is spec-compliant and simpler.

Patch:
diff --git a/go.mod b/go.mod
index 9cb3bb8..7ee055e 100644
--- a/go.mod
+++ b/go.mod
@@ -4,7 +4,7 @@ go 1.20
 
 require (
 	github.com/BurntSushi/toml v1.3.2
-	github.com/TBD54566975/ssi-sdk v0.0.4-alpha.0.20230601154259-07707db2c404
+	github.com/TBD54566975/ssi-sdk v0.0.4-alpha.0.20230623174120-9617360e9ee2
 	github.com/alicebob/miniredis/v2 v2.30.3
 	github.com/ardanlabs/conf v1.5.0
 	github.com/benbjohnson/clock v1.3.5
@@ -58,7 +58,7 @@ require (
 	github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20230305170008-8188dc5388df // indirect
 	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
 	github.com/aws/aws-sdk-go v1.44.277 // indirect
-	github.com/bits-and-blooms/bitset v1.7.0 // indirect
+	github.com/bits-and-blooms/bitset v1.8.0 // indirect
 	github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect
 	github.com/bytedance/sonic v1.9.1 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
@@ -130,7 +130,7 @@ require (
 	github.com/multiformats/go-base36 v0.2.0 // indirect
 	github.com/multiformats/go-multibase v0.2.0 // indirect
 	github.com/multiformats/go-multicodec v0.9.0 // indirect
-	github.com/multiformats/go-multihash v0.2.2 // indirect
+	github.com/multiformats/go-multihash v0.2.3 // indirect
 	github.com/multiformats/go-varint v0.0.7 // indirect
 	github.com/ory/go-acc v0.2.9-0.20230103102148-6b1c9a70dbbe // indirect
 	github.com/ory/go-convenience v0.1.0 // indirect
diff --git a/go.sum b/go.sum
index 1d33d1f..9ae8f25 100644
--- a/go.sum
+++ b/go.sum
@@ -46,8 +46,8 @@ github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbi
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc=
 github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE=
-github.com/TBD54566975/ssi-sdk v0.0.4-alpha.0.20230601154259-07707db2c404 h1:EwiJaa6rT7HciSJSK1cDhXbwW8jVln0nwm5X+6s0Lxs=
-github.com/TBD54566975/ssi-sdk v0.0.4-alpha.0.20230601154259-07707db2c404/go.mod h1:Lbdhy8ASuiEuRRk/bKbNcwa5VOrejk/CXo+6HESlwxo=
+github.com/TBD54566975/ssi-sdk v0.0.4-alpha.0.20230623174120-9617360e9ee2 h1:cJLc4zt1GpOXxQ5hzP+Z0j7GXSx/xyq7DW0jjapzSbE=
+github.com/TBD54566975/ssi-sdk v0.0.4-alpha.0.20230623174120-9617360e9ee2/go.mod h1:yPkVO9MCC/kRu+lut3jllhnCV0gEqSubaaSVT7xLSOs=
 github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a/go.mod h1:SGnFV6hVsYE877CKEZ6tDNTjaSXYUk6QqoIK6PrAtcc=
 github.com/alicebob/gopher-json v0.0.0-20230218143504-906a9b012302 h1:uvdUDbHQHO85qeSydJtItA4T55Pw6BtAejd0APRJOCE=
 github.com/alicebob/gopher-json v0.0.0-20230218143504-906a9b012302/go.mod h1:SGnFV6hVsYE877CKEZ6tDNTjaSXYUk6QqoIK6PrAtcc=
@@ -64,8 +64,8 @@ github.com/aws/aws-sdk-go v1.44.277 h1:YHmyzBPARTJ7LLYV1fxbfEbQOaUh3kh52hb7nBvX3
 github.com/aws/aws-sdk-go v1.44.277/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI=
 github.com/benbjohnson/clock v1.3.5 h1:VvXlSJBzZpA/zum6Sj74hxwYI2DIxRWuNIoXAzHZz5o=
 github.com/benbjohnson/clock v1.3.5/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
-github.com/bits-and-blooms/bitset v1.7.0 h1:YjAGVd3XmtK9ktAbX8Zg2g2PwLIMjGREZJHlV4j7NEo=
-github.com/bits-and-blooms/bitset v1.7.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
+github.com/bits-and-blooms/bitset v1.8.0 h1:FD+XqgOZDUxxZ8hzoBFuV9+cGWY9CslN6d5MS5JVb4c=
+github.com/bits-and-blooms/bitset v1.8.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
 github.com/bsm/ginkgo/v2 v2.7.0 h1:ItPMPH90RbmZJt5GtkcNvIRuGEdwlBItdNVoyzaNQao=
 github.com/bsm/ginkgo/v2 v2.7.0/go.mod h1:AiKlXPm7ItEHNc/2+OkrNG4E0ITzojb9/xWzvQ9XZ9w=
 github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
@@ -385,8 +385,8 @@ github.com/multiformats/go-multibase v0.2.0 h1:isdYCVLvksgWlMW9OZRYJEa9pZETFivnc
 github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6oPyjtnzK/XTFDPkNuk=
 github.com/multiformats/go-multicodec v0.9.0 h1:pb/dlPnzee/Sxv/j4PmkDRxCOi3hXTz3IbPKOXWJkmg=
 github.com/multiformats/go-multicodec v0.9.0/go.mod h1:L3QTQvMIaVBkXOXXtVmYE+LI16i14xuaojr/H7Ai54k=
-github.com/multiformats/go-multihash v0.2.2 h1:Uu7LWs/PmWby1gkj1S1DXx3zyd3aVabA4FiMKn/2tAc=
-github.com/multiformats/go-multihash v0.2.2/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM=
+github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U=
+github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM=
 github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8=
 github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU=
 github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32 h1:W6apQkHrMkS0Muv8G/TipAy/FJl/rCYT0+EuS8+Z0z4=
diff --git a/internal/credential/model.go b/internal/credential/model.go
index bcc310b..a06c984 100644
--- a/internal/credential/model.go
+++ b/internal/credential/model.go
@@ -5,8 +5,10 @@ import (
 	"reflect"
 
 	"github.com/TBD54566975/ssi-sdk/credential"
+	"github.com/TBD54566975/ssi-sdk/credential/parsing"
 	"github.com/goccy/go-json"
 	"github.com/pkg/errors"
+
 	"github.com/tbd54566975/ssi-service/internal/keyaccess"
 )
 
@@ -57,7 +59,7 @@ func (c Container) HasJWTCredential() bool {
 
 // NewCredentialContainerFromJWT attempts to parse a VC-JWT credential from a string into a Container
 func NewCredentialContainerFromJWT(credentialJWT string) (*Container, error) {
-	_, _, cred, err := credential.ToCredential(credentialJWT)
+	_, _, cred, err := parsing.ToCredential(credentialJWT)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not parse credential from JWT")
 	}
@@ -70,7 +72,7 @@ func NewCredentialContainerFromJWT(credentialJWT string) (*Container, error) {
 // NewCredentialContainerFromMap attempts to parse a data integrity credential from a piece of JSON,
 // which is represented as a map in go, into a Container
 func NewCredentialContainerFromMap(credMap map[string]any) (*Container, error) {
-	_, _, cred, err := credential.ToCredential(credMap)
+	_, _, cred, err := parsing.ToCredential(credMap)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not parse credential from map")
 	}
diff --git a/internal/credential/verification.go b/internal/credential/verification.go
index 6a74ea5..1bf7e65 100644
--- a/internal/credential/verification.go
+++ b/internal/credential/verification.go
@@ -5,7 +5,8 @@ import (
 	"fmt"
 
 	credsdk "github.com/TBD54566975/ssi-sdk/credential"
-	"github.com/TBD54566975/ssi-sdk/credential/verification"
+	"github.com/TBD54566975/ssi-sdk/credential/integrity"
+	"github.com/TBD54566975/ssi-sdk/credential/validation"
 	"github.com/TBD54566975/ssi-sdk/crypto"
 	"github.com/TBD54566975/ssi-sdk/did/resolution"
 	sdkutil "github.com/TBD54566975/ssi-sdk/util"
@@ -18,15 +19,15 @@ import (
 	"github.com/tbd54566975/ssi-service/internal/schema"
 )
 
-type Verifier struct {
-	verifier       *verification.CredentialVerifier
+type Validator struct {
+	validator      *validation.CredentialValidator
 	didResolver    resolution.Resolver
 	schemaResolver schema.Resolution
 }
 
-// NewCredentialVerifier creates a new credential verifier which executes both signature and static verification checks.
+// NewCredentialValidator creates a new credential validator which executes both signature and static verification checks.
 // In the future the set of verification checks will be configurable.
-func NewCredentialVerifier(didResolver resolution.Resolver, schemaResolver schema.Resolution) (*Verifier, error) {
+func NewCredentialValidator(didResolver resolution.Resolver, schemaResolver schema.Resolution) (*Validator, error) {
 	if didResolver == nil {
 		return nil, errors.New("didResolver cannot be nil")
 	}
@@ -34,13 +35,13 @@ func NewCredentialVerifier(didResolver resolution.Resolver, schemaResolver schem
 		return nil, errors.New("schemaResolver cannot be nil")
 	}
 	// TODO(gabe): consider making this configurable
-	verifiers := verification.GetKnownVerifiers()
-	verifier, err := verification.NewCredentialVerifier(verifiers)
+	validators := validation.GetKnownVerifiers()
+	validator, err := validation.NewCredentialValidator(validators)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to create static credential verifier")
+		return nil, errors.Wrap(err, "failed to create static credential validator")
 	}
-	return &Verifier{
-		verifier:       verifier,
+	return &Validator{
+		validator:      validator,
 		didResolver:    didResolver,
 		schemaResolver: schemaResolver,
 	}, nil
@@ -50,9 +51,9 @@ func NewCredentialVerifier(didResolver resolution.Resolver, schemaResolver schem
 
 // VerifyJWTCredential first parses and checks the signature on the given JWT credential. Next, it runs
 // a set of static verification checks on the credential as per the credential service's configuration.
-func (v Verifier) VerifyJWTCredential(ctx context.Context, token keyaccess.JWT) error {
+func (v Validator) VerifyJWTCredential(ctx context.Context, token keyaccess.JWT) error {
 	// first, parse the token to see if it contains a valid verifiable credential
-	gotHeaders, _, cred, err := credsdk.ParseVerifiableCredentialFromJWT(token.String())
+	gotHeaders, _, cred, err := integrity.ParseVerifiableCredentialFromJWT(token.String())
 	if err != nil {
 		return sdkutil.LoggingErrorMsg(err, "could not parse credential from JWT")
 	}
@@ -76,10 +77,10 @@ func (v Verifier) VerifyJWTCredential(ctx context.Context, token keyaccess.JWT)
 		return sdkutil.LoggingError(err)
 	}
 
-	// construct a signature verifier from the verification information
+	// construct a signature validator from the verification information
 	verifier, err := keyaccess.NewJWKKeyAccessVerifier(issuerDID, jwtKID, pubKey)
 	if err != nil {
-		return sdkutil.LoggingErrorMsg(err, "could not create verifier")
+		return sdkutil.LoggingErrorMsg(err, "could not create validator")
 	}
 
 	// verify the signature on the credential
@@ -87,12 +88,12 @@ func (v Verifier) VerifyJWTCredential(ctx context.Context, token keyaccess.JWT)
 		return sdkutil.LoggingErrorMsg(err, "could not verify credential's signature")
 	}
 
-	return v.staticVerificationChecks(ctx, *cred)
+	return v.staticValidationChecks(ctx, *cred)
 }
 
 // VerifyDataIntegrityCredential first checks the signature on the given data integrity credential. Next, it runs
 // a set of static verification checks on the credential as per the credential service's configuration.
-func (v Verifier) VerifyDataIntegrityCredential(ctx context.Context, credential credsdk.VerifiableCredential) error {
+func (v Validator) VerifyDataIntegrityCredential(ctx context.Context, credential credsdk.VerifiableCredential) error {
 	// resolve the issuer's key material
 	issuer, ok := credential.Issuer.(string)
 	if !ok {
@@ -113,10 +114,10 @@ func (v Verifier) VerifyDataIntegrityCredential(ctx context.Context, credential
 		return sdkutil.LoggingError(err)
 	}
 
-	// construct a signature verifier from the verification information
+	// construct a signature validator from the verification information
 	verifier, err := keyaccess.NewDataIntegrityKeyAccess(issuer, verificationMethod, pubKey)
 	if err != nil {
-		errMsg := fmt.Sprintf("could not create verifier for kid %s", verificationMethod)
+		errMsg := fmt.Sprintf("could not create validator for kid %s", verificationMethod)
 		return sdkutil.LoggingErrorMsg(err, errMsg)
 	}
 
@@ -125,7 +126,7 @@ func (v Verifier) VerifyDataIntegrityCredential(ctx context.Context, credential
 		return sdkutil.LoggingErrorMsg(err, "could not verify the credential's signature")
 	}
 
-	return v.staticVerificationChecks(ctx, credential)
+	return v.staticValidationChecks(ctx, credential)
 }
 
 func getKeyFromProof(proof crypto.Proof, key string) (any, error) {
@@ -140,7 +141,7 @@ func getKeyFromProof(proof crypto.Proof, key string) (any, error) {
 	return proofMap[key], nil
 }
 
-func (v Verifier) VerifyJWT(ctx context.Context, did string, token keyaccess.JWT) error {
+func (v Validator) VerifyJWT(ctx context.Context, did string, token keyaccess.JWT) error {
 	// parse headers
 	headers, err := keyaccess.GetJWTHeaders([]byte(token))
 	if err != nil {
@@ -161,10 +162,10 @@ func (v Verifier) VerifyJWT(ctx context.Context, did string, token keyaccess.JWT
 		return sdkutil.LoggingError(err)
 	}
 
-	// construct a signature verifier from the verification information
+	// construct a signature validator from the verification information
 	verifier, err := keyaccess.NewJWKKeyAccessVerifier(did, kid, pubKey)
 	if err != nil {
-		return sdkutil.LoggingErrorMsgf(err, "could not create verifier for kid %s", kid)
+		return sdkutil.LoggingErrorMsgf(err, "could not create validator for kid %s", kid)
 	}
 
 	// verify the signature on the credential
@@ -175,11 +176,11 @@ func (v Verifier) VerifyJWT(ctx context.Context, did string, token keyaccess.JWT
 	return nil
 }
 
-// staticVerificationChecks runs a set of static verification checks on the credential as per the credential
+// staticValidationChecks runs a set of static validation checks on the credential as per the credential
 // service's configuration, such as checking the credential's schema, expiration, and object validity.
-func (v Verifier) staticVerificationChecks(ctx context.Context, credential credsdk.VerifiableCredential) error {
+func (v Validator) staticValidationChecks(ctx context.Context, credential credsdk.VerifiableCredential) error {
 	// if the credential has a schema, resolve it before it is to be used in verification
-	var verificationOpts []verification.Option
+	var validationOpts []validation.Option
 	if credential.CredentialSchema != nil {
 		schemaID := credential.CredentialSchema.ID
 		resolvedSchema, _, err := v.schemaResolver.Resolve(ctx, schemaID)
@@ -190,12 +191,12 @@ func (v Verifier) staticVerificationChecks(ctx context.Context, credential creds
 		if err != nil {
 			return errors.Wrapf(err, "for credential<%s> failed to marshal schema: %s", credential.ID, schemaID)
 		}
-		verificationOpts = append(verificationOpts, verification.WithSchema(string(schemaBytes)))
+		validationOpts = append(validationOpts, validation.WithSchema(string(schemaBytes)))
 	}
 
 	// run the configured static checks on the credential
-	if err := v.verifier.VerifyCredential(credential, verificationOpts...); err != nil {
-		return sdkutil.LoggingErrorMsg(err, "static credential verification failed")
+	if err := v.validator.ValidateCredential(credential, validationOpts...); err != nil {
+		return sdkutil.LoggingErrorMsg(err, "static credential validation failed")
 	}
 
 	return nil
diff --git a/internal/keyaccess/jwt.go b/internal/keyaccess/jwt.go
index dc13d7b..689add4 100644
--- a/internal/keyaccess/jwt.go
+++ b/internal/keyaccess/jwt.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 
 	"github.com/TBD54566975/ssi-sdk/credential"
+	"github.com/TBD54566975/ssi-sdk/credential/integrity"
 	"github.com/TBD54566975/ssi-sdk/crypto/jwx"
 	"github.com/TBD54566975/ssi-sdk/did/resolution"
 	"github.com/goccy/go-json"
@@ -122,7 +123,7 @@ func (ka JWKKeyAccess) SignVerifiableCredential(cred credential.VerifiableCreden
 		return nil, errors.New("cannot sign invalid credential")
 	}
 
-	tokenBytes, err := credential.SignVerifiableCredentialJWT(*ka.Signer, cred)
+	tokenBytes, err := integrity.SignVerifiableCredentialJWT(*ka.Signer, cred)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not sign cred")
 	}
@@ -133,7 +134,7 @@ func (ka JWKKeyAccess) VerifyVerifiableCredential(token JWT) (*credential.Verifi
 	if token == "" {
 		return nil, errors.New("token cannot be empty")
 	}
-	_, _, verifiableCredential, err := credential.VerifyVerifiableCredentialJWT(*ka.Verifier, token.String())
+	_, _, verifiableCredential, err := integrity.VerifyVerifiableCredentialJWT(*ka.Verifier, token.String())
 	return verifiableCredential, err
 }
 
@@ -144,7 +145,7 @@ func (ka JWKKeyAccess) SignVerifiablePresentation(audience string, presentation
 	if err := presentation.IsValid(); err != nil {
 		return nil, errors.New("cannot sign invalid presentation")
 	}
-	tokenBytes, err := credential.SignVerifiablePresentationJWT(*ka.Signer, credential.JWTVVPParameters{Audience: []string{audience}}, 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")
 	}
@@ -155,7 +156,7 @@ func (ka JWKKeyAccess) VerifyVerifiablePresentation(ctx context.Context, resolve
 	if token == "" {
 		return nil, errors.New("token cannot be empty")
 	}
-	_, _, presentation, err := credential.VerifyVerifiablePresentationJWT(ctx, *ka.Verifier, resolver, token.String())
+	_, _, presentation, err := integrity.VerifyVerifiablePresentationJWT(ctx, *ka.Verifier, resolver, token.String())
 	return presentation, err
 }
 
diff --git a/pkg/server/router/presentation.go b/pkg/server/router/presentation.go
index 07ea616..85219eb 100644
--- a/pkg/server/router/presentation.go
+++ b/pkg/server/router/presentation.go
@@ -5,14 +5,15 @@ import (
 	"net/http"
 	"net/url"
 
-	"github.com/TBD54566975/ssi-sdk/credential"
 	"github.com/TBD54566975/ssi-sdk/credential/exchange"
+	"github.com/TBD54566975/ssi-sdk/credential/integrity"
 	"github.com/gin-gonic/gin"
 	"github.com/goccy/go-json"
 	"github.com/pkg/errors"
-	"github.com/tbd54566975/ssi-service/pkg/server/pagination"
 	"go.einride.tech/aip/filtering"
 
+	"github.com/tbd54566975/ssi-service/pkg/server/pagination"
+
 	credint "github.com/tbd54566975/ssi-service/internal/credential"
 	"github.com/tbd54566975/ssi-service/internal/keyaccess"
 	"github.com/tbd54566975/ssi-service/pkg/server/framework"
@@ -227,7 +228,7 @@ type CreateSubmissionRequest struct {
 }
 
 func (r CreateSubmissionRequest) toServiceRequest() (*model.CreateSubmissionRequest, error) {
-	_, _, vp, err := credential.ParseVerifiablePresentationFromJWT(r.SubmissionJWT.String())
+	_, _, vp, err := integrity.ParseVerifiablePresentationFromJWT(r.SubmissionJWT.String())
 	if err != nil {
 		return nil, errors.Wrap(err, "parsing presentation from jwt")
 	}
diff --git a/pkg/service/credential/service.go b/pkg/service/credential/service.go
index d28fa27..33313eb 100644
--- a/pkg/service/credential/service.go
+++ b/pkg/service/credential/service.go
@@ -13,6 +13,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
+
 	"github.com/tbd54566975/ssi-service/config"
 	credint "github.com/tbd54566975/ssi-service/internal/credential"
 	"github.com/tbd54566975/ssi-service/internal/keyaccess"
@@ -26,7 +27,7 @@ import (
 type Service struct {
 	storage  *Storage
 	config   config.CredentialServiceConfig
-	verifier *credint.Verifier
+	verifier *credint.Validator
 
 	// external dependencies
 	keyStore *keystore.Service
@@ -69,7 +70,7 @@ func NewCredentialService(config config.CredentialServiceConfig, s storage.Servi
 	if err != nil {
 		return nil, sdkutil.LoggingErrorMsg(err, "could not instantiate storage for the credential service")
 	}
-	verifier, err := credint.NewCredentialVerifier(didResolver, schema)
+	verifier, err := credint.NewCredentialValidator(didResolver, schema)
 	if err != nil {
 		return nil, sdkutil.LoggingErrorMsg(err, "could not instantiate verifier for the credential service")
 	}
diff --git a/pkg/service/credential/storage.go b/pkg/service/credential/storage.go
index 8749887..f3450fb 100644
--- a/pkg/service/credential/storage.go
+++ b/pkg/service/credential/storage.go
@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/TBD54566975/ssi-sdk/credential"
+	"github.com/TBD54566975/ssi-sdk/credential/integrity"
 	statussdk "github.com/TBD54566975/ssi-sdk/credential/status"
 	sdkutil "github.com/TBD54566975/ssi-sdk/util"
 	"github.com/goccy/go-json"
@@ -283,7 +284,7 @@ func buildStoredCredential(request StoreCredentialRequest) (*StoredCredential, e
 	// assume we have a Data Integrity credential
 	cred := request.Credential
 	if request.HasJWTCredential() {
-		_, _, parsedCred, err := credential.ParseVerifiableCredentialFromJWT(request.CredentialJWT.String())
+		_, _, parsedCred, err := integrity.ParseVerifiableCredentialFromJWT(request.CredentialJWT.String())
 		if err != nil {
 			return nil, errors.Wrap(err, "could not parse credential from jwt")
 		}
diff --git a/pkg/service/manifest/response.go b/pkg/service/manifest/response.go
index bb0b332..4068332 100644
--- a/pkg/service/manifest/response.go
+++ b/pkg/service/manifest/response.go
@@ -6,9 +6,9 @@ import (
 	"strings"
 	"time"
 
-	credsdk "github.com/TBD54566975/ssi-sdk/credential"
 	"github.com/TBD54566975/ssi-sdk/credential/exchange"
 	"github.com/TBD54566975/ssi-sdk/credential/manifest"
+	"github.com/TBD54566975/ssi-sdk/credential/parsing"
 	errresp "github.com/TBD54566975/ssi-sdk/error"
 	sdkutil "github.com/TBD54566975/ssi-sdk/util"
 	"github.com/goccy/go-json"
@@ -238,7 +238,7 @@ func getCredentialForInputDescriptor(applicationJSON map[string]any, templateInp
 }
 
 func toCredentialJSON(c any) (map[string]any, error) {
-	_, _, genericCredential, err := credsdk.ToCredential(c)
+	_, _, genericCredential, err := parsing.ToCredential(c)
 	if err != nil {
 		return nil, errors.Wrapf(err, "converting credential to json")
 	}
diff --git a/pkg/service/presentation/service.go b/pkg/service/presentation/service.go
index 35e0690..b791f21 100644
--- a/pkg/service/presentation/service.go
+++ b/pkg/service/presentation/service.go
@@ -4,13 +4,14 @@ import (
 	"context"
 	"fmt"
 
-	credsdk "github.com/TBD54566975/ssi-sdk/credential"
 	"github.com/TBD54566975/ssi-sdk/credential/exchange"
+	"github.com/TBD54566975/ssi-sdk/credential/integrity"
 	"github.com/TBD54566975/ssi-sdk/did/resolution"
 	sdkutil "github.com/TBD54566975/ssi-sdk/util"
 	"github.com/lestrrat-go/jwx/jws"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
+
 	"github.com/tbd54566975/ssi-service/config"
 	"github.com/tbd54566975/ssi-service/internal/credential"
 	didint "github.com/tbd54566975/ssi-service/internal/did"
@@ -36,7 +37,7 @@ type Service struct {
 	config     config.PresentationServiceConfig
 	resolver   resolution.Resolver
 	schema     *schema.Service
-	verifier   *credential.Verifier
+	verifier   *credential.Validator
 	reqStorage common.RequestStorage
 }
 
@@ -72,7 +73,7 @@ func NewPresentationService(config config.PresentationServiceConfig, s storage.S
 	if err != nil {
 		return nil, sdkutil.LoggingErrorMsg(err, "could not instantiate storage for the operations")
 	}
-	verifier, err := credential.NewCredentialVerifier(resolver, schema)
+	verifier, err := credential.NewCredentialValidator(resolver, schema)
 	if err != nil {
 		return nil, sdkutil.LoggingErrorMsg(err, "could not instantiate verifier")
 	}
@@ -175,7 +176,7 @@ func (s Service) CreateSubmission(ctx context.Context, request model.CreateSubmi
 		return nil, errors.Wrap(err, "provided value is not a valid presentation submission")
 	}
 
-	headers, _, vp, err := credsdk.ParseVerifiablePresentationFromJWT(request.SubmissionJWT.String())
+	headers, _, vp, err := integrity.ParseVerifiablePresentationFromJWT(request.SubmissionJWT.String())
 	if err != nil {
 		return nil, errors.Wrap(err, "parsing vp from jwt")
 	}
diff --git a/pkg/service/schema/service.go b/pkg/service/schema/service.go
index c170cf7..161d2ab 100644
--- a/pkg/service/schema/service.go
+++ b/pkg/service/schema/service.go
@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/TBD54566975/ssi-sdk/credential"
+	"github.com/TBD54566975/ssi-sdk/credential/parsing"
 	"github.com/TBD54566975/ssi-sdk/credential/schema"
 	"github.com/TBD54566975/ssi-sdk/did/resolution"
 	schemalib "github.com/TBD54566975/ssi-sdk/schema"
@@ -256,7 +257,7 @@ func (s Service) Resolve(ctx context.Context, id string) (*schema.JSONSchema, sc
 	case schema.JSONSchema2023Type:
 		return gotSchemaResponse.Schema, schema.JSONSchema2023Type, nil
 	case schema.CredentialSchema2023Type:
-		_, _, cred, err := credential.ToCredential(gotSchemaResponse.CredentialSchema.String())
+		_, _, cred, err := parsing.ToCredential(gotSchemaResponse.CredentialSchema.String())
 		if err != nil {
 			return nil, "", sdkutil.LoggingErrorMsg(err, "converting credential schema from jwt to credential map")
 		}
diff --git a/pkg/storage/storage.go b/pkg/storage/storage.go
index 6dbabb6..02783dd 100644
--- a/pkg/storage/storage.go
+++ b/pkg/storage/storage.go
@@ -81,7 +81,7 @@ func NewStorage(storageProvider Type, opts ...Option) (ServiceStorage, error) {
 	if impl == nil {
 		return impl, fmt.Errorf("unsupported storage provider: %s", storageProvider)
 	}
-	logrus.Infof("STORAGE OPTS: %+v", opts)
+	logrus.Infof("Storage options: %+v", opts)
 	err := impl.Init(opts...)
 	return impl, err
 }


Test patch:
diff --git a/integration/credential_manifest_integration_test.go b/integration/credential_manifest_integration_test.go
index f135d8a..db1dbcd 100644
--- a/integration/credential_manifest_integration_test.go
+++ b/integration/credential_manifest_integration_test.go
@@ -3,7 +3,7 @@ package integration
 import (
 	"testing"
 
-	credsdk "github.com/TBD54566975/ssi-sdk/credential"
+	"github.com/TBD54566975/ssi-sdk/credential/parsing"
 	"github.com/TBD54566975/ssi-sdk/crypto"
 	"github.com/TBD54566975/ssi-sdk/did/key"
 	"github.com/stretchr/testify/assert"
@@ -370,7 +370,7 @@ func TestSubmitAndReviewApplicationIntegration(t *testing.T) {
 	vc, err := getJSONElement(reviewApplicationOutput, "$.verifiableCredentials[0]")
 	assert.NoError(t, err)
 	assert.NotEmpty(t, vc)
-	_, _, typedVC, err := credsdk.ToCredential(vc)
+	_, _, typedVC, err := parsing.ToCredential(vc)
 	assert.NoError(t, err)
 	assert.Equal(t, "Mister", typedVC.CredentialSubject["givenName"])
 	assert.Equal(t, "Tee", typedVC.CredentialSubject["familyName"])
diff --git a/pkg/server/server_credential_test.go b/pkg/server/server_credential_test.go
index d5aa3d7..ac1802d 100644
--- a/pkg/server/server_credential_test.go
+++ b/pkg/server/server_credential_test.go
@@ -11,6 +11,7 @@ import (
 
 	"github.com/goccy/go-json"
 	"github.com/google/uuid"
+
 	"github.com/tbd54566975/ssi-service/pkg/testutil"
 
 	credsdk "github.com/TBD54566975/ssi-sdk/credential"
@@ -29,23 +30,23 @@ import (
 func TestCredentialAPI(t *testing.T) {
 
 	for _, test := range testutil.TestDatabases {
-		t.Run(test.Name, func(t *testing.T) {
+		t.Run(test.Name, func(tt *testing.T) {
 
-			t.Run("Batch Create Credentials", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Batch Create Credentials", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				issuerDID, err := didService.CreateDIDByMethod(context.Background(), did.CreateDIDRequest{
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				batchCreateCredentialsRequest := router.BatchCreateCredentialsRequest{
 					Requests: []router.CreateCredentialRequest{
@@ -72,7 +73,7 @@ func TestCredentialAPI(t *testing.T) {
 						},
 					},
 				}
-				tt.Run("Returns Many Credentials", func(ttt *testing.T) {
+				ttt.Run("Returns Many Credentials", func(ttt *testing.T) {
 					requestValue := newRequestValue(ttt, batchCreateCredentialsRequest)
 					req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials/batch", requestValue)
 					w := httptest.NewRecorder()
@@ -101,7 +102,7 @@ func TestCredentialAPI(t *testing.T) {
 					assert.NotEmpty(ttt, resp.Credentials[1].Credential.CredentialStatus)
 				})
 
-				tt.Run("Fails with malformed request", func(ttt *testing.T) {
+				ttt.Run("Fails with malformed request", func(ttt *testing.T) {
 					batchCreateCredentialsRequest := batchCreateCredentialsRequest
 					// missing the data field
 					batchCreateCredentialsRequest.Requests = append(batchCreateCredentialsRequest.Requests, router.CreateCredentialRequest{
@@ -120,7 +121,7 @@ func TestCredentialAPI(t *testing.T) {
 					assert.Contains(ttt, w.Body.String(), "invalid batch create credential request")
 				})
 
-				tt.Run("Fails with more than 1000 requests", func(ttt *testing.T) {
+				ttt.Run("Fails with more than 1000 requests", func(ttt *testing.T) {
 					batchCreateCredentialsRequest := batchCreateCredentialsRequest
 					// missing the data field
 					for i := 0; i < 1000; i++ {
@@ -136,21 +137,22 @@ func TestCredentialAPI(t *testing.T) {
 					assert.Contains(ttt, w.Body.String(), "max number of requests is 1000")
 				})
 			})
-			t.Run("Test Create Credential", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+			tt.Run("Test Create Credential", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
+
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				issuerDID, err := didService.CreateDIDByMethod(context.Background(), did.CreateDIDRequest{
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				// missing required field: data
 				badCredRequest := router.CreateCredentialRequest{
@@ -159,13 +161,13 @@ func TestCredentialAPI(t *testing.T) {
 					Subject:   "did:abc:456",
 					Expiry:    time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				badRequestValue := newRequestValue(tt, badCredRequest)
+				badRequestValue := newRequestValue(ttt, badCredRequest)
 				req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", badRequestValue)
 				w := httptest.NewRecorder()
 
 				c := newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.Contains(tt, w.Body.String(), "invalid create credential request")
+				assert.Contains(ttt, w.Body.String(), "invalid create credential request")
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -181,11 +183,11 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				missingIssuerRequestValue := newRequestValue(tt, missingIssuerRequest)
+				missingIssuerRequestValue := newRequestValue(ttt, missingIssuerRequest)
 				req = httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", missingIssuerRequestValue)
 				c = newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.Contains(tt, w.Body.String(), "getting key for signing credential<did:abc:123#key-1>")
+				assert.Contains(ttt, w.Body.String(), "getting key for signing credential<did:abc:123#key-1>")
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -201,41 +203,43 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req = httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c = newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var resp router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&resp)
-				assert.NoError(tt, err)
+				assert.NoError(ttt, err)
 
-				assert.NotEmpty(tt, resp.CredentialJWT)
-				assert.NoError(tt, err)
-				assert.Equal(tt, resp.Credential.Issuer, issuerDID.DID.ID)
+				assert.NotEmpty(ttt, resp.CredentialJWT)
+				println("HEREHERE")
+				println(*resp.CredentialJWT)
+				assert.NoError(ttt, err)
+				assert.Equal(ttt, resp.Credential.Issuer, issuerDID.DID.ID)
 				after, found := strings.CutPrefix(resp.Credential.ID, "https://ssi-service.com/v1/credentials/")
-				assert.True(tt, found)
-				assert.NotPanics(tt, func() {
+				assert.True(ttt, found)
+				assert.NotPanics(ttt, func() {
 					uuid.MustParse(after)
 				})
 			})
 
-			t.Run("Test Create Credential with Schema", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Test Create Credential with Schema", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				issuerDID, err := didService.CreateDIDByMethod(context.Background(), did.CreateDIDRequest{
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				// create a schema
 				simpleSchema := map[string]any{
@@ -260,8 +264,8 @@ func TestCredentialAPI(t *testing.T) {
 					},
 				}
 				createdSchema, err := schemaService.CreateSchema(context.Background(), schema.CreateSchemaRequest{Issuer: "me", Name: "simple schema", Schema: simpleSchema})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, createdSchema)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, createdSchema)
 
 				w := httptest.NewRecorder()
 
@@ -276,16 +280,16 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c := newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var resp router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&resp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, resp.CredentialJWT)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, resp.CredentialJWT)
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -294,17 +298,17 @@ func TestCredentialAPI(t *testing.T) {
 				req = httptest.NewRequest(http.MethodGet, fmt.Sprintf("https://ssi-service.com/v1/credential?schema=%s", createdSchema.ID), nil)
 				c = newRequestContextWithParams(w, req, map[string]string{"schema": createdSchema.ID})
 				credRouter.ListCredentials(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var getCredsResp router.ListCredentialsResponse
 				err = json.NewDecoder(w.Body).Decode(&getCredsResp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, getCredsResp)
-				assert.Len(tt, getCredsResp.Credentials, 1)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, getCredsResp)
+				assert.Len(ttt, getCredsResp.Credentials, 1)
 
-				assert.Equal(tt, resp.ID, getCredsResp.Credentials[0].ID)
-				assert.Equal(tt, resp.Credential.ID, getCredsResp.Credentials[0].Credential.ID)
-				assert.Equal(tt, resp.Credential.CredentialSchema.ID, getCredsResp.Credentials[0].Credential.CredentialSchema.ID)
+				assert.Equal(ttt, resp.ID, getCredsResp.Credentials[0].ID)
+				assert.Equal(ttt, resp.Credential.ID, getCredsResp.Credentials[0].Credential.ID)
+				assert.Equal(ttt, resp.Credential.CredentialSchema.ID, getCredsResp.Credentials[0].Credential.CredentialSchema.ID)
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -321,21 +325,21 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				requestValue = newRequestValue(tt, missingSchemaCred)
+				requestValue = newRequestValue(ttt, missingSchemaCred)
 				req = httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c = newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.Contains(tt, w.Body.String(), "schema not found")
+				assert.Contains(ttt, w.Body.String(), "schema not found")
 			})
 
-			t.Run("Test Get Credential By ID", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Test Get Credential By ID", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				w := httptest.NewRecorder()
 
@@ -343,7 +347,7 @@ func TestCredentialAPI(t *testing.T) {
 				req := httptest.NewRequest(http.MethodGet, "https://ssi-service.com/v1/credentials/bad", nil)
 				c := newRequestContext(w, req)
 				credRouter.GetCredential(c)
-				assert.Contains(tt, w.Body.String(), "cannot get credential without ID parameter")
+				assert.Contains(ttt, w.Body.String(), "cannot get credential without ID parameter")
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -352,7 +356,7 @@ func TestCredentialAPI(t *testing.T) {
 				req = httptest.NewRequest(http.MethodGet, "https://ssi-service.com/v1/credentials/bad", nil)
 				c = newRequestContextWithParams(w, req, map[string]string{"id": "bad"})
 				credRouter.GetCredential(c)
-				assert.Contains(tt, w.Body.String(), "could not get credential with id: bad")
+				assert.Contains(ttt, w.Body.String(), "could not get credential with id: bad")
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -361,8 +365,8 @@ func TestCredentialAPI(t *testing.T) {
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				createCredRequest := router.CreateCredentialRequest{
 					Issuer:    issuerDID.DID.ID,
@@ -374,18 +378,18 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req = httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c = newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				// We expect a JWT credential
 				var resp router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&resp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, resp.Credential)
-				assert.NotEmpty(tt, resp.CredentialJWT)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, resp.Credential)
+				assert.NotEmpty(ttt, resp.CredentialJWT)
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -394,24 +398,24 @@ func TestCredentialAPI(t *testing.T) {
 				req = httptest.NewRequest(http.MethodGet, resp.Credential.ID, nil)
 				c = newRequestContextWithParams(w, req, map[string]string{"id": idFromURI(resp.Credential.ID)})
 				credRouter.GetCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var getCredResp router.GetCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&getCredResp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, getCredResp)
-				assert.NotEmpty(tt, getCredResp.CredentialJWT)
-				assert.Equal(tt, resp.Credential.ID, getCredResp.Credential.ID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, getCredResp)
+				assert.NotEmpty(ttt, getCredResp.CredentialJWT)
+				assert.Equal(ttt, resp.Credential.ID, getCredResp.Credential.ID)
 			})
 
-			t.Run("Test Get Credential By Schema", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Test Get Credential By Schema", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				w := httptest.NewRecorder()
 
@@ -419,8 +423,8 @@ func TestCredentialAPI(t *testing.T) {
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				// create a schema
 				simpleSchema := map[string]any{
@@ -445,8 +449,8 @@ func TestCredentialAPI(t *testing.T) {
 					},
 				}
 				createdSchema, err := schemaService.CreateSchema(context.Background(), schema.CreateSchemaRequest{Issuer: "me", Name: "simple schema", Schema: simpleSchema})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, createdSchema)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, createdSchema)
 
 				createCredRequest := router.CreateCredentialRequest{
 					Issuer:    issuerDID.DID.ID,
@@ -459,16 +463,16 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c := newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var resp router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&resp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, resp.CredentialJWT)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, resp.CredentialJWT)
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -477,27 +481,27 @@ func TestCredentialAPI(t *testing.T) {
 				req = httptest.NewRequest(http.MethodGet, fmt.Sprintf("https://ssi-service.com/v1/credential?schema=%s", createdSchema.ID), nil)
 				c = newRequestContext(w, req)
 				credRouter.ListCredentials(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var getCredsResp router.ListCredentialsResponse
 				err = json.NewDecoder(w.Body).Decode(&getCredsResp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, getCredsResp)
-				assert.Len(tt, getCredsResp.Credentials, 1)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, getCredsResp)
+				assert.Len(ttt, getCredsResp.Credentials, 1)
 
-				assert.Equal(tt, resp.ID, getCredsResp.Credentials[0].ID)
-				assert.Equal(tt, resp.Credential.ID, getCredsResp.Credentials[0].Credential.ID)
-				assert.Equal(tt, resp.Credential.CredentialSchema.ID, getCredsResp.Credentials[0].Credential.CredentialSchema.ID)
+				assert.Equal(ttt, resp.ID, getCredsResp.Credentials[0].ID)
+				assert.Equal(ttt, resp.Credential.ID, getCredsResp.Credentials[0].Credential.ID)
+				assert.Equal(ttt, resp.Credential.CredentialSchema.ID, getCredsResp.Credentials[0].Credential.CredentialSchema.ID)
 			})
 
-			t.Run("Get Credential No Param", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Get Credential No Param", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				w := httptest.NewRecorder()
 
@@ -505,8 +509,8 @@ func TestCredentialAPI(t *testing.T) {
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				createCredRequest := router.CreateCredentialRequest{
 					Issuer:    issuerDID.DID.ID,
@@ -518,16 +522,16 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c := newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var resp router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&resp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, resp.CredentialJWT)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, resp.CredentialJWT)
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -536,26 +540,26 @@ func TestCredentialAPI(t *testing.T) {
 				req = httptest.NewRequest(http.MethodGet, "https://ssi-service.com/v1/credentials", nil)
 				c = newRequestContext(w, req)
 				credRouter.ListCredentials(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var getCredsResp router.ListCredentialsResponse
 				err = json.NewDecoder(w.Body).Decode(&getCredsResp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, getCredsResp)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, getCredsResp)
 
-				assert.Len(tt, getCredsResp.Credentials, 1)
-				assert.Equal(tt, resp.ID, getCredsResp.Credentials[0].ID)
-				assert.Equal(tt, resp.Credential.ID, getCredsResp.Credentials[0].Credential.ID)
+				assert.Len(ttt, getCredsResp.Credentials, 1)
+				assert.Equal(ttt, resp.ID, getCredsResp.Credentials[0].ID)
+				assert.Equal(ttt, resp.Credential.ID, getCredsResp.Credentials[0].Credential.ID)
 			})
 
-			t.Run("Test Get Credential By Issuer", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Test Get Credential By Issuer", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				w := httptest.NewRecorder()
 
@@ -563,8 +567,8 @@ func TestCredentialAPI(t *testing.T) {
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				createCredRequest := router.CreateCredentialRequest{
 					Issuer:    issuerDID.DID.ID,
@@ -576,16 +580,16 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c := newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var resp router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&resp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, resp.CredentialJWT)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, resp.CredentialJWT)
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -594,26 +598,26 @@ func TestCredentialAPI(t *testing.T) {
 				req = httptest.NewRequest(http.MethodGet, fmt.Sprintf("https://ssi-service.com/v1/credential?issuer=%s", issuerDID.DID.ID), nil)
 				c = newRequestContext(w, req)
 				credRouter.ListCredentials(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var getCredsResp router.ListCredentialsResponse
 				err = json.NewDecoder(w.Body).Decode(&getCredsResp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, getCredsResp)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, getCredsResp)
 
-				assert.Len(tt, getCredsResp.Credentials, 1)
-				assert.Equal(tt, resp.ID, getCredsResp.Credentials[0].ID)
-				assert.Equal(tt, resp.Credential.ID, getCredsResp.Credentials[0].Credential.ID)
+				assert.Len(ttt, getCredsResp.Credentials, 1)
+				assert.Equal(ttt, resp.ID, getCredsResp.Credentials[0].ID)
+				assert.Equal(ttt, resp.Credential.ID, getCredsResp.Credentials[0].Credential.ID)
 			})
 
-			t.Run("Test Get Credential By Subject", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Test Get Credential By Subject", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				w := httptest.NewRecorder()
 
@@ -621,8 +625,8 @@ func TestCredentialAPI(t *testing.T) {
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				subjectID := "did:abc:456"
 				createCredRequest := router.CreateCredentialRequest{
@@ -635,16 +639,16 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c := newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var createCredentialResponse router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&createCredentialResponse)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, createCredentialResponse.CredentialJWT)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, createCredentialResponse.CredentialJWT)
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -653,34 +657,34 @@ func TestCredentialAPI(t *testing.T) {
 				req = httptest.NewRequest(http.MethodGet, fmt.Sprintf("https://ssi-service.com/v1/credential?subject=%s", subjectID), nil)
 				c = newRequestContext(w, req)
 				credRouter.ListCredentials(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var listCredentialsResponse router.ListCredentialsResponse
 				err = json.NewDecoder(w.Body).Decode(&listCredentialsResponse)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, listCredentialsResponse)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, listCredentialsResponse)
 
-				assert.Len(tt, listCredentialsResponse.Credentials, 1)
-				assert.Equal(tt, createCredentialResponse.ID, listCredentialsResponse.Credentials[0].ID)
-				assert.Equal(tt, createCredentialResponse.Credential.ID, listCredentialsResponse.Credentials[0].Credential.ID)
-				assert.Equal(tt, createCredentialResponse.Credential.CredentialSubject[credsdk.VerifiableCredentialIDProperty], listCredentialsResponse.Credentials[0].Credential.CredentialSubject[credsdk.VerifiableCredentialIDProperty])
+				assert.Len(ttt, listCredentialsResponse.Credentials, 1)
+				assert.Equal(ttt, createCredentialResponse.ID, listCredentialsResponse.Credentials[0].ID)
+				assert.Equal(ttt, createCredentialResponse.Credential.ID, listCredentialsResponse.Credentials[0].Credential.ID)
+				assert.Equal(ttt, createCredentialResponse.Credential.CredentialSubject[credsdk.VerifiableCredentialIDProperty], listCredentialsResponse.Credentials[0].Credential.CredentialSubject[credsdk.VerifiableCredentialIDProperty])
 			})
 
-			t.Run("Test Delete Credential", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Test Delete Credential", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				issuerDID, err := didService.CreateDIDByMethod(context.Background(), did.CreateDIDRequest{
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				createCredRequest := router.CreateCredentialRequest{
 					Issuer:    issuerDID.DID.ID,
@@ -692,16 +696,16 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				w := httptest.NewRecorder()
 				c := newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var resp router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&resp)
-				assert.NoError(tt, err)
+				assert.NoError(ttt, err)
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -711,13 +715,13 @@ func TestCredentialAPI(t *testing.T) {
 				req = httptest.NewRequest(http.MethodGet, credID, nil)
 				c = newRequestContextWithParams(w, req, map[string]string{"id": idFromURI(credID)})
 				credRouter.GetCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var getCredResp router.GetCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&getCredResp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, getCredResp)
-				assert.Equal(tt, credID, getCredResp.Credential.ID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, getCredResp)
+				assert.Equal(ttt, credID, getCredResp.Credential.ID)
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -726,7 +730,7 @@ func TestCredentialAPI(t *testing.T) {
 				req = httptest.NewRequest(http.MethodDelete, fmt.Sprintf("https://ssi-service.com/v1/credentials/%s", credID), nil)
 				c = newRequestContextWithParams(w, req, map[string]string{"id": credID})
 				credRouter.DeleteCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
@@ -735,24 +739,24 @@ func TestCredentialAPI(t *testing.T) {
 				req = httptest.NewRequest(http.MethodGet, fmt.Sprintf("https://ssi-service.com/v1/credentials/%s", credID), nil)
 				c = newRequestContextWithParams(w, req, map[string]string{"id": credID})
 				credRouter.GetCredential(c)
-				assert.Contains(tt, w.Body.String(), fmt.Sprintf("could not get credential with id: %s", credID))
+				assert.Contains(ttt, w.Body.String(), fmt.Sprintf("could not get credential with id: %s", credID))
 			})
 
-			t.Run("Test Verifying a Credential", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Test Verifying a Credential", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				issuerDID, err := didService.CreateDIDByMethod(context.Background(), did.CreateDIDRequest{
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				// good request
 				createCredRequest := router.CreateCredentialRequest{
@@ -765,73 +769,73 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				w := httptest.NewRecorder()
 				c := newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var resp router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&resp)
-				assert.NoError(tt, err)
+				assert.NoError(ttt, err)
 
-				assert.NotEmpty(tt, resp.CredentialJWT)
-				assert.NoError(tt, err)
-				assert.Equal(tt, resp.Credential.Issuer, issuerDID.DID.ID)
+				assert.NotEmpty(ttt, resp.CredentialJWT)
+				assert.NoError(ttt, err)
+				assert.Equal(ttt, resp.Credential.Issuer, issuerDID.DID.ID)
 
 				// reset the http recorder
 				w = httptest.NewRecorder()
 
 				// verify the credential
-				requestValue = newRequestValue(tt, router.VerifyCredentialRequest{CredentialJWT: resp.CredentialJWT})
+				requestValue = newRequestValue(ttt, router.VerifyCredentialRequest{CredentialJWT: resp.CredentialJWT})
 				req = httptest.NewRequest(http.MethodPost, "https://ssi-service.com/v1/credentials/verification", requestValue)
 				c = newRequestContext(w, req)
 				credRouter.VerifyCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var verifyResp router.VerifyCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&verifyResp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, verifyResp)
-				assert.True(tt, verifyResp.Verified)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, verifyResp)
+				assert.True(ttt, verifyResp.Verified)
 
 				// bad credential
-				requestValue = newRequestValue(tt, router.VerifyCredentialRequest{CredentialJWT: keyaccess.JWTPtr("bad")})
+				requestValue = newRequestValue(ttt, router.VerifyCredentialRequest{CredentialJWT: keyaccess.JWTPtr("bad")})
 				req = httptest.NewRequest(http.MethodPost, "https://ssi-service.com/v1/credentials/verification", requestValue)
 				c = newRequestContext(w, req)
 				credRouter.VerifyCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				err = json.NewDecoder(w.Body).Decode(&verifyResp)
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, verifyResp)
-				assert.False(tt, verifyResp.Verified)
-				assert.Contains(tt, verifyResp.Reason, "could not parse credential from JWT")
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, verifyResp)
+				assert.False(ttt, verifyResp.Verified)
+				assert.Contains(ttt, verifyResp.Reason, "could not parse credential from JWT")
 			})
 
-			t.Run("Test Create Revocable Credential", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Test Create Revocable Credential", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				issuerDID, err := didService.CreateDIDByMethod(context.Background(), did.CreateDIDRequest{
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				issuerDIDTwo, err := didService.CreateDIDByMethod(context.Background(), did.CreateDIDRequest{
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDIDTwo)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDIDTwo)
 
 				w := httptest.NewRecorder()
 
@@ -846,20 +850,20 @@ func TestCredentialAPI(t *testing.T) {
 					},
 					Expiry: time.Now().Add(24 * time.Hour).Format(time.RFC3339),
 				}
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c := newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var resp router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&resp)
-				assert.NoError(tt, err)
+				assert.NoError(ttt, err)
 
-				assert.NotEmpty(tt, resp.CredentialJWT)
-				assert.NoError(tt, err)
-				assert.Empty(tt, resp.Credential.CredentialStatus)
-				assert.Equal(tt, resp.Credential.Issuer, issuerDID.DID.ID)
+				assert.NotEmpty(ttt, resp.CredentialJWT)
+				assert.NoError(ttt, err)
+				assert.Empty(ttt, resp.Credential.CredentialStatus)
+				assert.Equal(ttt, resp.Credential.Issuer, issuerDID.DID.ID)
 
 				// good revocable request One
 				createRevocableCredRequestOne := router.CreateCredentialRequest{
@@ -874,24 +878,24 @@ func TestCredentialAPI(t *testing.T) {
 					Revocable: true,
 				}
 
-				requestValue = newRequestValue(tt, createRevocableCredRequestOne)
+				requestValue = newRequestValue(ttt, createRevocableCredRequestOne)
 				req = httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c = newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var revocableRespOne router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&revocableRespOne)
-				assert.NoError(tt, err)
+				assert.NoError(ttt, err)
 
-				assert.NotEmpty(tt, revocableRespOne.CredentialJWT)
-				assert.NotEmpty(tt, revocableRespOne.Credential.CredentialStatus)
-				assert.Equal(tt, revocableRespOne.Credential.Issuer, issuerDID.DID.ID)
+				assert.NotEmpty(ttt, revocableRespOne.CredentialJWT)
+				assert.NotEmpty(ttt, revocableRespOne.Credential.CredentialStatus)
+				assert.Equal(ttt, revocableRespOne.Credential.Issuer, issuerDID.DID.ID)
 
 				credStatusMap, ok := revocableRespOne.Credential.CredentialStatus.(map[string]any)
-				assert.True(tt, ok)
+				assert.True(ttt, ok)
 
-				assert.NotEmpty(tt, credStatusMap["statusListIndex"])
+				assert.NotEmpty(ttt, credStatusMap["statusListIndex"])
 
 				// good revocable request Two
 				createRevocableCredRequestTwo := router.CreateCredentialRequest{
@@ -906,24 +910,24 @@ func TestCredentialAPI(t *testing.T) {
 					Revocable: true,
 				}
 
-				requestValue = newRequestValue(tt, createRevocableCredRequestTwo)
+				requestValue = newRequestValue(ttt, createRevocableCredRequestTwo)
 				req = httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c = newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var revocableRespTwo router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&revocableRespTwo)
-				assert.NoError(tt, err)
+				assert.NoError(ttt, err)
 
-				assert.NotEmpty(tt, revocableRespTwo.CredentialJWT)
-				assert.NotEmpty(tt, revocableRespTwo.Credential.CredentialStatus)
-				assert.Equal(tt, revocableRespTwo.Credential.Issuer, issuerDID.DID.ID)
+				assert.NotEmpty(ttt, revocableRespTwo.CredentialJWT)
+				assert.NotEmpty(ttt, revocableRespTwo.Credential.CredentialStatus)
+				assert.Equal(ttt, revocableRespTwo.Credential.Issuer, issuerDID.DID.ID)
 
 				credStatusMap, ok = revocableRespTwo.Credential.CredentialStatus.(map[string]any)
-				assert.True(tt, ok)
+				assert.True(ttt, ok)
 
-				assert.NotEmpty(tt, credStatusMap["statusListIndex"])
+				assert.NotEmpty(ttt, credStatusMap["statusListIndex"])
 
 				// good revocable request Three
 				createRevocableCredRequestThree := router.CreateCredentialRequest{
@@ -938,24 +942,24 @@ func TestCredentialAPI(t *testing.T) {
 					Revocable: true,
 				}
 
-				requestValue = newRequestValue(tt, createRevocableCredRequestThree)
+				requestValue = newRequestValue(ttt, createRevocableCredRequestThree)
 				req = httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c = newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var revocableRespThree router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&revocableRespThree)
-				assert.NoError(tt, err)
+				assert.NoError(ttt, err)
 
-				assert.NotEmpty(tt, revocableRespThree.CredentialJWT)
-				assert.NotEmpty(tt, revocableRespThree.Credential.CredentialStatus)
-				assert.Equal(tt, revocableRespThree.Credential.Issuer, issuerDID.DID.ID)
+				assert.NotEmpty(ttt, revocableRespThree.CredentialJWT)
+				assert.NotEmpty(ttt, revocableRespThree.Credential.CredentialStatus)
+				assert.Equal(ttt, revocableRespThree.Credential.Issuer, issuerDID.DID.ID)
 
 				credStatusMap, ok = revocableRespThree.Credential.CredentialStatus.(map[string]any)
-				assert.True(tt, ok)
+				assert.True(ttt, ok)
 
-				assert.NotEmpty(tt, credStatusMap["statusListIndex"])
+				assert.NotEmpty(ttt, credStatusMap["statusListIndex"])
 
 				// good revocable request Four (different issuer / schema)
 				createRevocableCredRequestFour := router.CreateCredentialRequest{
@@ -970,41 +974,41 @@ func TestCredentialAPI(t *testing.T) {
 					Revocable: true,
 				}
 
-				requestValue = newRequestValue(tt, createRevocableCredRequestFour)
+				requestValue = newRequestValue(ttt, createRevocableCredRequestFour)
 				req = httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c = newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var revocableRespFour router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&revocableRespFour)
-				assert.NoError(tt, err)
+				assert.NoError(ttt, err)
 
-				assert.NotEmpty(tt, revocableRespFour.CredentialJWT)
-				assert.NotEmpty(tt, revocableRespFour.Credential.CredentialStatus)
-				assert.Equal(tt, revocableRespFour.Credential.Issuer, issuerDIDTwo.DID.ID)
+				assert.NotEmpty(ttt, revocableRespFour.CredentialJWT)
+				assert.NotEmpty(ttt, revocableRespFour.Credential.CredentialStatus)
+				assert.Equal(ttt, revocableRespFour.Credential.Issuer, issuerDIDTwo.DID.ID)
 
 				credStatusMap, ok = revocableRespFour.Credential.CredentialStatus.(map[string]any)
-				assert.True(tt, ok)
+				assert.True(ttt, ok)
 
-				assert.NotEmpty(tt, credStatusMap["statusListIndex"])
+				assert.NotEmpty(ttt, credStatusMap["statusListIndex"])
 			})
 
-			t.Run("Test Get Revoked Status Of Credential", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Test Get Revoked Status Of Credential", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				issuerDID, err := didService.CreateDIDByMethod(context.Background(), did.CreateDIDRequest{
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				w := httptest.NewRecorder()
 
@@ -1021,66 +1025,66 @@ func TestCredentialAPI(t *testing.T) {
 					Revocable: true,
 				}
 
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c := newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var resp router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&resp)
-				assert.NoError(tt, err)
+				assert.NoError(ttt, err)
 
-				assert.NotEmpty(tt, resp.CredentialJWT)
-				assert.NotEmpty(tt, resp.Credential.CredentialStatus)
-				assert.Equal(tt, resp.Credential.Issuer, issuerDID.DID.ID)
+				assert.NotEmpty(ttt, resp.CredentialJWT)
+				assert.NotEmpty(ttt, resp.Credential.CredentialStatus)
+				assert.Equal(ttt, resp.Credential.Issuer, issuerDID.DID.ID)
 
 				credStatusMap, ok := resp.Credential.CredentialStatus.(map[string]any)
-				assert.True(tt, ok)
+				assert.True(ttt, ok)
 
-				assert.NotEmpty(tt, credStatusMap["statusListIndex"])
+				assert.NotEmpty(ttt, credStatusMap["statusListIndex"])
 
 				req = httptest.NewRequest(http.MethodGet, fmt.Sprintf("%s/status", resp.Credential.ID), nil)
 				c = newRequestContextWithParams(w, req, map[string]string{"id": idFromURI(resp.Credential.ID)})
 				credRouter.GetCredentialStatus(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var credStatusResponse = router.GetCredentialStatusResponse{}
 				err = json.NewDecoder(w.Body).Decode(&credStatusResponse)
-				assert.NoError(tt, err)
-				assert.Equal(tt, false, credStatusResponse.Revoked)
+				assert.NoError(ttt, err)
+				assert.Equal(ttt, false, credStatusResponse.Revoked)
 
 				// good request number one
 				updateCredStatusRequest := router.UpdateCredentialStatusRequest{Revoked: true}
 
-				requestValue = newRequestValue(tt, updateCredStatusRequest)
+				requestValue = newRequestValue(ttt, updateCredStatusRequest)
 				req = httptest.NewRequest(http.MethodPut, fmt.Sprintf("%s/status", resp.Credential.ID), requestValue)
 				c = newRequestContextWithParams(w, req, map[string]string{"id": idFromURI(resp.Credential.ID)})
 				credRouter.UpdateCredentialStatus(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var credStatusUpdateResponse = router.UpdateCredentialStatusResponse{}
 				err = json.NewDecoder(w.Body).Decode(&credStatusUpdateResponse)
-				assert.NoError(tt, err)
-				assert.Equal(tt, true, credStatusUpdateResponse.Revoked)
+				assert.NoError(ttt, err)
+				assert.Equal(ttt, true, credStatusUpdateResponse.Revoked)
 
 			})
 
-			t.Run("Test Get Status List Credential", func(tt *testing.T) {
-				db := test.ServiceStorage(t)
-				require.NotEmpty(tt, db)
+			tt.Run("Test Get Status List Credential", func(ttt *testing.T) {
+				db := test.ServiceStorage(ttt)
+				require.NotEmpty(ttt, db)
 
-				keyStoreService, _ := testKeyStoreService(tt, db)
-				didService, _ := testDIDService(tt, db, keyStoreService, nil)
-				schemaService := testSchemaService(tt, db, keyStoreService, didService)
-				credRouter := testCredentialRouter(tt, db, keyStoreService, didService, schemaService)
+				keyStoreService, _ := testKeyStoreService(ttt, db)
+				didService, _ := testDIDService(ttt, db, keyStoreService, nil)
+				schemaService := testSchemaService(ttt, db, keyStoreService, didService)
+				credRouter := testCredentialRouter(ttt, db, keyStoreService, didService, schemaService)
 
 				issuerDID, err := didService.CreateDIDByMethod(context.Background(), did.CreateDIDRequest{
 					Method:  didsdk.KeyMethod,
 					KeyType: crypto.Ed25519,
 				})
-				assert.NoError(tt, err)
-				assert.NotEmpty(tt, issuerDID)
+				assert.NoError(ttt, err)
+				assert.NotEmpty(ttt, issuerDID)
 
 				w := httptest.NewRecorder()
 
@@ -1097,28 +1101,28 @@ func TestCredentialAPI(t *testing.T) {
 					Revocable: true,
 				}
 
-				requestValue := newRequestValue(tt, createCredRequest)
+				requestValue := newRequestValue(ttt, createCredRequest)
 				req := httptest.NewRequest(http.MethodPut, "https://ssi-service.com/v1/credentials", requestValue)
 				c := newRequestContext(w, req)
 				credRouter.CreateCredential(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var resp router.CreateCredentialResponse
 				err = json.NewDecoder(w.Body).Decode(&resp)
-				assert.NoError(tt, err)
+				assert.NoError(ttt, err)
 
-				assert.NotEmpty(tt, resp.CredentialJWT)
-				assert.NotEmpty(tt, resp.Credential.CredentialStatus)
-				assert.Equal(tt, resp.Credential.Issuer, issuerDID.DID.ID)
+				assert.NotEmpty(ttt, resp.CredentialJWT)
+				assert.NotEmpty(ttt, resp.Credential.CredentialStatus)
+				assert.Equal(ttt, resp.Credential.Issuer, issuerDID.DID.ID)
 
 				credStatusMap, ok := resp.Credential.CredentialStatus.(map[string]any)
-				assert.True(tt, ok)
+				assert.True(ttt, ok)
 
-				assert.NotEmpty(tt, credStatusMap["statusListIndex"])
+				assert.NotEmpty(ttt, credStatusMap["statusListIndex"])
 
 				credStatusListID := (credStatusMap["statusListCredential"]).(string)
 
-				assert.NotEmpty(tt, credStatusListID)
+				assert.NotEmpty(ttt, credStatusListID)
 
 				i := strings.LastIndex(credStatusListID, "/")
 				uuidStringUUID := credStatusListID[i+1:]
@@ -1126,15 +1130,15 @@ func TestCredentialAPI(t *testing.T) {
 				req = httptest.NewRequest(http.MethodGet, fmt.Sprintf("https://localhost:8080/%s", credStatusListID), nil)
 				c = newRequestContextWithParams(w, req, map[string]string{"id": uuidStringUUID})
 				credRouter.GetCredentialStatusList(c)
-				assert.True(tt, util.Is2xxResponse(w.Code))
+				assert.True(ttt, util.Is2xxResponse(w.Code))
 
 				var credListResp router.GetCredentialStatusListResponse
 				err = json.NewDecoder(w.Body).Decode(&credListResp)
-				assert.NoError(tt, err)
+				assert.NoError(ttt, err)
 
-				assert.NotEmpty(tt, credListResp.CredentialJWT)
-				assert.Empty(tt, credListResp.Credential.CredentialStatus)
-				assert.Equal(tt, credListResp.Credential.ID, credStatusListID)
+				assert.NotEmpty(ttt, credListResp.CredentialJWT)
+				assert.Empty(ttt, credListResp.Credential.CredentialStatus)
+				assert.Equal(ttt, credListResp.Credential.ID, credStatusListID)
 			})
 		})
 	}
diff --git a/pkg/server/server_manifest_test.go b/pkg/server/server_manifest_test.go
index e7206e6..b880da3 100644
--- a/pkg/server/server_manifest_test.go
+++ b/pkg/server/server_manifest_test.go
@@ -10,6 +10,7 @@ import (
 
 	credsdk "github.com/TBD54566975/ssi-sdk/credential"
 	"github.com/TBD54566975/ssi-sdk/credential/manifest"
+	"github.com/TBD54566975/ssi-sdk/credential/parsing"
 	"github.com/TBD54566975/ssi-sdk/crypto"
 	didsdk "github.com/TBD54566975/ssi-sdk/did"
 	"github.com/TBD54566975/ssi-sdk/did/key"
@@ -450,7 +451,7 @@ func TestManifestAPI(t *testing.T) {
 				assert.NoError(tt, err)
 				assert.Len(tt, appResp.Credentials, 2, "each output_descriptor in the definition should result in a credential")
 
-				_, _, vc, err := credsdk.ToCredential(appResp.Credentials[0])
+				_, _, vc, err := parsing.ToCredential(appResp.Credentials[0])
 				assert.NoError(tt, err)
 				expectedSubject := credsdk.CredentialSubject{
 					"id":        applicantDID.ID,
@@ -463,7 +464,7 @@ func TestManifestAPI(t *testing.T) {
 				assert.Equal(tt, licenseSchema.ID, vc.CredentialSchema.ID)
 				assert.Empty(tt, vc.CredentialStatus)
 
-				_, _, vc2, err := credsdk.ToCredential(appResp.Credentials[1])
+				_, _, vc2, err := parsing.ToCredential(appResp.Credentials[1])
 				assert.NoError(tt, err)
 				expectedSubject = credsdk.CredentialSubject{
 					"id":        applicantDID.ID,
@@ -638,7 +639,7 @@ func TestManifestAPI(t *testing.T) {
 				assert.Len(tt, appResp.Credentials, 2)
 				assert.Empty(tt, appResp.Response.Denial)
 
-				_, _, vc, err := credsdk.ToCredential(appResp.Credentials[0])
+				_, _, vc, err := parsing.ToCredential(appResp.Credentials[0])
 				assert.NoError(tt, err)
 				assert.Equal(tt, credsdk.CredentialSubject{
 					"id":        applicantDID.ID,
diff --git a/pkg/server/server_presentation_test.go b/pkg/server/server_presentation_test.go
index 7a242a6..ef3348f 100644
--- a/pkg/server/server_presentation_test.go
+++ b/pkg/server/server_presentation_test.go
@@ -11,6 +11,7 @@ import (
 
 	"github.com/TBD54566975/ssi-sdk/credential"
 	"github.com/TBD54566975/ssi-sdk/credential/exchange"
+	"github.com/TBD54566975/ssi-sdk/credential/integrity"
 	"github.com/TBD54566975/ssi-sdk/crypto"
 	"github.com/TBD54566975/ssi-sdk/crypto/jwx"
 	didsdk "github.com/TBD54566975/ssi-sdk/did"
@@ -21,6 +22,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
 	"github.com/tbd54566975/ssi-service/pkg/testutil"
 
 	"github.com/tbd54566975/ssi-service/config"
@@ -768,7 +770,7 @@ func createSubmissionRequest(t *testing.T, definitionID, requesterDID string, vc
 	holderSigner jwx.Signer, holderDID key.DIDKey) router.CreateSubmissionRequest {
 	issuerSigner, didKey := getSigner(t)
 	vc.Issuer = didKey.String()
-	vcData, err := credential.SignVerifiableCredentialJWT(issuerSigner, vc)
+	vcData, err := integrity.SignVerifiableCredentialJWT(issuerSigner, vc)
 	require.NoError(t, err)
 	ps := exchange.PresentationSubmission{
 		ID:           uuid.NewString(),
@@ -791,7 +793,7 @@ func createSubmissionRequest(t *testing.T, definitionID, requesterDID string, vc
 		VerifiableCredential:   []any{keyaccess.JWT(vcData)},
 	}
 
-	signed, err := credential.SignVerifiablePresentationJWT(holderSigner, credential.JWTVVPParameters{Audience: []string{requesterDID}}, vp)
+	signed, err := integrity.SignVerifiablePresentationJWT(holderSigner, integrity.JWTVVPParameters{Audience: []string{requesterDID}}, vp)
 	require.NoError(t, err)
 
 	request := router.CreateSubmissionRequest{SubmissionJWT: keyaccess.JWT(signed)}
diff --git a/pkg/server/server_schema_test.go b/pkg/server/server_schema_test.go
index 090d7e3..d466fc4 100644
--- a/pkg/server/server_schema_test.go
+++ b/pkg/server/server_schema_test.go
@@ -7,7 +7,7 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/TBD54566975/ssi-sdk/credential"
+	"github.com/TBD54566975/ssi-sdk/credential/parsing"
 	"github.com/TBD54566975/ssi-sdk/credential/schema"
 	"github.com/TBD54566975/ssi-sdk/crypto"
 	"github.com/goccy/go-json"
@@ -127,7 +127,7 @@ func TestSchemaAPI(t *testing.T) {
 				assert.Equal(tt, schema.CredentialSchema2023Type, resp.Type)
 
 				// decode the schema from the response and verify it
-				_, _, cred, err := credential.ToCredential(resp.CredentialSchema.String())
+				_, _, cred, err := parsing.ToCredential(resp.CredentialSchema.String())
 				assert.NoError(tt, err)
 				credSubjectBytes, err := json.Marshal(cred.CredentialSubject)
 				assert.NoError(tt, err)