@twin.org/immutable-proof-service 0.0.2-next.3 → 0.0.3-next.10

package/dist/esm/index.mjs

@@ -1,692 +0,0 @@
-import { property, SortDirection, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
-import { Guards, ComponentFactory, Is, Validation, Converter, RandomHelper, ObjectHelper, Urn, GeneralError, NotFoundError, JsonHelper } from '@twin.org/core';
-import { ImmutableProofTypes, ImmutableProofContexts, ImmutableProofFailure, ImmutableProofTopics } from '@twin.org/immutable-proof-models';
-import { DidCryptoSuites, ProofTypes, DidContexts } from '@twin.org/standards-w3c-did';
-import { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
-import { BackgroundTaskConnectorFactory, TaskStatus } from '@twin.org/background-task-models';
-import { Sha256 } from '@twin.org/crypto';
-import { JsonLdHelper, JsonLdProcessor } from '@twin.org/data-json-ld';
-import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
-import { IdentityConnectorFactory } from '@twin.org/identity-models';
-import { VerifiableStorageConnectorFactory } from '@twin.org/verifiable-storage-models';
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class describing the immutable proof.
- */
-let ImmutableProof = class ImmutableProof {
-    /**
-     * The id of the proof.
-     */
-    id;
-    /**
-     * The identity of the node which controls the proof.
-     */
-    nodeIdentity;
-    /**
-     * The identity of the user which created the proof.
-     */
-    userIdentity;
-    /**
-     * The date/time of when the proof was created.
-     */
-    dateCreated;
-    /**
-     * The associated id for the item.
-     */
-    proofObjectId;
-    /**
-     * The associated hash for the item.
-     */
-    proofObjectHash;
-    /**
-     * The verifiable storage id.
-     */
-    verifiableStorageId;
-};
-__decorate([
-    property({ type: "string", isPrimary: true }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "id", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "nodeIdentity", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "userIdentity", void 0);
-__decorate([
-    property({ type: "string", format: "date-time", sortDirection: SortDirection.Descending }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "dateCreated", void 0);
-__decorate([
-    property({ type: "string", optional: true }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "proofObjectId", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "proofObjectHash", void 0);
-__decorate([
-    property({ type: "string", optional: true }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "verifiableStorageId", void 0);
-ImmutableProof = __decorate([
-    entity()
-], ImmutableProof);
-
-/**
- * The source used when communicating about these routes.
- */
-const ROUTES_SOURCE = "immutableProofRoutes";
-/**
- * The tag to associate with the routes.
- */
-const tagsImmutableProof = [
-    {
-        name: "Immutable Proof",
-        description: "Endpoints which are modelled to access an immutable proof contract."
-    }
-];
-/**
- * The REST routes for immutable proof.
- * @param baseRouteName Prefix to prepend to the paths.
- * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
- * @returns The generated routes.
- */
-function generateRestRoutesImmutableProof(baseRouteName, componentName) {
-    const createRoute = {
-        operationId: "immutableProofCreate",
-        summary: "Create a proof",
-        tag: tagsImmutableProof[0].name,
-        method: "POST",
-        path: `${baseRouteName}/`,
-        handler: async (httpRequestContext, request) => immutableProofCreate(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IImmutableProofCreateRequest",
-            examples: [
-                {
-                    id: "immutableProofCreateRequestExample",
-                    request: {
-                        body: {
-                            document: {
-                                "@context": "https://schema.org",
-                                type: "Person",
-                                name: "John Smith"
-                            }
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "ICreatedResponse",
-                examples: [
-                    {
-                        id: "immutableProofCreateResponseExample",
-                        response: {
-                            statusCode: HttpStatusCode.created,
-                            headers: {
-                                [HeaderTypes.Location]: "test:1234567890"
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    const getRoute = {
-        operationId: "immutableProofGet",
-        summary: "Get a proof",
-        tag: tagsImmutableProof[0].name,
-        method: "GET",
-        path: `${baseRouteName}/:id`,
-        handler: async (httpRequestContext, request) => immutableProofGet(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IImmutableProofGetRequest",
-            examples: [
-                {
-                    id: "immutableProofGetRequestExample",
-                    request: {
-                        headers: {
-                            [HeaderTypes.Accept]: MimeTypes.Json
-                        },
-                        pathParams: {
-                            id: "ais:1234567890"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IImmutableProofGetResponse",
-                examples: [
-                    {
-                        id: "immutableProofGetResponseExample",
-                        response: {
-                            body: {
-                                "@context": [
-                                    ImmutableProofContexts.ContextRoot,
-                                    ImmutableProofContexts.ContextRootCommon
-                                ],
-                                type: ImmutableProofTypes.ImmutableProof,
-                                id: "ais:1234567890",
-                                nodeIdentity: "node-1",
-                                userIdentity: "user-1",
-                                proofObjectId: "test:1234567890",
-                                proofObjectHash: "EAOKyDN0mYQbBh91eMdVeroxQx1H4GfnRbmt6n/2L/Y=",
-                                proof: {
-                                    "@context": DidContexts.ContextDataIntegrity,
-                                    type: ProofTypes.DataIntegrityProof,
-                                    cryptosuite: DidCryptoSuites.EdDSAJcs2022,
-                                    created: "2024-08-22T11:56:56.272Z",
-                                    proofPurpose: "assertionMethod",
-                                    proofValue: "7DdiPPYtxLjCD3wA1po2rv..."
-                                }
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "IImmutableProofGetResponse",
-                mimeType: MimeTypes.JsonLd,
-                examples: [
-                    {
-                        id: "immutableProofJsonLdGetResponseExample",
-                        response: {
-                            headers: {
-                                [HeaderTypes.ContentType]: MimeTypes.JsonLd
-                            },
-                            body: {
-                                "@context": [
-                                    ImmutableProofContexts.ContextRoot,
-                                    ImmutableProofContexts.ContextRootCommon
-                                ],
-                                type: ImmutableProofTypes.ImmutableProof,
-                                id: "ais:1234567890",
-                                nodeIdentity: "node-1",
-                                userIdentity: "user-1",
-                                proofObjectId: "test:1234567890",
-                                proofObjectHash: "EAOKyDN0mYQbBh91eMdVeroxQx1H4GfnRbmt6n/2L/Y=",
-                                proof: {
-                                    "@context": DidContexts.ContextDataIntegrity,
-                                    type: ProofTypes.DataIntegrityProof,
-                                    cryptosuite: DidCryptoSuites.EdDSAJcs2022,
-                                    created: "2024-08-22T11:56:56.272Z",
-                                    proofPurpose: "assertionMethod",
-                                    proofValue: "7DdiPPYtxLjCD3wA1po2rv..."
-                                }
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    const verifyRoute = {
-        operationId: "immutableProofVerify",
-        summary: "Verify a proof",
-        tag: tagsImmutableProof[0].name,
-        method: "GET",
-        path: `${baseRouteName}/:id/verify`,
-        handler: async (httpRequestContext, request) => immutableProofVerify(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IImmutableProofVerifyRequest",
-            examples: [
-                {
-                    id: "immutableProofVerifyRequestExample",
-                    request: {
-                        pathParams: {
-                            id: "ais:1234567890"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IImmutableProofVerifyResponse",
-                examples: [
-                    {
-                        id: "immutableProofVerifyResponseExample",
-                        response: {
-                            body: {
-                                "@context": ImmutableProofContexts.ContextRoot,
-                                type: ImmutableProofTypes.ImmutableProofVerification,
-                                verified: true
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "IImmutableProofVerifyResponse",
-                examples: [
-                    {
-                        id: "immutableProofVerifyResponseFailExample",
-                        response: {
-                            body: {
-                                "@context": ImmutableProofContexts.ContextRoot,
-                                type: ImmutableProofTypes.ImmutableProofVerification,
-                                verified: false,
-                                failure: ImmutableProofFailure.ProofTypeMismatch
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    return [createRoute, getRoute, verifyRoute];
-}
-/**
- * Create a proof.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function immutableProofCreate(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.body.document", request.body.document);
-    const component = ComponentFactory.get(componentName);
-    const result = await component.create(request.body.document, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
-    return {
-        statusCode: HttpStatusCode.created,
-        headers: {
-            [HeaderTypes.Location]: result
-        }
-    };
-}
-/**
- * Get the proof.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function immutableProofGet(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
-    const component = ComponentFactory.get(componentName);
-    const result = await component.get(request.pathParams.id);
-    return {
-        headers: {
-            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
-        },
-        body: result
-    };
-}
-/**
- * Verify the proof.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function immutableProofVerify(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
-    const component = ComponentFactory.get(componentName);
-    const result = await component.verify(request.pathParams.id);
-    return {
-        headers: {
-            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
-        },
-        body: result
-    };
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for performing immutable proof operations.
- */
-class ImmutableProofService {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "ImmutableProofService";
-    /**
-     * The namespace for the service.
-     * @internal
-     */
-    static _NAMESPACE = "immutable-proof";
-    /**
-     * The configuration for the connector.
-     * @internal
-     */
-    _config;
-    /**
-     * The identity connector.
-     * @internal
-     */
-    _identityConnector;
-    /**
-     * The entity storage for proofs.
-     * @internal
-     */
-    _proofStorage;
-    /**
-     * The verifiable storage for the credentials.
-     * @internal
-     */
-    _verifiableStorage;
-    /**
-     * The background task connector.
-     * @internal
-     */
-    _backgroundTaskConnector;
-    /**
-     * The event bus component.
-     * @internal
-     */
-    _eventBusComponent;
-    /**
-     * The verification method id to use for the proofs.
-     * @internal
-     */
-    _verificationMethodId;
-    /**
-     * The identity connector type.
-     * @internal
-     */
-    _identityConnectorType;
-    /**
-     * Create a new instance of ImmutableProofService.
-     * @param options The dependencies for the immutable proof connector.
-     */
-    constructor(options) {
-        this._proofStorage = EntityStorageConnectorFactory.get(options?.immutableProofEntityStorageType ?? "immutable-proof");
-        this._verifiableStorage = VerifiableStorageConnectorFactory.get(options?.verifiableStorageType ?? "verifiable-storage");
-        this._identityConnectorType = options?.identityConnectorType ?? "identity";
-        this._identityConnector = IdentityConnectorFactory.get(this._identityConnectorType);
-        this._backgroundTaskConnector = BackgroundTaskConnectorFactory.get(options?.backgroundTaskConnectorType ?? "background-task");
-        if (Is.stringValue(options?.eventBusComponentType)) {
-            this._eventBusComponent = ComponentFactory.get(options.eventBusComponentType);
-        }
-        this._config = options?.config ?? {};
-        this._verificationMethodId = this._config.verificationMethodId ?? "immutable-proof-assertion";
-        this._backgroundTaskConnector.registerHandler("immutable-proof", "@twin.org/immutable-proof-task", "processProofTask", async (task) => {
-            await this.finaliseTask(task);
-        });
-    }
-    /**
-     * Create a new proof.
-     * @param document The document to create the proof for.
-     * @param userIdentity The identity to create the immutable proof operation with.
-     * @param nodeIdentity The node identity to use for vault operations.
-     * @returns The id of the new proof.
-     */
-    async create(document, userIdentity, nodeIdentity) {
-        Guards.object(ImmutableProofService.CLASS_NAME, "document", document);
-        Guards.stringValue(ImmutableProofService.CLASS_NAME, "userIdentity", userIdentity);
-        Guards.stringValue(ImmutableProofService.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        try {
-            const validationFailures = [];
-            await JsonLdHelper.validate(document, validationFailures);
-            Validation.asValidationError(ImmutableProofService.CLASS_NAME, "document", validationFailures);
-            const id = Converter.bytesToHex(RandomHelper.generate(32), false);
-            const dateCreated = new Date(Date.now()).toISOString();
-            const proofObjectId = ObjectHelper.extractProperty(document, ["@id", "id"], false);
-            // We don't want to store the whole document in the immutable proof, as this could be large
-            // and also reveal information that should not be stored in the proof so we hash the document
-            // and store the hash
-            const proofObjectHash = this.calculateDocumentHash(document);
-            const proofEntity = {
-                id,
-                nodeIdentity,
-                userIdentity,
-                dateCreated,
-                proofObjectId,
-                proofObjectHash
-            };
-            await this._proofStorage.set(proofEntity);
-            const immutableProof = this.proofEntityToJsonLd(proofEntity);
-            const proofTaskPayload = {
-                proofId: id,
-                nodeIdentity,
-                identityConnectorType: this._identityConnectorType,
-                verificationMethodId: this._verificationMethodId,
-                document: immutableProof
-            };
-            await this._backgroundTaskConnector.create("immutable-proof", proofTaskPayload);
-            return new Urn(ImmutableProofService._NAMESPACE, id).toString();
-        }
-        catch (error) {
-            throw new GeneralError(ImmutableProofService.CLASS_NAME, "createFailed", undefined, error);
-        }
-    }
-    /**
-     * Get a proof.
-     * @param id The id of the proof to get.
-     * @returns The proof.
-     * @throws NotFoundError if the proof is not found.
-     */
-    async get(id) {
-        Guards.stringValue(ImmutableProofService.CLASS_NAME, "id", id);
-        const urnParsed = Urn.fromValidString(id);
-        if (urnParsed.namespaceIdentifier() !== ImmutableProofService._NAMESPACE) {
-            throw new GeneralError(ImmutableProofService.CLASS_NAME, "namespaceMismatch", {
-                namespace: ImmutableProofService._NAMESPACE,
-                id
-            });
-        }
-        try {
-            const { immutableProof } = await this.internalGet(id, false);
-            return JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
-        }
-        catch (error) {
-            throw new GeneralError(ImmutableProofService.CLASS_NAME, "getFailed", undefined, error);
-        }
-    }
-    /**
-     * Verify a proof.
-     * @param id The id of the proof to verify.
-     * @returns The result of the verification and any failures.
-     * @throws NotFoundError if the proof is not found.
-     */
-    async verify(id) {
-        Guards.stringValue(ImmutableProofService.CLASS_NAME, "id", id);
-        const urnParsed = Urn.fromValidString(id);
-        if (urnParsed.namespaceIdentifier() !== ImmutableProofService._NAMESPACE) {
-            throw new GeneralError(ImmutableProofService.CLASS_NAME, "namespaceMismatch", {
-                namespace: ImmutableProofService._NAMESPACE,
-                id
-            });
-        }
-        try {
-            const { verified, failure } = await this.internalGet(id, true);
-            return {
-                "@context": ImmutableProofContexts.ContextRoot,
-                type: ImmutableProofTypes.ImmutableProofVerification,
-                verified,
-                failure
-            };
-        }
-        catch (error) {
-            throw new GeneralError(ImmutableProofService.CLASS_NAME, "verifyFailed", undefined, error);
-        }
-    }
-    /**
-     * Remove the verifiable storage for the proof.
-     * @param id The id of the proof to remove the storage from.
-     * @param nodeIdentity The node identity to use for vault operations.
-     * @returns Nothing.
-     * @throws NotFoundError if the proof is not found.
-     */
-    async removeVerifiable(id, nodeIdentity) {
-        Guards.stringValue(ImmutableProofService.CLASS_NAME, "id", id);
-        Guards.stringValue(ImmutableProofService.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        const urnParsed = Urn.fromValidString(id);
-        if (urnParsed.namespaceIdentifier() !== ImmutableProofService._NAMESPACE) {
-            throw new GeneralError(ImmutableProofService.CLASS_NAME, "namespaceMismatch", {
-                namespace: ImmutableProofService._NAMESPACE,
-                id
-            });
-        }
-        try {
-            const streamId = urnParsed.namespaceSpecific(0);
-            const streamEntity = await this._proofStorage.get(streamId);
-            if (Is.empty(streamEntity)) {
-                throw new NotFoundError(ImmutableProofService.CLASS_NAME, "proofNotFound", id);
-            }
-            if (Is.stringValue(streamEntity.verifiableStorageId)) {
-                await this._verifiableStorage.remove(nodeIdentity, streamEntity.verifiableStorageId);
-                delete streamEntity.verifiableStorageId;
-                await this._proofStorage.set(streamEntity);
-            }
-        }
-        catch (error) {
-            throw new GeneralError(ImmutableProofService.CLASS_NAME, "removeVerifiableFailed", undefined, error);
-        }
-    }
-    /**
-     * Calculate the object hash.
-     * @param object The entry to calculate the hash for.
-     * @returns The hash.
-     * @internal
-     */
-    calculateDocumentHash(nodeObject) {
-        return `sha256:${Converter.bytesToBase64(Sha256.sum256(ObjectHelper.toBytes(JsonHelper.canonicalize(nodeObject))))}`;
-    }
-    /**
-     * Map the stream entity to a model.
-     * @param proofEntity The stream entity.
-     * @returns The model.
-     * @internal
-     */
-    proofEntityToJsonLd(proofEntity) {
-        const jsonLd = {
-            "@context": [ImmutableProofContexts.ContextRoot, ImmutableProofContexts.ContextRootCommon],
-            type: ImmutableProofTypes.ImmutableProof,
-            id: proofEntity.id,
-            nodeIdentity: proofEntity.nodeIdentity,
-            userIdentity: proofEntity.userIdentity,
-            proofObjectId: proofEntity.proofObjectId,
-            proofObjectHash: proofEntity.proofObjectHash,
-            verifiableStorageId: proofEntity.verifiableStorageId
-        };
-        return jsonLd;
-    }
-    /**
-     * Process a proof.
-     * @param proofEntity The proof entity to process.
-     * @internal
-     */
-    async finaliseTask(task) {
-        if (task.status === TaskStatus.Success && Is.object(task.payload) && Is.object(task.result)) {
-            const proofEntity = await this._proofStorage.get(task.payload.proofId);
-            if (Is.object(proofEntity)) {
-                const immutableProof = this.proofEntityToJsonLd(proofEntity);
-                // As we are adding the proof to the data we update its context
-                immutableProof["@context"] = JsonLdProcessor.combineContexts([ImmutableProofContexts.ContextRoot, ImmutableProofContexts.ContextRootCommon], task.result.proof["@context"]);
-                immutableProof.proof = task.result.proof;
-                ObjectHelper.propertyDelete(immutableProof.proof, "@context");
-                if (Is.stringValue(immutableProof.proof.created)) {
-                    proofEntity.dateCreated = immutableProof.proof.created;
-                }
-                const compacted = await JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
-                const verifiableCreateResult = await this._verifiableStorage.create(proofEntity.nodeIdentity, ObjectHelper.toBytes(compacted));
-                proofEntity.verifiableStorageId = verifiableCreateResult.id;
-                await this._proofStorage.set(proofEntity);
-                await this._eventBusComponent?.publish(ImmutableProofTopics.ProofCreated, { id: new Urn(ImmutableProofService._NAMESPACE, task.payload.proofId).toString() });
-            }
-        }
-    }
-    /**
-     * Verify a proof.
-     * @param id The id of the proof to verify.
-     * @param verify Validate the proof.
-     * @returns The result of the verification and any failures.
-     * @throws NotFoundError if the proof is not found.
-     * @internal
-     */
-    async internalGet(id, verify) {
-        const urnParsed = Urn.fromValidString(id);
-        const proofId = urnParsed.namespaceSpecific(0);
-        const proofEntity = await this._proofStorage.get(proofId);
-        if (Is.empty(proofEntity)) {
-            throw new NotFoundError(ImmutableProofService.CLASS_NAME, "proofNotFound", id);
-        }
-        let proofJsonLd = this.proofEntityToJsonLd(proofEntity);
-        let verified = false;
-        let failure = ImmutableProofFailure.NotIssued;
-        if (Is.stringValue(proofEntity.verifiableStorageId)) {
-            failure = ImmutableProofFailure.ProofMissing;
-            const immutableResult = await this._verifiableStorage.get(proofEntity.verifiableStorageId);
-            if (Is.uint8Array(immutableResult.data)) {
-                proofJsonLd = ObjectHelper.fromBytes(immutableResult.data);
-                const unsecureDocument = ObjectHelper.clone(proofJsonLd);
-                proofJsonLd.immutableReceipt = immutableResult.receipt;
-                proofJsonLd.verifiableStorageId = proofEntity.verifiableStorageId;
-                // As we are adding the receipt to the data we update the JSON-LD context
-                const receiptContext = immutableResult.receipt["@context"];
-                if (!Is.empty(receiptContext)) {
-                    proofJsonLd["@context"] = JsonLdProcessor.combineContexts(proofJsonLd["@context"], receiptContext);
-                }
-                if (verify && Is.object(proofJsonLd.proof)) {
-                    if (proofJsonLd.proof.cryptosuite !== DidCryptoSuites.EdDSAJcs2022) {
-                        failure = ImmutableProofFailure.CryptoSuiteMismatch;
-                    }
-                    else if (proofJsonLd.proof.type !== ProofTypes.DataIntegrityProof) {
-                        failure = ImmutableProofFailure.ProofTypeMismatch;
-                    }
-                    else {
-                        const isVerified = await this._identityConnector.verifyProof(unsecureDocument, proofJsonLd.proof);
-                        if (isVerified) {
-                            verified = true;
-                            failure = undefined;
-                        }
-                        else {
-                            failure = ImmutableProofFailure.SignatureMismatch;
-                        }
-                    }
-                }
-            }
-        }
-        return {
-            immutableProof: proofJsonLd,
-            verified,
-            failure
-        };
-    }
-}
-
-const restEntryPoints = [
-    {
-        name: "immutable-proof",
-        defaultBaseRoute: "immutable-proof",
-        tags: tagsImmutableProof,
-        generateRoutes: generateRestRoutesImmutableProof
-    }
-];
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Initialize the schema for the immutable proof entity storage connector.
- */
-function initSchema() {
-    EntitySchemaFactory.register("ImmutableProof", () => EntitySchemaHelper.getSchema(ImmutableProof));
-}
-
-export { ImmutableProof, ImmutableProofService, generateRestRoutesImmutableProof, immutableProofCreate, immutableProofGet, immutableProofVerify, initSchema, restEntryPoints, tagsImmutableProof };