@trustvc/trustvc 2.1.0 → 2.2.0

package/dist/cjs/verify/fragments/document-integrity/bbs2023W3CSignatureIntegrity.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var w3cModernSignatureIntegrityFactory = require('./w3cModernSignatureIntegrityFactory');
+
+const bbs2023W3CSignatureIntegrity = w3cModernSignatureIntegrityFactory.createW3CSignatureIntegrityVerifier({
+  cryptosuite: "bbs-2023",
+  name: "Bbs2023W3CSignatureIntegrity",
+  derivationPaths: []
+});
+
+exports.bbs2023W3CSignatureIntegrity = bbs2023W3CSignatureIntegrity;

package/dist/cjs/verify/fragments/document-integrity/ecdsaW3CSignatureIntegrity.js

@@ -1,87 +1,11 @@
 'use strict';
 
-var verify = require('../../../w3c/verify');
-var w3cVc = require('@trustvc/w3c-vc');
+var w3cModernSignatureIntegrityFactory = require('./w3cModernSignatureIntegrityFactory');
 
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const PROOF_TYPE = "DataIntegrityProof";
-const CRYPTOSUITE = "ecdsa-sd-2023";
-const DERIVE_CREDENTIAL_ERROR = "Use deriveCredential() first";
-function isSignedVerifiableCredential(document) {
-  return typeof document === "object" && document !== null && "proof" in document;
-}
-__name(isSignedVerifiableCredential, "isSignedVerifiableCredential");
-const ecdsaW3CSignatureIntegrity = {
-  skip: /* @__PURE__ */ __name(async () => {
-    return {
-      type: "DOCUMENT_INTEGRITY",
-      name: "EcdsaW3CSignatureIntegrity",
-      reason: {
-        code: 0,
-        codeString: "SKIPPED",
-        message: `Document either has no proof or proof type is not '${PROOF_TYPE}' or proof cryptosuite is not '${CRYPTOSUITE}'.`
-      },
-      status: "SKIPPED"
-    };
-  }, "skip"),
-  test: /* @__PURE__ */ __name((document) => {
-    const doc = document;
-    return doc.proof?.type === "DataIntegrityProof" && doc.proof?.cryptosuite === "ecdsa-sd-2023";
-  }, "test"),
-  verify: /* @__PURE__ */ __name(async (document, verifierOptions) => {
-    if (!isSignedVerifiableCredential(document)) {
-      return {
-        type: "DOCUMENT_INTEGRITY",
-        name: "EcdsaW3CSignatureIntegrity",
-        data: false,
-        reason: {
-          message: "Document is not a valid SignedVerifiableCredential"
-        },
-        status: "INVALID"
-      };
-    }
-    try {
-      let verificationResult = await verify.verifyW3CSignature(document, verifierOptions);
-      let isDerived = true;
-      if (!verificationResult.verified && verificationResult.error?.includes(DERIVE_CREDENTIAL_ERROR)) {
-        const derivedCredential = await w3cVc.deriveCredential(document, []);
-        verificationResult = await verify.verifyW3CSignature(derivedCredential.derived, verifierOptions);
-        isDerived = false;
-      }
-      if (verificationResult.verified) {
-        return {
-          type: "DOCUMENT_INTEGRITY",
-          name: "EcdsaW3CSignatureIntegrity",
-          data: true,
-          reason: {
-            message: isDerived ? "Document verified successfully" : "Document verified after derivation"
-          },
-          status: "VALID"
-        };
-      } else {
-        return {
-          type: "DOCUMENT_INTEGRITY",
-          name: "EcdsaW3CSignatureIntegrity",
-          data: false,
-          reason: {
-            message: verificationResult.error || "Verification failed"
-          },
-          status: "INVALID"
-        };
-      }
-    } catch (error) {
-      return {
-        type: "DOCUMENT_INTEGRITY",
-        name: "EcdsaW3CSignatureIntegrity",
-        data: false,
-        reason: {
-          message: error instanceof Error ? error.message : "Unknown verification error"
-        },
-        status: "INVALID"
-      };
-    }
-  }, "verify")
-};
+const ecdsaW3CSignatureIntegrity = w3cModernSignatureIntegrityFactory.createW3CSignatureIntegrityVerifier({
+  cryptosuite: "ecdsa-sd-2023",
+  name: "EcdsaW3CSignatureIntegrity",
+  derivationPaths: []
+});
 
 exports.ecdsaW3CSignatureIntegrity = ecdsaW3CSignatureIntegrity;

