@0xpolygonid/js-sdk 1.24.1 → 1.26.0

package/dist/node/cjs/circuits/auth-v2.js

@@ -92,5 +92,11 @@ class AuthV2PubSignals {
         this.GISTRoot = js_merkletree_1.Hash.fromString(sVals[2]);
         return this;
     }
+    getStatesInfo() {
+        return {
+            states: [],
+            gists: [{ id: this.userID, root: this.GISTRoot }]
+        };
+    }
 }
 exports.AuthV2PubSignals = AuthV2PubSignals;

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/contract-request.js

@@ -30,6 +30,7 @@ class ContractRequestHandler extends message_handler_1.AbstractMessageHandler {
         this._proofService = _proofService;
         this._zkpVerifier = _zkpVerifier;
         this._supportedCircuits = [
+            models_1.CircuitId.AuthV2,
             models_1.CircuitId.AtomicQueryMTPV2OnChain,
             models_1.CircuitId.AtomicQuerySigV2OnChain,
             models_1.CircuitId.AtomicQueryV3OnChain
@@ -60,7 +61,12 @@ class ContractRequestHandler extends message_handler_1.AbstractMessageHandler {
             throw new Error(`Invalid chain id ${chain_id}`);
         }
         const verifierDid = message.from ? js_iden3_core_1.DID.parse(message.from) : undefined;
-        const zkpResponses = await (0, common_1.processZeroKnowledgeProofRequests)(did, message?.body?.scope, verifierDid, this._proofService, { ethSigner, challenge, supportedCircuits: this._supportedCircuits });
+        const { scope = [] } = message.body;
+        const zkpResponses = await (0, common_1.processZeroKnowledgeProofRequests)(did, scope, verifierDid, this._proofService, {
+            ethSigner,
+            challenge,
+            supportedCircuits: this._supportedCircuits
+        });
         const methodId = message.body.transaction_data.method_id.replace('0x', '');
         switch (methodId) {
             case storage_1.FunctionSignatures.SubmitZKPResponseV2:

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/handlers/payment.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaymentHandler = exports.createPayment = exports.convertPaymentAmount = exports.verifyEIP712TypedData = exports.createPaymentRequest = void 0;
+exports.PaymentHandler = exports.createPayment = exports.verifyEIP712TypedData = exports.createPaymentRequest = void 0;
 const constants_1 = require("../constants");
 const constants_2 = require("../constants");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
@@ -63,11 +63,10 @@ function createPaymentRequest(sender, receiver, agent, payments, opts) {
 }
 exports.createPaymentRequest = createPaymentRequest;
 async function verifyEIP712TypedData(data, resolver) {
-    const convertedAmount = await convertPaymentAmount(data.amount, data.currency);
     const paymentData = data.type === verifiable_1.PaymentRequestDataType.Iden3PaymentRailsRequestV1
         ? {
             recipient: data.recipient,
-            amount: convertedAmount,
+            amount: data.amount,
             expirationDate: (0, js_iden3_core_1.getUnixTimestamp)(new Date(data.expirationDate)),
             nonce: data.nonce,
             metadata: '0x'
@@ -75,7 +74,7 @@ async function verifyEIP712TypedData(data, resolver) {
         : {
             tokenAddress: data.tokenAddress,
             recipient: data.recipient,
-            amount: convertedAmount,
+            amount: data.amount,
             expirationDate: (0, js_iden3_core_1.getUnixTimestamp)(new Date(data.expirationDate)),
             nonce: data.nonce,
             metadata: '0x'
@@ -100,31 +99,6 @@ async function verifyEIP712TypedData(data, resolver) {
     throw new Error(`failed request. no matching verificationMethod`);
 }
 exports.verifyEIP712TypedData = verifyEIP712TypedData;
-async function convertPaymentAmount(amount, currency) {
-    let convertedAmount = 0n;
-    switch (currency) {
-        case verifiable_1.SupportedCurrencies.ETH:
-        case verifiable_1.SupportedCurrencies.POL:
-        case verifiable_1.SupportedCurrencies.MATIC:
-            convertedAmount = (0, ethers_1.parseEther)(amount.toString());
-            break;
-        case verifiable_1.SupportedCurrencies.ETH_WEI:
-            convertedAmount = (0, ethers_1.parseUnits)(amount.toString(), 'wei');
-            break;
-        case verifiable_1.SupportedCurrencies.ETH_GWEI:
-            convertedAmount = (0, ethers_1.parseUnits)(amount.toString(), 'gwei');
-            break;
-        case verifiable_1.SupportedCurrencies.USDC:
-        case verifiable_1.SupportedCurrencies.USDT: {
-            convertedAmount = (0, ethers_1.parseUnits)(amount.toString(), 6);
-            break;
-        }
-        default:
-            throw new Error(`failed request. unsupported currency ${currency}`);
-    }
-    return convertedAmount;
-}
-exports.convertPaymentAmount = convertPaymentAmount;
 /**
  * @beta
  * createPayment is a function to create protocol payment message
@@ -312,35 +286,38 @@ class PaymentHandler extends message_handler_1.AbstractMessageHandler {
         for (let i = 0; i < payments.length; i++) {
             const { credentials, description } = payments[i];
             const dataArr = [];
-            for (let j = 0; j < payments[i].chains.length; j++) {
-                const { features, nonce, amount, currency, chainId, expirationDate, type } = payments[i].chains[j];
+            for (let j = 0; j < payments[i].options.length; j++) {
+                const { nonce, amount, chainId, optionId, expirationDate } = payments[i].options[j];
                 const multiChainConfig = this._params.multiChainPaymentConfig?.find((c) => c.chainId === chainId);
                 if (!multiChainConfig) {
                     throw new Error(`failed request. no config for chain ${chainId}`);
                 }
-                const { recipient, paymentContract, erc20TokenAddressArr } = multiChainConfig;
-                const tokenAddress = erc20TokenAddressArr.find((t) => t.symbol === currency)?.address;
-                if (type === verifiable_1.PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 && !tokenAddress) {
-                    throw new Error(`failed request. no token address for currency ${currency}`);
+                const { recipient, paymentRails, options } = multiChainConfig;
+                const option = options.find((t) => t.id === optionId);
+                if (!option) {
+                    throw new Error(`failed request. no option for id ${optionId}`);
+                }
+                if (option.type === verifiable_1.PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 &&
+                    !option.contractAddress) {
+                    throw new Error(`failed request. no token address for option id ${optionId}`);
                 }
                 const expirationDateRequired = expirationDate ?? new Date(new Date().setHours(new Date().getHours() + 1));
-                const typeUrl = `https://schema.iden3.io/core/json/${type}.json`;
+                const typeUrl = `https://schema.iden3.io/core/json/${option.type}.json`;
                 const typesFetchResult = await fetch(typeUrl);
                 const types = await typesFetchResult.json();
                 delete types.EIP712Domain;
-                const convertedAmount = await convertPaymentAmount(amount, currency);
-                const paymentData = type === verifiable_1.PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                const paymentData = option.type === verifiable_1.PaymentRequestDataType.Iden3PaymentRailsRequestV1
                     ? {
                         recipient,
-                        amount: convertedAmount,
+                        amount: amount,
                         expirationDate: (0, js_iden3_core_1.getUnixTimestamp)(expirationDateRequired),
                         nonce,
                         metadata: '0x'
                     }
                     : {
-                        tokenAddress,
+                        tokenAddress: option.contractAddress,
                         recipient,
-                        amount: convertedAmount,
+                        amount: amount,
                         expirationDate: (0, js_iden3_core_1.getUnixTimestamp)(expirationDateRequired),
                         nonce,
                         metadata: '0x'
@@ -349,7 +326,7 @@ class PaymentHandler extends message_handler_1.AbstractMessageHandler {
                     name: 'MCPayment',
                     version: '1.0.0',
                     chainId,
-                    verifyingContract: paymentContract
+                    verifyingContract: paymentRails
                 };
                 const signature = await signer.signTypedData(domain, types, paymentData);
                 const proof = [
@@ -369,20 +346,24 @@ class PaymentHandler extends message_handler_1.AbstractMessageHandler {
                 const d = {
                     type: verifiable_1.PaymentRequestDataType.Iden3PaymentRailsRequestV1,
                     '@context': [
-                        `https://schema.iden3.io/core/jsonld/payment.jsonld#${type}`,
+                        `https://schema.iden3.io/core/jsonld/payment.jsonld#${option.type}`,
                         'https://w3id.org/security/suites/eip712sig-2021/v1'
                     ],
                     recipient,
                     amount: amount.toString(),
-                    currency,
                     expirationDate: expirationDateRequired.toISOString(),
                     nonce: nonce.toString(),
                     metadata: '0x',
                     proof
                 };
-                dataArr.push(type === verifiable_1.PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                dataArr.push(option.type === verifiable_1.PaymentRequestDataType.Iden3PaymentRailsRequestV1
                     ? d
-                    : { ...d, type, tokenAddress: tokenAddress || '', features: features || [] });
+                    : {
+                        ...d,
+                        type: option.type,
+                        tokenAddress: option.contractAddress || '',
+                        features: option.features || []
+                    });
             }
             paymentRequestInfo.push({
                 data: dataArr,

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 = {}));