@trustvc/trustvc 2.0.7 → 2.2.0

package/README.md

@@ -155,7 +155,7 @@ const signedWrappedDocument = await signOA(wrappedDocument, {
 
 #### b) TrustVC W3C Signing (signW3C)
 
-The `signW3C` function signs W3C Verifiable Credentials using the provided cryptographic suite and key pair. By default, it uses the **ecdsa-sd-2023** crypto suite unless otherwise specified.
+The `signW3C` function signs W3C Verifiable Credentials using the provided cryptographic suite and key pair. By default, it uses the **ecdsa-sd-2023** crypto suite unless otherwise specified. It also supports **bbs-2023** for modern BBS signatures.
 
 ```ts
 import { signW3C, VerificationType } from '@trustvc/trustvc';
@@ -195,7 +195,7 @@ const signingResult = await signW3C(rawDocument, {
   secretKeyMultibase: '<secretKeyMultibase>'
 });
 
-// You can also specify mandatory pointers for selective disclosure with ecdsa-sd-2023
+// You can also specify mandatory pointers for selective disclosure with ecdsa-sd-2023 / bbs-2023
 const signingResultWithPointers = await signW3C(
   rawDocument,
   {
@@ -212,7 +212,22 @@ const signingResultWithPointers = await signW3C(
   }
 );
 
-// Alternatively, specify a different crypto suite. Ensure the context is updated to include the crypto suite.
+// Using BBS-2023 cryptosuite
+const signingResultWithBbs2023 = await signW3C(
+  rawDocument,
+  {
+    '@context': 'https://w3id.org/security/multikey/v1',
+    id: 'did:web:trustvc.github.io:did:1#multikey-2',
+    type: VerificationType.Multikey,
+    controller: 'did:web:trustvc.github.io:did:1',
+    publicKeyMultibase: 'zUC75kRac7BdtjawFUxowfgD6mzqnRHFxAfMDaBynebdYgakviQkPS1KNJEw7uGWqj91H3hSE4pTERb3EZKLgKXjpqHWrN8dyE8SKyPBE3k7kUGjBNAqJoNGgUzqUW3DSaWrcNr',
+    secretKeyMultibase: '<secretKeyMultibase>',
+  },
+  'bbs-2023'
+);
+
+// ⚠️ DEPRECATED: BbsBlsSignature2020 is no longer supported
+// Use 'ecdsa-sd-2023 or bbs-2023' cryptosuite instead as shown above
 const signingResultWithBbs = await signW3C(
   rawDocument,
   {
@@ -222,7 +237,7 @@ const signingResultWithBbs = await signW3C(
     publicKeyBase58: 'oRfEeWFresvhRtXCkihZbxyoi2JER7gHTJ5psXhHsdCoU1MttRMi3Yp9b9fpjmKh7bMgfWKLESiK2YovRd8KGzJsGuamoAXfqDDVhckxuc9nmsJ84skCSTijKeU4pfAcxeJ',
     privateKeyBase58: '<privateKeyBase58>',
   },
-  'BbsBlsSignature2020'
+  'BbsBlsSignature2020' // This will return an error
 );
 
 ```
@@ -231,7 +246,7 @@ const signingResultWithBbs = await signW3C(
 
 ### 3. **Deriving (Selective Disclosure)**
 
-> When using ECDSA-SD-2023 crypto suite, we can derive a new credential with selective disclosure. This means you can choose which parts of the credential to reveal while keeping others hidden.
+> When using ECDSA-SD-2023 or BBS-2023 crypto suites, we can derive a new credential with selective disclosure. This means you can choose which parts of the credential to reveal while keeping others hidden.
 
 ```ts
 import { deriveW3C } from '@trustvc/trustvc';
@@ -282,7 +297,7 @@ const derivationResult = await deriveW3C(signedDocument, {
 
 ### 4. **Verifying**
 
-> TrustVC simplifies the verification process with a single function that supports both W3C Verifiable Credentials (VCs) and OpenAttestation Verifiable Documents (VDs). Whether you're working with W3C standards or OpenAttestation standards, TrustVC handles the verification seamlessly. For ECDSA-signed documents, which normally require derivation before verification, TrustVC automatically handles this process internally - if a document is not derived, the `verifyDocument` function will automatically derive and verify the document in a single step.
+> TrustVC simplifies the verification process with a single function that supports both W3C Verifiable Credentials (VCs) and OpenAttestation Verifiable Documents (VDs). Whether you're working with W3C standards or OpenAttestation standards, TrustVC handles the verification seamlessly. For ECDSA-SD-2023 and BBS-2023 signed documents, which normally require derivation before verification, TrustVC automatically handles this process internally - if a document is not derived, the `verifyDocument` function will automatically derive and verify the document in a single step.
 
 ```ts
 import { verifyDocument } from '@trustvc/trustvc';

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/core/documentBuilder.d.ts

@@ -1,5 +1,5 @@
 import { PrivateKeyPair } from '@trustvc/w3c-issuer';
-import { VerifiableCredential, CryptoSuiteName, SignedVerifiableCredential, ContextDocument } from '@trustvc/w3c-vc';
+import { VerifiableCredential, CryptoSuiteName, SignedVerifiableCredential } from '@trustvc/w3c-vc';
 
 /**
  * Configuration for a W3C Verifiable Document using a Bitstring Status List.
@@ -79,7 +79,7 @@ declare class DocumentBuilder {
     renderMethod(method: RenderMethod): this;
     qrCode(method: qrCode): this;
     sign(privateKey: PrivateKeyPair, cryptoSuite?: CryptoSuiteName, options?: SignOptions): Promise<SignedVerifiableCredential>;
-    derive(revealedAttributes: ContextDocument | string[]): Promise<SignedVerifiableCredential>;
+    derive(revealedAttributes: string[]): Promise<SignedVerifiableCredential>;
     verify(): Promise<boolean>;
     toString(): string;
     private isTransferableRecordsConfig;

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/dist/types/w3c/derive.d.ts

@@ -1,11 +1,11 @@
-import { SignedVerifiableCredential, ContextDocument, DerivedResult } from '@trustvc/w3c-vc';
+import { SignedVerifiableCredential, DerivedResult } from '@trustvc/w3c-vc';
 
 /**
  * Derives a credential with selective disclosure based on revealed attributes.
  * @param {object} credential - The verifiable credential to be selectively disclosed.
- * @param {object|string[]} revealedAttributes - For BBS+: The attributes from the credential that should be revealed. For ECDSA-SD-2023: Array of selective pointers.
+ * @param {string[]} revealedAttributes - Array of selective pointers.
  * @returns {Promise<DerivedResult>} A DerivedResult containing the derived proof or an error message.
  */
-declare const deriveW3C: (credential: SignedVerifiableCredential, revealedAttributes: ContextDocument | string[]) => Promise<DerivedResult>;
+declare const deriveW3C: (credential: SignedVerifiableCredential, revealedAttributes: string[]) => Promise<DerivedResult>;
 
 export { deriveW3C };

package/dist/types/w3c/sign.d.ts

@@ -6,8 +6,8 @@ import { PrivateKeyPair } from '@trustvc/w3c-issuer';
  * @param {RawVerifiableCredential} credential - The verifiable credential object that needs to be signed.
  * @param {PrivateKeyPair} keyPair - The private and public key pair used for signing the credential.
  * @param {CryptoSuiteName} [cryptoSuite='ecdsa-sd-2023'] - The cryptographic suite to be used for signing (default is 'ecdsa-sd-2023').
- * @param {object} [options] - Optional parameters including mandatoryPointers for ECDSA-SD-2023.
- * @param {string[]} [options.mandatoryPointers] - Optional mandatory pointers for ECDSA-SD-2023.
+ * @param {object} [options] - Optional parameters including mandatoryPointers for both ECDSA-SD-2023 / BBS-2023.
+ * @param {string[]} [options.mandatoryPointers] - Optional mandatory pointers for both ECDSA-SD-2023 / BBS-2023.
  * @returns {Promise<SigningResult>} A promise that resolves to the result of the signing operation, which includes the signed credential.
  */
 declare const signW3C: (credential: RawVerifiableCredential, keyPair: PrivateKeyPair, cryptoSuite?: CryptoSuiteName, options?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustvc/trustvc",
-  "version": "2.0.7",
+  "version": "2.2.0",
   "description": "TrustVC library",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -122,11 +122,11 @@
     "@tradetrust-tt/tradetrust": "^6.10.2",
     "@tradetrust-tt/tradetrust-utils": "^2.4.2",
     "@tradetrust-tt/tt-verify": "^9.6.0",
-    "@trustvc/w3c": "^1.3.0-alpha.11",
-    "@trustvc/w3c-context": "^1.3.0-alpha.10",
-    "@trustvc/w3c-credential-status": "^1.3.0-alpha.10",
-    "@trustvc/w3c-issuer": "^1.3.0-alpha.8",
-    "@trustvc/w3c-vc": "^1.3.0-alpha.11",
+    "@trustvc/w3c": "^1.3.0-alpha.14",
+    "@trustvc/w3c-context": "^1.3.0-alpha.12",
+    "@trustvc/w3c-credential-status": "^1.3.0-alpha.12",
+    "@trustvc/w3c-issuer": "^1.3.0-alpha.10",
+    "@trustvc/w3c-vc": "^1.3.0-alpha.14",
     "ethers": "^5.8.0",
     "ethersV6": "npm:ethers@^6.14.4",
     "js-sha3": "^0.9.3",