package/dist/cjs/verify/fragments/document-integrity/w3cModernSignatureIntegrityFactory.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var w3cVc = require('@trustvc/w3c-vc');
+var verify = require('../../../w3c/verify');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const PROOF_TYPE = "DataIntegrityProof";
+const DERIVE_CREDENTIAL_ERROR = "Use deriveCredential() first";
+function isSignedVerifiableCredential(document) {
+  return typeof document === "object" && document !== null && "proof" in document;
+}
+__name(isSignedVerifiableCredential, "isSignedVerifiableCredential");
+function createW3CSignatureIntegrityVerifier(config) {
+  const { cryptosuite, name, derivationPaths = [] } = config;
+  return {
+    skip: /* @__PURE__ */ __name(async () => {
+      return {
+        type: "DOCUMENT_INTEGRITY",
+        name,
+        reason: {
+          code: 0,
+          codeString: "SKIPPED",
+          message: `Document either has no proof or proof type is not '${PROOF_TYPE}' or proof cryptosuite is not '${cryptosuite}'.`
+        },
+        status: "SKIPPED"
+      };
+    }, "skip"),
+    test: /* @__PURE__ */ __name((document) => {
+      const doc = document;
+      return doc.proof?.type === PROOF_TYPE && doc.proof?.cryptosuite === cryptosuite;
+    }, "test"),
+    verify: /* @__PURE__ */ __name(async (document, verifierOptions) => {
+      if (!isSignedVerifiableCredential(document)) {
+        return {
+          type: "DOCUMENT_INTEGRITY",
+          name,
+          data: false,
+          reason: {
+            message: "Document is not a valid SignedVerifiableCredential"
+          },
+          status: "INVALID"
+        };
+      }
+      try {
+        let verificationResult = await verify.verifyW3CSignature(document, verifierOptions);
+        let isDerived = true;
+        if (!verificationResult.verified && verificationResult.error?.includes(DERIVE_CREDENTIAL_ERROR)) {
+          const derivedCredential = await w3cVc.deriveCredential(document, derivationPaths);
+          verificationResult = await verify.verifyW3CSignature(derivedCredential.derived, verifierOptions);
+          isDerived = false;
+        }
+        if (verificationResult.verified) {
+          return {
+            type: "DOCUMENT_INTEGRITY",
+            name,
+            data: true,
+            reason: {
+              message: isDerived ? "Document verified successfully" : "Document verified after derivation"
+            },
+            status: "VALID"
+          };
+        } else {
+          return {
+            type: "DOCUMENT_INTEGRITY",
+            name,
+            data: false,
+            reason: {
+              message: verificationResult.error || "Verification failed"
+            },
+            status: "INVALID"
+          };
+        }
+      } catch (error) {
+        return {
+          type: "DOCUMENT_INTEGRITY",
+          name,
+          data: false,
+          reason: {
+            message: error instanceof Error ? error.message : "Unknown verification error"
+          },
+          status: "INVALID"
+        };
+      }
+    }, "verify")
+  };
+}
+__name(createW3CSignatureIntegrityVerifier, "createW3CSignatureIntegrityVerifier");
+
+exports.createW3CSignatureIntegrityVerifier = createW3CSignatureIntegrityVerifier;

package/dist/cjs/verify/verify.js

