@credo-ts/openid4vc 0.6.0-pr-2195-20250322195244 → 0.6.0-pr-2324-20250625125220

package/build/openid4vc-holder/OpenId4VciHolderService.js

@@ -14,8 +14,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenId4VciHolderService = void 0;
 const core_1 = require("@credo-ts/core");
+const core_2 = require("@credo-ts/core");
 const oauth2_1 = require("@openid4vc/oauth2");
 const openid4vci_1 = require("@openid4vc/openid4vci");
+const openid4vci_2 = require("@openid4vc/openid4vci");
 const shared_1 = require("../shared");
 const callbacks_1 = require("../shared/callbacks");
 const issuerMetadataUtils_1 = require("../shared/issuerMetadataUtils");
@@ -49,28 +51,63 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
     async resolveAuthorizationRequest(agentContext, resolvedCredentialOffer, authCodeFlowOptions) {
         const { clientId, redirectUri } = authCodeFlowOptions;
         const { metadata, credentialOfferPayload, offeredCredentialConfigurations } = resolvedCredentialOffer;
-        const client = this.getClient(agentContext);
+        const oauth2Client = this.getOauth2Client(agentContext);
+        const client = this.getClient(agentContext, {
+            clientId: authCodeFlowOptions.clientId,
+            clientAttestation: authCodeFlowOptions.walletAttestationJwt,
+        });
         // If scope is not provided, we request scope for all offered credentials
         const scope = authCodeFlowOptions.scope ?? (0, issuerMetadataUtils_1.getScopesFromCredentialConfigurationsSupported)(offeredCredentialConfigurations);
+        if (!credentialOfferPayload.grants?.[oauth2_1.authorizationCodeGrantIdentifier]) {
+            throw new core_2.CredoError(`Provided credential offer does not include the 'authorization_code' grant.`);
+        }
+        const authorizationCodeGrant = credentialOfferPayload.grants[oauth2_1.authorizationCodeGrantIdentifier];
+        const authorizationServer = (0, openid4vci_1.determineAuthorizationServerForCredentialOffer)({
+            issuerMetadata: metadata,
+            grantAuthorizationServer: authorizationCodeGrant.authorization_server,
+        });
+        const authorizationServerMetadata = (0, oauth2_1.getAuthorizationServerMetadataFromList)(metadata.authorizationServers, authorizationServer);
+        // TODO: should we allow key reuse between dpop and wallet attestation?
+        const isDpopSupported = oauth2Client.isDpopSupported({ authorizationServerMetadata });
+        const dpop = isDpopSupported.supported
+            ? await this.getDpopOptions(agentContext, {
+                dpopSigningAlgValuesSupported: isDpopSupported.dpopSigningAlgValuesSupported,
+            })
+            : undefined;
         const authorizationResult = await client.initiateAuthorization({
             clientId,
             issuerMetadata: metadata,
             credentialOffer: credentialOfferPayload,
             scope: scope.join(' '),
             redirectUri,
+            dpop,
         });
-        if (authorizationResult.authorizationFlow === openid4vci_1.AuthorizationFlow.PresentationDuringIssuance) {
+        if (authorizationResult.authorizationFlow === openid4vci_2.AuthorizationFlow.PresentationDuringIssuance) {
             return {
-                authorizationFlow: openid4vci_1.AuthorizationFlow.PresentationDuringIssuance,
+                authorizationFlow: openid4vci_2.AuthorizationFlow.PresentationDuringIssuance,
                 openid4vpRequestUrl: authorizationResult.openid4vpRequestUrl,
                 authSession: authorizationResult.authSession,
+                // FIXME: return dpop result from this endpoint (dpop nonce)
+                dpop: dpop
+                    ? {
+                        alg: dpop.signer.alg,
+                        jwk: core_2.Kms.PublicJwk.fromUnknown(dpop.signer.publicJwk),
+                    }
+                    : undefined,
             };
         }
         // Normal Oauth2Redirect flow
         return {
-            authorizationFlow: openid4vci_1.AuthorizationFlow.Oauth2Redirect,
+            authorizationFlow: openid4vci_2.AuthorizationFlow.Oauth2Redirect,
             codeVerifier: authorizationResult.pkce?.codeVerifier,
             authorizationRequestUrl: authorizationResult.authorizationRequestUrl,
+            // FIXME: return dpop result from this endpoint (dpop nonce)
+            dpop: dpop
+                ? {
+                    alg: dpop.signer.alg,
+                    jwk: core_2.Kms.PublicJwk.fromUnknown(dpop.signer.publicJwk),
+                }
+                : undefined,
         };
     }
     async sendNotification(agentContext, options) {
@@ -91,10 +128,11 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
         });
     }
     async getDpopOptions(agentContext, { jwk, dpopSigningAlgValuesSupported, nonce, }) {
+        const kms = agentContext.resolve(core_2.Kms.KeyManagementApi);
         if (jwk) {
             const alg = dpopSigningAlgValuesSupported.find((alg) => jwk.supportedSignatureAlgorithms.includes(alg));
             if (!alg) {
-                throw new core_1.CredoError(`No supported dpop signature algorithms found in dpop_signing_alg_values_supported '${dpopSigningAlgValuesSupported.join(', ')}' matching key type ${jwk.keyType}`);
+                throw new core_2.CredoError(`No supported dpop signature algorithms found in dpop_signing_alg_values_supported '${dpopSigningAlgValuesSupported.join(', ')}' matching jwk ${jwk.jwkTypehumanDescription}`);
             }
             return {
                 signer: {
@@ -105,59 +143,83 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
                 nonce,
             };
         }
-        const alg = dpopSigningAlgValuesSupported.find((alg) => (0, core_1.getJwkClassFromJwaSignatureAlgorithm)(alg));
-        const JwkClass = alg ? (0, core_1.getJwkClassFromJwaSignatureAlgorithm)(alg) : undefined;
-        if (!alg || !JwkClass) {
-            throw new core_1.CredoError(`No supported dpop signature algorithms found in dpop_signing_alg_values_supported '${dpopSigningAlgValuesSupported.join(', ')}'`);
+        const alg = dpopSigningAlgValuesSupported.find((alg) => {
+            try {
+                core_2.Kms.PublicJwk.supportedPublicJwkClassForSignatureAlgorithm(alg);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!alg) {
+            throw new core_2.CredoError(`No supported dpop signature algorithms found in dpop_signing_alg_values_supported '${dpopSigningAlgValuesSupported.join(', ')}'`);
         }
-        const key = await agentContext.wallet.createKey({ keyType: JwkClass.keyType });
+        const key = await kms.createKeyForSignatureAlgorithm({ algorithm: alg });
         return {
             signer: {
                 method: 'jwk',
                 alg,
-                publicJwk: (0, core_1.getJwkFromKey)(key).toJson(),
+                publicJwk: key.publicJwk,
             },
             nonce,
         };
     }
     async retrieveAuthorizationCodeUsingPresentation(agentContext, options) {
-        const client = this.getClient(agentContext);
-        // TODO: support dpop on this endpoint as well
-        // const dpop = options.dpop
-        //   ? await this.getDpopOptions(agentContext, {
-        //       ...options.dpop,
-        //       dpopSigningAlgValuesSupported: [options.dpop.alg],
-        //     })
-        //   : undefined
-        // TODO: we should support DPoP in this request as well
-        const { authorizationChallengeResponse } = await client.retrieveAuthorizationCodeUsingPresentation({
+        const client = this.getClient(agentContext, {
+            clientAttestation: options.walletAttestationJwt,
+        });
+        const dpop = options.dpop
+            ? await this.getDpopOptions(agentContext, {
+                ...options.dpop,
+                dpopSigningAlgValuesSupported: [options.dpop.alg],
+            })
+            : undefined;
+        const { authorizationChallengeResponse, dpop: dpopResult } = await client.retrieveAuthorizationCodeUsingPresentation({
             authSession: options.authSession,
             presentationDuringIssuanceSession: options.presentationDuringIssuanceSession,
             credentialOffer: options.resolvedCredentialOffer.credentialOfferPayload,
             issuerMetadata: options.resolvedCredentialOffer.metadata,
-            // dpop
+            dpop,
         });
         return {
             authorizationCode: authorizationChallengeResponse.authorization_code,
+            dpop: dpop
+                ? {
+                    ...dpopResult,
+                    alg: dpop.signer.alg,
+                    jwk: core_2.Kms.PublicJwk.fromUnknown(dpop.signer.publicJwk),
+                }
+                : undefined,
         };
     }
     async requestAccessToken(agentContext, options) {
         const { metadata, credentialOfferPayload } = options.resolvedCredentialOffer;
-        const client = this.getClient(agentContext);
+        const client = this.getClient(agentContext, {
+            clientAttestation: options.walletAttestationJwt,
+            clientId: 'clientId' in options ? options.clientId : undefined,
+        });
         const oauth2Client = this.getOauth2Client(agentContext);
         const authorizationServer = options.code
             ? credentialOfferPayload.grants?.authorization_code?.authorization_server
             : credentialOfferPayload.grants?.[oauth2_1.preAuthorizedCodeGrantIdentifier]?.authorization_server;
         const authorizationServerMetadata = (0, oauth2_1.getAuthorizationServerMetadataFromList)(metadata.authorizationServers, authorizationServer ?? metadata.authorizationServers[0].issuer);
-        // TODO: should allow dpop input parameter for if it was already bound earlier
         const isDpopSupported = oauth2Client.isDpopSupported({
             authorizationServerMetadata,
         });
-        const dpop = isDpopSupported.supported
+        const dpop = options.dpop
             ? await this.getDpopOptions(agentContext, {
-                dpopSigningAlgValuesSupported: isDpopSupported.dpopSigningAlgValuesSupported,
+                ...options.dpop,
+                dpopSigningAlgValuesSupported: [options.dpop.alg],
             })
-            : undefined;
+            : // We should be careful about this case. It could just be the user didn't correctly
+                // provide the DPoP from the auth response. In whic case different DPoP will be used
+                // However it might be that they only use DPoP for the token request (esp in pre-auth case)
+                isDpopSupported.supported
+                    ? await this.getDpopOptions(agentContext, {
+                        dpopSigningAlgValuesSupported: isDpopSupported.dpopSigningAlgValuesSupported,
+                    })
+                    : undefined;
         const result = options.code
             ? await client.retrieveAuthorizationCodeAccessTokenFromOffer({
                 issuerMetadata: metadata,
@@ -166,11 +228,6 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
                 dpop,
                 pkceCodeVerifier: options.codeVerifier,
                 redirectUri: options.redirectUri,
-                additionalRequestPayload: {
-                    // TODO: handle it as part of client auth once we support
-                    // assertion based client authentication
-                    client_id: options.clientId,
-                },
             })
             : await client.retrievePreAuthorizedCodeAccessTokenFromOffer({
                 credentialOffer: credentialOfferPayload,
@@ -184,7 +241,7 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
                 ? {
                     ...result.dpop,
                     alg: dpop.signer.alg,
-                    jwk: (0, core_1.getJwkFromJson)(dpop.signer.publicJwk),
+                    jwk: core_2.Kms.PublicJwk.fromUnknown(dpop.signer.publicJwk),
                 }
                 : undefined,
         };
@@ -192,22 +249,10 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
     async acceptCredentialOffer(agentContext, options) {
         const { resolvedCredentialOffer, acceptCredentialOfferOptions } = options;
         const { metadata, offeredCredentialConfigurations } = resolvedCredentialOffer;
-        const { credentialConfigurationIds, credentialBindingResolver, verifyCredentialStatus, requestBatch } = acceptCredentialOfferOptions;
+        const { credentialConfigurationIds, credentialBindingResolver, verifyCredentialStatus, allowedProofOfPossessionSignatureAlgorithms, } = acceptCredentialOfferOptions;
         const client = this.getClient(agentContext);
         if (credentialConfigurationIds?.length === 0) {
-            throw new core_1.CredoError(`'credentialConfigurationIds' may not be empty`);
-        }
-        const supportedJwaSignatureAlgorithms = (0, utils_1.getSupportedJwaSignatureAlgorithms)(agentContext);
-        const allowedProofOfPossessionSigAlgs = acceptCredentialOfferOptions.allowedProofOfPossessionSignatureAlgorithms;
-        const possibleProofOfPossessionSigAlgs = allowedProofOfPossessionSigAlgs
-            ? allowedProofOfPossessionSigAlgs.filter((algorithm) => supportedJwaSignatureAlgorithms.includes(algorithm))
-            : supportedJwaSignatureAlgorithms;
-        if (possibleProofOfPossessionSigAlgs.length === 0) {
-            throw new core_1.CredoError([
-                'No possible proof of possession signature algorithm found.',
-                `Signature algorithms supported by the Agent '${supportedJwaSignatureAlgorithms.join(', ')}'`,
-                `Allowed Signature algorithms '${allowedProofOfPossessionSigAlgs?.join(', ')}'`,
-            ].join('\n'));
+            throw new core_2.CredoError(`'credentialConfigurationIds' may not be empty`);
         }
         const receivedCredentials = [];
         let cNonce = options.cNonce;
@@ -215,7 +260,7 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
         const credentialConfigurationsToRequest = credentialConfigurationIds?.map((id) => {
             if (!offeredCredentialConfigurations[id]) {
                 const offeredCredentialIds = Object.keys(offeredCredentialConfigurations).join(', ');
-                throw new core_1.CredoError(`Credential to request '${id}' is not present in offered credentials. Offered credentials are ${offeredCredentialIds}`);
+                throw new core_2.CredoError(`Credential to request '${id}' is not present in offered credentials. Offered credentials are ${offeredCredentialIds}`);
             }
             return [id, offeredCredentialConfigurations[id]];
         }) ?? Object.entries(offeredCredentialConfigurations);
@@ -242,46 +287,41 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
                         : undefined,
                 })
                     .catch((e) => {
-                    if (e instanceof openid4vci_1.Openid4vciRetrieveCredentialsError && e.response.credentialErrorResponseResult?.success) {
+                    if (e instanceof openid4vci_2.Openid4vciRetrieveCredentialsError && e.response.credentialErrorResponseResult?.success) {
                         cNonce = e.response.credentialErrorResponseResult.data.c_nonce;
                     }
                 });
             }
         }
         if (!cNonce) {
-            throw new core_1.CredoError('No cNonce provided and unable to acquire cNonce from the credential issuer');
-        }
-        // If true: use max from issuer or otherwise 1
-        // If number not 0: use the number
-        // Else: use 1
-        const batchSize = requestBatch === true ? (metadata.credentialIssuer.batch_credential_issuance?.batch_size ?? 1) : requestBatch || 1;
-        if (typeof requestBatch === 'number' && requestBatch > 1 && !metadata.credentialIssuer.batch_credential_issuance) {
-            throw new core_1.CredoError(`Credential issuer '${metadata.credentialIssuer.credential_issuer}' does not support batch credential issuance using the 'proofs' request property. Onlt 'proof' supported.`);
+            throw new core_2.CredoError('No cNonce provided and unable to acquire cNonce from the credential issuer');
         }
         for (const [offeredCredentialId, offeredCredentialConfiguration] of credentialConfigurationsToRequest) {
-            const jwts = [];
-            for (let i = 0; i < batchSize; i++) {
-                // TODO: we should call this method once with a keyLength. Gives more control to the user and better aligns with key attestations
-                // Get a key instance for each entry in the batch.
-                // Get all options for the credential request (such as which kid to use, the signature algorithm, etc)
-                const { jwtSigner } = await this.getCredentialRequestOptions(agentContext, {
-                    possibleProofOfPossessionSignatureAlgorithms: possibleProofOfPossessionSigAlgs,
-                    offeredCredential: {
-                        id: offeredCredentialId,
-                        configuration: offeredCredentialConfiguration,
-                    },
-                    credentialBindingResolver,
-                });
-                const { jwt } = await client.createCredentialRequestJwtProof({
-                    credentialConfigurationId: offeredCredentialId,
-                    issuerMetadata: resolvedCredentialOffer.metadata,
-                    signer: jwtSigner,
-                    clientId: options.clientId,
-                    nonce: cNonce,
-                });
-                this.logger.debug('Generated credential request proof of possesion jwt', { jwt });
-                jwts.push(jwt);
-            }
+            const proofs = await this.getCredentialRequestOptions(agentContext, {
+                allowedProofOfPossesionAlgorithms: allowedProofOfPossessionSignatureAlgorithms ?? (0, utils_1.getSupportedJwaSignatureAlgorithms)(agentContext),
+                metadata,
+                offeredCredential: {
+                    id: offeredCredentialId,
+                    configuration: offeredCredentialConfiguration,
+                },
+                clientId: options.clientId,
+                // We already checked whether nonce exists above
+                cNonce: cNonce,
+                credentialBindingResolver,
+            });
+            this.logger.debug('Generated credential request proof of possesion', { proofs });
+            const proof = 
+            // Draft 11 ALWAYS uses proof
+            (metadata.originalDraftVersion === openid4vci_2.Openid4vciDraftVersion.Draft11 ||
+                // Draft 14 allows both proof and proofs. Try to use proof when it makes to improve interoperability
+                (metadata.originalDraftVersion === openid4vci_2.Openid4vciDraftVersion.Draft14 &&
+                    metadata.credentialIssuer.batch_credential_issuance === undefined)) &&
+                proofs.jwt?.length === 1
+                ? {
+                    proof_type: 'jwt',
+                    jwt: proofs.jwt[0],
+                }
+                : undefined;
             const { credentialResponse, dpop } = await client.retrieveCredentials({
                 issuerMetadata: metadata,
                 accessToken: options.accessToken,
@@ -293,13 +333,9 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
                         dpopSigningAlgValuesSupported: [options.dpop.alg],
                     })
                     : undefined,
-                proofs: batchSize > 1 ? { jwt: jwts } : undefined,
-                proof: batchSize === 1
-                    ? {
-                        proof_type: 'jwt',
-                        jwt: jwts[0],
-                    }
-                    : undefined,
+                // Only include proofs if we don't add proof
+                proofs: !proof ? proofs : undefined,
+                proof,
             });
             // Set new nonce values
             cNonce = credentialResponse.c_nonce;
@@ -310,9 +346,10 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
                 credentialIssuerMetadata: metadata.credentialIssuer,
                 format: offeredCredentialConfiguration.format,
                 credentialConfigurationId: offeredCredentialId,
+                credentialConfiguration: offeredCredentialConfiguration,
             });
-            this.logger.debug('received credential', credential.credentials.map((c) => c instanceof core_1.Mdoc ? { issuerSignedNamespaces: c.issuerSignedNamespaces, base64Url: c.base64Url } : c));
-            receivedCredentials.push({ ...credential, credentialConfigurationId: offeredCredentialId });
+            this.logger.debug('received credential', credential.credentials.map((c) => c instanceof core_2.Mdoc ? { issuerSignedNamespaces: c.issuerSignedNamespaces, base64Url: c.base64Url } : c));
+            receivedCredentials.push(credential);
         }
         return {
             credentials: receivedCredentials,
@@ -332,82 +369,178 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
      * of possession.
      */
     async getCredentialRequestOptions(agentContext, options) {
-        const { signatureAlgorithms, supportedDidMethods, supportsAllDidMethods, supportsJwk } = this.getProofOfPossessionRequirements(agentContext, {
+        const dids = agentContext.resolve(core_1.DidsApi);
+        const { allowedProofOfPossesionAlgorithms, offeredCredential } = options;
+        const { configuration, id: configurationId } = offeredCredential;
+        const supportedJwaSignatureAlgorithms = (0, utils_1.getSupportedJwaSignatureAlgorithms)(agentContext);
+        const possibleProofOfPossessionSignatureAlgorithms = allowedProofOfPossesionAlgorithms
+            ? allowedProofOfPossesionAlgorithms.filter((algorithm) => supportedJwaSignatureAlgorithms.includes(algorithm))
+            : supportedJwaSignatureAlgorithms;
+        if (possibleProofOfPossessionSignatureAlgorithms.length === 0) {
+            throw new core_2.CredoError([
+                'No possible proof of possession signature algorithm found.',
+                `Signature algorithms supported by the Agent '${supportedJwaSignatureAlgorithms.join(', ')}'`,
+                `Allowed Signature algorithms '${allowedProofOfPossesionAlgorithms?.join(', ')}'`,
+            ].join('\n'));
+        }
+        const { proofTypes, supportedDidMethods, supportsAllDidMethods, supportsJwk } = this.getProofOfPossessionRequirements(agentContext, {
             credentialToRequest: options.offeredCredential,
-            possibleProofOfPossessionSignatureAlgorithms: options.possibleProofOfPossessionSignatureAlgorithms,
-        });
-        const JwkClasses = signatureAlgorithms.map((signatureAlgorithm) => {
-            const JwkClass = (0, core_1.getJwkClassFromJwaSignatureAlgorithm)(signatureAlgorithm);
-            if (!JwkClass) {
-                throw new core_1.CredoError(`Could not determine JWK key type of the JWA signature algorithm '${signatureAlgorithm}'`);
-            }
-            return JwkClass;
+            metadata: options.metadata,
+            possibleProofOfPossessionSignatureAlgorithms,
         });
-        const keyTypes = JwkClasses.map((JwkClass) => JwkClass.keyType);
-        const supportedVerificationMethods = keyTypes.flatMap((keyType) => (0, core_1.getSupportedVerificationMethodTypesFromKeyType)(keyType));
-        const format = options.offeredCredential.configuration.format;
+        const format = configuration.format;
         const supportsAnyMethod = supportedDidMethods !== undefined || supportsAllDidMethods || supportsJwk;
+        const issuerMaxBatchSize = options.metadata.credentialIssuer.batch_credential_issuance?.batch_size ?? 1;
         // Now we need to determine how the credential will be bound to us
         const credentialBinding = await options.credentialBindingResolver({
             agentContext,
             credentialFormat: format,
-            signatureAlgorithms,
-            supportedVerificationMethods,
-            keyTypes: JwkClasses.map((JwkClass) => JwkClass.keyType),
-            credentialConfigurationId: options.offeredCredential.id,
+            credentialConfigurationId: configurationId,
+            credentialConfiguration: configuration,
+            metadata: options.metadata,
+            issuerMaxBatchSize,
+            proofTypes,
             supportsAllDidMethods,
             supportedDidMethods,
             supportsJwk,
         });
-        let jwk;
+        const client = this.getClient(agentContext);
         // Make sure the issuer of proof of possession is valid according to openid issuer metadata
         if (credentialBinding.method === 'did') {
-            // Test binding method
+            if (!proofTypes.jwt) {
+                throw new core_2.CredoError(`JWT proof type is not supported for configuration '${configurationId}', which is required for did based credential binding.`);
+            }
+            if (proofTypes.jwt.keyAttestationsRequired) {
+                throw new core_2.CredoError(`Credential binding returned list of DID urls, but credential configuration '${configurationId}' requires key attestations. Key attestations and DIDs are not compatible.`);
+            }
+            if (credentialBinding.didUrls.length > issuerMaxBatchSize) {
+                throw new core_2.CredoError(`Issuer supports issuing a batch of maximum ${issuerMaxBatchSize} credential(s). Binding resolver returned ${credentialBinding.didUrls.length} DID urls. Make sure the returned value does not exceed the max batch issuance.`);
+            }
+            if (credentialBinding.didUrls.length === 0) {
+                throw new core_2.CredoError('Credential binding with method did returned empty didUrls list');
+            }
+            const firstDid = (0, core_2.parseDid)(credentialBinding.didUrls[0]);
+            if (!credentialBinding.didUrls.every((didUrl) => (0, core_2.parseDid)(didUrl).method === firstDid.method)) {
+                throw new core_2.CredoError('Expected all did urls for binding method did to use the same did method');
+            }
             if (!supportsAllDidMethods &&
                 // If supportedDidMethods is undefined, it means the issuer didn't include the binding methods in the metadata
                 // The user can still select a verification method, but we can't validate it
                 supportedDidMethods !== undefined &&
-                !supportedDidMethods.find((supportedDidMethod) => credentialBinding.didUrl.startsWith(supportedDidMethod) && supportsAnyMethod)) {
-                const { method } = (0, core_1.parseDid)(credentialBinding.didUrl);
+                !supportedDidMethods.find((supportedDidMethod) => firstDid.did.startsWith(supportedDidMethod) && supportsAnyMethod)) {
+                // Test binding method
                 const supportedDidMethodsString = supportedDidMethods.join(', ');
-                throw new core_1.CredoError(`Resolved credential binding for proof of possession uses did method '${method}', but issuer only supports '${supportedDidMethodsString}'`);
+                throw new core_2.CredoError(`Resolved credential binding for proof of possession uses did method '${firstDid.method}', but issuer only supports '${supportedDidMethodsString}'`);
             }
-            const key = await (0, utils_1.getKeyFromDid)(agentContext, credentialBinding.didUrl);
-            jwk = (0, core_1.getJwkFromKey)(key);
-            if (!keyTypes.includes(key.keyType)) {
-                throw new core_1.CredoError(`Credential binding returned did url that points to key with type '${key.keyType}', but one of '${keyTypes.join(', ')}' was expected`);
+            const { publicJwk: firstKey } = await dids.resolveVerificationMethodFromCreatedDidRecord(firstDid.didUrl);
+            const algorithm = proofTypes.jwt.supportedSignatureAlgorithms.find((algorithm) => firstKey.supportedSignatureAlgorithms.includes(algorithm));
+            if (!algorithm) {
+                throw new core_2.CredoError(`Credential binding returned did url that points to key '${firstKey.jwkTypehumanDescription}' that supports signature algorithms ${firstKey.supportedSignatureAlgorithms.join(', ')}, but one of '${proofTypes.jwt.supportedSignatureAlgorithms.join(', ')}' was expected`);
             }
+            // This will/should leverage the caching, so it's ok to resolve the did here
+            const keys = await Promise.all(credentialBinding.didUrls.map(async (didUrl, index) => index === 0
+                ? // We already fetched the first did
+                    { jwk: firstKey, didUrl: firstDid.didUrl }
+                : { jwk: (await dids.resolveVerificationMethodFromCreatedDidRecord(didUrl)).publicJwk, didUrl }));
+            if (!keys.every((key) => core_2.Kms.assymetricJwkKeyTypeMatches(key.jwk.toJson(), firstKey.toJson()))) {
+                throw new core_2.CredoError('Expected all did urls to point to the same key type');
+            }
+            return {
+                jwt: await Promise.all(keys.map((key) => client
+                    .createCredentialRequestJwtProof({
+                    credentialConfigurationId: configurationId,
+                    issuerMetadata: options.metadata,
+                    signer: {
+                        method: 'did',
+                        didUrl: key.didUrl,
+                        alg: algorithm,
+                        kid: key.jwk.keyId,
+                    },
+                    nonce: options.cNonce,
+                    clientId: options.clientId,
+                })
+                    .then(({ jwt }) => jwt))),
+            };
         }
-        else if (credentialBinding.method === 'jwk') {
+        if (credentialBinding.method === 'jwk') {
             if (!supportsJwk && supportsAnyMethod) {
-                throw new core_1.CredoError(`Resolved credential binding for proof of possession uses jwk, but openid issuer does not support 'jwk' or 'cose_key' cryptographic binding method`);
+                throw new core_2.CredoError(`Resolved credential binding for proof of possession uses jwk, but openid issuer does not support 'jwk' or 'cose_key' cryptographic binding method`);
             }
-            jwk = credentialBinding.jwk;
-            if (!keyTypes.includes(credentialBinding.jwk.key.keyType)) {
-                throw new core_1.CredoError(`Credential binding returned jwk with key with type '${credentialBinding.jwk.key.keyType}', but one of '${keyTypes.join(', ')}' was expected`);
+            if (!proofTypes.jwt) {
+                throw new core_2.CredoError(`JWT proof type is not supported for configuration '${configurationId}', which is required for jwk based credential binding.`);
             }
-        }
-        else {
-            // @ts-expect-error currently if/else if exhaustive, but once we add new option it will give ts error
-            throw new core_1.CredoError(`Unsupported credential binding method ${credentialBinding.method}`);
-        }
-        const alg = jwk.supportedSignatureAlgorithms.find((alg) => signatureAlgorithms.includes(alg));
-        if (!alg) {
-            // Should not happen, to make ts happy
-            throw new core_1.CredoError(`Unable to determine alg for key type ${jwk.keyType}`);
-        }
-        const jwtSigner = credentialBinding.method === 'did'
-            ? {
-                method: credentialBinding.method,
-                didUrl: credentialBinding.didUrl,
-                alg,
+            if (proofTypes.jwt.keyAttestationsRequired) {
+                throw new core_2.CredoError(`Credential binding returned list of JWK keys, but credential configuration '${configurationId}' requires key attestations. Return a key attestation with binding method 'attestation'.`);
             }
-            : {
-                method: 'jwk',
-                publicJwk: credentialBinding.jwk.toJson(),
-                alg,
+            if (credentialBinding.keys.length > issuerMaxBatchSize) {
+                throw new core_2.CredoError(`Issuer supports issuing a batch of maximum ${issuerMaxBatchSize} credential(s). Binding resolver returned ${credentialBinding.keys.length} keys. Make sure the returned value does not exceed the max batch issuance.`);
+            }
+            if (credentialBinding.keys.length === 0) {
+                throw new core_2.CredoError('Credential binding with method jwk returned empty keys list');
+            }
+            const firstJwk = credentialBinding.keys[0];
+            if (!credentialBinding.keys.every((key) => core_2.Kms.assymetricJwkKeyTypeMatches(key.toJson(), firstJwk.toJson()))) {
+                throw new core_2.CredoError('Expected all keys for binding method jwk to use the same key type');
+            }
+            const algorithm = proofTypes.jwt.supportedSignatureAlgorithms.find((algorithm) => firstJwk.supportedSignatureAlgorithms.includes(algorithm));
+            if (!algorithm) {
+                throw new core_2.CredoError(`Credential binding returned jwk that points to key '${firstJwk.jwkTypehumanDescription}' that supports signature algorithms ${firstJwk.supportedSignatureAlgorithms.join(', ')}, but one of '${proofTypes.jwt.supportedSignatureAlgorithms.join(', ')}' was expected`);
+            }
+            return {
+                jwt: await Promise.all(credentialBinding.keys.map((jwk) => client
+                    .createCredentialRequestJwtProof({
+                    credentialConfigurationId: configurationId,
+                    issuerMetadata: options.metadata,
+                    signer: {
+                        method: 'jwk',
+                        publicJwk: jwk.toJson(),
+                        alg: algorithm,
+                    },
+                    nonce: options.cNonce,
+                    clientId: options.clientId,
+                })
+                    .then(({ jwt }) => jwt))),
             };
-        return { credentialBinding, signatureAlgorithm: alg, jwtSigner };
+        }
+        if (credentialBinding.method === 'attestation') {
+            const { payload } = (0, openid4vci_1.parseKeyAttestationJwt)({ keyAttestationJwt: credentialBinding.keyAttestationJwt });
+            // TODO: check client_id matches in payload
+            if (payload.attested_keys.length > issuerMaxBatchSize) {
+                throw new core_2.CredoError(`Issuer supports issuing a batch of maximum ${issuerMaxBatchSize} credential(s). Binding resolver returned key attestation with ${payload.attested_keys.length} attested keys. Make sure the returned value does not exceed the max batch issuance.`);
+            }
+            // TODO: check nonce matches cNonce
+            if (proofTypes.attestation && payload.nonce) {
+                // If attestation is supported and the attestation contains a nonce, we can use the attestation directly
+                return {
+                    attestation: [credentialBinding.keyAttestationJwt],
+                };
+            }
+            if (proofTypes.jwt) {
+                const jwk = core_2.Kms.PublicJwk.fromUnknown(payload.attested_keys[0]);
+                return {
+                    jwt: [
+                        await client
+                            .createCredentialRequestJwtProof({
+                            credentialConfigurationId: configurationId,
+                            issuerMetadata: options.metadata,
+                            signer: {
+                                method: 'jwk',
+                                publicJwk: payload.attested_keys[0],
+                                // TODO: we should probably use the 'alg' from the jwk
+                                alg: jwk.supportedSignatureAlgorithms[0],
+                            },
+                            keyAttestationJwt: credentialBinding.keyAttestationJwt,
+                            nonce: options.cNonce,
+                            clientId: options.clientId,
+                        })
+                            .then(({ jwt }) => jwt),
+                    ],
+                };
+            }
+            throw new core_2.CredoError(`Unable to create credential request proofs. Configuration supports 'attestation' proof type, but attestation did not contain a 'nonce' value`);
+        }
+        // @ts-expect-error currently if/else if exhaustive, but once we add new option it will give ts error
+        throw new core_2.CredoError(`Unsupported credential binding method ${credentialBinding.method}`);
     }
     /**
      * Get the requirements for creating the proof of possession. Based on the allowed
@@ -416,53 +549,87 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
      * algorithm to use, based on the order of preference.
      */
     getProofOfPossessionRequirements(agentContext, options) {
-        const { credentialToRequest } = options;
-        if (!OpenId4VciHolderServiceOptions_1.openId4VciSupportedCredentialFormats.includes(credentialToRequest.configuration.format)) {
-            throw new core_1.CredoError([
+        const { credentialToRequest, possibleProofOfPossessionSignatureAlgorithms, metadata } = options;
+        const { configuration, id: configurationId } = credentialToRequest;
+        if (!OpenId4VciHolderServiceOptions_1.openId4VciSupportedCredentialFormats.includes(configuration.format)) {
+            throw new core_2.CredoError([
                 `Requested credential with format '${credentialToRequest.configuration.format}',`,
                 `for the credential with id '${credentialToRequest.id},`,
                 `but the wallet only supports the following formats '${OpenId4VciHolderServiceOptions_1.openId4VciSupportedCredentialFormats.join(', ')}'`,
             ].join('\n'));
         }
         // For each of the supported algs, find the key types, then find the proof types
-        const signatureSuiteRegistry = agentContext.dependencyManager.resolve(core_1.SignatureSuiteRegistry);
-        let signatureAlgorithms = [];
-        if (credentialToRequest.configuration.proof_types_supported) {
-            if (!credentialToRequest.configuration.proof_types_supported.jwt) {
-                throw new core_1.CredoError(`Unsupported proof type(s) ${Object.keys(credentialToRequest.configuration.proof_types_supported).join(', ')}. Supported proof type(s) are: jwt`);
+        const signatureSuiteRegistry = agentContext.dependencyManager.resolve(core_2.SignatureSuiteRegistry);
+        let proofTypesSupported = configuration.proof_types_supported;
+        if (!proofTypesSupported) {
+            // For draft above 11 we do not allow no proof_type (we do not support no key binding for now)
+            if (metadata.originalDraftVersion !== openid4vci_2.Openid4vciDraftVersion.Draft11) {
+                throw new core_2.CredoError(`Credential configuration '${configurationId}' does not specifcy proof_types_supported. Credentials not bound to keys are not supported at the moment`);
             }
+            // For draft 11 we fall back to jwt proof type
+            proofTypesSupported = {
+                jwt: {
+                    proof_signing_alg_values_supported: possibleProofOfPossessionSignatureAlgorithms,
+                },
+            };
         }
-        const proofSigningAlgsSupported = credentialToRequest.configuration.proof_types_supported?.jwt?.proof_signing_alg_values_supported;
-        // If undefined, it means the issuer didn't include the cryptographic suites in the metadata
-        // We just guess that the first one is supported
-        if (proofSigningAlgsSupported === undefined) {
-            signatureAlgorithms = options.possibleProofOfPossessionSignatureAlgorithms;
-        }
-        else {
-            switch (credentialToRequest.configuration.format) {
-                case shared_1.OpenId4VciCredentialFormatProfile.JwtVcJson:
-                case shared_1.OpenId4VciCredentialFormatProfile.JwtVcJsonLd:
-                case shared_1.OpenId4VciCredentialFormatProfile.SdJwtVc:
-                case shared_1.OpenId4VciCredentialFormatProfile.MsoMdoc:
-                    signatureAlgorithms = options.possibleProofOfPossessionSignatureAlgorithms.filter((signatureAlgorithm) => proofSigningAlgsSupported.includes(signatureAlgorithm));
-                    break;
-                case shared_1.OpenId4VciCredentialFormatProfile.LdpVc:
-                    signatureAlgorithms = options.possibleProofOfPossessionSignatureAlgorithms.filter((signatureAlgorithm) => {
-                        const JwkClass = (0, core_1.getJwkClassFromJwaSignatureAlgorithm)(signatureAlgorithm);
-                        if (!JwkClass)
-                            return false;
-                        const matchingSuite = signatureSuiteRegistry.getAllByKeyType(JwkClass.keyType);
-                        if (matchingSuite.length === 0)
-                            return false;
-                        return proofSigningAlgsSupported.includes(matchingSuite[0].proofType);
-                    });
-                    break;
-                default:
-                    throw new core_1.CredoError('Unsupported credential format.');
+        const proofTypes = {
+            jwt: undefined,
+            attestation: undefined,
+        };
+        for (const [proofType, proofTypeConfig] of Object.entries(proofTypesSupported)) {
+            if (proofType !== 'jwt' && proofType !== 'attestation')
+                continue;
+            let signatureAlgorithms = [];
+            const proofSigningAlgsSupported = proofTypeConfig?.proof_signing_alg_values_supported;
+            if (proofSigningAlgsSupported === undefined) {
+                // If undefined, it means the issuer didn't include the cryptographic suites in the metadata
+                // We just guess that the first one is supported
+                signatureAlgorithms = options.possibleProofOfPossessionSignatureAlgorithms;
+            }
+            else {
+                switch (credentialToRequest.configuration.format) {
+                    case shared_1.OpenId4VciCredentialFormatProfile.JwtVcJson:
+                    case shared_1.OpenId4VciCredentialFormatProfile.JwtVcJsonLd:
+                    case shared_1.OpenId4VciCredentialFormatProfile.SdJwtVc:
+                    case shared_1.OpenId4VciCredentialFormatProfile.SdJwtDc:
+                    case shared_1.OpenId4VciCredentialFormatProfile.MsoMdoc:
+                        signatureAlgorithms = options.possibleProofOfPossessionSignatureAlgorithms.filter((signatureAlgorithm) => proofSigningAlgsSupported.includes(signatureAlgorithm));
+                        break;
+                    // FIXME: this is wrong, as the proof type is separate from the credential signing alg
+                    // But there might be some draft 11 logic that depends on this, can be removed soon
+                    case shared_1.OpenId4VciCredentialFormatProfile.LdpVc:
+                        signatureAlgorithms = options.possibleProofOfPossessionSignatureAlgorithms.filter((signatureAlgorithm) => {
+                            try {
+                                const jwkClass = core_2.Kms.PublicJwk.supportedPublicJwkClassForSignatureAlgorithm(signatureAlgorithm);
+                                const matchingSuites = signatureSuiteRegistry.getAllByPublicJwkType(jwkClass);
+                                if (matchingSuites.length === 0)
+                                    return false;
+                                return proofSigningAlgsSupported.includes(matchingSuites[0].proofType);
+                            }
+                            catch {
+                                return false;
+                            }
+                        });
+                        break;
+                    default:
+                        throw new core_2.CredoError('Unsupported credential format.');
+                }
             }
+            proofTypes[proofType] = {
+                supportedSignatureAlgorithms: signatureAlgorithms,
+                keyAttestationsRequired: proofTypeConfig.key_attestations_required
+                    ? {
+                        keyStorage: proofTypeConfig.key_attestations_required.key_storage,
+                        userAuthentication: proofTypeConfig.key_attestations_required.user_authentication,
+                    }
+                    : undefined,
+            };
         }
-        if (signatureAlgorithms.length === 0) {
-            throw new core_1.CredoError(`Could not establish signature algorithm for format ${credentialToRequest.configuration.format} and id ${credentialToRequest.id}. Server supported signature algorithms are '${proofSigningAlgsSupported?.join(', ') ?? 'Not defined'}', available are '${options.possibleProofOfPossessionSignatureAlgorithms.join(', ')}'`);
+        const { jwt, attestation } = proofTypes;
+        if (!jwt && !attestation) {
+            const supported = Object.keys(proofTypesSupported).join(', ');
+            throw new core_2.CredoError(`Unsupported proof type(s) ${supported}. Supported proof type(s) are: jwt, attestation`);
         }
         const issuerSupportedBindingMethods = credentialToRequest.configuration.cryptographic_binding_methods_supported;
         const supportsAllDidMethods = issuerSupportedBindingMethods?.includes('did') ?? false;
@@ -471,26 +638,26 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
         const supportsCoseKey = issuerSupportedBindingMethods?.includes('cose_key') ?? false;
         const supportsJwk = issuerSupportedBindingMethods?.includes('jwk') || supportsCoseKey;
         return {
-            signatureAlgorithms,
+            proofTypes,
             supportedDidMethods,
             supportsAllDidMethods,
             supportsJwk,
         };
     }
     async handleCredentialResponse(agentContext, credentialResponse, options) {
-        const { verifyCredentialStatus, credentialConfigurationId } = options;
+        const { verifyCredentialStatus, credentialConfigurationId, credentialConfiguration } = options;
         this.logger.debug('Credential response', credentialResponse);
         const credentials = credentialResponse.credentials ?? (credentialResponse.credential ? [credentialResponse.credential] : undefined);
         if (!credentials) {
-            throw new core_1.CredoError(`Credential response returned neither 'credentials' nor 'credential' parameter.`);
+            throw new core_2.CredoError(`Credential response returned neither 'credentials' nor 'credential' parameter.`);
         }
         const notificationId = credentialResponse.notification_id;
         const format = options.format;
-        if (format === shared_1.OpenId4VciCredentialFormatProfile.SdJwtVc) {
+        if (format === shared_1.OpenId4VciCredentialFormatProfile.SdJwtVc || format === shared_1.OpenId4VciCredentialFormatProfile.SdJwtDc) {
             if (!credentials.every((c) => typeof c === 'string')) {
-                throw new core_1.CredoError(`Received credential(s) of format ${format}, but not all credential(s) are a string. ${JSON.stringify(credentials)}`);
+                throw new core_2.CredoError(`Received credential(s) of format ${format}, but not all credential(s) are a string. ${JSON.stringify(credentials)}`);
             }
-            const sdJwtVcApi = agentContext.dependencyManager.resolve(core_1.SdJwtVcApi);
+            const sdJwtVcApi = agentContext.dependencyManager.resolve(core_2.SdJwtVcApi);
             const verificationResults = await Promise.all(credentials.map((compactSdJwtVc, index) => sdJwtVcApi.verify({
                 compactSdJwtVc,
                 // Only load and verify it for the first instance
@@ -498,21 +665,22 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
             })));
             if (!verificationResults.every((result) => result.isValid)) {
                 agentContext.config.logger.error('Failed to validate credential(s)', { verificationResults });
-                throw new core_1.CredoError(`Failed to validate sd-jwt-vc credentials. Results = ${JSON.stringify(verificationResults)}`);
+                throw new core_2.CredoError(`Failed to validate sd-jwt-vc credentials. Results = ${JSON.stringify(verificationResults)}`);
             }
             return {
                 credentials: verificationResults.map((result) => result.sdJwtVc),
                 notificationId,
                 credentialConfigurationId,
+                credentialConfiguration,
             };
         }
         if (options.format === shared_1.OpenId4VciCredentialFormatProfile.JwtVcJson ||
             options.format === shared_1.OpenId4VciCredentialFormatProfile.JwtVcJsonLd) {
             if (!credentials.every((c) => typeof c === 'string')) {
-                throw new core_1.CredoError(`Received credential(s) of format ${format}, but not all credential(s) are a string. ${JSON.stringify(credentials)}`);
+                throw new core_2.CredoError(`Received credential(s) of format ${format}, but not all credential(s) are a string. ${JSON.stringify(credentials)}`);
             }
             const result = await Promise.all(credentials.map(async (c) => {
-                const credential = core_1.W3cJwtVerifiableCredential.fromSerializedJwt(c);
+                const credential = core_2.W3cJwtVerifiableCredential.fromSerializedJwt(c);
                 const result = await this.w3cCredentialService.verifyCredential(agentContext, {
                     credential,
                     verifyCredentialStatus,
@@ -521,19 +689,24 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
             }));
             if (!result.every((c) => c.result.isValid)) {
                 agentContext.config.logger.error('Failed to validate credentials', { result });
-                throw new core_1.CredoError(`Failed to validate credential, error = ${result
+                throw new core_2.CredoError(`Failed to validate credential, error = ${result
                     .map((e) => e.result.error?.message)
                     .filter(Boolean)
                     .join(', ')}`);
             }
-            return { credentials: result.map((r) => r.credential), notificationId, credentialConfigurationId };
+            return {
+                credentials: result.map((r) => r.credential),
+                notificationId,
+                credentialConfigurationId,
+                credentialConfiguration,
+            };
         }
         if (format === shared_1.OpenId4VciCredentialFormatProfile.LdpVc) {
             if (!credentials.every((c) => typeof c === 'object')) {
-                throw new core_1.CredoError(`Received credential(s) of format ${format}, but not all credential(s) are an object. ${JSON.stringify(credentials)}`);
+                throw new core_2.CredoError(`Received credential(s) of format ${format}, but not all credential(s) are an object. ${JSON.stringify(credentials)}`);
             }
             const result = await Promise.all(credentials.map(async (c) => {
-                const credential = core_1.W3cJsonLdVerifiableCredential.fromJson(c);
+                const credential = core_2.W3cJsonLdVerifiableCredential.fromJson(c);
                 const result = await this.w3cCredentialService.verifyCredential(agentContext, {
                     credential,
                     verifyCredentialStatus,
@@ -542,20 +715,25 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
             }));
             if (!result.every((c) => c.result.isValid)) {
                 agentContext.config.logger.error('Failed to validate credentials', { result });
-                throw new core_1.CredoError(`Failed to validate credential, error = ${result
+                throw new core_2.CredoError(`Failed to validate credential, error = ${result
                     .map((e) => e.result.error?.message)
                     .filter(Boolean)
                     .join(', ')}`);
             }
-            return { credentials: result.map((r) => r.credential), notificationId, credentialConfigurationId };
+            return {
+                credentials: result.map((r) => r.credential),
+                notificationId,
+                credentialConfigurationId,
+                credentialConfiguration,
+            };
         }
         if (format === shared_1.OpenId4VciCredentialFormatProfile.MsoMdoc) {
             if (!credentials.every((c) => typeof c === 'string')) {
-                throw new core_1.CredoError(`Received credential(s) of format ${format}, but not all credential(s) are a string. ${JSON.stringify(credentials)}`);
+                throw new core_2.CredoError(`Received credential(s) of format ${format}, but not all credential(s) are a string. ${JSON.stringify(credentials)}`);
             }
-            const mdocApi = agentContext.dependencyManager.resolve(core_1.MdocApi);
+            const mdocApi = agentContext.dependencyManager.resolve(core_2.MdocApi);
             const result = await Promise.all(credentials.map(async (credential) => {
-                const mdoc = core_1.Mdoc.fromBase64Url(credential);
+                const mdoc = core_2.Mdoc.fromBase64Url(credential);
                 const result = await mdocApi.verify(mdoc, {});
                 return {
                     result,
@@ -564,18 +742,62 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
             }));
             if (!result.every((r) => r.result.isValid)) {
                 agentContext.config.logger.error('Failed to validate credentials', { result });
-                throw new core_1.CredoError(`Failed to validate mdoc credential(s). \n - ${result
+                throw new core_2.CredoError(`Failed to validate mdoc credential(s). \n - ${result
                     .map((r, i) => (r.result.isValid ? undefined : `(${i}) ${r.result.error}`))
                     .filter(Boolean)
                     .join('\n - ')}`);
             }
-            return { credentials: result.map((c) => c.mdoc), notificationId, credentialConfigurationId };
+            return {
+                credentials: result.map((c) => c.mdoc),
+                notificationId,
+                credentialConfigurationId,
+                credentialConfiguration,
+            };
         }
-        throw new core_1.CredoError(`Unsupported credential format ${options.format}`);
+        throw new core_2.CredoError(`Unsupported credential format ${options.format}`);
     }
-    getClient(agentContext) {
-        return new openid4vci_1.Openid4vciClient({
-            callbacks: (0, callbacks_1.getOid4vcCallbacks)(agentContext),
+    getClient(agentContext, { clientAttestation, clientId } = {}) {
+        const callbacks = (0, callbacks_1.getOid4vcCallbacks)(agentContext);
+        return new openid4vci_2.Openid4vciClient({
+            callbacks: {
+                ...callbacks,
+                clientAuthentication: (options) => {
+                    const { authorizationServerMetadata, url, body } = options;
+                    const oauth2Client = this.getOauth2Client(agentContext);
+                    const clientAttestationSupported = oauth2Client.isClientAttestationSupported({
+                        authorizationServerMetadata,
+                    });
+                    // Client attestations
+                    if (clientAttestation && clientAttestationSupported) {
+                        return (0, oauth2_1.clientAuthenticationClientAttestationJwt)({
+                            clientAttestationJwt: clientAttestation,
+                            callbacks,
+                        })(options);
+                    }
+                    // Pre auth flow
+                    if (url === authorizationServerMetadata.token_endpoint &&
+                        authorizationServerMetadata['pre-authorized_grant_anonymous_access_supported'] &&
+                        body.grant_type === oauth2_1.preAuthorizedCodeGrantIdentifier) {
+                        return (0, oauth2_1.clientAuthenticationAnonymous)()(options);
+                    }
+                    // Just a client id (no auth)
+                    if (clientId) {
+                        return (0, oauth2_1.clientAuthenticationNone)({ clientId })(options);
+                    }
+                    // NOTE: we fall back to anonymous authentication for pre-auth for now, as there's quite some
+                    // issuers that do not have pre-authorized_grant_anonymous_access_supported defined
+                    if (url === authorizationServerMetadata.token_endpoint &&
+                        body.grant_type === oauth2_1.preAuthorizedCodeGrantIdentifier) {
+                        return (0, oauth2_1.clientAuthenticationAnonymous)()(options);
+                    }
+                    // TODO: We should still look at auth_methods_supported
+                    // If there is an auth session for the auth challenge endpoint, we don't have to include the client_id
+                    if (url === authorizationServerMetadata.authorization_challenge_endpoint && body.auth_session) {
+                        return (0, oauth2_1.clientAuthenticationAnonymous)()(options);
+                    }
+                    throw new core_2.CredoError('Unable to perform client authentication.');
+                },
+            },
         });
     }
     getOauth2Client(agentContext) {
@@ -586,8 +808,8 @@ let OpenId4VciHolderService = class OpenId4VciHolderService {
 };
 exports.OpenId4VciHolderService = OpenId4VciHolderService;
 exports.OpenId4VciHolderService = OpenId4VciHolderService = __decorate([
-    (0, core_1.injectable)(),
-    __param(0, (0, core_1.inject)(core_1.InjectionSymbols.Logger)),
-    __metadata("design:paramtypes", [Object, core_1.W3cCredentialService])
+    (0, core_2.injectable)(),
+    __param(0, (0, core_2.inject)(core_2.InjectionSymbols.Logger)),
+    __metadata("design:paramtypes", [Object, core_2.W3cCredentialService])
 ], OpenId4VciHolderService);
 //# sourceMappingURL=OpenId4VciHolderService.js.map