@sphereon/ssi-sdk.oid4vci-holder 0.33.0 → 0.33.1-feature.vcdm2.4

package/dist/services/OID4VCIHolderService.js

@@ -1,54 +1,42 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startFirstPartApplicationMachine = exports.getIssuanceCryptoSuite = exports.getIssuanceMethod = exports.getIssuanceOpts = exports.getCredentialConfigsSupportedBySingleTypeOrId = exports.getCredentialConfigsSupported = exports.getCredentialConfigsSupportedMerged = exports.getIdentifierOpts = exports.mapCredentialToAccept = exports.verifyCredentialToAccept = exports.selectCredentialLocaleBranding = exports.getCredentialConfigsBasedOnFormatPref = exports.getBasicIssuerLocaleBranding = exports.getCredentialBranding = void 0;
-const oid4vci_client_1 = require("@sphereon/oid4vci-client");
-const oid4vci_common_1 = require("@sphereon/oid4vci-common");
-const ssi_sdk_ext_did_resolver_jwk_1 = require("@sphereon/ssi-sdk-ext.did-resolver-jwk");
-const ssi_sdk_ext_did_utils_1 = require("@sphereon/ssi-sdk-ext.did-utils");
-const ssi_sdk_ext_identifier_resolution_1 = require("@sphereon/ssi-sdk-ext.identifier-resolution");
-const ssi_sdk_ext_key_utils_1 = require("@sphereon/ssi-sdk-ext.key-utils");
-const ssi_types_1 = require("@sphereon/ssi-types");
-const utils_1 = require("@veramo/utils");
-const Localization_1 = require("../localization/Localization");
-const IOID4VCIHolder_1 = require("../types/IOID4VCIHolder");
-const OIDC4VCIBrandingMapper_1 = require("../mappers/OIDC4VCIBrandingMapper");
-const firstPartyMachine_1 = require("../machines/firstPartyMachine");
-const FirstPartyMachine_1 = require("../types/FirstPartyMachine");
-const ssi_sdk_core_1 = require("@sphereon/ssi-sdk.core");
-const getCredentialBranding = (args) => __awaiter(void 0, void 0, void 0, function* () {
+import { LOG } from '@sphereon/oid4vci-client';
+import { getSupportedCredentials, getTypesFromCredentialSupported, getTypesFromObject, OpenId4VCIVersion, } from '@sphereon/oid4vci-common';
+import { KeyUse } from '@sphereon/ssi-sdk-ext.did-resolver-jwk';
+import { getOrCreatePrimaryIdentifier, SupportedDidMethodEnum } from '@sphereon/ssi-sdk-ext.did-utils';
+import { isIIdentifier, isManagedIdentifierDidResult, isManagedIdentifierResult, managedIdentifierToJwk, } from '@sphereon/ssi-sdk-ext.identifier-resolution';
+import { keyTypeFromCryptographicSuite } from '@sphereon/ssi-sdk-ext.key-utils';
+import { CredentialMapper, JoseSignatureAlgorithm, mdocDecodedCredentialToUniformCredential, sdJwtDecodedCredentialToUniformCredential, } from '@sphereon/ssi-types';
+import { asArray } from '@veramo/utils';
+import { translate } from '../localization/Localization';
+import { OID4VCIHolderEvent, } from '../types/IOID4VCIHolder';
+import { oid4vciGetCredentialBrandingFrom, sdJwtGetCredentialBrandingFrom, issuerLocaleBrandingFrom } from '../mappers/OIDC4VCIBrandingMapper';
+import { FirstPartyMachine } from '../machines/firstPartyMachine';
+import { FirstPartyMachineStateTypes } from '../types/FirstPartyMachine';
+import { defaultHasher } from '@sphereon/ssi-sdk.core';
+export const getCredentialBranding = async (args) => {
     const { credentialsSupported, context } = args;
     const credentialBranding = {};
-    yield Promise.all(Object.entries(credentialsSupported).map((_a) => __awaiter(void 0, [_a], void 0, function* ([configId, credentialsConfigSupported]) {
+    await Promise.all(Object.entries(credentialsSupported).map(async ([configId, credentialsConfigSupported]) => {
         let sdJwtTypeMetadata;
         if (credentialsConfigSupported.format === 'vc+sd-jwt') {
             const vct = credentialsConfigSupported.vct;
             if (vct.startsWith('http')) {
                 try {
-                    sdJwtTypeMetadata = yield context.agent.fetchSdJwtTypeMetadataFromVctUrl({ vct });
+                    sdJwtTypeMetadata = await context.agent.fetchSdJwtTypeMetadataFromVctUrl({ vct });
                 }
-                catch (_b) {
+                catch {
                     // For now, we are just going to ignore and continue without any branding as we still have a fallback
                 }
             }
         }
         let mappedLocaleBranding = [];
         if (sdJwtTypeMetadata) {
-            mappedLocaleBranding = yield (0, OIDC4VCIBrandingMapper_1.sdJwtGetCredentialBrandingFrom)({
+            mappedLocaleBranding = await sdJwtGetCredentialBrandingFrom({
                 credentialDisplay: sdJwtTypeMetadata.display,
                 claimsMetadata: sdJwtTypeMetadata.claims,
             });
         }
         else {
-            mappedLocaleBranding = yield (0, OIDC4VCIBrandingMapper_1.oid4vciGetCredentialBrandingFrom)({
+            mappedLocaleBranding = await oid4vciGetCredentialBrandingFrom({
                 credentialDisplay: credentialsConfigSupported.display,
                 issuerCredentialSubject: 
                 // @ts-ignore // FIXME SPRIND-123 add proper support for type recognition as claim display can be located elsewhere for v13
@@ -56,26 +44,24 @@ const getCredentialBranding = (args) => __awaiter(void 0, void 0, void 0, functi
             });
         }
         // TODO we should make the mapper part of the plugin, so that the logic for getting the branding becomes more clear and easier to use
-        const localeBranding = yield Promise.all(mappedLocaleBranding.map((localeBranding) => __awaiter(void 0, void 0, void 0, function* () { return yield context.agent.ibCredentialLocaleBrandingFrom({ localeBranding }); })));
+        const localeBranding = await Promise.all(mappedLocaleBranding.map(async (localeBranding) => await context.agent.ibCredentialLocaleBrandingFrom({ localeBranding })));
         const defaultCredentialType = 'VerifiableCredential';
-        const configSupportedTypes = (0, oid4vci_common_1.getTypesFromCredentialSupported)(credentialsConfigSupported);
-        const credentialTypes = configSupportedTypes.length === 0 ? (0, utils_1.asArray)(defaultCredentialType) : configSupportedTypes;
+        const configSupportedTypes = getTypesFromCredentialSupported(credentialsConfigSupported);
+        const credentialTypes = configSupportedTypes.length === 0 ? asArray(defaultCredentialType) : configSupportedTypes;
         const filteredCredentialTypes = credentialTypes.filter((type) => type !== defaultCredentialType);
         credentialBranding[filteredCredentialTypes[0]] = localeBranding; // TODO for now taking the first type
-    })));
+    }));
     return credentialBranding;
-});
-exports.getCredentialBranding = getCredentialBranding;
-const getBasicIssuerLocaleBranding = (args) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const getBasicIssuerLocaleBranding = async (args) => {
     const { display, dynamicRegistrationClientMetadata, context } = args;
-    return yield Promise.all(display.map((issuerDisplay) => __awaiter(void 0, void 0, void 0, function* () {
+    return await Promise.all(display.map(async (issuerDisplay) => {
         // FIXME for now we do not have locale support for dynamicRegistrationClientMetadata, so we add all the metadata to every locale
-        const branding = yield (0, OIDC4VCIBrandingMapper_1.issuerLocaleBrandingFrom)({ issuerDisplay, dynamicRegistrationClientMetadata });
+        const branding = await issuerLocaleBrandingFrom({ issuerDisplay, dynamicRegistrationClientMetadata });
         return context.agent.ibIssuerLocaleBrandingFrom({ localeBranding: branding });
-    })));
-});
-exports.getBasicIssuerLocaleBranding = getBasicIssuerLocaleBranding;
-const getCredentialConfigsBasedOnFormatPref = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    }));
+};
+export const getCredentialConfigsBasedOnFormatPref = async (args) => {
     const { vcFormatPreferences, credentials } = args;
     const prefConfigs = {};
     Object.entries(credentials).forEach(([key, config]) => {
@@ -85,34 +71,31 @@ const getCredentialConfigsBasedOnFormatPref = (args) => __awaiter(void 0, void 0
         }
     });
     return prefConfigs;
-});
-exports.getCredentialConfigsBasedOnFormatPref = getCredentialConfigsBasedOnFormatPref;
-const selectCredentialLocaleBranding = (args) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const selectCredentialLocaleBranding = async (args) => {
     const { locale, localeBranding } = args;
-    return localeBranding === null || localeBranding === void 0 ? void 0 : localeBranding.find((branding) => { var _a; return locale ? ((_a = branding.locale) === null || _a === void 0 ? void 0 : _a.startsWith(locale)) || branding.locale === undefined : branding.locale === undefined; });
-});
-exports.selectCredentialLocaleBranding = selectCredentialLocaleBranding;
-const verifyCredentialToAccept = (args) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    return localeBranding?.find((branding) => locale ? branding.locale?.startsWith(locale) || branding.locale === undefined : branding.locale === undefined);
+};
+export const verifyCredentialToAccept = async (args) => {
     const { mappedCredential, hasher, onVerifyEBSICredentialIssuer, schemaValidation, context } = args;
     const credential = mappedCredential.credentialToAccept.credentialResponse.credential;
     if (!credential) {
         return Promise.reject(Error('No credential found in credential response'));
     }
-    const wrappedVC = ssi_types_1.CredentialMapper.toWrappedVerifiableCredential(credential, { hasher: hasher !== null && hasher !== void 0 ? hasher : ssi_sdk_core_1.defaultHasher });
-    if (((_b = (_a = wrappedVC.decoded) === null || _a === void 0 ? void 0 : _a.iss) === null || _b === void 0 ? void 0 : _b.includes('did:ebsi:')) ||
-        (typeof ((_d = (_c = wrappedVC.decoded) === null || _c === void 0 ? void 0 : _c.vc) === null || _d === void 0 ? void 0 : _d.issuer) === 'string'
-            ? (_g = (_f = (_e = wrappedVC.decoded) === null || _e === void 0 ? void 0 : _e.vc) === null || _f === void 0 ? void 0 : _f.issuer) === null || _g === void 0 ? void 0 : _g.includes('did:ebsi:')
-            : (_l = (_k = (_j = (_h = wrappedVC.decoded) === null || _h === void 0 ? void 0 : _h.vc) === null || _j === void 0 ? void 0 : _j.issuer) === null || _k === void 0 ? void 0 : _k.existingInstanceId) === null || _l === void 0 ? void 0 : _l.includes('did:ebsi:'))) {
+    const wrappedVC = CredentialMapper.toWrappedVerifiableCredential(credential, { hasher: hasher ?? defaultHasher });
+    if (wrappedVC.decoded?.iss?.includes('did:ebsi:') ||
+        (typeof wrappedVC.decoded?.vc?.issuer === 'string'
+            ? wrappedVC.decoded?.vc?.issuer?.includes('did:ebsi:')
+            : wrappedVC.decoded?.vc?.issuer?.existingInstanceId?.includes('did:ebsi:'))) {
         // TODO: Skipping VC validation for EBSI conformance issued credential, as their Issuer is not present in the ledger (sigh)
         // just calling the verifySchema functionality for ebsi credentials
-        yield context.agent.cvVerifySchema({ credential, hasher, validationPolicy: schemaValidation });
+        await context.agent.cvVerifySchema({ credential, hasher, validationPolicy: schemaValidation });
         if (JSON.stringify(wrappedVC.decoded).includes('vc:ebsi:conformance')) {
             return { source: wrappedVC, error: undefined, result: true, subResults: [] };
         }
         if (onVerifyEBSICredentialIssuer) {
             try {
-                yield onVerifyEBSICredentialIssuer({
+                await onVerifyEBSICredentialIssuer({
                     wrappedVc: wrappedVC,
                 });
             }
@@ -121,7 +104,7 @@ const verifyCredentialToAccept = (args) => __awaiter(void 0, void 0, void 0, fun
             }
         }
     }
-    const verificationResult = yield context.agent.cvVerifyCredential({
+    const verificationResult = await context.agent.cvVerifyCredential({
         credential,
         hasher,
         // TODO WAL-675 we might want to allow these types of options as part of the context, now we have state machines. Allows us to pre-determine whether these policies apply and whether remote context should be fetched
@@ -134,98 +117,102 @@ const verifyCredentialToAccept = (args) => __awaiter(void 0, void 0, void 0, fun
         },
     });
     if (!verificationResult.result || verificationResult.error) {
-        return Promise.reject(Error((_m = verificationResult.error) !== null && _m !== void 0 ? _m : (0, Localization_1.translate)('oid4vci_machine_credential_verification_failed_message')));
+        return Promise.reject(Error(verificationResult.error ?? translate('oid4vci_machine_credential_verification_failed_message')));
     }
     return verificationResult;
-});
-exports.verifyCredentialToAccept = verifyCredentialToAccept;
-const mapCredentialToAccept = (args) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const mapCredentialToAccept = async (args) => {
     const { credentialToAccept, hasher } = args;
     const credentialResponse = credentialToAccept.credentialResponse;
     const verifiableCredential = credentialResponse.credential;
     if (!verifiableCredential) {
         return Promise.reject(Error('No credential found in credential response'));
     }
-    const wrappedVerifiableCredential = ssi_types_1.CredentialMapper.toWrappedVerifiableCredential(verifiableCredential, { hasher });
+    const wrappedVerifiableCredential = CredentialMapper.toWrappedVerifiableCredential(verifiableCredential, { hasher });
     let uniformVerifiableCredential;
-    if (ssi_types_1.CredentialMapper.isSdJwtDecodedCredential(wrappedVerifiableCredential.credential)) {
-        uniformVerifiableCredential = yield (0, ssi_types_1.sdJwtDecodedCredentialToUniformCredential)(wrappedVerifiableCredential.credential);
+    if (CredentialMapper.isSdJwtDecodedCredential(wrappedVerifiableCredential.credential)) {
+        uniformVerifiableCredential = await sdJwtDecodedCredentialToUniformCredential(wrappedVerifiableCredential.credential);
     }
-    else if (ssi_types_1.CredentialMapper.isSdJwtEncoded(wrappedVerifiableCredential.credential)) {
+    else if (CredentialMapper.isSdJwtEncoded(wrappedVerifiableCredential.credential)) {
         if (!hasher) {
             return Promise.reject('a hasher is required for encoded SD-JWT credentials');
         }
         const asyncHasher = (data, algorithm) => Promise.resolve(hasher(data, algorithm));
-        const decodedSdJwt = yield ssi_types_1.CredentialMapper.decodeSdJwtVcAsync(wrappedVerifiableCredential.credential, asyncHasher);
-        uniformVerifiableCredential = (0, ssi_types_1.sdJwtDecodedCredentialToUniformCredential)(decodedSdJwt);
+        const decodedSdJwt = await CredentialMapper.decodeSdJwtVcAsync(wrappedVerifiableCredential.credential, asyncHasher);
+        uniformVerifiableCredential = sdJwtDecodedCredentialToUniformCredential(decodedSdJwt);
     }
-    else if (ssi_types_1.CredentialMapper.isMsoMdocDecodedCredential(wrappedVerifiableCredential.credential)) {
-        uniformVerifiableCredential = (0, ssi_types_1.mdocDecodedCredentialToUniformCredential)(wrappedVerifiableCredential.credential);
+    else if (CredentialMapper.isMsoMdocDecodedCredential(wrappedVerifiableCredential.credential)) {
+        uniformVerifiableCredential = mdocDecodedCredentialToUniformCredential(wrappedVerifiableCredential.credential);
     }
     else {
         uniformVerifiableCredential = wrappedVerifiableCredential.credential;
     }
     const correlationId = typeof uniformVerifiableCredential.issuer === 'string'
         ? uniformVerifiableCredential.issuer
-        : ssi_types_1.CredentialMapper.isSdJwtDecodedCredential(uniformVerifiableCredential)
+        : CredentialMapper.isSdJwtDecodedCredential(uniformVerifiableCredential)
             ? uniformVerifiableCredential.decodedPayload.iss
             : uniformVerifiableCredential.issuer.id;
-    return Object.assign({ correlationId,
-        credentialToAccept, types: credentialToAccept.types, rawVerifiableCredential: verifiableCredential, uniformVerifiableCredential }, (credentialResponse.credential_subject_issuance && { credential_subject_issuance: credentialResponse.credential_subject_issuance }));
-});
-exports.mapCredentialToAccept = mapCredentialToAccept;
-const getIdentifierOpts = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    return {
+        correlationId,
+        credentialToAccept,
+        types: credentialToAccept.types,
+        rawVerifiableCredential: verifiableCredential,
+        uniformVerifiableCredential,
+        ...(credentialResponse.credential_subject_issuance && { credential_subject_issuance: credentialResponse.credential_subject_issuance }),
+    };
+};
+export const getIdentifierOpts = async (args) => {
     const { issuanceOpt, context } = args;
     const { identifier: identifierArg } = issuanceOpt;
-    if (identifierArg && (0, ssi_sdk_ext_identifier_resolution_1.isManagedIdentifierResult)(identifierArg)) {
+    if (identifierArg && isManagedIdentifierResult(identifierArg)) {
         return identifierArg;
     }
-    const { supportedPreferredDidMethod, supportedBindingMethods, keyType = 'Secp256r1', kms = yield context.agent.keyManagerGetDefaultKeyManagementSystem(), } = issuanceOpt;
+    const { supportedPreferredDidMethod, supportedBindingMethods, keyType = 'Secp256r1', kms = await context.agent.keyManagerGetDefaultKeyManagementSystem(), } = issuanceOpt;
     let identifier;
     if (identifierArg) {
-        if ((0, ssi_sdk_ext_identifier_resolution_1.isIIdentifier)(identifierArg.identifier)) {
-            identifier = yield context.agent.identifierManagedGet(identifierArg);
+        if (isIIdentifier(identifierArg.identifier)) {
+            identifier = await context.agent.identifierManagedGet(identifierArg);
         }
         else if (!identifierArg.method && issuanceOpt.supportedBindingMethods.includes('jwk')) {
-            identifier = yield (0, ssi_sdk_ext_identifier_resolution_1.managedIdentifierToJwk)(identifierArg, context);
+            identifier = await managedIdentifierToJwk(identifierArg, context);
         }
         else if (identifierArg.method && !supportedBindingMethods.includes(identifierArg.method)) {
             throw Error(`Supplied identifier method ${identifierArg.method} not supported by the issuer: ${supportedBindingMethods.join(',')}`);
         }
         else {
-            identifier = yield context.agent.identifierManagedGet(identifierArg);
+            identifier = await context.agent.identifierManagedGet(identifierArg);
         }
     }
-    const agentContext = Object.assign(Object.assign({}, context), { agent: context.agent });
-    if ((!identifierArg || (0, ssi_sdk_ext_identifier_resolution_1.isIIdentifier)(identifierArg.identifier)) &&
+    const agentContext = { ...context, agent: context.agent };
+    if ((!identifierArg || isIIdentifier(identifierArg.identifier)) &&
         supportedPreferredDidMethod &&
         (!supportedBindingMethods || supportedBindingMethods.length === 0 || supportedBindingMethods.filter((method) => method.startsWith('did')))) {
         // previous code for managing DIDs only
-        const { result, created } = yield (0, ssi_sdk_ext_did_utils_1.getOrCreatePrimaryIdentifier)(agentContext, {
+        const { result, created } = await getOrCreatePrimaryIdentifier(agentContext, {
             method: supportedPreferredDidMethod,
             createOpts: {
                 options: {
                     type: issuanceOpt.keyType,
-                    use: ssi_sdk_ext_did_resolver_jwk_1.KeyUse.Signature,
+                    use: KeyUse.Signature,
                     codecName: issuanceOpt.codecName,
                     kms: issuanceOpt.kms,
                 },
             },
         });
-        identifier = yield context.agent.identifierManagedGetByDid({
+        identifier = await context.agent.identifierManagedGetByDid({
             identifier: result,
             keyType,
             offlineWhenNoDIDRegistered: result.did.startsWith('did:ebsi:'),
         });
         if (created) {
-            yield agentContext.agent.emit(IOID4VCIHolder_1.OID4VCIHolderEvent.IDENTIFIER_CREATED, { identifier });
+            await agentContext.agent.emit(OID4VCIHolderEvent.IDENTIFIER_CREATED, { identifier });
         }
     }
     else if (supportedBindingMethods.includes('jwk')) {
         // todo: we probably should do something similar as with DIDs for re-use/new keys
-        const key = yield context.agent.keyManagerCreate({ type: keyType, kms, meta: { keyAlias: `key_${keyType}_${Date.now()}` } });
+        const key = await context.agent.keyManagerCreate({ type: keyType, kms, meta: { keyAlias: `key_${keyType}_${Date.now()}` } });
         // TODO. Create/move this to identifier service await agentContext.agent.emit(OID4VCIHolderEvent.IDENTIFIER_CREATED, { key })
-        identifier = yield (0, ssi_sdk_ext_identifier_resolution_1.managedIdentifierToJwk)({ method: 'key', identifier: key, kmsKeyRef: key.kid }, context);
+        identifier = await managedIdentifierToJwk({ method: 'key', identifier: key, kmsKeyRef: key.kid }, context);
         // } else if (supportedBindingMethods.includes('cose_key')) {
         //   // TODO COSE HERE
         //   throw Error(`Holder currently does not support binding method: ${supportedBindingMethods.join(',')}`)
@@ -235,40 +222,44 @@ const getIdentifierOpts = (args) => __awaiter(void 0, void 0, void 0, function*
     }
     args.issuanceOpt.identifier = identifier;
     return identifier;
-});
-exports.getIdentifierOpts = getIdentifierOpts;
-const getCredentialConfigsSupportedMerged = (args) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const getCredentialConfigsSupportedMerged = async (args) => {
     let result = {};
-    (yield (0, exports.getCredentialConfigsSupported)(args)).forEach((supported) => {
-        result = Object.assign(Object.assign({}, result), supported);
+    (await getCredentialConfigsSupported(args)).forEach((supported) => {
+        result = { ...result, ...supported };
     });
     return result;
-});
-exports.getCredentialConfigsSupportedMerged = getCredentialConfigsSupportedMerged;
-const getCredentialConfigsSupported = (args) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const getCredentialConfigsSupported = async (args) => {
     const { types, configurationIds } = args;
     if (Array.isArray(types) && types.length > 0) {
-        return Promise.all(types.map((type) => (0, exports.getCredentialConfigsSupportedBySingleTypeOrId)(Object.assign(Object.assign({}, args), { types: type }))));
+        return Promise.all(types.map((type) => getCredentialConfigsSupportedBySingleTypeOrId({ ...args, types: type })));
     }
     else if (Array.isArray(configurationIds) && configurationIds.length > 0) {
-        return Promise.all(configurationIds.map((configurationId) => (0, exports.getCredentialConfigsSupportedBySingleTypeOrId)(Object.assign(Object.assign({}, args), { configurationId, types: undefined }))));
-    }
-    const configs = yield (0, exports.getCredentialConfigsSupportedBySingleTypeOrId)(Object.assign(Object.assign({}, args), { types: undefined, configurationId: undefined }));
+        return Promise.all(configurationIds.map((configurationId) => getCredentialConfigsSupportedBySingleTypeOrId({
+            ...args,
+            configurationId,
+            types: undefined,
+        })));
+    }
+    const configs = await getCredentialConfigsSupportedBySingleTypeOrId({
+        ...args,
+        types: undefined,
+        configurationId: undefined,
+    });
     return configs && Object.keys(configs).length > 0 ? [configs] : [];
-});
-exports.getCredentialConfigsSupported = getCredentialConfigsSupported;
+};
 /**
  * Please note that this method only returns configs supported for a single set of credential types or a single config id.
  * If an offer contains multiple formats/types in an array or multiple config ids, you will have to call this method for all of them
  * @param args
  */
-const getCredentialConfigsSupportedBySingleTypeOrId = (args) => __awaiter(void 0, void 0, void 0, function* () {
+export const getCredentialConfigsSupportedBySingleTypeOrId = async (args) => {
     const { client, vcFormatPreferences, configurationId } = args;
     let { format = undefined, types = undefined } = args;
     function createIdFromTypes(supported) {
-        var _a, _b;
         const format = supported.format;
-        const type = (_b = (_a = (0, oid4vci_common_1.getTypesFromObject)(supported)) === null || _a === void 0 ? void 0 : _a.join()) !== null && _b !== void 0 ? _b : '';
+        const type = getTypesFromObject(supported)?.join() ?? '';
         const id = `${type}:${format}`;
         return id;
     }
@@ -283,18 +274,18 @@ const getCredentialConfigsSupportedBySingleTypeOrId = (args) => __awaiter(void 0
     }
     // We should always have a credential offer at this point given the above
     if (!Array.isArray(format) && client.credentialOffer) {
-        if (client.version() > oid4vci_common_1.OpenId4VCIVersion.VER_1_0_09 &&
+        if (client.version() > OpenId4VCIVersion.VER_1_0_09 &&
             typeof client.credentialOffer.credential_offer === 'object' &&
             'credentials' in client.credentialOffer.credential_offer) {
             format = client.credentialOffer.credential_offer.credentials
                 .filter((cred) => typeof cred !== 'string')
                 .map((cred) => cred.format);
-            if ((format === null || format === void 0 ? void 0 : format.length) === 0) {
+            if (format?.length === 0) {
                 format = undefined; // Otherwise we would match nothing
             }
         }
     }
-    const offerSupported = (0, oid4vci_common_1.getSupportedCredentials)({
+    const offerSupported = getSupportedCredentials({
         types: types ? [types] : client.getCredentialOfferTypes(),
         format,
         version: client.version(),
@@ -315,12 +306,12 @@ const getCredentialConfigsSupportedBySingleTypeOrId = (args) => __awaiter(void 0
             allSupported[id] = supported;
         });
     }
-    let credentialConfigsSupported = yield (0, exports.getCredentialConfigsBasedOnFormatPref)({
+    let credentialConfigsSupported = await getCredentialConfigsBasedOnFormatPref({
         credentials: allSupported,
         vcFormatPreferences,
     });
     if (!credentialConfigsSupported || Object.keys(credentialConfigsSupported).length === 0) {
-        oid4vci_client_1.LOG.warning(`No matching supported credential found for ${client.getIssuer()}`);
+        LOG.warning(`No matching supported credential found for ${client.getIssuer()}`);
     }
     if (client.credentialOffer === undefined) {
         return credentialConfigsSupported;
@@ -342,27 +333,25 @@ const getCredentialConfigsSupportedBySingleTypeOrId = (args) => __awaiter(void 0
         throw new Error(`No matching supported credential configs found for offer`);
     }
     return credentialsToOffer;
-});
-exports.getCredentialConfigsSupportedBySingleTypeOrId = getCredentialConfigsSupportedBySingleTypeOrId;
-const getIssuanceOpts = (args) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const getIssuanceOpts = async (args) => {
     const { client, credentialsSupported, 
     // serverMetadata,
     context, didMethodPreferences, jwtCryptographicSuitePreferences, jsonldCryptographicSuitePreferences, forceIssuanceOpt, } = args;
     if (credentialsSupported === undefined || Object.keys(credentialsSupported).length === 0) {
         return Promise.reject(Error('No credentials supported'));
     }
-    const getIssuanceOpts = Object.values(credentialsSupported).map((credentialSupported) => __awaiter(void 0, void 0, void 0, function* () {
+    const getIssuanceOpts = Object.values(credentialsSupported).map(async (credentialSupported) => {
         /*if (!serverMetadata?.credentialIssuerMetadata) {
           return await getDefaultIssuanceOpts({ credentialSupported, opts: { client }, context })
         }*/
-        var _a;
-        const cryptographicSuite = yield (0, exports.getIssuanceCryptoSuite)({
+        const cryptographicSuite = await getIssuanceCryptoSuite({
             credentialSupported,
             client,
             jwtCryptographicSuitePreferences,
             jsonldCryptographicSuitePreferences,
         });
-        const { didMethod, methods } = yield (0, exports.getIssuanceMethod)({
+        const { didMethod, methods } = await getIssuanceMethod({
             credentialSupported,
             client,
             didMethodPreferences,
@@ -372,19 +361,26 @@ const getIssuanceOpts = (args) => __awaiter(void 0, void 0, void 0, function* ()
             methods.push('did');
         }
         const issuanceOpt = forceIssuanceOpt
-            ? Object.assign(Object.assign({}, credentialSupported), forceIssuanceOpt) : Object.assign(Object.assign(Object.assign({}, credentialSupported), { supportedPreferredDidMethod: didMethod, supportedBindingMethods: methods, format: credentialSupported.format, keyType: client.isEBSI() ? 'Secp256r1' : (0, ssi_sdk_ext_key_utils_1.keyTypeFromCryptographicSuite)({ crv: cryptographicSuite }) }), (client.isEBSI() && { codecName: 'EBSI' }));
-        const identifier = yield (0, exports.getIdentifierOpts)({ issuanceOpt, context });
-        if (!client.clientId && (0, ssi_sdk_ext_identifier_resolution_1.isManagedIdentifierDidResult)(identifier)) {
+            ? { ...credentialSupported, ...forceIssuanceOpt }
+            : {
+                ...credentialSupported,
+                supportedPreferredDidMethod: didMethod,
+                supportedBindingMethods: methods,
+                format: credentialSupported.format,
+                keyType: client.isEBSI() ? 'Secp256r1' : keyTypeFromCryptographicSuite({ crv: cryptographicSuite }),
+                ...(client.isEBSI() && { codecName: 'EBSI' }),
+            };
+        const identifier = await getIdentifierOpts({ issuanceOpt, context });
+        if (!client.clientId && isManagedIdentifierDidResult(identifier)) {
             // FIXME: We really should fetch server metadata. Have user select required credentials. Take the first cred to determine a kid when no clientId is present and set that.
             //  Needs a preference service for crypto, keys, dids, and clientId, with ecosystem support
-            client.clientId = (_a = identifier.issuer) !== null && _a !== void 0 ? _a : identifier.did;
+            client.clientId = identifier.issuer ?? identifier.did;
         }
-        return Object.assign(Object.assign({}, issuanceOpt), { identifier });
-    }));
-    return yield Promise.all(getIssuanceOpts);
-});
-exports.getIssuanceOpts = getIssuanceOpts;
-const getIssuanceMethod = (opts) => __awaiter(void 0, void 0, void 0, function* () {
+        return { ...issuanceOpt, identifier };
+    });
+    return await Promise.all(getIssuanceOpts);
+};
+export const getIssuanceMethod = async (opts) => {
     const { client, credentialSupported, didMethodPreferences } = opts;
     const { format, cryptographic_binding_methods_supported } = credentialSupported;
     let methods = []; // we use the external identifier method, as we should be supporting all values in the server metadata anyway
@@ -403,21 +399,19 @@ const getIssuanceMethod = (opts) => __awaiter(void 0, void 0, void 0, function*
         console.warn(`We should have been able to determine cryptographic_binding_methods_supported, will fall back to legacy behaviour. This is likely a bug`);
     }
     if (client.isEBSI()) {
-        return { methods: ['did'], didMethod: ssi_sdk_ext_did_utils_1.SupportedDidMethodEnum.DID_KEY };
+        return { methods: ['did'], didMethod: SupportedDidMethodEnum.DID_KEY };
     }
     // legacy fallback
     methods = ['did'];
-    if (!format || (format.includes('jwt') && !(format === null || format === void 0 ? void 0 : format.includes('jwt_vc_json_ld')))) {
+    if (!format || (format.includes('jwt') && !format?.includes('jwt_vc_json_ld'))) {
         return { methods, didMethod: format ? didMethodPreferences[1] : didMethodPreferences[0] };
     }
     else {
         // JsonLD
         return { methods, didMethod: didMethodPreferences[0] };
     }
-});
-exports.getIssuanceMethod = getIssuanceMethod;
-const getIssuanceCryptoSuite = (opts) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
+};
+export const getIssuanceCryptoSuite = async (opts) => {
     const { client, credentialSupported, jwtCryptographicSuitePreferences, jsonldCryptographicSuitePreferences } = opts;
     let signing_algs_supported;
     if ('proof_types_supported' in credentialSupported && credentialSupported.proof_types_supported) {
@@ -436,9 +430,9 @@ const getIssuanceCryptoSuite = (opts) => __awaiter(void 0, void 0, void 0, funct
         }
     }
     else {
-        signing_algs_supported = (0, utils_1.asArray)(
+        signing_algs_supported = asArray(
         // @ts-ignore // legacy
-        (_b = (_a = credentialSupported.credential_signing_alg_values_supported) !== null && _a !== void 0 ? _a : credentialSupported.proof_signing_alg_values_supported) !== null && _b !== void 0 ? _b : []);
+        credentialSupported.credential_signing_alg_values_supported ?? credentialSupported.proof_signing_alg_values_supported ?? []);
     }
     // TODO: Return array, so the wallet/user could choose
     switch (credentialSupported.format) {
@@ -453,7 +447,7 @@ const getIssuanceCryptoSuite = (opts) => __awaiter(void 0, void 0, void 0, funct
                 return supportedPreferences[0];
             }
             else if (client.isEBSI()) {
-                return ssi_types_1.JoseSignatureAlgorithm.ES256;
+                return JoseSignatureAlgorithm.ES256;
             }
             // if we cannot find supported cryptographic suites, we just try with the first preference
             const fallback = jwtCryptographicSuitePreferences[0];
@@ -477,9 +471,8 @@ const getIssuanceCryptoSuite = (opts) => __awaiter(void 0, void 0, void 0, funct
         default:
             return Promise.reject(Error(`Credential format '${credentialSupported.format}' not supported`));
     }
-});
-exports.getIssuanceCryptoSuite = getIssuanceCryptoSuite;
-const startFirstPartApplicationMachine = (args, context) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const startFirstPartApplicationMachine = async (args, context) => {
     const { openID4VCIClientState, stateNavigationListener, contact } = args;
     if (!openID4VCIClientState) {
         return Promise.reject(Error('Missing openID4VCI client state in context'));
@@ -487,7 +480,7 @@ const startFirstPartApplicationMachine = (args, context) => __awaiter(void 0, vo
     if (!contact) {
         return Promise.reject(Error('Missing contact in context'));
     }
-    const firstPartyMachineInstance = firstPartyMachine_1.FirstPartyMachine.newInstance({
+    const firstPartyMachineInstance = FirstPartyMachine.newInstance({
         openID4VCIClientState,
         contact,
         agentContext: context,
@@ -496,20 +489,20 @@ const startFirstPartApplicationMachine = (args, context) => __awaiter(void 0, vo
     return new Promise((resolve, reject) => {
         try {
             firstPartyMachineInstance.onTransition((state) => {
-                if (state.matches(FirstPartyMachine_1.FirstPartyMachineStateTypes.done)) {
+                if (state.matches(FirstPartyMachineStateTypes.done)) {
                     const authorizationCodeResponse = state.context.authorizationCodeResponse;
                     if (!authorizationCodeResponse) {
                         reject(Error('No authorizationCodeResponse acquired'));
                     }
                     resolve(authorizationCodeResponse);
                 }
-                else if (state.matches(FirstPartyMachine_1.FirstPartyMachineStateTypes.aborted)) {
-                    resolve(FirstPartyMachine_1.FirstPartyMachineStateTypes.aborted);
+                else if (state.matches(FirstPartyMachineStateTypes.aborted)) {
+                    resolve(FirstPartyMachineStateTypes.aborted);
                 }
-                else if (state.matches(FirstPartyMachine_1.FirstPartyMachineStateTypes.declined)) {
-                    resolve(FirstPartyMachine_1.FirstPartyMachineStateTypes.declined);
+                else if (state.matches(FirstPartyMachineStateTypes.declined)) {
+                    resolve(FirstPartyMachineStateTypes.declined);
                 }
-                else if (state.matches(FirstPartyMachine_1.FirstPartyMachineStateTypes.error)) {
+                else if (state.matches(FirstPartyMachineStateTypes.error)) {
                     reject(state.context.error);
                 }
             });
@@ -519,6 +512,5 @@ const startFirstPartApplicationMachine = (args, context) => __awaiter(void 0, vo
             reject(error);
         }
     });
-});
-exports.startFirstPartApplicationMachine = startFirstPartApplicationMachine;
+};
 //# sourceMappingURL=OID4VCIHolderService.js.map