@sphereon/ssi-sdk.siopv2-oid4vp-op-auth 0.34.1-fix.80 → 0.34.1-next.278

package/src/session/OID4VP.ts

@@ -11,7 +11,7 @@
 //  // ProofOptions
 // } from '@sphereon/ssi-sdk.core'
 //import { UniqueDigitalCredential, verifiableCredentialForRoleFilter } from '@sphereon/ssi-sdk.credential-store'
-//import { CredentialRole, FindDigitalCredentialArgs } from '@sphereon/ssi-sdk.data-store'
+//import { CredentialRole, FindDigitalCredentialArgs } from '@sphereon/ssi-sdk.data-store-types'
 import {
   //CompactJWT,
   HasherSync,
@@ -38,7 +38,6 @@ export class OID4VP {
     // const { session,
     //   // allIdentifiers, hasher = defaultHasher
     // } = args
-
     //this.session = session
     // this.allIdentifiers = allIdentifiers ?? []
     // this.hasher = hasher
@@ -85,142 +84,142 @@ export class OID4VP {
   //   return await Promise.all(credentialsWithDefinitions.map((cred) => this.createVerifiablePresentation(credentialRole, cred, opts)))
   // }
 
-//   public async createVerifiablePresentation(
-//     credentialRole: CredentialRole,
-//     selectedVerifiableCredentials: VerifiableCredentialsWithDefinition,
-//     opts?: {
-//       forceNoCredentialsInVP?: boolean // Allow to create a VP without credentials, like EBSI is using it. Defaults to false
-//       restrictToFormats?: Format
-//       restrictToDIDMethods?: string[]
-//       proofOpts?: ProofOptions
-//       idOpts?: ManagedIdentifierOptsOrResult
-//       skipDidResolution?: boolean
-//       holder?: string
-//       subjectIsHolder?: boolean
-//       applyFilter?: boolean
-//       hasher?: HasherSync
-//     },
-//   ): Promise<VerifiablePresentationWithDefinition> {
-//     const { subjectIsHolder, holder, forceNoCredentialsInVP = false } = { ...opts }
-//     if (subjectIsHolder && holder) {
-//       throw Error('Cannot both have subject is holder and a holderDID value at the same time (programming error)')
-//     }
-//     if (forceNoCredentialsInVP) {
-//       selectedVerifiableCredentials.credentials = []
-//     } else if (!selectedVerifiableCredentials?.credentials || selectedVerifiableCredentials.credentials.length === 0) {
-//       throw Error('No verifiable verifiableCredentials provided for presentation definition')
-//     }
-//
-//     // const proofOptions: ProofOptions = {
-//     //   ...opts?.proofOpts,
-//     //   challenge: opts?.proofOpts?.nonce ?? opts?.proofOpts?.challenge ?? this.session.nonce,
-//     //   domain: opts?.proofOpts?.domain ?? (await this.session.getRedirectUri()),
-//     // }
-//
-//     let idOpts = opts?.idOpts
-//     if (!idOpts) {
-//       if (opts?.subjectIsHolder) {
-//         if (forceNoCredentialsInVP) {
-//           return Promise.reject(
-//             Error(
-//               `Cannot have subject is holder, when force no credentials is being used, as we could never determine the holder then. Please provide holderDID`,
-//             ),
-//           )
-//         }
-//         const firstUniqueDC = selectedVerifiableCredentials.credentials[0]
-//         //        const firstVC = firstUniqueDC.uniformVerifiableCredential!
-//         if (typeof firstUniqueDC !== 'object' || !('digitalCredential' in firstUniqueDC)) {
-//           return Promise.reject(Error('If no opts provided, credentials should be of type UniqueDigitalCredential'))
-//         }
-//
-//         idOpts = isOID4VCIssuerIdentifier(firstUniqueDC.digitalCredential.kmsKeyRef)
-//           ? await this.session.context.agent.identifierManagedGetByIssuer({
-//               identifier: firstUniqueDC.digitalCredential.kmsKeyRef,
-//             })
-//           : await this.session.context.agent.identifierManagedGetByKid({
-//               identifier: firstUniqueDC.digitalCredential.kmsKeyRef,
-//               kmsKeyRef: firstUniqueDC.digitalCredential.kmsKeyRef,
-//             })
-//
-//         /*
-//         const holder = CredentialMapper.isSdJwtDecodedCredential(firstVC)
-//           ? firstVC.decodedPayload.cnf?.jwk
-//             ? //TODO SDK-19: convert the JWK to hex and search for the appropriate key and associated DID
-//               //doesn't apply to did:jwk only, as you can represent any DID key as a JWK. So whenever you encounter a JWK it doesn't mean it had to come from a did:jwk in the system. It just can always be represented as a did:jwk
-//               `did:jwk:${encodeJoseBlob(firstVC.decodedPayload.cnf?.jwk)}#0`
-//             : firstVC.decodedPayload.sub
-//           : Array.isArray(firstVC.credentialSubject)
-//             ? firstVC.credentialSubject[0].id
-//             : firstVC.credentialSubject.id
-//         if (holder) {
-//           idOpts = { identifier: holder }
-//         }
-// */
-//       } else if (opts?.holder) {
-//         idOpts = { identifier: opts.holder }
-//       }
-//     }
-//
-//     // We are making sure to filter, in case the user submitted all verifiableCredentials in the wallet/agent. We also make sure to get original formats back
-//     const vcs = forceNoCredentialsInVP
-//       ? selectedVerifiableCredentials
-//       : opts?.applyFilter
-//         ? await this.filterCredentials(credentialRole, selectedVerifiableCredentials.dcqlQuery, {
-//             restrictToFormats: opts?.restrictToFormats,
-//             restrictToDIDMethods: opts?.restrictToDIDMethods,
-//             filterOpts: {
-//               verifiableCredentials: selectedVerifiableCredentials.credentials,
-//             },
-//           })
-//         : {
-//             definition: selectedVerifiableCredentials.dcqlQuery,
-//             credentials: selectedVerifiableCredentials.credentials,
-//           }
-//
-//     if (!idOpts) {
-//       return Promise.reject(Error(`No identifier options present at this point`))
-//     }
-//
-//     // const signCallback = await createOID4VPPresentationSignCallback({
-//     //   presentationSignCallback: this.session.options.presentationSignCallback,
-//     //   idOpts,
-//     //   context: this.session.context,
-//     //   domain: proofOptions.domain,
-//     //   challenge: proofOptions.challenge,
-//     //   format: opts?.restrictToFormats ?? selectedVerifiableCredentials.dcqlQuery.dcqlQuery.format,
-//     //   skipDidResolution: opts?.skipDidResolution ?? false,
-//     // })
-//     const identifier: ManagedIdentifierResult = await this.session.context.agent.identifierManagedGet(idOpts)
-//     const verifiableCredentials = vcs.credentials.map((credential) =>
-//       typeof credential === 'object' && 'digitalCredential' in credential ? credential.originalVerifiableCredential! : credential,
-//     )
-//     // const presentationResult = await this.getPresentationExchange({
-//     //   verifiableCredentials: verifiableCredentials,
-//     //   allIdentifiers: this.allIdentifiers,
-//     //   hasher: opts?.hasher,
-//     // }).createVerifiablePresentation(vcs.dcqlQuery.dcqlQuery, verifiableCredentials, signCallback, {
-//     //   proofOptions,
-//     //   // fixme: Update to newer siop-vp to not require dids here. But when Veramo is creating the VP it's still looking at this field to pass into didManagerGet
-//     //   ...(identifier && isManagedIdentifierDidResult(identifier) && { holderDID: identifier.did }),
-//     // })
-//
-//     const verifiablePresentations = presentationResult.verifiablePresentations.map((verifiablePresentation) =>
-//       typeof verifiablePresentation !== 'string' &&
-//       'proof' in verifiablePresentation &&
-//       'jwt' in verifiablePresentation.proof &&
-//       verifiablePresentation.proof.jwt
-//         ? verifiablePresentation.proof.jwt
-//         : verifiablePresentation,
-//     )
-//
-//     return {
-//       ...presentationResult,
-//       verifiablePresentations,
-//       verifiableCredentials: verifiableCredentials,
-//       dcqlQuery: selectedVerifiableCredentials.dcqlQuery,
-//       idOpts,
-//     }
-//   }
+  //   public async createVerifiablePresentation(
+  //     credentialRole: CredentialRole,
+  //     selectedVerifiableCredentials: VerifiableCredentialsWithDefinition,
+  //     opts?: {
+  //       forceNoCredentialsInVP?: boolean // Allow to create a VP without credentials, like EBSI is using it. Defaults to false
+  //       restrictToFormats?: Format
+  //       restrictToDIDMethods?: string[]
+  //       proofOpts?: ProofOptions
+  //       idOpts?: ManagedIdentifierOptsOrResult
+  //       skipDidResolution?: boolean
+  //       holder?: string
+  //       subjectIsHolder?: boolean
+  //       applyFilter?: boolean
+  //       hasher?: HasherSync
+  //     },
+  //   ): Promise<VerifiablePresentationWithDefinition> {
+  //     const { subjectIsHolder, holder, forceNoCredentialsInVP = false } = { ...opts }
+  //     if (subjectIsHolder && holder) {
+  //       throw Error('Cannot both have subject is holder and a holderDID value at the same time (programming error)')
+  //     }
+  //     if (forceNoCredentialsInVP) {
+  //       selectedVerifiableCredentials.credentials = []
+  //     } else if (!selectedVerifiableCredentials?.credentials || selectedVerifiableCredentials.credentials.length === 0) {
+  //       throw Error('No verifiable verifiableCredentials provided for presentation definition')
+  //     }
+  //
+  //     // const proofOptions: ProofOptions = {
+  //     //   ...opts?.proofOpts,
+  //     //   challenge: opts?.proofOpts?.nonce ?? opts?.proofOpts?.challenge ?? this.session.nonce,
+  //     //   domain: opts?.proofOpts?.domain ?? (await this.session.getRedirectUri()),
+  //     // }
+  //
+  //     let idOpts = opts?.idOpts
+  //     if (!idOpts) {
+  //       if (opts?.subjectIsHolder) {
+  //         if (forceNoCredentialsInVP) {
+  //           return Promise.reject(
+  //             Error(
+  //               `Cannot have subject is holder, when force no credentials is being used, as we could never determine the holder then. Please provide holderDID`,
+  //             ),
+  //           )
+  //         }
+  //         const firstUniqueDC = selectedVerifiableCredentials.credentials[0]
+  //         //        const firstVC = firstUniqueDC.uniformVerifiableCredential!
+  //         if (typeof firstUniqueDC !== 'object' || !('digitalCredential' in firstUniqueDC)) {
+  //           return Promise.reject(Error('If no opts provided, credentials should be of type UniqueDigitalCredential'))
+  //         }
+  //
+  //         idOpts = isOID4VCIssuerIdentifier(firstUniqueDC.digitalCredential.kmsKeyRef)
+  //           ? await this.session.context.agent.identifierManagedGetByIssuer({
+  //               identifier: firstUniqueDC.digitalCredential.kmsKeyRef,
+  //             })
+  //           : await this.session.context.agent.identifierManagedGetByKid({
+  //               identifier: firstUniqueDC.digitalCredential.kmsKeyRef,
+  //               kmsKeyRef: firstUniqueDC.digitalCredential.kmsKeyRef,
+  //             })
+  //
+  //         /*
+  //         const holder = CredentialMapper.isSdJwtDecodedCredential(firstVC)
+  //           ? firstVC.decodedPayload.cnf?.jwk
+  //             ? //TODO SDK-19: convert the JWK to hex and search for the appropriate key and associated DID
+  //               //doesn't apply to did:jwk only, as you can represent any DID key as a JWK. So whenever you encounter a JWK it doesn't mean it had to come from a did:jwk in the system. It just can always be represented as a did:jwk
+  //               `did:jwk:${encodeJoseBlob(firstVC.decodedPayload.cnf?.jwk)}#0`
+  //             : firstVC.decodedPayload.sub
+  //           : Array.isArray(firstVC.credentialSubject)
+  //             ? firstVC.credentialSubject[0].id
+  //             : firstVC.credentialSubject.id
+  //         if (holder) {
+  //           idOpts = { identifier: holder }
+  //         }
+  // */
+  //       } else if (opts?.holder) {
+  //         idOpts = { identifier: opts.holder }
+  //       }
+  //     }
+  //
+  //     // We are making sure to filter, in case the user submitted all verifiableCredentials in the wallet/agent. We also make sure to get original formats back
+  //     const vcs = forceNoCredentialsInVP
+  //       ? selectedVerifiableCredentials
+  //       : opts?.applyFilter
+  //         ? await this.filterCredentials(credentialRole, selectedVerifiableCredentials.dcqlQuery, {
+  //             restrictToFormats: opts?.restrictToFormats,
+  //             restrictToDIDMethods: opts?.restrictToDIDMethods,
+  //             filterOpts: {
+  //               verifiableCredentials: selectedVerifiableCredentials.credentials,
+  //             },
+  //           })
+  //         : {
+  //             definition: selectedVerifiableCredentials.dcqlQuery,
+  //             credentials: selectedVerifiableCredentials.credentials,
+  //           }
+  //
+  //     if (!idOpts) {
+  //       return Promise.reject(Error(`No identifier options present at this point`))
+  //     }
+  //
+  //     // const signCallback = await createOID4VPPresentationSignCallback({
+  //     //   presentationSignCallback: this.session.options.presentationSignCallback,
+  //     //   idOpts,
+  //     //   context: this.session.context,
+  //     //   domain: proofOptions.domain,
+  //     //   challenge: proofOptions.challenge,
+  //     //   format: opts?.restrictToFormats ?? selectedVerifiableCredentials.dcqlQuery.dcqlQuery.format,
+  //     //   skipDidResolution: opts?.skipDidResolution ?? false,
+  //     // })
+  //     const identifier: ManagedIdentifierResult = await this.session.context.agent.identifierManagedGet(idOpts)
+  //     const verifiableCredentials = vcs.credentials.map((credential) =>
+  //       typeof credential === 'object' && 'digitalCredential' in credential ? credential.originalVerifiableCredential! : credential,
+  //     )
+  //     // const presentationResult = await this.getPresentationExchange({
+  //     //   verifiableCredentials: verifiableCredentials,
+  //     //   allIdentifiers: this.allIdentifiers,
+  //     //   hasher: opts?.hasher,
+  //     // }).createVerifiablePresentation(vcs.dcqlQuery.dcqlQuery, verifiableCredentials, signCallback, {
+  //     //   proofOptions,
+  //     //   // fixme: Update to newer siop-vp to not require dids here. But when Veramo is creating the VP it's still looking at this field to pass into didManagerGet
+  //     //   ...(identifier && isManagedIdentifierDidResult(identifier) && { holderDID: identifier.did }),
+  //     // })
+  //
+  //     const verifiablePresentations = presentationResult.verifiablePresentations.map((verifiablePresentation) =>
+  //       typeof verifiablePresentation !== 'string' &&
+  //       'proof' in verifiablePresentation &&
+  //       'jwt' in verifiablePresentation.proof &&
+  //       verifiablePresentation.proof.jwt
+  //         ? verifiablePresentation.proof.jwt
+  //         : verifiablePresentation,
+  //     )
+  //
+  //     return {
+  //       ...presentationResult,
+  //       verifiablePresentations,
+  //       verifiableCredentials: verifiableCredentials,
+  //       dcqlQuery: selectedVerifiableCredentials.dcqlQuery,
+  //       idOpts,
+  //     }
+  //   }
 
   // public async filterCredentialsAgainstAllDefinitions(
   //   credentialRole: CredentialRole,
@@ -284,50 +283,50 @@ export class OID4VP {
   //   }
   // }
 
-//   public async filterCredentialsWithSelectionStatus(
-//     credentialRole: CredentialRole,
-//     presentationDefinition: PresentationDefinitionWithLocation,
-//     opts?: {
-//       filterOpts?: { verifiableCredentials?: OriginalVerifiableCredential[]; filter?: FindDigitalCredentialArgs }
-//       holderDIDs?: string[]
-//       restrictToFormats?: Format
-//       restrictToDIDMethods?: string[]
-//     },
-//   ): Promise<SelectResults> {
-//     const selectionResults: SelectResults = await this.getPresentationExchange({
-//       verifiableCredentials: await this.getCredentials(credentialRole, opts?.filterOpts),
-//     }).selectVerifiableCredentialsForSubmission(presentationDefinition.definition, opts)
-//     if (selectionResults.errors && selectionResults.errors.length > 0) {
-//       throw Error(JSON.stringify(selectionResults.errors))
-//     } else if (selectionResults.areRequiredCredentialsPresent === Status.ERROR) {
-//       throw Error(`Not all required credentials are available to satisfy the relying party's request`)
-//     }
-//
-//     const matches: SubmissionRequirementMatch[] | undefined = selectionResults.matches
-//     if (!matches || matches.length === 0 || !selectionResults.verifiableCredential || selectionResults.verifiableCredential.length === 0) {
-//       throw Error(JSON.stringify(selectionResults.errors))
-//     }
-//     return selectionResults
-//   }
-//
-//   private async getCredentials(
-//     credentialRole: CredentialRole,
-//     filterOpts?: {
-//       verifiableCredentials?: OriginalVerifiableCredential[]
-//       filter?: FindDigitalCredentialArgs
-//     },
-//   ): Promise<OriginalVerifiableCredential[]> {
-//     if (filterOpts?.verifiableCredentials && filterOpts.verifiableCredentials.length > 0) {
-//       return filterOpts.verifiableCredentials
-//     }
-//
-//     const filter = verifiableCredentialForRoleFilter(credentialRole, filterOpts?.filter)
-//     const uniqueCredentials = await this.session.context.agent.crsGetUniqueCredentials({ filter })
-//     return uniqueCredentials.map((uniqueVC: UniqueDigitalCredential) => {
-//       const vc = uniqueVC.uniformVerifiableCredential!
-//       const proof = Array.isArray(vc.proof) ? vc.proof : [vc.proof]
-//       const jwtProof = proof.find((p: IProof) => p?.type === DEFAULT_JWT_PROOF_TYPE)
-//       return jwtProof ? (jwtProof.jwt as CompactJWT) : vc
-//     })
-//   }
+  //   public async filterCredentialsWithSelectionStatus(
+  //     credentialRole: CredentialRole,
+  //     presentationDefinition: PresentationDefinitionWithLocation,
+  //     opts?: {
+  //       filterOpts?: { verifiableCredentials?: OriginalVerifiableCredential[]; filter?: FindDigitalCredentialArgs }
+  //       holderDIDs?: string[]
+  //       restrictToFormats?: Format
+  //       restrictToDIDMethods?: string[]
+  //     },
+  //   ): Promise<SelectResults> {
+  //     const selectionResults: SelectResults = await this.getPresentationExchange({
+  //       verifiableCredentials: await this.getCredentials(credentialRole, opts?.filterOpts),
+  //     }).selectVerifiableCredentialsForSubmission(presentationDefinition.definition, opts)
+  //     if (selectionResults.errors && selectionResults.errors.length > 0) {
+  //       throw Error(JSON.stringify(selectionResults.errors))
+  //     } else if (selectionResults.areRequiredCredentialsPresent === Status.ERROR) {
+  //       throw Error(`Not all required credentials are available to satisfy the relying party's request`)
+  //     }
+  //
+  //     const matches: SubmissionRequirementMatch[] | undefined = selectionResults.matches
+  //     if (!matches || matches.length === 0 || !selectionResults.verifiableCredential || selectionResults.verifiableCredential.length === 0) {
+  //       throw Error(JSON.stringify(selectionResults.errors))
+  //     }
+  //     return selectionResults
+  //   }
+  //
+  //   private async getCredentials(
+  //     credentialRole: CredentialRole,
+  //     filterOpts?: {
+  //       verifiableCredentials?: OriginalVerifiableCredential[]
+  //       filter?: FindDigitalCredentialArgs
+  //     },
+  //   ): Promise<OriginalVerifiableCredential[]> {
+  //     if (filterOpts?.verifiableCredentials && filterOpts.verifiableCredentials.length > 0) {
+  //       return filterOpts.verifiableCredentials
+  //     }
+  //
+  //     const filter = verifiableCredentialForRoleFilter(credentialRole, filterOpts?.filter)
+  //     const uniqueCredentials = await this.session.context.agent.crsGetUniqueCredentials({ filter })
+  //     return uniqueCredentials.map((uniqueVC: UniqueDigitalCredential) => {
+  //       const vc = uniqueVC.uniformVerifiableCredential!
+  //       const proof = Array.isArray(vc.proof) ? vc.proof : [vc.proof]
+  //       const jwtProof = proof.find((p: IProof) => p?.type === DEFAULT_JWT_PROOF_TYPE)
+  //       return jwtProof ? (jwtProof.jwt as CompactJWT) : vc
+  //     })
+  //   }
 }

package/src/session/functions.ts

@@ -60,14 +60,7 @@ export async function createOPBuilder({
   const eventEmitter = opOptions.eventEmitter ?? new EventEmitter()
   const builder = OP.builder()
     .withResponseMode(opOptions.responseMode ?? ResponseMode.DIRECT_POST)
-    .withSupportedVersions(
-      opOptions.supportedVersions ?? [
-        SupportedVersion.SIOPv2_ID1,
-        SupportedVersion.JWT_VC_PRESENTATION_PROFILE_v1,
-        SupportedVersion.SIOPv2_D11,
-        SupportedVersion.SIOPv2_D12_OID4VP_D18,
-      ],
-    )
+    .withSupportedVersions(opOptions.supportedVersions ?? [SupportedVersion.OID4VP_v1, SupportedVersion.SIOPv2_OID4VP_D28])
     .withExpiresIn(opOptions.expiresIn ?? 300)
     .withEventEmitter(eventEmitter)
     .withRegistration({

package/src/types/IDidAuthSiopOpAuthenticator.ts

@@ -12,7 +12,7 @@ import { DIDDocument } from '@sphereon/did-uni-client'
 import { IIdentifierResolution, ManagedIdentifierOptsOrResult } from '@sphereon/ssi-sdk-ext.identifier-resolution'
 import { IJwtService } from '@sphereon/ssi-sdk-ext.jwt-service'
 import { ICredentialStore } from '@sphereon/ssi-sdk.credential-store'
-import { Party } from '@sphereon/ssi-sdk.data-store'
+import { Party } from '@sphereon/ssi-sdk.data-store-types'
 import { IPDManager } from '@sphereon/ssi-sdk.pd-manager'
 import { ISDJwtPlugin } from '@sphereon/ssi-sdk.sd-jwt'
 import { HasherSync, PresentationSubmission, W3CVerifiablePresentation } from '@sphereon/ssi-types'

package/src/types/machine/index.ts

@@ -1,6 +1,6 @@
 import { VerifiedAuthorizationRequest } from '@sphereon/did-auth-siop'
 import { ManagedIdentifierOptsOrResult } from '@sphereon/ssi-sdk-ext.identifier-resolution'
-import { DidAuthConfig, Party } from '@sphereon/ssi-sdk.data-store'
+import { DidAuthConfig, Party } from '@sphereon/ssi-sdk.data-store-types'
 import { BaseActionObject, Interpreter, ResolveTypegenMeta, ServiceMap, State, StateMachine, TypegenDisabled } from 'xstate'
 import { ErrorDetails } from '../error'
 import { SelectableCredentialsMap, Siopv2AuthorizationRequestData, Siopv2AuthorizationResponseData } from '../siop-service'

package/src/types/siop-service/index.ts

@@ -1,13 +1,10 @@
-import {
-  PresentationSignCallback,
-  RPRegistrationMetadataPayload,
-  VerifiedAuthorizationRequest,
-} from '@sphereon/did-auth-siop'
+import { PresentationSignCallback, RPRegistrationMetadataPayload, VerifiedAuthorizationRequest } from '@sphereon/did-auth-siop'
 import { IIdentifierResolution, ManagedIdentifierOptsOrResult } from '@sphereon/ssi-sdk-ext.identifier-resolution'
 import { IContactManager } from '@sphereon/ssi-sdk.contact-manager'
 import { ICredentialStore, UniqueDigitalCredential } from '@sphereon/ssi-sdk.credential-store'
-import { DidAuthConfig, ICredentialLocaleBranding, Identity, Party } from '@sphereon/ssi-sdk.data-store'
+import { DidAuthConfig, ICredentialLocaleBranding, Identity, Party } from '@sphereon/ssi-sdk.data-store-types'
 import { IIssuanceBranding } from '@sphereon/ssi-sdk.issuance-branding'
+import { ISDJwtPlugin } from '@sphereon/ssi-sdk.sd-jwt'
 import { IAgentContext, IDIDManager, IIdentifier, IResolver } from '@veramo/core'
 import { IDidAuthSiopOpAuthenticator } from '../IDidAuthSiopOpAuthenticator'
 import { Siopv2MachineContext, Siopv2MachineInterpreter, Siopv2MachineState } from '../machine'
@@ -90,5 +87,12 @@ export type OnIdentifierCreatedArgs = {
 }
 
 export type RequiredContext = IAgentContext<
-  IContactManager & IDidAuthSiopOpAuthenticator & IDIDManager & IResolver & IIdentifierResolution & ICredentialStore & IIssuanceBranding
+  IContactManager &
+    IDidAuthSiopOpAuthenticator &
+    IDIDManager &
+    IResolver &
+    IIdentifierResolution &
+    ICredentialStore &
+    IIssuanceBranding &
+    ISDJwtPlugin
 >

package/src/utils/CredentialUtils.ts

@@ -25,7 +25,7 @@ const getCredentialFromProofOrWrapped = (cred: any, hasher?: HasherSync): Origin
     return cred.proof.jwt
   }
 
-  return CredentialMapper.toWrappedVerifiableCredential(cred as OriginalVerifiableCredential, { hasher }).original
+  return CredentialMapper.toWrappedVerifiableCredential(cred as OriginalVerifiableCredential, { hasher }).original as OriginalVerifiableCredential // FIXME SSISDK-59
 }
 
 export const isUniqueDigitalCredential = (credential: InputCredential): credential is UniqueDigitalCredential => {

package/src/utils/dcql.ts

@@ -27,6 +27,7 @@ export function convertToDcqlCredentials(credential: UniqueDigitalCredential | O
   if (CredentialMapper.isJwtDecodedCredential(originalVerifiableCredential)) {
     return Dcql.toDcqlJwtCredential(CredentialMapper.toWrappedVerifiableCredential(originalVerifiableCredential) as WrappedW3CVerifiableCredential)
   } else if (CredentialMapper.isSdJwtDecodedCredential(originalVerifiableCredential)) {
+    // FIXME: SD-JWT VC vs VCDM2 + SD-JWT would need to be handled here
     return Dcql.toDcqlSdJwtCredential(CredentialMapper.toWrappedVerifiableCredential(originalVerifiableCredential) as WrappedSdJwtVerifiableCredential)
   } else if (CredentialMapper.isMsoMdocDecodedCredential(originalVerifiableCredential)) {
     return Dcql.toDcqlMdocCredential(CredentialMapper.toWrappedVerifiableCredential(originalVerifiableCredential) as WrappedMdocCredential)