Merge pull request #9 from animo/refactor/replace-mdoc-lib

Author: berendsliedrecht

lib/PEX.ts

@@ -1,20 +1,15 @@
 import { Format, PresentationDefinitionV1, PresentationDefinitionV2, PresentationSubmission } from '@sphereon/pex-models';
 import {
   CompactSdJwtVc,
-  CredentialMapper,
   Hasher,
   ICredential,
   IPresentation,
   IProof,
   JwtDecodedVerifiableCredential,
-  OriginalVerifiableCredential,
-  OriginalVerifiablePresentation,
   OrPromise,
   SdJwtDecodedVerifiableCredential,
   W3CVerifiableCredential,
   W3CVerifiablePresentation,
-  WrappedVerifiableCredential,
-  WrappedVerifiablePresentation,
 } from '@sphereon/ssi-types';
 
 import { Status } from './ConstraintUtils';
@@ -30,6 +25,13 @@ import {
   VerifiablePresentationResult,
 } from './signing';
 import { DiscoveredVersion, IInternalPresentationDefinition, IPresentationDefinition, OrArray, PEVersion, SSITypesBuilder } from './types';
+import {
+  OriginalVerifiableCredential,
+  OriginalVerifiablePresentation,
+  PexCredentialMapper,
+  WrappedVerifiableCredential,
+  WrappedVerifiablePresentation,
+} from './types/PexCredentialMapper';
 import { calculateSdHash, definitionVersionDiscovery, formatValidationErrors, getSubjectIdsAsString } from './utils';
 import { PresentationDefinitionV1VB, PresentationDefinitionV2VB, PresentationSubmissionVB, Validated, ValidationEngine } from './validation';
 
