@credo-ts/core 0.6.1-pr-2091-20241119140918 → 0.6.1

package/build/modules/vc/data-integrity/SignatureSuiteRegistry.d.mts

@@ -0,0 +1,26 @@
+import { PublicJwk, SupportedPublicJwkClass } from "../../kms/jwk/PublicJwk.mjs";
+
+//#region src/modules/vc/data-integrity/SignatureSuiteRegistry.d.ts
+declare const LinkedDataSignature: any;
+declare const SignatureSuiteToken: unique symbol;
+interface SuiteInfo {
+  suiteClass: typeof LinkedDataSignature;
+  proofType: string;
+  verificationMethodTypes: string[];
+  supportedPublicJwkTypes: SupportedPublicJwkClass[];
+}
+declare class SignatureSuiteRegistry {
+  private suiteMapping;
+  constructor(suites: Array<SuiteInfo | 'default'>);
+  get supportedProofTypes(): string[];
+  /**
+   * @deprecated recommended to always search by key type instead as that will have broader support
+   */
+  getByVerificationMethodType(verificationMethodType: string): SuiteInfo | undefined;
+  getAllByPublicJwkType(publicJwkType: SupportedPublicJwkClass | PublicJwk): SuiteInfo[];
+  getByProofType(proofType: string): SuiteInfo;
+  getVerificationMethodTypesByProofType(proofType: string): string[];
+}
+//#endregion
+export { SignatureSuiteRegistry, SignatureSuiteToken, SuiteInfo };
+//# sourceMappingURL=SignatureSuiteRegistry.d.mts.map

package/build/modules/vc/data-integrity/SignatureSuiteRegistry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignatureSuiteRegistry.d.mts","names":[],"sources":["../../../../src/modules/vc/data-integrity/SignatureSuiteRegistry.ts"],"sourcesContent":[],"mappings":";;;cAMM;cAEO;UACI,SAAA;qBACI;EAJf,SAAA,EAAA,MAAA;EAEO,uBAAmD,EAAA,MAAA,EAAA;EAC/C,uBAAS,EAIC,uBAAA,EAAA;AAG3B;AAMmE,cALtD,sBAAA,CAKsD;EAAN,QAAA,YAAA;EAWM,WAAA,CAAA,MAAA,EAXN,KAWM,CAXA,SAWA,GAAA,SAAA,CAAA;EAIrB,IAAA,mBAAA,CAAA,CAAA,EAAA,MAAA,EAAA;EAA0B;;;EAK/B,2BAAA,CAAA,sBAAA,EAAA,MAAA,CAAA,EAT0B,SAS1B,GAAA,SAAA;uCALK,0BAA0B,YAAS;qCAKxC"}

package/build/modules/vc/data-integrity/SignatureSuiteRegistry.mjs

@@ -0,0 +1,52 @@
+
+
+import { CredoError } from "../../../error/CredoError.mjs";
+import "../../../error/index.mjs";
+import { injectAll, injectable } from "../../../plugins/index.mjs";
+import { __decorateMetadata } from "../../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorateMetadata.mjs";
+import { __decorate } from "../../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { PublicJwk } from "../../kms/jwk/PublicJwk.mjs";
+import { __decorateParam } from "../../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorateParam.mjs";
+import { suites } from "./libraries/jsonld-signatures.mjs";
+
+//#region src/modules/vc/data-integrity/SignatureSuiteRegistry.ts
+var _ref;
+suites.LinkedDataSignature;
+const SignatureSuiteToken = Symbol("SignatureSuiteToken");
+let SignatureSuiteRegistry = class SignatureSuiteRegistry$1 {
+	constructor(suites$1) {
+		this.suiteMapping = suites$1.filter((suite) => suite !== "default");
+	}
+	get supportedProofTypes() {
+		return this.suiteMapping.map((x) => x.proofType);
+	}
+	/**
+	* @deprecated recommended to always search by key type instead as that will have broader support
+	*/
+	getByVerificationMethodType(verificationMethodType) {
+		return this.suiteMapping.find((x) => x.verificationMethodTypes.includes(verificationMethodType));
+	}
+	getAllByPublicJwkType(publicJwkType) {
+		const publicJwkClass = publicJwkType instanceof PublicJwk ? publicJwkType.JwkClass : publicJwkType;
+		return this.suiteMapping.filter((x) => x.supportedPublicJwkTypes.includes(publicJwkClass));
+	}
+	getByProofType(proofType) {
+		const suiteInfo = this.suiteMapping.find((x) => x.proofType === proofType);
+		if (!suiteInfo) throw new CredoError(`No signature suite for proof type: ${proofType}`);
+		return suiteInfo;
+	}
+	getVerificationMethodTypesByProofType(proofType) {
+		const suiteInfo = this.suiteMapping.find((suiteInfo$1) => suiteInfo$1.proofType === proofType);
+		if (!suiteInfo) throw new CredoError(`No verification method type found for proof type: ${proofType}`);
+		return suiteInfo.verificationMethodTypes;
+	}
+};
+SignatureSuiteRegistry = __decorate([
+	injectable(),
+	__decorateParam(0, injectAll(SignatureSuiteToken)),
+	__decorateMetadata("design:paramtypes", [typeof (_ref = typeof Array !== "undefined" && Array) === "function" ? _ref : Object])
+], SignatureSuiteRegistry);
+
+//#endregion
+export { SignatureSuiteRegistry, SignatureSuiteToken };
+//# sourceMappingURL=SignatureSuiteRegistry.mjs.map

