@sphereon/ssi-sdk.siopv2-oid4vp-op-auth 0.32.1-next.54 → 0.33.1-feature.vcdm2.4

package/dist/session/OpSession.js

@@ -1,59 +1,46 @@
-"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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpSession = void 0;
-const did_auth_siop_1 = require("@sphereon/did-auth-siop");
-const ssi_sdk_ext_did_utils_1 = require("@sphereon/ssi-sdk-ext.did-utils");
-const ssi_sdk_core_1 = require("@sphereon/ssi-sdk.core");
-const ssi_types_1 = require("@sphereon/ssi-types");
-const debug_1 = __importDefault(require("debug"));
-const uuid_1 = require("uuid");
-const functions_1 = require("./functions");
-const OID4VP_1 = require("./OID4VP");
-const pex_1 = require("@sphereon/pex");
-const debug = (0, debug_1.default)(`sphereon:sdk:siop:op-session`);
-class OpSession {
+import { OP, URI, } from '@sphereon/did-auth-siop';
+import { getAgentDIDMethods, getAgentResolver } from '@sphereon/ssi-sdk-ext.did-utils';
+import { encodeBase64url } from '@sphereon/ssi-sdk.core';
+import { CredentialMapper, parseDid, } from '@sphereon/ssi-types';
+import Debug from 'debug';
+import { v4 } from 'uuid';
+import { createOP } from './functions';
+import { OID4VP } from './OID4VP';
+import { PEX } from '@sphereon/pex';
+const debug = Debug(`sphereon:sdk:siop:op-session`);
+export class OpSession {
+    ts = new Date().getDate();
+    id;
+    options;
+    context;
+    requestJwtOrUri;
+    verifiedAuthorizationRequest;
+    _nonce;
+    _state;
+    _providedPresentationDefinitions;
     constructor(options) {
-        this.ts = new Date().getDate();
         this.id = options.sessionId;
         this.options = options.op;
         this.context = options.context;
         this.requestJwtOrUri = options.requestJwtOrUri;
         this._providedPresentationDefinitions = options.providedPresentationDefinitions;
     }
-    static init(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new OpSession(options);
-        });
+    static async init(options) {
+        return new OpSession(options);
     }
-    getAuthorizationRequest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.verifiedAuthorizationRequest) {
-                const op = yield (0, functions_1.createOP)({ opOptions: this.options, context: this.context });
-                this.verifiedAuthorizationRequest = yield op.verifyAuthorizationRequest(this.requestJwtOrUri);
-                this._nonce = yield this.verifiedAuthorizationRequest.authorizationRequest.getMergedProperty('nonce');
-                this._state = yield this.verifiedAuthorizationRequest.authorizationRequest.getMergedProperty('state');
-                // only used to ensure that we have DID methods supported
-                yield this.getSupportedDIDMethods();
-            }
-            return this.verifiedAuthorizationRequest;
-        });
+    async getAuthorizationRequest() {
+        if (!this.verifiedAuthorizationRequest) {
+            const op = await createOP({ opOptions: this.options, context: this.context });
+            this.verifiedAuthorizationRequest = await op.verifyAuthorizationRequest(this.requestJwtOrUri);
+            this._nonce = await this.verifiedAuthorizationRequest.authorizationRequest.getMergedProperty('nonce');
+            this._state = await this.verifiedAuthorizationRequest.authorizationRequest.getMergedProperty('state');
+            // only used to ensure that we have DID methods supported
+            await this.getSupportedDIDMethods();
+        }
+        return this.verifiedAuthorizationRequest;
     }
