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

package/dist/cjs/index.cjs

@@ -4,14 +4,14 @@ 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 entity = require('@twin.org/entity');
 
 /**
  * The source used when communicating about these routes.
@@ -197,6 +197,8 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                         id: "immutableProofVerifyResponseExample",
                         response: {
                             body: {
+                                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                type: immutableProofModels.ImmutableProofTypes.ImmutableProofVerification,
                                 verified: true
                             }
                         }
@@ -210,6 +212,8 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                         id: "immutableProofVerifyResponseFailExample",
                         response: {
                             body: {
+                                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                type: immutableProofModels.ImmutableProofTypes.ImmutableProofVerification,
                                 verified: false,
                                 failure: immutableProofModels.ImmutableProofFailure.ProofTypeMismatch
                             }
@@ -276,9 +280,13 @@ async function immutableProofVerify(httpRequestContext, componentName, 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);
     return {
+        headers: {
+            [web.HeaderTypes.ContentType]: mimeType === "json" ? web.MimeTypes.Json : web.MimeTypes.JsonLd
+        },
         body: result
     };
 }
@@ -322,40 +330,49 @@ class ImmutableProofService {
      * @internal
      */
     _immutableStorage;
+    /**
+     * The background task connector.
+     * @internal
+     */
+    _backgroundTaskConnector;
     /**
      * The assertion method id to use for the proofs.
      * @internal
      */
     _assertionMethodId;
     /**
-     * The proof config key id to use for the proofs.
+     * The proof hash key id to use for the proofs.
      * @internal
      */
-    _proofConfigKeyId;
+    _proofHashKeyId;
     /**
-     * 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-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 = 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-proof");
-        this._identityConnector = identityModels.IdentityConnectorFactory.get(options?.identityConnectorType ?? "identity");
+        this._immutableStorage = immutableStorageModels.ImmutableStorageConnectorFactory.get(options?.immutableStorageType ?? "immutable-storage");
+        this._identityConnectorType = options?.identityConnectorType ?? "identity";
+        this._identityConnector = identityModels.IdentityConnectorFactory.get(this._identityConnectorType);
+        this._backgroundTaskConnector = backgroundTaskModels.BackgroundTaskConnectorFactory.get(options?.backgroundTaskConnectorType ?? "background-task");
         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._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof-assertion";
+        this._proofHashKeyId = this._config.proofHashKeyId ?? "immutable-proof-hash";
+        this._backgroundTaskConnector.registerHandler("immutable-proof", "@twin.org/immutable-proof-task", "processProofTask", async (task) => {
+            await this.finaliseTask(task);
+        });
     }
     /**
      * Create a new authentication proof.
@@ -385,7 +402,16 @@ class ImmutableProofService {
                 proofObjectHash: core.Converter.bytesToBase64(hash)
             };
             await this._proofStorage.set(proofEntity);
-            this.startProcessingProofs();
+            const immutableProof = this.proofEntityToJsonLd(proofEntity);
+            const hashData = await this.generateHashData(proofEntity.nodeIdentity, immutableProof);
+            const proofTaskPayload = {
+                proofId: id,
+                nodeIdentity,
+                identityConnectorType: this._identityConnectorType,
+                assertionMethodId: this._assertionMethodId,
+                hashData: core.Converter.bytesToHex(hashData)
+            };
+            await this._backgroundTaskConnector.create("immutable-proof", proofTaskPayload);
             return new core.Urn(ImmutableProofService.NAMESPACE, id).toString();
         }
         catch (error) {
@@ -435,6 +461,8 @@ class ImmutableProofService {
         try {
             const { verified, failure } = await this.internalGet(id, proofObject);
             return {
+                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                type: immutableProofModels.ImmutableProofTypes.ImmutableProofVerification,
                 verified,
                 failure
             };
@@ -497,13 +525,9 @@ class ImmutableProofService {
      * @returns The model.
      * @internal
      */