package/build/modules/vc/data-integrity/SignatureSuiteRegistry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignatureSuiteRegistry.mjs","names":["SignatureSuiteRegistry","suites: Array<SuiteInfo | 'default'>","suites","suiteInfo"],"sources":["../../../../src/modules/vc/data-integrity/SignatureSuiteRegistry.ts"],"sourcesContent":["import { CredoError } from '../../../error'\nimport { injectAll, injectable } from '../../../plugins'\nimport { PublicJwk, type SupportedPublicJwkClass } from '../../kms/jwk/PublicJwk'\n\nimport { suites } from './libraries/jsonld-signatures'\n\nconst LinkedDataSignature = suites.LinkedDataSignature\n\nexport const SignatureSuiteToken = Symbol('SignatureSuiteToken')\nexport interface SuiteInfo {\n  suiteClass: typeof LinkedDataSignature\n  proofType: string\n  verificationMethodTypes: string[]\n  supportedPublicJwkTypes: SupportedPublicJwkClass[]\n}\n\n@injectable()\nexport class SignatureSuiteRegistry {\n  private suiteMapping: SuiteInfo[]\n\n  // TODO: replace this signature suite token with just injecting and registering the suites\n  // on the registry. It's a bit ugly/awkward approach.\n  public constructor(@injectAll(SignatureSuiteToken) suites: Array<SuiteInfo | 'default'>) {\n    this.suiteMapping = suites.filter((suite): suite is SuiteInfo => suite !== 'default')\n  }\n\n  public get supportedProofTypes(): string[] {\n    return this.suiteMapping.map((x) => x.proofType)\n  }\n\n  /**\n   * @deprecated recommended to always search by key type instead as that will have broader support\n   */\n  public getByVerificationMethodType(verificationMethodType: string) {\n    return this.suiteMapping.find((x) => x.verificationMethodTypes.includes(verificationMethodType))\n  }\n\n  public getAllByPublicJwkType(publicJwkType: SupportedPublicJwkClass | PublicJwk) {\n    const publicJwkClass = publicJwkType instanceof PublicJwk ? publicJwkType.JwkClass : publicJwkType\n    return this.suiteMapping.filter((x) => x.supportedPublicJwkTypes.includes(publicJwkClass))\n  }\n\n  public getByProofType(proofType: string) {\n    const suiteInfo = this.suiteMapping.find((x) => x.proofType === proofType)\n\n    if (!suiteInfo) {\n      throw new CredoError(`No signature suite for proof type: ${proofType}`)\n    }\n\n    return suiteInfo\n  }\n\n  public getVerificationMethodTypesByProofType(proofType: string): string[] {\n    const suiteInfo = this.suiteMapping.find((suiteInfo) => suiteInfo.proofType === proofType)\n\n    if (!suiteInfo) {\n      throw new CredoError(`No verification method type found for proof type: ${proofType}`)\n    }\n\n    return suiteInfo.verificationMethodTypes\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAM4B,OAAO;AAEnC,MAAa,sBAAsB,OAAO,sBAAsB;AASzD,mCAAMA,yBAAuB;CAKlC,AAAO,YAAY,AAAgCC,UAAsC;AACvF,OAAK,eAAeC,SAAO,QAAQ,UAA8B,UAAU,UAAU;;CAGvF,IAAW,sBAAgC;AACzC,SAAO,KAAK,aAAa,KAAK,MAAM,EAAE,UAAU;;;;;CAMlD,AAAO,4BAA4B,wBAAgC;AACjE,SAAO,KAAK,aAAa,MAAM,MAAM,EAAE,wBAAwB,SAAS,uBAAuB,CAAC;;CAGlG,AAAO,sBAAsB,eAAoD;EAC/E,MAAM,iBAAiB,yBAAyB,YAAY,cAAc,WAAW;AACrF,SAAO,KAAK,aAAa,QAAQ,MAAM,EAAE,wBAAwB,SAAS,eAAe,CAAC;;CAG5F,AAAO,eAAe,WAAmB;EACvC,MAAM,YAAY,KAAK,aAAa,MAAM,MAAM,EAAE,cAAc,UAAU;AAE1E,MAAI,CAAC,UACH,OAAM,IAAI,WAAW,sCAAsC,YAAY;AAGzE,SAAO;;CAGT,AAAO,sCAAsC,WAA6B;EACxE,MAAM,YAAY,KAAK,aAAa,MAAM,gBAAcC,YAAU,cAAc,UAAU;AAE1F,MAAI,CAAC,UACH,OAAM,IAAI,WAAW,qDAAqD,YAAY;AAGxF,SAAO,UAAU;;;;CA3CpB,YAAY;oBAMS,UAAU,oBAAoB"}

package/build/modules/vc/data-integrity/W3cJsonLdCredentialService.d.mts

@@ -0,0 +1,53 @@
+import { W3cJsonLdVerifiableCredential } from "./models/W3cJsonLdVerifiableCredential.mjs";
+import { W3cVerifyCredentialResult, W3cVerifyPresentationResult } from "../models/W3cVerifyResult.mjs";
+import "../models/index.mjs";
+import { W3cJsonLdSignCredentialOptions, W3cJsonLdSignPresentationOptions, W3cJsonLdVerifyCredentialOptions, W3cJsonLdVerifyPresentationOptions } from "../W3cCredentialServiceOptions.mjs";
+import { W3cJsonLdVerifiablePresentation } from "./models/W3cJsonLdVerifiablePresentation.mjs";
+import "./models/index.mjs";
+import { SignatureSuiteRegistry } from "./SignatureSuiteRegistry.mjs";
+import { W3cCredentialsModuleConfig } from "../W3cCredentialsModuleConfig.mjs";
+import { AgentContext } from "../../../agent/context/AgentContext.mjs";
+import "../../../agent/context/index.mjs";
+
+//#region src/modules/vc/data-integrity/W3cJsonLdCredentialService.d.ts
+/**
+ * Supports signing and verification of credentials according to the [Verifiable Credential Data Model](https://www.w3.org/TR/vc-data-model)
+ * using [Data Integrity Proof](https://www.w3.org/TR/vc-data-model/#data-integrity-proofs).
+ */
+declare class W3cJsonLdCredentialService {
+  private signatureSuiteRegistry;
+  private w3cCredentialsModuleConfig;
+  constructor(signatureSuiteRegistry: SignatureSuiteRegistry, w3cCredentialsModuleConfig: W3cCredentialsModuleConfig);
+  /**
+   * Signs a credential
+   */
+  signCredential(agentContext: AgentContext, options: W3cJsonLdSignCredentialOptions): Promise<W3cJsonLdVerifiableCredential>;
+  /**
+   * Verifies the signature(s) of a credential
+   *
+   * @param credential the credential to be verified
+   * @returns the verification result
+   */
+  verifyCredential(agentContext: AgentContext, options: W3cJsonLdVerifyCredentialOptions): Promise<W3cVerifyCredentialResult>;
+  /**
+   * Signs a presentation including the credentials it includes
+   *
+   * @param presentation the presentation to be signed
+   * @returns the signed presentation
+   */
+  signPresentation(agentContext: AgentContext, options: W3cJsonLdSignPresentationOptions): Promise<W3cJsonLdVerifiablePresentation>;
+  /**
+   * Verifies a presentation including the credentials it includes
+   *
+   * @param presentation the presentation to be verified
+   * @returns the verification result
+   */
+  verifyPresentation(agentContext: AgentContext, options: W3cJsonLdVerifyPresentationOptions): Promise<W3cVerifyPresentationResult>;
+  getVerificationMethodTypesByProofType(proofType: string): string[];
+  getExpandedTypesForCredential(agentContext: AgentContext, credential: W3cJsonLdVerifiableCredential): Promise<string[]>;
+  private getPublicJwkFromVerificationMethod;
+  private getSignatureSuitesForCredential;
+}
+//#endregion
+export { W3cJsonLdCredentialService };
+//# sourceMappingURL=W3cJsonLdCredentialService.d.mts.map

package/build/modules/vc/data-integrity/W3cJsonLdCredentialService.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"W3cJsonLdCredentialService.d.mts","names":[],"sources":["../../../../src/modules/vc/data-integrity/W3cJsonLdCredentialService.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;cA+Ba,0BAAA;;;EAAA,WAAA,CAAA,sBAA0B,EAKX,sBALW,EAAA,0BAAA,EAMP,0BANO;EAKX;;;EAYf,cAAA,CAAA,YAAA,EADK,YACL,EAAA,OAAA,EAAA,8BAAA,CAAA,EACR,OADQ,CACA,6BADA,CAAA;EACA;;;;;;EAwHK,gBAAA,CAAA,YAAA,EAnEA,YAmEA,EAAA,OAAA,EAlEL,gCAkEK,CAAA,EAjEb,OAiEa,CAjEL,yBAiEK,CAAA;EACL;;;;;;EAmER,gBAAA,CAAA,YAAA,EApEa,YAoEb,EAAA,OAAA,EAnEQ,gCAmER,CAAA,EAlEA,OAkEA,CAlEQ,+BAkER,CAAA;EA6EsD;;;;;;mCA/EzC,uBACL,qCACR,QAAQ;;8CA6E8C,0BAA0B,gCAA6B"}

package/build/modules/vc/data-integrity/W3cJsonLdCredentialService.mjs

@@ -0,0 +1,232 @@
+
+
+import { CredoError } from "../../../error/CredoError.mjs";
+import "../../../error/index.mjs";
+import { injectable } from "../../../plugins/index.mjs";
+import { __decorateMetadata } from "../../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorateMetadata.mjs";
+import { __decorate } from "../../../_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { asArray } from "../../../utils/array.mjs";
+import { JsonTransformer } from "../../../utils/JsonTransformer.mjs";
+import "../../../utils/index.mjs";
+import "../../kms/index.mjs";
+import { parseDid } from "../../dids/domain/parse.mjs";
+import { VerificationMethod } from "../../dids/domain/verificationMethod/VerificationMethod.mjs";
+import { getPublicJwkFromVerificationMethod } from "../../dids/domain/key-type/keyDidMapping.mjs";
+import "../../dids/domain/key-type/index.mjs";
+import { DidsApi } from "../../dids/DidsApi.mjs";
+import "../../dids/index.mjs";
+import jsonld_default from "./libraries/jsonld.mjs";
+import { W3cJsonLdVerifiableCredential } from "./models/W3cJsonLdVerifiableCredential.mjs";
+import { assertOnlyW3cJsonLdVerifiableCredentials } from "./jsonldUtil.mjs";
+import vc_default from "./libraries/vc.mjs";
+import { w3cDate } from "../util.mjs";
+import { W3cJsonLdVerifiablePresentation } from "./models/W3cJsonLdVerifiablePresentation.mjs";
+import "./models/index.mjs";
+import { SignatureSuiteRegistry } from "./SignatureSuiteRegistry.mjs";
+import { createKmsKeyPairClass } from "../../../crypto/KmsKeyPair.mjs";
+import { W3cCredentialsModuleConfig } from "../W3cCredentialsModuleConfig.mjs";
+
+//#region src/modules/vc/data-integrity/W3cJsonLdCredentialService.ts
+var _ref, _ref2;
+let W3cJsonLdCredentialService = class W3cJsonLdCredentialService$1 {
+	constructor(signatureSuiteRegistry, w3cCredentialsModuleConfig) {
+		this.signatureSuiteRegistry = signatureSuiteRegistry;
+		this.w3cCredentialsModuleConfig = w3cCredentialsModuleConfig;
+	}
+	/**
+	* Signs a credential
+	*/
+	async signCredential(agentContext, options) {
+		const WalletKeyPair = createKmsKeyPairClass(agentContext);
+		const signingKey = await this.getPublicJwkFromVerificationMethod(agentContext, options.verificationMethod);
+		const suiteInfo = this.signatureSuiteRegistry.getByProofType(options.proofType);
+		if (!this.signatureSuiteRegistry.getAllByPublicJwkType(signingKey).some(({ suiteClass }) => suiteClass === suiteInfo.suiteClass)) throw new CredoError("The key type of the verification method does not match the suite");
+		const keyPair = new WalletKeyPair({
+			controller: options.credential.issuerId,
+			id: options.verificationMethod,
+			publicJwk: signingKey
+		});
+		const SuiteClass = suiteInfo.suiteClass;
+		const suite = new SuiteClass({
+			key: keyPair,
+			LDKeyClass: WalletKeyPair,
+			proof: { verificationMethod: options.verificationMethod },
+			useNativeCanonize: false,
+			date: options.created ?? w3cDate()
+		});
+		try {
+			const result = await vc_default.issue({
+				credential: JsonTransformer.toJSON(options.credential),
+				suite,
+				purpose: options.proofPurpose,
+				documentLoader: this.w3cCredentialsModuleConfig.documentLoader(agentContext)
+			});
+			return JsonTransformer.fromJSON(result, W3cJsonLdVerifiableCredential);
+		} catch (error) {
+			throw new CredoError(`Error issuing W3C JSON-LD VC. ${error.message}`, { cause: error });
+		}
+	}
+	/**
+	* Verifies the signature(s) of a credential
+	*
+	* @param credential the credential to be verified
+	* @returns the verification result
+	*/
+	async verifyCredential(agentContext, options) {
+		try {
+			const verifyCredentialStatus = options.verifyCredentialStatus ?? true;
+			const suites = this.getSignatureSuitesForCredential(agentContext, options.credential);
+			const verifyOptions = {
+				credential: JsonTransformer.toJSON(options.credential),
+				suite: suites,
+				documentLoader: this.w3cCredentialsModuleConfig.documentLoader(agentContext),
+				checkStatus: ({ credential }) => {
+					if (verifyCredentialStatus && "credentialStatus" in credential) throw new CredoError("Verifying credential status for JSON-LD credentials is currently not supported");
+					return { verified: true };
+				}
+			};
+			if (options.proofPurpose) verifyOptions.purpose = options.proofPurpose;
+			const result = await vc_default.verifyCredential(verifyOptions);
+			const { verified: isValid, ...remainingResult } = result;
+			if (!isValid) agentContext.config.logger.debug(`Credential verification failed: ${result.error?.message}`, { stack: result.error?.stack });
+			return {
+				isValid,
+				validations: { vcJs: {
+					isValid,
+					...remainingResult
+				} },
+				error: result.error
+			};
+		} catch (error) {
+			return {
+				isValid: false,
+				validations: {},
+				error
+			};
+		}
+	}
+	/**
+	* Signs a presentation including the credentials it includes
+	*
+	* @param presentation the presentation to be signed
+	* @returns the signed presentation
+	*/
+	async signPresentation(agentContext, options) {
+		const WalletKeyPair = createKmsKeyPairClass(agentContext);
+		const suiteInfo = this.signatureSuiteRegistry.getByProofType(options.proofType);
+		if (!suiteInfo) throw new CredoError(`The requested proofType ${options.proofType} is not supported`);
+		const signingKey = await this.getPublicJwkFromVerificationMethod(agentContext, options.verificationMethod);
+		if (!this.signatureSuiteRegistry.getAllByPublicJwkType(signingKey).some(({ suiteClass }) => suiteClass === suiteInfo.suiteClass)) throw new CredoError("The key type of the verification method does not match the suite");
+		const verificationMethodObject = (await this.w3cCredentialsModuleConfig.documentLoader(agentContext)(options.verificationMethod)).document;
+		const keyPair = new WalletKeyPair({
+			controller: verificationMethodObject.controller,
+			id: options.verificationMethod,
+			publicJwk: signingKey
+		});
+		const suite = new suiteInfo.suiteClass({
+			LDKeyClass: WalletKeyPair,
+			proof: { verificationMethod: options.verificationMethod },
+			date: (/* @__PURE__ */ new Date()).toISOString(),
+			key: keyPair,
+			useNativeCanonize: false
+		});
+		const signOptions = {
+			presentation: JsonTransformer.toJSON(options.presentation),
+			suite,
+			challenge: options.challenge,
+			domain: options.domain,
+			documentLoader: this.w3cCredentialsModuleConfig.documentLoader(agentContext)
+		};
+		if (options.proofPurpose) signOptions.purpose = options.proofPurpose;
+		const result = await vc_default.signPresentation(signOptions);
+		return JsonTransformer.fromJSON(result, W3cJsonLdVerifiablePresentation);
+	}
+	/**
+	* Verifies a presentation including the credentials it includes
+	*
+	* @param presentation the presentation to be verified
+	* @returns the verification result
+	*/
+	async verifyPresentation(agentContext, options) {
+		try {
+			const WalletKeyPair = createKmsKeyPairClass(agentContext);
+			let proofs = options.presentation.proof;
+			if (!Array.isArray(proofs)) proofs = [proofs];
+			if (options.purpose) proofs = proofs.filter((proof) => proof.proofPurpose === options.purpose.term);
+			const presentationSuites = proofs.map((proof) => {
+				const SuiteClass = this.signatureSuiteRegistry.getByProofType(proof.type).suiteClass;
+				return new SuiteClass({
+					LDKeyClass: WalletKeyPair,
+					proof: { verificationMethod: proof.verificationMethod },
+					date: proof.created,
+					useNativeCanonize: false
+				});
+			});
+			const credentials = asArray(options.presentation.verifiableCredential);
+			assertOnlyW3cJsonLdVerifiableCredentials(credentials);
+			const credentialSuites = credentials.map((credential) => this.getSignatureSuitesForCredential(agentContext, credential));
+			const allSuites = presentationSuites.concat(...credentialSuites);
+			const verifyOptions = {
+				presentation: JsonTransformer.toJSON(options.presentation),
+				suite: allSuites,
+				challenge: options.challenge,
+				domain: options.domain,
+				documentLoader: this.w3cCredentialsModuleConfig.documentLoader(agentContext)
+			};
+			if (options.purpose) verifyOptions.presentationPurpose = options.purpose;
+			const result = await vc_default.verify(verifyOptions);
+			const { verified: isValid, ...remainingResult } = result;
+			return {
+				isValid,
+				validations: { vcJs: {
+					isValid,
+					...remainingResult
+				} },
+				error: result.error
+			};
+		} catch (error) {
+			return {
+				isValid: false,
+				validations: {},
+				error
+			};
+		}
+	}
+	getVerificationMethodTypesByProofType(proofType) {
+		return this.signatureSuiteRegistry.getByProofType(proofType).verificationMethodTypes;
+	}
+	async getExpandedTypesForCredential(agentContext, credential) {
+		const expandedTypes = (await jsonld_default.expand(JsonTransformer.toJSON(credential), { documentLoader: this.w3cCredentialsModuleConfig.documentLoader(agentContext) }))[0]["@type"];
+		return asArray(expandedTypes);
+	}
+	async getPublicJwkFromVerificationMethod(agentContext, verificationMethod) {
+		const dids = agentContext.resolve(DidsApi);
+		const verificationMethodObject = await this.w3cCredentialsModuleConfig.documentLoader(agentContext)(verificationMethod);
+		const verificationMethodInstance = JsonTransformer.fromJSON(verificationMethodObject.document, VerificationMethod);
+		const did = parseDid(verificationMethod);
+		const publicJwk = getPublicJwkFromVerificationMethod(verificationMethodInstance);
+		const [didRecord] = await dids.getCreatedDids({ did: did.did });
+		if (didRecord) publicJwk.keyId = didRecord.keys?.find(({ didDocumentRelativeKeyId }) => didDocumentRelativeKeyId === `#${did.fragment}`)?.kmsKeyId ?? publicJwk.legacyKeyId;
+		else publicJwk.keyId = publicJwk.legacyKeyId;
+		return publicJwk;
+	}
+	getSignatureSuitesForCredential(agentContext, credential) {
+		const WalletKeyPair = createKmsKeyPairClass(agentContext);
+		let proofs = credential.proof;
+		if (!Array.isArray(proofs)) proofs = [proofs];
+		return proofs.map((proof) => {
+			const SuiteClass = this.signatureSuiteRegistry.getByProofType(proof.type).suiteClass;
+			return new SuiteClass({
+				LDKeyClass: WalletKeyPair,
+				proof: { verificationMethod: proof.verificationMethod },
+				date: proof.created,
+				useNativeCanonize: false
+			});
+		});
+	}
+};
+W3cJsonLdCredentialService = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof (_ref = typeof SignatureSuiteRegistry !== "undefined" && SignatureSuiteRegistry) === "function" ? _ref : Object, typeof (_ref2 = typeof W3cCredentialsModuleConfig !== "undefined" && W3cCredentialsModuleConfig) === "function" ? _ref2 : Object])], W3cJsonLdCredentialService);
+
+//#endregion
+export { W3cJsonLdCredentialService };
+//# sourceMappingURL=W3cJsonLdCredentialService.mjs.map

