@twin.org/immutable-proof-service 0.0.1-next.3 → 0.0.1-next.30

package/dist/cjs/index.cjs

@@ -1,17 +1,83 @@
 'use strict';
 
+var entity = require('@twin.org/entity');
 var core = require('@twin.org/core');
 var immutableProofModels = require('@twin.org/immutable-proof-models');
 var standardsW3cDid = require('@twin.org/standards-w3c-did');
 var web = require('@twin.org/web');
+var backgroundTaskModels = require('@twin.org/background-task-models');
 var crypto = require('@twin.org/crypto');
 var dataJsonLd = require('@twin.org/data-json-ld');
-var dataSchemaOrg = require('@twin.org/data-schema-org');
-var entity = require('@twin.org/entity');
 var entityStorageModels = require('@twin.org/entity-storage-models');
 var identityModels = require('@twin.org/identity-models');
-var immutableStorageModels = require('@twin.org/immutable-storage-models');
-var vaultModels = require('@twin.org/vault-models');
+var verifiableStorageModels = require('@twin.org/verifiable-storage-models');
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class describing the immutable proof.
+ */
+exports.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([
+    entity.property({ type: "string", isPrimary: true }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "id", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "nodeIdentity", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "userIdentity", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "dateCreated", void 0);
+__decorate([
+    entity.property({ type: "string", optional: true }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "proofObjectId", void 0);
+__decorate([
+    entity.property({ type: "string" }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "proofObjectHash", void 0);
+__decorate([
+    entity.property({ type: "string", optional: true }),
+    __metadata("design:type", String)
+], exports.ImmutableProof.prototype, "verifiableStorageId", void 0);
+exports.ImmutableProof = __decorate([
+    entity.entity()
+], exports.ImmutableProof);
 
 /**
  * The source used when communicating about these routes.
@@ -47,8 +113,8 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                     id: "immutableProofCreateRequestExample",
                     request: {
                         body: {
-                            proofObject: {
-                                "@context": "http://schema.org",
+                            document: {
+                                "@context": "https://schema.org",
                                 type: "Person",
                                 name: "John Smith"
                             }
@@ -108,15 +174,19 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                         id: "immutableProofGetResponseExample",
                         response: {
                             body: {
-                                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                "@context": [
+                                    immutableProofModels.ImmutableProofContexts.ContextRoot,
+                                    immutableProofModels.ImmutableProofContexts.ContextRootCommon
+                                ],
                                 type: immutableProofModels.ImmutableProofTypes.ImmutableProof,
                                 id: "ais:1234567890",
+                                nodeIdentity: "node-1",
                                 userIdentity: "user-1",
                                 proofObjectId: "test:1234567890",
                                 proofObjectHash: "EAOKyDN0mYQbBh91eMdVeroxQx1H4GfnRbmt6n/2L/Y=",
                                 proof: {
-                                    "@context": standardsW3cDid.DidContexts.ContextVCDataIntegrity,
-                                    type: standardsW3cDid.DidTypes.DataIntegrityProof,
+                                    "@context": standardsW3cDid.DidContexts.ContextDataIntegrity,
+                                    type: standardsW3cDid.ProofTypes.DataIntegrityProof,
                                     cryptosuite: standardsW3cDid.DidCryptoSuites.EdDSAJcs2022,
                                     created: "2024-08-22T11:56:56.272Z",
                                     proofPurpose: "assertionMethod",
@@ -138,15 +208,19 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                                 [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                "@context": [
+                                    immutableProofModels.ImmutableProofContexts.ContextRoot,
+                                    immutableProofModels.ImmutableProofContexts.ContextRootCommon
+                                ],
                                 type: immutableProofModels.ImmutableProofTypes.ImmutableProof,
                                 id: "ais:1234567890",
+                                nodeIdentity: "node-1",
                                 userIdentity: "user-1",
                                 proofObjectId: "test:1234567890",
                                 proofObjectHash: "EAOKyDN0mYQbBh91eMdVeroxQx1H4GfnRbmt6n/2L/Y=",
                                 proof: {
-                                    "@context": standardsW3cDid.DidContexts.ContextVCDataIntegrity,
-                                    type: standardsW3cDid.DidTypes.DataIntegrityProof,
+                                    "@context": standardsW3cDid.DidContexts.ContextDataIntegrity,
+                                    type: standardsW3cDid.ProofTypes.DataIntegrityProof,
                                     cryptosuite: standardsW3cDid.DidCryptoSuites.EdDSAJcs2022,
                                     created: "2024-08-22T11:56:56.272Z",
                                     proofPurpose: "assertionMethod",
@@ -166,8 +240,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",
@@ -177,13 +251,6 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                     request: {
                         pathParams: {
                             id: "ais:1234567890"
-                        },
-                        body: {
-                            proofObject: {
-                                "@context": "http://schema.org",
-                                type: "Person",
-                                name: "John Smith"
-                            }
                         }
                     }
                 }
@@ -197,7 +264,7 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                         id: "immutableProofVerifyResponseExample",
                         response: {
                             body: {
-                                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                "@context": immutableProofModels.ImmutableProofContexts.ContextRoot,
                                 type: immutableProofModels.ImmutableProofTypes.ImmutableProofVerification,
                                 verified: true
                             }
@@ -212,7 +279,7 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                         id: "immutableProofVerifyResponseFailExample",
                         response: {
                             body: {
-                                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                "@context": immutableProofModels.ImmutableProofContexts.ContextRoot,
                                 type: immutableProofModels.ImmutableProofTypes.ImmutableProofVerification,
                                 verified: false,
                                 failure: immutableProofModels.ImmutableProofFailure.ProofTypeMismatch
@@ -237,9 +304,9 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
  */
 async function immutableProofCreate(httpRequestContext, componentName, request) {
     core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.body.proofObject", request.body.proofObject);
+    core.Guards.object(ROUTES_SOURCE, "request.body.document", request.body.document);
     const component = core.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: web.HttpStatusCode.created,
         headers: {
@@ -279,10 +346,9 @@ async function immutableProofVerify(httpRequestContext, componentName, request)
     core.Guards.object(ROUTES_SOURCE, "request", request);
     core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
     core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    core.Guards.object(ROUTES_SOURCE, "request.body.proofObject", request.body.proofObject);
     const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
     const component = core.ComponentFactory.get(componentName);
-    const result = await component.verify(request.pathParams.id, request.body.proofObject);
+    const result = await component.verify(request.pathParams.id);
     return {
         headers: {
             [web.HeaderTypes.ContentType]: mimeType === "json" ? web.MimeTypes.Json : web.MimeTypes.JsonLd
@@ -310,11 +376,6 @@ class ImmutableProofService {
      * @internal
      */
     _config;
-    /**
-     * The vault connector.
-     * @internal
-     */
-    _vaultConnector;
     /**
      * The identity connector.
      * @internal
@@ -326,74 +387,89 @@ class ImmutableProofService {
      */
     _proofStorage;
     /**
-     * The immutable storage for the credentials.
+     * The verifiable storage for the credentials.
+     * @internal
+     */
+    _verifiableStorage;
+    /**
+     * The background task connector.
      * @internal
      */
-    _immutableStorage;
+    _backgroundTaskConnector;
     /**
-     * The assertion method id to use for the proofs.
+     * The event bus component.
      * @internal
      */
-    _assertionMethodId;
+    _eventBusComponent;
     /**
-     * The proof config key id to use for the proofs.
+     * The verification method id to use for the proofs.
      * @internal
      */
-    _proofConfigKeyId;
+    _verificationMethodId;
     /**
-     * Are we currently processing proofs.
+     * The identity connector type.
      * @internal
      */
-    _processing;
+    _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".
      */
     constructor(options) {
-        this._vaultConnector = vaultModels.VaultConnectorFactory.get(options?.vaultConnectorType ?? "vault");
         this._proofStorage = entityStorageModels.EntityStorageConnectorFactory.get(options?.immutableProofEntityStorageType ?? core.StringHelper.kebabCase("ImmutableProof"));
-        this._immutableStorage = immutableStorageModels.ImmutableStorageConnectorFactory.get(options?.immutableStorageType ?? "immutable-storage");
-        this._identityConnector = identityModels.IdentityConnectorFactory.get(options?.identityConnectorType ?? "identity");
+        this._verifiableStorage = verifiableStorageModels.VerifiableStorageConnectorFactory.get(options?.verifiableStorageType ?? "verifiable-storage");
+        this._identityConnectorType = options?.identityConnectorType ?? "identity";
+        this._identityConnector = identityModels.IdentityConnectorFactory.get(this._identityConnectorType);
+        this._backgroundTaskConnector = backgroundTaskModels.BackgroundTaskConnectorFactory.get(options?.backgroundTaskConnectorType ?? "background-task");
+        if (core.Is.stringValue(options?.eventBusComponentType)) {
+            this._eventBusComponent = core.ComponentFactory.get(options.eventBusComponentType);
+        }
         this._config = options?.config ?? {};
-        this._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof";
-        this._proofConfigKeyId = this._config.proofConfigKeyId ?? "immutable-proof";
-        dataSchemaOrg.SchemaOrgDataTypes.registerRedirects();
-        this._processing = false;
+        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) {
-        core.Guards.object(this.CLASS_NAME, "proofObject", proofObject);
+    async create(document, userIdentity, nodeIdentity) {
+        core.Guards.object(this.CLASS_NAME, "document", document);
         core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
         try {
             const validationFailures = [];
-            await dataJsonLd.JsonLdHelper.validate(proofObject, validationFailures);
-            core.Validation.asValidationError(this.CLASS_NAME, "proofObject", validationFailures);
+            await dataJsonLd.JsonLdHelper.validate(document, validationFailures);
+            core.Validation.asValidationError(this.CLASS_NAME, "document", validationFailures);
             const id = core.Converter.bytesToHex(core.RandomHelper.generate(32), false);
             const dateCreated = new Date(Date.now()).toISOString();
-            const proofObjectId = core.ObjectHelper.extractProperty(proofObject, ["@id", "id"], false);
-            const hash = this.calculateHash(id, dateCreated, nodeIdentity, userIdentity, proofObject);
+            const proofObjectId = core.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: core.Converter.bytesToBase64(hash)
+                proofObjectHash
             };
             await this._proofStorage.set(proofEntity);
-            this.startProcessingProofs();
+            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 core.Urn(ImmutableProofService.NAMESPACE, id).toString();
         }
         catch (error) {
@@ -401,7 +477,7 @@ class ImmutableProofService {
         }
     }
     /**
-     * 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.
@@ -416,22 +492,20 @@ class ImmutableProofService {
             });
         }
         try {
-            const { immutableProof } = await this.internalGet(id);
-            const compacted = await dataJsonLd.JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
-            return compacted;
+            const { immutableProof } = await this.internalGet(id, false);
+            return dataJsonLd.JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
         }
         catch (error) {
             throw new core.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) {
         core.Guards.stringValue(this.CLASS_NAME, "id", id);
         const urnParsed = core.Urn.fromValidString(id);
         if (urnParsed.namespaceIdentifier() !== ImmutableProofService.NAMESPACE) {
@@ -441,9 +515,9 @@ class ImmutableProofService {
             });
         }
         try {
-            const { verified, failure } = await this.internalGet(id, proofObject);
+            const { verified, failure } = await this.internalGet(id, true);
             return {
-                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                "@context": immutableProofModels.ImmutableProofContexts.ContextRoot,
                 type: immutableProofModels.ImmutableProofTypes.ImmutableProofVerification,
                 verified,
                 failure
@@ -454,13 +528,13 @@ 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) {
         core.Guards.stringValue(this.CLASS_NAME, "id", id);
         core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
         const urnParsed = core.Urn.fromValidString(id);
@@ -476,14 +550,14 @@ class ImmutableProofService {
             if (core.Is.empty(streamEntity)) {
                 throw new core.NotFoundError(this.CLASS_NAME, "proofNotFound", id);
             }
-            if (core.Is.stringValue(streamEntity.immutableStorageId)) {
-                await this._immutableStorage.remove(nodeIdentity, streamEntity.immutableStorageId);
-                delete streamEntity.immutableStorageId;
+            if (core.Is.stringValue(streamEntity.verifiableStorageId)) {
+                await this._verifiableStorage.remove(nodeIdentity, streamEntity.verifiableStorageId);
+                delete streamEntity.verifiableStorageId;
                 await this._proofStorage.set(streamEntity);
             }
         }
         catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "removeImmutableFailed", undefined, error);
+            throw new core.GeneralError(this.CLASS_NAME, "removeVerifiableFailed", undefined, error);
         }
     }
     /**
@@ -492,14 +566,8 @@ class ImmutableProofService {
      * @returns The hash.
      * @internal
      */
-    calculateHash(id, dateCreated, nodeIdentity, userIdentity, proofObject) {
-        const b2b = new crypto.Blake2b(crypto.Blake2b.SIZE_256);
-        b2b.update(core.Converter.utf8ToBytes(id));
-        b2b.update(core.Converter.utf8ToBytes(dateCreated));
-        b2b.update(core.Converter.utf8ToBytes(nodeIdentity));
-        b2b.update(core.Converter.utf8ToBytes(userIdentity));
-        b2b.update(core.ObjectHelper.toBytes(proofObject));
-        return b2b.digest();
+    calculateDocumentHash(nodeObject) {
+        return `sha256:${core.Converter.bytesToBase64(crypto.Sha256.sum256(core.ObjectHelper.toBytes(core.JsonHelper.canonicalize(nodeObject))))}`;
     }
     /**
      * Map the stream entity to a model.
@@ -507,99 +575,84 @@ class ImmutableProofService {
      * @returns The model.
      * @internal
      */
-    proofEntityToModel(proofEntity) {
-        const model = {
-            "@context": [
-                immutableProofModels.ImmutableProofTypes.ContextRoot,
-                dataSchemaOrg.SchemaOrgTypes.ContextRoot,
-                standardsW3cDid.DidContexts.ContextVCDataIntegrity
-            ],
+    proofEntityToJsonLd(proofEntity) {
+        const jsonLd = {
+            "@context": [immutableProofModels.ImmutableProofContexts.ContextRoot, immutableProofModels.ImmutableProofContexts.ContextRootCommon],
             type: immutableProofModels.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;
     }
     /**
-     * Start processing proofs.
-     * @returns Nothing.
-     * @internal
-     */
-    startProcessingProofs() {
-        if (!this._processing) {
-            setTimeout(async () => {
-                await this.processProofs();
-            }, 0);
-        }
-    }
-    /**
-     * Process the proofs.
+     * Process a proof.
+     * @param proofEntity The proof entity to process.
      * @internal
      */
-    async processProofs() {
-        // Get the oldest pending proof, plus one more, we can then determine whether to
-        // trigger another process after this one
-        const pendingProofs = await this._proofStorage.query({
-            property: "immutableStorageId",
-            comparison: entity.ComparisonOperator.Equals,
-            value: undefined
-        }, [
-            {
-                property: "dateCreated",
-                sortDirection: entity.SortDirection.Ascending
+    async finaliseTask(task) {
+        if (task.status === backgroundTaskModels.TaskStatus.Success && core.Is.object(task.payload) && core.Is.object(task.result)) {
+            const proofEntity = await this._proofStorage.get(task.payload.proofId);
+            if (core.Is.object(proofEntity)) {
+                const immutableProof = this.proofEntityToJsonLd(proofEntity);
+                // As we are adding the proof to the data we update its context
+                immutableProof["@context"] = dataJsonLd.JsonLdProcessor.combineContexts([immutableProofModels.ImmutableProofContexts.ContextRoot, immutableProofModels.ImmutableProofContexts.ContextRootCommon], task.result.proof["@context"]);
+                immutableProof.proof = task.result.proof;
+                core.ObjectHelper.propertyDelete(immutableProof.proof, "@context");
+                if (core.Is.stringValue(immutableProof.proof.created)) {
+                    proofEntity.dateCreated = immutableProof.proof.created;
+                }
+                const compacted = await dataJsonLd.JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
+                const verifiableCreateResult = await this._verifiableStorage.create(proofEntity.nodeIdentity, core.ObjectHelper.toBytes(compacted));
+                proofEntity.verifiableStorageId = verifiableCreateResult.id;
+                await this._proofStorage.set(proofEntity);
+                await this._eventBusComponent?.publish(immutableProofModels.ImmutableProofTopics.ProofCreated, { id: new core.Urn(ImmutableProofService.NAMESPACE, task.payload.proofId).toString() });
             }
-        ], undefined, undefined, 2);
-        if (pendingProofs.entities.length > 0) {
-            const proofEntity = pendingProofs.entities[0];
-            const immutableProof = this.proofEntityToModel(proofEntity);
-            const hashData = await this.generateHashData(proofEntity.nodeIdentity, immutableProof);
-            immutableProof.proof = await this._identityConnector.createProof(proofEntity.nodeIdentity, `${proofEntity.nodeIdentity}#${this._assertionMethodId}`, hashData);
-            proofEntity.dateCreated = immutableProof.proof.created ?? new Date(Date.now()).toISOString();
-            const compacted = await dataJsonLd.JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
-            proofEntity.immutableStorageId = await this._immutableStorage.store(proofEntity.nodeIdentity, core.ObjectHelper.toBytes(compacted));
-            await this._proofStorage.set(proofEntity);
-        }
-        // If there are still remaining proofs, start the timer again
-        this._processing = false;
-        if (pendingProofs.entities.length > 1) {
-            this.startProcessingProofs();
         }
     }
     /**
-     * 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 = core.Urn.fromValidString(id);
         const proofId = urnParsed.namespaceSpecific(0);
         const proofEntity = await this._proofStorage.get(proofId);
         if (core.Is.empty(proofEntity)) {
             throw new core.NotFoundError(this.CLASS_NAME, "proofNotFound", id);
         }
-        let proofModel = await this.proofEntityToModel(proofEntity);
+        let proofJsonLd = this.proofEntityToJsonLd(proofEntity);
         let verified = false;
         let failure = immutableProofModels.ImmutableProofFailure.NotIssued;
-        if (core.Is.stringValue(proofEntity.immutableStorageId)) {
+        if (core.Is.stringValue(proofEntity.verifiableStorageId)) {
             failure = immutableProofModels.ImmutableProofFailure.ProofMissing;
-            const immutableData = await this._immutableStorage.get(proofEntity.immutableStorageId);
-            if (core.Is.uint8Array(immutableData)) {
-                proofModel = core.ObjectHelper.fromBytes(immutableData);
-                if (core.Is.object(proofModel.proof) && core.Is.object(proofObject)) {
-                    if (proofModel.proof.cryptosuite !== standardsW3cDid.DidCryptoSuites.EdDSAJcs2022) {
+            const immutableResult = await this._verifiableStorage.get(proofEntity.verifiableStorageId);
+            if (core.Is.uint8Array(immutableResult.data)) {
+                proofJsonLd = core.ObjectHelper.fromBytes(immutableResult.data);
+                const unsecureDocument = core.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 (!core.Is.empty(receiptContext)) {
+                    proofJsonLd["@context"] = dataJsonLd.JsonLdProcessor.combineContexts(proofJsonLd["@context"], receiptContext);
+                }
+                if (verify && core.Is.object(proofJsonLd.proof)) {
+                    if (proofJsonLd.proof.cryptosuite !== standardsW3cDid.DidCryptoSuites.EdDSAJcs2022) {
                         failure = immutableProofModels.ImmutableProofFailure.CryptoSuiteMismatch;
                     }
-                    else if (proofModel.proof.type !== standardsW3cDid.DidTypes.DataIntegrityProof) {
+                    else if (proofJsonLd.proof.type !== standardsW3cDid.ProofTypes.DataIntegrityProof) {
                         failure = immutableProofModels.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;
@@ -612,98 +665,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) {
-        const canonicalDocument = core.JsonHelper.canonicalize(core.ObjectHelper.omit(immutableProof, ["proof"]));
-        const proofConfigKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofConfigKeyId}`);
-        const proofConfigHash = crypto.Sha256.sum256(proofConfigKey.privateKey);
-        const transformedDocumentHash = crypto.Sha256.sum256(core.Converter.utf8ToBytes(canonicalDocument));
-        const hashData = new Uint8Array(proofConfigHash.length + transformedDocumentHash.length);
-        hashData.set(proofConfigHash);
-        hashData.set(transformedDocumentHash, proofConfigHash.length);
-        return hashData;
-    }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class describing the immutable proof.
- */
-exports.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([
-    entity.property({ type: "string", isPrimary: true }),
-    __metadata("design:type", String)
-], exports.ImmutableProof.prototype, "id", void 0);
-__decorate([
-    entity.property({ type: "string" }),
-    __metadata("design:type", String)
-], exports.ImmutableProof.prototype, "nodeIdentity", void 0);
-__decorate([
-    entity.property({ type: "string" }),
-    __metadata("design:type", String)
-], exports.ImmutableProof.prototype, "userIdentity", void 0);
-__decorate([
-    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
-    __metadata("design:type", String)
-], exports.ImmutableProof.prototype, "dateCreated", void 0);
-__decorate([
-    entity.property({ type: "string" }),
-    __metadata("design:type", String)
-], exports.ImmutableProof.prototype, "proofObjectId", void 0);
-__decorate([
-    entity.property({ type: "string" }),
-    __metadata("design:type", String)
-], exports.ImmutableProof.prototype, "proofObjectHash", void 0);
-__decorate([
-    entity.property({ type: "string" }),
-    __metadata("design:type", String)
-], exports.ImmutableProof.prototype, "immutableStorageId", void 0);
-exports.ImmutableProof = __decorate([
-    entity.entity()
-], exports.ImmutableProof);
-
 const restEntryPoints = [
     {
         name: "immutable-proof",