-    getAuthorizationRequestURI() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield did_auth_siop_1.URI.fromAuthorizationRequest((yield this.getAuthorizationRequest()).authorizationRequest);
-        });
+    async getAuthorizationRequestURI() {
+        return await URI.fromAuthorizationRequest((await this.getAuthorizationRequest()).authorizationRequest);
     }
     get nonce() {
         if (!this._nonce) {
@@ -73,289 +60,266 @@ class OpSession {
         this.verifiedAuthorizationRequest = undefined;
         return this;
     }
-    getSupportedDIDMethods(didPrefix) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const agentMethods = this.getAgentDIDMethodsSupported({ didPrefix });
-            let rpMethods = yield this.getRPDIDMethodsSupported({ didPrefix, agentMethods });
-            debug(`RP supports subject syntax types: ${JSON.stringify(this.getSubjectSyntaxTypesSupported())}`);
-            if (rpMethods.dids.length === 0) {
-                debug(`RP does not support DIDs. Supported: ${JSON.stringify(this.getSubjectSyntaxTypesSupported())}`);
-                return [];
-            }
-            let intersection;
-            if (rpMethods.dids.includes('did')) {
-                intersection =
-                    agentMethods && agentMethods.length > 0
-                        ? agentMethods
-                        : (yield (0, ssi_sdk_ext_did_utils_1.getAgentDIDMethods)(this.context)).map((method) => convertDidMethod(method, didPrefix)); // fallback to the agent in case the agent methods are undefined
-            }
-            else if (!agentMethods || agentMethods.length === 0) {
-                intersection = (_a = rpMethods.dids) === null || _a === void 0 ? void 0 : _a.map((method) => convertDidMethod(method, didPrefix));
-            }
-            else {
-                intersection = agentMethods.filter((value) => rpMethods.dids.includes(value));
-            }
-            if (intersection.length === 0) {
-                throw Error('No matching DID methods between agent and relying party');
-            }
-            return intersection.map((value) => convertDidMethod(value, didPrefix));
-        });
+    async getSupportedDIDMethods(didPrefix) {
+        const agentMethods = this.getAgentDIDMethodsSupported({ didPrefix });
+        let rpMethods = await this.getRPDIDMethodsSupported({ didPrefix, agentMethods });
+        debug(`RP supports subject syntax types: ${JSON.stringify(this.getSubjectSyntaxTypesSupported())}`);
+        if (rpMethods.dids.length === 0) {
+            debug(`RP does not support DIDs. Supported: ${JSON.stringify(this.getSubjectSyntaxTypesSupported())}`);
+            return [];
+        }
+        let intersection;
+        if (rpMethods.dids.includes('did')) {
+            intersection =
+                agentMethods && agentMethods.length > 0
+                    ? agentMethods
+                    : (await getAgentDIDMethods(this.context)).map((method) => convertDidMethod(method, didPrefix)); // fallback to the agent in case the agent methods are undefined
+        }
+        else if (!agentMethods || agentMethods.length === 0) {
+            intersection = rpMethods.dids?.map((method) => convertDidMethod(method, didPrefix));
+        }
+        else {
+            intersection = agentMethods.filter((value) => rpMethods.dids.includes(value));
+        }
+        if (intersection.length === 0) {
+            throw Error('No matching DID methods between agent and relying party');
+        }
+        return intersection.map((value) => convertDidMethod(value, didPrefix));
     }
     getAgentDIDMethodsSupported(opts) {
-        var _a;
-        const agentMethods = (_a = this.options.supportedDIDMethods) === null || _a === void 0 ? void 0 : _a.map((method) => convertDidMethod(method, opts.didPrefix));
+        const agentMethods = this.options.supportedDIDMethods?.map((method) => convertDidMethod(method, opts.didPrefix));
         debug(`agent methods: ${JSON.stringify(agentMethods)}`);
         return agentMethods;
     }
-    getSubjectSyntaxTypesSupported() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const authReq = yield this.getAuthorizationRequest();
-            const subjectSyntaxTypesSupported = (_a = authReq.registrationMetadataPayload) === null || _a === void 0 ? void 0 : _a.subject_syntax_types_supported;
-            return subjectSyntaxTypesSupported !== null && subjectSyntaxTypesSupported !== void 0 ? subjectSyntaxTypesSupported : [];
-        });
+    async getSubjectSyntaxTypesSupported() {
+        const authReq = await this.getAuthorizationRequest();
+        const subjectSyntaxTypesSupported = authReq.registrationMetadataPayload?.subject_syntax_types_supported;
+        return subjectSyntaxTypesSupported ?? [];
     }