@@ -7,6 +7,7 @@ var transferableRecordVerifier = require('./fragments/document-status/transferab
 var w3cCredentialStatus = require('./fragments/document-status/w3cCredentialStatus');
 var w3cIssuerIdentity = require('./fragments/issuer-identity/w3cIssuerIdentity');
 var fragments = require('./fragments');
+var bbs2023W3CSignatureIntegrity = require('./fragments/document-integrity/bbs2023W3CSignatureIntegrity');
 
 const verifiers = {
   documentIntegrity: {
@@ -35,6 +36,7 @@ const openAttestationVerifiers = [
 const w3cVerifiers = [
   w3cSignatureIntegrity.w3cSignatureIntegrity,
   ecdsaW3CSignatureIntegrity.ecdsaW3CSignatureIntegrity,
+  bbs2023W3CSignatureIntegrity.bbs2023W3CSignatureIntegrity,
   w3cCredentialStatus.w3cCredentialStatus,
   transferableRecordVerifier.credentialStatusTransferableRecordVerifier,
   fragments.w3cEmptyCredentialStatus,

package/dist/esm/verify/fragments/document-integrity/bbs2023W3CSignatureIntegrity.js

@@ -0,0 +1,9 @@
+import { createW3CSignatureIntegrityVerifier } from './w3cModernSignatureIntegrityFactory';
+
+const bbs2023W3CSignatureIntegrity = createW3CSignatureIntegrityVerifier({
+  cryptosuite: "bbs-2023",
+  name: "Bbs2023W3CSignatureIntegrity",
+  derivationPaths: []
+});
+
+export { bbs2023W3CSignatureIntegrity };

package/dist/esm/verify/fragments/document-integrity/ecdsaW3CSignatureIntegrity.js

@@ -1,85 +1,9 @@
-import { verifyW3CSignature } from '../../../w3c/verify';
-import { deriveCredential } from '@trustvc/w3c-vc';
+import { createW3CSignatureIntegrityVerifier } from './w3cModernSignatureIntegrityFactory';
 
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const PROOF_TYPE = "DataIntegrityProof";
-const CRYPTOSUITE = "ecdsa-sd-2023";
-const DERIVE_CREDENTIAL_ERROR = "Use deriveCredential() first";
-function isSignedVerifiableCredential(document) {
-  return typeof document === "object" && document !== null && "proof" in document;
-}
-__name(isSignedVerifiableCredential, "isSignedVerifiableCredential");
-const ecdsaW3CSignatureIntegrity = {
-  skip: /* @__PURE__ */ __name(async () => {
-    return {
-      type: "DOCUMENT_INTEGRITY",
-      name: "EcdsaW3CSignatureIntegrity",
-      reason: {
-        code: 0,
-        codeString: "SKIPPED",
-        message: `Document either has no proof or proof type is not '${PROOF_TYPE}' or proof cryptosuite is not '${CRYPTOSUITE}'.`
-      },
-      status: "SKIPPED"
-    };
-  }, "skip"),
-  test: /* @__PURE__ */ __name((document) => {
-    const doc = document;
-    return doc.proof?.type === "DataIntegrityProof" && doc.proof?.cryptosuite === "ecdsa-sd-2023";
-  }, "test"),
-  verify: /* @__PURE__ */ __name(async (document, verifierOptions) => {
-    if (!isSignedVerifiableCredential(document)) {
-      return {
-        type: "DOCUMENT_INTEGRITY",
-        name: "EcdsaW3CSignatureIntegrity",
-        data: false,
-        reason: {
-          message: "Document is not a valid SignedVerifiableCredential"
-        },
-        status: "INVALID"
-      };
-    }
-    try {
-      let verificationResult = await verifyW3CSignature(document, verifierOptions);
-      let isDerived = true;
-      if (!verificationResult.verified && verificationResult.error?.includes(DERIVE_CREDENTIAL_ERROR)) {
-        const derivedCredential = await deriveCredential(document, []);
-        verificationResult = await verifyW3CSignature(derivedCredential.derived, verifierOptions);
-        isDerived = false;
-      }
-      if (verificationResult.verified) {
-        return {
-          type: "DOCUMENT_INTEGRITY",
-          name: "EcdsaW3CSignatureIntegrity",
-          data: true,
-          reason: {
-            message: isDerived ? "Document verified successfully" : "Document verified after derivation"
-          },
-          status: "VALID"
-        };
-      } else {
-        return {
-          type: "DOCUMENT_INTEGRITY",
-          name: "EcdsaW3CSignatureIntegrity",
-          data: false,
-          reason: {
-            message: verificationResult.error || "Verification failed"
-          },
-          status: "INVALID"
-        };
-      }
-    } catch (error) {
-      return {
-        type: "DOCUMENT_INTEGRITY",
-        name: "EcdsaW3CSignatureIntegrity",
-        data: false,
-        reason: {
-          message: error instanceof Error ? error.message : "Unknown verification error"
-        },
-        status: "INVALID"
-      };
-    }
-  }, "verify")
-};
+const ecdsaW3CSignatureIntegrity = createW3CSignatureIntegrityVerifier({
+  cryptosuite: "ecdsa-sd-2023",
+  name: "EcdsaW3CSignatureIntegrity",
+  derivationPaths: []
+});
 
 export { ecdsaW3CSignatureIntegrity };

package/dist/esm/verify/fragments/document-integrity/w3cModernSignatureIntegrityFactory.js

@@ -0,0 +1,88 @@
+import { deriveCredential } from '@trustvc/w3c-vc';
+import { verifyW3CSignature } from '../../../w3c/verify';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const PROOF_TYPE = "DataIntegrityProof";
+const DERIVE_CREDENTIAL_ERROR = "Use deriveCredential() first";
+function isSignedVerifiableCredential(document) {
+  return typeof document === "object" && document !== null && "proof" in document;
+}
+__name(isSignedVerifiableCredential, "isSignedVerifiableCredential");
+function createW3CSignatureIntegrityVerifier(config) {
+  const { cryptosuite, name, derivationPaths = [] } = config;
+  return {
+    skip: /* @__PURE__ */ __name(async () => {
+      return {
+        type: "DOCUMENT_INTEGRITY",
+        name,
+        reason: {
+          code: 0,
+          codeString: "SKIPPED",
+          message: `Document either has no proof or proof type is not '${PROOF_TYPE}' or proof cryptosuite is not '${cryptosuite}'.`
+        },
+        status: "SKIPPED"
+      };
+    }, "skip"),
+    test: /* @__PURE__ */ __name((document) => {
+      const doc = document;
+      return doc.proof?.type === PROOF_TYPE && doc.proof?.cryptosuite === cryptosuite;
+    }, "test"),
+    verify: /* @__PURE__ */ __name(async (document, verifierOptions) => {
+      if (!isSignedVerifiableCredential(document)) {
+        return {
+          type: "DOCUMENT_INTEGRITY",
+          name,
+          data: false,
+          reason: {
+            message: "Document is not a valid SignedVerifiableCredential"
+          },
+          status: "INVALID"
+        };
+      }
+      try {
+        let verificationResult = await verifyW3CSignature(document, verifierOptions);
+        let isDerived = true;
+        if (!verificationResult.verified && verificationResult.error?.includes(DERIVE_CREDENTIAL_ERROR)) {
+          const derivedCredential = await deriveCredential(document, derivationPaths);
+          verificationResult = await verifyW3CSignature(derivedCredential.derived, verifierOptions);
+          isDerived = false;
+        }
+        if (verificationResult.verified) {
+          return {
+            type: "DOCUMENT_INTEGRITY",
+            name,
+            data: true,
+            reason: {
+              message: isDerived ? "Document verified successfully" : "Document verified after derivation"
+            },
+            status: "VALID"
+          };
+        } else {
+          return {
+            type: "DOCUMENT_INTEGRITY",
+            name,
+            data: false,
+            reason: {
+              message: verificationResult.error || "Verification failed"
+            },
+            status: "INVALID"
+          };
+        }
+      } catch (error) {
+        return {
+          type: "DOCUMENT_INTEGRITY",
+          name,
+          data: false,
+          reason: {
+            message: error instanceof Error ? error.message : "Unknown verification error"
+          },
+          status: "INVALID"
+        };
+      }
+    }, "verify")
+  };
+}
+__name(createW3CSignatureIntegrityVerifier, "createW3CSignatureIntegrityVerifier");
+
+export { createW3CSignatureIntegrityVerifier };

package/dist/esm/verify/verify.js

@@ -6,6 +6,7 @@ import { credentialStatusTransferableRecordVerifier } from './fragments/document
 import { w3cCredentialStatus } from './fragments/document-status/w3cCredentialStatus';
 import { w3cIssuerIdentity } from './fragments/issuer-identity/w3cIssuerIdentity';
 import { w3cEmptyCredentialStatus } from './fragments';
+import { bbs2023W3CSignatureIntegrity } from './fragments/document-integrity/bbs2023W3CSignatureIntegrity';
 
 const verifiers = {
   documentIntegrity: {
@@ -34,6 +35,7 @@ const openAttestationVerifiers = [
 const w3cVerifiers = [
   w3cSignatureIntegrity,
   ecdsaW3CSignatureIntegrity,
+  bbs2023W3CSignatureIntegrity,
   w3cCredentialStatus,
   credentialStatusTransferableRecordVerifier,
   w3cEmptyCredentialStatus,

package/dist/types/verify/fragments/document-integrity/bbs2023W3CSignatureIntegrity.d.ts

@@ -0,0 +1,5 @@
+import { Verifier, VerificationFragment } from '@tradetrust-tt/tt-verify';
+
+declare const bbs2023W3CSignatureIntegrity: Verifier<VerificationFragment>;
+
+export { bbs2023W3CSignatureIntegrity };

package/dist/types/verify/fragments/document-integrity/w3cModernSignatureIntegrityFactory.d.ts

@@ -0,0 +1,13 @@
+import { Verifier, VerificationFragment } from '@tradetrust-tt/tt-verify';
+
+interface CryptosuiteConfig {
+    /** The cryptosuite identifier (e.g., 'bbs-2023', 'ecdsa-sd-2023') */
+    cryptosuite: string;
+    /** Display name for the verifier (e.g., 'Bbs2023W3CSignatureIntegrity') */
+    name: string;
+    /** Optional array of JSON paths to derive from the credential */
+    derivationPaths?: string[];
+}
+declare function createW3CSignatureIntegrityVerifier(config: CryptosuiteConfig): Verifier<VerificationFragment>;
+
+export { type CryptosuiteConfig, createW3CSignatureIntegrityVerifier };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustvc/trustvc",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "TrustVC library",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",