@twin.org/immutable-proof-service 0.0.1-next.6 → 0.0.1-next.8

package/dist/cjs/index.cjs

@@ -4,13 +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 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.
@@ -330,20 +331,20 @@ 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 assertion method id to use for the proofs.
      * @internal
      */
-    _proofConfigKeyId;
+    _assertionMethodId;
     /**
-     * Are we currently processing proofs.
+     * The proof hash key id to use for the proofs.
      * @internal
      */
-    _processing;
+    _proofHashKeyId;
     /**
      * Create a new instance of ImmutableProofService.
      * @param options The dependencies for the immutable proof connector.
@@ -352,16 +353,18 @@ class ImmutableProofService {
      * @param options.immutableProofEntityStorageType The entity storage for proofs, defaults to "immutable-proof".
      * @param options.immutableStorageType The immutable storage, defaults to "immutable-storage".
      * @param options.identityConnectorType The identity connector type, defaults to "identity".
+     * @param options.backgroundTaskConnectorType The background task connector type, defaults to "background-task".
      */
     constructor(options) {
         this._vaultConnector = 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._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";
-        this._processing = false;
+        this._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof-assertion";
+        this._proofHashKeyId = this._config.proofHashKeyId ?? "immutable-proof-hash";
+        this._backgroundTaskConnector.registerHandler("immutable-proof", async (proof) => this.processProof(proof));
     }
     /**
      * Create a new authentication proof.
@@ -391,7 +394,7 @@ class ImmutableProofService {
                 proofObjectHash: core.Converter.bytesToBase64(hash)
             };
             await this._proofStorage.set(proofEntity);
-            this.startProcessingProofs(0);
+            await this._backgroundTaskConnector.create("immutable-proof", proofEntity);
             return new core.Urn(ImmutableProofService.NAMESPACE, id).toString();
         }
         catch (error) {
@@ -517,66 +520,26 @@ class ImmutableProofService {
         return model;
     }
     /**
-     * Start processing proofs.
-     * @param interval The interval to process proofs.
-     * @returns Nothing.
+     * Process a proof.
+     * @param proofEntity The proof entity to process.
      * @internal
      */