-    getRPDIDMethodsSupported(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g;
-            let keyType;
-            const agentMethods = (_c = (_b = ((_a = opts.agentMethods) !== null && _a !== void 0 ? _a : this.getAgentDIDMethodsSupported(opts))) === null || _b === void 0 ? void 0 : _b.map((method) => convertDidMethod(method, opts.didPrefix))) !== null && _c !== void 0 ? _c : [];
-            debug(`agent methods supported: ${JSON.stringify(agentMethods)}`);
-            const authReq = yield this.getAuthorizationRequest();
-            const subjectSyntaxTypesSupported = (_e = (_d = authReq.registrationMetadataPayload) === null || _d === void 0 ? void 0 : _d.subject_syntax_types_supported) === null || _e === void 0 ? void 0 : _e.map((method) => convertDidMethod(method, opts.didPrefix)).filter((val) => !val.startsWith('did'));
-            debug(`subject syntax types supported in rp method supported: ${JSON.stringify(subjectSyntaxTypesSupported)}`);
-            const aud = yield authReq.authorizationRequest.getMergedProperty('aud');
-            let rpMethods = [];
-            if (aud && aud.startsWith('did:')) {
-                const didMethod = convertDidMethod((0, ssi_types_1.parseDid)(aud).method, opts.didPrefix);
-                debug(`aud did method: ${didMethod}`);
-                // The RP knows our DID, so we can use it to determine the supported DID methods
-                // If the aud did:method is not in the supported types, there still is something wrong, unless the RP signals to support all did methods
-                if (subjectSyntaxTypesSupported &&
-                    subjectSyntaxTypesSupported.length > 0 &&
-                    !subjectSyntaxTypesSupported.includes('did') &&
-                    !subjectSyntaxTypesSupported.includes(didMethod)) {
-                    throw Error(`The aud DID method ${didMethod} is not in the supported types ${subjectSyntaxTypesSupported}`);
-                }
-                rpMethods = [didMethod];
+    async getRPDIDMethodsSupported(opts) {
+        let keyType;
+        const agentMethods = (opts.agentMethods ?? this.getAgentDIDMethodsSupported(opts))?.map((method) => convertDidMethod(method, opts.didPrefix)) ?? [];
+        debug(`agent methods supported: ${JSON.stringify(agentMethods)}`);
+        const authReq = await this.getAuthorizationRequest();
+        const subjectSyntaxTypesSupported = authReq.registrationMetadataPayload?.subject_syntax_types_supported
+            ?.map((method) => convertDidMethod(method, opts.didPrefix))
+            .filter((val) => !val.startsWith('did'));
+        debug(`subject syntax types supported in rp method supported: ${JSON.stringify(subjectSyntaxTypesSupported)}`);
+        const aud = await authReq.authorizationRequest.getMergedProperty('aud');
+        let rpMethods = [];
+        if (aud && aud.startsWith('did:')) {
+            const didMethod = convertDidMethod(parseDid(aud).method, opts.didPrefix);
+            debug(`aud did method: ${didMethod}`);
+            // The RP knows our DID, so we can use it to determine the supported DID methods
+            // If the aud did:method is not in the supported types, there still is something wrong, unless the RP signals to support all did methods
+            if (subjectSyntaxTypesSupported &&
+                subjectSyntaxTypesSupported.length > 0 &&
+                !subjectSyntaxTypesSupported.includes('did') &&
+                !subjectSyntaxTypesSupported.includes(didMethod)) {
+                throw Error(`The aud DID method ${didMethod} is not in the supported types ${subjectSyntaxTypesSupported}`);
             }
-            else if (subjectSyntaxTypesSupported) {
-                rpMethods = (Array.isArray(subjectSyntaxTypesSupported) ? subjectSyntaxTypesSupported : [subjectSyntaxTypesSupported]).map((method) => convertDidMethod(method, opts.didPrefix));
-            }
-            const isEBSI = rpMethods.length === 0 &&
-                (((_f = authReq.issuer) === null || _f === void 0 ? void 0 : _f.includes('.ebsi.eu')) || ((_g = (yield authReq.authorizationRequest.getMergedProperty('client_id'))) === null || _g === void 0 ? void 0 : _g.includes('.ebsi.eu')));
-            let codecName = undefined;
-            if (isEBSI && (!aud || !aud.startsWith('http'))) {
-                debug(`EBSI detected, adding did:key to supported DID methods for RP`);
-                const didKeyMethod = convertDidMethod('did:key', opts.didPrefix);
-                if (!(agentMethods === null || agentMethods === void 0 ? void 0 : agentMethods.includes(didKeyMethod))) {
-                    throw Error(`EBSI detected, but agent did not support did:key. Please reconfigure agent`);
-                }
-                rpMethods = [didKeyMethod];
-                keyType = 'Secp256r1';
-                codecName = 'jwk_jcs-pub';
+            rpMethods = [didMethod];
+        }
+        else if (subjectSyntaxTypesSupported) {
+            rpMethods = (Array.isArray(subjectSyntaxTypesSupported) ? subjectSyntaxTypesSupported : [subjectSyntaxTypesSupported]).map((method) => convertDidMethod(method, opts.didPrefix));
+        }
+        const isEBSI = rpMethods.length === 0 &&
+            (authReq.issuer?.includes('.ebsi.eu') || (await authReq.authorizationRequest.getMergedProperty('client_id'))?.includes('.ebsi.eu'));
+        let codecName = undefined;
+        if (isEBSI && (!aud || !aud.startsWith('http'))) {
+            debug(`EBSI detected, adding did:key to supported DID methods for RP`);
+            const didKeyMethod = convertDidMethod('did:key', opts.didPrefix);
+            if (!agentMethods?.includes(didKeyMethod)) {
+                throw Error(`EBSI detected, but agent did not support did:key. Please reconfigure agent`);
             }
-            return { dids: rpMethods, codecName, keyType };
-        });
+            rpMethods = [didKeyMethod];
+            keyType = 'Secp256r1';
+            codecName = 'jwk_jcs-pub';
+        }
+        return { dids: rpMethods, codecName, keyType };
     }
-    getSupportedIdentifiers(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // todo: we also need to check signature algo
-            const methods = yield this.getSupportedDIDMethods(true);
-            debug(`supported DID methods (did: prefix = true): ${JSON.stringify(methods)}`);
-            if (methods.length === 0) {
-                throw Error(`No DID methods are supported`);
-            }
-            const identifiers = yield this.context.agent
-                .didManagerFind()
-                .then((ids) => ids.filter((id) => methods.includes(id.provider)));
-            if (identifiers.length === 0) {
-                debug(`No identifiers available in agent supporting methods ${JSON.stringify(methods)}`);
-                if ((opts === null || opts === void 0 ? void 0 : opts.createInCaseNoDIDFound) !== false) {
-                    const { codecName, keyType } = yield this.getRPDIDMethodsSupported({
-                        didPrefix: true,
-                        agentMethods: methods,
-                    });
-                    const identifier = yield this.context.agent.didManagerCreate({
-                        provider: methods[0],
-                        options: { codecName, keyType, type: keyType }, // both keyType and type, because not every did provider has the same param
-                    });
-                    debug(`Created a new identifier for the SIOP interaction: ${identifier.did}`);
-                    identifiers.push(identifier);
-                }
+    async getSupportedIdentifiers(opts) {
+        // todo: we also need to check signature algo
+        const methods = await this.getSupportedDIDMethods(true);
+        debug(`supported DID methods (did: prefix = true): ${JSON.stringify(methods)}`);
+        if (methods.length === 0) {
+            throw Error(`No DID methods are supported`);
+        }
+        const identifiers = await this.context.agent
+            .didManagerFind()
+            .then((ids) => ids.filter((id) => methods.includes(id.provider)));
+        if (identifiers.length === 0) {
+            debug(`No identifiers available in agent supporting methods ${JSON.stringify(methods)}`);
+            if (opts?.createInCaseNoDIDFound !== false) {
+                const { codecName, keyType } = await this.getRPDIDMethodsSupported({
+                    didPrefix: true,
+                    agentMethods: methods,
+                });
+                const identifier = await this.context.agent.didManagerCreate({
+                    provider: methods[0],
+                    options: { codecName, keyType, type: keyType }, // both keyType and type, because not every did provider has the same param
+                });
+                debug(`Created a new identifier for the SIOP interaction: ${identifier.did}`);
+                identifiers.push(identifier);
             }
-            debug(`supported identifiers: ${JSON.stringify(identifiers.map((id) => id.did))}`);
-            return identifiers;
-        });
+        }
+        debug(`supported identifiers: ${JSON.stringify(identifiers.map((id) => id.did))}`);
+        return identifiers;
     }
-    getSupportedDIDs() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.getSupportedIdentifiers()).map((id) => id.did);
-        });
+    async getSupportedDIDs() {
+        return (await this.getSupportedIdentifiers()).map((id) => id.did);
     }