package/build/modules/vc/data-integrity/W3cJsonLdCredentialService.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"W3cJsonLdCredentialService.mjs","names":["W3cJsonLdCredentialService","vc","verifyOptions: Record<string, unknown>","signOptions: Record<string, unknown>","expandedTypes: SingleOrArray<string>","jsonld"],"sources":["../../../../src/modules/vc/data-integrity/W3cJsonLdCredentialService.ts"],"sourcesContent":["import type { AgentContext } from '../../../agent/context'\nimport { createKmsKeyPairClass } from '../../../crypto/KmsKeyPair'\nimport { CredoError } from '../../../error'\nimport { injectable } from '../../../plugins'\nimport type { SingleOrArray } from '../../../types'\nimport { asArray, JsonTransformer } from '../../../utils'\nimport { DidsApi, parseDid, VerificationMethod } from '../../dids'\nimport { getPublicJwkFromVerificationMethod } from '../../dids/domain/key-type'\nimport { PublicJwk } from '../../kms'\nimport type { W3cVerifyCredentialResult, W3cVerifyPresentationResult } from '../models'\nimport type { W3cJsonCredential } from '../models/credential/W3cJsonCredential'\nimport { w3cDate } from '../util'\nimport type {\n  W3cJsonLdSignCredentialOptions,\n  W3cJsonLdSignPresentationOptions,\n  W3cJsonLdVerifyCredentialOptions,\n  W3cJsonLdVerifyPresentationOptions,\n} from '../W3cCredentialServiceOptions'\nimport { W3cCredentialsModuleConfig } from '../W3cCredentialsModuleConfig'\nimport { assertOnlyW3cJsonLdVerifiableCredentials } from './jsonldUtil'\nimport jsonld from './libraries/jsonld'\nimport vc from './libraries/vc'\nimport { W3cJsonLdVerifiableCredential } from './models'\nimport { W3cJsonLdVerifiablePresentation } from './models/W3cJsonLdVerifiablePresentation'\nimport { SignatureSuiteRegistry } from './SignatureSuiteRegistry'\n\n/**\n * Supports signing and verification of credentials according to the [Verifiable Credential Data Model](https://www.w3.org/TR/vc-data-model)\n * using [Data Integrity Proof](https://www.w3.org/TR/vc-data-model/#data-integrity-proofs).\n */\n@injectable()\nexport class W3cJsonLdCredentialService {\n  private signatureSuiteRegistry: SignatureSuiteRegistry\n  private w3cCredentialsModuleConfig: W3cCredentialsModuleConfig\n\n  public constructor(\n    signatureSuiteRegistry: SignatureSuiteRegistry,\n    w3cCredentialsModuleConfig: W3cCredentialsModuleConfig\n  ) {\n    this.signatureSuiteRegistry = signatureSuiteRegistry\n    this.w3cCredentialsModuleConfig = w3cCredentialsModuleConfig\n  }\n\n  /**\n   * Signs a credential\n   */\n  public async signCredential(\n    agentContext: AgentContext,\n    options: W3cJsonLdSignCredentialOptions\n  ): Promise<W3cJsonLdVerifiableCredential> {\n    const WalletKeyPair = createKmsKeyPairClass(agentContext)\n\n    const signingKey = await this.getPublicJwkFromVerificationMethod(agentContext, options.verificationMethod)\n    const suiteInfo = this.signatureSuiteRegistry.getByProofType(options.proofType)\n\n    const suitesForKey = this.signatureSuiteRegistry.getAllByPublicJwkType(signingKey)\n\n    if (!suitesForKey.some(({ suiteClass }) => suiteClass === suiteInfo.suiteClass)) {\n      throw new CredoError('The key type of the verification method does not match the suite')\n    }\n\n    const keyPair = new WalletKeyPair({\n      controller: options.credential.issuerId, // should we check this against the verificationMethod.controller?\n      id: options.verificationMethod,\n      publicJwk: signingKey,\n    })\n\n    const SuiteClass = suiteInfo.suiteClass\n\n    const suite = new SuiteClass({\n      key: keyPair,\n      LDKeyClass: WalletKeyPair,\n      proof: {\n        verificationMethod: options.verificationMethod,\n      },\n      useNativeCanonize: false,\n      date: options.created ?? w3cDate(),\n    })\n\n    try {\n      const result = await vc.issue({\n        credential: JsonTransformer.toJSON(options.credential),\n        suite: suite,\n        purpose: options.proofPurpose,\n        documentLoader: this.w3cCredentialsModuleConfig.documentLoader(agentContext),\n      })\n\n      return JsonTransformer.fromJSON(result, W3cJsonLdVerifiableCredential)\n    } catch (error) {\n      throw new CredoError(`Error issuing W3C JSON-LD VC. ${error.message}`, {\n        cause: error,\n      })\n    }\n  }\n\n  /**\n   * Verifies the signature(s) of a credential\n   *\n   * @param credential the credential to be verified\n   * @returns the verification result\n   */\n  public async verifyCredential(\n    agentContext: AgentContext,\n    options: W3cJsonLdVerifyCredentialOptions\n  ): Promise<W3cVerifyCredentialResult> {\n    try {\n      const verifyCredentialStatus = options.verifyCredentialStatus ?? true\n\n      const suites = this.getSignatureSuitesForCredential(agentContext, options.credential)\n\n      const verifyOptions: Record<string, unknown> = {\n        credential: JsonTransformer.toJSON(options.credential),\n        suite: suites,\n        documentLoader: this.w3cCredentialsModuleConfig.documentLoader(agentContext),\n        checkStatus: ({ credential }: { credential: W3cJsonCredential }) => {\n          // Only throw error if credentialStatus is present\n          if (verifyCredentialStatus && 'credentialStatus' in credential) {\n            throw new CredoError('Verifying credential status for JSON-LD credentials is currently not supported')\n          }\n          return {\n            verified: true,\n          }\n        },\n      }\n\n      // this is a hack because vcjs throws if purpose is passed as undefined or null\n      if (options.proofPurpose) {\n        verifyOptions.purpose = options.proofPurpose\n      }\n\n      const result = await vc.verifyCredential(verifyOptions)\n\n      const { verified: isValid, ...remainingResult } = result\n\n      if (!isValid) {\n        agentContext.config.logger.debug(`Credential verification failed: ${result.error?.message}`, {\n          stack: result.error?.stack,\n        })\n      }\n\n      // We map the result to our own result type to make it easier to work with\n      // however, for now we just add a single vcJs validation result as we don't\n      // have access to the internal validation results of vc-js\n      return {\n        isValid,\n        validations: {\n          vcJs: {\n            isValid,\n            ...remainingResult,\n          },\n        },\n        error: result.error,\n      }\n    } catch (error) {\n      return {\n        isValid: false,\n        validations: {},\n        error,\n      }\n    }\n  }\n\n  /**\n   * Signs a presentation including the credentials it includes\n   *\n   * @param presentation the presentation to be signed\n   * @returns the signed presentation\n   */\n  public async signPresentation(\n    agentContext: AgentContext,\n    options: W3cJsonLdSignPresentationOptions\n  ): Promise<W3cJsonLdVerifiablePresentation> {\n    // create keyPair\n    const WalletKeyPair = createKmsKeyPairClass(agentContext)\n\n    const suiteInfo = this.signatureSuiteRegistry.getByProofType(options.proofType)\n\n    if (!suiteInfo) {\n      throw new CredoError(`The requested proofType ${options.proofType} is not supported`)\n    }\n\n    const signingKey = await this.getPublicJwkFromVerificationMethod(agentContext, options.verificationMethod)\n    const suitesForKey = this.signatureSuiteRegistry.getAllByPublicJwkType(signingKey)\n\n    if (!suitesForKey.some(({ suiteClass }) => suiteClass === suiteInfo.suiteClass)) {\n      throw new CredoError('The key type of the verification method does not match the suite')\n    }\n\n    const documentLoader = this.w3cCredentialsModuleConfig.documentLoader(agentContext)\n    const verificationMethodObject = (await documentLoader(options.verificationMethod)).document as Record<\n      string,\n      unknown\n    >\n\n    const keyPair = new WalletKeyPair({\n      controller: verificationMethodObject.controller as string,\n      id: options.verificationMethod,\n      publicJwk: signingKey,\n    })\n\n    const suite = new suiteInfo.suiteClass({\n      LDKeyClass: WalletKeyPair,\n      proof: {\n        verificationMethod: options.verificationMethod,\n      },\n      date: new Date().toISOString(),\n      key: keyPair,\n      useNativeCanonize: false,\n    })\n\n    const signOptions: Record<string, unknown> = {\n      presentation: JsonTransformer.toJSON(options.presentation),\n      suite: suite,\n      challenge: options.challenge,\n      domain: options.domain,\n      documentLoader: this.w3cCredentialsModuleConfig.documentLoader(agentContext),\n    }\n\n    // this is a hack because vcjs throws if purpose is passed as undefined or null\n    if (options.proofPurpose) {\n      signOptions.purpose = options.proofPurpose\n    }\n\n    const result = await vc.signPresentation(signOptions)\n\n    return JsonTransformer.fromJSON(result, W3cJsonLdVerifiablePresentation)\n  }\n\n  /**\n   * Verifies a presentation including the credentials it includes\n   *\n   * @param presentation the presentation to be verified\n   * @returns the verification result\n   */\n  public async verifyPresentation(\n    agentContext: AgentContext,\n    options: W3cJsonLdVerifyPresentationOptions\n  ): Promise<W3cVerifyPresentationResult> {\n    try {\n      // create keyPair\n      const WalletKeyPair = createKmsKeyPairClass(agentContext)\n\n      let proofs = options.presentation.proof\n\n      if (!Array.isArray(proofs)) {\n        proofs = [proofs]\n      }\n      if (options.purpose) {\n        proofs = proofs.filter((proof) => proof.proofPurpose === options.purpose.term)\n      }\n\n      const presentationSuites = proofs.map((proof) => {\n        const SuiteClass = this.signatureSuiteRegistry.getByProofType(proof.type).suiteClass\n        return new SuiteClass({\n          LDKeyClass: WalletKeyPair,\n          proof: {\n            verificationMethod: proof.verificationMethod,\n          },\n          date: proof.created,\n          useNativeCanonize: false,\n        })\n      })\n\n      const credentials = asArray(options.presentation.verifiableCredential)\n      assertOnlyW3cJsonLdVerifiableCredentials(credentials)\n\n      const credentialSuites = credentials.map((credential) =>\n        this.getSignatureSuitesForCredential(agentContext, credential)\n      )\n      const allSuites = presentationSuites.concat(...credentialSuites)\n\n      const verifyOptions: Record<string, unknown> = {\n        presentation: JsonTransformer.toJSON(options.presentation),\n        suite: allSuites,\n        challenge: options.challenge,\n        domain: options.domain,\n        documentLoader: this.w3cCredentialsModuleConfig.documentLoader(agentContext),\n      }\n\n      // this is a hack because vcjs throws if purpose is passed as undefined or null\n      if (options.purpose) {\n        verifyOptions.presentationPurpose = options.purpose\n      }\n\n      const result = await vc.verify(verifyOptions)\n\n      const { verified: isValid, ...remainingResult } = result\n\n      // We map the result to our own result type to make it easier to work with\n      // however, for now we just add a single vcJs validation result as we don't\n      // have access to the internal validation results of vc-js\n      return {\n        isValid,\n        validations: {\n          vcJs: {\n            isValid,\n            ...remainingResult,\n          },\n        },\n        error: result.error,\n      }\n    } catch (error) {\n      return {\n        isValid: false,\n        validations: {},\n        error,\n      }\n    }\n  }\n\n  public getVerificationMethodTypesByProofType(proofType: string): string[] {\n    return this.signatureSuiteRegistry.getByProofType(proofType).verificationMethodTypes\n  }\n\n  public async getExpandedTypesForCredential(agentContext: AgentContext, credential: W3cJsonLdVerifiableCredential) {\n    // Get the expanded types\n    const expandedTypes: SingleOrArray<string> = (\n      await jsonld.expand(JsonTransformer.toJSON(credential), {\n        documentLoader: this.w3cCredentialsModuleConfig.documentLoader(agentContext),\n      })\n    )[0]['@type']\n\n    return asArray(expandedTypes)\n  }\n\n  private async getPublicJwkFromVerificationMethod(\n    agentContext: AgentContext,\n    verificationMethod: string\n  ): Promise<PublicJwk> {\n    const dids = agentContext.resolve(DidsApi)\n\n    const documentLoader = this.w3cCredentialsModuleConfig.documentLoader(agentContext)\n    const verificationMethodObject = await documentLoader(verificationMethod)\n    const verificationMethodInstance = JsonTransformer.fromJSON(verificationMethodObject.document, VerificationMethod)\n    const did = parseDid(verificationMethod)\n    const publicJwk = getPublicJwkFromVerificationMethod(verificationMethodInstance)\n\n    const [didRecord] = await dids.getCreatedDids({ did: did.did })\n\n    // For all modern uses of did bound credentials there MUST be a did record\n    if (didRecord) {\n      publicJwk.keyId =\n        didRecord.keys?.find(({ didDocumentRelativeKeyId }) => didDocumentRelativeKeyId === `#${did.fragment}`)\n          ?.kmsKeyId ?? publicJwk.legacyKeyId\n    } else {\n      // If we don't have a did record we assume legacy key id should be used.\n      publicJwk.keyId = publicJwk.legacyKeyId\n    }\n\n    return publicJwk\n  }\n\n  private getSignatureSuitesForCredential(agentContext: AgentContext, credential: W3cJsonLdVerifiableCredential) {\n    const WalletKeyPair = createKmsKeyPairClass(agentContext)\n\n    let proofs = credential.proof\n\n    if (!Array.isArray(proofs)) {\n      proofs = [proofs]\n    }\n\n    return proofs.map((proof) => {\n      const SuiteClass = this.signatureSuiteRegistry.getByProofType(proof.type).suiteClass\n      return new SuiteClass({\n        LDKeyClass: WalletKeyPair,\n        proof: {\n          verificationMethod: proof.verificationMethod,\n        },\n        date: proof.created,\n        useNativeCanonize: false,\n      })\n    })\n  }\n}\n"],"mappings":"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"}

