{"version":3,"file":"DifPresentationExchangeService.mjs","names":["DifPresentationExchangeSubmissionLocation"],"sources":["../../../src/modules/dif-presentation-exchange/DifPresentationExchangeService.ts"],"sourcesContent":["import type { Checked, PresentationSignCallBackParams, Validated, VerifiablePresentationResult } from '@animo-id/pex'\nimport { PEX, Status } from '@animo-id/pex'\nimport { type PartialSdJwtDecodedVerifiableCredential, PEVersion } from '@animo-id/pex/dist/main/lib/index.js'\nimport type { InputDescriptorV2 } from '@sphereon/pex-models'\nimport type {\n  SdJwtDecodedVerifiableCredential,\n  W3CVerifiablePresentation as SphereonW3cVerifiablePresentation,\n  W3CVerifiablePresentation,\n} from '@sphereon/ssi-types'\nimport type { AgentContext } from '../../agent'\nimport { CredoError } from '../../error'\nimport { injectable } from '../../plugins'\nimport type { Query } from '../../storage/StorageService'\nimport { JsonTransformer } from '../../utils'\nimport { uuid } from '../../utils/uuid'\nimport type { VerificationMethod } from '../dids'\nimport { DidsApi, getPublicJwkFromVerificationMethod } from '../dids'\nimport { getJwkHumanDescription } from '../kms'\nimport { MdocApi, MdocRecord, type MdocSessionTranscriptOptions } from '../mdoc'\nimport { MdocDeviceResponse } from '../mdoc/MdocDeviceResponse'\nimport type { SdJwtVcRecord } from '../sd-jwt-vc'\nimport { SdJwtVcApi } from '../sd-jwt-vc'\nimport type { W3cCredentialRecord, W3cJsonPresentation } from '../vc'\nimport {\n  ClaimFormat,\n  SignatureSuiteRegistry,\n  W3cCredentialRepository,\n  W3cCredentialService,\n  W3cPresentation,\n} from '../vc'\nimport type { IAnonCredsW3cCredentialService } from '../vc/anoncreds-w3c-credential'\nimport {\n  ANONCREDS_W3C_CREDENTIAL_CRYPTOSUITE,\n  AnonCredsW3cCredentialServiceSymbol,\n} from '../vc/anoncreds-w3c-credential'\nimport { purposes } from '../vc/linked-data-proofs/adapters/jsonld-signatures-adapter'\nimport { DifPresentationExchangeError } from './DifPresentationExchangeError'\nimport type {\n  DifPexCredentialsForRequest,\n  DifPexInputDescriptorToCredentials,\n  DifPresentationExchangeDefinition,\n  DifPresentationExchangeDefinitionV1,\n  DifPresentationExchangeDefinitionV2,\n  DifPresentationExchangeSubmission,\n  VerifiablePresentation,\n} from './models'\nimport { DifPresentationExchangeSubmissionLocation } from './models'\nimport type { PresentationToCreate } from './utils'\nimport {\n  getCredentialsForRequest,\n  getPresentationsToCreate,\n  getSphereonOriginalVerifiableCredential,\n  getSphereonOriginalVerifiablePresentation,\n  getVerifiablePresentationFromEncoded,\n} from './utils'\n\n/**\n * @todo create a public api for using dif presentation exchange\n */\n@injectable()\nexport class DifPresentationExchangeService {\n  private pex = new PEX()\n\n  public constructor(private w3cCredentialService: W3cCredentialService) {}\n\n  public async getCredentialsForRequest(\n    agentContext: AgentContext,\n    presentationDefinition: DifPresentationExchangeDefinition\n  ): Promise<DifPexCredentialsForRequest> {\n    const credentialRecords = await this.queryCredentialForPresentationDefinition(agentContext, presentationDefinition)\n    return getCredentialsForRequest(agentContext, this.pex, presentationDefinition, credentialRecords)\n  }\n\n  /**\n   * Selects the credentials to use based on the output from `getCredentialsForRequest`\n   * Use this method if you don't want to manually select the credentials yourself.\n   */\n  public selectCredentialsForRequest(\n    credentialsForRequest: DifPexCredentialsForRequest\n  ): DifPexInputDescriptorToCredentials {\n    if (!credentialsForRequest.areRequirementsSatisfied) {\n      throw new CredoError('Could not find the required credentials for the presentation submission')\n    }\n\n    const credentials: DifPexInputDescriptorToCredentials = {}\n\n    for (const requirement of credentialsForRequest.requirements) {\n      // Take needsCount entries from the submission entry\n      for (const submission of requirement.submissionEntry.slice(0, requirement.needsCount)) {\n        if (!credentials[submission.inputDescriptorId]) {\n          credentials[submission.inputDescriptorId] = []\n        }\n\n        // We pick the first matching VC if we are auto-selecting\n        credentials[submission.inputDescriptorId].push(submission.verifiableCredentials[0])\n      }\n    }\n\n    return credentials\n  }\n\n  public validatePresentationDefinition(presentationDefinition: DifPresentationExchangeDefinition) {\n    const validation = PEX.validateDefinition(presentationDefinition)\n    const errorMessages = this.formatValidated(validation)\n\n    if (errorMessages.length > 0) {\n      throw new DifPresentationExchangeError('Invalid presentation definition', { additionalMessages: errorMessages })\n    }\n  }\n\n  public validatePresentationSubmission(presentationSubmission: DifPresentationExchangeSubmission) {\n    const validation = PEX.validateSubmission(presentationSubmission)\n    const errorMessages = this.formatValidated(validation)\n    if (errorMessages.length > 0) {\n      throw new DifPresentationExchangeError('Invalid presentation submission', { additionalMessages: errorMessages })\n    }\n  }\n\n  public validatePresentation(\n    presentationDefinition: DifPresentationExchangeDefinition,\n    presentations: VerifiablePresentation | VerifiablePresentation[],\n    presentationSubmission?: DifPresentationExchangeSubmission\n  ) {\n    const result = this.pex.evaluatePresentation(\n      presentationDefinition,\n      Array.isArray(presentations)\n        ? presentations.map(getSphereonOriginalVerifiablePresentation)\n        : getSphereonOriginalVerifiablePresentation(presentations),\n      {\n        limitDisclosureSignatureSuites: ['DataIntegrityProof.anoncreds-2023'],\n        presentationSubmission,\n      }\n    )\n\n    if (result.areRequiredCredentialsPresent === Status.ERROR) {\n      const errorMessages = this.formatValidated(result.errors)\n      throw new DifPresentationExchangeError('Invalid presentation', { additionalMessages: errorMessages })\n    }\n  }\n\n  private formatValidated(v?: Checked[] | Validated) {\n    const validated = Array.isArray(v) ? v : v ? [v] : []\n    return validated\n      .filter((r) => r.status === Status.ERROR)\n      .map((r) => r.message)\n      .filter((r): r is string => Boolean(r))\n  }\n\n  public async createPresentation(\n    agentContext: AgentContext,\n    options: {\n      credentialsForInputDescriptor: DifPexInputDescriptorToCredentials\n      presentationDefinition: DifPresentationExchangeDefinition\n      /**\n       * Defaults to {@link DifPresentationExchangeSubmissionLocation.PRESENTATION}\n       */\n      presentationSubmissionLocation?: DifPresentationExchangeSubmissionLocation\n      /**\n       * Also known as `nonce`\n       */\n      challenge: string\n\n      /**\n       * Also known as `audience`\n       */\n      domain?: string\n\n      /**\n       * Mdoc openid4vp specific options\n       */\n      mdocSessionTranscript?: MdocSessionTranscriptOptions\n    }\n  ) {\n    const { presentationDefinition, domain, challenge, mdocSessionTranscript } = options\n    const presentationSubmissionLocation =\n      options.presentationSubmissionLocation ?? DifPresentationExchangeSubmissionLocation.PRESENTATION\n\n    const verifiablePresentationResultsWithFormat: Array<{\n      verifiablePresentationResult: VerifiablePresentationResult\n      claimFormat: PresentationToCreate['claimFormat']\n    }> = []\n\n    const presentationsToCreate = getPresentationsToCreate(options.credentialsForInputDescriptor)\n    for (const presentationToCreate of presentationsToCreate) {\n      // We create a presentation for each subject\n      // Thus for each subject we need to filter all the related input descriptors and credentials\n      const inputDescriptorIds = presentationToCreate.verifiableCredentials.map((c) => c.inputDescriptorId)\n      const inputDescriptorsForPresentation = (\n        presentationDefinition as DifPresentationExchangeDefinitionV1\n      ).input_descriptors.filter((inputDescriptor) => inputDescriptorIds.includes(inputDescriptor.id))\n\n      const presentationDefinitionForSubject: DifPresentationExchangeDefinition = {\n        ...presentationDefinition,\n        input_descriptors: inputDescriptorsForPresentation,\n\n        // We remove the submission requirements, as it will otherwise fail to create the VP\n        submission_requirements: undefined,\n      }\n\n      if (presentationToCreate.claimFormat === ClaimFormat.MsoMdoc) {\n        if (presentationToCreate.verifiableCredentials.length !== 1) {\n          throw new DifPresentationExchangeError(\n            'Currently a Mdoc presentation can only be created from a single credential'\n          )\n        }\n\n        if (!mdocSessionTranscript) {\n          throw new DifPresentationExchangeError(\n            'Missing mdoc session transcript options for creating MDOC presentation.'\n          )\n        }\n\n        const { credential, inputDescriptorId } = presentationToCreate.verifiableCredentials[0]\n\n        const deviceResponse = await MdocDeviceResponse.createDeviceResponseWithPresentationDefinition(agentContext, {\n          mdocs: [credential.firstCredential],\n          presentationDefinition,\n          sessionTranscriptOptions: mdocSessionTranscript,\n        })\n\n        if (presentationSubmissionLocation !== DifPresentationExchangeSubmissionLocation.EXTERNAL) {\n          throw new DifPresentationExchangeError(\n            'Only EXTERNAL DifPresentationExchangeSubmissionLocation supported for mdoc presentations'\n          )\n        }\n\n        verifiablePresentationResultsWithFormat.push({\n          verifiablePresentationResult: {\n            presentationSubmission: {\n              id: `MdocPresentationSubmission ${uuid()}`,\n              definition_id: presentationDefinition.id,\n              descriptor_map: [\n                {\n                  id: inputDescriptorId,\n                  format: 'mso_mdoc',\n                  path: '$',\n                },\n              ],\n            },\n            verifiablePresentations: [deviceResponse.encoded],\n            presentationSubmissionLocation,\n          },\n          claimFormat: presentationToCreate.claimFormat,\n        })\n      } else {\n        // Get all the credentials for the presentation\n        const credentialsForPresentation = presentationToCreate.verifiableCredentials.map((c) =>\n          getSphereonOriginalVerifiableCredential(c.credential)\n        )\n\n        const extraProofOptions = this.shouldSignWithAnonCredsW3cService(presentationToCreate)\n          ? {\n              typeSupportsSelectiveDisclosure: true,\n              type: `DataIntegrityProof.${ANONCREDS_W3C_CREDENTIAL_CRYPTOSUITE}`,\n            }\n          : {}\n\n        const verifiablePresentationResult = await this.pex.verifiablePresentationFrom(\n          presentationDefinitionForSubject,\n          credentialsForPresentation,\n          this.getPresentationSignCallback(agentContext, presentationToCreate),\n          {\n            proofOptions: {\n              challenge,\n              domain,\n\n              ...extraProofOptions,\n            },\n            presentationSubmissionLocation,\n          }\n        )\n\n        verifiablePresentationResultsWithFormat.push({\n          verifiablePresentationResult,\n          claimFormat: presentationToCreate.claimFormat,\n        })\n      }\n    }\n\n    if (verifiablePresentationResultsWithFormat.length === 0) {\n      throw new DifPresentationExchangeError('No verifiable presentations created')\n    }\n\n    if (presentationsToCreate.length !== verifiablePresentationResultsWithFormat.length) {\n      throw new DifPresentationExchangeError('Invalid amount of verifiable presentations created')\n    }\n\n    const presentationSubmission: DifPresentationExchangeSubmission = {\n      id: verifiablePresentationResultsWithFormat[0].verifiablePresentationResult.presentationSubmission.id,\n      definition_id:\n        verifiablePresentationResultsWithFormat[0].verifiablePresentationResult.presentationSubmission.definition_id,\n      descriptor_map: [],\n    }\n\n    verifiablePresentationResultsWithFormat.forEach(({ verifiablePresentationResult }, index) => {\n      const descriptorMap = verifiablePresentationResult.presentationSubmission.descriptor_map.map((d) => {\n        const descriptor = { ...d }\n\n        // when multiple presentations are submitted, path should be $[0], $[1]\n        // FIXME: this should be addressed in the PEX/OID4VP lib.\n        // See https://github.com/Sphereon-Opensource/SIOP-OID4VP/issues/62\n        if (\n          presentationSubmissionLocation === DifPresentationExchangeSubmissionLocation.EXTERNAL &&\n          verifiablePresentationResultsWithFormat.length > 1\n        ) {\n          descriptor.path = `$[${index}]`\n        }\n\n        return descriptor\n      })\n\n      presentationSubmission.descriptor_map.push(...descriptorMap)\n    })\n\n    return {\n      verifiablePresentations: verifiablePresentationResultsWithFormat.flatMap((resultWithFormat) =>\n        resultWithFormat.verifiablePresentationResult.verifiablePresentations.map((vp) =>\n          getVerifiablePresentationFromEncoded(agentContext, vp)\n        )\n      ),\n      encodedVerifiablePresentations: verifiablePresentationResultsWithFormat.flatMap(\n        (resultWithFormat) =>\n          resultWithFormat.verifiablePresentationResult.verifiablePresentations as unknown as (\n            | string\n            | W3cJsonPresentation\n          )[]\n      ),\n      presentationSubmission,\n      presentationSubmissionLocation:\n        verifiablePresentationResultsWithFormat[0].verifiablePresentationResult.presentationSubmissionLocation,\n    }\n  }\n\n  private getSigningAlgorithmFromVerificationMethod(\n    verificationMethod: VerificationMethod,\n    suitableAlgorithms?: Array<string>\n  ) {\n    const publicJwk = getPublicJwkFromVerificationMethod(verificationMethod)\n\n    if (suitableAlgorithms) {\n      const possibleAlgorithms = publicJwk.supportedSignatureAlgorithms.filter((alg) =>\n        suitableAlgorithms?.includes(alg)\n      )\n      if (!possibleAlgorithms || possibleAlgorithms.length === 0) {\n        throw new DifPresentationExchangeError(\n          [\n            'Found no suitable signing algorithm.',\n            `Algorithms supported by Verification method: ${publicJwk.supportedSignatureAlgorithms.join(', ')}`,\n            `Suitable algorithms: ${suitableAlgorithms.join(', ')}`,\n          ].join('\\n')\n        )\n      }\n\n      return possibleAlgorithms[0]\n    }\n\n    return publicJwk.signatureAlgorithm\n  }\n\n  private getSigningAlgorithmsForPresentationDefinitionAndInputDescriptors(\n    algorithmsSatisfyingDefinition: Array<string>,\n    inputDescriptorAlgorithms: Array<Array<string>>\n  ) {\n    const allDescriptorAlgorithms = inputDescriptorAlgorithms.flat()\n    const algorithmsSatisfyingDescriptors = allDescriptorAlgorithms.filter((alg) =>\n      inputDescriptorAlgorithms.every((descriptorAlgorithmSet) => descriptorAlgorithmSet.includes(alg))\n    )\n\n    const algorithmsSatisfyingPdAndDescriptorRestrictions = algorithmsSatisfyingDefinition.filter((alg) =>\n      algorithmsSatisfyingDescriptors.includes(alg)\n    )\n\n    if (\n      algorithmsSatisfyingDefinition.length > 0 &&\n      algorithmsSatisfyingDescriptors.length > 0 &&\n      algorithmsSatisfyingPdAndDescriptorRestrictions.length === 0\n    ) {\n      throw new DifPresentationExchangeError(\n        'No signature algorithm found for satisfying restrictions of the presentation definition and input descriptors'\n      )\n    }\n\n    if (allDescriptorAlgorithms.length > 0 && algorithmsSatisfyingDescriptors.length === 0) {\n      throw new DifPresentationExchangeError(\n        'No signature algorithm found for satisfying restrictions of the input descriptors'\n      )\n    }\n\n    let suitableAlgorithms: Array<string> | undefined\n    if (algorithmsSatisfyingPdAndDescriptorRestrictions.length > 0) {\n      suitableAlgorithms = algorithmsSatisfyingPdAndDescriptorRestrictions\n    } else if (algorithmsSatisfyingDescriptors.length > 0) {\n      suitableAlgorithms = algorithmsSatisfyingDescriptors\n    } else if (algorithmsSatisfyingDefinition.length > 0) {\n      suitableAlgorithms = algorithmsSatisfyingDefinition\n    }\n\n    return suitableAlgorithms\n  }\n\n  private getSigningAlgorithmForJwtVc(\n    presentationDefinition: DifPresentationExchangeDefinitionV1 | DifPresentationExchangeDefinitionV2,\n    verificationMethod: VerificationMethod\n  ) {\n    const algorithmsSatisfyingDefinition = presentationDefinition.format?.jwt_vc?.alg ?? []\n\n    const inputDescriptorAlgorithms: Array<Array<string>> = presentationDefinition.input_descriptors\n      .map((descriptor) => (descriptor as InputDescriptorV2).format?.jwt_vc?.alg ?? [])\n      .filter((alg) => alg.length > 0)\n\n    const suitableAlgorithms = this.getSigningAlgorithmsForPresentationDefinitionAndInputDescriptors(\n      algorithmsSatisfyingDefinition,\n      inputDescriptorAlgorithms\n    )\n\n    return this.getSigningAlgorithmFromVerificationMethod(verificationMethod, suitableAlgorithms)\n  }\n\n  private getProofTypeForLdpVc(\n    agentContext: AgentContext,\n    presentationDefinition: DifPresentationExchangeDefinitionV1 | DifPresentationExchangeDefinitionV2,\n    verificationMethod: VerificationMethod\n  ) {\n    const algorithmsSatisfyingDefinition = presentationDefinition.format?.ldp_vc?.proof_type ?? []\n\n    const inputDescriptorAlgorithms: Array<Array<string>> = presentationDefinition.input_descriptors\n      .map((descriptor) => (descriptor as InputDescriptorV2).format?.ldp_vc?.proof_type ?? [])\n      .filter((alg) => alg.length > 0)\n\n    const suitableSignatureSuites = this.getSigningAlgorithmsForPresentationDefinitionAndInputDescriptors(\n      algorithmsSatisfyingDefinition,\n      inputDescriptorAlgorithms\n    )\n\n    // For each of the supported algs, find the key types, then find the proof types\n    const signatureSuiteRegistry = agentContext.dependencyManager.resolve(SignatureSuiteRegistry)\n\n    const publicJwk = getPublicJwkFromVerificationMethod(verificationMethod)\n    const supportedSignatureSuites = signatureSuiteRegistry.getAllByPublicJwkType(publicJwk)\n    if (supportedSignatureSuites.length === 0) {\n      throw new DifPresentationExchangeError(\n        `Couldn't find a supported signature suite for the given jwk ${getJwkHumanDescription(publicJwk.toJson())}`\n      )\n    }\n\n    if (suitableSignatureSuites) {\n      const foundSignatureSuite = supportedSignatureSuites.find((suite) =>\n        suitableSignatureSuites.includes(suite.proofType)\n      )\n\n      if (!foundSignatureSuite) {\n        throw new DifPresentationExchangeError(\n          [\n            'No possible signature suite found for the given verification method.',\n            `Verification method type: ${verificationMethod.type}`,\n            `jwk type: ${getJwkHumanDescription(publicJwk.toJson())}`,\n            `SupportedSignatureSuites: '${supportedSignatureSuites.map((s) => s.proofType).join(', ')}'`,\n            `SuitableSignatureSuites: ${suitableSignatureSuites.join(', ')}`,\n          ].join('\\n')\n        )\n      }\n\n      return foundSignatureSuite.proofType\n    }\n\n    return supportedSignatureSuites[0].proofType\n  }\n\n  /**\n   * if all submission descriptors have a format of di | ldp,\n   * and all credentials have an anoncreds W3C credential proof we default to\n   * signing the presentation using the ANONCREDS_W3C_CREDENTIAL_CRYPTOSUITE\n   */\n  private shouldSignWithAnonCredsW3cService(\n    presentationToCreate: PresentationToCreate,\n    presentationSubmission?: DifPresentationExchangeSubmission\n  ) {\n    if (presentationToCreate.claimFormat !== ClaimFormat.LdpVp) return undefined\n\n    const validDescriptorFormat =\n      !presentationSubmission ||\n      presentationSubmission.descriptor_map.every((descriptor) =>\n        [ClaimFormat.DiVc, ClaimFormat.DiVp, ClaimFormat.LdpVc, ClaimFormat.LdpVp].includes(\n          descriptor.format as ClaimFormat\n        )\n      )\n\n    const credentialsAreSignedWithAnonCredsW3c = presentationToCreate.verifiableCredentials.every(({ credential }) => {\n      const firstCredential = credential.firstCredential\n      if (firstCredential.claimFormat !== ClaimFormat.LdpVc) return false\n      return firstCredential.anonCredsW3cCredentialCryptosuites.includes(ANONCREDS_W3C_CREDENTIAL_CRYPTOSUITE)\n    })\n\n    return validDescriptorFormat && credentialsAreSignedWithAnonCredsW3c\n  }\n\n  private getPresentationSignCallback(agentContext: AgentContext, presentationToCreate: PresentationToCreate) {\n    return async (callBackParams: PresentationSignCallBackParams) => {\n      // The created partial proof and presentation, as well as original supplied options\n      const {\n        presentation: presentationInput,\n        options,\n        presentationDefinition,\n        presentationSubmission,\n      } = callBackParams\n      const { challenge, domain } = options.proofOptions ?? {}\n\n      if (!challenge) {\n        throw new CredoError('challenge MUST be provided when signing a Verifiable Presentation')\n      }\n\n      if (presentationToCreate.claimFormat === ClaimFormat.JwtVp) {\n        if (!presentationToCreate.subjectIds) {\n          throw new DifPresentationExchangeError('Cannot create presentation for credentials without subject id')\n        }\n\n        // Determine a suitable verification method for the presentation\n        const verificationMethod = await this.getVerificationMethodForSubjectId(\n          agentContext,\n          presentationToCreate.subjectIds[0]\n        )\n\n        const w3cPresentation = JsonTransformer.fromJSON(presentationInput, W3cPresentation)\n        w3cPresentation.holder = verificationMethod.controller\n\n        const signedPresentation = await this.w3cCredentialService.signPresentation<ClaimFormat.JwtVp>(agentContext, {\n          format: ClaimFormat.JwtVp,\n          alg: this.getSigningAlgorithmForJwtVc(presentationDefinition, verificationMethod),\n          verificationMethod: verificationMethod.id,\n          presentation: w3cPresentation,\n          challenge,\n          domain,\n        })\n\n        return signedPresentation.encoded as W3CVerifiablePresentation\n      }\n      if (presentationToCreate.claimFormat === ClaimFormat.LdpVp) {\n        if (this.shouldSignWithAnonCredsW3cService(presentationToCreate, presentationSubmission)) {\n          // make sure the descriptors format properties are set correctly\n          presentationSubmission.descriptor_map = presentationSubmission.descriptor_map.map((descriptor) => ({\n            ...descriptor,\n            format: 'di_vp',\n          }))\n          const anoncredsW3cCredentialService = agentContext.dependencyManager.resolve<IAnonCredsW3cCredentialService>(\n            AnonCredsW3cCredentialServiceSymbol\n          )\n          const presentation = await anoncredsW3cCredentialService.createPresentation(agentContext, {\n            presentationDefinition,\n            presentationSubmission,\n            selectedCredentialRecords: presentationToCreate.verifiableCredentials.map((vc) => vc.credential),\n            challenge,\n          })\n          return {\n            ...presentation.toJSON(),\n            presentation_submission: presentationSubmission,\n          } as unknown as SphereonW3cVerifiablePresentation\n        }\n\n        if (!presentationToCreate.subjectIds) {\n          throw new DifPresentationExchangeError('Cannot create presentation for credentials without subject id')\n        }\n        // Determine a suitable verification method for the presentation\n        const verificationMethod = await this.getVerificationMethodForSubjectId(\n          agentContext,\n          presentationToCreate.subjectIds[0]\n        )\n\n        const w3cPresentation = JsonTransformer.fromJSON(presentationInput, W3cPresentation)\n        w3cPresentation.holder = verificationMethod.controller\n\n        const signedPresentation = await this.w3cCredentialService.signPresentation(agentContext, {\n          format: ClaimFormat.LdpVp,\n          // TODO: we should move the check for which proof to use for a presentation to earlier\n          // as then we know when determining which VPs to submit already if the proof types are supported\n          // by the verifier, and we can then just add this to the vpToCreate interface\n          proofType: this.getProofTypeForLdpVc(agentContext, presentationDefinition, verificationMethod),\n          proofPurpose: new purposes.AuthenticationProofPurpose({ challenge, domain }),\n          verificationMethod: verificationMethod.id,\n          presentation: w3cPresentation,\n          challenge,\n          domain,\n        })\n\n        return signedPresentation.encoded as W3CVerifiablePresentation\n      }\n      if (presentationToCreate.claimFormat === ClaimFormat.SdJwtDc) {\n        const sdJwtInput = presentationInput as\n          | SdJwtDecodedVerifiableCredential\n          | PartialSdJwtDecodedVerifiableCredential\n\n        if (!domain) {\n          throw new CredoError(\"Missing 'domain' property, unable to set required 'aud' property in SD-JWT KB-JWT\")\n        }\n\n        const sdJwtVcApi = this.getSdJwtVcApi(agentContext)\n\n        // NOTE: we use the kmsKeyId from the first credential. We don't support the new useMode (for single-use credentials) for PEX\n        const originalSdJwtVc = sdJwtVcApi.fromCompact(sdJwtInput.compactSdJwtVc)\n        originalSdJwtVc.kmsKeyId =\n          presentationToCreate.verifiableCredentials[0].credential.credentialInstances[0].kmsKeyId\n\n        const sdJwtVc = await sdJwtVcApi.present({\n          sdJwtVc: originalSdJwtVc,\n          // SD is already handled by PEX, so we presents all keys\n          presentationFrame: undefined,\n          verifierMetadata: {\n            audience: domain,\n            nonce: challenge,\n            // TODO: we should make this optional\n            issuedAt: Math.floor(Date.now() / 1000),\n          },\n          additionalPayload: presentationToCreate.verifiableCredentials[0].additionalPayload,\n        })\n\n        return sdJwtVc\n      }\n      throw new DifPresentationExchangeError(\n        'Only JWT, SD-JWT-VC, JSONLD credentials are supported for a single presentation'\n      )\n    }\n  }\n\n  private async getVerificationMethodForSubjectId(agentContext: AgentContext, subjectId: string) {\n    const didsApi = agentContext.dependencyManager.resolve(DidsApi)\n\n    if (!subjectId.startsWith('did:')) {\n      throw new DifPresentationExchangeError(\n        `Only dids are supported as credentialSubject id. ${subjectId} is not a valid did`\n      )\n    }\n\n    const didDocument = await didsApi.resolveDidDocument(subjectId)\n\n    if (!didDocument.authentication || didDocument.authentication.length === 0) {\n      throw new DifPresentationExchangeError(\n        `No authentication verificationMethods found for did ${subjectId} in did document`\n      )\n    }\n\n    // the signature suite to use for the presentation is dependant on the credentials we share.\n    // 1. Get the verification method for this given proof purpose in this DID document\n    const [verificationMethod] = didDocument.findVerificationMethodsByPurpose(['authentication'])\n    return verificationMethod\n  }\n\n  /**\n   * Queries the wallet for credentials that match the given presentation definition. This only does an initial query based on the\n   * schema of the input descriptors. It does not do any further filtering based on the constraints in the input descriptors.\n   */\n  private async queryCredentialForPresentationDefinition(\n    agentContext: AgentContext,\n    presentationDefinition: DifPresentationExchangeDefinition\n  ): Promise<Array<SdJwtVcRecord | W3cCredentialRecord | MdocRecord>> {\n    const w3cCredentialRepository = agentContext.dependencyManager.resolve(W3cCredentialRepository)\n    const w3cQuery: Array<Query<W3cCredentialRecord>> = []\n    const sdJwtVcQuery: Array<Query<SdJwtVcRecord>> = []\n    const mdocQuery: Array<Query<MdocRecord>> = []\n\n    const presentationDefinitionVersion = PEX.definitionVersionDiscovery(presentationDefinition)\n\n    if (!presentationDefinitionVersion.version) {\n      throw new DifPresentationExchangeError(\n        'Unable to determine the Presentation Exchange version from the presentation definition',\n        presentationDefinitionVersion.error ? { additionalMessages: [presentationDefinitionVersion.error] } : {}\n      )\n    }\n\n    // FIXME: in the query we should take into account the supported proof types of the verifier\n    // this could help enormously in the amount of credentials we have to retrieve from storage.\n    if (presentationDefinitionVersion.version === PEVersion.v1) {\n      const pd = presentationDefinition as DifPresentationExchangeDefinitionV1\n\n      // The schema.uri can contain either an expanded type, or a context uri\n      for (const inputDescriptor of pd.input_descriptors) {\n        for (const schema of inputDescriptor.schema) {\n          sdJwtVcQuery.push({\n            vct: schema.uri,\n          })\n          w3cQuery.push({\n            $or: [{ expandedTypes: [schema.uri] }, { contexts: [schema.uri] }, { types: [schema.uri] }],\n          })\n          mdocQuery.push({\n            docType: inputDescriptor.id,\n          })\n        }\n      }\n    } else if (presentationDefinitionVersion.version === PEVersion.v2) {\n      // FIXME: As PE version 2 does not have the `schema` anymore, we can't query by schema anymore.\n      // We probably need\n      // to find some way to do initial filtering, hopefully if there's a filter on the `type` field or something.\n    } else {\n      throw new DifPresentationExchangeError(\n        `Unsupported presentation definition version ${presentationDefinitionVersion.version as unknown as string}`\n      )\n    }\n\n    const allRecords: Array<SdJwtVcRecord | W3cCredentialRecord | MdocRecord> = []\n\n    // query the wallet ourselves first to avoid the need to query the pex library for all\n    // credentials for every proof request\n    const w3cCredentialRecords =\n      w3cQuery.length > 0\n        ? await w3cCredentialRepository.findByQuery(agentContext, { $or: w3cQuery })\n        : await w3cCredentialRepository.getAll(agentContext)\n    allRecords.push(...w3cCredentialRecords)\n\n    const sdJwtVcApi = this.getSdJwtVcApi(agentContext)\n    const sdJwtVcRecords =\n      sdJwtVcQuery.length > 0 ? await sdJwtVcApi.findAllByQuery({ $or: sdJwtVcQuery }) : await sdJwtVcApi.getAll()\n    allRecords.push(...sdJwtVcRecords)\n\n    const mdocApi = this.getMdocApi(agentContext)\n    const mdocRecords = mdocQuery.length > 0 ? await mdocApi.findAllByQuery({ $or: mdocQuery }) : await mdocApi.getAll()\n    allRecords.push(...mdocRecords)\n\n    return allRecords\n  }\n\n  private getSdJwtVcApi(agentContext: AgentContext) {\n    return agentContext.dependencyManager.resolve(SdJwtVcApi)\n  }\n\n  private getMdocApi(agentContext: AgentContext) {\n    return agentContext.dependencyManager.resolve(MdocApi)\n  }\n}\n"],"mappings":"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"}