-    getRedirectUri() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return Promise.resolve(this.verifiedAuthorizationRequest.responseURI);
-        });
+    async getRedirectUri() {
+        return Promise.resolve(this.verifiedAuthorizationRequest.responseURI);
     }
-    hasPresentationDefinitions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const defs = (_a = this._providedPresentationDefinitions) !== null && _a !== void 0 ? _a : (yield this.getAuthorizationRequest()).presentationDefinitions;
-            return defs !== undefined && defs.length > 0;
-        });
+    async hasPresentationDefinitions() {
+        const defs = this._providedPresentationDefinitions ?? (await this.getAuthorizationRequest()).presentationDefinitions;
+        return defs !== undefined && defs.length > 0;
     }
-    getPresentationDefinitions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (!(yield this.hasPresentationDefinitions())) {
-                throw Error(`No presentation definitions found`);
-            }
-            return (_a = this._providedPresentationDefinitions) !== null && _a !== void 0 ? _a : (yield this.getAuthorizationRequest()).presentationDefinitions;
-        });
+    async getPresentationDefinitions() {
+        if (!(await this.hasPresentationDefinitions())) {
+            throw Error(`No presentation definitions found`);
+        }
+        return this._providedPresentationDefinitions ?? (await this.getAuthorizationRequest()).presentationDefinitions;
     }