package/build/modules/vc/data-integrity/deriveProof.d.mts

@@ -0,0 +1,27 @@
+import { JsonObject } from "../../../types.mjs";
+import { W3cJsonLdVerifiableCredential } from "./models/W3cJsonLdVerifiableCredential.mjs";
+
+//#region src/modules/vc/data-integrity/deriveProof.d.ts
+interface W3cJsonLdDeriveProofOptions {
+  credential: W3cJsonLdVerifiableCredential;
+  revealDocument: JsonObject;
+  verificationMethod: string;
+}
+/**
+ * Derives a proof from a document featuring a supported linked data proof
+ *
+ * NOTE - This is a temporary API extending JSON-LD signatures
+ *
+ * @param proofDocument A document featuring a linked data proof capable of proof derivation
+ * @param revealDocument A document of the form of a JSON-LD frame describing the terms to selectively derive from the proof document
+ * @param options Options for proof derivation
+ */
+declare const deriveProof: (proofDocument: JsonObject, revealDocument: JsonObject, {
+  suite,
+  skipProofCompaction,
+  documentLoader,
+  nonce
+}: any) => Promise<W3cJsonLdVerifiableCredential>;
+//#endregion
+export { W3cJsonLdDeriveProofOptions, deriveProof };
+//# sourceMappingURL=deriveProof.d.mts.map

