@0xpolygonid/js-sdk 1.25.1 → 1.27.0

package/dist/node/cjs/iden3comm/constants.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_AUTH_VERIFY_DELAY = exports.DEFAULT_PROOF_VERIFY_DELAY = exports.defaultAcceptProfile = exports.AcceptJwsAlgorithms = exports.AcceptJwzAlgorithms = exports.AcceptAuthCircuits = exports.ProtocolVersion = exports.SUPPORTED_PUBLIC_KEY_TYPES = exports.MediaType = exports.PROTOCOL_MESSAGE_TYPE = void 0;
 const IDEN3_PROTOCOL = 'https://iden3-communication.io/';
+const DIDCOMM_PROTOCOL = 'https://didcomm.org/';
 /**
  * Constants for Iden3 protocol
  */
@@ -45,7 +46,11 @@ exports.PROTOCOL_MESSAGE_TYPE = Object.freeze({
     // PaymentRequestMessageType is type for payment-request message
     PAYMENT_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment-request`,
     // PaymentMessageType is type for payment message
-    PAYMENT_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment`
+    PAYMENT_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment`,
+    // DiscoveryProtocolQueriesMessageType is type for didcomm discovery protocol queries
+    DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/queries`,
+    // DiscoveryProtocolDiscloseMessageType is type for didcomm discovery protocol disclose
+    DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/disclose`
 });
 /**
  * Media types for iden3 comm communication protocol

package/dist/node/cjs/iden3comm/handlers/auth.js

@@ -287,32 +287,24 @@ class AuthHandler extends message_handler_1.AbstractMessageHandler {
     }
     getSupportedMediaTypeByProfile(ctx, responseType, profile) {
         let mediaType;
-        if (profile?.length) {
-            const supportedMediaTypes = [];
-            for (const acceptProfile of profile) {
-                // 1. check protocol version
-                const { protocolVersion, env } = (0, utils_2.parseAcceptProfile)(acceptProfile);
-                const responseTypeVersion = Number(responseType.split('/').at(-2));
-                if (protocolVersion !== constants_1.ProtocolVersion.V1 ||
-                    (protocolVersion === constants_1.ProtocolVersion.V1 &&
-                        (responseTypeVersion < 1 || responseTypeVersion >= 2))) {
-                    continue;
-                }
-                // 2. check packer support
-                if (this._packerMgr.isProfileSupported(env, acceptProfile)) {
-                    supportedMediaTypes.push(env);
-                }
-            }
-            if (!supportedMediaTypes.length) {
-                throw new Error('no packer with profile which meets `accept` header requirements');
-            }
-            mediaType = supportedMediaTypes[0];
-            if (ctx.mediaType && supportedMediaTypes.includes(ctx.mediaType)) {
-                mediaType = ctx.mediaType;
+        if (!profile?.length) {
+            return ctx.mediaType || constants_1.MediaType.ZKPMessage;
+        }
+        const supportedMediaTypes = [];
+        for (const acceptProfile of profile) {
+            const { env } = (0, utils_2.parseAcceptProfile)(acceptProfile);
+            if (this._packerMgr.isProfileSupported(env, acceptProfile)) {
+                supportedMediaTypes.push(env);
             }
         }
-        else {
-            mediaType = ctx.mediaType || constants_1.MediaType.ZKPMessage;
+        if (!supportedMediaTypes.length) {
+            throw new Error('no packer with profile which meets `accept` header requirements');
+        }
+        mediaType = supportedMediaTypes.includes(constants_1.MediaType.ZKPMessage)
+            ? constants_1.MediaType.ZKPMessage
+            : supportedMediaTypes[0];
+        if (ctx.mediaType && supportedMediaTypes.includes(ctx.mediaType)) {
+            mediaType = ctx.mediaType;
         }
         return mediaType;
     }

package/dist/node/cjs/iden3comm/handlers/discovery-protocol.js

@@ -0,0 +1,198 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryProtocolHandler = exports.createDiscoveryFeatureDiscloseMessage = exports.createDiscoveryFeatureQueryMessage = void 0;
+const constants_1 = require("../constants");
+const uuid = __importStar(require("uuid"));
+const discovery_protocol_1 = require("../types/protocol/discovery-protocol");
+const message_handler_1 = require("./message-handler");
+const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const common_1 = require("./common");
+/**
+ * @beta
+ * createDiscoveryFeatureQueryMessage is a function to create didcomm protocol discovery-feature query message
+ * @param opts - discovery-feature query options
+ * @returns `DiscoverFeatureQueriesMessage`
+ */
+function createDiscoveryFeatureQueryMessage(queries, opts) {
+    const uuidv4 = uuid.v4();
+    return {
+        id: uuidv4,
+        thid: uuidv4,
+        typ: constants_1.MediaType.PlainMessage,
+        type: constants_1.PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE,
+        body: {
+            queries
+        },
+        from: opts?.from,
+        to: opts?.to,
+        created_time: (0, js_iden3_core_1.getUnixTimestamp)(new Date()),
+        expires_time: opts?.expires_time
+    };
+}
+exports.createDiscoveryFeatureQueryMessage = createDiscoveryFeatureQueryMessage;
+/**
+ * @beta
+ * createDiscoveryFeatureDiscloseMessage is a function to create didcomm protocol discovery-feature disclose message
+ * @param {DiscoverFeatureDisclosure[]} disclosures - array of disclosures
+ * @param opts - basic message options
+ * @returns `DiscoverFeatureQueriesMessage`
+ */
+function createDiscoveryFeatureDiscloseMessage(disclosures, opts) {
+    const uuidv4 = uuid.v4();
+    return {
+        id: uuidv4,
+        typ: constants_1.MediaType.PlainMessage,
+        thid: uuidv4,
+        type: constants_1.PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE,
+        body: {
+            disclosures
+        },
+        from: opts?.from,
+        to: opts?.to,
+        created_time: (0, js_iden3_core_1.getUnixTimestamp)(new Date()),
+        expires_time: opts?.expires_time
+    };
+}
+exports.createDiscoveryFeatureDiscloseMessage = createDiscoveryFeatureDiscloseMessage;
+/**
+ *
+ * Handler for discovery protocol
+ *
+ * @public
+ * @beta
+ * @class DiscoveryProtocolHandler
+ * @implements implements DiscoveryProtocolHandler interface
+ */
+class DiscoveryProtocolHandler extends message_handler_1.AbstractMessageHandler {
+    /**
+     * Creates an instance of DiscoveryProtocolHandler.
+     * @param {DiscoveryProtocolOptions} _options - discovery protocol options
+     */
+    constructor(_options) {
+        super();
+        this._options = _options;
+        const headers = [
+            'id',
+            'typ',
+            'type',
+            'thid',
+            'body',
+            'from',
+            'to',
+            'created_time',
+            'expires_time'
+        ];
+        if (!_options.headers) {
+            _options.headers = headers;
+        }
+    }
+    /**
+     * @inheritdoc IProtocolMessageHandler#handle
+     */
+    async handle(message, context) {
+        switch (message.type) {
+            case constants_1.PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE:
+                return await this.handleDiscoveryQuery(message, context);
+            default:
+                return super.handle(message, context);
+        }
+    }
+    /**
+     * @inheritdoc IDiscoveryProtocolHandler#handleDiscoveryQuery
+     */
+    async handleDiscoveryQuery(message, opts) {
+        if (!opts?.allowExpiredMessages) {
+            (0, common_1.verifyExpiresTime)(message);
+        }
+        const disclosures = [];
+        for (const query of message.body.queries) {
+            disclosures.push(...this.handleQuery(query));
+        }
+        return Promise.resolve(createDiscoveryFeatureDiscloseMessage(disclosures, {
+            to: message.from,
+            from: message.to,
+            expires_time: opts?.disclosureExpiresDate
+                ? (0, js_iden3_core_1.getUnixTimestamp)(opts.disclosureExpiresDate)
+                : undefined
+        }));
+    }
+    handleQuery(query) {
+        let result = [];
+        switch (query[discovery_protocol_1.DiscoverFeatureQueryType.FeatureType]) {
+            case discovery_protocol_1.DiscoveryProtocolFeatureType.Accept:
+                result = this.handleAcceptQuery();
+                break;
+            case discovery_protocol_1.DiscoveryProtocolFeatureType.Protocol:
+                result = this.handleProtocolQuery();
+                break;
+            case discovery_protocol_1.DiscoveryProtocolFeatureType.GoalCode:
+                result = this.handleGoalCodeQuery();
+                break;
+            case discovery_protocol_1.DiscoveryProtocolFeatureType.Header:
+                result = this.handleHeaderQuery();
+                break;
+        }
+        return this.handleMatch(result, query.match);
+    }
+    handleAcceptQuery() {
+        const acceptProfiles = this._options.packageManager.getSupportedProfiles();
+        return acceptProfiles.map((profile) => ({
+            [discovery_protocol_1.DiscoverFeatureQueryType.FeatureType]: discovery_protocol_1.DiscoveryProtocolFeatureType.Accept,
+            id: profile
+        }));
+    }
+    handleProtocolQuery() {
+        return (this._options.protocols?.map((protocol) => ({
+            [discovery_protocol_1.DiscoverFeatureQueryType.FeatureType]: discovery_protocol_1.DiscoveryProtocolFeatureType.Protocol,
+            id: protocol
+        })) ?? []);
+    }
+    handleGoalCodeQuery() {
+        return (this._options.goalCodes?.map((goalCode) => ({
+            [discovery_protocol_1.DiscoverFeatureQueryType.FeatureType]: discovery_protocol_1.DiscoveryProtocolFeatureType.GoalCode,
+            id: goalCode
+        })) ?? []);
+    }
+    handleHeaderQuery() {
+        return (this._options.headers?.map((header) => ({
+            [discovery_protocol_1.DiscoverFeatureQueryType.FeatureType]: discovery_protocol_1.DiscoveryProtocolFeatureType.Header,
+            id: header
+        })) ?? []);
+    }
+    handleMatch(disclosures, match) {
+        if (!match || match === '*') {
+            return disclosures;
+        }
+        const regExp = this.wildcardToRegExp(match);
+        return disclosures.filter((disclosure) => regExp.test(disclosure.id));
+    }
+    wildcardToRegExp(match) {
+        // Escape special regex characters, then replace `*` with `.*`
+        const regexPattern = match.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+        return new RegExp(`^${regexPattern}$`);
+    }
+}
+exports.DiscoveryProtocolHandler = DiscoveryProtocolHandler;

package/dist/node/cjs/iden3comm/handlers/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./common"), exports);
 __exportStar(require("./credential-proposal"), exports);
 __exportStar(require("./message-handler"), exports);
 __exportStar(require("./payment"), exports);
+__exportStar(require("./discovery-protocol"), exports);

package/dist/node/cjs/iden3comm/packageManager.js

@@ -18,6 +18,18 @@ class PackageManager {
     constructor() {
         this.packers = new Map();
     }
+    /** {@inheritDoc IPackageManager.getSupportedProfiles} */
+    getSupportedProfiles() {
+        const acceptProfiles = [];
+        const mediaTypes = this.getSupportedMediaTypes();
+        for (const mediaType of mediaTypes) {
+            const p = this.packers.get(mediaType);
+            if (p) {
+                acceptProfiles.push(...p.getSupportedProfiles());
+            }
+        }
+        return [...new Set(acceptProfiles)];
+    }
     /** {@inheritDoc IPackageManager.isProfileSupported} */
     isProfileSupported(mediaType, profile) {
         const p = this.packers.get(mediaType);

package/dist/node/cjs/iden3comm/packers/jws.js

@@ -27,6 +27,8 @@ class JWSPacker {
     constructor(_kms, _documentResolver) {
         this._kms = _kms;
         this._documentResolver = _documentResolver;
+        this.supportedAlgorithms = [constants_1.AcceptJwsAlgorithms.ES256K, constants_1.AcceptJwsAlgorithms.ES256KR];
+        this.supportedProtocolVersions = [constants_1.ProtocolVersion.V1];
     }
     /**
      * Packs the given payload and returns a promise that resolves to the packed data.
@@ -89,24 +91,23 @@ class JWSPacker {
     }
     /** {@inheritDoc IPacker.getSupportedProfiles} */
     getSupportedProfiles() {
-        return [`env=${this.mediaType()}&alg=${this.getSupportedAlgorithms().join(',')}`];
+        return this.supportedProtocolVersions.map((v) => `${v};env=${this.mediaType()};alg=${this.supportedAlgorithms.join(',')}`);
     }
     /** {@inheritDoc IPacker.isProfileSupported} */
     isProfileSupported(profile) {
-        const { env, circuits, alg } = (0, utils_2.parseAcceptProfile)(profile);
+        const { protocolVersion, env, circuits, alg } = (0, utils_2.parseAcceptProfile)(profile);
+        if (!this.supportedProtocolVersions.includes(protocolVersion)) {
+            return false;
+        }
         if (env !== this.mediaType()) {
             return false;
         }
         if (circuits) {
             throw new Error(`Circuits are not supported for ${env} media type`);
         }
-        const supportedAlgArr = this.getSupportedAlgorithms();
-        const algSupported = !alg?.length || alg.some((a) => supportedAlgArr.includes(a));
+        const algSupported = !alg?.length || alg.some((a) => this.supportedAlgorithms.includes(a));
         return algSupported;
     }
-    getSupportedAlgorithms() {
-        return [constants_1.AcceptJwsAlgorithms.ES256K, constants_1.AcceptJwsAlgorithms.ES256KR];
-    }
     async resolveDidDoc(from) {
         let didDocument;
         try {

package/dist/node/cjs/iden3comm/packers/plain.js

@@ -12,6 +12,9 @@ const utils_2 = require("../utils");
  * @implements implements IPacker interface
  */
 class PlainPacker {
+    constructor() {
+        this.supportedProtocolVersions = [constants_1.ProtocolVersion.V1];
+    }
     /**
      * Packs a basic message using the specified parameters.
      *
@@ -55,11 +58,14 @@ class PlainPacker {
     }
     /** {@inheritDoc IPacker.getSupportedProfiles} */
     getSupportedProfiles() {
-        return [`env=${this.mediaType()}`];
+        return this.supportedProtocolVersions.map((v) => `${v};env=${this.mediaType()}`);
     }
     /** {@inheritDoc IPacker.isProfileSupported} */
     isProfileSupported(profile) {
-        const { env, circuits, alg } = (0, utils_2.parseAcceptProfile)(profile);
+        const { protocolVersion, env, circuits, alg } = (0, utils_2.parseAcceptProfile)(profile);
+        if (!this.supportedProtocolVersions.includes(protocolVersion)) {
+            return false;
+        }
         if (env !== this.mediaType()) {
             return false;
         }

package/dist/node/cjs/iden3comm/packers/zkp.js

@@ -83,6 +83,9 @@ class ZKPPacker {
         this.provingParamsMap = provingParamsMap;
         this.verificationParamsMap = verificationParamsMap;
         this._opts = _opts;
+        this.supportedProtocolVersions = [constants_1.ProtocolVersion.V1];
+        this.supportedAlgorithms = [constants_1.AcceptJwzAlgorithms.Groth16];
+        this.supportedCircuitIds = [constants_1.AcceptAuthCircuits.AuthV2];
     }
     /**
      * Packs a basic message using the specified parameters.
@@ -144,28 +147,23 @@ class ZKPPacker {
     }
     /** {@inheritDoc IPacker.getSupportedProfiles} */
     getSupportedProfiles() {
-        return [
-            `env=${this.mediaType()}&alg=${this.getSupportedAlgorithms().join(',')}&circuitIds=${this.getSupportedCircuitIds().join(',')}`
-        ];
+        return this.supportedProtocolVersions.map((v) => `${v};env=${this.mediaType()};alg=${this.supportedAlgorithms.join(',')};circuitIds=${this.supportedCircuitIds.join(',')}`);
     }
     /** {@inheritDoc IPacker.isProfileSupported} */
     isProfileSupported(profile) {
-        const { env, circuits, alg } = (0, utils_2.parseAcceptProfile)(profile);
+        const { protocolVersion, env, circuits, alg } = (0, utils_2.parseAcceptProfile)(profile);
+        if (!this.supportedProtocolVersions.includes(protocolVersion)) {
+            return false;
+        }
         if (env !== this.mediaType()) {
             return false;
         }
-        const supportedCircuitIds = this.getSupportedCircuitIds();
+        const supportedCircuitIds = this.supportedCircuitIds;
         const circuitIdSupported = !circuits?.length || circuits.some((c) => supportedCircuitIds.includes(c));
-        const supportedAlgArr = this.getSupportedAlgorithms();
+        const supportedAlgArr = this.supportedAlgorithms;
         const algSupported = !alg?.length || alg.some((a) => supportedAlgArr.includes(a));
         return algSupported && circuitIdSupported;
     }
-    getSupportedAlgorithms() {
-        return [constants_1.AcceptJwzAlgorithms.Groth16];
-    }
-    getSupportedCircuitIds() {
-        return [constants_1.AcceptAuthCircuits.AuthV2];
-    }
 }
 exports.ZKPPacker = ZKPPacker;
 const verifySender = async (token, msg) => {

package/dist/node/cjs/iden3comm/types/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./protocol/contract-request"), exports);
 __exportStar(require("./protocol/proposal-request"), exports);
 __exportStar(require("./protocol/payment"), exports);
 __exportStar(require("./protocol/accept-profile"), exports);
+__exportStar(require("./protocol/discovery-protocol"), exports);
 __exportStar(require("./packer"), exports);
 __exportStar(require("./models"), exports);
 __exportStar(require("./packageManager"), exports);

package/dist/node/cjs/iden3comm/types/protocol/discovery-protocol.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryProtocolFeatureType = exports.DiscoverFeatureQueryType = void 0;
+/** @beta DiscoverFeatureQueryType is enum for query type fields */
+var DiscoverFeatureQueryType;
+(function (DiscoverFeatureQueryType) {
+    DiscoverFeatureQueryType["FeatureType"] = "feature-type";
+})(DiscoverFeatureQueryType = exports.DiscoverFeatureQueryType || (exports.DiscoverFeatureQueryType = {}));
+/** @beta DiscoveryProtocolFeatureType is enum for supported feature-types */
+var DiscoveryProtocolFeatureType;
+(function (DiscoveryProtocolFeatureType) {
+    DiscoveryProtocolFeatureType["Accept"] = "accept";
+    DiscoveryProtocolFeatureType["Protocol"] = "protocol";
+    DiscoveryProtocolFeatureType["GoalCode"] = "goal-code";
+    DiscoveryProtocolFeatureType["Header"] = "header";
+})(DiscoveryProtocolFeatureType = exports.DiscoveryProtocolFeatureType || (exports.DiscoveryProtocolFeatureType = {}));

package/dist/node/esm/iden3comm/constants.js

@@ -1,4 +1,5 @@
 const IDEN3_PROTOCOL = 'https://iden3-communication.io/';
+const DIDCOMM_PROTOCOL = 'https://didcomm.org/';
 /**
  * Constants for Iden3 protocol
  */
@@ -42,7 +43,11 @@ export const PROTOCOL_MESSAGE_TYPE = Object.freeze({
     // PaymentRequestMessageType is type for payment-request message
     PAYMENT_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment-request`,
     // PaymentMessageType is type for payment message
-    PAYMENT_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment`
+    PAYMENT_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment`,
+    // DiscoveryProtocolQueriesMessageType is type for didcomm discovery protocol queries
+    DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/queries`,
+    // DiscoveryProtocolDiscloseMessageType is type for didcomm discovery protocol disclose
+    DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/disclose`
 });
 /**
  * Media types for iden3 comm communication protocol

package/dist/node/esm/iden3comm/handlers/auth.js

@@ -1,4 +1,4 @@
-import { MediaType, ProtocolVersion } from '../constants';
+import { MediaType } from '../constants';
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
 import { DID, getUnixTimestamp } from '@iden3/js-iden3-core';
 import { proving } from '@iden3/js-jwz';
@@ -259,32 +259,24 @@ export class AuthHandler extends AbstractMessageHandler {
     }
     getSupportedMediaTypeByProfile(ctx, responseType, profile) {
         let mediaType;
-        if (profile?.length) {
-            const supportedMediaTypes = [];
-            for (const acceptProfile of profile) {
-                // 1. check protocol version
-                const { protocolVersion, env } = parseAcceptProfile(acceptProfile);
-                const responseTypeVersion = Number(responseType.split('/').at(-2));
-                if (protocolVersion !== ProtocolVersion.V1 ||
-                    (protocolVersion === ProtocolVersion.V1 &&
-                        (responseTypeVersion < 1 || responseTypeVersion >= 2))) {
-                    continue;
-                }
-                // 2. check packer support
-                if (this._packerMgr.isProfileSupported(env, acceptProfile)) {
-                    supportedMediaTypes.push(env);
-                }
-            }
-            if (!supportedMediaTypes.length) {
-                throw new Error('no packer with profile which meets `accept` header requirements');
-            }
-            mediaType = supportedMediaTypes[0];
-            if (ctx.mediaType && supportedMediaTypes.includes(ctx.mediaType)) {
-                mediaType = ctx.mediaType;
+        if (!profile?.length) {
+            return ctx.mediaType || MediaType.ZKPMessage;
+        }
+        const supportedMediaTypes = [];
+        for (const acceptProfile of profile) {
+            const { env } = parseAcceptProfile(acceptProfile);
+            if (this._packerMgr.isProfileSupported(env, acceptProfile)) {
+                supportedMediaTypes.push(env);
             }
         }
-        else {
-            mediaType = ctx.mediaType || MediaType.ZKPMessage;
+        if (!supportedMediaTypes.length) {
+            throw new Error('no packer with profile which meets `accept` header requirements');
+        }
+        mediaType = supportedMediaTypes.includes(MediaType.ZKPMessage)
+            ? MediaType.ZKPMessage
+            : supportedMediaTypes[0];
+        if (ctx.mediaType && supportedMediaTypes.includes(ctx.mediaType)) {
+            mediaType = ctx.mediaType;
         }
         return mediaType;
     }