-    getOID4VP(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            return yield OID4VP_1.OID4VP.init(this, (_a = args.allIdentifiers) !== null && _a !== void 0 ? _a : [], args.hasher);
-        });
+    async getOID4VP(args) {
+        return await OID4VP.init(this, args.allIdentifiers ?? [], args.hasher);
     }
     createPresentationVerificationCallback(context) {
-        function presentationVerificationCallback(args, presentationSubmission) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let result;
-                if (ssi_types_1.CredentialMapper.isSdJwtEncoded(args)) {
-                    try {
-                        const sdJwtResult = yield context.agent.verifySdJwtPresentation({ presentation: args });
-                        result = {
-                            verified: 'header' in sdJwtResult,
-                            error: 'header' in sdJwtResult ? undefined : { message: 'could not verify SD JWT presentation' },
-                        };
-                    }
-                    catch (error) {
-                        result = {
-                            verified: false,
-                            error: { message: error.message },
-                        };
-                    }
+        async function presentationVerificationCallback(args, presentationSubmission) {
+            let result;
+            if (CredentialMapper.isSdJwtEncoded(args)) {
+                try {
+                    const sdJwtResult = await context.agent.verifySdJwtPresentation({ presentation: args });
+                    result = {
+                        verified: 'header' in sdJwtResult,
+                        error: 'header' in sdJwtResult ? undefined : { message: 'could not verify SD JWT presentation' },
+                    };
                 }
-                else {
-                    // @ts-ignore TODO IVerifiablePresentation has too many union types for Veramo
-                    result = yield context.agent.verifyPresentation({ presentation: args });
+                catch (error) {
+                    result = {
+                        verified: false,
+                        error: { message: error.message },
+                    };
                 }
-                return result;
-            });
+            }
+            else {
+                // @ts-ignore TODO IVerifiablePresentation has too many union types for Veramo
+                result = await context.agent.verifyPresentation({ presentation: args });
+            }
+            return result;
         }
         return presentationVerificationCallback;
     }
