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

package/dist/cjs/index.cjs

@@ -6,7 +6,6 @@ var standardsW3cDid = require('@twin.org/standards-w3c-did');
 var web = require('@twin.org/web');
 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');
@@ -362,7 +361,6 @@ class ImmutableProofService {
         this._config = options?.config ?? {};
         this._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof";
         this._proofConfigKeyId = this._config.proofConfigKeyId ?? "immutable-proof";
-        dataSchemaOrg.SchemaOrgDataTypes.registerRedirects();
         this._processing = false;
     }
     /**
@@ -393,7 +391,7 @@ class ImmutableProofService {
                 proofObjectHash: core.Converter.bytesToBase64(hash)
             };
             await this._proofStorage.set(proofEntity);
-            this.startProcessingProofs();
+            this.startProcessingProofs(0);
             return new core.Urn(ImmutableProofService.NAMESPACE, id).toString();
         }
         catch (error) {
@@ -507,13 +505,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,
@@ -524,14 +518,16 @@ class ImmutableProofService {
     }
     /**
      * Start processing proofs.
+     * @param interval The interval to process proofs.
      * @returns Nothing.
      * @internal
      */
-    startProcessingProofs() {
+    startProcessingProofs(interval) {
         if (!this._processing) {
+            this._processing = true;
             setTimeout(async () => {
                 await this.processProofs();
-            }, 0);
+            }, interval);
         }
     }
     /**
@@ -539,32 +535,48 @@ class ImmutableProofService {
      * @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
+        let remainingProofs = 0;
+        try {
+            // 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
+                }
+            ], undefined, undefined, 2);
+            remainingProofs = pendingProofs.entities.length;
+            if (remainingProofs > 0) {
+                const proofEntity = pendingProofs.entities[0];
+                const immutableProof = this.proofEntityToJsonLd(proofEntity);
+                const hashData = await this.generateHashData(proofEntity.nodeIdentity, immutableProof);
+                // As we are adding the proof to the data we update its context
+                immutableProof["@context"] = [
+                    immutableProofModels.ImmutableProofTypes.ContextRoot,
+                    immutableStorageModels.ImmutableStorageTypes.ContextRoot,
+                    standardsW3cDid.DidContexts.ContextVCDataIntegrity
+                ];
+                immutableProof.proof = await this._identityConnector.createProof(proofEntity.nodeIdentity, `${proofEntity.nodeIdentity}#${this._assertionMethodId}`, hashData);
+                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);
+                remainingProofs--;
             }
-        ], 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();
+        finally {
+            // If there are still remaining proofs, start the timer again
+            this._processing = false;
+            if (remainingProofs > 0) {
+                this.startProcessingProofs(100);
+            }
         }
     }
     /**
@@ -582,14 +594,15 @@ 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;
                 if (core.Is.object(proofModel.proof) && core.Is.object(proofObject)) {
                     if (proofModel.proof.cryptosuite !== standardsW3cDid.DidCryptoSuites.EdDSAJcs2022) {
                         failure = immutableProofModels.ImmutableProofFailure.CryptoSuiteMismatch;
@@ -626,7 +639,11 @@ class ImmutableProofService {
      * @internal
      */
     async generateHashData(nodeIdentity, immutableProof) {
-        const canonicalDocument = core.JsonHelper.canonicalize(core.ObjectHelper.omit(immutableProof, ["proof"]));
+        // We hash the data for the proof with 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 proofConfigKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofConfigKeyId}`);
         const proofConfigHash = crypto.Sha256.sum256(proofConfigKey.privateKey);
         const transformedDocumentHash = crypto.Sha256.sum256(core.Converter.utf8ToBytes(canonicalDocument));

package/dist/esm/index.mjs

@@ -4,11 +4,10 @@ import { DidContexts, DidTypes, DidCryptoSuites } from '@twin.org/standards-w3c-
 import { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
 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';
 
 /**
@@ -360,7 +359,6 @@ class ImmutableProofService {
         this._config = options?.config ?? {};
         this._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof";
         this._proofConfigKeyId = this._config.proofConfigKeyId ?? "immutable-proof";
-        SchemaOrgDataTypes.registerRedirects();
         this._processing = false;
     }
     /**
@@ -391,7 +389,7 @@ class ImmutableProofService {
                 proofObjectHash: Converter.bytesToBase64(hash)
             };
             await this._proofStorage.set(proofEntity);
-            this.startProcessingProofs();
+            this.startProcessingProofs(0);
             return new Urn(ImmutableProofService.NAMESPACE, id).toString();
         }
         catch (error) {
@@ -505,13 +503,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,
@@ -522,14 +516,16 @@ class ImmutableProofService {
     }
     /**
      * Start processing proofs.
+     * @param interval The interval to process proofs.
      * @returns Nothing.
      * @internal
      */
-    startProcessingProofs() {
+    startProcessingProofs(interval) {
         if (!this._processing) {
+            this._processing = true;
             setTimeout(async () => {
                 await this.processProofs();
-            }, 0);
+            }, interval);
         }
     }
     /**
@@ -537,32 +533,48 @@ class ImmutableProofService {
      * @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
+        let remainingProofs = 0;
+        try {
+            // 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
+                }
+            ], undefined, undefined, 2);
+            remainingProofs = pendingProofs.entities.length;
+            if (remainingProofs > 0) {
+                const proofEntity = pendingProofs.entities[0];
+                const immutableProof = this.proofEntityToJsonLd(proofEntity);
+                const hashData = await this.generateHashData(proofEntity.nodeIdentity, immutableProof);
+                // As we are adding the proof to the data we update its context
+                immutableProof["@context"] = [
+                    ImmutableProofTypes.ContextRoot,
+                    ImmutableStorageTypes.ContextRoot,
+                    DidContexts.ContextVCDataIntegrity
+                ];
+                immutableProof.proof = await this._identityConnector.createProof(proofEntity.nodeIdentity, `${proofEntity.nodeIdentity}#${this._assertionMethodId}`, hashData);
+                if (Is.stringValue(immutableProof.proof.created)) {
+                    proofEntity.dateCreated = immutableProof.proof.created;
+                }
+                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);
+                remainingProofs--;
             }
-        ], 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();
+        finally {
+            // If there are still remaining proofs, start the timer again
+            this._processing = false;
+            if (remainingProofs > 0) {
+                this.startProcessingProofs(100);
+            }
         }
     }
     /**
@@ -580,14 +592,15 @@ 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;
                 if (Is.object(proofModel.proof) && Is.object(proofObject)) {
                     if (proofModel.proof.cryptosuite !== DidCryptoSuites.EdDSAJcs2022) {
                         failure = ImmutableProofFailure.CryptoSuiteMismatch;
@@ -624,7 +637,11 @@ class ImmutableProofService {
      * @internal
      */
     async generateHashData(nodeIdentity, immutableProof) {
-        const canonicalDocument = JsonHelper.canonicalize(ObjectHelper.omit(immutableProof, ["proof"]));
+        // We hash the data for the proof with 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 proofConfigKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofConfigKeyId}`);
         const proofConfigHash = Sha256.sum256(proofConfigKey.privateKey);
         const transformedDocumentHash = Sha256.sum256(Converter.utf8ToBytes(canonicalDocument));

package/dist/types/immutableProofService.d.ts

@@ -1,5 +1,5 @@
 import { type IJsonLdNodeObject } from "@twin.org/data-json-ld";
-import { type IImmutableProofVerification, 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.

package/docs/changelog.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/immutable-proof-service",
-	"version": "0.0.1-next.3",
+	"version": "0.0.1-next.5",
 	"description": "Immutable proof contract implementation and REST endpoint definitions",
 	"repository": {
 		"type": "git",
@@ -22,7 +22,7 @@
 		"@twin.org/entity": "next",
 		"@twin.org/entity-storage-models": "next",
 		"@twin.org/identity-models": "next",
-		"@twin.org/immutable-proof-models": "0.0.1-next.3",
+		"@twin.org/immutable-proof-models": "0.0.1-next.5",
 		"@twin.org/immutable-storage-models": "next",
 		"@twin.org/nameof": "next",
 		"@twin.org/standards-w3c-did": "next",