@twin.org/immutable-proof-service 0.0.1-next.4 → 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;
     }
     /**
@@ -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,
@@ -558,13 +552,21 @@ class ImmutableProofService {
             remainingProofs = pendingProofs.entities.length;
             if (remainingProofs > 0) {
                 const proofEntity = pendingProofs.entities[0];
-                const immutableProof = this.proofEntityToModel(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,
+                    immutableStorageModels.ImmutableStorageTypes.ContextRoot,
+                    standardsW3cDid.DidContexts.ContextVCDataIntegrity
+                ];
                 immutableProof.proof = await this._identityConnector.createProof(proofEntity.nodeIdentity, `${proofEntity.nodeIdentity}#${this._assertionMethodId}`, hashData);
-                proofEntity.dateCreated =
-                    immutableProof.proof.created ?? new Date(Date.now()).toISOString();
+                if (core.Is.stringValue(immutableProof.proof.created)) {
+                    proofEntity.dateCreated = immutableProof.proof.created;
+                }
                 const compacted = await dataJsonLd.JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
-                proofEntity.immutableStorageId = await this._immutableStorage.store(proofEntity.nodeIdentity, core.ObjectHelper.toBytes(compacted));
+                const immutableStoreResult = await this._immutableStorage.store(proofEntity.nodeIdentity, core.ObjectHelper.toBytes(compacted));
+                proofEntity.immutableStorageId = immutableStoreResult.id;
                 await this._proofStorage.set(proofEntity);
                 remainingProofs--;
             }
@@ -592,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;
@@ -636,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;
     }
     /**
@@ -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,
@@ -556,13 +550,21 @@ class ImmutableProofService {
             remainingProofs = pendingProofs.entities.length;
             if (remainingProofs > 0) {
                 const proofEntity = pendingProofs.entities[0];
-                const immutableProof = this.proofEntityToModel(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,
+                    ImmutableStorageTypes.ContextRoot,
+                    DidContexts.ContextVCDataIntegrity
+                ];
                 immutableProof.proof = await this._identityConnector.createProof(proofEntity.nodeIdentity, `${proofEntity.nodeIdentity}#${this._assertionMethodId}`, hashData);
-                proofEntity.dateCreated =
-                    immutableProof.proof.created ?? new Date(Date.now()).toISOString();
+                if (Is.stringValue(immutableProof.proof.created)) {
+                    proofEntity.dateCreated = immutableProof.proof.created;
+                }
                 const compacted = await JsonLdProcessor.compact(immutableProof, immutableProof["@context"]);
-                proofEntity.immutableStorageId = await this._immutableStorage.store(proofEntity.nodeIdentity, ObjectHelper.toBytes(compacted));
+                const immutableStoreResult = await this._immutableStorage.store(proofEntity.nodeIdentity, ObjectHelper.toBytes(compacted));
+                proofEntity.immutableStorageId = immutableStoreResult.id;
                 await this._proofStorage.set(proofEntity);
                 remainingProofs--;
             }
@@ -590,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;
@@ -634,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.4
+## 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.4",
+	"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.4",
+		"@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",