@animo-id/pex
Version:
A Typescript implementation of the v1 and v2 DIF Presentation Exchange specification
450 lines • 45.8 kB
JavaScript
import { Status } from './ConstraintUtils';
import { EvaluationClientWrapper } from './evaluation';
import { PresentationSubmissionLocation, } from './signing';
import { PEVersion, SSITypesBuilder } from './types';
import { PexCredentialMapper, } from './types/PexCredentialMapper';
import { calculateSdHash, definitionVersionDiscovery, formatValidationErrors, getSubjectIdsAsString } from './utils';
import { PresentationDefinitionV1VB, PresentationDefinitionV2VB, PresentationSubmissionVB, ValidationEngine } from './validation';
/**
* This is the main interfacing class to be used by developers using the PEX library.
*/
export class PEX {
_evaluationClientWrapper;
options;
constructor(options) {
// TODO: So we have state in the form of this property which is set in the constructor, but we are overwriting it elsewhere. We need to retrhink how to instantiate PEX
this._evaluationClientWrapper = new EvaluationClientWrapper();
this.options = options;
}
/***
* The evaluatePresentation compares what is expected from one or more presentations with a presentationDefinition.
* presentationDefinition: It can be either v1 or v2 of presentationDefinition
*
* @param presentationDefinition the definition of what is expected in the presentation.
* @param presentations the presentation(s) which have to be evaluated in comparison of the definition.
* @param opts - limitDisclosureSignatureSuites the credential signature suites that support limit disclosure
*
* @return the evaluation results specify what was expected and was fulfilled and also specifies which requirements described in the input descriptors
* were not fulfilled by the presentation(s).
*/
evaluatePresentation(presentationDefinition, presentations, opts) {
// We map it to an array for now to make processing on the presentations easier, but before checking against the submission
// we will transform it to the original structure (array vs single) so the references in the submission stay correct
const presentationsArray = Array.isArray(presentations) ? presentations : [presentations];
if (presentationsArray.length === 0) {
throw new Error('At least one presentation must be provided');
}
let originalPresentationSubmission = opts?.presentationSubmission;
const generatePresentationSubmission = opts?.generatePresentationSubmission !== undefined ? opts.generatePresentationSubmission : opts?.presentationSubmission === undefined;
const pd = SSITypesBuilder.toInternalPresentationDefinition(presentationDefinition);
const presentationsCopy = JSON.parse(JSON.stringify(presentationsArray));
const wrappedPresentations = presentationsCopy.map((p) => SSITypesBuilder.mapExternalVerifiablePresentationToWrappedVP(p));
let presentationSubmission = opts?.presentationSubmission;
let presentationSubmissionLocation = opts?.presentationSubmissionLocation ??
((Array.isArray(presentations) && presentations.length > 1) || !PexCredentialMapper.isW3cPresentation(wrappedPresentations[0].presentation)
? PresentationSubmissionLocation.EXTERNAL
: PresentationSubmissionLocation.PRESENTATION);
// When only one presentation, we also allow it to be present in the VP
if (!presentationSubmission &&
presentationsArray.length === 1 &&
PexCredentialMapper.isW3cPresentation(wrappedPresentations[0].presentation) &&
!opts?.generatePresentationSubmission) {
const decoded = wrappedPresentations[0].decoded;
if ('presentation_submission' in decoded) {
presentationSubmission = JSON.parse(JSON.stringify(decoded.presentation_submission));
originalPresentationSubmission = decoded.presentation_submission;
}
if (!presentationSubmission) {
throw Error(`Either a presentation submission as part of the VP or provided in options was expected`);
}
presentationSubmissionLocation = PresentationSubmissionLocation.PRESENTATION;
if (opts?.presentationSubmissionLocation && opts.presentationSubmissionLocation !== PresentationSubmissionLocation.PRESENTATION) {
throw new Error(`unexpected presentationSubmissionLocation ${opts.presentationSubmissionLocation} was provided. Expected ${PresentationSubmissionLocation.PRESENTATION} when no presentationSubmission passed and first verifiable presentation contains a presentation_submission and generatePresentationSubmission is false`);
}
// We need to update the vp path as PEX decoded assumes it's an external submission
// So we need to update the submission paths
if (wrappedPresentations[0].format === 'jwt_vp') {
for (const descriptor of presentationSubmission.descriptor_map) {
if (!descriptor.path.startsWith('$.vp')) {
descriptor.path = descriptor.path.replace('$.', '$.vp.');
}
}
}
}
else if (!presentationSubmission && !generatePresentationSubmission) {
throw new Error('Presentation submission in options was expected.');
}
// TODO: we should probably add support for holder dids in the kb-jwt of an SD-JWT. We can extract this from the
// `wrappedPresentation.original.compactKbJwt`, but as HAIP doesn't use dids, we'll leave it for now.
const holderDIDs = wrappedPresentations
.map((p) => {
return PexCredentialMapper.isW3cPresentation(p.presentation) && p.presentation.holder ? p.presentation.holder : undefined;
})
.filter((d) => d !== undefined);
const updatedOpts = {
...opts,
holderDIDs,
presentationSubmission,
presentationSubmissionLocation,
generatePresentationSubmission,
};
const allWvcs = wrappedPresentations.reduce((all, wvp) => [...all, ...wvp.vcs], []);
const result = this._evaluationClientWrapper.evaluatePresentations(pd, Array.isArray(presentations) ? wrappedPresentations : wrappedPresentations[0], updatedOpts);
if (result.areRequiredCredentialsPresent !== Status.ERROR) {
const selectFromClientWrapper = new EvaluationClientWrapper();
const selectResults = selectFromClientWrapper.selectFrom(pd, allWvcs, updatedOpts);
if (selectResults.areRequiredCredentialsPresent !== Status.ERROR) {
result.errors = [];
}
}
return {
...result,
value: originalPresentationSubmission ?? result.value,
};
}
/***
* The evaluate compares what is expected from a verifiableCredentials with the presentationDefinition.
*
* @param presentationDefinition the v1 or v2 definition of what is expected in the presentation.
* @param verifiableCredentials the verifiable credentials which are candidates to fulfill requirements defined in the presentationDefinition param.
* @param opts - holderDIDs the list of the DIDs that the wallet holders controls. Optional, but needed by some input requirements that do a holderDID check.
* @ - limitDisclosureSignatureSuites the credential signature suites that support limit disclosure
*
* @return the evaluation results specify what was expected and was fulfilled and also specifies which requirements described in the input descriptors
* were not fulfilled by the verifiable credentials.
*/
evaluateCredentials(presentationDefinition, verifiableCredentials, opts) {
const wrappedVerifiableCredentials = SSITypesBuilder.mapExternalVerifiableCredentialsToWrappedVcs(verifiableCredentials);
// TODO: So we have state in the form of this property which is set in the constructor, but we are overwriting it here. We need to retrhink how to instantiate PEX
this._evaluationClientWrapper = new EvaluationClientWrapper();
const pd = SSITypesBuilder.toInternalPresentationDefinition(presentationDefinition);
const result = this._evaluationClientWrapper.evaluate(pd, wrappedVerifiableCredentials, opts);
if (result.value && result.value.descriptor_map.length) {
const selectFromClientWrapper = new EvaluationClientWrapper();
const selectResults = selectFromClientWrapper.selectFrom(pd, wrappedVerifiableCredentials, opts);
result.areRequiredCredentialsPresent = selectResults.areRequiredCredentialsPresent;
result.errors = selectResults.errors;
}
else {
result.areRequiredCredentialsPresent = Status.ERROR;
}
return result;
}
/**
* The selectFrom method is a helper function that helps filter out the verifiable credentials which can not be selected and returns
* the selectable credentials.
*
* @param presentationDefinition the v1 or v2 definition of what is expected in the presentation.
* @param verifiableCredentials verifiable credentials are the credentials from wallet provided to the library to find selectable credentials.
* @param opts - holderDIDs the decentralized identifier(s) of the wallet holderDID. This is used to identify the credentials issued to the holderDID of wallet in certain scenario's.
* - limitDisclosureSignatureSuites the credential signature suites that support limit disclosure
*
* @return the selectable credentials.
*/
selectFrom(presentationDefinition, verifiableCredentials, opts) {
const verifiableCredentialCopy = JSON.parse(JSON.stringify(verifiableCredentials));
const pd = SSITypesBuilder.toInternalPresentationDefinition(presentationDefinition);
// TODO: So we have state in the form of this property which is set in the constructor, but we are overwriting it here. We need to retrhink how to instantiate PEX
this._evaluationClientWrapper = new EvaluationClientWrapper();
return this._evaluationClientWrapper.selectFrom(pd, SSITypesBuilder.mapExternalVerifiableCredentialsToWrappedVcs(verifiableCredentialCopy), opts);
}
presentationSubmissionFrom(presentationDefinition, selectedCredentials, opts) {
const pd = SSITypesBuilder.toInternalPresentationDefinition(presentationDefinition);
return this._evaluationClientWrapper.submissionFrom(pd, SSITypesBuilder.mapExternalVerifiableCredentialsToWrappedVcs(selectedCredentials), opts);
}
/**
* This method helps create an Unsigned Presentation. An Unsigned Presentation after signing becomes a Presentation. And can be sent to
* the verifier after signing it.
*
* @param presentationDefinition the v1 or v2 definition of what is expected in the presentation.
* @param selectedCredentials the credentials which were declared selectable by getSelectableCredentials and then chosen by the intelligent-user
* (e.g. human).
* @param opts - holderDID optional; the decentralized identity of the wallet holderDID. This is used to identify the holderDID of the presentation.
*
* @return the presentation.
*/
presentationFrom(presentationDefinition, selectedCredentials, opts) {
const presentationSubmission = this.presentationSubmissionFrom(presentationDefinition, selectedCredentials, opts);
const hasSdJwtCredentials = selectedCredentials.some((c) => PexCredentialMapper.isSdJwtDecodedCredential(c) || PexCredentialMapper.isSdJwtEncoded(c));
// We could include it in the KB-JWT? Not sure if we want that
if (opts?.presentationSubmissionLocation === PresentationSubmissionLocation.PRESENTATION && hasSdJwtCredentials) {
throw new Error('Presentation submission location cannot be set to presentation when creating a presentation with an SD-JWT VC');
}
const presentationSubmissionLocation = opts?.presentationSubmissionLocation ??
(hasSdJwtCredentials ? PresentationSubmissionLocation.EXTERNAL : PresentationSubmissionLocation.PRESENTATION);
const presentations = this.constructPresentations(selectedCredentials, {
...opts,
// We only pass in the submission in case it needs to be included in the presentation
presentationSubmission: presentationSubmissionLocation === PresentationSubmissionLocation.PRESENTATION ? presentationSubmission : undefined,
});
this.updateSdJwtCredentials(presentations);
return {
presentations,
presentationSubmissionLocation,
presentationSubmission,
};
}
constructPresentations(selectedCredentials, opts) {
if (!selectedCredentials) {
throw Error(`At least a verifiable credential needs to be passed in to create a presentation`);
}
const verifiableCredential = (Array.isArray(selectedCredentials) ? selectedCredentials : [selectedCredentials]);
const wVCs = verifiableCredential.map((vc) => PexCredentialMapper.toWrappedVerifiableCredential(vc));
const holders = Array.from(new Set(wVCs.flatMap((wvc) => getSubjectIdsAsString(wvc.credential))));
const holder = opts?.holderDID ?? (holders.length === 1 ? holders[0] : undefined);
const type = opts?.basePresentationPayload?.type
? Array.isArray(opts.basePresentationPayload.type)
? opts.basePresentationPayload.type
: [opts.basePresentationPayload.type]
: [];
if (!type.includes('VerifiablePresentation')) {
type.push('VerifiablePresentation');
}
const context = opts?.basePresentationPayload?.['@context']
? Array.isArray(opts.basePresentationPayload['@context'])
? opts.basePresentationPayload['@context']
: [opts.basePresentationPayload['@context']]
: [];
if (!context.includes('https://www.w3.org/2018/credentials/v1')) {
context.push('https://www.w3.org/2018/credentials/v1');
}
if (opts?.presentationSubmission) {
if (!type.includes('PresentationSubmission')) {
type.push('PresentationSubmission');
}
if (!context.includes('https://identity.foundation/presentation-exchange/submission/v1')) {
context.push('https://identity.foundation/presentation-exchange/submission/v1');
}
}
const result = [];
if (PEX.allowMultipleVCsPerPresentation(verifiableCredential)) {
result.push({
...opts?.basePresentationPayload,
'@context': context,
type,
holder,
...(!!opts?.presentationSubmission && { presentation_submission: opts.presentationSubmission }),
verifiableCredential,
});
}
else {
verifiableCredential.forEach((vc) => {
if (PexCredentialMapper.isSdJwtDecodedCredential(vc)) {
result.push(vc);
}
else if (PexCredentialMapper.isSdJwtEncoded(vc)) {
const decoded = PexCredentialMapper.decodeVerifiableCredential(vc);
result.push(decoded);
}
else {
// This should be jwt or json-ld
result.push({
...opts?.basePresentationPayload,
'@context': context,
type,
holder,
...(!!opts?.presentationSubmission && { presentation_submission: opts.presentationSubmission }),
verifiableCredential: [vc],
});
}
});
}
return result;
}
/*
TODO SDK-37 refinement needed
*/
static allowMultipleVCsPerPresentation(verifiableCredentials) {
const jwtCredentials = verifiableCredentials.filter((c) => PexCredentialMapper.isJwtEncoded(c) || PexCredentialMapper.isJwtDecodedCredential(c));
if (jwtCredentials.length > 0) {
const subjects = new Set();
const verificationMethods = new Set();
for (const credential of jwtCredentials) {
const decodedCredential = PexCredentialMapper.isJwtEncoded(credential)
? PexCredentialMapper.decodeVerifiableCredential(credential)
: credential;
const subject = decodedCredential.sub ||
(decodedCredential.vc && 'id' in decodedCredential.vc.credentialSubject && decodedCredential.vc.credentialSubject.id);
if (subject) {
subjects.add(subject);
}
const vcProof = decodedCredential.proof ?? decodedCredential.vc.proof;
const proofs = Array.isArray(vcProof) ? vcProof : [vcProof];
proofs.filter((proof) => proof.verificationMethod).forEach((proof) => verificationMethods.add(proof.verificationMethod));
}
// If there's more than one unique subject or verification method, we can't allow multiple VCs in a single presentation
if (subjects.size > 1 || verificationMethods.size > 1) {
return false;
}
}
if (verifiableCredentials.some((c) => PexCredentialMapper.isSdJwtEncoded(c) || PexCredentialMapper.isSdJwtDecodedCredential(c))) {
return false;
}
return true;
}
/**
* This method validates whether an object is usable as a presentation definition or not.
*
* @param presentationDefinition presentationDefinition of V1 or v2 to be validated.
*
* @return the validation results to reveal what is acceptable/unacceptable about the passed object to be considered a valid presentation definition
*/
static validateDefinition(presentationDefinition) {
const result = definitionVersionDiscovery(presentationDefinition);
if (result.error) {
const errorParts = [result.error];
const v1ErrorString = formatValidationErrors(result.v1Errors);
if (v1ErrorString) {
errorParts.push('\nVersion 1 validation errors:\n ' + v1ErrorString);
}
const v2ErrorString = formatValidationErrors(result.v2Errors);
if (v2ErrorString) {
errorParts.push('\nVersion 2 validation errors:\n ' + v2ErrorString);
}
throw new Error(errorParts.join(''));
}
const validators = [];
result.version === PEVersion.v1
? validators.push({
bundler: new PresentationDefinitionV1VB('root'),
target: SSITypesBuilder.modelEntityToInternalPresentationDefinitionV1(presentationDefinition),
})
: validators.push({
bundler: new PresentationDefinitionV2VB('root'),
target: SSITypesBuilder.modelEntityInternalPresentationDefinitionV2(presentationDefinition),
});
return new ValidationEngine().validate(validators);
}
/**
* This method validates whether an object is usable as a presentation submission or not.
*
* @param presentationSubmission the object to be validated.
*
* @return the validation results to reveal what is acceptable/unacceptable about the passed object to be considered a valid presentation submission
*/
static validateSubmission(presentationSubmission) {
return new ValidationEngine().validate([
{
bundler: new PresentationSubmissionVB('root'),
target: presentationSubmission,
},
]);
}
/**
* This method can be used to combine a definition, selected Verifiable Credentials, together with
* signing opts and a callback to sign a presentation, making it a Verifiable Presentation before sending.
*
* Please note that PEX has no signature support on purpose. We didn't want this library to depend on all kinds of signature suites.
* The callback function next to the Signing Params also gets a Presentation which is evaluated against the definition.
* It is up to you to decide whether you simply update the supplied partial proof and add it to the presentation in the callback,
* or whether you will use the selected Credentials, Presentation definition, evaluation results and/or presentation submission together with the signature opts
*
* @param presentationDefinition the Presentation Definition V1 or V2
* @param selectedCredentials the PEX and/or User selected/filtered credentials that will become part of the Verifiable Presentation
* @param signingCallBack the function which will be provided as a parameter. And this will be the method that will be able to perform actual
* signing. One example of signing is available in the project named. pe-selective-disclosure.
* @param opts Signing Params these are the signing params required to sign.
*
* @return the signed and thus Verifiable Presentation.
*/
async verifiablePresentationFrom(presentationDefinition, selectedCredentials, signingCallBack, opts) {
const { holderDID, signatureOptions, proofOptions } = opts;
function limitedDisclosureSuites() {
let limitDisclosureSignatureSuites = [];
if (proofOptions?.typeSupportsSelectiveDisclosure) {
if (!proofOptions?.type) {
throw Error('Please provide a proof type if you enable selective disclosure');
}
limitDisclosureSignatureSuites = [proofOptions.type];
}
return limitDisclosureSignatureSuites;
}
const holderDIDs = holderDID ? [holderDID] : [];
const limitDisclosureSignatureSuites = limitedDisclosureSuites();
const evaluationResult = this.evaluateCredentials(presentationDefinition, selectedCredentials, {
holderDIDs,
limitDisclosureSignatureSuites,
});
if (evaluationResult.areRequiredCredentialsPresent === Status.ERROR) {
throw new Error('Could not create presentation, selected credentials do not satisfy the presentation definition');
}
const presentationResult = this.presentationFrom(presentationDefinition, evaluationResult.verifiableCredential, opts);
const presentations = presentationResult.presentations;
const evaluationResults = this.evaluatePresentation(presentationDefinition, presentations, {
limitDisclosureSignatureSuites,
...(presentationResult.presentationSubmissionLocation === PresentationSubmissionLocation.EXTERNAL && {
presentationSubmission: presentationResult.presentationSubmission,
}),
});
if (!evaluationResults.value && selectedCredentials.length === 0) {
evaluationResults.value = presentationResult.presentationSubmission;
}
if (!evaluationResults.value) {
throw new Error('Could not get evaluation results from presentationResult');
}
const proof = {
type: proofOptions?.type,
verificationMethod: signatureOptions?.verificationMethod,
created: proofOptions?.created ? proofOptions.created : new Date().toISOString(),
proofPurpose: proofOptions?.proofPurpose,
proofValue: signatureOptions?.proofValue,
jws: signatureOptions?.jws,
challenge: proofOptions?.challenge,
nonce: proofOptions?.nonce,
domain: proofOptions?.domain,
};
this.updateSdJwtCredentials(presentations, proofOptions?.nonce);
const verifiablePresentations = [];
for (const presentation of presentations) {
const callBackParams = {
options: {
...opts,
presentationSubmissionLocation: presentationResult.presentationSubmissionLocation,
},
presentation,
presentationDefinition,
selectedCredentials,
proof,
presentationSubmission: evaluationResults.value,
evaluationResults,
};
verifiablePresentations.push(await signingCallBack(callBackParams));
}
return {
verifiablePresentations,
presentationSubmissionLocation: presentationResult.presentationSubmissionLocation,
presentationSubmission: evaluationResults.value,
};
}
updateSdJwtCredentials(presentations, nonce) {
presentations.forEach((presentation, index) => {
// Select type without kbJwt as isSdJwtDecodedCredential and won't accept the partial sdvc type
if (PexCredentialMapper.isSdJwtDecodedCredential(presentation)) {
const sdJwtCredential = presentation;
// extract sd_alg or default to sha-256
const hashAlg = sdJwtCredential.signedPayload._sd_alg ?? 'sha-256';
const sdHash = calculateSdHash(sdJwtCredential.compactSdJwtVc, hashAlg);
const kbJwt = {
// alg MUST be set by the signer
header: {
typ: 'kb+jwt',
},
// aud MUST be set by the signer or provided by e.g. SIOP/OpenID4VP lib
payload: {
iat: Math.floor(new Date().getTime() / 1000),
nonce: nonce,
sd_hash: sdHash,
},
};
presentations[index] = {
...sdJwtCredential,
kbJwt,
};
}
});
}
static definitionVersionDiscovery(presentationDefinition) {
return definitionVersionDiscovery(presentationDefinition);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PEX.js","sourceRoot":"","sources":["../../../lib/PEX.ts"],"names":[],"mappings":"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"}