@twin.org/immutable-proof-service 0.0.1-next.2 → 0.0.1-next.21

package/dist/cjs/index.cjs

@@ -1,18 +1,85 @@
 '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');
 
+// 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);
+
 /**
  * The source used when communicating about these routes.
  */
@@ -48,7 +115,7 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                     request: {
                         body: {
                             proofObject: {
-                                "@context": "http://schema.org",
+                                "@context": "https://schema.org",
                                 type: "Person",
                                 name: "John Smith"
                             }
@@ -108,7 +175,10 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                         id: "immutableProofGetResponseExample",
                         response: {
                             body: {
-                                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                "@context": [
+                                    immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                    immutableProofModels.ImmutableProofTypes.ContextRootCommon
+                                ],
                                 type: immutableProofModels.ImmutableProofTypes.ImmutableProof,
                                 id: "ais:1234567890",
                                 userIdentity: "user-1",
@@ -138,7 +208,10 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                                 [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                "@context": [
+                                    immutableProofModels.ImmutableProofTypes.ContextRoot,
+                                    immutableProofModels.ImmutableProofTypes.ContextRootCommon
+                                ],
                                 type: immutableProofModels.ImmutableProofTypes.ImmutableProof,
                                 id: "ais:1234567890",
                                 userIdentity: "user-1",
@@ -166,8 +239,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 +250,6 @@ function generateRestRoutesImmutableProof(baseRouteName, componentName) {
                     request: {
                         pathParams: {
                             id: "ais:1234567890"
-                        },
-                        body: {
-                            proofObject: {
-                                "@context": "http://schema.org",
-                                type: "Person",
-                                name: "John Smith"
-                            }
                         }
                     }
                 }
@@ -279,10 +345,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
@@ -331,39 +396,50 @@ class ImmutableProofService {
      */
     _immutableStorage;
     /**
-     * The assertion method id to use for the proofs.
+     * The background task connector.
      * @internal
      */
-    _assertionMethodId;
+    _backgroundTaskConnector;
     /**
-     * The proof config key id to use for the proofs.
+     * The event bus component.
      * @internal
      */
-    _proofConfigKeyId;
+    _eventBusComponent;
     /**
-     * Are we currently processing proofs.
+     * The verification method id to use for the proofs.
      * @internal
      */
-    _processing;
+    _verificationMethodId;
+    /**
+     * The proof hash key id to use for the proofs.
+     * @internal
+     */
+    _proofHashKeyId;
+    /**
+     * 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-proof".
-     * @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-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");
+        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._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.
@@ -393,7 +469,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._verificationMethodId,
+                hashData: core.Converter.bytesToHex(hashData)
+            };
+            await this._backgroundTaskConnector.create("immutable-proof", proofTaskPayload);
             return new core.Urn(ImmutableProofService.NAMESPACE, id).toString();
         }
         catch (error) {
@@ -416,7 +501,7 @@ class ImmutableProofService {
             });
         }
         try {
-            const { immutableProof } = await this.internalGet(id);
+            const { immutableProof } = await this.internalGet(id, false);
             const compacted = await dataJsonLd.JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
             return compacted;
         }
@@ -427,11 +512,10 @@ class ImmutableProofService {
     /**
      * Verify an authentication 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,7 +525,7 @@ class ImmutableProofService {
             });
         }
         try {
-            const { verified, failure } = await this.internalGet(id, proofObject);
+            const { verified, failure } = await this.internalGet(id, true);
             return {
                 "@context": immutableProofModels.ImmutableProofTypes.ContextRoot,
                 type: immutableProofModels.ImmutableProofTypes.ImmutableProofVerification,
@@ -507,13 +591,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, immutableProofModels.ImmutableProofTypes.ContextRootCommon],
             type: immutableProofModels.ImmutableProofTypes.ImmutableProof,
             id: proofEntity.id,
             userIdentity: proofEntity.userIdentity,
@@ -523,74 +603,62 @@ class ImmutableProofService {
         return model;
     }
     /**
-     * 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"] = [
+                    immutableProofModels.ImmutableProofTypes.ContextRoot,
+                    immutableProofModels.ImmutableProofTypes.ContextRootCommon,
+                    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);
+                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.
      * @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 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);
-                if (core.Is.object(proofModel.proof) && core.Is.object(proofObject)) {
+            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 (verify && core.Is.object(proofModel.proof)) {
                     if (proofModel.proof.cryptosuite !== standardsW3cDid.DidCryptoSuites.EdDSAJcs2022) {
                         failure = immutableProofModels.ImmutableProofFailure.CryptoSuiteMismatch;
                     }
@@ -626,84 +694,21 @@ 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, immutableProofModels.ImmutableProofTypes.ContextRootCommon];
+        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;
     }
 }
 
-// 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",