package/build/modules/vc/data-integrity/deriveProof.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveProof.d.mts","names":[],"sources":["../../../../src/modules/vc/data-integrity/deriveProof.ts"],"sourcesContent":[],"mappings":";;;;UAsBiB,2BAAA;cACH;kBACI;;AAFlB;AAeA;;;;;;;;;AAKU,cALG,WAKH,EAAA,CAAA,aAAA,EAJO,UAIP,EAAA,cAAA,EAHQ,UAGR,EAAA;EAAA,KAAA;EAAA,mBAAA;EAAA,cAAA;EAAA;AAAA,CAAA,EAAA,GAAA,EAAA,GAAP,OAAO,CAAC,6BAAD,CAAA"}

package/build/modules/vc/data-integrity/deriveProof.mjs

@@ -0,0 +1,80 @@
+
+
+import { JsonTransformer } from "../../../utils/JsonTransformer.mjs";
+import "../../../utils/index.mjs";
+import { SECURITY_PROOF_URL } from "../constants.mjs";
+import jsonld_default from "./libraries/jsonld.mjs";
+import { W3cJsonLdVerifiableCredential } from "./models/W3cJsonLdVerifiableCredential.mjs";
+import { getProofs, getTypeInfo } from "./jsonldUtil.mjs";
+
+//#region src/modules/vc/data-integrity/deriveProof.ts
+/**
+* Derives a proof from a document featuring a supported linked data proof
+*
+* NOTE - This is a temporary API extending JSON-LD signatures
+*
+* @param proofDocument A document featuring a linked data proof capable of proof derivation
+* @param revealDocument A document of the form of a JSON-LD frame describing the terms to selectively derive from the proof document
+* @param options Options for proof derivation
+*/
+const deriveProof = async (proofDocument, revealDocument, { suite, skipProofCompaction, documentLoader, nonce }) => {
+	if (!suite) throw new TypeError("\"options.suite\" is required.");
+	if (Array.isArray(proofDocument)) throw new TypeError("proofDocument should be an object not an array.");
+	const { proofs, document } = await getProofs({
+		document: proofDocument,
+		proofType: suite.supportedDeriveProofType,
+		documentLoader
+	});
+	if (proofs.length === 0) throw new Error("There were not any proofs provided that can be used to derive a proof with this suite.");
+	let derivedProof = await suite.deriveProof({
+		document,
+		proof: proofs[0],
+		revealDocument,
+		documentLoader,
+		nonce
+	});
+	if (proofs.length > 1) {
+		derivedProof = {
+			...derivedProof,
+			proof: [derivedProof.proof]
+		};
+		proofs.splice(0, 1);
+		for (const proof of proofs) {
+			const additionalDerivedProofValue = await suite.deriveProof({
+				document,
+				proof,
+				revealDocument,
+				documentLoader
+			});
+			derivedProof.proof.push(additionalDerivedProofValue.proof);
+		}
+	}
+	if (!skipProofCompaction) {
+		const expandedProof = { [SECURITY_PROOF_URL]: { "@graph": derivedProof.proof } };
+		const { types, alias } = await getTypeInfo(derivedProof.document, { documentLoader });
+		expandedProof["@type"] = types;
+		const ctx = jsonld_default.getValues(derivedProof.document, "@context");
+		const compactProof = await jsonld_default.compact(expandedProof, ctx, {
+			documentLoader,
+			compactToRelative: false
+		});
+		delete compactProof[alias];
+		delete compactProof["@context"];
+		/**
+		* removes the @included tag when multiple proofs exist because the
+		* @included tag messes up the canonicalized bytes leading to a bad
+		* signature that won't verify.
+		**/
+		if (compactProof.proof?.["@included"]) compactProof.proof = compactProof.proof["@included"];
+		const key = Object.keys(compactProof)[0];
+		jsonld_default.addValue(derivedProof.document, key, compactProof[key]);
+	} else {
+		delete derivedProof.proof["@context"];
+		jsonld_default.addValue(derivedProof.document, "proof", derivedProof.proof);
+	}
+	return JsonTransformer.fromJSON(derivedProof.document, W3cJsonLdVerifiableCredential);
+};
+
+//#endregion
+export { deriveProof };
+//# sourceMappingURL=deriveProof.mjs.map

