@twin.org/immutable-proof-service 0.0.1-next.9 → 0.0.2-next.1

package/dist/esm/index.mjs

@@ -1,15 +1,81 @@
-import { Guards, ComponentFactory, StringHelper, Validation, Converter, RandomHelper, ObjectHelper, Urn, GeneralError, Is, NotFoundError, JsonHelper } from '@twin.org/core';
-import { ImmutableProofTypes, ImmutableProofFailure } from '@twin.org/immutable-proof-models';
-import { DidContexts, DidTypes, DidCryptoSuites } from '@twin.org/standards-w3c-did';
+import { property, SortDirection, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
+import { Guards, ComponentFactory, StringHelper, 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 } from '@twin.org/background-task-models';
-import { Blake2b, Sha256 } from '@twin.org/crypto';
+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 { ImmutableStorageConnectorFactory, ImmutableStorageTypes } from '@twin.org/immutable-storage-models';
-import { VaultConnectorFactory } from '@twin.org/vault-models';
-import { property, SortDirection, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
+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.
@@ -45,8 +111,8 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                     id: "immutableProofCreateRequestExample",
                     request: {
                         body: {
-                            proofObject: {
-                                "@context": "http://schema.org",
+                            document: {
+                                "@context": "https://schema.org",
                                 type: "Person",
                                 name: "John Smith"
                             }
@@ -106,15 +172,19 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                         id: "immutableProofGetResponseExample",
                         response: {
                             body: {
-                                "@context": ImmutableProofTypes.ContextRoot,
+                                "@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.ContextVCDataIntegrity,
-                                    type: DidTypes.DataIntegrityProof,
+                                    "@context": DidContexts.ContextDataIntegrity,
+                                    type: ProofTypes.DataIntegrityProof,
                                     cryptosuite: DidCryptoSuites.EdDSAJcs2022,
                                     created: "2024-08-22T11:56:56.272Z",
                                     proofPurpose: "assertionMethod",
@@ -136,15 +206,19 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                                 [HeaderTypes.ContentType]: MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": ImmutableProofTypes.ContextRoot,
+                                "@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.ContextVCDataIntegrity,
-                                    type: DidTypes.DataIntegrityProof,
+                                    "@context": DidContexts.ContextDataIntegrity,
+                                    type: ProofTypes.DataIntegrityProof,
                                     cryptosuite: DidCryptoSuites.EdDSAJcs2022,
                                     created: "2024-08-22T11:56:56.272Z",
                                     proofPurpose: "assertionMethod",
@@ -164,8 +238,8 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
         operationId: "immutableProofVerify",
         summary: "Verify a proof",
         tag: tagsImmutableProof[0].name,
-        method: "POST",
-        path: `${baseRouteName}/:id`,
+        method: "GET",
+        path: `${baseRouteName}/:id/verify`,
         handler: async (httpRequestContext, request) => immutableProofVerify(httpRequestContext, componentName, request),
         requestType: {
             type: "IImmutableProofVerifyRequest",
@@ -175,13 +249,6 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                     request: {
                         pathParams: {
                             id: "ais:1234567890"
-                        },
-                        body: {
-                            proofObject: {
-                                "@context": "http://schema.org",
-                                type: "Person",
-                                name: "John Smith"
-                            }
                         }
                     }
                 }
@@ -195,7 +262,7 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                         id: "immutableProofVerifyResponseExample",
                         response: {
                             body: {
-                                "@context": ImmutableProofTypes.ContextRoot,
+                                "@context": ImmutableProofContexts.ContextRoot,
                                 type: ImmutableProofTypes.ImmutableProofVerification,
                                 verified: true
                             }
@@ -210,7 +277,7 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                         id: "immutableProofVerifyResponseFailExample",
                         response: {
                             body: {
-                                "@context": ImmutableProofTypes.ContextRoot,
+                                "@context": ImmutableProofContexts.ContextRoot,
                                 type: ImmutableProofTypes.ImmutableProofVerification,
                                 verified: false,
                                 failure: ImmutableProofFailure.ProofTypeMismatch
@@ -235,9 +302,9 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
  */
 async function immutableProofCreate(httpRequestContext, componentName, request) {
     Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.body.proofObject", request.body.proofObject);
+    Guards.object(ROUTES_SOURCE, "request.body.document", request.body.document);
     const component = ComponentFactory.get(componentName);
-    const result = await component.create(request.body.proofObject);
+    const result = await component.create(request.body.document, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         statusCode: HttpStatusCode.created,
         headers: {
@@ -277,10 +344,9 @@ 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);
-    Guards.object(ROUTES_SOURCE, "request.body.proofObject", request.body.proofObject);
     const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
     const component = ComponentFactory.get(componentName);
-    const result = await component.verify(request.pathParams.id, request.body.proofObject);
+    const result = await component.verify(request.pathParams.id);
     return {
         headers: {
             [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
@@ -297,8 +363,9 @@ async function immutableProofVerify(httpRequestContext, componentName, request)
 class ImmutableProofService {
     /**
      * The namespace for the service.
+     * @internal
      */
-    static NAMESPACE = "immutable-proof";
+    static _NAMESPACE = "immutable-proof";
     /**
      * Runtime name for the class.
      */
@@ -308,11 +375,6 @@ class ImmutableProofService {
      * @internal
      */
     _config;
-    /**
-     * The vault connector.
-     * @internal
-     */
-    _vaultConnector;
     /**
      * The identity connector.
      * @internal
@@ -324,83 +386,97 @@ class ImmutableProofService {
      */
     _proofStorage;
     /**
-     * The immutable storage for the credentials.
+     * The verifiable storage for the credentials.
      * @internal
      */
-    _immutableStorage;
+    _verifiableStorage;
     /**
      * The background task connector.
      * @internal
      */
     _backgroundTaskConnector;
     /**
-     * The assertion method id to use for the proofs.
+     * The event bus component.
      * @internal
      */
-    _assertionMethodId;
+    _eventBusComponent;
     /**
-     * The proof hash key id to use for the proofs.
+     * The verification method id to use for the proofs.
      * @internal
      */
-    _proofHashKeyId;
+    _verificationMethodId;
+    /**
+     * The identity connector type.
+     * @internal
+     */
+    _identityConnectorType;
     /**
      * Create a new instance of ImmutableProofService.
      * @param options The dependencies for the immutable proof connector.
-     * @param options.config The configuration for the connector.
-     * @param options.vaultConnectorType The vault connector type, defaults to "vault".
-     * @param options.immutableProofEntityStorageType The entity storage for proofs, defaults to "immutable-proof".
-     * @param options.immutableStorageType The immutable storage, defaults to "immutable-storage".
-     * @param options.identityConnectorType The identity connector type, defaults to "identity".
-     * @param options.backgroundTaskConnectorType The background task connector type, defaults to "background-task".
      */
     constructor(options) {
-        this._vaultConnector = VaultConnectorFactory.get(options?.vaultConnectorType ?? "vault");
         this._proofStorage = EntityStorageConnectorFactory.get(options?.immutableProofEntityStorageType ?? StringHelper.kebabCase("ImmutableProof"));
-        this._immutableStorage = ImmutableStorageConnectorFactory.get(options?.immutableStorageType ?? "immutable-storage");
-        this._identityConnector = IdentityConnectorFactory.get(options?.identityConnectorType ?? "identity");
+        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._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof-assertion";
-        this._proofHashKeyId = this._config.proofHashKeyId ?? "immutable-proof-hash";
-        this._backgroundTaskConnector.registerHandler("immutable-proof", async (proof) => this.processProof(proof));
+        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 authentication proof.
-     * @param proofObject The object for the proof as JSON-LD.
+     * 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 authentication proof.
+     * @returns The id of the new proof.
      */
-    async create(proofObject, userIdentity, nodeIdentity) {
-        Guards.object(this.CLASS_NAME, "proofObject", proofObject);
+    async create(document, userIdentity, nodeIdentity) {
+        Guards.object(this.CLASS_NAME, "document", document);
         Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
         try {
             const validationFailures = [];
-            await JsonLdHelper.validate(proofObject, validationFailures);
-            Validation.asValidationError(this.CLASS_NAME, "proofObject", validationFailures);
+            await JsonLdHelper.validate(document, validationFailures);
+            Validation.asValidationError(this.CLASS_NAME, "document", validationFailures);
             const id = Converter.bytesToHex(RandomHelper.generate(32), false);
             const dateCreated = new Date(Date.now()).toISOString();
-            const proofObjectId = ObjectHelper.extractProperty(proofObject, ["@id", "id"], false);
-            const hash = this.calculateHash(id, dateCreated, nodeIdentity, userIdentity, proofObject);
+            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: Converter.bytesToBase64(hash)
+                proofObjectHash
             };
             await this._proofStorage.set(proofEntity);
-            await this._backgroundTaskConnector.create("immutable-proof", proofEntity);
-            return new Urn(ImmutableProofService.NAMESPACE, id).toString();
+            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(this.CLASS_NAME, "createFailed", undefined, error);
         }
     }
     /**
-     * Get an authentication proof.
+     * Get a proof.
      * @param id The id of the proof to get.
      * @returns The proof.
      * @throws NotFoundError if the proof is not found.
@@ -408,41 +484,39 @@ class ImmutableProofService {
     async get(id) {
         Guards.stringValue(this.CLASS_NAME, "id", id);
         const urnParsed = Urn.fromValidString(id);
-        if (urnParsed.namespaceIdentifier() !== ImmutableProofService.NAMESPACE) {
+        if (urnParsed.namespaceIdentifier() !== ImmutableProofService._NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
-                namespace: ImmutableProofService.NAMESPACE,
+                namespace: ImmutableProofService._NAMESPACE,
                 id
             });
         }
         try {
-            const { immutableProof } = await this.internalGet(id);
-            const compacted = await JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
-            return compacted;
+            const { immutableProof } = await this.internalGet(id, false);
+            return JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "getFailed", undefined, error);
         }
     }
     /**
-     * Verify an authentication proof.
+     * Verify a proof.
      * @param id The id of the proof to verify.
-     * @param proofObject The object to verify as JSON-LD.
      * @returns The result of the verification and any failures.
      * @throws NotFoundError if the proof is not found.
      */
-    async verify(id, proofObject) {
+    async verify(id) {
         Guards.stringValue(this.CLASS_NAME, "id", id);
         const urnParsed = Urn.fromValidString(id);
-        if (urnParsed.namespaceIdentifier() !== ImmutableProofService.NAMESPACE) {
+        if (urnParsed.namespaceIdentifier() !== ImmutableProofService._NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
-                namespace: ImmutableProofService.NAMESPACE,
+                namespace: ImmutableProofService._NAMESPACE,
                 id
             });
         }
         try {
-            const { verified, failure } = await this.internalGet(id, proofObject);
+            const { verified, failure } = await this.internalGet(id, true);
             return {
-                "@context": ImmutableProofTypes.ContextRoot,
+                "@context": ImmutableProofContexts.ContextRoot,
                 type: ImmutableProofTypes.ImmutableProofVerification,
                 verified,
                 failure
@@ -453,19 +527,19 @@ class ImmutableProofService {
         }
     }
     /**
-     * Remove the immutable storage for the proof.
+     * 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 removeImmutable(id, nodeIdentity) {
+    async removeVerifiable(id, nodeIdentity) {
         Guards.stringValue(this.CLASS_NAME, "id", id);
         Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
         const urnParsed = Urn.fromValidString(id);
-        if (urnParsed.namespaceIdentifier() !== ImmutableProofService.NAMESPACE) {
+        if (urnParsed.namespaceIdentifier() !== ImmutableProofService._NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
-                namespace: ImmutableProofService.NAMESPACE,
+                namespace: ImmutableProofService._NAMESPACE,
                 id
             });
         }
@@ -475,14 +549,14 @@ class ImmutableProofService {
             if (Is.empty(streamEntity)) {
                 throw new NotFoundError(this.CLASS_NAME, "proofNotFound", id);
             }
-            if (Is.stringValue(streamEntity.immutableStorageId)) {
-                await this._immutableStorage.remove(nodeIdentity, streamEntity.immutableStorageId);
-                delete streamEntity.immutableStorageId;
+            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(this.CLASS_NAME, "removeImmutableFailed", undefined, error);
+            throw new GeneralError(this.CLASS_NAME, "removeVerifiableFailed", undefined, error);
         }
     }
     /**
@@ -491,14 +565,8 @@ class ImmutableProofService {
      * @returns The hash.
      * @internal
      */
-    calculateHash(id, dateCreated, nodeIdentity, userIdentity, proofObject) {
-        const b2b = new Blake2b(Blake2b.SIZE_256);
-        b2b.update(Converter.utf8ToBytes(id));
-        b2b.update(Converter.utf8ToBytes(dateCreated));
-        b2b.update(Converter.utf8ToBytes(nodeIdentity));
-        b2b.update(Converter.utf8ToBytes(userIdentity));
-        b2b.update(ObjectHelper.toBytes(proofObject));
-        return b2b.digest();
+    calculateDocumentHash(nodeObject) {
+        return `sha256:${Converter.bytesToBase64(Sha256.sum256(ObjectHelper.toBytes(JsonHelper.canonicalize(nodeObject))))}`;
     }
     /**
      * Map the stream entity to a model.
@@ -507,76 +575,83 @@ class ImmutableProofService {
      * @internal
      */
     proofEntityToJsonLd(proofEntity) {
-        const model = {
-            "@context": ImmutableProofTypes.ContextRoot,
+        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
+            proofObjectHash: proofEntity.proofObjectHash,
+            verifiableStorageId: proofEntity.verifiableStorageId
         };
-        return model;
+        return jsonLd;
     }
     /**
      * Process a proof.
      * @param proofEntity The proof entity to process.
      * @internal
      */
-    async processProof(proofEntity) {
-        const immutableProof = this.proofEntityToJsonLd(proofEntity);
-        const hashData = await this.generateHashData(proofEntity.nodeIdentity, immutableProof);
-        // As we are adding the proof to the data we update its context
-        immutableProof["@context"] = [
-            ImmutableProofTypes.ContextRoot,
-            DidContexts.ContextVCDataIntegrity
-        ];
-        immutableProof.proof = await this._identityConnector.createProof(proofEntity.nodeIdentity, `${proofEntity.nodeIdentity}#${this._assertionMethodId}`, hashData);
-        if (Is.stringValue(immutableProof.proof.created)) {
-            proofEntity.dateCreated = immutableProof.proof.created;
+    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() });
+            }
         }
-        const compacted = await JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
-        const immutableStoreResult = await this._immutableStorage.store(proofEntity.nodeIdentity, ObjectHelper.toBytes(compacted));
-        proofEntity.immutableStorageId = immutableStoreResult.id;
-        await this._proofStorage.set(proofEntity);
     }
     /**
-     * Verify an authentication proof.
+     * Verify a proof.
      * @param id The id of the proof to verify.
-     * @param proofObject The object to verify as JSON-LD.
+     * @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, proofObject) {
+    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(this.CLASS_NAME, "proofNotFound", id);
         }
-        let proofModel = await this.proofEntityToJsonLd(proofEntity);
+        let proofJsonLd = this.proofEntityToJsonLd(proofEntity);
         let verified = false;
         let failure = ImmutableProofFailure.NotIssued;
-        if (Is.stringValue(proofEntity.immutableStorageId)) {
+        if (Is.stringValue(proofEntity.verifiableStorageId)) {
             failure = ImmutableProofFailure.ProofMissing;
-            const immutableResult = await this._immutableStorage.get(proofEntity.immutableStorageId);
+            const immutableResult = await this._verifiableStorage.get(proofEntity.verifiableStorageId);
             if (Is.uint8Array(immutableResult.data)) {
-                proofModel = ObjectHelper.fromBytes(immutableResult.data);
-                proofModel.immutableReceipt = immutableResult.receipt;
-                // As we are adding the receipt to the data we update its context
-                if (Is.array(proofModel["@context"])) {
-                    proofModel["@context"].push(ImmutableStorageTypes.ContextRoot);
+                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 (Is.object(proofModel.proof) && Is.object(proofObject)) {
-                    if (proofModel.proof.cryptosuite !== DidCryptoSuites.EdDSAJcs2022) {
+                if (verify && Is.object(proofJsonLd.proof)) {
+                    if (proofJsonLd.proof.cryptosuite !== DidCryptoSuites.EdDSAJcs2022) {
                         failure = ImmutableProofFailure.CryptoSuiteMismatch;
                     }
-                    else if (proofModel.proof.type !== DidTypes.DataIntegrityProof) {
+                    else if (proofJsonLd.proof.type !== ProofTypes.DataIntegrityProof) {
                         failure = ImmutableProofFailure.ProofTypeMismatch;
                     }
                     else {
-                        const hashData = await this.generateHashData(proofEntity.nodeIdentity, proofModel);
-                        const isVerified = await this._identityConnector.verifyProof(hashData, proofModel.proof);
+                        const isVerified = await this._identityConnector.verifyProof(unsecureDocument, proofJsonLd.proof);
                         if (isVerified) {
                             verified = true;
                             failure = undefined;
@@ -589,102 +664,13 @@ class ImmutableProofService {
             }
         }
         return {
-            immutableProof: proofModel,
+            immutableProof: proofJsonLd,
             verified,
             failure
         };
     }
-    /**
-     * Generate the hash data for the proof.
-     * Conforms to https://www.w3.org/TR/vc-di-eddsa/#create-proof-eddsa-jcs-2022
-     * @param nodeIdentity The node identity to use for vault operations.
-     * @param immutableProof The immutable proof to generate the hash data for.
-     * @returns The hash data.
-     * @internal
-     */
-    async generateHashData(nodeIdentity, immutableProof) {
-        // We hash the data for the proof without the the proof or immutable receipt for the proof
-        // without these objects we can simplify the context
-        const object = ObjectHelper.omit(immutableProof, ["proof", "immutableReceipt"]);
-        object["@context"] = ImmutableProofTypes.ContextRoot;
-        const canonicalDocument = JsonHelper.canonicalize(object);
-        const proofKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofHashKeyId}`);
-        const proofHash = Sha256.sum256(proofKey.privateKey);
-        const transformedDocumentHash = Sha256.sum256(Converter.utf8ToBytes(canonicalDocument));
-        const hashData = new Uint8Array(proofHash.length + transformedDocumentHash.length);
-        hashData.set(proofHash);
-        hashData.set(transformedDocumentHash, proofHash.length);
-        return hashData;
-    }
 }
 
-// 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 immutable storage id.
-     */
-    immutableStorageId;
-};
-__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" }),
-    __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" }),
-    __metadata("design:type", String)
-], ImmutableProof.prototype, "immutableStorageId", void 0);
-ImmutableProof = __decorate([
-    entity()
-], ImmutableProof);
-
 const restEntryPoints = [
     {
         name: "immutable-proof",