@sphereon/ssi-types 0.23.5-unstable.88 → 0.24.0

package/src/mapper/credential-mapper.ts

@@ -1,748 +1,748 @@
-import jwt_decode from 'jwt-decode'
-import {
-  DocumentFormat,
-  IPresentation,
-  IProof,
-  IProofPurpose,
-  IProofType,
-  IVerifiableCredential,
-  IVerifiablePresentation,
-  JwtDecodedVerifiableCredential,
-  JwtDecodedVerifiablePresentation,
-  OriginalType,
-  OriginalVerifiableCredential,
-  OriginalVerifiablePresentation,
-  UniformVerifiablePresentation,
-  W3CVerifiableCredential,
-  W3CVerifiablePresentation,
-  WrappedVerifiableCredential,
-  WrappedVerifiablePresentation,
-  SdJwtDecodedVerifiableCredential,
-  SdJwtDecodedVerifiableCredentialPayload,
-  ICredential,
-  WrappedSdJwtVerifiableCredential,
-  WrappedW3CVerifiableCredential,
-  isWrappedSdJwtVerifiableCredential,
-  isWrappedSdJwtVerifiablePresentation,
-  isWrappedW3CVerifiableCredential,
-  isWrappedW3CVerifiablePresentation,
-  Hasher,
-  decodeSdJwtVc,
-  decodeSdJwtVcAsync,
-  AsyncHasher,
-} from '../types'
-import { ObjectUtils } from '../utils'
-
-export class CredentialMapper {
-  /**
-   * Decodes a compact SD-JWT vc to it's decoded variant. This method can be used when the hasher implementation used is Async, and therefore not suitable for usage
-   * with the other decode methods.
-   */
-  static decodeSdJwtVcAsync(compactSdJwtVc: string, hasher: AsyncHasher) {
-    return decodeSdJwtVcAsync(compactSdJwtVc, hasher)
-  }
-
-  /**
-   * Decodes a Verifiable Presentation to a uniform format.
-   *
-   * When decoding SD-JWT credentials, a hasher implementation must be provided. The hasher implementation must be sync. When using
-   * an async hasher implementation, use the decodeSdJwtVcAsync method instead and you can provide the decoded payload to methods
-   * instead of the compact SD-JWT.
-   *
-   * @param hasher Hasher implementation to use for SD-JWT decoding.
-   */
-  static decodeVerifiablePresentation(
-    presentation: OriginalVerifiablePresentation,
-    hasher?: Hasher,
-  ): JwtDecodedVerifiablePresentation | IVerifiablePresentation | SdJwtDecodedVerifiableCredential {
-    if (CredentialMapper.isJwtEncoded(presentation)) {
-      const payload = jwt_decode(presentation as string) as JwtDecodedVerifiablePresentation
-      const header = jwt_decode(presentation as string, { header: true }) as Record<string, any>
-
-      payload.vp.proof = {
-        type: IProofType.JwtProof2020,
-        created: payload.nbf,
-        proofPurpose: IProofPurpose.authentication,
-        verificationMethod: header['kid'] ?? payload.iss,
-        jwt: presentation as string,
-      }
-      return payload
-    } else if (CredentialMapper.isJwtDecodedPresentation(presentation)) {
-      return presentation as JwtDecodedVerifiablePresentation
-    } else if (CredentialMapper.isSdJwtEncoded(presentation)) {
-      if (!hasher) {
-        throw new Error('Hasher implementation is required to decode SD-JWT')
-      }
-      return decodeSdJwtVc(presentation, hasher)
-    } else if (CredentialMapper.isSdJwtDecodedCredential(presentation)) {
-      return presentation as SdJwtDecodedVerifiableCredential
-    } else if (CredentialMapper.isJsonLdAsString(presentation)) {
-      return JSON.parse(presentation as string) as IVerifiablePresentation
-    } else {
-      return presentation as IVerifiablePresentation
-    }
-  }
-
-  /**
-   * Decodes a Verifiable Credential to a uniform format.
-   *
-   * When decoding SD-JWT credentials, a hasher implementation must be provided. The hasher implementation must be sync. When using
-   * an async hasher implementation, use the decodeSdJwtVcAsync method instead and you can provide the decoded payload to methods
-   * instead of the compact SD-JWT.
-   *
-   * @param hasher Hasher implementation to use for SD-JWT decoding
-   */
-  static decodeVerifiableCredential(
-    credential: OriginalVerifiableCredential,
-    hasher?: Hasher,
-  ): JwtDecodedVerifiableCredential | IVerifiableCredential | SdJwtDecodedVerifiableCredential {
-    if (CredentialMapper.isJwtEncoded(credential)) {
-      const payload = jwt_decode(credential as string) as JwtDecodedVerifiableCredential
-      const header = jwt_decode(credential as string, { header: true }) as Record<string, any>
-      payload.vc.proof = {
-        type: IProofType.JwtProof2020,
-        created: payload.nbf,
-        proofPurpose: IProofPurpose.authentication,
-        verificationMethod: header['kid'] ?? payload.iss,
-        jwt: credential as string,
-      }
-      return payload
-    } else if (CredentialMapper.isJwtDecodedCredential(credential)) {
-      return credential
-    } else if (CredentialMapper.isJsonLdAsString(credential)) {
-      return JSON.parse(credential as string) as IVerifiableCredential
-    } else if (CredentialMapper.isSdJwtEncoded(credential)) {
-      if (!hasher) {
-        throw new Error('Hasher implementation is required to decode SD-JWT')
-      }
-      return decodeSdJwtVc(credential, hasher)
-    } else if (CredentialMapper.isSdJwtDecodedCredential(credential)) {
-      return credential
-    } else {
-      return credential as IVerifiableCredential
-    }
-  }
-
-  /**
-   * Converts a presentation to a wrapped presentation.
-   *
-   * When decoding SD-JWT credentials, a hasher implementation must be provided. The hasher implementation must be sync. When using
-   * an async hasher implementation, use the decodeSdJwtVcAsync method instead and you can provide the decoded payload to methods
-   * instead of the compact SD-JWT.
-   *
-   * @param hasher Hasher implementation to use for SD-JWT decoding
-   */
-  static toWrappedVerifiablePresentation(
-    originalPresentation: OriginalVerifiablePresentation,
-    opts?: { maxTimeSkewInMS?: number; hasher?: Hasher },
-  ): WrappedVerifiablePresentation {
-    // SD-JWT
-    if (CredentialMapper.isSdJwtDecodedCredential(originalPresentation) || CredentialMapper.isSdJwtEncoded(originalPresentation)) {
-      let decodedPresentation: SdJwtDecodedVerifiableCredential
-      if (CredentialMapper.isSdJwtEncoded(originalPresentation)) {
-        if (!opts?.hasher) {
-          throw new Error('Hasher implementation is required to decode SD-JWT')
-        }
-        decodedPresentation = decodeSdJwtVc(originalPresentation, opts.hasher)
-      } else {
-        decodedPresentation = originalPresentation
-      }
-      return {
-        type: CredentialMapper.isSdJwtDecodedCredential(originalPresentation) ? OriginalType.SD_JWT_VC_DECODED : OriginalType.SD_JWT_VC_ENCODED,
-        format: 'vc+sd-jwt',
-        original: originalPresentation,
-        presentation: decodedPresentation,
-        decoded: decodedPresentation.decodedPayload,
-        // NOTE: we also include the SD-JWT VC as the VC, as the SD-JWT acts as both the VC and the VP
-        vcs: [CredentialMapper.toWrappedVerifiableCredential(originalPresentation, opts) as WrappedSdJwtVerifiableCredential],
-      }
-    }
-
-    // If the VP is not an encoded/decoded SD-JWT, we assume it will be a W3C VC
-    const proof = CredentialMapper.getFirstProof(originalPresentation)
-    const original =
-      typeof originalPresentation !== 'string' && CredentialMapper.hasJWTProofType(originalPresentation) ? proof?.jwt : originalPresentation
-    if (!original) {
-      throw Error(
-        'Could not determine original presentation, probably it was a converted JWT presentation, that is now missing the JWT value in the proof',
-      )
-    }
-    const decoded = CredentialMapper.decodeVerifiablePresentation(original) as IVerifiablePresentation | JwtDecodedVerifiablePresentation
-    const isJwtEncoded: boolean = CredentialMapper.isJwtEncoded(original)
-    const isJwtDecoded: boolean = CredentialMapper.isJwtDecodedPresentation(original)
-
-    const type = isJwtEncoded ? OriginalType.JWT_ENCODED : isJwtDecoded ? OriginalType.JWT_DECODED : OriginalType.JSONLD
-    const format = isJwtDecoded || isJwtEncoded ? 'jwt_vp' : ('ldp_vp' as const)
-
-    let vp: OriginalVerifiablePresentation
-    if (isJwtEncoded || isJwtDecoded) {
-      vp = CredentialMapper.jwtDecodedPresentationToUniformPresentation(decoded as JwtDecodedVerifiablePresentation, false, opts)
-    } else {
-      vp = decoded as IVerifiablePresentation
-    }
-    if (!vp || !('verifiableCredential' in vp) || !vp.verifiableCredential || vp.verifiableCredential.length === 0) {
-      throw Error(`VP needs to have at least one verifiable credential at this point`)
-    }
-    const vcs = CredentialMapper.toWrappedVerifiableCredentials(
-      vp.verifiableCredential /*.map(value => value.original)*/,
-      opts,
-    ) as WrappedW3CVerifiableCredential[]
-
-    const presentation = {
-      ...vp,
-      verifiableCredential: vcs, // We overwrite the verifiableCredentials with wrapped versions, making it an InternalVerifiablePresentation. Note: we keep the singular key name of the vc data model
-    } as UniformVerifiablePresentation
-    return {
-      type,
-      format,
-      original,
-      decoded,
-      presentation,
-      vcs,
-    }
-  }
-
-  /**
-   * Converts a list of credentials to a list of wrapped credentials.
-   *
-   * When decoding SD-JWT credentials, a hasher implementation must be provided. The hasher implementation must be sync. When using
-   * an async hasher implementation, use the decodeSdJwtVcAsync method instead and you can provide the decoded payload to methods
-   * instead of the compact SD-JWT.
-   *
-   * @param hasher Hasher implementation to use for SD-JWT decoding
-   */
-  static toWrappedVerifiableCredentials(
-    verifiableCredentials: OriginalVerifiableCredential[],
-    opts?: { maxTimeSkewInMS?: number; hasher?: Hasher },
-  ): WrappedVerifiableCredential[] {
-    return verifiableCredentials.map((vc) => CredentialMapper.toWrappedVerifiableCredential(vc, opts))
-  }
-
-  /**
-   * Converts a credential to a wrapped credential.
-   *
-   * When decoding SD-JWT credentials, a hasher implementation must be provided. The hasher implementation must be sync. When using
-   * an async hasher implementation, use the decodeSdJwtVcAsync method instead and you can provide the decoded payload to methods
-   * instead of the compact SD-JWT.
-   *
-   * @param hasher Hasher implementation to use for SD-JWT decoding
-   */
-  static toWrappedVerifiableCredential(
-    verifiableCredential: OriginalVerifiableCredential,
-    opts?: { maxTimeSkewInMS?: number; hasher?: Hasher },
-  ): WrappedVerifiableCredential {
-    // SD-JWT
-    if (CredentialMapper.isSdJwtDecodedCredential(verifiableCredential) || CredentialMapper.isSdJwtEncoded(verifiableCredential)) {
-      let decodedCredential: SdJwtDecodedVerifiableCredential
-      if (CredentialMapper.isSdJwtEncoded(verifiableCredential)) {
-        if (!opts?.hasher) {
-          throw new Error('Hasher implementation is required to decode SD-JWT')
-        }
-        decodedCredential = decodeSdJwtVc(verifiableCredential, opts.hasher)
-      } else {
-        decodedCredential = verifiableCredential
-      }
-
-      return {
-        type: CredentialMapper.isSdJwtDecodedCredential(verifiableCredential) ? OriginalType.SD_JWT_VC_DECODED : OriginalType.SD_JWT_VC_ENCODED,
-        format: 'vc+sd-jwt',
-        original: verifiableCredential,
-        credential: decodedCredential,
-        decoded: decodedCredential.decodedPayload,
-      }
-    }
-
-    // If the VC is not an encoded/decoded SD-JWT, we assume it will be a W3C VC
-    const proof = CredentialMapper.getFirstProof(verifiableCredential)
-    const original = CredentialMapper.hasJWTProofType(verifiableCredential) && proof ? proof.jwt ?? verifiableCredential : verifiableCredential
-    if (!original) {
-      throw Error(
-        'Could not determine original credential, probably it was a converted JWT credential, that is now missing the JWT value in the proof',
-      )
-    }
-    const decoded = CredentialMapper.decodeVerifiableCredential(original) as JwtDecodedVerifiableCredential | IVerifiableCredential
-
-    const isJwtEncoded = CredentialMapper.isJwtEncoded(original)
-    const isJwtDecoded = CredentialMapper.isJwtDecodedCredential(original)
-    const type = isJwtEncoded ? OriginalType.JWT_ENCODED : isJwtDecoded ? OriginalType.JWT_DECODED : OriginalType.JSONLD
-
-    const credential =
-      isJwtEncoded || isJwtDecoded
-        ? CredentialMapper.jwtDecodedCredentialToUniformCredential(decoded as JwtDecodedVerifiableCredential, opts)
-        : (decoded as IVerifiableCredential)
-
-    const format = isJwtEncoded || isJwtDecoded ? ('jwt_vc' as const) : ('ldp_vc' as const)
-    return {
-      original,
-      decoded,
-      format,
-      type,
-      credential,
-    }
-  }
-
-  public static isJwtEncoded(original: OriginalVerifiableCredential | OriginalVerifiablePresentation): original is string {
-    return ObjectUtils.isString(original) && original.startsWith('ey') && !original.includes('~')
-  }
-
-  public static isSdJwtEncoded(original: OriginalVerifiableCredential | OriginalVerifiablePresentation): original is string {
-    return ObjectUtils.isString(original) && original.startsWith('ey') && original.includes('~')
-  }
-
-  public static isW3cCredential(credential: ICredential | SdJwtDecodedVerifiableCredential): credential is ICredential {
-    return '@context' in credential && ((credential as ICredential).type?.includes('VerifiableCredential') || false)
-  }
-
-  public static isCredential(original: OriginalVerifiableCredential | OriginalVerifiablePresentation): original is OriginalVerifiableCredential {
-    try {
-      if (CredentialMapper.isJwtEncoded(original)) {
-        const vc: IVerifiableCredential = CredentialMapper.toUniformCredential(original)
-        return CredentialMapper.isW3cCredential(vc)
-      } else if (CredentialMapper.isSdJwtEncoded(original)) {
-        return true
-      }
-      return (
-        CredentialMapper.isW3cCredential(original as ICredential) ||
-        CredentialMapper.isSdJwtDecodedCredentialPayload(original as ICredential) ||
-        CredentialMapper.isJwtDecodedCredential(original as OriginalVerifiableCredential) ||
-        CredentialMapper.isSdJwtDecodedCredential(original as OriginalVerifiableCredential)
-      )
-    } catch (e) {
-      return false
-    }
-  }
-
-  public static isPresentation(original: OriginalVerifiableCredential | OriginalVerifiablePresentation): original is OriginalVerifiablePresentation {
-    try {
-      if (CredentialMapper.isJwtEncoded(original)) {
-        const vp: IVerifiablePresentation = CredentialMapper.toUniformPresentation(original)
-        return CredentialMapper.isW3cPresentation(vp)
-      } else if (CredentialMapper.isSdJwtEncoded(original)) {
-        return false
-      }
-      return (
-        CredentialMapper.isW3cPresentation(original as IPresentation) ||
-        CredentialMapper.isSdJwtDecodedCredentialPayload(original as ICredential) ||
-        CredentialMapper.isJwtDecodedPresentation(original as OriginalVerifiablePresentation) ||
-        CredentialMapper.isSdJwtDecodedCredential(original as OriginalVerifiableCredential)
-      )
-    } catch (e) {
-      return false
-    }
-  }
-
-  public static hasProof(original: OriginalVerifiableCredential | OriginalVerifiablePresentation | string): boolean {
-    try {
-      if (CredentialMapper.isJwtEncoded(original) || CredentialMapper.isJwtDecodedCredential(original as OriginalVerifiableCredential)) {
-        return true
-      } else if (CredentialMapper.isSdJwtEncoded(original) || CredentialMapper.isSdJwtDecodedCredential(original)) {
-        //todo: we might want to revisit this
-        return true
-      }
-      if ('vc' in (original as JwtDecodedVerifiableCredential) && (original as JwtDecodedVerifiableCredential).vc.proof) {
-        return true
-      }
-      if ('vp' in (original as JwtDecodedVerifiablePresentation) && (original as JwtDecodedVerifiablePresentation).vp.proof) {
-        return true
-      }
-      return !!(original as IVerifiableCredential | IVerifiablePresentation).proof
-    } catch (e) {
-      return false
-    }
-  }
-
-  public static isW3cPresentation(
-    presentation: UniformVerifiablePresentation | IPresentation | SdJwtDecodedVerifiableCredential,
-  ): presentation is IPresentation {
-    return '@context' in presentation && ((presentation as IPresentation).type?.includes('VerifiablePresentation') || false)
-  }
-
-  public static isSdJwtDecodedCredentialPayload(
-    credential: ICredential | SdJwtDecodedVerifiableCredentialPayload,
-  ): credential is SdJwtDecodedVerifiableCredentialPayload {
-    return 'vct' in credential
-  }
-
-  public static areOriginalVerifiableCredentialsEqual(firstOriginal: OriginalVerifiableCredential, secondOriginal: OriginalVerifiableCredential) {
-    // String (e.g. encoded jwt or SD-JWT)
-    if (typeof firstOriginal === 'string' || typeof secondOriginal === 'string') {
-      return firstOriginal === secondOriginal
-    } else if (CredentialMapper.isSdJwtDecodedCredential(firstOriginal) || CredentialMapper.isSdJwtDecodedCredential(secondOriginal)) {
-      return firstOriginal.compactSdJwtVc === secondOriginal.compactSdJwtVc
-    } else {
-      // JSON-LD or decoded JWT. (should we compare the signatures instead?)
-      return JSON.stringify(secondOriginal.proof) === JSON.stringify(firstOriginal.proof)
-    }
-  }
-
-  private static isJsonLdAsString(original: OriginalVerifiableCredential | OriginalVerifiablePresentation): original is string {
-    return ObjectUtils.isString(original) && original.includes('@context')
-  }
-
-  public static isSdJwtDecodedCredential(
-    original: OriginalVerifiableCredential | OriginalVerifiablePresentation | ICredential | IPresentation,
-  ): original is SdJwtDecodedVerifiableCredential {
-    return (<SdJwtDecodedVerifiableCredential>original).compactSdJwtVc !== undefined
-  }
-
-  public static isJwtDecodedCredential(original: OriginalVerifiableCredential): original is JwtDecodedVerifiableCredential {
-    return (<JwtDecodedVerifiableCredential>original).vc !== undefined && (<JwtDecodedVerifiableCredential>original).iss !== undefined
-  }
-
-  public static isJwtDecodedPresentation(original: OriginalVerifiablePresentation): original is JwtDecodedVerifiablePresentation {
-    return (<JwtDecodedVerifiablePresentation>original).vp !== undefined && (<JwtDecodedVerifiablePresentation>original).iss !== undefined
-  }
-
-  public static isWrappedSdJwtVerifiableCredential = isWrappedSdJwtVerifiableCredential
-  public static isWrappedSdJwtVerifiablePresentation = isWrappedSdJwtVerifiablePresentation
-  public static isWrappedW3CVerifiableCredential = isWrappedW3CVerifiableCredential
-  public static isWrappedW3CVerifiablePresentation = isWrappedW3CVerifiablePresentation
-
-  static jwtEncodedPresentationToUniformPresentation(
-    jwt: string,
-    makeCredentialsUniform: boolean = true,
-    opts?: { maxTimeSkewInMS?: number },
-  ): IPresentation {
-    return CredentialMapper.jwtDecodedPresentationToUniformPresentation(jwt_decode(jwt), makeCredentialsUniform, opts)
-  }
-
-  static jwtDecodedPresentationToUniformPresentation(
-    decoded: JwtDecodedVerifiablePresentation,
-    makeCredentialsUniform: boolean = true,
-    opts?: { maxTimeSkewInMS?: number },
-  ): IVerifiablePresentation {
-    const { iss, aud, jti, vp, ...rest } = decoded
-
-    const presentation: IVerifiablePresentation = {
-      ...rest,
-      ...vp,
-    }
-    if (makeCredentialsUniform) {
-      if (!vp.verifiableCredential) {
-        throw Error('Verifiable Presentation should have a verifiable credential at this point')
-      }
-      presentation.verifiableCredential = vp.verifiableCredential.map((vc) => CredentialMapper.toUniformCredential(vc, opts))
-    }
-    if (iss) {
-      const holder = presentation.holder
-      if (holder) {
-        if (holder !== iss) {
-          throw new Error(`Inconsistent holders between JWT claim (${iss}) and VC value (${holder})`)
-        }
-      }
-      presentation.holder = iss
-    }
-    if (aud) {
-      const verifier = presentation.verifier
-      if (verifier) {
-        if (verifier !== aud) {
-          throw new Error(`Inconsistent holders between JWT claim (${aud}) and VC value (${verifier})`)
-        }
-      }
-      presentation.verifier = aud
-    }
-    if (jti) {
-      const id = presentation.id
-      if (id && id !== jti) {
-        throw new Error(`Inconsistent VP ids between JWT claim (${jti}) and VP value (${id})`)
-      }
-      presentation.id = jti
-    }
-    return presentation
-  }
-
-  static toUniformCredential(
-    verifiableCredential: OriginalVerifiableCredential,
-    opts?: {
-      maxTimeSkewInMS?: number
-    },
-  ): IVerifiableCredential {
-    if (CredentialMapper.isSdJwtDecodedCredential(verifiableCredential)) {
-      throw new Error('Converting SD-JWT VC to uniform VC is not supported.')
-    }
-    const original =
-      typeof verifiableCredential !== 'string' && CredentialMapper.hasJWTProofType(verifiableCredential)
-        ? CredentialMapper.getFirstProof(verifiableCredential)?.jwt
-        : verifiableCredential
-    if (!original) {
-      throw Error(
-        'Could not determine original credential from passed in credential. Probably because a JWT proof type was present, but now is not available anymore',
-      )
-    }
-    const decoded = CredentialMapper.decodeVerifiableCredential(original)
-
-    const isJwtEncoded: boolean = CredentialMapper.isJwtEncoded(original)
-    const isJwtDecoded: boolean = CredentialMapper.isJwtDecodedCredential(original)
-
-    if (isJwtDecoded || isJwtEncoded) {
-      return CredentialMapper.jwtDecodedCredentialToUniformCredential(decoded as JwtDecodedVerifiableCredential, opts)
-    } else {
-      return decoded as IVerifiableCredential
-    }
-  }
-
-  static toUniformPresentation(
-    presentation: OriginalVerifiablePresentation,
-    opts?: { maxTimeSkewInMS?: number; addContextIfMissing?: boolean },
-  ): IVerifiablePresentation {
-    if (CredentialMapper.isSdJwtDecodedCredential(presentation)) {
-      throw new Error('Converting SD-JWT VC to uniform VP is not supported.')
-    }
-
-    const proof = CredentialMapper.getFirstProof(presentation)
-    const original = typeof presentation !== 'string' && CredentialMapper.hasJWTProofType(presentation) ? proof?.jwt : presentation
-    if (!original) {
-      throw Error(
-        'Could not determine original presentation, probably it was a converted JWT presentation, that is now missing the JWT value in the proof',
-      )
-    }
-    const decoded = CredentialMapper.decodeVerifiablePresentation(original)
-    const isJwtEncoded: boolean = CredentialMapper.isJwtEncoded(original)
-    const isJwtDecoded: boolean = CredentialMapper.isJwtDecodedPresentation(original)
-    const uniformPresentation =
-      isJwtEncoded || isJwtDecoded
-        ? CredentialMapper.jwtDecodedPresentationToUniformPresentation(decoded as JwtDecodedVerifiablePresentation, false)
-        : (decoded as IVerifiablePresentation)
-
-    // At time of writing Velocity Networks does not conform to specification. Adding bare minimum @context section to stop parsers from crashing and whatnot
-    if (opts?.addContextIfMissing && !uniformPresentation['@context']) {
-      uniformPresentation['@context'] = ['https://www.w3.org/2018/credentials/v1']
-    }
-
-    uniformPresentation.verifiableCredential = uniformPresentation.verifiableCredential?.map((vc) =>
-      CredentialMapper.toUniformCredential(vc, opts),
-    ) as IVerifiableCredential[] // We cast it because we IPresentation needs a VC. The internal Credential doesn't have the required Proof anymore (that is intended)
-    return uniformPresentation
-  }
-
-  static jwtEncodedCredentialToUniformCredential(
-    jwt: string,
-    opts?: {
-      maxTimeSkewInMS?: number
-    },
-  ): IVerifiableCredential {
-    return CredentialMapper.jwtDecodedCredentialToUniformCredential(jwt_decode(jwt), opts)
-  }
-
-  static jwtDecodedCredentialToUniformCredential(
-    decoded: JwtDecodedVerifiableCredential,
-    opts?: { maxTimeSkewInMS?: number },
-  ): IVerifiableCredential {
-    const { exp, nbf, iss, vc, sub, jti, ...rest } = decoded
-    const credential: IVerifiableCredential = {
-      ...rest,
-      ...vc,
-    }
-
-    const maxSkewInMS = opts?.maxTimeSkewInMS ?? 1500
-
-    if (exp) {
-      const expDate = credential.expirationDate
-      const jwtExp = parseInt(exp.toString())
-      // fix seconds to millisecond for the date
-      const expDateAsStr = jwtExp < 9999999999 ? new Date(jwtExp * 1000).toISOString().replace(/\.000Z/, 'Z') : new Date(jwtExp).toISOString()
-      if (expDate && expDate !== expDateAsStr) {
-        const diff = Math.abs(new Date(expDateAsStr).getTime() - new Date(expDate).getTime())
-        if (!maxSkewInMS || diff > maxSkewInMS) {
-          throw new Error(`Inconsistent expiration dates between JWT claim (${expDateAsStr}) and VC value (${expDate})`)
-        }
-      }
-      credential.expirationDate = expDateAsStr
-    }
-
-    if (nbf) {
-      const issuanceDate = credential.issuanceDate
-      const jwtNbf = parseInt(nbf.toString())
-      // fix seconds to millisecs for the date
-      const nbfDateAsStr = jwtNbf < 9999999999 ? new Date(jwtNbf * 1000).toISOString().replace(/\.000Z/, 'Z') : new Date(jwtNbf).toISOString()
-      if (issuanceDate && issuanceDate !== nbfDateAsStr) {
-        const diff = Math.abs(new Date(nbfDateAsStr).getTime() - new Date(issuanceDate).getTime())
-        if (!maxSkewInMS || diff > maxSkewInMS) {
-          throw new Error(`Inconsistent issuance dates between JWT claim (${nbfDateAsStr}) and VC value (${issuanceDate})`)
-        }
-      }
-      credential.issuanceDate = nbfDateAsStr
-    }
-
-    if (iss) {
-      const issuer = credential.issuer
-      if (issuer) {
-        if (typeof issuer === 'string') {
-          if (issuer !== iss) {
-            throw new Error(`Inconsistent issuers between JWT claim (${iss}) and VC value (${issuer})`)
-          }
-        } else {
-          if (!issuer.id && Object.keys(issuer).length > 0) {
-            // We have an issuer object with more than 1 property but without an issuer id. Set it,
-            // because the default behaviour of did-jwt-vc is to remove the id value when creating JWTs
-            issuer.id = iss
-          }
-          if (issuer.id !== iss) {
-            throw new Error(`Inconsistent issuers between JWT claim (${iss}) and VC value (${issuer.id})`)
-          }
-        }
-      } else {
-        credential.issuer = iss
-      }
-    }
-
-    if (sub) {
-      const subjects = Array.isArray(credential.credentialSubject) ? credential.credentialSubject : [credential.credentialSubject]
-      for (let i = 0; i < subjects.length; i++) {
-        const csId = subjects[i].id
-        if (csId && csId !== sub) {
-          throw new Error(`Inconsistent credential subject ids between JWT claim (${sub}) and VC value (${csId})`)
-        }
-        Array.isArray(credential.credentialSubject) ? (credential.credentialSubject[i].id = sub) : (credential.credentialSubject.id = sub)
-      }
-    }
-    if (jti) {
-      const id = credential.id
-      if (id && id !== jti) {
-        throw new Error(`Inconsistent credential ids between JWT claim (${jti}) and VC value (${id})`)
-      }
-      credential.id = jti
-    }
-
-    return credential
-  }
-
-  static toExternalVerifiableCredential(verifiableCredential: any): IVerifiableCredential {
-    let proof
-    if (verifiableCredential.proof) {
-      if (!verifiableCredential.proof.type) {
-        throw new Error('Verifiable credential proof is missing a type')
-      }
-
-      if (!verifiableCredential.proof.created) {
-        throw new Error('Verifiable credential proof is missing a created date')
-      }
-
-      if (!verifiableCredential.proof.proofPurpose) {
-        throw new Error('Verifiable credential proof is missing a proof purpose')
-      }
-
-      if (!verifiableCredential.proof.verificationMethod) {
-        throw new Error('Verifiable credential proof is missing a verification method')
-      }
-      proof = {
-        ...verifiableCredential.proof,
-        type: verifiableCredential.proof.type,
-        created: verifiableCredential.proof.created,
-        proofPurpose: verifiableCredential.proof.proofPurpose,
-        verificationMethod: verifiableCredential.proof.verificationMethod,
-      }
-    }
-
-    return {
-      ...verifiableCredential,
-      type: verifiableCredential.type
-        ? typeof verifiableCredential.type === 'string'
-          ? [verifiableCredential.type]
-          : verifiableCredential.type
-        : ['VerifiableCredential'],
-      proof,
-    }
-  }
-
-  static storedCredentialToOriginalFormat(credential: OriginalVerifiableCredential): W3CVerifiableCredential {
-    const type: DocumentFormat = CredentialMapper.detectDocumentType(credential)
-    if (typeof credential === 'string') {
-      if (type === DocumentFormat.JWT) {
-        return CredentialMapper.toCompactJWT(credential)
-      } else if (type === DocumentFormat.JSONLD) {
-        return JSON.parse(credential)
-      }
-    } else if (type === DocumentFormat.JWT && 'vc' in credential) {
-      return CredentialMapper.toCompactJWT(credential)
-    } else if ('proof' in credential && credential.proof.type === 'JwtProof2020' && credential.proof.jwt) {
-      return credential.proof.jwt
-    }
-    return credential as W3CVerifiableCredential
-  }
-
-  static storedPresentationToOriginalFormat(presentation: OriginalVerifiablePresentation): W3CVerifiablePresentation {
-    const type: DocumentFormat = CredentialMapper.detectDocumentType(presentation)
-    if (typeof presentation === 'string') {
-      if (type === DocumentFormat.JWT) {
-        return CredentialMapper.toCompactJWT(presentation)
-      } else if (type === DocumentFormat.JSONLD) {
-        return JSON.parse(presentation)
-      }
-    } else if (type === DocumentFormat.JWT && 'vp' in presentation) {
-      return CredentialMapper.toCompactJWT(presentation)
-    } else if ('proof' in presentation && presentation.proof.type === 'JwtProof2020' && presentation.proof.jwt) {
-      return presentation.proof.jwt
-    }
-    return presentation as W3CVerifiablePresentation
-  }
-
-  static toCompactJWT(
-    jwtDocument: W3CVerifiableCredential | JwtDecodedVerifiableCredential | W3CVerifiablePresentation | JwtDecodedVerifiablePresentation | string,
-  ): string {
-    if (!jwtDocument || CredentialMapper.detectDocumentType(jwtDocument) !== DocumentFormat.JWT) {
-      throw Error('Cannot convert non JWT credential to JWT')
-    }
-    if (typeof jwtDocument === 'string') {
-      return jwtDocument
-    }
-    let proof: string | undefined
-    if ('vp' in jwtDocument) {
-      proof = 'jwt' in jwtDocument.vp.proof ? jwtDocument.vp.proof.jwt : jwtDocument.vp.proof
-    } else if ('vc' in jwtDocument) {
-      proof = 'jwt' in jwtDocument.vc.proof ? jwtDocument.vc.proof.jwt : jwtDocument.vc.proof
-    } else {
-      proof = Array.isArray(jwtDocument.proof) ? jwtDocument.proof[0].jwt : jwtDocument.proof.jwt
-    }
-    if (!proof) {
-      throw Error(`Could not get JWT from supplied document`)
-    }
-    return proof
-  }
-
-  static detectDocumentType(
-    document:
-      | W3CVerifiableCredential
-      | W3CVerifiablePresentation
-      | JwtDecodedVerifiableCredential
-      | JwtDecodedVerifiablePresentation
-      | SdJwtDecodedVerifiableCredential,
-  ): DocumentFormat {
-    if (this.isJsonLdAsString(document)) {
-      return DocumentFormat.JSONLD
-    } else if (this.isJwtEncoded(document)) {
-      return DocumentFormat.JWT
-    } else if (this.isSdJwtEncoded(document) || this.isSdJwtDecodedCredential(document as any)) {
-      return DocumentFormat.SD_JWT_VC
-    }
-
-    const proofs = 'vc' in document ? document.vc.proof : 'vp' in document ? document.vp.proof : (<IVerifiableCredential>document).proof
-    const proof: IProof = Array.isArray(proofs) ? proofs[0] : proofs
-
-    if (proof?.jwt) {
-      return DocumentFormat.JWT
-    } else if (proof?.type === 'EthereumEip712Signature2021') {
-      return DocumentFormat.EIP712
-    }
-    return DocumentFormat.JSONLD
-  }
-
-  private static hasJWTProofType(
-    document: W3CVerifiableCredential | W3CVerifiablePresentation | JwtDecodedVerifiableCredential | JwtDecodedVerifiablePresentation,
-  ): boolean {
-    if (typeof document === 'string') {
-      return false
-    }
-    return !!CredentialMapper.getFirstProof(document)?.jwt
-  }
-
-  private static getFirstProof(
-    document: W3CVerifiableCredential | W3CVerifiablePresentation | JwtDecodedVerifiableCredential | JwtDecodedVerifiablePresentation,
-  ): IProof | undefined {
-    if (!document || typeof document === 'string') {
-      return undefined
-    }
-    const proofs = 'vc' in document ? document.vc.proof : 'vp' in document ? document.vp.proof : (<IVerifiableCredential>document).proof
-    return Array.isArray(proofs) ? proofs[0] : proofs
-  }
-}
+import jwt_decode from 'jwt-decode'
+import {
+  DocumentFormat,
+  IPresentation,
+  IProof,
+  IProofPurpose,
+  IProofType,
+  IVerifiableCredential,
+  IVerifiablePresentation,
+  JwtDecodedVerifiableCredential,
+  JwtDecodedVerifiablePresentation,
+  OriginalType,
+  OriginalVerifiableCredential,
+  OriginalVerifiablePresentation,
+  UniformVerifiablePresentation,
+  W3CVerifiableCredential,
+  W3CVerifiablePresentation,
+  WrappedVerifiableCredential,
+  WrappedVerifiablePresentation,
+  SdJwtDecodedVerifiableCredential,
+  SdJwtDecodedVerifiableCredentialPayload,
+  ICredential,
+  WrappedSdJwtVerifiableCredential,
+  WrappedW3CVerifiableCredential,
+  isWrappedSdJwtVerifiableCredential,
+  isWrappedSdJwtVerifiablePresentation,
+  isWrappedW3CVerifiableCredential,
+  isWrappedW3CVerifiablePresentation,
+  Hasher,
+  decodeSdJwtVc,
+  decodeSdJwtVcAsync,
+  AsyncHasher,
+} from '../types'
+import { ObjectUtils } from '../utils'
+
+export class CredentialMapper {
+  /**
+   * Decodes a compact SD-JWT vc to it's decoded variant. This method can be used when the hasher implementation used is Async, and therefore not suitable for usage
+   * with the other decode methods.
+   */
+  static decodeSdJwtVcAsync(compactSdJwtVc: string, hasher: AsyncHasher) {
+    return decodeSdJwtVcAsync(compactSdJwtVc, hasher)
+  }
+
+  /**
+   * Decodes a Verifiable Presentation to a uniform format.
+   *
+   * When decoding SD-JWT credentials, a hasher implementation must be provided. The hasher implementation must be sync. When using
+   * an async hasher implementation, use the decodeSdJwtVcAsync method instead and you can provide the decoded payload to methods
+   * instead of the compact SD-JWT.
+   *
+   * @param hasher Hasher implementation to use for SD-JWT decoding.
+   */
+  static decodeVerifiablePresentation(
+    presentation: OriginalVerifiablePresentation,
+    hasher?: Hasher,
+  ): JwtDecodedVerifiablePresentation | IVerifiablePresentation | SdJwtDecodedVerifiableCredential {
+    if (CredentialMapper.isJwtEncoded(presentation)) {
+      const payload = jwt_decode(presentation as string) as JwtDecodedVerifiablePresentation
+      const header = jwt_decode(presentation as string, { header: true }) as Record<string, any>
+
+      payload.vp.proof = {
+        type: IProofType.JwtProof2020,
+        created: payload.nbf,
+        proofPurpose: IProofPurpose.authentication,
+        verificationMethod: header['kid'] ?? payload.iss,
+        jwt: presentation as string,
+      }
+      return payload
+    } else if (CredentialMapper.isJwtDecodedPresentation(presentation)) {
+      return presentation as JwtDecodedVerifiablePresentation
+    } else if (CredentialMapper.isSdJwtEncoded(presentation)) {
+      if (!hasher) {
+        throw new Error('Hasher implementation is required to decode SD-JWT')
+      }
+      return decodeSdJwtVc(presentation, hasher)
+    } else if (CredentialMapper.isSdJwtDecodedCredential(presentation)) {
+      return presentation as SdJwtDecodedVerifiableCredential
+    } else if (CredentialMapper.isJsonLdAsString(presentation)) {
+      return JSON.parse(presentation as string) as IVerifiablePresentation
+    } else {
+      return presentation as IVerifiablePresentation
+    }
+  }
+
+  /**
+   * Decodes a Verifiable Credential to a uniform format.
+   *
+   * When decoding SD-JWT credentials, a hasher implementation must be provided. The hasher implementation must be sync. When using
+   * an async hasher implementation, use the decodeSdJwtVcAsync method instead and you can provide the decoded payload to methods
+   * instead of the compact SD-JWT.
+   *
+   * @param hasher Hasher implementation to use for SD-JWT decoding
+   */
+  static decodeVerifiableCredential(
+    credential: OriginalVerifiableCredential,
+    hasher?: Hasher,
+  ): JwtDecodedVerifiableCredential | IVerifiableCredential | SdJwtDecodedVerifiableCredential {
+    if (CredentialMapper.isJwtEncoded(credential)) {
+      const payload = jwt_decode(credential as string) as JwtDecodedVerifiableCredential
+      const header = jwt_decode(credential as string, { header: true }) as Record<string, any>
+      payload.vc.proof = {
+        type: IProofType.JwtProof2020,
+        created: payload.nbf,
+        proofPurpose: IProofPurpose.authentication,
+        verificationMethod: header['kid'] ?? payload.iss,
+        jwt: credential as string,
+      }
+      return payload
+    } else if (CredentialMapper.isJwtDecodedCredential(credential)) {
+      return credential
+    } else if (CredentialMapper.isJsonLdAsString(credential)) {
+      return JSON.parse(credential as string) as IVerifiableCredential
+    } else if (CredentialMapper.isSdJwtEncoded(credential)) {
+      if (!hasher) {
+        throw new Error('Hasher implementation is required to decode SD-JWT')
+      }
+      return decodeSdJwtVc(credential, hasher)
+    } else if (CredentialMapper.isSdJwtDecodedCredential(credential)) {
+      return credential
+    } else {
+      return credential as IVerifiableCredential
+    }
+  }
+
+  /**
+   * Converts a presentation to a wrapped presentation.
+   *
+   * When decoding SD-JWT credentials, a hasher implementation must be provided. The hasher implementation must be sync. When using
+   * an async hasher implementation, use the decodeSdJwtVcAsync method instead and you can provide the decoded payload to methods
+   * instead of the compact SD-JWT.
+   *
+   * @param hasher Hasher implementation to use for SD-JWT decoding
+   */
+  static toWrappedVerifiablePresentation(
+    originalPresentation: OriginalVerifiablePresentation,
+    opts?: { maxTimeSkewInMS?: number; hasher?: Hasher },
+  ): WrappedVerifiablePresentation {
+    // SD-JWT
+    if (CredentialMapper.isSdJwtDecodedCredential(originalPresentation) || CredentialMapper.isSdJwtEncoded(originalPresentation)) {
+      let decodedPresentation: SdJwtDecodedVerifiableCredential
+      if (CredentialMapper.isSdJwtEncoded(originalPresentation)) {
+        if (!opts?.hasher) {
+          throw new Error('Hasher implementation is required to decode SD-JWT')
+        }
+        decodedPresentation = decodeSdJwtVc(originalPresentation, opts.hasher)
+      } else {
+        decodedPresentation = originalPresentation
+      }
+      return {
+        type: CredentialMapper.isSdJwtDecodedCredential(originalPresentation) ? OriginalType.SD_JWT_VC_DECODED : OriginalType.SD_JWT_VC_ENCODED,
+        format: 'vc+sd-jwt',
+        original: originalPresentation,
+        presentation: decodedPresentation,
+        decoded: decodedPresentation.decodedPayload,
+        // NOTE: we also include the SD-JWT VC as the VC, as the SD-JWT acts as both the VC and the VP
+        vcs: [CredentialMapper.toWrappedVerifiableCredential(originalPresentation, opts) as WrappedSdJwtVerifiableCredential],
+      }
+    }
+
+    // If the VP is not an encoded/decoded SD-JWT, we assume it will be a W3C VC
+    const proof = CredentialMapper.getFirstProof(originalPresentation)
+    const original =
+      typeof originalPresentation !== 'string' && CredentialMapper.hasJWTProofType(originalPresentation) ? proof?.jwt : originalPresentation
+    if (!original) {
+      throw Error(
+        'Could not determine original presentation, probably it was a converted JWT presentation, that is now missing the JWT value in the proof',
+      )
+    }
+    const decoded = CredentialMapper.decodeVerifiablePresentation(original) as IVerifiablePresentation | JwtDecodedVerifiablePresentation
+    const isJwtEncoded: boolean = CredentialMapper.isJwtEncoded(original)
+    const isJwtDecoded: boolean = CredentialMapper.isJwtDecodedPresentation(original)
+
+    const type = isJwtEncoded ? OriginalType.JWT_ENCODED : isJwtDecoded ? OriginalType.JWT_DECODED : OriginalType.JSONLD
+    const format = isJwtDecoded || isJwtEncoded ? 'jwt_vp' : ('ldp_vp' as const)
+
+    let vp: OriginalVerifiablePresentation
+    if (isJwtEncoded || isJwtDecoded) {
+      vp = CredentialMapper.jwtDecodedPresentationToUniformPresentation(decoded as JwtDecodedVerifiablePresentation, false, opts)
+    } else {
+      vp = decoded as IVerifiablePresentation
+    }
+    if (!vp || !('verifiableCredential' in vp) || !vp.verifiableCredential || vp.verifiableCredential.length === 0) {
+      throw Error(`VP needs to have at least one verifiable credential at this point`)
+    }
+    const vcs = CredentialMapper.toWrappedVerifiableCredentials(
+      vp.verifiableCredential /*.map(value => value.original)*/,
+      opts,
+    ) as WrappedW3CVerifiableCredential[]
+
+    const presentation = {
+      ...vp,
+      verifiableCredential: vcs, // We overwrite the verifiableCredentials with wrapped versions, making it an InternalVerifiablePresentation. Note: we keep the singular key name of the vc data model
+    } as UniformVerifiablePresentation
+    return {
+      type,
+      format,
+      original,
+      decoded,
+      presentation,
+      vcs,
+    }
+  }
+
+  /**
+   * Converts a list of credentials to a list of wrapped credentials.
+   *
+   * When decoding SD-JWT credentials, a hasher implementation must be provided. The hasher implementation must be sync. When using
+   * an async hasher implementation, use the decodeSdJwtVcAsync method instead and you can provide the decoded payload to methods
+   * instead of the compact SD-JWT.
+   *
+   * @param hasher Hasher implementation to use for SD-JWT decoding
+   */
+  static toWrappedVerifiableCredentials(
+    verifiableCredentials: OriginalVerifiableCredential[],
+    opts?: { maxTimeSkewInMS?: number; hasher?: Hasher },
+  ): WrappedVerifiableCredential[] {
+    return verifiableCredentials.map((vc) => CredentialMapper.toWrappedVerifiableCredential(vc, opts))
+  }
+
+  /**
+   * Converts a credential to a wrapped credential.
+   *
+   * When decoding SD-JWT credentials, a hasher implementation must be provided. The hasher implementation must be sync. When using
+   * an async hasher implementation, use the decodeSdJwtVcAsync method instead and you can provide the decoded payload to methods
+   * instead of the compact SD-JWT.
+   *
+   * @param hasher Hasher implementation to use for SD-JWT decoding
+   */
+  static toWrappedVerifiableCredential(
+    verifiableCredential: OriginalVerifiableCredential,
+    opts?: { maxTimeSkewInMS?: number; hasher?: Hasher },
+  ): WrappedVerifiableCredential {
+    // SD-JWT
+    if (CredentialMapper.isSdJwtDecodedCredential(verifiableCredential) || CredentialMapper.isSdJwtEncoded(verifiableCredential)) {
+      let decodedCredential: SdJwtDecodedVerifiableCredential
+      if (CredentialMapper.isSdJwtEncoded(verifiableCredential)) {
+        if (!opts?.hasher) {
+          throw new Error('Hasher implementation is required to decode SD-JWT')
+        }
+        decodedCredential = decodeSdJwtVc(verifiableCredential, opts.hasher)
+      } else {
+        decodedCredential = verifiableCredential
+      }
+
+      return {
+        type: CredentialMapper.isSdJwtDecodedCredential(verifiableCredential) ? OriginalType.SD_JWT_VC_DECODED : OriginalType.SD_JWT_VC_ENCODED,
+        format: 'vc+sd-jwt',
+        original: verifiableCredential,
+        credential: decodedCredential,
+        decoded: decodedCredential.decodedPayload,
+      }
+    }
+
+    // If the VC is not an encoded/decoded SD-JWT, we assume it will be a W3C VC
+    const proof = CredentialMapper.getFirstProof(verifiableCredential)
+    const original = CredentialMapper.hasJWTProofType(verifiableCredential) && proof ? proof.jwt ?? verifiableCredential : verifiableCredential
+    if (!original) {
+      throw Error(
+        'Could not determine original credential, probably it was a converted JWT credential, that is now missing the JWT value in the proof',
+      )
+    }
+    const decoded = CredentialMapper.decodeVerifiableCredential(original) as JwtDecodedVerifiableCredential | IVerifiableCredential
+
+    const isJwtEncoded = CredentialMapper.isJwtEncoded(original)
+    const isJwtDecoded = CredentialMapper.isJwtDecodedCredential(original)
+    const type = isJwtEncoded ? OriginalType.JWT_ENCODED : isJwtDecoded ? OriginalType.JWT_DECODED : OriginalType.JSONLD
+
+    const credential =
+      isJwtEncoded || isJwtDecoded
+        ? CredentialMapper.jwtDecodedCredentialToUniformCredential(decoded as JwtDecodedVerifiableCredential, opts)
+        : (decoded as IVerifiableCredential)
+
+    const format = isJwtEncoded || isJwtDecoded ? ('jwt_vc' as const) : ('ldp_vc' as const)
+    return {
+      original,
+      decoded,
+      format,
+      type,
+      credential,
+    }
+  }
+
+  public static isJwtEncoded(original: OriginalVerifiableCredential | OriginalVerifiablePresentation): original is string {
+    return ObjectUtils.isString(original) && original.startsWith('ey') && !original.includes('~')
+  }
+
+  public static isSdJwtEncoded(original: OriginalVerifiableCredential | OriginalVerifiablePresentation): original is string {
+    return ObjectUtils.isString(original) && original.startsWith('ey') && original.includes('~')
+  }
+
+  public static isW3cCredential(credential: ICredential | SdJwtDecodedVerifiableCredential): credential is ICredential {
+    return '@context' in credential && ((credential as ICredential).type?.includes('VerifiableCredential') || false)
+  }
+
+  public static isCredential(original: OriginalVerifiableCredential | OriginalVerifiablePresentation): original is OriginalVerifiableCredential {
+    try {
+      if (CredentialMapper.isJwtEncoded(original)) {
+        const vc: IVerifiableCredential = CredentialMapper.toUniformCredential(original)
+        return CredentialMapper.isW3cCredential(vc)
+      } else if (CredentialMapper.isSdJwtEncoded(original)) {
+        return true
+      }
+      return (
+        CredentialMapper.isW3cCredential(original as ICredential) ||
+        CredentialMapper.isSdJwtDecodedCredentialPayload(original as ICredential) ||
+        CredentialMapper.isJwtDecodedCredential(original as OriginalVerifiableCredential) ||
+        CredentialMapper.isSdJwtDecodedCredential(original as OriginalVerifiableCredential)
+      )
+    } catch (e) {
+      return false
+    }
+  }
+
+  public static isPresentation(original: OriginalVerifiableCredential | OriginalVerifiablePresentation): original is OriginalVerifiablePresentation {
+    try {
+      if (CredentialMapper.isJwtEncoded(original)) {
+        const vp: IVerifiablePresentation = CredentialMapper.toUniformPresentation(original)
+        return CredentialMapper.isW3cPresentation(vp)
+      } else if (CredentialMapper.isSdJwtEncoded(original)) {
+        return false
+      }
+      return (
+        CredentialMapper.isW3cPresentation(original as IPresentation) ||
+        CredentialMapper.isSdJwtDecodedCredentialPayload(original as ICredential) ||
+        CredentialMapper.isJwtDecodedPresentation(original as OriginalVerifiablePresentation) ||
+        CredentialMapper.isSdJwtDecodedCredential(original as OriginalVerifiableCredential)
+      )
+    } catch (e) {
+      return false
+    }
+  }
+
+  public static hasProof(original: OriginalVerifiableCredential | OriginalVerifiablePresentation | string): boolean {
+    try {
+      if (CredentialMapper.isJwtEncoded(original) || CredentialMapper.isJwtDecodedCredential(original as OriginalVerifiableCredential)) {
+        return true
+      } else if (CredentialMapper.isSdJwtEncoded(original) || CredentialMapper.isSdJwtDecodedCredential(original)) {
+        //todo: we might want to revisit this
+        return true
+      }
+      if ('vc' in (original as JwtDecodedVerifiableCredential) && (original as JwtDecodedVerifiableCredential).vc.proof) {
+        return true
+      }
+      if ('vp' in (original as JwtDecodedVerifiablePresentation) && (original as JwtDecodedVerifiablePresentation).vp.proof) {
+        return true
+      }
+      return !!(original as IVerifiableCredential | IVerifiablePresentation).proof
+    } catch (e) {
+      return false
+    }
+  }
+
+  public static isW3cPresentation(
+    presentation: UniformVerifiablePresentation | IPresentation | SdJwtDecodedVerifiableCredential,
+  ): presentation is IPresentation {
+    return '@context' in presentation && ((presentation as IPresentation).type?.includes('VerifiablePresentation') || false)
+  }
+
+  public static isSdJwtDecodedCredentialPayload(
+    credential: ICredential | SdJwtDecodedVerifiableCredentialPayload,
+  ): credential is SdJwtDecodedVerifiableCredentialPayload {
+    return 'vct' in credential
+  }
+
+  public static areOriginalVerifiableCredentialsEqual(firstOriginal: OriginalVerifiableCredential, secondOriginal: OriginalVerifiableCredential) {
+    // String (e.g. encoded jwt or SD-JWT)
+    if (typeof firstOriginal === 'string' || typeof secondOriginal === 'string') {
+      return firstOriginal === secondOriginal
+    } else if (CredentialMapper.isSdJwtDecodedCredential(firstOriginal) || CredentialMapper.isSdJwtDecodedCredential(secondOriginal)) {
+      return firstOriginal.compactSdJwtVc === secondOriginal.compactSdJwtVc
+    } else {
+      // JSON-LD or decoded JWT. (should we compare the signatures instead?)
+      return JSON.stringify(secondOriginal.proof) === JSON.stringify(firstOriginal.proof)
+    }
+  }
+
+  private static isJsonLdAsString(original: OriginalVerifiableCredential | OriginalVerifiablePresentation): original is string {
+    return ObjectUtils.isString(original) && original.includes('@context')
+  }
+
+  public static isSdJwtDecodedCredential(
+    original: OriginalVerifiableCredential | OriginalVerifiablePresentation | ICredential | IPresentation,
+  ): original is SdJwtDecodedVerifiableCredential {
+    return (<SdJwtDecodedVerifiableCredential>original).compactSdJwtVc !== undefined
+  }
+
+  public static isJwtDecodedCredential(original: OriginalVerifiableCredential): original is JwtDecodedVerifiableCredential {
+    return (<JwtDecodedVerifiableCredential>original).vc !== undefined && (<JwtDecodedVerifiableCredential>original).iss !== undefined
+  }
+
+  public static isJwtDecodedPresentation(original: OriginalVerifiablePresentation): original is JwtDecodedVerifiablePresentation {
+    return (<JwtDecodedVerifiablePresentation>original).vp !== undefined && (<JwtDecodedVerifiablePresentation>original).iss !== undefined
+  }
+
+  public static isWrappedSdJwtVerifiableCredential = isWrappedSdJwtVerifiableCredential
+  public static isWrappedSdJwtVerifiablePresentation = isWrappedSdJwtVerifiablePresentation
+  public static isWrappedW3CVerifiableCredential = isWrappedW3CVerifiableCredential
+  public static isWrappedW3CVerifiablePresentation = isWrappedW3CVerifiablePresentation
+
+  static jwtEncodedPresentationToUniformPresentation(
+    jwt: string,
+    makeCredentialsUniform: boolean = true,
+    opts?: { maxTimeSkewInMS?: number },
+  ): IPresentation {
+    return CredentialMapper.jwtDecodedPresentationToUniformPresentation(jwt_decode(jwt), makeCredentialsUniform, opts)
+  }
+
+  static jwtDecodedPresentationToUniformPresentation(
+    decoded: JwtDecodedVerifiablePresentation,
+    makeCredentialsUniform: boolean = true,
+    opts?: { maxTimeSkewInMS?: number },
+  ): IVerifiablePresentation {
+    const { iss, aud, jti, vp, ...rest } = decoded
+
+    const presentation: IVerifiablePresentation = {
+      ...rest,
+      ...vp,
+    }
+    if (makeCredentialsUniform) {
+      if (!vp.verifiableCredential) {
+        throw Error('Verifiable Presentation should have a verifiable credential at this point')
+      }
+      presentation.verifiableCredential = vp.verifiableCredential.map((vc) => CredentialMapper.toUniformCredential(vc, opts))
+    }
+    if (iss) {
+      const holder = presentation.holder
+      if (holder) {
+        if (holder !== iss) {
+          throw new Error(`Inconsistent holders between JWT claim (${iss}) and VC value (${holder})`)
+        }
+      }
+      presentation.holder = iss
+    }
+    if (aud) {
+      const verifier = presentation.verifier
+      if (verifier) {
+        if (verifier !== aud) {
+          throw new Error(`Inconsistent holders between JWT claim (${aud}) and VC value (${verifier})`)
+        }
+      }
+      presentation.verifier = aud
+    }
+    if (jti) {
+      const id = presentation.id
+      if (id && id !== jti) {
+        throw new Error(`Inconsistent VP ids between JWT claim (${jti}) and VP value (${id})`)
+      }
+      presentation.id = jti
+    }
+    return presentation
+  }
+
+  static toUniformCredential(
+    verifiableCredential: OriginalVerifiableCredential,
+    opts?: {
+      maxTimeSkewInMS?: number
+    },
+  ): IVerifiableCredential {
+    if (CredentialMapper.isSdJwtDecodedCredential(verifiableCredential)) {
+      throw new Error('Converting SD-JWT VC to uniform VC is not supported.')
+    }
+    const original =
+      typeof verifiableCredential !== 'string' && CredentialMapper.hasJWTProofType(verifiableCredential)
+        ? CredentialMapper.getFirstProof(verifiableCredential)?.jwt
+        : verifiableCredential
+    if (!original) {
+      throw Error(
+        'Could not determine original credential from passed in credential. Probably because a JWT proof type was present, but now is not available anymore',
+      )
+    }
+    const decoded = CredentialMapper.decodeVerifiableCredential(original)
+
+    const isJwtEncoded: boolean = CredentialMapper.isJwtEncoded(original)
+    const isJwtDecoded: boolean = CredentialMapper.isJwtDecodedCredential(original)
+
+    if (isJwtDecoded || isJwtEncoded) {
+      return CredentialMapper.jwtDecodedCredentialToUniformCredential(decoded as JwtDecodedVerifiableCredential, opts)
+    } else {
+      return decoded as IVerifiableCredential
+    }
+  }
+
+  static toUniformPresentation(
+    presentation: OriginalVerifiablePresentation,
+    opts?: { maxTimeSkewInMS?: number; addContextIfMissing?: boolean },
+  ): IVerifiablePresentation {
+    if (CredentialMapper.isSdJwtDecodedCredential(presentation)) {
+      throw new Error('Converting SD-JWT VC to uniform VP is not supported.')
+    }
+
+    const proof = CredentialMapper.getFirstProof(presentation)
+    const original = typeof presentation !== 'string' && CredentialMapper.hasJWTProofType(presentation) ? proof?.jwt : presentation
+    if (!original) {
+      throw Error(
+        'Could not determine original presentation, probably it was a converted JWT presentation, that is now missing the JWT value in the proof',
+      )
+    }
+    const decoded = CredentialMapper.decodeVerifiablePresentation(original)
+    const isJwtEncoded: boolean = CredentialMapper.isJwtEncoded(original)
+    const isJwtDecoded: boolean = CredentialMapper.isJwtDecodedPresentation(original)
+    const uniformPresentation =
+      isJwtEncoded || isJwtDecoded
+        ? CredentialMapper.jwtDecodedPresentationToUniformPresentation(decoded as JwtDecodedVerifiablePresentation, false)
+        : (decoded as IVerifiablePresentation)
+
+    // At time of writing Velocity Networks does not conform to specification. Adding bare minimum @context section to stop parsers from crashing and whatnot
+    if (opts?.addContextIfMissing && !uniformPresentation['@context']) {
+      uniformPresentation['@context'] = ['https://www.w3.org/2018/credentials/v1']
+    }
+
+    uniformPresentation.verifiableCredential = uniformPresentation.verifiableCredential?.map((vc) =>
+      CredentialMapper.toUniformCredential(vc, opts),
+    ) as IVerifiableCredential[] // We cast it because we IPresentation needs a VC. The internal Credential doesn't have the required Proof anymore (that is intended)
+    return uniformPresentation
+  }
+
+  static jwtEncodedCredentialToUniformCredential(
+    jwt: string,
+    opts?: {
+      maxTimeSkewInMS?: number
+    },
+  ): IVerifiableCredential {
+    return CredentialMapper.jwtDecodedCredentialToUniformCredential(jwt_decode(jwt), opts)
+  }
+
+  static jwtDecodedCredentialToUniformCredential(
+    decoded: JwtDecodedVerifiableCredential,
+    opts?: { maxTimeSkewInMS?: number },
+  ): IVerifiableCredential {
+    const { exp, nbf, iss, vc, sub, jti, ...rest } = decoded
+    const credential: IVerifiableCredential = {
+      ...rest,
+      ...vc,
+    }
+
+    const maxSkewInMS = opts?.maxTimeSkewInMS ?? 1500
+
+    if (exp) {
+      const expDate = credential.expirationDate
+      const jwtExp = parseInt(exp.toString())
+      // fix seconds to millisecond for the date
+      const expDateAsStr = jwtExp < 9999999999 ? new Date(jwtExp * 1000).toISOString().replace(/\.000Z/, 'Z') : new Date(jwtExp).toISOString()
+      if (expDate && expDate !== expDateAsStr) {
+        const diff = Math.abs(new Date(expDateAsStr).getTime() - new Date(expDate).getTime())
+        if (!maxSkewInMS || diff > maxSkewInMS) {
+          throw new Error(`Inconsistent expiration dates between JWT claim (${expDateAsStr}) and VC value (${expDate})`)
+        }
+      }
+      credential.expirationDate = expDateAsStr
+    }
+
+    if (nbf) {
+      const issuanceDate = credential.issuanceDate
+      const jwtNbf = parseInt(nbf.toString())
+      // fix seconds to millisecs for the date
+      const nbfDateAsStr = jwtNbf < 9999999999 ? new Date(jwtNbf * 1000).toISOString().replace(/\.000Z/, 'Z') : new Date(jwtNbf).toISOString()
+      if (issuanceDate && issuanceDate !== nbfDateAsStr) {
+        const diff = Math.abs(new Date(nbfDateAsStr).getTime() - new Date(issuanceDate).getTime())
+        if (!maxSkewInMS || diff > maxSkewInMS) {
+          throw new Error(`Inconsistent issuance dates between JWT claim (${nbfDateAsStr}) and VC value (${issuanceDate})`)
+        }
+      }
+      credential.issuanceDate = nbfDateAsStr
+    }
+
+    if (iss) {
+      const issuer = credential.issuer
+      if (issuer) {
+        if (typeof issuer === 'string') {
+          if (issuer !== iss) {
+            throw new Error(`Inconsistent issuers between JWT claim (${iss}) and VC value (${issuer})`)
+          }
+        } else {
+          if (!issuer.id && Object.keys(issuer).length > 0) {
+            // We have an issuer object with more than 1 property but without an issuer id. Set it,
+            // because the default behaviour of did-jwt-vc is to remove the id value when creating JWTs
+            issuer.id = iss
+          }
+          if (issuer.id !== iss) {
+            throw new Error(`Inconsistent issuers between JWT claim (${iss}) and VC value (${issuer.id})`)
+          }
+        }
+      } else {
+        credential.issuer = iss
+      }
+    }
+
+    if (sub) {
+      const subjects = Array.isArray(credential.credentialSubject) ? credential.credentialSubject : [credential.credentialSubject]
+      for (let i = 0; i < subjects.length; i++) {
+        const csId = subjects[i].id
+        if (csId && csId !== sub) {
+          throw new Error(`Inconsistent credential subject ids between JWT claim (${sub}) and VC value (${csId})`)
+        }
+        Array.isArray(credential.credentialSubject) ? (credential.credentialSubject[i].id = sub) : (credential.credentialSubject.id = sub)
+      }
+    }
+    if (jti) {
+      const id = credential.id
+      if (id && id !== jti) {
+        throw new Error(`Inconsistent credential ids between JWT claim (${jti}) and VC value (${id})`)
+      }
+      credential.id = jti
+    }
+
+    return credential
+  }
+
+  static toExternalVerifiableCredential(verifiableCredential: any): IVerifiableCredential {
+    let proof
+    if (verifiableCredential.proof) {
+      if (!verifiableCredential.proof.type) {
+        throw new Error('Verifiable credential proof is missing a type')
+      }
+
+      if (!verifiableCredential.proof.created) {
+        throw new Error('Verifiable credential proof is missing a created date')
+      }
+
+      if (!verifiableCredential.proof.proofPurpose) {
+        throw new Error('Verifiable credential proof is missing a proof purpose')
+      }
+
+      if (!verifiableCredential.proof.verificationMethod) {
+        throw new Error('Verifiable credential proof is missing a verification method')
+      }
+      proof = {
+        ...verifiableCredential.proof,
+        type: verifiableCredential.proof.type,
+        created: verifiableCredential.proof.created,
+        proofPurpose: verifiableCredential.proof.proofPurpose,
+        verificationMethod: verifiableCredential.proof.verificationMethod,
+      }
+    }
+
+    return {
+      ...verifiableCredential,
+      type: verifiableCredential.type
+        ? typeof verifiableCredential.type === 'string'
+          ? [verifiableCredential.type]
+          : verifiableCredential.type
+        : ['VerifiableCredential'],
+      proof,
+    }
+  }
+
+  static storedCredentialToOriginalFormat(credential: OriginalVerifiableCredential): W3CVerifiableCredential {
+    const type: DocumentFormat = CredentialMapper.detectDocumentType(credential)
+    if (typeof credential === 'string') {
+      if (type === DocumentFormat.JWT) {
+        return CredentialMapper.toCompactJWT(credential)
+      } else if (type === DocumentFormat.JSONLD) {
+        return JSON.parse(credential)
+      }
+    } else if (type === DocumentFormat.JWT && 'vc' in credential) {
+      return CredentialMapper.toCompactJWT(credential)
+    } else if ('proof' in credential && credential.proof.type === 'JwtProof2020' && credential.proof.jwt) {
+      return credential.proof.jwt
+    }
+    return credential as W3CVerifiableCredential
+  }
+
+  static storedPresentationToOriginalFormat(presentation: OriginalVerifiablePresentation): W3CVerifiablePresentation {
+    const type: DocumentFormat = CredentialMapper.detectDocumentType(presentation)
+    if (typeof presentation === 'string') {
+      if (type === DocumentFormat.JWT) {
+        return CredentialMapper.toCompactJWT(presentation)
+      } else if (type === DocumentFormat.JSONLD) {
+        return JSON.parse(presentation)
+      }
+    } else if (type === DocumentFormat.JWT && 'vp' in presentation) {
+      return CredentialMapper.toCompactJWT(presentation)
+    } else if ('proof' in presentation && presentation.proof.type === 'JwtProof2020' && presentation.proof.jwt) {
+      return presentation.proof.jwt
+    }
+    return presentation as W3CVerifiablePresentation
+  }
+
+  static toCompactJWT(
+    jwtDocument: W3CVerifiableCredential | JwtDecodedVerifiableCredential | W3CVerifiablePresentation | JwtDecodedVerifiablePresentation | string,
+  ): string {
+    if (!jwtDocument || CredentialMapper.detectDocumentType(jwtDocument) !== DocumentFormat.JWT) {
+      throw Error('Cannot convert non JWT credential to JWT')
+    }
+    if (typeof jwtDocument === 'string') {
+      return jwtDocument
+    }
+    let proof: string | undefined
+    if ('vp' in jwtDocument) {
+      proof = 'jwt' in jwtDocument.vp.proof ? jwtDocument.vp.proof.jwt : jwtDocument.vp.proof
+    } else if ('vc' in jwtDocument) {
+      proof = 'jwt' in jwtDocument.vc.proof ? jwtDocument.vc.proof.jwt : jwtDocument.vc.proof
+    } else {
+      proof = Array.isArray(jwtDocument.proof) ? jwtDocument.proof[0].jwt : jwtDocument.proof.jwt
+    }
+    if (!proof) {
+      throw Error(`Could not get JWT from supplied document`)
+    }
+    return proof
+  }
+
+  static detectDocumentType(
+    document:
+      | W3CVerifiableCredential
+      | W3CVerifiablePresentation
+      | JwtDecodedVerifiableCredential
+      | JwtDecodedVerifiablePresentation
+      | SdJwtDecodedVerifiableCredential,
+  ): DocumentFormat {
+    if (this.isJsonLdAsString(document)) {
+      return DocumentFormat.JSONLD
+    } else if (this.isJwtEncoded(document)) {
+      return DocumentFormat.JWT
+    } else if (this.isSdJwtEncoded(document) || this.isSdJwtDecodedCredential(document as any)) {
+      return DocumentFormat.SD_JWT_VC
+    }
+
+    const proofs = 'vc' in document ? document.vc.proof : 'vp' in document ? document.vp.proof : (<IVerifiableCredential>document).proof
+    const proof: IProof = Array.isArray(proofs) ? proofs[0] : proofs
+
+    if (proof?.jwt) {
+      return DocumentFormat.JWT
+    } else if (proof?.type === 'EthereumEip712Signature2021') {
+      return DocumentFormat.EIP712
+    }
+    return DocumentFormat.JSONLD
+  }
+
+  private static hasJWTProofType(
+    document: W3CVerifiableCredential | W3CVerifiablePresentation | JwtDecodedVerifiableCredential | JwtDecodedVerifiablePresentation,
+  ): boolean {
+    if (typeof document === 'string') {
+      return false
+    }
+    return !!CredentialMapper.getFirstProof(document)?.jwt
+  }
+
+  private static getFirstProof(
+    document: W3CVerifiableCredential | W3CVerifiablePresentation | JwtDecodedVerifiableCredential | JwtDecodedVerifiablePresentation,
+  ): IProof | undefined {
+    if (!document || typeof document === 'string') {
+      return undefined
+    }
+    const proofs = 'vc' in document ? document.vc.proof : 'vp' in document ? document.vp.proof : (<IVerifiableCredential>document).proof
+    return Array.isArray(proofs) ? proofs[0] : proofs
+  }
+}