@twin.org/identity-connector-entity-storage 0.0.2-next.9 → 0.0.3-next.2

package/dist/cjs/index.cjs

@@ -1,1326 +0,0 @@
-'use strict';
-
-var entity = require('@twin.org/entity');
-var core = require('@twin.org/core');
-var dataJsonLd = require('@twin.org/data-json-ld');
-var entityStorageModels = require('@twin.org/entity-storage-models');
-var identityModels = require('@twin.org/identity-models');
-var standardsW3cDid = require('@twin.org/standards-w3c-did');
-var vaultModels = require('@twin.org/vault-models');
-var web = require('@twin.org/web');
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class describing the identity document.
- */
-exports.IdentityDocument = class IdentityDocument {
-    /**
-     * The identity of the document.
-     */
-    id;
-    /**
-     * The DID document.
-     */
-    document;
-    /**
-     * The signature of the document.
-     */
-    signature;
-    /**
-     * The controller of the document.
-     */
-    controller;
-};
-__decorate([
-    entity.property({ type: "string", isPrimary: true }),
-    __metadata("design:type", String)
-], exports.IdentityDocument.prototype, "id", void 0);
-__decorate([
-    entity.property({ type: "object" }),
-    __metadata("design:type", Object)
-], exports.IdentityDocument.prototype, "document", void 0);
-__decorate([
-    entity.property({ type: "string" }),
-    __metadata("design:type", String)
-], exports.IdentityDocument.prototype, "signature", void 0);
-__decorate([
-    entity.property({ type: "string" }),
-    __metadata("design:type", String)
-], exports.IdentityDocument.prototype, "controller", void 0);
-exports.IdentityDocument = __decorate([
-    entity.entity()
-], exports.IdentityDocument);
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class representing profile details for the identity.
- */
-exports.IdentityProfile = class IdentityProfile {
-    /**
-     * The id for the identity.
-     */
-    identity;
-    /**
-     * The public profile data.
-     */
-    publicProfile;
-    /**
-     * The private profile data.
-     */
-    privateProfile;
-};
-__decorate([
-    entity.property({ type: "string", isPrimary: true }),
-    __metadata("design:type", String)
-], exports.IdentityProfile.prototype, "identity", void 0);
-__decorate([
-    entity.property({ type: "object", optional: true }),
-    __metadata("design:type", Object)
-], exports.IdentityProfile.prototype, "publicProfile", void 0);
-__decorate([
-    entity.property({ type: "object", optional: true }),
-    __metadata("design:type", Object)
-], exports.IdentityProfile.prototype, "privateProfile", void 0);
-exports.IdentityProfile = __decorate([
-    entity.entity()
-], exports.IdentityProfile);
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for performing identity operations using entity storage.
- */
-class EntityStorageIdentityConnector {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "EntityStorageIdentityConnector";
-    /**
-     * The namespace supported by the identity connector.
-     */
-    static NAMESPACE = "entity-storage";
-    /**
-     * The size of the revocation bitmap in bits (16Kb).
-     * @internal
-     */
-    static _REVOCATION_BITS_SIZE = 131072;
-    /**
-     * The entity storage for identities.
-     * @internal
-     */
-    _didDocumentEntityStorage;
-    /**
-     * The vault for the keys.
-     * @internal
-     */
-    _vaultConnector;
-    /**
-     * Create a new instance of EntityStorageIdentityConnector.
-     * @param options The options for the identity connector.
-     */
-    constructor(options) {
-        this._didDocumentEntityStorage = entityStorageModels.EntityStorageConnectorFactory.get(options?.didDocumentEntityStorageType ?? "identity-document");
-        this._vaultConnector = vaultModels.VaultConnectorFactory.get(options?.vaultConnectorType ?? "vault");
-    }
-    /**
-     * Build the key name to access the specified key in the vault.
-     * @param identity The identity of the user to access the vault keys.
-     * @returns The vault key.
-     * @internal
-     */
-    static buildVaultKey(identity, key) {
-        return `${identity}/${key}`;
-    }
-    /**
-     * Verify the document in storage.
-     * @param didDocument The did document that was stored.
-     * @internal
-     */
-    static async verifyDocument(didDocument, vaultConnector) {
-        const stringifiedDocument = core.JsonHelper.canonicalize(didDocument.document);
-        const docBytes = core.Converter.utf8ToBytes(stringifiedDocument);
-        const verified = await vaultConnector.verify(EntityStorageIdentityConnector.buildVaultKey(didDocument.id, "did"), docBytes, core.Converter.base64ToBytes(didDocument.signature));
-        if (!verified) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "signatureVerificationFailed");
-        }
-    }
-    /**
-     * Create a new document.
-     * @param controller The controller of the identity who can make changes.
-     * @returns The created document.
-     */
-    async createDocument(controller) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "controller", controller);
-        try {
-            const did = `did:${EntityStorageIdentityConnector.NAMESPACE}:${core.Converter.bytesToHex(core.RandomHelper.generate(32), true)}`;
-            await this._vaultConnector.createKey(EntityStorageIdentityConnector.buildVaultKey(did, "did"), vaultModels.VaultKeyType.Ed25519);
-            const bitString = new core.BitString(EntityStorageIdentityConnector._REVOCATION_BITS_SIZE);
-            const compressed = await core.Compression.compress(bitString.getBits(), core.CompressionType.Gzip);
-            const didDocument = {
-                "@context": standardsW3cDid.DidContexts.Context,
-                id: did,
-                service: [
-                    {
-                        id: `${did}#revocation`,
-                        type: "BitstringStatusList",
-                        serviceEndpoint: `data:application/octet-stream;base64,${core.Converter.bytesToBase64Url(compressed)}`
-                    }
-                ]
-            };
-            await this.updateDocument(controller, didDocument);
-            return didDocument;
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "createDocumentFailed", undefined, error);
-        }
-    }
-    /**
-     * Remove a document.
-     * @param controller The controller of the identity who can make changes.
-     * @param documentId The id of the document to remove.
-     * @returns Nothing.
-     */
-    async removeDocument(controller, documentId) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "documentId", documentId);
-        try {
-            const didDocument = await this._didDocumentEntityStorage.get(documentId);
-            if (core.Is.empty(didDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", documentId);
-            }
-            await this._didDocumentEntityStorage.remove(documentId);
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "removeDocumentFailed", undefined, error);
-        }
-    }
-    /**
-     * Add a verification method to the document in JSON Web key Format.
-     * @param controller The controller of the identity who can make changes.
-     * @param documentId The id of the document to add the verification method to.
-     * @param verificationMethodType The type of the verification method to add.
-     * @param verificationMethodId The id of the verification method, if undefined uses the kid of the generated JWK.
-     * @returns The verification method.
-     * @throws NotFoundError if the id can not be resolved.
-     * @throws NotSupportedError if the platform does not support multiple keys.
-     */
-    async addVerificationMethod(controller, documentId, verificationMethodType, verificationMethodId) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "documentId", documentId);
-        core.Guards.arrayOneOf(EntityStorageIdentityConnector.CLASS_NAME, "verificationMethodType", verificationMethodType, Object.values(standardsW3cDid.DidVerificationMethodType));
-        let tempKeyId;
-        try {
-            const didIdentityDocument = await this._didDocumentEntityStorage.get(documentId);
-            if (core.Is.undefined(didIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", documentId);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(didIdentityDocument, this._vaultConnector);
-            const didDocument = didIdentityDocument.document;
-            let methodKeyPublic;
-            if (core.Is.stringValue(verificationMethodId)) {
-                // If there is a verification method id, we will try to get the key from the vault.
-                try {
-                    const defaultMethodId = `${controller}/${verificationMethodId}`;
-                    // If there is an existing key, we will use it.
-                    const existingKey = await this._vaultConnector.getKey(defaultMethodId);
-                    methodKeyPublic = existingKey.publicKey;
-                }
-                catch { }
-            }
-            if (core.Is.empty(methodKeyPublic)) {
-                // If there is no existing key, we will create a new one with a temporary name.
-                tempKeyId = `temp-vm-${core.Converter.bytesToBase64Url(core.RandomHelper.generate(16))}`;
-                methodKeyPublic = await this._vaultConnector.createKey(EntityStorageIdentityConnector.buildVaultKey(didDocument.id, tempKeyId), vaultModels.VaultKeyType.Ed25519);
-            }
-            const jwkParams = {
-                alg: "EdDSA",
-                kty: "OKP",
-                crv: "Ed25519",
-                x: core.Converter.bytesToBase64Url(methodKeyPublic)
-            };
-            const kid = await web.Jwk.generateKid(jwkParams);
-            const methodId = `${documentId}#${verificationMethodId ?? kid}`;
-            if (core.Is.stringValue(tempKeyId)) {
-                // If we created a temporary key, we will rename it to the final method id.
-                await this._vaultConnector.renameKey(EntityStorageIdentityConnector.buildVaultKey(didDocument.id, tempKeyId), EntityStorageIdentityConnector.buildVaultKey(didDocument.id, verificationMethodId ?? kid));
-                tempKeyId = undefined;
-            }
-            const methods = this.getAllMethods(didDocument);
-            const existingMethodIndex = methods.findIndex(m => {
-                if (core.Is.string(m.method)) {
-                    return m.method === methodId;
-                }
-                return m.method.id === methodId;
-            });
-            if (existingMethodIndex !== -1) {
-                const methodArray = didDocument[methods[existingMethodIndex].arrayKey];
-                if (core.Is.array(methodArray)) {
-                    methodArray.splice(existingMethodIndex, 1);
-                }
-            }
-            const didVerificationMethod = {
-                id: methodId,
-                controller: documentId,
-                type: "JsonWebKey",
-                publicKeyJwk: {
-                    ...jwkParams,
-                    kid
-                }
-            };
-            didDocument[verificationMethodType] ??= [];
-            didDocument[verificationMethodType]?.push(didVerificationMethod);
-            await this.updateDocument(controller, didDocument);
-            return didVerificationMethod;
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "addVerificationMethodFailed", undefined, error);
-        }
-        finally {
-            if (core.Is.stringValue(tempKeyId)) {
-                // If we created a temporary key and it is still in use, we will remove it from the vault.
-                try {
-                    await this._vaultConnector.removeKey(tempKeyId);
-                }
-                catch { }
-            }
-        }
-    }
-    /**
-     * Remove a verification method from the document.
-     * @param controller The controller of the identity who can make changes.
-     * @param verificationMethodId The id of the verification method.
-     * @returns Nothing.
-     * @throws NotFoundError if the id can not be resolved.
-     * @throws NotSupportedError if the platform does not support multiple revocable keys.
-     */
-    async removeVerificationMethod(controller, verificationMethodId) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        try {
-            const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
-            if (core.Is.empty(idParts.fragment)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "missingDid", verificationMethodId);
-            }
-            const didIdentityDocument = await this._didDocumentEntityStorage.get(idParts.id);
-            if (core.Is.undefined(didIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", idParts.id);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(didIdentityDocument, this._vaultConnector);
-            const didDocument = didIdentityDocument.document;
-            const methods = this.getAllMethods(didDocument);
-            const existingMethodIndex = methods.findIndex(m => {
-                if (core.Is.string(m.method)) {
-                    return m.method === verificationMethodId;
-                }
-                return m.method.id === verificationMethodId;
-            });
-            if (existingMethodIndex !== -1) {
-                const methodArray = didDocument[methods[existingMethodIndex].arrayKey];
-                if (core.Is.array(methodArray)) {
-                    methodArray.splice(existingMethodIndex, 1);
-                    if (methodArray.length === 0) {
-                        delete didDocument[methods[existingMethodIndex].arrayKey];
-                    }
-                }
-            }
-            else {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "verificationMethodNotFound", verificationMethodId);
-            }
-            await this.updateDocument(controller, didDocument);
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "removeVerificationMethodFailed", undefined, error);
-        }
-    }
-    /**
-     * Add a service to the document.
-     * @param controller The controller of the identity who can make changes.
-     * @param documentId The id of the document to add the service to.
-     * @param serviceId The id of the service.
-     * @param serviceType The type of the service.
-     * @param serviceEndpoint The endpoint for the service.
-     * @returns The service.
-     * @throws NotFoundError if the id can not be resolved.
-     */
-    async addService(controller, documentId, serviceId, serviceType, serviceEndpoint) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "documentId", documentId);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "serviceId", serviceId);
-        if (core.Is.array(serviceType)) {
-            core.Guards.arrayValue(EntityStorageIdentityConnector.CLASS_NAME, "serviceType", serviceType);
-        }
-        else {
-            core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "serviceType", serviceType);
-        }
-        if (core.Is.array(serviceEndpoint)) {
-            core.Guards.arrayValue(EntityStorageIdentityConnector.CLASS_NAME, "serviceEndpoint", serviceEndpoint);
-        }
-        else {
-            core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "serviceEndpoint", serviceEndpoint);
-        }
-        try {
-            const didIdentityDocument = await this._didDocumentEntityStorage.get(documentId);
-            if (core.Is.undefined(didIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", documentId);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(didIdentityDocument, this._vaultConnector);
-            const didDocument = didIdentityDocument.document;
-            const fullServiceId = serviceId.includes("#") ? serviceId : `${documentId}#${serviceId}`;
-            if (core.Is.array(didDocument.service)) {
-                const existingServiceIndex = didDocument.service.findIndex(s => s.id === fullServiceId);
-                if (existingServiceIndex !== -1) {
-                    didDocument.service?.splice(existingServiceIndex, 1);
-                }
-            }
-            const didService = {
-                id: fullServiceId,
-                type: serviceType,
-                serviceEndpoint
-            };
-            didDocument.service ??= [];
-            didDocument.service.push(didService);
-            await this.updateDocument(controller, didDocument);
-            return didService;
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "addServiceFailed", undefined, error);
-        }
-    }
-    /**
-     * Remove a service from the document.
-     * @param controller The controller of the identity who can make changes.
-     * @param serviceId The id of the service.
-     * @returns Nothing.
-     * @throws NotFoundError if the id can not be resolved.
-     */
-    async removeService(controller, serviceId) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "serviceId", serviceId);
-        try {
-            const idParts = identityModels.DocumentHelper.parseId(serviceId);
-            if (core.Is.empty(idParts.fragment)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "missingDid", serviceId);
-            }
-            const didIdentityDocument = await this._didDocumentEntityStorage.get(idParts.id);
-            if (core.Is.undefined(didIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", idParts.id);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(didIdentityDocument, this._vaultConnector);
-            const didDocument = didIdentityDocument.document;
-            if (core.Is.array(didDocument.service)) {
-                const existingServiceIndex = didDocument.service.findIndex(s => s.id === serviceId);
-                if (existingServiceIndex !== -1) {
-                    didDocument.service?.splice(existingServiceIndex, 1);
-                    if (didDocument.service?.length === 0) {
-                        delete didDocument.service;
-                    }
-                }
-            }
-            else {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "serviceNotFound", serviceId);
-            }
-            await this.updateDocument(controller, didDocument);
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "removeServiceFailed", undefined, error);
-        }
-    }
-    /**
-     * Create a verifiable credential for a verification method.
-     * @param controller The controller of the identity who can make changes.
-     * @param verificationMethodId The verification method id to use.
-     * @param id The id of the credential.
-     * @param subject The credential subject to store in the verifiable credential.
-     * @param options Additional options for creating the verifiable credential.
-     * @param options.revocationIndex The bitmap revocation index of the credential, if undefined will not have revocation status.
-     * @param options.expirationDate The date the verifiable credential is valid until.
-     * @returns The created verifiable credential and its token.
-     * @throws NotFoundError if the id can not be resolved.
-     */
-    async createVerifiableCredential(controller, verificationMethodId, id, subject, options) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        core.Guards.object(EntityStorageIdentityConnector.CLASS_NAME, "subject", subject);
-        if (!core.Is.undefined(options?.revocationIndex)) {
-            core.Guards.number(EntityStorageIdentityConnector.CLASS_NAME, "options.revocationIndex", options.revocationIndex);
-        }
-        try {
-            const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
-            if (core.Is.empty(idParts.fragment)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "missingDid", verificationMethodId);
-            }
-            const issuerIdentityDocument = await this._didDocumentEntityStorage.get(idParts.id);
-            if (core.Is.undefined(issuerIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", idParts.id);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(issuerIdentityDocument, this._vaultConnector);
-            const issuerDidDocument = issuerIdentityDocument.document;
-            const methods = this.getAllMethods(issuerDidDocument);
-            const methodAndArray = methods.find(m => {
-                if (core.Is.string(m.method)) {
-                    return m.method === verificationMethodId;
-                }
-                return m.method.id === verificationMethodId;
-            });
-            if (!methodAndArray) {
-                throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "methodMissing", {
-                    method: verificationMethodId
-                });
-            }
-            const verificationDidMethod = methodAndArray.method;
-            if (!core.Is.stringValue(verificationDidMethod.publicKeyJwk?.x)) {
-                throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "publicKeyJwkMissing", {
-                    method: verificationMethodId
-                });
-            }
-            const revocationService = issuerDidDocument.service?.find(s => s.id.endsWith("#revocation"));
-            const subjectClone = core.ObjectHelper.clone(subject);
-            const finalTypes = [standardsW3cDid.DidTypes.VerifiableCredential];
-            const credContext = core.ObjectHelper.extractProperty(subjectClone, [
-                "@context"
-            ]);
-            const credId = core.ObjectHelper.extractProperty(subjectClone, ["@id", "id"], false);
-            const credType = core.ObjectHelper.extractProperty(subjectClone, ["@type", "type"]);
-            if (core.Is.stringValue(credType)) {
-                finalTypes.push(credType);
-            }
-            const verifiableCredential = {
-                "@context": dataJsonLd.JsonLdProcessor.combineContexts(standardsW3cDid.DidContexts.ContextVCv1, credContext),
-                id,
-                type: finalTypes,
-                credentialSubject: subjectClone,
-                issuer: issuerDidDocument.id,
-                issuanceDate: new Date(Date.now()).toISOString(),
-                expirationDate: core.Is.date(options?.expirationDate)
-                    ? options?.expirationDate.toISOString()
-                    : undefined,
-                credentialStatus: revocationService && !core.Is.undefined(options?.revocationIndex)
-                    ? {
-                        id: revocationService.id,
-                        type: core.Is.array(revocationService.type)
-                            ? revocationService.type[0]
-                            : revocationService.type,
-                        revocationBitmapIndex: options.revocationIndex.toString()
-                    }
-                    : undefined
-            };
-            const jwtHeader = {
-                kid: verificationDidMethod.id,
-                typ: "JWT",
-                alg: "EdDSA"
-            };
-            const jwtVc = core.ObjectHelper.pick(core.ObjectHelper.clone(verifiableCredential), [
-                "@context",
-                "type",
-                "credentialSubject",
-                "credentialStatus"
-            ]);
-            if (core.Is.array(jwtVc.credentialSubject)) {
-                jwtVc.credentialSubject = jwtVc.credentialSubject.map(c => {
-                    core.ObjectHelper.propertyDelete(c, "id");
-                    return c;
-                });
-            }
-            else {
-                core.ObjectHelper.propertyDelete(jwtVc.credentialSubject, "id");
-            }
-            const jwtPayload = {
-                iss: idParts.id,
-                nbf: Math.floor(Date.now() / 1000),
-                jti: verifiableCredential.id,
-                sub: credId,
-                vc: jwtVc
-            };
-            const signature = await web.Jwt.encodeWithSigner(jwtHeader, jwtPayload, async (header, payload) => vaultModels.VaultConnectorHelper.jwtSigner(this._vaultConnector, EntityStorageIdentityConnector.buildVaultKey(idParts.id, idParts.fragment ?? ""), header, payload));
-            return {
-                verifiableCredential,
-                jwt: signature
-            };
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "createVerifiableCredentialFailed", undefined, error);
-        }
-    }
-    /**
-     * Check a verifiable credential is valid.
-     * @param credentialJwt The credential to verify.
-     * @returns The credential stored in the jwt and the revocation status.
-     */
-    async checkVerifiableCredential(credentialJwt) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "credentialJwt", credentialJwt);
-        try {
-            const jwtDecoded = await web.Jwt.decode(credentialJwt);
-            const jwtHeader = jwtDecoded.header;
-            const jwtPayload = jwtDecoded.payload;
-            const jwtSignature = jwtDecoded.signature;
-            if (core.Is.undefined(jwtHeader) ||
-                core.Is.undefined(jwtPayload) ||
-                core.Is.undefined(jwtPayload.iss) ||
-                core.Is.undefined(jwtSignature)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "jwkSignatureFailed");
-            }
-            const issuerDocumentId = jwtPayload.iss;
-            const issuerIdentityDocument = await this._didDocumentEntityStorage.get(issuerDocumentId);
-            if (core.Is.undefined(issuerIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", issuerDocumentId);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(issuerIdentityDocument, this._vaultConnector);
-            const issuerDidDocument = issuerIdentityDocument.document;
-            const methods = this.getAllMethods(issuerDidDocument);
-            const methodAndArray = methods.find(m => {
-                if (core.Is.string(m.method)) {
-                    return m.method === jwtHeader.kid;
-                }
-                return m.method.id === jwtHeader.kid;
-            });
-            if (!methodAndArray) {
-                throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "methodMissing", {
-                    method: jwtHeader.kid
-                });
-            }
-            const didMethod = methodAndArray.method;
-            if (!core.Is.stringValue(didMethod.publicKeyJwk?.x)) {
-                throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "publicKeyJwkMissing", {
-                    method: jwtHeader.kid
-                });
-            }
-            await web.Jwt.verifySignature(credentialJwt, await web.Jwk.toCryptoKey(didMethod.publicKeyJwk));
-            const verifiableCredential = jwtPayload.vc;
-            if (core.Is.object(verifiableCredential)) {
-                if (core.Is.string(jwtPayload.jti)) {
-                    verifiableCredential.id = jwtPayload.jti;
-                }
-                verifiableCredential.issuer = issuerDocumentId;
-                if (core.Is.number(jwtPayload.nbf)) {
-                    verifiableCredential.issuanceDate = new Date(jwtPayload.nbf * 1000).toISOString();
-                }
-                if (core.Is.array(verifiableCredential.credentialSubject)) {
-                    verifiableCredential.credentialSubject = verifiableCredential.credentialSubject.map(c => {
-                        core.ObjectHelper.propertySet(c, "id", jwtPayload.sub);
-                        return c;
-                    });
-                }
-                else if (core.Is.object(verifiableCredential.credentialSubject)) {
-                    core.ObjectHelper.propertySet(verifiableCredential.credentialSubject, "id", jwtPayload.sub);
-                }
-            }
-            const credentialStatus = verifiableCredential.credentialStatus;
-            let revoked = false;
-            if (core.Is.object(credentialStatus)) {
-                revoked = await this.checkRevocation(issuerDidDocument, credentialStatus.revocationBitmapIndex);
-            }
-            else if (core.Is.arrayValue(credentialStatus)) {
-                for (let i = 0; i < credentialStatus.length; i++) {
-                    revoked = await this.checkRevocation(issuerDidDocument, credentialStatus[i].revocationBitmapIndex);
-                    if (revoked) {
-                        break;
-                    }
-                }
-            }
-            return {
-                revoked,
-                verifiableCredential: revoked ? undefined : verifiableCredential
-            };
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "checkingVerifiableCredentialFailed", undefined, error);
-        }
-    }
-    /**
-     * Revoke verifiable credential(s).
-     * @param controller The controller of the identity who can make changes.
-     * @param issuerDocumentId The id of the document to update the revocation list for.
-     * @param credentialIndices The revocation bitmap index or indices to revoke.
-     * @returns Nothing.
-     */
-    async revokeVerifiableCredentials(controller, issuerDocumentId, credentialIndices) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "issuerDocumentId", issuerDocumentId);
-        core.Guards.arrayValue(EntityStorageIdentityConnector.CLASS_NAME, "credentialIndices", credentialIndices);
-        try {
-            const issuerIdentityDocument = await this._didDocumentEntityStorage.get(issuerDocumentId);
-            if (core.Is.undefined(issuerIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", issuerDocumentId);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(issuerIdentityDocument, this._vaultConnector);
-            const issuerDidDocument = issuerIdentityDocument.document;
-            const revocationService = issuerDidDocument.service?.find(s => s.id.endsWith("#revocation"));
-            if (revocationService &&
-                core.Is.string(revocationService.serviceEndpoint) &&
-                revocationService.type === "BitstringStatusList") {
-                const revocationParts = revocationService.serviceEndpoint.split(",");
-                if (revocationParts.length === 2) {
-                    const compressedRevocationBytes = core.Converter.base64UrlToBytes(revocationParts[1]);
-                    const decompressed = await core.Compression.decompress(compressedRevocationBytes, core.CompressionType.Gzip);
-                    const bitString = core.BitString.fromBits(decompressed, EntityStorageIdentityConnector._REVOCATION_BITS_SIZE);
-                    for (const credentialIndex of credentialIndices) {
-                        bitString.setBit(credentialIndex, true);
-                    }
-                    const compressed = await core.Compression.compress(bitString.getBits(), core.CompressionType.Gzip);
-                    revocationService.serviceEndpoint = `data:application/octet-stream;base64,${core.Converter.bytesToBase64Url(compressed)}`;
-                }
-            }
-            await this.updateDocument(controller, issuerDidDocument);
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "revokeVerifiableCredentialsFailed", undefined, error);
-        }
-    }
-    /**
-     * Unrevoke verifiable credential(s).
-     * @param controller The controller of the identity who can make changes.
-     * @param issuerDocumentId The id of the document to update the revocation list for.
-     * @param credentialIndices The revocation bitmap index or indices to un revoke.
-     * @returns Nothing.
-     */
-    async unrevokeVerifiableCredentials(controller, issuerDocumentId, credentialIndices) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "issuerDocumentId", issuerDocumentId);
-        core.Guards.arrayValue(EntityStorageIdentityConnector.CLASS_NAME, "credentialIndices", credentialIndices);
-        try {
-            const issuerIdentityDocument = await this._didDocumentEntityStorage.get(issuerDocumentId);
-            if (core.Is.undefined(issuerIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", issuerDocumentId);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(issuerIdentityDocument, this._vaultConnector);
-            const issuerDidDocument = issuerIdentityDocument.document;
-            const revocationService = issuerDidDocument.service?.find(s => s.id.endsWith("#revocation"));
-            if (revocationService &&
-                core.Is.string(revocationService.serviceEndpoint) &&
-                revocationService.type === "BitstringStatusList") {
-                const revocationParts = revocationService.serviceEndpoint.split(",");
-                if (revocationParts.length === 2) {
-                    const compressedRevocationBytes = core.Converter.base64UrlToBytes(revocationParts[1]);
-                    const decompressed = await core.Compression.decompress(compressedRevocationBytes, core.CompressionType.Gzip);
-                    const bitString = core.BitString.fromBits(decompressed, EntityStorageIdentityConnector._REVOCATION_BITS_SIZE);
-                    for (const credentialIndex of credentialIndices) {
-                        bitString.setBit(credentialIndex, false);
-                    }
-                    const compressed = await core.Compression.compress(bitString.getBits(), core.CompressionType.Gzip);
-                    revocationService.serviceEndpoint = `data:application/octet-stream;base64,${core.Converter.bytesToBase64Url(compressed)}`;
-                }
-            }
-            await this.updateDocument(controller, issuerDidDocument);
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "unrevokeVerifiableCredentialsFailed", undefined, error);
-        }
-    }
-    /**
-     * Create a verifiable presentation from the supplied verifiable credentials.
-     * @param controller The controller of the identity who can make changes.
-     * @param verificationMethodId The method to associate with the presentation.
-     * @param presentationId The id of the presentation.
-     * @param contexts The contexts for the data stored in the verifiable credential.
-     * @param types The types for the data stored in the verifiable credential.
-     * @param verifiableCredentials The credentials to use for creating the presentation in jwt format.
-     * @param expiresInMinutes The time in minutes for the presentation to expire.
-     * @returns The created verifiable presentation and its token.
-     * @throws NotFoundError if the id can not be resolved.
-     */
-    async createVerifiablePresentation(controller, verificationMethodId, presentationId, contexts, types, verifiableCredentials, expiresInMinutes) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        if (core.Is.array(types)) {
-            core.Guards.arrayValue(EntityStorageIdentityConnector.CLASS_NAME, "types", types);
-        }
-        else if (core.Is.string(types)) {
-            core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "types", types);
-        }
-        core.Guards.arrayValue(EntityStorageIdentityConnector.CLASS_NAME, "verifiableCredentials", verifiableCredentials);
-        if (!core.Is.undefined(expiresInMinutes)) {
-            core.Guards.integer(EntityStorageIdentityConnector.CLASS_NAME, "expiresInMinutes", expiresInMinutes);
-        }
-        try {
-            const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
-            if (core.Is.empty(idParts.fragment)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "missingDid", verificationMethodId);
-            }
-            const holderIdentityDocument = await this._didDocumentEntityStorage.get(idParts.id);
-            if (core.Is.undefined(holderIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", idParts.id);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(holderIdentityDocument, this._vaultConnector);
-            const holderDidDocument = holderIdentityDocument.document;
-            const methods = this.getAllMethods(holderDidDocument);
-            const methodAndArray = methods.find(m => {
-                if (core.Is.string(m.method)) {
-                    return m.method === verificationMethodId;
-                }
-                return m.method.id === verificationMethodId;
-            });
-            if (!methodAndArray) {
-                throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "methodMissing", {
-                    method: verificationMethodId
-                });
-            }
-            const didMethod = methodAndArray.method;
-            if (!core.Is.stringValue(didMethod.publicKeyJwk?.x)) {
-                throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "publicKeyJwkMissing", {
-                    method: verificationMethodId
-                });
-            }
-            const finalTypes = [standardsW3cDid.DidTypes.VerifiablePresentation];
-            if (core.Is.array(types)) {
-                finalTypes.push(...types);
-            }
-            else if (core.Is.stringValue(types)) {
-                finalTypes.push(types);
-            }
-            const verifiablePresentation = {
-                "@context": dataJsonLd.JsonLdProcessor.combineContexts(standardsW3cDid.DidContexts.ContextVCv1, contexts),
-                id: presentationId,
-                type: finalTypes,
-                verifiableCredential: verifiableCredentials,
-                holder: idParts.id
-            };
-            const jwtHeader = {
-                kid: didMethod.id,
-                typ: "JWT",
-                alg: "EdDSA"
-            };
-            const jwtVp = core.ObjectHelper.pick(core.ObjectHelper.clone(verifiablePresentation), [
-                "@context",
-                "type",
-                "verifiableCredential"
-            ]);
-            const jwtPayload = {
-                iss: idParts.id,
-                nbf: Math.floor(Date.now() / 1000),
-                vp: jwtVp
-            };
-            if (core.Is.integer(expiresInMinutes)) {
-                const expiresInSeconds = expiresInMinutes * 60;
-                jwtPayload.exp = Math.floor(Date.now() / 1000) + expiresInSeconds;
-            }
-            const signature = await web.Jwt.encodeWithSigner(jwtHeader, jwtPayload, async (header, payload) => vaultModels.VaultConnectorHelper.jwtSigner(this._vaultConnector, EntityStorageIdentityConnector.buildVaultKey(idParts.id, idParts.fragment ?? ""), header, payload));
-            return {
-                verifiablePresentation,
-                jwt: signature
-            };
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "createVerifiablePresentationFailed", undefined, error);
-        }
-    }
-    /**
-     * Check a verifiable presentation is valid.
-     * @param presentationJwt The presentation to verify.
-     * @returns The presentation stored in the jwt and the revocation status.
-     */
-    async checkVerifiablePresentation(presentationJwt) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "presentationJwt", presentationJwt);
-        try {
-            const jwtDecoded = await web.Jwt.decode(presentationJwt);
-            const jwtHeader = jwtDecoded.header;
-            const jwtPayload = jwtDecoded.payload;
-            const jwtSignature = jwtDecoded.signature;
-            if (core.Is.undefined(jwtHeader) ||
-                core.Is.undefined(jwtPayload) ||
-                core.Is.undefined(jwtPayload.iss) ||
-                core.Is.undefined(jwtSignature)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "jwkSignatureFailed");
-            }
-            const holderDocumentId = jwtPayload.iss;
-            const holderIdentityDocument = await this._didDocumentEntityStorage.get(holderDocumentId);
-            if (core.Is.undefined(holderIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", holderDocumentId);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(holderIdentityDocument, this._vaultConnector);
-            const issuers = [];
-            const tokensRevoked = [];
-            const verifiablePresentation = jwtPayload?.vp;
-            if (core.Is.object(verifiablePresentation) &&
-                core.Is.array(verifiablePresentation.verifiableCredential)) {
-                for (const vcJwt of verifiablePresentation.verifiableCredential) {
-                    let revoked = true;
-                    if (core.Is.stringValue(vcJwt)) {
-                        const jwt = await web.Jwt.decode(vcJwt);
-                        if (core.Is.string(jwt.payload?.iss)) {
-                            const issuerDocumentId = jwt.payload.iss;
-                            verifiablePresentation.holder = issuerDocumentId;
-                            const issuerDidDocument = await this._didDocumentEntityStorage.get(issuerDocumentId);
-                            if (core.Is.undefined(issuerDidDocument)) {
-                                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", issuerDocumentId);
-                            }
-                            await EntityStorageIdentityConnector.verifyDocument(issuerDidDocument, this._vaultConnector);
-                            issuers.push({
-                                "@context": standardsW3cDid.DidContexts.Context,
-                                ...issuerDidDocument
-                            });
-                            const vc = jwt.payload.vc;
-                            if (core.Is.object(vc)) {
-                                const credentialStatus = vc.credentialStatus;
-                                if (core.Is.object(credentialStatus)) {
-                                    revoked = await this.checkRevocation({
-                                        "@context": standardsW3cDid.DidContexts.Context,
-                                        ...issuerDidDocument
-                                    }, credentialStatus.revocationBitmapIndex);
-                                }
-                                else if (core.Is.arrayValue(credentialStatus)) {
-                                    for (let i = 0; i < credentialStatus.length; i++) {
-                                        revoked = await this.checkRevocation({
-                                            "@context": standardsW3cDid.DidContexts.Context,
-                                            ...issuerDidDocument
-                                        }, credentialStatus[i].revocationBitmapIndex);
-                                        if (revoked) {
-                                            break;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        revoked = false;
-                    }
-                    tokensRevoked.push(revoked);
-                }
-            }
-            return {
-                revoked: tokensRevoked.some(Boolean),
-                verifiablePresentation,
-                issuers
-            };
-        }
-        catch (error) {
-            if (core.BaseError.isErrorMessage(error, /revoked/i)) {
-                return {
-                    revoked: true
-                };
-            }
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "checkingVerifiablePresentationFailed", undefined, error);
-        }
-    }
-    /**
-     * Create a proof for arbitrary data with the specified verification method.
-     * @param controller The controller of the identity who can make changes.
-     * @param verificationMethodId The verification method id to use.
-     * @param proofType The type of proof to create.
-     * @param unsecureDocument The unsecure document to create the proof for.
-     * @returns The proof.
-     */
-    async createProof(controller, verificationMethodId, proofType, unsecureDocument) {
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "controller", controller);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        core.Guards.arrayOneOf(EntityStorageIdentityConnector.CLASS_NAME, "proofType", proofType, Object.values(standardsW3cDid.ProofTypes));
-        core.Guards.object(EntityStorageIdentityConnector.CLASS_NAME, "unsecureDocument", unsecureDocument);
-        try {
-            const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
-            if (core.Is.empty(idParts.fragment)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "missingDid", verificationMethodId);
-            }
-            const didIdentityDocument = await this._didDocumentEntityStorage.get(idParts.id);
-            if (core.Is.undefined(didIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", idParts.id);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(didIdentityDocument, this._vaultConnector);
-            const didDocument = didIdentityDocument.document;
-            const methods = this.getAllMethods(didDocument);
-            const methodAndArray = methods.find(m => {
-                if (core.Is.string(m.method)) {
-                    return m.method === verificationMethodId;
-                }
-                return m.method.id === verificationMethodId;
-            });
-            if (!methodAndArray) {
-                throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "methodMissing", {
-                    method: verificationMethodId
-                });
-            }
-            const didMethod = methodAndArray.method;
-            if (!core.Is.stringValue(didMethod.publicKeyJwk?.x)) {
-                throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "publicKeyJwkMissing", {
-                    method: verificationMethodId
-                });
-            }
-            const vaultKey = EntityStorageIdentityConnector.buildVaultKey(didDocument.id, idParts.fragment ?? "");
-            const key = await this._vaultConnector.getKey(vaultKey);
-            const signedProof = await standardsW3cDid.ProofHelper.createProof(proofType, unsecureDocument, standardsW3cDid.ProofHelper.createUnsignedProof(proofType, verificationMethodId), await web.Jwk.fromEd25519Private(key.privateKey));
-            return signedProof;
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "createProofFailed", undefined, error);
-        }
-    }
-    /**
-     * Verify proof for arbitrary data with the specified verification method.
-     * @param document The document to verify.
-     * @param proof The proof to verify.
-     * @returns True if the proof is verified.
-     */
-    async verifyProof(document, proof) {
-        core.Guards.object(EntityStorageIdentityConnector.CLASS_NAME, "document", document);
-        core.Guards.object(EntityStorageIdentityConnector.CLASS_NAME, "proof", proof);
-        core.Guards.stringValue(EntityStorageIdentityConnector.CLASS_NAME, "proof.verificationMethod", proof.verificationMethod);
-        try {
-            const idParts = identityModels.DocumentHelper.parseId(proof.verificationMethod);
-            if (core.Is.empty(idParts.fragment)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "missingDid", proof.verificationMethod);
-            }
-            const didIdentityDocument = await this._didDocumentEntityStorage.get(idParts.id);
-            if (core.Is.undefined(didIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityConnector.CLASS_NAME, "documentNotFound", idParts.id);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(didIdentityDocument, this._vaultConnector);
-            const didDocument = didIdentityDocument.document;
-            const methods = this.getAllMethods(didDocument);
-            const methodAndArray = methods.find(m => {
-                if (core.Is.string(m.method)) {
-                    return m.method === proof.verificationMethod;
-                }
-                return m.method.id === proof.verificationMethod;
-            });
-            if (!methodAndArray) {
-                throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "methodMissing", {
-                    method: proof.verificationMethod
-                });
-            }
-            const didMethod = methodAndArray.method;
-            if (!core.Is.stringValue(didMethod.publicKeyJwk?.x)) {
-                throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "publicKeyJwkMissing", {
-                    method: proof.verificationMethod
-                });
-            }
-            return standardsW3cDid.ProofHelper.verifyProof(document, proof, didMethod.publicKeyJwk);
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityConnector.CLASS_NAME, "verifyProofFailed", undefined, error);
-        }
-    }
-    /**
-     * Get all the methods from a document.
-     * @param document The document to get the methods from.
-     * @returns The methods.
-     * @internal
-     */
-    getAllMethods(document) {
-        const methods = [];
-        const methodTypes = Object.values(standardsW3cDid.DidVerificationMethodType);
-        for (const methodType of methodTypes) {
-            const mt = document[methodType];
-            if (core.Is.arrayValue(mt)) {
-                methods.push(...mt.map(m => ({
-                    arrayKey: methodType,
-                    method: core.Is.string(m) ? { id: m } : m
-                })));
-            }
-        }
-        return methods;
-    }
-    /**
-     * Check if a revocation index is revoked.
-     * @param document The document to check.
-     * @param revocationBitmapIndex The revocation index to check.
-     * @returns True if the index is revoked.
-     * @internal
-     */
-    async checkRevocation(document, revocationBitmapIndex) {
-        if (core.Is.stringValue(revocationBitmapIndex)) {
-            const revocationIndex = core.Coerce.number(revocationBitmapIndex);
-            if (core.Is.number(revocationIndex)) {
-                const revocationService = document.service?.find(s => s.id.endsWith("#revocation"));
-                if (revocationService &&
-                    core.Is.string(revocationService.serviceEndpoint) &&
-                    revocationService.type === "BitstringStatusList") {
-                    const revocationParts = revocationService.serviceEndpoint.split(",");
-                    if (revocationParts.length === 2) {
-                        const compressedRevocationBytes = core.Converter.base64UrlToBytes(revocationParts[1]);
-                        const decompressed = await core.Compression.decompress(compressedRevocationBytes, core.CompressionType.Gzip);
-                        const bitString = core.BitString.fromBits(decompressed, EntityStorageIdentityConnector._REVOCATION_BITS_SIZE);
-                        return bitString.getBit(revocationIndex);
-                    }
-                }
-            }
-        }
-        return false;
-    }
-    /**
-     * Update the document in storage.
-     * @param controller The controller of the document.
-     * @param didDocument The did document to store.
-     * @internal
-     */
-    async updateDocument(controller, didDocument) {
-        const stringifiedDocument = core.JsonHelper.canonicalize(didDocument);
-        const docBytes = core.Converter.utf8ToBytes(stringifiedDocument);
-        const signature = await this._vaultConnector.sign(EntityStorageIdentityConnector.buildVaultKey(didDocument.id, "did"), docBytes);
-        await this._didDocumentEntityStorage.set({
-            id: didDocument.id,
-            document: didDocument,
-            signature: core.Converter.bytesToBase64(signature),
-            controller
-        });
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class which implements the identity profile connector contract.
- */
-class EntityStorageIdentityProfileConnector {
-    /**
-     * The namespace supported by the identity profile connector.
-     */
-    static NAMESPACE = "entity-storage";
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "EntityStorageIdentityProfileConnector";
-    /**
-     * The storage connector for the profiles.
-     * @internal
-     */
-    _profileEntityStorage;
-    /**
-     * Create a new instance of EntityStorageIdentityProfileConnector.
-     * @param options The options for the identity service.
-     */
-    constructor(options) {
-        this._profileEntityStorage = entityStorageModels.EntityStorageConnectorFactory.get(options?.profileEntityStorageType ?? "identity-profile");
-    }
-    /**
-     * Create the profile properties for an identity.
-     * @param identity The identity of the profile to create.
-     * @param publicProfile The public profile data.
-     * @param privateProfile The private profile data.
-     * @returns Nothing.
-     */
-    async create(identity, publicProfile, privateProfile) {
-        core.Guards.stringValue(EntityStorageIdentityProfileConnector.CLASS_NAME, "identity", identity);
-        try {
-            const profile = await this._profileEntityStorage.get(identity);
-            if (!core.Is.empty(profile)) {
-                throw new core.AlreadyExistsError(EntityStorageIdentityProfileConnector.CLASS_NAME, "alreadyExists", identity);
-            }
-            await this._profileEntityStorage.set({
-                identity,
-                publicProfile,
-                privateProfile
-            });
-        }
-        catch (error) {
-            if (core.BaseError.someErrorClass(error, EntityStorageIdentityProfileConnector.CLASS_NAME)) {
-                throw error;
-            }
-            throw new core.GeneralError(EntityStorageIdentityProfileConnector.CLASS_NAME, "createFailed", { identity }, error);
-        }
-    }
-    /**
-     * Get the profile properties for an identity.
-     * @param identity The identity of the item to get.
-     * @param publicPropertyNames The public properties to get for the profile, defaults to all.
-     * @param privatePropertyNames The private properties to get for the profile, defaults to all.
-     * @returns The items properties.
-     */
-    async get(identity, publicPropertyNames, privatePropertyNames) {
-        try {
-            const profile = await this._profileEntityStorage.get(identity);
-            if (!profile) {
-                throw new core.NotFoundError(EntityStorageIdentityProfileConnector.CLASS_NAME, "identityNotFound", identity);
-            }
-            return this.pickProperties(profile, publicPropertyNames, privatePropertyNames);
-        }
-        catch (error) {
-            if (core.BaseError.someErrorClass(error, EntityStorageIdentityProfileConnector.CLASS_NAME)) {
-                throw error;
-            }
-            throw new core.GeneralError(EntityStorageIdentityProfileConnector.CLASS_NAME, "getFailed", { identity }, error);
-        }
-    }
-    /**
-     * Update the profile properties of an identity.
-     * @param identity The identity to update.
-     * @param publicProfile The public profile data.
-     * @param privateProfile The private profile data.
-     * @returns Nothing.
-     */
-    async update(identity, publicProfile, privateProfile) {
-        core.Guards.stringValue(EntityStorageIdentityProfileConnector.CLASS_NAME, "identity", identity);
-        try {
-            const profile = await this._profileEntityStorage.get(identity);
-            if (core.Is.empty(profile)) {
-                throw new core.NotFoundError(EntityStorageIdentityProfileConnector.CLASS_NAME, "notFound", identity);
-            }
-            profile.publicProfile = publicProfile ?? profile.publicProfile;
-            profile.privateProfile = privateProfile ?? profile.privateProfile;
-            await this._profileEntityStorage.set(profile);
-        }
-        catch (error) {
-            if (core.BaseError.someErrorClass(error, EntityStorageIdentityProfileConnector.CLASS_NAME)) {
-                throw error;
-            }
-            throw new core.GeneralError(EntityStorageIdentityProfileConnector.CLASS_NAME, "updateFailed", { identity }, error);
-        }
-    }
-    /**
-     * Delete the profile for an identity.
-     * @param identity The identity to delete.
-     * @returns Nothing.
-     */
-    async remove(identity) {
-        core.Guards.stringValue(EntityStorageIdentityProfileConnector.CLASS_NAME, "identity", identity);
-        try {
-            const profile = await this._profileEntityStorage.get(identity);
-            if (core.Is.empty(profile)) {
-                throw new core.NotFoundError(EntityStorageIdentityProfileConnector.CLASS_NAME, "notFound", identity);
-            }
-            await this._profileEntityStorage.remove(identity);
-        }
-        catch (error) {
-            if (core.BaseError.someErrorClass(error, EntityStorageIdentityProfileConnector.CLASS_NAME)) {
-                throw error;
-            }
-            throw new core.GeneralError(EntityStorageIdentityProfileConnector.CLASS_NAME, "removeFailed", { identity }, error);
-        }
-    }
-    /**
-     * Get a list of the requested types.
-     * @param publicFilters The filters to apply to the identities public profiles.
-     * @param privateFilters The filters to apply to the identities private profiles.
-     * @param publicPropertyNames The public properties to get for the profile, defaults to all.
-     * @param privatePropertyNames The private properties to get for the profile, defaults to all.
-     * @param cursor The cursor for paged requests.
-     * @param limit The maximum number of items in a page.
-     * @returns The list of items and cursor for paging.
-     */
-    async list(publicFilters, privateFilters, publicPropertyNames, privatePropertyNames, cursor, limit) {
-        try {
-            const conditions = [];
-            if (core.Is.arrayValue(publicFilters)) {
-                for (const filter of publicFilters) {
-                    conditions.push({
-                        property: `publicProfile.${filter.propertyName}`,
-                        value: filter.propertyValue,
-                        comparison: entity.ComparisonOperator.Equals
-                    });
-                }
-            }
-            if (core.Is.arrayValue(privateFilters)) {
-                for (const filter of privateFilters) {
-                    conditions.push({
-                        property: `privateProfile.${filter.propertyName}`,
-                        value: filter.propertyValue,
-                        comparison: entity.ComparisonOperator.Equals
-                    });
-                }
-            }
-            const result = await this._profileEntityStorage.query(core.Is.arrayValue(conditions)
-                ? {
-                    conditions
-                }
-                : undefined, undefined, undefined, cursor, limit);
-            const items = [];
-            for (const resultEntity of result.entities) {
-                items.push({
-                    identity: resultEntity.identity ?? "",
-                    ...this.pickProperties(resultEntity, publicPropertyNames, privatePropertyNames)
-                });
-            }
-            return {
-                items,
-                cursor: result.cursor
-            };
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityProfileConnector.CLASS_NAME, "listFailed", undefined, error);
-        }
-    }
-    /**
-     * Get the profile properties for an identity.
-     * @param profile The profile to pick the properties from.
-     * @param publicPropertyNames The public properties to get for the profile, defaults to all.
-     * @param privatePropertyNames The private properties to get for the profile, defaults to all.
-     * @returns The identity profile, will only return private data if you have correct permissions.
-     * @internal
-     */
-    pickProperties(profile, publicPropertyNames, privatePropertyNames) {
-        return {
-            publicProfile: core.Is.array(publicPropertyNames)
-                ? core.ObjectHelper.pick(profile.publicProfile, publicPropertyNames)
-                : profile.publicProfile,
-            privateProfile: core.Is.array(privatePropertyNames)
-                ? core.ObjectHelper.pick(profile.privateProfile, privatePropertyNames)
-                : profile.privateProfile
-        };
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for performing identity operations using entity storage.
- */
-class EntityStorageIdentityResolverConnector {
-    /**
-     * The namespace supported by the identity connector.
-     */
-    static NAMESPACE = "entity-storage";
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "EntityStorageIdentityResolverConnector";
-    /**
-     * The entity storage for identities.
-     * @internal
-     */
-    _didDocumentEntityStorage;
-    /**
-     * The vault for the keys.
-     * @internal
-     */
-    _vaultConnector;
-    /**
-     * Create a new instance of EntityStorageIdentityResolverConnector.
-     * @param options The options for the identity connector.
-     */
-    constructor(options) {
-        this._didDocumentEntityStorage = entityStorageModels.EntityStorageConnectorFactory.get(options?.didDocumentEntityStorageType ?? "identity-document");
-        this._vaultConnector = vaultModels.VaultConnectorFactory.get(options?.vaultConnectorType ?? "vault");
-    }
-    /**
-     * Resolve a document from its id.
-     * @param documentId The id of the document to resolve.
-     * @returns The resolved document.
-     * @throws NotFoundError if the id can not be resolved.
-     */
-    async resolveDocument(documentId) {
-        core.Guards.stringValue(EntityStorageIdentityResolverConnector.CLASS_NAME, "documentId", documentId);
-        try {
-            const didIdentityDocument = await this._didDocumentEntityStorage.get(documentId);
-            if (core.Is.undefined(didIdentityDocument)) {
-                throw new core.NotFoundError(EntityStorageIdentityResolverConnector.CLASS_NAME, "documentNotFound", documentId);
-            }
-            await EntityStorageIdentityConnector.verifyDocument(didIdentityDocument, this._vaultConnector);
-            return didIdentityDocument.document;
-        }
-        catch (error) {
-            throw new core.GeneralError(EntityStorageIdentityResolverConnector.CLASS_NAME, "resolveDocumentFailed", undefined, error);
-        }
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialize the schema for the identity entity storage connector.
- * @param options Options for which entities to register.
- * @param options.includeDocument Whether to include the document entity, defaults to true.
- * @param options.includeProfile Whether to include the profile entity, defaults to true.
- */
-function initSchema(options) {
-    if (options?.includeDocument ?? true) {
-        entity.EntitySchemaFactory.register("IdentityDocument", () => entity.EntitySchemaHelper.getSchema(exports.IdentityDocument));
-    }
-    if (options?.includeProfile ?? true) {
-        entity.EntitySchemaFactory.register("IdentityProfile", () => entity.EntitySchemaHelper.getSchema(exports.IdentityProfile));
-    }
-}
-
-exports.EntityStorageIdentityConnector = EntityStorageIdentityConnector;
-exports.EntityStorageIdentityProfileConnector = EntityStorageIdentityProfileConnector;
-exports.EntityStorageIdentityResolverConnector = EntityStorageIdentityResolverConnector;
-exports.initSchema = initSchema;