@@ -38,7 +40,7 @@ export interface PEXOptions {
    * Hasher implementation, can be used for tasks such as decoding a compact SD-JWT VC to it's encoded variant.
    * When decoding SD-JWT credentials the hasher must be provided. The hasher implementation must be sync. When using
    * an async hasher implementation, you must manually decode the credential or presentation first according to the
-   * `SdJwtDecodedVerifiableCredential` interface. You can use the `CredentialMapper.decodeSdJwtAsync` method for
+   * `SdJwtDecodedVerifiableCredential` interface. You can use the `PexCredentialMapper.decodeSdJwtAsync` method for
    *  this from the `@sphereon/ssi-types` package. NOTE that this is only needed when using an async hasher, and
    * that for sync hashers providing it here is enough for the decoding to be done automatically.
    */
@@ -106,15 +108,15 @@ export class PEX {
     let presentationSubmission = opts?.presentationSubmission;
     let presentationSubmissionLocation =
       opts?.presentationSubmissionLocation ??
-      ((Array.isArray(presentations) && presentations.length > 1) || !CredentialMapper.isW3cPresentation(wrappedPresentations[0].presentation)
+      ((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 &&
-      CredentialMapper.isW3cPresentation(wrappedPresentations[0].presentation) &&
+      PexCredentialMapper.isW3cPresentation(wrappedPresentations[0].presentation) &&
       !generatePresentationSubmission
     ) {
       const decoded = wrappedPresentations[0].decoded;
@@ -138,7 +140,7 @@ export class PEX {
     // `wrappedPresentation.original.compactKbJwt`, but as HAIP doesn't use dids, we'll leave it for now.
     const holderDIDs = wrappedPresentations
       .map((p) => {
-        return CredentialMapper.isW3cPresentation(p.presentation) && p.presentation.holder ? p.presentation.holder : undefined;
+        return PexCredentialMapper.isW3cPresentation(p.presentation) && p.presentation.holder ? p.presentation.holder : undefined;
       })
       .filter((d): d is string => d !== undefined);
 
@@ -269,7 +271,9 @@ export class PEX {
     opts?: PresentationFromOpts,
   ): PresentationResult {
     const presentationSubmission = this.presentationSubmissionFrom(presentationDefinition, selectedCredentials, opts);
-    const hasSdJwtCredentials = selectedCredentials.some((c) => CredentialMapper.isSdJwtDecodedCredential(c) || CredentialMapper.isSdJwtEncoded(c));
+    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) {
@@ -310,7 +314,7 @@ export class PEX {
     }
     const verifiableCredential = (Array.isArray(selectedCredentials) ? selectedCredentials : [selectedCredentials]) as W3CVerifiableCredential[];
 
-    const wVCs = verifiableCredential.map((vc) => CredentialMapper.toWrappedVerifiableCredential(vc));
+    const wVCs = verifiableCredential.map((vc) => PexCredentialMapper.toWrappedVerifiableCredential(vc));
     const holders = Array.from(new Set(wVCs.flatMap((wvc) => getSubjectIdsAsString(wvc.credential as ICredential))));
     const holder = opts?.holderDID ?? (holders.length === 1 ? holders[0] : undefined);
 
@@ -352,10 +356,10 @@ export class PEX {
       });
     } else {
       verifiableCredential.forEach((vc) => {
-        if (CredentialMapper.isSdJwtDecodedCredential(vc)) {
+        if (PexCredentialMapper.isSdJwtDecodedCredential(vc)) {
           result.push(vc as PartialSdJwtDecodedVerifiableCredential);
-        } else if (CredentialMapper.isSdJwtEncoded(vc)) {
-          const decoded = CredentialMapper.decodeVerifiableCredential(vc);
+        } else if (PexCredentialMapper.isSdJwtEncoded(vc)) {
+          const decoded = PexCredentialMapper.decodeVerifiableCredential(vc);
           result.push(decoded as PartialSdJwtDecodedVerifiableCredential);
         } else {
           // This should be jwt or json-ld
@@ -377,15 +381,15 @@ export class PEX {
     TODO SDK-37 refinement needed
    */
   private static allowMultipleVCsPerPresentation(verifiableCredentials: Array<OriginalVerifiableCredential>): boolean {
-    const jwtCredentials = verifiableCredentials.filter((c) => CredentialMapper.isJwtEncoded(c) || CredentialMapper.isJwtDecodedCredential(c));
+    const jwtCredentials = verifiableCredentials.filter((c) => PexCredentialMapper.isJwtEncoded(c) || PexCredentialMapper.isJwtDecodedCredential(c));
 
     if (jwtCredentials.length > 0) {
       const subjects = new Set<string>();
       const verificationMethods = new Set<string>();
 
       for (const credential of jwtCredentials) {
-        const decodedCredential = CredentialMapper.isJwtEncoded(credential)
-          ? (CredentialMapper.decodeVerifiableCredential(credential) as JwtDecodedVerifiableCredential)
+        const decodedCredential = PexCredentialMapper.isJwtEncoded(credential)
+          ? (PexCredentialMapper.decodeVerifiableCredential(credential) as JwtDecodedVerifiableCredential)
           : (credential as JwtDecodedVerifiableCredential);
 
         const subject =
@@ -406,7 +410,7 @@ export class PEX {
       }
     }
 
-    if (verifiableCredentials.some((c) => CredentialMapper.isSdJwtEncoded(c) || CredentialMapper.isSdJwtDecodedCredential(c))) {
+    if (verifiableCredentials.some((c) => PexCredentialMapper.isSdJwtEncoded(c) || PexCredentialMapper.isSdJwtDecodedCredential(c))) {
       return false;
     }
 
@@ -568,7 +572,7 @@ export class PEX {
   ) {
     presentations.forEach((presentation, index) => {
       // Select type without kbJwt as isSdJwtDecodedCredential and won't accept the partial sdvc type
-      if (CredentialMapper.isSdJwtDecodedCredential(presentation as SdJwtDecodedVerifiableCredential)) {
+      if (PexCredentialMapper.isSdJwtDecodedCredential(presentation as SdJwtDecodedVerifiableCredential)) {
         const sdJwtCredential = presentation as SdJwtDecodedVerifiableCredential;
 
         // extract sd_alg or default to sha-256

lib/PEXv1.ts

@@ -1,10 +1,11 @@
 import { Format, PresentationDefinitionV1, PresentationSubmission } from '@sphereon/pex-models';
-import { CredentialMapper, IPresentation, OriginalVerifiableCredential, OriginalVerifiablePresentation } from '@sphereon/ssi-types';
+import { IPresentation } from '@sphereon/ssi-types';
 
 import { PEX } from './PEX';
 import { EvaluationClientWrapper, EvaluationResults, PresentationEvaluationResults, SelectResults } from './evaluation';
 import { PresentationFromOpts, PresentationResult, PresentationSubmissionLocation } from './signing';
 import { SSITypesBuilder } from './types';
+import { OriginalVerifiableCredential, OriginalVerifiablePresentation, PexCredentialMapper } from './types/PexCredentialMapper';
 import { PresentationDefinitionV1VB, Validated, ValidationEngine } from './validation';
 
 /**
@@ -113,7 +114,9 @@ export class PEXv1 extends PEX {
       opts,
     );
 
-    const hasSdJwtCredentials = selectedCredentials.some((c) => CredentialMapper.isSdJwtDecodedCredential(c) || CredentialMapper.isSdJwtEncoded(c));
+    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) {

lib/PEXv2.ts

@@ -1,10 +1,11 @@
 import { Format, PresentationDefinitionV2, PresentationSubmission } from '@sphereon/pex-models';
-import { CredentialMapper, IPresentation, OriginalVerifiableCredential, OriginalVerifiablePresentation } from '@sphereon/ssi-types';
+import { IPresentation } from '@sphereon/ssi-types';
 
 import { PEX } from './PEX';
 import { EvaluationClientWrapper, EvaluationResults, PresentationEvaluationResults, SelectResults } from './evaluation';
 import { PresentationFromOpts, PresentationResult, PresentationSubmissionLocation } from './signing';
 import { SSITypesBuilder } from './types';
+import { OriginalVerifiableCredential, OriginalVerifiablePresentation, PexCredentialMapper } from './types/PexCredentialMapper';
 import { PresentationDefinitionV2VB, Validated, ValidationEngine } from './validation';
 
 /**
@@ -109,7 +110,9 @@ export class PEXv2 extends PEX {
       SSITypesBuilder.mapExternalVerifiableCredentialsToWrappedVcs(selectedCredentials),
       opts,
     );
-    const hasSdJwtCredentials = selectedCredentials.some((c) => CredentialMapper.isSdJwtDecodedCredential(c) || CredentialMapper.isSdJwtEncoded(c));
+    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) {

lib/evaluation/core/evaluationResults.ts

@@ -1,7 +1,8 @@
 import { PresentationSubmission } from '@sphereon/pex-models';
-import { IPresentation, IVerifiableCredential, OriginalVerifiablePresentation, SdJwtDecodedVerifiableCredential } from '@sphereon/ssi-types';
+import { IPresentation, IVerifiableCredential, SdJwtDecodedVerifiableCredential } from '@sphereon/ssi-types';
 
 import { Checked, Status } from '../../ConstraintUtils';
+import { OriginalVerifiablePresentation } from '../../types/PexCredentialMapper';
 
 export interface PresentationEvaluationResults extends Omit<EvaluationResults, 'verifiableCredential'> {
   presentations: Array<OriginalVerifiablePresentation | IPresentation>;

lib/evaluation/core/selectResults.ts

@@ -1,6 +1,5 @@
-import { OriginalVerifiableCredential } from '@sphereon/ssi-types';
-
 import { Checked, Status } from '../../ConstraintUtils';
+import { OriginalVerifiableCredential } from '../../types/PexCredentialMapper';
 
 import { SubmissionRequirementMatch } from './submissionRequirementMatch';
 

lib/evaluation/evaluationClient.ts

@@ -1,9 +1,10 @@
 import { Format, PresentationSubmission } from '@sphereon/pex-models';
-import { IProofType, WrappedVerifiableCredential } from '@sphereon/ssi-types';
+import { IProofType } from '@sphereon/ssi-types';
 
 import { Status } from '../ConstraintUtils';
 import { IInternalPresentationDefinition } from '../types';
 import PexMessages from '../types/Messages';
+import { WrappedVerifiableCredential } from '../types/PexCredentialMapper';
 import { filterToRestrictedDIDs, uniformDIDMethods } from '../utils';
 
 import { HandlerCheckResult } from './core';

lib/evaluation/evaluationClientWrapper.ts

@@ -1,16 +1,7 @@
 import { JSONPath as jp } from '@astronautlabs/jsonpath';
 import { Descriptor, Format, InputDescriptorV1, InputDescriptorV2, PresentationSubmission, Rules } from '@sphereon/pex-models';
 import type { SubmissionRequirement } from '@sphereon/pex-models';
-import {
-  CredentialMapper,
-  IVerifiableCredential,
-  IVerifiablePresentation,
-  OriginalVerifiableCredential,
-  SdJwtDecodedVerifiableCredential,
-  WrappedMdocCredential,
-  WrappedVerifiableCredential,
-  WrappedVerifiablePresentation,
-} from '@sphereon/ssi-types';
+import { IVerifiableCredential, IVerifiablePresentation, SdJwtDecodedVerifiableCredential } from '@sphereon/ssi-types';
 
 import { Checked, Status } from '../ConstraintUtils';
 import { PresentationSubmissionLocation } from '../signing';
@@ -21,6 +12,13 @@ import {
   IPresentationDefinition,
   OrArray,
 } from '../types';
+import {
+  OriginalVerifiableCredential,
+  PexCredentialMapper,
+  WrappedMdocCredential,
+  WrappedVerifiableCredential,
+  WrappedVerifiablePresentation,
+} from '../types/PexCredentialMapper';
 import { JsonPathUtils } from '../utils';
 import { getVpFormatForVcFormat } from '../utils/formatMap';
 
@@ -468,7 +466,7 @@ export class EvaluationClientWrapper {
     }
 
     // FIXME figure out possible types, can't see that in debug mode...
-    const isCredential = CredentialMapper.isCredential(vcResult.value as OriginalVerifiableCredential);
+    const isCredential = PexCredentialMapper.isCredential(vcResult.value as OriginalVerifiableCredential);
     if (
       !vcResult.value ||
       (typeof vcResult.value === 'string' && !isCredential) ||
@@ -505,7 +503,7 @@ export class EvaluationClientWrapper {
     }
 
     // Find the corresponding Wrapped Verifiable Credential (wvc) based on the original VC
-    const wvc = wvp.vcs.find((wrappedVc) => CredentialMapper.areOriginalVerifiableCredentialsEqual(wrappedVc.original, originalVc));
+    const wvc = wvp.vcs.find((wrappedVc) => PexCredentialMapper.areOriginalVerifiableCredentialsEqual(wrappedVc.original, originalVc));
 
     if (!wvc) {
       return {
@@ -555,7 +553,7 @@ export class EvaluationClientWrapper {
     // If only a single VP is passed that is not w3c and no presentationSubmissionLocation, we set the default location to presentation. Otherwise we assume it's external
     const presentationSubmissionLocation =
       opts?.presentationSubmissionLocation ??
-      (Array.isArray(wvps) || !CredentialMapper.isW3cPresentation(Array.isArray(wvps) ? wvps[0].presentation : wvps.presentation)
+      (Array.isArray(wvps) || !PexCredentialMapper.isW3cPresentation(Array.isArray(wvps) ? wvps[0].presentation : wvps.presentation)
         ? PresentationSubmissionLocation.EXTERNAL
         : PresentationSubmissionLocation.PRESENTATION);
 
@@ -651,10 +649,10 @@ export class EvaluationClientWrapper {
           const vcs = matchingVp.vcs as WrappedMdocCredential[];
           vcPath += ` with nested mdoc with doctype ${descriptor.id}`;
 
-          const matchingVc = vcs.find((vc) => descriptor.id === vc.credential.docType.asStr);
+          const matchingVc = vcs.find((vc) => descriptor.id === vc.credential.docType);
 
           if (!matchingVc) {
-            const allDoctypes = vcs.map((vc) => `'${vc.credential.docType.asStr}'`).join(', ');
+            const allDoctypes = vcs.map((vc) => `'${vc.credential.docType}'`).join(', ');
             result.areRequiredCredentialsPresent = Status.ERROR;
             result.errors?.push({
               status: Status.ERROR,
@@ -691,7 +689,7 @@ export class EvaluationClientWrapper {
 
       // Determine holder DIDs
       const holderDIDs =
-        CredentialMapper.isW3cPresentation(matchingVp.presentation) && matchingVp.presentation.holder
+        PexCredentialMapper.isW3cPresentation(matchingVp.presentation) && matchingVp.presentation.holder
           ? [matchingVp.presentation.holder]
           : opts?.holderDIDs || [];
 

lib/evaluation/handlers/abstractEvaluationHandler.ts

@@ -1,9 +1,9 @@
 import { JSONPath as jp } from '@astronautlabs/jsonpath';
 import { InputDescriptorV1, InputDescriptorV2, PresentationSubmission } from '@sphereon/pex-models';
-import { WrappedVerifiableCredential } from '@sphereon/ssi-types';
 
 import { Status } from '../../ConstraintUtils';
 import { IInternalPresentationDefinition } from '../../types';
+import { WrappedVerifiableCredential } from '../../types/PexCredentialMapper';
 import { HandlerCheckResult } from '../core';
 import { EvaluationClient } from '../evaluationClient';
 

lib/evaluation/handlers/didRestrictionEvaluationHandler.ts

@@ -1,8 +1,7 @@
-import { CredentialMapper, WrappedVerifiableCredential } from '@sphereon/ssi-types';
-
 import { Status } from '../../ConstraintUtils';
 import { IInternalPresentationDefinition, InternalPresentationDefinitionV1, InternalPresentationDefinitionV2 } from '../../types';
 import PexMessages from '../../types/Messages';
+import { PexCredentialMapper, WrappedVerifiableCredential } from '../../types/PexCredentialMapper';
 import { isRestrictedDID } from '../../utils';
 import { HandlerCheckResult } from '../core';
 import { EvaluationClient } from '../evaluationClient';
@@ -39,13 +38,13 @@ export class DIDRestrictionEvaluationHandler extends AbstractEvaluationHandler {
   }
 
   private getIssuerIdFromWrappedVerifiableCredential(wrappedVc: WrappedVerifiableCredential) {
-    if (CredentialMapper.isW3cCredential(wrappedVc.credential)) {
+    if (PexCredentialMapper.isW3cCredential(wrappedVc.credential)) {
       return typeof wrappedVc.credential.issuer === 'object' ? wrappedVc.credential.issuer.id : wrappedVc.credential.issuer;
-    } else if (CredentialMapper.isSdJwtDecodedCredential(wrappedVc.credential)) {
+    } else if (PexCredentialMapper.isSdJwtDecodedCredential(wrappedVc.credential)) {
       return wrappedVc.credential.decodedPayload.iss;
     }
     // mdoc is not bound to did
-    else if (CredentialMapper.isWrappedMdocCredential(wrappedVc)) {
+    else if (PexCredentialMapper.isWrappedMdocCredential(wrappedVc)) {
       return undefined;
     }
     throw new Error('Unsupported credential type');

lib/evaluation/handlers/evaluationHandler.ts

@@ -1,6 +1,5 @@
-import { WrappedVerifiableCredential } from '@sphereon/ssi-types';
-
 import { IInternalPresentationDefinition } from '../../types/Internal.types';
+import { WrappedVerifiableCredential } from '../../types/PexCredentialMapper';
 import { EvaluationClient } from '../evaluationClient';
 
 export interface EvaluationHandler {