package/build/modules/vc/data-integrity/deriveProof.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveProof.mjs","names":["expandedProof: Record<string, unknown>","jsonld"],"sources":["../../../../src/modules/vc/data-integrity/deriveProof.ts"],"sourcesContent":["/*\n * Copyright 2020 - MATTR Limited\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *     http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { JsonObject } from '../../../types'\n\nimport { JsonTransformer } from '../../../utils'\nimport { SECURITY_PROOF_URL } from '../constants'\n\nimport { getProofs, getTypeInfo } from './jsonldUtil'\nimport jsonld from './libraries/jsonld'\nimport { W3cJsonLdVerifiableCredential } from './models/W3cJsonLdVerifiableCredential'\n\nexport interface W3cJsonLdDeriveProofOptions {\n  credential: W3cJsonLdVerifiableCredential\n  revealDocument: JsonObject\n  verificationMethod: string\n}\n\n/**\n * Derives a proof from a document featuring a supported linked data proof\n *\n * NOTE - This is a temporary API extending JSON-LD signatures\n *\n * @param proofDocument A document featuring a linked data proof capable of proof derivation\n * @param revealDocument A document of the form of a JSON-LD frame describing the terms to selectively derive from the proof document\n * @param options Options for proof derivation\n */\nexport const deriveProof = async (\n  proofDocument: JsonObject,\n  revealDocument: JsonObject,\n  // biome-ignore lint/suspicious/noExplicitAny: no explanation\n  { suite, skipProofCompaction, documentLoader, nonce }: any\n): Promise<W3cJsonLdVerifiableCredential> => {\n  if (!suite) {\n    throw new TypeError('\"options.suite\" is required.')\n  }\n\n  if (Array.isArray(proofDocument)) {\n    throw new TypeError('proofDocument should be an object not an array.')\n  }\n\n  const { proofs, document } = await getProofs({\n    document: proofDocument,\n    proofType: suite.supportedDeriveProofType,\n    documentLoader,\n  })\n\n  if (proofs.length === 0) {\n    throw new Error('There were not any proofs provided that can be used to derive a proof with this suite.')\n  }\n\n  let derivedProof = await suite.deriveProof({\n    document,\n    proof: proofs[0],\n    revealDocument,\n    documentLoader,\n\n    nonce,\n  })\n\n  if (proofs.length > 1) {\n    // convert the proof property value from object ot array of objects\n    derivedProof = { ...derivedProof, proof: [derivedProof.proof] }\n\n    // drop the first proof because it's already been processed\n    proofs.splice(0, 1)\n\n    // add all the additional proofs to the derivedProof document\n    for (const proof of proofs) {\n      const additionalDerivedProofValue = await suite.deriveProof({\n        document,\n        proof,\n        revealDocument,\n        documentLoader,\n      })\n      derivedProof.proof.push(additionalDerivedProofValue.proof)\n    }\n  }\n\n  if (!skipProofCompaction) {\n    const expandedProof: Record<string, unknown> = {\n      [SECURITY_PROOF_URL]: {\n        '@graph': derivedProof.proof,\n      },\n    }\n\n    // account for type-scoped `proof` definition by getting document types\n    const { types, alias } = await getTypeInfo(derivedProof.document, {\n      documentLoader,\n    })\n\n    expandedProof['@type'] = types\n\n    const ctx = jsonld.getValues(derivedProof.document, '@context')\n\n    const compactProof = await jsonld.compact(expandedProof, ctx, {\n      documentLoader,\n      compactToRelative: false,\n    })\n\n    delete compactProof[alias]\n    // biome-ignore lint/performance/noDelete: no explanation\n    delete compactProof['@context']\n\n    /**\n     * removes the @included tag when multiple proofs exist because the\n     * @included tag messes up the canonicalized bytes leading to a bad\n     * signature that won't verify.\n     **/\n    if (compactProof.proof?.['@included']) {\n      compactProof.proof = compactProof.proof['@included']\n    }\n\n    // add proof to document\n    const key = Object.keys(compactProof)[0]\n    jsonld.addValue(derivedProof.document, key, compactProof[key])\n  } else {\n    // biome-ignore lint/performance/noDelete: no explanation\n    delete derivedProof.proof['@context']\n    jsonld.addValue(derivedProof.document, 'proof', derivedProof.proof)\n  }\n\n  return JsonTransformer.fromJSON(derivedProof.document, W3cJsonLdVerifiableCredential)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqCA,MAAa,cAAc,OACzB,eACA,gBAEA,EAAE,OAAO,qBAAqB,gBAAgB,YACH;AAC3C,KAAI,CAAC,MACH,OAAM,IAAI,UAAU,iCAA+B;AAGrD,KAAI,MAAM,QAAQ,cAAc,CAC9B,OAAM,IAAI,UAAU,kDAAkD;CAGxE,MAAM,EAAE,QAAQ,aAAa,MAAM,UAAU;EAC3C,UAAU;EACV,WAAW,MAAM;EACjB;EACD,CAAC;AAEF,KAAI,OAAO,WAAW,EACpB,OAAM,IAAI,MAAM,yFAAyF;CAG3G,IAAI,eAAe,MAAM,MAAM,YAAY;EACzC;EACA,OAAO,OAAO;EACd;EACA;EAEA;EACD,CAAC;AAEF,KAAI,OAAO,SAAS,GAAG;AAErB,iBAAe;GAAE,GAAG;GAAc,OAAO,CAAC,aAAa,MAAM;GAAE;AAG/D,SAAO,OAAO,GAAG,EAAE;AAGnB,OAAK,MAAM,SAAS,QAAQ;GAC1B,MAAM,8BAA8B,MAAM,MAAM,YAAY;IAC1D;IACA;IACA;IACA;IACD,CAAC;AACF,gBAAa,MAAM,KAAK,4BAA4B,MAAM;;;AAI9D,KAAI,CAAC,qBAAqB;EACxB,MAAMA,gBAAyC,GAC5C,qBAAqB,EACpB,UAAU,aAAa,OACxB,EACF;EAGD,MAAM,EAAE,OAAO,UAAU,MAAM,YAAY,aAAa,UAAU,EAChE,gBACD,CAAC;AAEF,gBAAc,WAAW;EAEzB,MAAM,MAAMC,eAAO,UAAU,aAAa,UAAU,WAAW;EAE/D,MAAM,eAAe,MAAMA,eAAO,QAAQ,eAAe,KAAK;GAC5D;GACA,mBAAmB;GACpB,CAAC;AAEF,SAAO,aAAa;AAEpB,SAAO,aAAa;;;;;;AAOpB,MAAI,aAAa,QAAQ,aACvB,cAAa,QAAQ,aAAa,MAAM;EAI1C,MAAM,MAAM,OAAO,KAAK,aAAa,CAAC;AACtC,iBAAO,SAAS,aAAa,UAAU,KAAK,aAAa,KAAK;QACzD;AAEL,SAAO,aAAa,MAAM;AAC1B,iBAAO,SAAS,aAAa,UAAU,SAAS,aAAa,MAAM;;AAGrE,QAAO,gBAAgB,SAAS,aAAa,UAAU,8BAA8B"}

package/build/modules/vc/data-integrity/index.d.mts

@@ -0,0 +1,18 @@
+import { DataIntegrityProof, DataIntegrityProofOptions } from "./models/DataIntegrityProof.mjs";
+import { W3cJsonLdVerifiableCredential, W3cJsonLdVerifiableCredentialOptions } from "./models/W3cJsonLdVerifiableCredential.mjs";
+import { W3cJsonLdDeriveProofOptions, deriveProof } from "./deriveProof.mjs";
+import { DocumentLoader, Proof } from "./jsonldUtil.mjs";
+import { vcLibraries } from "./libraries/index.mjs";
+import { W3cJsonLdVerifiablePresentation, W3cJsonLdVerifiablePresentationOptions } from "./models/W3cJsonLdVerifiablePresentation.mjs";
+import { ANONCREDS_DATA_INTEGRITY_CRYPTOSUITE, AnonCredsDataIntegrityServiceSymbol, AnoncredsDataIntegrityCreatePresentation, AnoncredsDataIntegrityVerifyPresentation, IAnonCredsDataIntegrityService } from "./models/IAnonCredsDataIntegrityService.mjs";
+import { LdKeyPair, LdKeyPairOptions } from "./models/LdKeyPair.mjs";
+import "./models/index.mjs";
+import { CredentialIssuancePurpose } from "./proof-purposes/CredentialIssuancePurpose.mjs";
+import { ProofPurpose } from "./proof-purposes/ProofPurpose.mjs";
+import "./proof-purposes/index.mjs";
+import { SignatureSuiteRegistry, SignatureSuiteToken, SuiteInfo } from "./SignatureSuiteRegistry.mjs";
+import { JwsLinkedDataSignature, JwsLinkedDataSignatureOptions } from "./signature-suites/JwsLinkedDataSignature.mjs";
+import { Ed25519Signature2018 } from "./signature-suites/ed25519/Ed25519Signature2018.mjs";
+import { Ed25519Signature2020 } from "./signature-suites/ed25519/Ed25519Signature2020.mjs";
+import "./signature-suites/index.mjs";
+import { W3cJsonLdCredentialService } from "./W3cJsonLdCredentialService.mjs";

package/build/modules/vc/data-integrity/index.mjs

@@ -0,0 +1,18 @@
+
+
+import { DataIntegrityProof } from "./models/DataIntegrityProof.mjs";
+import { W3cJsonLdVerifiableCredential } from "./models/W3cJsonLdVerifiableCredential.mjs";
+import { deriveProof } from "./deriveProof.mjs";
+import { vcLibraries } from "./libraries/index.mjs";
+import { ANONCREDS_DATA_INTEGRITY_CRYPTOSUITE, AnonCredsDataIntegrityServiceSymbol } from "./models/IAnonCredsDataIntegrityService.mjs";
+import { LdKeyPair } from "./models/LdKeyPair.mjs";
+import { W3cJsonLdVerifiablePresentation } from "./models/W3cJsonLdVerifiablePresentation.mjs";
+import "./models/index.mjs";
+import { CredentialIssuancePurpose } from "./proof-purposes/CredentialIssuancePurpose.mjs";
+import "./proof-purposes/index.mjs";
+import { SignatureSuiteRegistry, SignatureSuiteToken } from "./SignatureSuiteRegistry.mjs";
+import { JwsLinkedDataSignature } from "./signature-suites/JwsLinkedDataSignature.mjs";
+import { Ed25519Signature2018 } from "./signature-suites/ed25519/Ed25519Signature2018.mjs";
+import { Ed25519Signature2020 } from "./signature-suites/ed25519/Ed25519Signature2020.mjs";
+import "./signature-suites/index.mjs";
+import { W3cJsonLdCredentialService } from "./W3cJsonLdCredentialService.mjs";

package/build/modules/vc/data-integrity/jsonldUtil.d.mts

@@ -0,0 +1,25 @@
+import { JsonObject, JsonValue } from "../../../types.mjs";
+import "./models/W3cJsonLdVerifiableCredential.mjs";
+import "./models/GetProofsOptions.mjs";
+import "./models/GetProofsResult.mjs";
+import "./models/GetTypeOptions.mjs";
+
+//#region src/modules/vc/data-integrity/jsonldUtil.d.ts
+type JsonLdDoc = Record<string, unknown>;
+interface VerificationMethod extends JsonObject {
+  id: string;
+  [key: string]: JsonValue;
+}
+interface Proof extends JsonObject {
+  verificationMethod: string | VerificationMethod;
+  [key: string]: JsonValue;
+}
+interface DocumentLoaderResult {
+  contextUrl?: string | null;
+  documentUrl: string;
+  document: Record<string, unknown>;
+}
+type DocumentLoader = (url: string) => Promise<DocumentLoaderResult>;
+//#endregion
+export { DocumentLoader, JsonLdDoc, Proof, VerificationMethod };
+//# sourceMappingURL=jsonldUtil.d.mts.map

package/build/modules/vc/data-integrity/jsonldUtil.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonldUtil.d.mts","names":[],"sources":["../../../../src/modules/vc/data-integrity/jsonldUtil.ts"],"sourcesContent":[],"mappings":";;;;;;;KASY,SAAA,GAAY;UACP,kBAAA,SAA2B;;iBAE3B;AAHjB;AACiB,UAKA,KAAA,SAAc,UAHd,CAAA;EAGA,kBAAM,EAAA,MAAA,GACQ,kBADR;EACQ,CAAA,GAAA,EAAA,MAAA,CAAA,EACd,SADc;;AADA,UAKd,oBAAA,CALc;EAAU,UAAA,CAAA,EAAA,MAAA,GAAA,IAAA;EAKxB,WAAA,EAAA,MAAA;EAML,QAAA,EAHA,MAGA,CAAc,MAAA,EAAA,OAA4B,CAAA;;KAA1C,cAAA,oBAAkC,QAAQ"}