-    startProcessingProofs(interval) {
-        if (!this._processing) {
-            this._processing = true;
-            setTimeout(async () => {
-                await this.processProofs();
-            }, interval);
-        }
-    }
-    /**
-     * Process the proofs.
-     * @internal
-     */
-    async processProofs() {
-        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,
-                    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--;
-            }
-        }
-        finally {
-            // If there are still remaining proofs, start the timer again
-            this._processing = false;
-            if (remainingProofs > 0) {
-                this.startProcessingProofs(100);
-            }
+    async processProof(proofEntity) {
+        const immutableProof = this.proofEntityToJsonLd(proofEntity);
+        const hashData = await this.generateHashData(proofEntity.nodeIdentity, immutableProof);
+        // As we are adding the proof to the data we update its context
+        immutableProof["@context"] = [
+            immutableProofModels.ImmutableProofTypes.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);
     }
     /**
      * Verify an authentication proof.
@@ -642,17 +605,17 @@ class ImmutableProofService {
      * @internal
      */
     async generateHashData(nodeIdentity, immutableProof) {
-        // We hash the data for the proof with the proof or immutable receipt for the proof
+        // 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 proofConfigKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofConfigKeyId}`);
-        const proofConfigHash = crypto.Sha256.sum256(proofConfigKey.privateKey);
+        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,13 +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 } from '@twin.org/background-task-models';
 import { Blake2b, Sha256 } from '@twin.org/crypto';
 import { JsonLdHelper, JsonLdProcessor } from '@twin.org/data-json-ld';
-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, 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.
@@ -328,20 +329,20 @@ 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 assertion method id to use for the proofs.
      * @internal
      */
-    _proofConfigKeyId;
+    _assertionMethodId;
     /**
-     * Are we currently processing proofs.
+     * The proof hash key id to use for the proofs.
      * @internal
      */
-    _processing;
+    _proofHashKeyId;
     /**
      * Create a new instance of ImmutableProofService.
      * @param options The dependencies for the immutable proof connector.
@@ -350,16 +351,18 @@ class ImmutableProofService {
      * @param options.immutableProofEntityStorageType The entity storage for proofs, defaults to "immutable-proof".
      * @param options.immutableStorageType The immutable storage, defaults to "immutable-storage".
      * @param options.identityConnectorType The identity connector type, defaults to "identity".
+     * @param options.backgroundTaskConnectorType The background task connector type, defaults to "background-task".
      */
     constructor(options) {
         this._vaultConnector = VaultConnectorFactory.get(options?.vaultConnectorType ?? "vault");
         this._proofStorage = EntityStorageConnectorFactory.get(options?.immutableProofEntityStorageType ?? StringHelper.kebabCase("ImmutableProof"));
         this._immutableStorage = ImmutableStorageConnectorFactory.get(options?.immutableStorageType ?? "immutable-storage");
         this._identityConnector = IdentityConnectorFactory.get(options?.identityConnectorType ?? "identity");
+        this._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";
-        this._processing = false;
+        this._assertionMethodId = this._config.assertionMethodId ?? "immutable-proof-assertion";
+        this._proofHashKeyId = this._config.proofHashKeyId ?? "immutable-proof-hash";
+        this._backgroundTaskConnector.registerHandler("immutable-proof", async (proof) => this.processProof(proof));
     }
     /**
      * Create a new authentication proof.
@@ -389,7 +392,7 @@ class ImmutableProofService {
                 proofObjectHash: Converter.bytesToBase64(hash)
             };
             await this._proofStorage.set(proofEntity);
-            this.startProcessingProofs(0);
+            await this._backgroundTaskConnector.create("immutable-proof", proofEntity);
             return new Urn(ImmutableProofService.NAMESPACE, id).toString();
         }
         catch (error) {
@@ -515,66 +518,26 @@ class ImmutableProofService {
         return model;
     }
     /**
-     * Start processing proofs.
-     * @param interval The interval to process proofs.
-     * @returns Nothing.
+     * Process a proof.
+     * @param proofEntity The proof entity to process.
      * @internal
      */
-    startProcessingProofs(interval) {
-        if (!this._processing) {
-            this._processing = true;
-            setTimeout(async () => {
-                await this.processProofs();
-            }, interval);
-        }
-    }
-    /**
-     * Process the proofs.
-     * @internal
-     */
-    async processProofs() {
-        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,
-                    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--;
-            }
-        }
-        finally {
-            // If there are still remaining proofs, start the timer again
-            this._processing = false;
-            if (remainingProofs > 0) {
-                this.startProcessingProofs(100);
-            }
+    async processProof(proofEntity) {
+        const immutableProof = this.proofEntityToJsonLd(proofEntity);
+        const hashData = await this.generateHashData(proofEntity.nodeIdentity, immutableProof);
+        // As we are adding the proof to the data we update its context
+        immutableProof["@context"] = [
+            ImmutableProofTypes.ContextRoot,
+            DidContexts.ContextVCDataIntegrity
+        ];
+        immutableProof.proof = await this._identityConnector.createProof(proofEntity.nodeIdentity, `${proofEntity.nodeIdentity}#${this._assertionMethodId}`, hashData);
+        if (Is.stringValue(immutableProof.proof.created)) {
+            proofEntity.dateCreated = immutableProof.proof.created;
         }
+        const compacted = await JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
+        const immutableStoreResult = await this._immutableStorage.store(proofEntity.nodeIdentity, ObjectHelper.toBytes(compacted));
+        proofEntity.immutableStorageId = immutableStoreResult.id;
+        await this._proofStorage.set(proofEntity);
     }
     /**
      * Verify an authentication proof.
@@ -640,17 +603,17 @@ class ImmutableProofService {
      * @internal
      */
     async generateHashData(nodeIdentity, immutableProof) {
-        // We hash the data for the proof with the proof or immutable receipt for the proof
+        // 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 proofConfigKey = await this._vaultConnector.getKey(`${nodeIdentity}/${this._proofConfigKeyId}`);
-        const proofConfigHash = Sha256.sum256(proofConfigKey.privateKey);
+        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

@@ -21,13 +21,15 @@ export declare class ImmutableProofService implements IImmutableProofComponent {
      * @param options.immutableProofEntityStorageType The entity storage for proofs, defaults to "immutable-proof".
      * @param options.immutableStorageType The immutable storage, defaults to "immutable-storage".
      * @param options.identityConnectorType The identity connector type, defaults to "identity".
+     * @param options.backgroundTaskConnectorType The background task connector type, defaults to "background-task".
      */
     constructor(options?: {
         vaultConnectorType?: string;
         immutableProofEntityStorageType?: string;
         immutableStorageType?: string;
-        config?: IImmutableProofServiceConfig;
         identityConnectorType?: string;
+        backgroundTaskConnectorType?: string;
+        config?: IImmutableProofServiceConfig;
     });
     /**
      * Create a new authentication proof.

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.6
+## v0.0.1-next.8
 
 - Initial Release

package/docs/reference/classes/ImmutableProofService.md

@@ -32,14 +32,18 @@ The entity storage for proofs, defaults to "immutable-proof".
 
 The immutable storage, defaults to "immutable-storage".
 
-• **options.config?**: [`IImmutableProofServiceConfig`](../interfaces/IImmutableProofServiceConfig.md)
-
-The configuration for the connector.
-
 • **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)

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.6",
+	"version": "0.0.1-next.8",
 	"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,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.6",
+		"@twin.org/immutable-proof-models": "0.0.1-next.8",
 		"@twin.org/immutable-storage-models": "next",
 		"@twin.org/nameof": "next",
 		"@twin.org/standards-w3c-did": "next",