@0xpolygonid/js-sdk 1.25.1 → 1.27.0

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

@@ -0,0 +1,169 @@
+import { MediaType, PROTOCOL_MESSAGE_TYPE } from '../constants';
+import * as uuid from 'uuid';
+import { DiscoverFeatureQueryType, DiscoveryProtocolFeatureType } from '../types/protocol/discovery-protocol';
+import { AbstractMessageHandler } from './message-handler';
+import { getUnixTimestamp } from '@iden3/js-iden3-core';
+import { verifyExpiresTime } from './common';
+/**
+ * @beta
+ * createDiscoveryFeatureQueryMessage is a function to create didcomm protocol discovery-feature query message
+ * @param opts - discovery-feature query options
+ * @returns `DiscoverFeatureQueriesMessage`
+ */
+export function createDiscoveryFeatureQueryMessage(queries, opts) {
+    const uuidv4 = uuid.v4();
+    return {
+        id: uuidv4,
+        thid: uuidv4,
+        typ: MediaType.PlainMessage,
+        type: PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE,
+        body: {
+            queries
+        },
+        from: opts?.from,
+        to: opts?.to,
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time
+    };
+}
+/**
+ * @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`
+ */
+export function createDiscoveryFeatureDiscloseMessage(disclosures, opts) {
+    const uuidv4 = uuid.v4();
+    return {
+        id: uuidv4,
+        typ: MediaType.PlainMessage,
+        thid: uuidv4,
+        type: PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE,
+        body: {
+            disclosures
+        },
+        from: opts?.from,
+        to: opts?.to,
+        created_time: getUnixTimestamp(new Date()),
+        expires_time: opts?.expires_time
+    };
+}
+/**
+ *
+ * Handler for discovery protocol
+ *
+ * @public
+ * @beta
+ * @class DiscoveryProtocolHandler
+ * @implements implements DiscoveryProtocolHandler interface
+ */
+export class DiscoveryProtocolHandler extends 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 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) {
+            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
+                ? getUnixTimestamp(opts.disclosureExpiresDate)
+                : undefined
+        }));
+    }
+    handleQuery(query) {
+        let result = [];
+        switch (query[DiscoverFeatureQueryType.FeatureType]) {
+            case DiscoveryProtocolFeatureType.Accept:
+                result = this.handleAcceptQuery();
+                break;
+            case DiscoveryProtocolFeatureType.Protocol:
+                result = this.handleProtocolQuery();
+                break;
+            case DiscoveryProtocolFeatureType.GoalCode:
+                result = this.handleGoalCodeQuery();
+                break;
+            case DiscoveryProtocolFeatureType.Header:
+                result = this.handleHeaderQuery();
+                break;
+        }
+        return this.handleMatch(result, query.match);
+    }
+    handleAcceptQuery() {
+        const acceptProfiles = this._options.packageManager.getSupportedProfiles();
+        return acceptProfiles.map((profile) => ({
+            [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType.Accept,
+            id: profile
+        }));
+    }
+    handleProtocolQuery() {
+        return (this._options.protocols?.map((protocol) => ({
+            [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType.Protocol,
+            id: protocol
+        })) ?? []);
+    }
+    handleGoalCodeQuery() {
+        return (this._options.goalCodes?.map((goalCode) => ({
+            [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType.GoalCode,
+            id: goalCode
+        })) ?? []);
+    }
+    handleHeaderQuery() {
+        return (this._options.headers?.map((header) => ({
+            [DiscoverFeatureQueryType.FeatureType]: 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}$`);
+    }
+}

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

@@ -7,3 +7,4 @@ export * from './common';
 export * from './credential-proposal';
 export * from './message-handler';
 export * from './payment';
+export * from './discovery-protocol';

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

@@ -15,6 +15,18 @@ export 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/esm/iden3comm/packers/jws.js

@@ -1,4 +1,4 @@
-import { AcceptJwsAlgorithms, MediaType, SUPPORTED_PUBLIC_KEY_TYPES } from '../constants';
+import { AcceptJwsAlgorithms, MediaType, ProtocolVersion, SUPPORTED_PUBLIC_KEY_TYPES } from '../constants';
 import { extractPublicKeyBytes, resolveVerificationMethods } from '../utils/did';
 import { keyPath } from '../../kms/';
 import { verifyJWS } from 'did-jwt';
@@ -24,6 +24,8 @@ export class JWSPacker {
     constructor(_kms, _documentResolver) {
         this._kms = _kms;
         this._documentResolver = _documentResolver;
+        this.supportedAlgorithms = [AcceptJwsAlgorithms.ES256K, AcceptJwsAlgorithms.ES256KR];
+        this.supportedProtocolVersions = [ProtocolVersion.V1];
     }
     /**
      * Packs the given payload and returns a promise that resolves to the packed data.
@@ -86,24 +88,23 @@ export 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 } = parseAcceptProfile(profile);
+        const { protocolVersion, env, circuits, alg } = 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 [AcceptJwsAlgorithms.ES256K, AcceptJwsAlgorithms.ES256KR];
-    }
     async resolveDidDoc(from) {
         let didDocument;
         try {

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

@@ -1,4 +1,4 @@
-import { MediaType } from '../constants';
+import { MediaType, ProtocolVersion } from '../constants';
 import { byteDecoder, byteEncoder } from '../../utils';
 import { parseAcceptProfile } from '../utils';
 /**
@@ -9,6 +9,9 @@ import { parseAcceptProfile } from '../utils';
  * @implements implements IPacker interface
  */
 export class PlainPacker {
+    constructor() {
+        this.supportedProtocolVersions = [ProtocolVersion.V1];
+    }
     /**
      * Packs a basic message using the specified parameters.
      *
@@ -52,11 +55,14 @@ export 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 } = parseAcceptProfile(profile);
+        const { protocolVersion, env, circuits, alg } = parseAcceptProfile(profile);
+        if (!this.supportedProtocolVersions.includes(protocolVersion)) {
+            return false;
+        }
         if (env !== this.mediaType()) {
             return false;
         }

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

@@ -3,7 +3,7 @@ import { AuthV2PubSignals, CircuitId } from '../../circuits/index';
 import { BytesHelper, DID } from '@iden3/js-iden3-core';
 import { bytesToProtocolMessage } from '../utils/envelope';
 import { ErrNoProvingMethodAlg, ErrPackedWithUnsupportedCircuit, ErrProofIsInvalid, ErrSenderNotUsedTokenCreation, ErrStateVerificationFailed, ErrUnknownCircuitID } from '../errors';
-import { AcceptAuthCircuits, AcceptJwzAlgorithms, MediaType } from '../constants';
+import { AcceptAuthCircuits, AcceptJwzAlgorithms, MediaType, ProtocolVersion } from '../constants';
 import { byteDecoder, byteEncoder } from '../../utils';
 import { DEFAULT_AUTH_VERIFY_DELAY } from '../constants';
 import { parseAcceptProfile } from '../utils';
@@ -78,6 +78,9 @@ export class ZKPPacker {
         this.provingParamsMap = provingParamsMap;
         this.verificationParamsMap = verificationParamsMap;
         this._opts = _opts;
+        this.supportedProtocolVersions = [ProtocolVersion.V1];
+        this.supportedAlgorithms = [AcceptJwzAlgorithms.Groth16];
+        this.supportedCircuitIds = [AcceptAuthCircuits.AuthV2];
     }
     /**
      * Packs a basic message using the specified parameters.
@@ -139,28 +142,23 @@ export 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 } = parseAcceptProfile(profile);
+        const { protocolVersion, env, circuits, alg } = 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 [AcceptJwzAlgorithms.Groth16];
-    }
-    getSupportedCircuitIds() {
-        return [AcceptAuthCircuits.AuthV2];
-    }
 }
 const verifySender = async (token, msg) => {
     switch (token.circuitId) {

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

@@ -7,6 +7,7 @@ export * from './protocol/contract-request';
 export * from './protocol/proposal-request';
 export * from './protocol/payment';
 export * from './protocol/accept-profile';
+export * from './protocol/discovery-protocol';
 export * from './packer';
 export * from './models';
 export * from './packageManager';

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

@@ -0,0 +1,13 @@
+/** @beta DiscoverFeatureQueryType is enum for query type fields */
+export var DiscoverFeatureQueryType;
+(function (DiscoverFeatureQueryType) {
+    DiscoverFeatureQueryType["FeatureType"] = "feature-type";
+})(DiscoverFeatureQueryType || (DiscoverFeatureQueryType = {}));
+/** @beta DiscoveryProtocolFeatureType is enum for supported feature-types */
+export var DiscoveryProtocolFeatureType;
+(function (DiscoveryProtocolFeatureType) {
+    DiscoveryProtocolFeatureType["Accept"] = "accept";
+    DiscoveryProtocolFeatureType["Protocol"] = "protocol";
+    DiscoveryProtocolFeatureType["GoalCode"] = "goal-code";
+    DiscoveryProtocolFeatureType["Header"] = "header";
+})(DiscoveryProtocolFeatureType || (DiscoveryProtocolFeatureType = {}));

package/dist/types/iden3comm/constants.d.ts

@@ -23,6 +23,8 @@ export declare const PROTOCOL_MESSAGE_TYPE: Readonly<{
     PROPOSAL_MESSAGE_TYPE: "https://iden3-communication.io/credentials/0.1/proposal";
     PAYMENT_REQUEST_MESSAGE_TYPE: "https://iden3-communication.io/credentials/0.1/payment-request";
     PAYMENT_MESSAGE_TYPE: "https://iden3-communication.io/credentials/0.1/payment";
+    DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE: "https://didcomm.org/discover-features/2.0/queries";
+    DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE: "https://didcomm.org/discover-features/2.0/disclose";
 }>;
 /**
  * Media types for iden3 comm communication protocol

package/dist/types/iden3comm/handlers/credential-proposal.d.ts

@@ -1,4 +1,4 @@
-import { BasicMessage, DIDDocument, IPackageManager, JsonDocumentObject, PackerParams } from '../types';
+import { BasicMessage, DIDDocument, IPackageManager, PackerParams } from '../types';
 import { DID } from '@iden3/js-iden3-core';
 import { Proposal, ProposalRequestCredential, ProposalRequestMessage, ProposalMessage } from '../types/protocol/proposal-request';
 import { IIdentityWallet } from '../../identity';
@@ -6,10 +6,6 @@ import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler }
 /** @beta ProposalRequestCreationOptions represents proposal-request creation options */
 export type ProposalRequestCreationOptions = {
     credentials: ProposalRequestCredential[];
-    metadata?: {
-        type: string;
-        data?: JsonDocumentObject;
-    };
     did_doc?: DIDDocument;
     expires_time?: Date;
 };

package/dist/types/iden3comm/handlers/discovery-protocol.d.ts

@@ -0,0 +1,100 @@
+import { BasicMessage, IPackageManager, ProtocolMessage } from '../types';
+import { DiscoverFeatureDiscloseMessage, DiscoverFeatureDisclosure, DiscoverFeatureQueriesMessage, DiscoverFeatureQuery } from '../types/protocol/discovery-protocol';
+import { AbstractMessageHandler, BasicHandlerOptions, IProtocolMessageHandler } from './message-handler';
+/**
+ * @beta
+ * DiscoveryProtocolOptions contains options for DiscoveryProtocolHandler
+ * @public
+ * @interface   DiscoveryProtocolOptions
+ */
+export interface DiscoveryProtocolOptions {
+    packageManager: IPackageManager;
+    protocols?: Array<ProtocolMessage>;
+    goalCodes?: Array<string>;
+    headers?: Array<string>;
+}
+/**
+ *
+ * Options to pass to discovery-protocol handler
+ *
+ * @beta
+ * @public
+ * @type DiscoveryProtocolHandlerOptions
+ */
+export type DiscoveryProtocolHandlerOptions = BasicHandlerOptions & {
+    disclosureExpiresDate?: Date;
+};
+/**
+ * @beta
+ * createDiscoveryFeatureQueryMessage is a function to create didcomm protocol discovery-feature query message
+ * @param opts - discovery-feature query options
+ * @returns `DiscoverFeatureQueriesMessage`
+ */
+export declare function createDiscoveryFeatureQueryMessage(queries: DiscoverFeatureQuery[], opts?: {
+    from?: string;
+    to?: string;
+    expires_time?: number;
+}): DiscoverFeatureQueriesMessage;
+/**
+ * @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`
+ */
+export declare function createDiscoveryFeatureDiscloseMessage(disclosures: DiscoverFeatureDisclosure[], opts?: {
+    from?: string;
+    to?: string;
+    expires_time?: number;
+}): DiscoverFeatureDiscloseMessage;
+/**
+ * Interface to work with discovery protocol handler
+ *
+ * @beta
+ * @public
+ * @interface IDiscoveryProtocolHandler
+ */
+export interface IDiscoveryProtocolHandler {
+    /**
+     * handle discovery query message
+     *
+     * @param {DiscoverFeatureQueriesMessage} message - discover feature queries message
+     * @param {{ expires_time?: number}} opts - discover feature handle options
+     * @returns {Promise<DiscoverFeatureDiscloseMessage>} - discover feature disclose message
+     */
+    handleDiscoveryQuery(message: DiscoverFeatureQueriesMessage, opts?: DiscoveryProtocolHandlerOptions): Promise<DiscoverFeatureDiscloseMessage>;
+}
+/**
+ *
+ * Handler for discovery protocol
+ *
+ * @public
+ * @beta
+ * @class DiscoveryProtocolHandler
+ * @implements implements DiscoveryProtocolHandler interface
+ */
+export declare class DiscoveryProtocolHandler extends AbstractMessageHandler implements IDiscoveryProtocolHandler, IProtocolMessageHandler {
+    private readonly _options;
+    /**
+     * Creates an instance of DiscoveryProtocolHandler.
+     * @param {DiscoveryProtocolOptions} _options - discovery protocol options
+     */
+    constructor(_options: DiscoveryProtocolOptions);
+    /**
+     * @inheritdoc IProtocolMessageHandler#handle
+     */
+    handle(message: BasicMessage, context: {
+        [key: string]: unknown;
+    }): Promise<BasicMessage | null>;
+    /**
+     * @inheritdoc IDiscoveryProtocolHandler#handleDiscoveryQuery
+     */
+    handleDiscoveryQuery(message: DiscoverFeatureQueriesMessage, opts?: DiscoveryProtocolHandlerOptions): Promise<DiscoverFeatureDiscloseMessage>;
+    private handleQuery;
+    private handleAcceptQuery;
+    private handleProtocolQuery;
+    private handleGoalCodeQuery;
+    private handleHeaderQuery;
+    private handleMatch;
+    private wildcardToRegExp;
+}

package/dist/types/iden3comm/handlers/index.d.ts

@@ -7,3 +7,4 @@ export * from './common';
 export * from './credential-proposal';
 export * from './message-handler';
 export * from './payment';
+export * from './discovery-protocol';

package/dist/types/iden3comm/packageManager.d.ts

@@ -13,6 +13,8 @@ export declare class PackageManager implements IPackageManager {
      * Creates an instance of PackageManager.
      */
     constructor();
+    /** {@inheritDoc IPackageManager.getSupportedProfiles} */
+    getSupportedProfiles(): string[];
     /** {@inheritDoc IPackageManager.isProfileSupported} */
     isProfileSupported(mediaType: MediaType, profile: string): boolean;
     /** {@inheritDoc IPackageManager.getSupportedMediaTypes} */

package/dist/types/iden3comm/packers/jws.d.ts

@@ -12,6 +12,8 @@ import { Resolvable } from 'did-resolver';
 export declare class JWSPacker implements IPacker {
     private readonly _kms;
     private readonly _documentResolver;
+    private readonly supportedAlgorithms;
+    private readonly supportedProtocolVersions;
     /**
      * Creates an instance of JWSPacker.
      *
@@ -48,7 +50,6 @@ export declare class JWSPacker implements IPacker {
     getSupportedProfiles(): string[];
     /** {@inheritDoc IPacker.isProfileSupported} */
     isProfileSupported(profile: string): boolean;
-    private getSupportedAlgorithms;
     private resolveDidDoc;
     private packInternal;
 }

package/dist/types/iden3comm/packers/plain.d.ts

@@ -8,6 +8,7 @@ import { MediaType } from '../constants';
  * @implements implements IPacker interface
  */
 export declare class PlainPacker implements IPacker {
+    private readonly supportedProtocolVersions;
     /**
      * Packs a basic message using the specified parameters.
      *

package/dist/types/iden3comm/packers/zkp.d.ts

@@ -58,6 +58,9 @@ export declare class ZKPPacker implements IPacker {
     readonly provingParamsMap: Map<string, ProvingParams>;
     readonly verificationParamsMap: Map<string, VerificationParams>;
     private readonly _opts;
+    private readonly supportedProtocolVersions;
+    private readonly supportedAlgorithms;
+    private readonly supportedCircuitIds;
     /**
      * Creates an instance of ZKPPacker.
      * @param {Map<string, ProvingParams>} provingParamsMap - string is derived by JSON.parse(ProvingMethodAlg)
@@ -91,6 +94,4 @@ export declare class ZKPPacker implements IPacker {
     getSupportedProfiles(): string[];
     /** {@inheritDoc IPacker.isProfileSupported} */
     isProfileSupported(profile: string): boolean;
-    private getSupportedAlgorithms;
-    private getSupportedCircuitIds;
 }

package/dist/types/iden3comm/types/index.d.ts

@@ -7,6 +7,7 @@ export * from './protocol/contract-request';
 export * from './protocol/proposal-request';
 export * from './protocol/payment';
 export * from './protocol/accept-profile';
+export * from './protocol/discovery-protocol';
 export * from './packer';
 export * from './models';
 export * from './packageManager';

package/dist/types/iden3comm/types/packageManager.d.ts

@@ -70,6 +70,12 @@ export interface IPackageManager {
      * @returns MediaType[]
      */
     getSupportedMediaTypes(): MediaType[];
+    /**
+     * gets supported accept profiles by packer manager
+     *
+     * @returns string[]
+     */
+    getSupportedProfiles(): string[];
     /**
      * returns true if media type and algorithms supported by packer manager
      *

package/dist/types/iden3comm/types/protocol/contract-request.d.ts

@@ -26,7 +26,7 @@ export type ContractInvokeResponseBody = {
 };
 /** OnChainZeroKnowledgeProofResponse represents structure of onchain zero knowledge proof response */
 export type OnChainZeroKnowledgeProofResponse = ZeroKnowledgeProofResponse & {
-    txHash: string;
+    txHash?: string;
 };
 /** ContractInvokeTransactionData represents structure of contract invoke transaction data object */
 export type ContractInvokeTransactionData = {

package/dist/types/iden3comm/types/protocol/discovery-protocol.d.ts

@@ -0,0 +1,41 @@
+import { PROTOCOL_MESSAGE_TYPE } from '../../constants';
+import { BasicMessage } from '../packer';
+/** @beta DiscoverFeatureQueryType is enum for query type fields */
+export declare enum DiscoverFeatureQueryType {
+    FeatureType = "feature-type"
+}
+/** @beta DiscoveryProtocolFeatureType is enum for supported feature-types */
+export declare enum DiscoveryProtocolFeatureType {
+    Accept = "accept",
+    Protocol = "protocol",
+    GoalCode = "goal-code",
+    Header = "header"
+}
+/** @beta DiscoverFeatureQueriesMessage is struct the represents discover feature queries message */
+export type DiscoverFeatureQueriesMessage = BasicMessage & {
+    body: DiscoverFeatureQueriesBody;
+    type: typeof PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE;
+};
+/** @beta DiscoverFeatureQueriesBody is struct the represents discover feature queries body */
+export type DiscoverFeatureQueriesBody = {
+    queries: DiscoverFeatureQuery[];
+};
+/** @beta DiscoverFeatureQuery is struct the represents discover feature query */
+export type DiscoverFeatureQuery = {
+    [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType;
+    match?: string;
+};
+/** @beta DiscoverFeatureDiscloseMessage is struct the represents discover feature disclose message */
+export type DiscoverFeatureDiscloseMessage = BasicMessage & {
+    body: DiscoverFeatureDiscloseBody;
+    type: typeof PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE;
+};
+/** @beta DiscoverFeatureDiscloseBody is struct the represents discover feature disclose body */
+export type DiscoverFeatureDiscloseBody = {
+    disclosures: DiscoverFeatureDisclosure[];
+};
+/** @beta DiscoverFeatureDisclosure is struct the represents discover feature disclosure */
+export type DiscoverFeatureDisclosure = {
+    [DiscoverFeatureQueryType.FeatureType]: DiscoveryProtocolFeatureType;
+    id: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xpolygonid/js-sdk",
-  "version": "1.25.1",
+  "version": "1.27.0",
   "description": "SDK to work with Polygon ID",
   "main": "dist/node/cjs/index.js",
   "module": "dist/node/esm/index.js",