-    proofEntityToModel(proofEntity) {
+    proofEntityToJsonLd(proofEntity) {
         const model = {
-            "@context": [
-                immutableProofModels.ImmutableProofTypes.ContextRoot,
-                dataSchemaOrg.SchemaOrgTypes.ContextRoot,
-                standardsW3cDid.DidContexts.ContextVCDataIntegrity
-            ],
+            "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
             type: immutableProofModels.ImmutableProofTypes.ImmutableProof,
             id: proofEntity.id,
             userIdentity: proofEntity.userIdentity,
@@ -513,48 +537,29 @@ class ImmutableProofService {
         return model;
     }
     /**
-     * Start processing proofs.
-     * @returns Nothing.
+     * Process a proof.
+     * @param proofEntity The proof entity to process.
      * @internal
      */
-    startProcessingProofs() {
-        if (!this._processing) {
-            setTimeout(async () => {
-                await this.processProofs();
-            }, 0);
-        }
-    }
-    /**
-     * Process the proofs.
-     * @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"] = [
+                    immutableProofModels.ImmutableProofTypes.ContextRoot,
+                    standardsW3cDid.DidContexts.ContextVCDataIntegrity
+                ];
+                immutableProof.proof = task.result.proof;
+                if (core.Is.stringValue(immutableProof.proof.created)) {
+                    proofEntity.dateCreated = immutableProof.proof.created;
+                }
+                const compacted = await dataJsonLd.JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
+                const immutableStoreResult = await this._immutableStorage.store(proofEntity.nodeIdentity, core.ObjectHelper.toBytes(compacted));
+                proofEntity.immutableStorageId = immutableStoreResult.id;
+                await this._proofStorage.set(proofEntity);
             }
-        ], 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();
         }
     }
     /**
@@ -572,14 +577,19 @@ class ImmutableProofService {
         if (core.Is.empty(proofEntity)) {
             throw new core.NotFoundError(this.CLASS_NAME, "proofNotFound", id);
         }
-        let proofModel = await this.proofEntityToModel(proofEntity);
+        let proofModel = await this.proofEntityToJsonLd(proofEntity);
         let verified = false;
         let failure = immutableProofModels.ImmutableProofFailure.NotIssued;
         if (core.Is.stringValue(proofEntity.immutableStorageId)) {
             failure = immutableProofModels.ImmutableProofFailure.ProofMissing;
-            const immutableData = await this._immutableStorage.get(proofEntity.immutableStorageId);
-            if (core.Is.uint8Array(immutableData)) {
-                proofModel = core.ObjectHelper.fromBytes(immutableData);
+            const immutableResult = await this._immutableStorage.get(proofEntity.immutableStorageId);
+            if (core.Is.uint8Array(immutableResult.data)) {
+                proofModel = core.ObjectHelper.fromBytes(immutableResult.data);
+                proofModel.immutableReceipt = immutableResult.receipt;
+                // As we are adding the receipt to the data we update its context
+                if (core.Is.array(proofModel["@context"])) {
+                    proofModel["@context"].push(immutableStorageModels.ImmutableStorageTypes.ContextRoot);
+                }
                 if (core.Is.object(proofModel.proof) && core.Is.object(proofObject)) {
                     if (proofModel.proof.cryptosuite !== standardsW3cDid.DidCryptoSuites.EdDSAJcs2022) {
                         failure = immutableProofModels.ImmutableProofFailure.CryptoSuiteMismatch;
@@ -616,13 +626,17 @@ class ImmutableProofService {
      * @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);
+        // 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 = core.ObjectHelper.omit(immutableProof, ["proof", "immutableReceipt"]);
+        object["@context"] = immutableProofModels.ImmutableProofTypes.ContextRoot;
+        const canonicalDocument = core.JsonHelper.canonicalize(object);
+        const proofKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofHashKeyId}`);
+        const proofHash = crypto.Sha256.sum256(proofKey.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);
+        const hashData = new Uint8Array(proofHash.length + transformedDocumentHash.length);
+        hashData.set(proofHash);
+        hashData.set(transformedDocumentHash, proofHash.length);
         return hashData;
     }
 }

package/dist/esm/index.mjs

@@ -2,14 +2,14 @@ import { Guards, ComponentFactory, StringHelper, Validation, Converter, RandomHe
 import { ImmutableProofTypes, ImmutableProofFailure } from '@twin.org/immutable-proof-models';
 import { DidContexts, DidTypes, DidCryptoSuites } from '@twin.org/standards-w3c-did';
 import { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
+import { BackgroundTaskConnectorFactory, TaskStatus } from '@twin.org/background-task-models';
 import { Blake2b, Sha256 } from '@twin.org/crypto';
 import { JsonLdHelper, JsonLdProcessor } from '@twin.org/data-json-ld';
-import { SchemaOrgDataTypes, SchemaOrgTypes } from '@twin.org/data-schema-org';
-import { ComparisonOperator, SortDirection, property, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
 import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
 import { IdentityConnectorFactory } from '@twin.org/identity-models';
-import { ImmutableStorageConnectorFactory } from '@twin.org/immutable-storage-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';
 
 /**
  * The source used when communicating about these routes.
@@ -195,6 +195,8 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                         id: "immutableProofVerifyResponseExample",
                         response: {
                             body: {
+                                "@context": ImmutableProofTypes.ContextRoot,
+                                type: ImmutableProofTypes.ImmutableProofVerification,
                                 verified: true
                             }
                         }
@@ -208,6 +210,8 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                         id: "immutableProofVerifyResponseFailExample",
                         response: {
                             body: {
+                                "@context": ImmutableProofTypes.ContextRoot,
+                                type: ImmutableProofTypes.ImmutableProofVerification,
                                 verified: false,
                                 failure: ImmutableProofFailure.ProofTypeMismatch
                             }
@@ -274,9 +278,13 @@ async function immutableProofVerify(httpRequestContext, componentName, 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);
     return {
+        headers: {
+            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
+        },
         body: result
     };
 }
@@ -320,40 +328,49 @@ class ImmutableProofService {
      * @internal
      */
     _immutableStorage;
+    /**
+     * The background task connector.
+     * @internal
+     */
+    _backgroundTaskConnector;
     /**
      * The assertion method id to use for the proofs.
      * @internal
      */
     _assertionMethodId;
     /**
-     * The proof config key id to use for the proofs.
+     * The proof hash key id to use for the proofs.
      * @internal
      */
-    _proofConfigKeyId;
+    _proofHashKeyId;
     /**
-     * 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-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-proof");
-        this._identityConnector = IdentityConnectorFactory.get(options?.identityConnectorType ?? "identity");
+        this._immutableStorage = ImmutableStorageConnectorFactory.get(options?.immutableStorageType ?? "immutable-storage");
+        this._identityConnectorType = options?.identityConnectorType ?? "identity";
+        this._identityConnector = IdentityConnectorFactory.get(this._identityConnectorType);
+        this._backgroundTaskConnector = BackgroundTaskConnectorFactory.get(options?.backgroundTaskConnectorType ?? "background-task");
         this._config = options?.config ?? {};
-        this._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof";
-        this._proofConfigKeyId = this._config.proofConfigKeyId ?? "immutable-proof";
-        SchemaOrgDataTypes.registerRedirects();
-        this._processing = false;
+        this._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof-assertion";
+        this._proofHashKeyId = this._config.proofHashKeyId ?? "immutable-proof-hash";
+        this._backgroundTaskConnector.registerHandler("immutable-proof", "@twin.org/immutable-proof-task", "processProofTask", async (task) => {
+            await this.finaliseTask(task);
+        });
     }
     /**
      * Create a new authentication proof.
@@ -383,7 +400,16 @@ class ImmutableProofService {
                 proofObjectHash: Converter.bytesToBase64(hash)
             };
             await this._proofStorage.set(proofEntity);
-            this.startProcessingProofs();
+            const immutableProof = this.proofEntityToJsonLd(proofEntity);
+            const hashData = await this.generateHashData(proofEntity.nodeIdentity, immutableProof);
+            const proofTaskPayload = {
+                proofId: id,
+                nodeIdentity,
+                identityConnectorType: this._identityConnectorType,
+                assertionMethodId: this._assertionMethodId,
+                hashData: Converter.bytesToHex(hashData)
+            };
+            await this._backgroundTaskConnector.create("immutable-proof", proofTaskPayload);
             return new Urn(ImmutableProofService.NAMESPACE, id).toString();
         }
         catch (error) {
@@ -433,6 +459,8 @@ class ImmutableProofService {
         try {
             const { verified, failure } = await this.internalGet(id, proofObject);
             return {
+                "@context": ImmutableProofTypes.ContextRoot,
+                type: ImmutableProofTypes.ImmutableProofVerification,
                 verified,
                 failure
             };
@@ -495,13 +523,9 @@ class ImmutableProofService {
      * @returns The model.
      * @internal
      */
-    proofEntityToModel(proofEntity) {
+    proofEntityToJsonLd(proofEntity) {
         const model = {
-            "@context": [
-                ImmutableProofTypes.ContextRoot,
-                SchemaOrgTypes.ContextRoot,
-                DidContexts.ContextVCDataIntegrity
-            ],
+            "@context": ImmutableProofTypes.ContextRoot,
             type: ImmutableProofTypes.ImmutableProof,
             id: proofEntity.id,
             userIdentity: proofEntity.userIdentity,
@@ -511,48 +535,29 @@ class ImmutableProofService {
         return model;
     }
     /**
-     * Start processing proofs.
-     * @returns Nothing.
+     * Process a proof.
+     * @param proofEntity The proof entity to process.
      * @internal
      */
-    startProcessingProofs() {
-        if (!this._processing) {
-            setTimeout(async () => {
-                await this.processProofs();
-            }, 0);
-        }
-    }
-    /**
-     * Process the proofs.
-     * @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: ComparisonOperator.Equals,
-            value: undefined
-        }, [
-            {
-                property: "dateCreated",
-                sortDirection: SortDirection.Ascending
+    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"] = [
+                    ImmutableProofTypes.ContextRoot,
+                    DidContexts.ContextVCDataIntegrity
+                ];
+                immutableProof.proof = task.result.proof;
+                if (Is.stringValue(immutableProof.proof.created)) {
+                    proofEntity.dateCreated = immutableProof.proof.created;
+                }
+                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);
             }
-        ], 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 JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
-            proofEntity.immutableStorageId = await this._immutableStorage.store(proofEntity.nodeIdentity, 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();
         }
     }
     /**
@@ -570,14 +575,19 @@ class ImmutableProofService {
         if (Is.empty(proofEntity)) {
             throw new NotFoundError(this.CLASS_NAME, "proofNotFound", id);
         }
-        let proofModel = await this.proofEntityToModel(proofEntity);
+        let proofModel = await this.proofEntityToJsonLd(proofEntity);
         let verified = false;
         let failure = ImmutableProofFailure.NotIssued;
         if (Is.stringValue(proofEntity.immutableStorageId)) {
             failure = ImmutableProofFailure.ProofMissing;
-            const immutableData = await this._immutableStorage.get(proofEntity.immutableStorageId);
-            if (Is.uint8Array(immutableData)) {
-                proofModel = ObjectHelper.fromBytes(immutableData);
+            const immutableResult = await this._immutableStorage.get(proofEntity.immutableStorageId);
+            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);
+                }
                 if (Is.object(proofModel.proof) && Is.object(proofObject)) {
                     if (proofModel.proof.cryptosuite !== DidCryptoSuites.EdDSAJcs2022) {
                         failure = ImmutableProofFailure.CryptoSuiteMismatch;
@@ -614,13 +624,17 @@ class ImmutableProofService {
      * @internal
      */
     async generateHashData(nodeIdentity, immutableProof) {
-        const canonicalDocument = JsonHelper.canonicalize(ObjectHelper.omit(immutableProof, ["proof"]));
-        const proofConfigKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofConfigKeyId}`);
-        const proofConfigHash = Sha256.sum256(proofConfigKey.privateKey);
+        // 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(proofConfigHash.length + transformedDocumentHash.length);
-        hashData.set(proofConfigHash);
-        hashData.set(transformedDocumentHash, proofConfigHash.length);
+        const hashData = new Uint8Array(proofHash.length + transformedDocumentHash.length);
+        hashData.set(proofHash);
+        hashData.set(transformedDocumentHash, proofHash.length);
         return hashData;
     }
 }

package/dist/types/immutableProofService.d.ts

@@ -1,5 +1,5 @@
 import { type IJsonLdNodeObject } from "@twin.org/data-json-ld";
-import { ImmutableProofFailure, type IImmutableProof, type IImmutableProofComponent } from "@twin.org/immutable-proof-models";
+import { type IImmutableProof, type IImmutableProofComponent, type IImmutableProofVerification } from "@twin.org/immutable-proof-models";
 import type { IImmutableProofServiceConfig } from "./models/IImmutableProofServiceConfig";
 /**
  * Class for performing immutable proof operations.
@@ -19,15 +19,17 @@ export declare class ImmutableProofService implements IImmutableProofComponent {
      * @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-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?: {
         vaultConnectorType?: string;
         immutableProofEntityStorageType?: string;
         immutableStorageType?: string;
-        config?: IImmutableProofServiceConfig;
         identityConnectorType?: string;
+        backgroundTaskConnectorType?: string;
+        config?: IImmutableProofServiceConfig;
     });
     /**
      * Create a new authentication proof.
@@ -51,10 +53,7 @@ export declare class ImmutableProofService implements IImmutableProofComponent {
      * @returns The result of the verification and any failures.
      * @throws NotFoundError if the proof is not found.
      */
-    verify(id: string, proofObject: IJsonLdNodeObject): Promise<{
-        verified: boolean;
-        failure?: ImmutableProofFailure;
-    }>;
+    verify(id: string, proofObject: IJsonLdNodeObject): Promise<IImmutableProofVerification>;
     /**
      * Remove the immutable storage for the proof.
      * @param id The id of the proof to remove the storage from.

package/dist/types/models/IImmutableProofServiceConfig.d.ts

@@ -4,12 +4,12 @@
 export interface IImmutableProofServiceConfig {
     /**
      * The assertion method id to use for the stream.
-     * @default immutable-proof
+     * @default immutable-proof-assertion
      */
     assertionMethodId?: string;
     /**
-     * The key to use in the proof config.
-     * @default immutable-proof
+     * The key to use in the proof hash.
+     * @default immutable-proof-hash
      */
-    proofConfigKeyId?: string;
+    proofHashKeyId?: string;
 }

package/docs/changelog.md

@@ -1,5 +1,5 @@
 # @twin.org/immutable-proof-service - Changelog
 
-## v0.0.1-next.1
+## v0.0.1-next.11
 
 - Initial Release

package/docs/open-api/spec.json

@@ -189,7 +189,7 @@
                         "content": {
                             "application/json": {
                                 "schema": {
-                                    "$ref": "#/components/schemas/ImmutableProof"
+                                    "$ref": "https://schema.twindev.org/immutable-proof/ImmutableProof"
                                 },
                                 "examples": {
                                     "immutableProofGetResponseExample": {
@@ -214,7 +214,7 @@
                             },
                             "application/ld+json": {
                                 "schema": {
-                                    "$ref": "#/components/schemas/ImmutableProof"
+                                    "$ref": "https://schema.twindev.org/immutable-proof/ImmutableProof"
                                 },
                                 "examples": {
                                     "immutableProofJsonLdGetResponseExample": {
@@ -344,6 +344,15 @@
                         },
                         "style": "simple",
                         "example": "ais:1234567890"
+                    },
+                    {
+                        "name": "accept",
+                        "in": "header",
+                        "required": true,
+                        "schema": {
+                            "type": "string"
+                        },
+                        "style": "simple"
                     }
                 ],
                 "security": [
@@ -379,16 +388,20 @@
                         "content": {
                             "application/json": {
                                 "schema": {
-                                    "$ref": "#/components/schemas/ImmutableProofVerifyResponse"
+                                    "$ref": "https://schema.twindev.org/immutable-proof/ImmutableProofVerification"
                                 },
                                 "examples": {
                                     "immutableProofVerifyResponseExample": {
                                         "value": {
+                                            "@context": "https://schema.twindev.org/immutable-proof/",
+                                            "type": "ImmutableProofVerification",
                                             "verified": true
                                         }
                                     },
                                     "immutableProofVerifyResponseFailExample": {
                                         "value": {
+                                            "@context": "https://schema.twindev.org/immutable-proof/",
+                                            "type": "ImmutableProofVerification",
                                             "verified": false,
                                             "failure": "proofTypeMismatch"
                                         }
@@ -643,66 +656,6 @@
                 "additionalProperties": false,
                 "description": "Model to describe serialized error."
             },
-            "ImmutableProof": {
-                "type": "object",
-                "properties": {
-                    "@context": {
-                        "anyOf": [
-                            {
-                                "type": "string",
-                                "const": "https://schema.twindev.org/immutable-proof/"
-                            },
-                            {
-                                "type": "array",
-                                "minItems": 1,
-                                "items": [
-                                    {
-                                        "type": "string",
-                                        "const": "https://schema.twindev.org/immutable-proof/"
-                                    }
-                                ],
-                                "additionalItems": {
-                                    "type": "string"
-                                }
-                            }
-                        ],
-                        "description": "JSON-LD Context."
-                    },
-                    "type": {
-                        "type": "string",
-                        "const": "ImmutableProof",
-                        "description": "JSON-LD Type."
-                    },
-                    "id": {
-                        "type": "string",
-                        "description": "The id of the proof."
-                    },
-                    "userIdentity": {
-                        "type": "string",
-                        "description": "The id of the user who created the proof."
-                    },
-                    "proofObjectId": {
-                        "type": "string",
-                        "description": "The id of the object associated with the proof."
-                    },
-                    "proofObjectHash": {
-                        "type": "string",
-                        "description": "The hash of the object associated with the proof."
-                    },
-                    "proof": {
-                        "$ref": "#/components/schemas/DidProof"
-                    }
-                },
-                "required": [
-                    "@context",
-                    "type",
-                    "id",
-                    "userIdentity",
-                    "proofObjectHash"
-                ],
-                "additionalProperties": false,
-                "description": "Interface describing an immutable proof state."
-            },
             "ImmutableProofCreateRequest": {
                 "type": "object",
                 "properties": {
@@ -716,36 +669,6 @@
                 "additionalProperties": false,
                 "description": "The parameters from the body."
             },
-            "ImmutableProofFailure": {
-                "anyOf": [
-                    {
-                        "type": "string",
-                        "const": "notIssued",
-                        "description": "Proof not yes issued."
-                    },
-                    {
-                        "type": "string",
-                        "const": "proofMissing",
-                        "description": "Proof missing."
-                    },
-                    {
-                        "type": "string",
-                        "const": "cryptoSuiteMismatch",
-                        "description": "Crypto suite mismatch."
-                    },
-                    {
-                        "type": "string",
-                        "const": "proofTypeMismatch",
-                        "description": "Proof type."
-                    },
-                    {
-                        "type": "string",
-                        "const": "signatureMismatch",
-                        "description": "Signature mismatch."
-                    }
-                ],
-                "description": "The failure reason of the proof."
-            },
             "ImmutableProofVerifyRequest": {
                 "type": "object",
                 "properties": {
@@ -759,23 +682,6 @@
                 "additionalProperties": false,
                 "description": "The parameters from the body."
             },
-            "ImmutableProofVerifyResponse": {
-                "type": "object",
-                "properties": {
-                    "verified": {
-                        "type": "boolean",
-                        "description": "Was the proof verified."
-                    },
-                    "failure": {
-                        "$ref": "#/components/schemas/ImmutableProofFailure"
-                    }
-                },
-                "required": [
-                    "verified"
-                ],
-                "additionalProperties": false,
-                "description": "The response body."
-            },
             "NotFoundResponse": {
                 "type": "object",
                 "additionalProperties": false,

package/docs/reference/classes/ImmutableProofService.md

@@ -30,16 +30,20 @@ The entity storage for proofs, defaults to "immutable-proof".
 
 • **options.immutableStorageType?**: `string`
 
-The immutable storage, defaults to "immutable-proof".
-
-• **options.config?**: [`IImmutableProofServiceConfig`](../interfaces/IImmutableProofServiceConfig.md)
-
-The configuration for the connector.
+The immutable storage, defaults to "immutable-storage".
 
 • **options.identityConnectorType?**: `string`
 
 The identity connector type, defaults to "identity".
 
+• **options.backgroundTaskConnectorType?**: `string`
+
+The background task connector type, defaults to "background-task".
+
+• **options.config?**: [`IImmutableProofServiceConfig`](../interfaces/IImmutableProofServiceConfig.md)
+
+The configuration for the connector.
+
 #### Returns
 
 [`ImmutableProofService`](ImmutableProofService.md)
@@ -128,7 +132,7 @@ NotFoundError if the proof is not found.
 
 ### verify()
 
-> **verify**(`id`, `proofObject`): `Promise`\<`object`\>
+> **verify**(`id`, `proofObject`): `Promise`\<`IImmutableProofVerification`\>
 
 Verify an authentication proof.
 
@@ -144,18 +148,10 @@ The object to verify as JSON-LD.
 
 #### Returns
 
-`Promise`\<`object`\>
+`Promise`\<`IImmutableProofVerification`\>
 
 The result of the verification and any failures.
 
-##### verified
-
-> **verified**: `boolean`
-
-##### failure?
-
-> `optional` **failure**: `ImmutableProofFailure`
-
 #### Throws
 
 NotFoundError if the proof is not found.

package/docs/reference/interfaces/IImmutableProofServiceConfig.md

@@ -13,19 +13,19 @@ The assertion method id to use for the stream.
 #### Default
 
 ```ts
-immutable-proof
+immutable-proof-assertion
 ```
 
 ***
 
-### proofConfigKeyId?
+### proofHashKeyId?
 
-> `optional` **proofConfigKeyId**: `string`
+> `optional` **proofHashKeyId**: `string`
 
-The key to use in the proof config.
+The key to use in the proof hash.
 
 #### Default
 
 ```ts
-immutable-proof
+immutable-proof-hash
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/immutable-proof-service",
-	"version": "0.0.1-next.1",
+	"version": "0.0.1-next.11",
 	"description": "Immutable proof contract implementation and REST endpoint definitions",
 	"repository": {
 		"type": "git",
@@ -15,6 +15,7 @@
 	},
 	"dependencies": {
 		"@twin.org/api-models": "next",
+		"@twin.org/background-task-models": "next",
 		"@twin.org/core": "next",
 		"@twin.org/crypto": "next",
 		"@twin.org/data-json-ld": "next",
@@ -22,7 +23,8 @@
 		"@twin.org/entity": "next",
 		"@twin.org/entity-storage-models": "next",
 		"@twin.org/identity-models": "next",
-		"@twin.org/immutable-proof-models": "0.0.1-next.1",
+		"@twin.org/immutable-proof-models": "0.0.1-next.11",
+		"@twin.org/immutable-proof-task": "0.0.1-next.11",
 		"@twin.org/immutable-storage-models": "next",
 		"@twin.org/nameof": "next",
 		"@twin.org/standards-w3c-did": "next",
@@ -39,7 +41,7 @@
 			"import": "./dist/esm/index.mjs",
 			"types": "./dist/types/index.d.ts"
 		},
-		"./locales": "./locales"
+		"./locales/*.json": "./locales/*.json"
 	},
 	"files": [
 		"dist/cjs",