@twin.org/identity-connector-entity-storage 0.0.1-next.28 → 0.0.1-next.29

package/dist/cjs/index.cjs

@@ -479,10 +479,7 @@ class EntityStorageIdentityConnector {
                 sub: credId,
                 vc: jwtVc
             };
-            const signature = await web.Jwt.encodeWithSigner(jwtHeader, jwtPayload, async (alg, key, payload) => {
-                const sig = await this._vaultConnector.sign(EntityStorageIdentityConnector.buildVaultKey(idParts.id, idParts.fragment ?? ""), payload);
-                return sig;
-            });
+            const signature = await web.Jwt.encodeWithSigner(jwtHeader, jwtPayload, async (header, payload) => vaultModels.VaultConnectorHelper.jwtSigner(this._vaultConnector, EntityStorageIdentityConnector.buildVaultKey(idParts.id, idParts.fragment ?? ""), header, payload));
             return {
                 verifiableCredential,
                 jwt: signature
@@ -531,10 +528,7 @@ class EntityStorageIdentityConnector {
             if (!core.Is.stringValue(didMethod.publicKeyJwk?.x)) {
                 throw new core.GeneralError(this.CLASS_NAME, "publicKeyJwkMissing", { method: jwtHeader.kid });
             }
-            const verified = web.Jwt.verifySignature(jwtHeader, jwtPayload, jwtSignature, core.Converter.base64UrlToBytes(didMethod.publicKeyJwk.x));
-            if (!verified) {
-                throw new core.GeneralError(this.CLASS_NAME, "jwkSignatureFailed");
-            }
+            await web.Jwt.verifySignature(credentialJwt, await web.Jwk.toCryptoKey(didMethod.publicKeyJwk));
             const verifiableCredential = jwtPayload.vc;
             if (core.Is.object(verifiableCredential)) {
                 if (core.Is.string(jwtPayload.jti)) {
@@ -741,10 +735,7 @@ class EntityStorageIdentityConnector {
                 const expiresInSeconds = expiresInMinutes * 60;
                 jwtPayload.exp = Math.floor(Date.now() / 1000) + expiresInSeconds;
             }
-            const signature = await web.Jwt.encodeWithSigner(jwtHeader, jwtPayload, async (alg, key, payload) => {
-                const sig = await this._vaultConnector.sign(EntityStorageIdentityConnector.buildVaultKey(idParts.id, idParts.fragment ?? ""), payload);
-                return sig;
-            });
+            const signature = await web.Jwt.encodeWithSigner(jwtHeader, jwtPayload, async (header, payload) => vaultModels.VaultConnectorHelper.jwtSigner(this._vaultConnector, EntityStorageIdentityConnector.buildVaultKey(idParts.id, idParts.fragment ?? ""), header, payload));
             return {
                 verifiablePresentation,
                 jwt: signature
@@ -847,13 +838,15 @@ class EntityStorageIdentityConnector {
      * Create a proof for arbitrary data with the specified verification method.
      * @param controller The controller of the identity who can make changes.
      * @param verificationMethodId The verification method id to use.
-     * @param bytes The data bytes to sign.
+     * @param proofType The type of proof to create.
+     * @param unsecureDocument The unsecure document to create the proof for.
      * @returns The proof.
      */
-    async createProof(controller, verificationMethodId, bytes) {
+    async createProof(controller, verificationMethodId, proofType, unsecureDocument) {
         core.Guards.stringValue(this.CLASS_NAME, "controller", controller);
         core.Guards.stringValue(this.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        core.Guards.uint8Array(this.CLASS_NAME, "bytes", bytes);
+        core.Guards.arrayOneOf(this.CLASS_NAME, "proofType", proofType, Object.values(standardsW3cDid.ProofTypes));
+        core.Guards.object(this.CLASS_NAME, "unsecureDocument", unsecureDocument);
         try {
             const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
             if (core.Is.empty(idParts.fragment)) {
@@ -881,16 +874,10 @@ class EntityStorageIdentityConnector {
                     method: verificationMethodId
                 });
             }
-            const signature = await this._vaultConnector.sign(EntityStorageIdentityConnector.buildVaultKey(didDocument.id, idParts.fragment ?? ""), bytes);
-            return {
-                "@context": standardsW3cDid.DidContexts.ContextVCDataIntegrity,
-                type: standardsW3cDid.DidTypes.DataIntegrityProof,
-                cryptosuite: standardsW3cDid.DidCryptoSuites.EdDSAJcs2022,
-                created: new Date(Date.now()).toISOString(),
-                verificationMethod: verificationMethodId,
-                proofPurpose: "assertionMethod",
-                proofValue: core.Converter.bytesToBase58(signature)
-            };
+            const vaultKey = EntityStorageIdentityConnector.buildVaultKey(didDocument.id, idParts.fragment ?? "");
+            const key = await this._vaultConnector.getKey(vaultKey);
+            const signedProof = await standardsW3cDid.ProofHelper.createProof(proofType, unsecureDocument, standardsW3cDid.ProofHelper.createUnsignedProof(proofType, verificationMethodId), await web.Jwk.fromEd25519Private(key.privateKey));
+            return signedProof;
         }
         catch (error) {
             throw new core.GeneralError(this.CLASS_NAME, "createProofFailed", undefined, error);
@@ -898,24 +885,15 @@ class EntityStorageIdentityConnector {
     }
     /**
      * Verify proof for arbitrary data with the specified verification method.
-     * @param bytes The data bytes to verify.
+     * @param document The document to verify.
      * @param proof The proof to verify.
      * @returns True if the proof is verified.
      */
-    async verifyProof(bytes, proof) {
-        core.Guards.uint8Array(this.CLASS_NAME, "bytes", bytes);
+    async verifyProof(document, proof) {
+        core.Guards.object(this.CLASS_NAME, "document", document);
         core.Guards.object(this.CLASS_NAME, "proof", proof);
-        core.Guards.stringValue(this.CLASS_NAME, "proof.type", proof.type);
-        core.Guards.stringValue(this.CLASS_NAME, "proof.cryptosuite", proof.cryptosuite);
         core.Guards.stringValue(this.CLASS_NAME, "proof.verificationMethod", proof.verificationMethod);
-        core.Guards.stringBase58(this.CLASS_NAME, "proof.proofValue", proof.proofValue);
         try {
-            if (proof.type !== standardsW3cDid.DidTypes.DataIntegrityProof) {
-                throw new core.GeneralError(this.CLASS_NAME, "proofType", { proofType: proof.type });
-            }
-            if (proof.cryptosuite !== standardsW3cDid.DidCryptoSuites.EdDSAJcs2022) {
-                throw new core.GeneralError(this.CLASS_NAME, "cryptoSuite", { cryptosuite: proof.cryptosuite });
-            }
             const idParts = identityModels.DocumentHelper.parseId(proof.verificationMethod);
             if (core.Is.empty(idParts.fragment)) {
                 throw new core.NotFoundError(this.CLASS_NAME, "missingDid", proof.verificationMethod);
@@ -941,10 +919,10 @@ class EntityStorageIdentityConnector {
             const didMethod = methodAndArray.method;
             if (!core.Is.stringValue(didMethod.publicKeyJwk?.x)) {
                 throw new core.GeneralError(this.CLASS_NAME, "publicKeyJwkMissing", {
-                    method: proof.verificationMethodId
+                    method: proof.verificationMethod
                 });
             }
-            return this._vaultConnector.verify(EntityStorageIdentityConnector.buildVaultKey(didIdentityDocument.id, idParts.fragment), bytes, core.Converter.base58ToBytes(proof.proofValue));
+            return standardsW3cDid.ProofHelper.verifyProof(document, proof, didMethod.publicKeyJwk);
         }
         catch (error) {
             throw new core.GeneralError(this.CLASS_NAME, "verifyProofFailed", undefined, error);

package/dist/esm/index.mjs

@@ -4,9 +4,9 @@ import { Sha256 } from '@twin.org/crypto';
 import { JsonLdProcessor } from '@twin.org/data-json-ld';
 import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
 import { DocumentHelper } from '@twin.org/identity-models';
-import { DidContexts, DidVerificationMethodType, DidTypes, DidCryptoSuites } from '@twin.org/standards-w3c-did';
-import { VaultConnectorFactory, VaultKeyType } from '@twin.org/vault-models';
-import { Jwt } from '@twin.org/web';
+import { DidContexts, DidVerificationMethodType, DidTypes, ProofTypes, ProofHelper } from '@twin.org/standards-w3c-did';
+import { VaultConnectorFactory, VaultKeyType, VaultConnectorHelper } from '@twin.org/vault-models';
+import { Jwt, Jwk } from '@twin.org/web';
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -477,10 +477,7 @@ class EntityStorageIdentityConnector {
                 sub: credId,
                 vc: jwtVc
             };
-            const signature = await Jwt.encodeWithSigner(jwtHeader, jwtPayload, async (alg, key, payload) => {
-                const sig = await this._vaultConnector.sign(EntityStorageIdentityConnector.buildVaultKey(idParts.id, idParts.fragment ?? ""), payload);
-                return sig;
-            });
+            const signature = await Jwt.encodeWithSigner(jwtHeader, jwtPayload, async (header, payload) => VaultConnectorHelper.jwtSigner(this._vaultConnector, EntityStorageIdentityConnector.buildVaultKey(idParts.id, idParts.fragment ?? ""), header, payload));
             return {
                 verifiableCredential,
                 jwt: signature
@@ -529,10 +526,7 @@ class EntityStorageIdentityConnector {
             if (!Is.stringValue(didMethod.publicKeyJwk?.x)) {
                 throw new GeneralError(this.CLASS_NAME, "publicKeyJwkMissing", { method: jwtHeader.kid });
             }
-            const verified = Jwt.verifySignature(jwtHeader, jwtPayload, jwtSignature, Converter.base64UrlToBytes(didMethod.publicKeyJwk.x));
-            if (!verified) {
-                throw new GeneralError(this.CLASS_NAME, "jwkSignatureFailed");
-            }
+            await Jwt.verifySignature(credentialJwt, await Jwk.toCryptoKey(didMethod.publicKeyJwk));
             const verifiableCredential = jwtPayload.vc;
             if (Is.object(verifiableCredential)) {
                 if (Is.string(jwtPayload.jti)) {
@@ -739,10 +733,7 @@ class EntityStorageIdentityConnector {
                 const expiresInSeconds = expiresInMinutes * 60;
                 jwtPayload.exp = Math.floor(Date.now() / 1000) + expiresInSeconds;
             }
-            const signature = await Jwt.encodeWithSigner(jwtHeader, jwtPayload, async (alg, key, payload) => {
-                const sig = await this._vaultConnector.sign(EntityStorageIdentityConnector.buildVaultKey(idParts.id, idParts.fragment ?? ""), payload);
-                return sig;
-            });
+            const signature = await Jwt.encodeWithSigner(jwtHeader, jwtPayload, async (header, payload) => VaultConnectorHelper.jwtSigner(this._vaultConnector, EntityStorageIdentityConnector.buildVaultKey(idParts.id, idParts.fragment ?? ""), header, payload));
             return {
                 verifiablePresentation,
                 jwt: signature
@@ -845,13 +836,15 @@ class EntityStorageIdentityConnector {
      * Create a proof for arbitrary data with the specified verification method.
      * @param controller The controller of the identity who can make changes.
      * @param verificationMethodId The verification method id to use.
-     * @param bytes The data bytes to sign.
+     * @param proofType The type of proof to create.
+     * @param unsecureDocument The unsecure document to create the proof for.
      * @returns The proof.
      */
-    async createProof(controller, verificationMethodId, bytes) {
+    async createProof(controller, verificationMethodId, proofType, unsecureDocument) {
         Guards.stringValue(this.CLASS_NAME, "controller", controller);
         Guards.stringValue(this.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        Guards.uint8Array(this.CLASS_NAME, "bytes", bytes);
+        Guards.arrayOneOf(this.CLASS_NAME, "proofType", proofType, Object.values(ProofTypes));
+        Guards.object(this.CLASS_NAME, "unsecureDocument", unsecureDocument);
         try {
             const idParts = DocumentHelper.parseId(verificationMethodId);
             if (Is.empty(idParts.fragment)) {
@@ -879,16 +872,10 @@ class EntityStorageIdentityConnector {
                     method: verificationMethodId
                 });
             }
-            const signature = await this._vaultConnector.sign(EntityStorageIdentityConnector.buildVaultKey(didDocument.id, idParts.fragment ?? ""), bytes);
-            return {
-                "@context": DidContexts.ContextVCDataIntegrity,
-                type: DidTypes.DataIntegrityProof,
-                cryptosuite: DidCryptoSuites.EdDSAJcs2022,
-                created: new Date(Date.now()).toISOString(),
-                verificationMethod: verificationMethodId,
-                proofPurpose: "assertionMethod",
-                proofValue: Converter.bytesToBase58(signature)
-            };
+            const vaultKey = EntityStorageIdentityConnector.buildVaultKey(didDocument.id, idParts.fragment ?? "");
+            const key = await this._vaultConnector.getKey(vaultKey);
+            const signedProof = await ProofHelper.createProof(proofType, unsecureDocument, ProofHelper.createUnsignedProof(proofType, verificationMethodId), await Jwk.fromEd25519Private(key.privateKey));
+            return signedProof;
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "createProofFailed", undefined, error);
@@ -896,24 +883,15 @@ class EntityStorageIdentityConnector {
     }
     /**
      * Verify proof for arbitrary data with the specified verification method.
-     * @param bytes The data bytes to verify.
+     * @param document The document to verify.
      * @param proof The proof to verify.
      * @returns True if the proof is verified.
      */
-    async verifyProof(bytes, proof) {
-        Guards.uint8Array(this.CLASS_NAME, "bytes", bytes);
+    async verifyProof(document, proof) {
+        Guards.object(this.CLASS_NAME, "document", document);
         Guards.object(this.CLASS_NAME, "proof", proof);
-        Guards.stringValue(this.CLASS_NAME, "proof.type", proof.type);
-        Guards.stringValue(this.CLASS_NAME, "proof.cryptosuite", proof.cryptosuite);
         Guards.stringValue(this.CLASS_NAME, "proof.verificationMethod", proof.verificationMethod);
-        Guards.stringBase58(this.CLASS_NAME, "proof.proofValue", proof.proofValue);
         try {
-            if (proof.type !== DidTypes.DataIntegrityProof) {
-                throw new GeneralError(this.CLASS_NAME, "proofType", { proofType: proof.type });
-            }
-            if (proof.cryptosuite !== DidCryptoSuites.EdDSAJcs2022) {
-                throw new GeneralError(this.CLASS_NAME, "cryptoSuite", { cryptosuite: proof.cryptosuite });
-            }
             const idParts = DocumentHelper.parseId(proof.verificationMethod);
             if (Is.empty(idParts.fragment)) {
                 throw new NotFoundError(this.CLASS_NAME, "missingDid", proof.verificationMethod);
@@ -939,10 +917,10 @@ class EntityStorageIdentityConnector {
             const didMethod = methodAndArray.method;
             if (!Is.stringValue(didMethod.publicKeyJwk?.x)) {
                 throw new GeneralError(this.CLASS_NAME, "publicKeyJwkMissing", {
-                    method: proof.verificationMethodId
+                    method: proof.verificationMethod
                 });
             }
-            return this._vaultConnector.verify(EntityStorageIdentityConnector.buildVaultKey(didIdentityDocument.id, idParts.fragment), bytes, Converter.base58ToBytes(proof.proofValue));
+            return ProofHelper.verifyProof(document, proof, didMethod.publicKeyJwk);
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "verifyProofFailed", undefined, error);

package/dist/types/entityStorageIdentityConnector.d.ts

@@ -1,6 +1,6 @@
 import { type IJsonLdContextDefinitionRoot, type IJsonLdNodeObject } from "@twin.org/data-json-ld";
 import { type IIdentityConnector } from "@twin.org/identity-models";
-import { DidVerificationMethodType, type IDidDocument, type IDidDocumentVerificationMethod, type IDidProof, type IDidService, type IDidVerifiableCredential, type IDidVerifiablePresentation } from "@twin.org/standards-w3c-did";
+import { DidVerificationMethodType, ProofTypes, type IDidDocument, type IDidDocumentVerificationMethod, type IDidService, type IDidVerifiableCredential, type IDidVerifiablePresentation, type IProof } from "@twin.org/standards-w3c-did";
 import type { IEntityStorageIdentityConnectorConstructorOptions } from "./models/IEntityStorageIdentityConnectorConstructorOptions";
 /**
  * Class for performing identity operations using entity storage.
@@ -133,15 +133,16 @@ export declare class EntityStorageIdentityConnector implements IIdentityConnecto
      * Create a proof for arbitrary data with the specified verification method.
      * @param controller The controller of the identity who can make changes.
      * @param verificationMethodId The verification method id to use.
-     * @param bytes The data bytes to sign.
+     * @param proofType The type of proof to create.
+     * @param unsecureDocument The unsecure document to create the proof for.
      * @returns The proof.
      */
-    createProof(controller: string, verificationMethodId: string, bytes: Uint8Array): Promise<IDidProof>;
+    createProof(controller: string, verificationMethodId: string, proofType: ProofTypes, unsecureDocument: IJsonLdNodeObject): Promise<IProof>;
     /**
      * Verify proof for arbitrary data with the specified verification method.
-     * @param bytes The data bytes to verify.
+     * @param document The document to verify.
      * @param proof The proof to verify.
      * @returns True if the proof is verified.
      */
-    verifyProof(bytes: Uint8Array, proof: IDidProof): Promise<boolean>;
+    verifyProof(document: IJsonLdNodeObject, proof: IProof): Promise<boolean>;
 }

package/docs/changelog.md

@@ -1,5 +1,5 @@
 # @twin.org/identity-connector-entity-storage- Changelog
 
-## v0.0.1-next.28
+## v0.0.1-next.29
 
 - Initial Release

package/docs/reference/classes/EntityStorageIdentityConnector.md

@@ -506,7 +506,7 @@ The presentation stored in the jwt and the revocation status.
 
 ### createProof()
 
-> **createProof**(`controller`, `verificationMethodId`, `bytes`): `Promise`\<`IDidProof`\>
+> **createProof**(`controller`, `verificationMethodId`, `proofType`, `unsecureDocument`): `Promise`\<`IProof`\>
 
 Create a proof for arbitrary data with the specified verification method.
 
@@ -524,15 +524,21 @@ The controller of the identity who can make changes.
 
 The verification method id to use.
 
-##### bytes
+##### proofType
 
-`Uint8Array`
+`ProofTypes`
 
-The data bytes to sign.
+The type of proof to create.
+
+##### unsecureDocument
+
+`IJsonLdNodeObject`
+
+The unsecure document to create the proof for.
 
 #### Returns
 
-`Promise`\<`IDidProof`\>
+`Promise`\<`IProof`\>
 
 The proof.
 
@@ -544,21 +550,21 @@ The proof.
 
 ### verifyProof()
 
-> **verifyProof**(`bytes`, `proof`): `Promise`\<`boolean`\>
+> **verifyProof**(`document`, `proof`): `Promise`\<`boolean`\>
 
 Verify proof for arbitrary data with the specified verification method.
 
 #### Parameters
 
-##### bytes
+##### document
 
-`Uint8Array`
+`IJsonLdNodeObject`
 
-The data bytes to verify.
+The document to verify.
 
 ##### proof
 
-`IDidProof`
+`IProof`
 
 The proof to verify.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/identity-connector-entity-storage",
-	"version": "0.0.1-next.28",
+	"version": "0.0.1-next.29",
 	"description": "Identity connector implementation using entity storage",
 	"repository": {
 		"type": "git",
@@ -19,7 +19,7 @@
 		"@twin.org/data-core": "next",
 		"@twin.org/data-json-ld": "next",
 		"@twin.org/entity": "next",
-		"@twin.org/identity-models": "0.0.1-next.28",
+		"@twin.org/identity-models": "0.0.1-next.29",
 		"@twin.org/nameof": "next",
 		"@twin.org/standards-w3c-did": "next",
 		"@twin.org/vault-models": "next",