-    createJarmResponseCallback(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ responseOpts, }) {
-            const agent = this.context.agent;
-            return function jarmResponse(opts) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    var _a, _b;
-                    const { clientMetadata, requestObjectPayload, authorizationResponsePayload: authResponse } = opts;
-                    const jwk = yield did_auth_siop_1.OP.extractEncJwksFromClientMetadata(clientMetadata);
-                    // @ts-ignore // FIXME: Fix jwk inference
-                    const recipientKey = yield agent.identifierExternalResolveByJwk({ identifier: jwk });
-                    return yield agent
-                        .jwtEncryptJweCompactJwt({
-                        recipientKey,
-                        protectedHeader: {},
-                        alg: (_a = requestObjectPayload.client_metadata.authorization_encrypted_response_alg) !== null && _a !== void 0 ? _a : 'ECDH-ES',
-                        enc: (_b = requestObjectPayload.client_metadata.authorization_encrypted_response_enc) !== null && _b !== void 0 ? _b : 'A256GCM',
-                        apv: (0, ssi_sdk_core_1.encodeBase64url)(opts.requestObjectPayload.nonce),
-                        apu: (0, ssi_sdk_core_1.encodeBase64url)((0, uuid_1.v4)()),
-                        payload: authResponse,
-                        issuer: responseOpts.issuer,
-                        audience: responseOpts.audience,
-                    })
-                        .then((result) => {
-                        return { response: result.jwt };
-                    });
-                });
-            };
-        });
+    async createJarmResponseCallback({ responseOpts, }) {
+        const agent = this.context.agent;
+        return async function jarmResponse(opts) {
+            const { clientMetadata, requestObjectPayload, authorizationResponsePayload: authResponse } = opts;
+            const jwk = await OP.extractEncJwksFromClientMetadata(clientMetadata);
+            // @ts-ignore // FIXME: Fix jwk inference
+            const recipientKey = await agent.identifierExternalResolveByJwk({ identifier: jwk });
+            return await agent
+                .jwtEncryptJweCompactJwt({
+                recipientKey,
+                protectedHeader: {},
+                alg: requestObjectPayload.client_metadata.authorization_encrypted_response_alg ?? 'ECDH-ES',
+                enc: requestObjectPayload.client_metadata.authorization_encrypted_response_enc ?? 'A256GCM',
+                apv: encodeBase64url(opts.requestObjectPayload.nonce),
+                apu: encodeBase64url(v4()),
+                payload: authResponse,
+                issuer: responseOpts.issuer,
+                audience: responseOpts.audience,
+            })
+                .then((result) => {
+                return { response: result.jwt };
+            });
+        };
     }
-    sendAuthorizationResponse(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            const resolveOpts = (_a = this.options.resolveOpts) !== null && _a !== void 0 ? _a : {
-                resolver: (0, ssi_sdk_ext_did_utils_1.getAgentResolver)(this.context, {
-                    uniresolverResolution: true,
-                    localResolution: true,
-                    resolverResolution: true,
-                }),
-            };
-            if (!resolveOpts.subjectSyntaxTypesSupported || resolveOpts.subjectSyntaxTypesSupported.length === 0) {
-                resolveOpts.subjectSyntaxTypesSupported = yield this.getSupportedDIDMethods(true);
+    async sendAuthorizationResponse(args) {
+        const resolveOpts = this.options.resolveOpts ?? {
+            resolver: getAgentResolver(this.context, {
+                uniresolverResolution: true,
+                localResolution: true,
+                resolverResolution: true,
+            }),
+        };
+        if (!resolveOpts.subjectSyntaxTypesSupported || resolveOpts.subjectSyntaxTypesSupported.length === 0) {
+            resolveOpts.subjectSyntaxTypesSupported = await this.getSupportedDIDMethods(true);
+        }
+        //todo: populate with the right verification params. In did-auth-siop we don't have any test that actually passes this parameter
+        const verification = {
+            presentationVerificationCallback: this.createPresentationVerificationCallback(this.context),
+        };
+        const request = await this.getAuthorizationRequest();
+        const hasDefinitions = await this.hasPresentationDefinitions();
+        if (hasDefinitions) {
+            const totalInputDescriptors = request.presentationDefinitions?.reduce((sum, pd) => {
+                return sum + pd.definition.input_descriptors.length;
+            }, 0);
+            const totalVCs = args.verifiablePresentations ? this.countVCsInAllVPs(args.verifiablePresentations, args.hasher) : 0;
+            if (!request.presentationDefinitions || !args.verifiablePresentations || totalVCs !== totalInputDescriptors) {
+                throw Error(`Amount of presentations ${args.verifiablePresentations?.length}, doesn't match expected ${request.presentationDefinitions?.length}`);
             }
-            //todo: populate with the right verification params. In did-auth-siop we don't have any test that actually passes this parameter
-            const verification = {
-                presentationVerificationCallback: this.createPresentationVerificationCallback(this.context),
-            };
-            const request = yield this.getAuthorizationRequest();
-            const hasDefinitions = yield this.hasPresentationDefinitions();
-            if (hasDefinitions) {
-                const totalInputDescriptors = (_b = request.presentationDefinitions) === null || _b === void 0 ? void 0 : _b.reduce((sum, pd) => {
-                    return sum + pd.definition.input_descriptors.length;
-                }, 0);
-                const totalVCs = args.verifiablePresentations ? this.countVCsInAllVPs(args.verifiablePresentations, args.hasher) : 0;
-                if (!request.presentationDefinitions || !args.verifiablePresentations || totalVCs !== totalInputDescriptors) {
-                    throw Error(`Amount of presentations ${(_c = args.verifiablePresentations) === null || _c === void 0 ? void 0 : _c.length}, doesn't match expected ${(_d = request.presentationDefinitions) === null || _d === void 0 ? void 0 : _d.length}`);
-                }
-                else if (!args.presentationSubmission) {
-                    throw Error(`Presentation submission is required when verifiable presentations are required`);
-                }
+            else if (!args.presentationSubmission) {
+                throw Error(`Presentation submission is required when verifiable presentations are required`);
             }
-            const verifiablePresentations = args.verifiablePresentations
-                ? args.verifiablePresentations.map((vp) => ssi_types_1.CredentialMapper.storedPresentationToOriginalFormat(vp))
-                : [];
-            const op = yield (0, functions_1.createOP)({
-                opOptions: Object.assign(Object.assign({}, this.options), { resolveOpts: Object.assign({}, this.options.resolveOpts), eventEmitter: this.options.eventEmitter, presentationSignCallback: this.options.presentationSignCallback, wellknownDIDVerifyCallback: this.options.wellknownDIDVerifyCallback, supportedVersions: request.versions }),
-                idOpts: args.responseSignerOpts,
-                context: this.context,
-            });
-            //TODO change this to use the new functionalities by identifier-resolver and get the jwkIssuer for the responseOpts
-            let issuer = args.responseSignerOpts.issuer;
-            const responseOpts = Object.assign(Object.assign({ verification,
-                issuer }, (args.isFirstParty && { isFirstParty: args.isFirstParty })), (args.verifiablePresentations && {
+        }
+        const verifiablePresentations = args.verifiablePresentations
+            ? args.verifiablePresentations.map((vp) => CredentialMapper.storedPresentationToOriginalFormat(vp))
+            : [];
+        const op = await createOP({
+            opOptions: {
+                ...this.options,
+                resolveOpts: { ...this.options.resolveOpts },
+                eventEmitter: this.options.eventEmitter,
+                presentationSignCallback: this.options.presentationSignCallback,
+                wellknownDIDVerifyCallback: this.options.wellknownDIDVerifyCallback,
+                supportedVersions: request.versions,
+            },
+            idOpts: args.responseSignerOpts,
+            context: this.context,
+        });
+        //TODO change this to use the new functionalities by identifier-resolver and get the jwkIssuer for the responseOpts
+        let issuer = args.responseSignerOpts.issuer;
+        const responseOpts = {
+            verification,
+            issuer,
+            ...(args.isFirstParty && { isFirstParty: args.isFirstParty }),
+            ...(args.verifiablePresentations && {
                 presentationExchange: {
                     verifiablePresentations,
                     presentationSubmission: args.presentationSubmission,
                 },
-            }));
-            const authResponse = yield op.createAuthorizationResponse(request, responseOpts);
-            const response = yield op.submitAuthorizationResponse(authResponse, yield this.createJarmResponseCallback({ responseOpts }));
-            if (response.status >= 400) {
-                throw Error(`Error ${response.status}: ${response.statusText || (yield response.text())}`);
-            }
-            else {
-                return response;
-            }
-        });
+            }),
+            dcqlQuery: args.dcqlResponse,
+        };
+        const authResponse = await op.createAuthorizationResponse(request, responseOpts);
+        const response = await op.submitAuthorizationResponse(authResponse, await this.createJarmResponseCallback({ responseOpts }));
+        if (response.status >= 400) {
+            throw Error(`Error ${response.status}: ${response.statusText || (await response.text())}`);
+        }
+        else {
+            return response;
+        }
     }
     countVCsInAllVPs(verifiablePresentations, hasher) {
         return verifiablePresentations.reduce((sum, vp) => {
-            var _a, _b;
-            if (ssi_types_1.CredentialMapper.isMsoMdocDecodedPresentation(vp) || ssi_types_1.CredentialMapper.isMsoMdocOid4VPEncoded(vp)) {
+            if (CredentialMapper.isMsoMdocDecodedPresentation(vp) || CredentialMapper.isMsoMdocOid4VPEncoded(vp)) {
                 return sum + 1;
             }
-            const uvp = ssi_types_1.CredentialMapper.toUniformPresentation(vp, { hasher: hasher !== null && hasher !== void 0 ? hasher : this.options.hasher });
-            if ((_a = uvp.verifiableCredential) === null || _a === void 0 ? void 0 : _a.length) {
-                return sum + ((_b = uvp.verifiableCredential) === null || _b === void 0 ? void 0 : _b.length);
+            const uvp = CredentialMapper.toUniformPresentation(vp, { hasher: hasher ?? this.options.hasher });
+            if (uvp.verifiableCredential?.length) {
+                return sum + uvp.verifiableCredential?.length;
             }
-            const isSdJWT = ssi_types_1.CredentialMapper.isSdJwtDecodedCredential(uvp);
+            const isSdJWT = CredentialMapper.isSdJwtDecodedCredential(uvp);
             if (isSdJWT ||
-                (uvp.verifiableCredential && !pex_1.PEX.allowMultipleVCsPerPresentation(uvp.verifiableCredential))) {
+                (uvp.verifiableCredential && !PEX.allowMultipleVCsPerPresentation(uvp.verifiableCredential))) {
                 return sum + 1;
             }
             return sum;
         }, 0);
     }
 }
-exports.OpSession = OpSession;
 function convertDidMethod(didMethod, didPrefix) {
     if (didPrefix === false) {
         return didMethod.startsWith('did:') ? didMethod.toLowerCase().replace('did:', '') : didMethod.toLowerCase();