@0xpolygonid/js-sdk 1.24.1 → 1.26.0

package/dist/node/cjs/iden3comm/utils/contract-request.utils.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareAuthV2ZeroKnowledgeResponse = exports.calculateRequestIdForCircuit = void 0;
+const ethers_1 = require("ethers");
+const utils_1 = require("../../utils");
+const circuits_1 = require("../../circuits");
+const js_crypto_1 = require("@iden3/js-crypto");
+/**
+ * @beta
+ * Retrieves the request ID from circuit string.
+ * CircuitId.AuthV2 - 940499666
+ * @returns The request ID.
+ */
+function calculateRequestIdForCircuit(circuitId) {
+    const circuitHash = (0, ethers_1.keccak256)(utils_1.byteEncoder.encode(circuitId));
+    const dataView = new DataView(js_crypto_1.Hex.decodeString(circuitHash.replace('0x', '')).buffer);
+    const id = dataView.getUint32(0);
+    return id;
+}
+exports.calculateRequestIdForCircuit = calculateRequestIdForCircuit;
+/**
+ * Prepares the zero-knowledge proof response for the AuthV2 circuit.
+ * @beta
+ * @param address - The address associated with the request.
+ * @param senderDid - The sender's decentralized identifier (DID).
+ * @param proofService - The proof service used to generate the proof.
+ * @returns A promise that resolves to an array of ZeroKnowledgeProofResponse objects.
+ */
+async function prepareAuthV2ZeroKnowledgeResponse(address, senderDid, proofService) {
+    const circuitId = circuits_1.CircuitId.AuthV2;
+    //  this is now hardcoded calculated value for 'authV2' that can be changed in the future.
+    const id = 940499666;
+    if ((0, utils_1.isEthereumIdentity)(senderDid)) {
+        return [
+            {
+                circuitId,
+                id,
+                pub_signals: [],
+                proof: {
+                    pi_a: [],
+                    pi_b: [],
+                    pi_c: [],
+                    protocol: 'groth16'
+                }
+            }
+        ];
+    }
+    const hash = Uint8Array.from([...(0, utils_1.hexToBytes)(address), ...new Uint8Array(12)]).reverse();
+    const { proof, pub_signals } = await proofService.generateAuthV2Proof(hash, senderDid);
+    return [
+        {
+            circuitId,
+            id,
+            pub_signals,
+            proof
+        }
+    ];
+}
+exports.prepareAuthV2ZeroKnowledgeResponse = prepareAuthV2ZeroKnowledgeResponse;

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

@@ -17,4 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./envelope"), exports);
 __exportStar(require("./message"), exports);
 __exportStar(require("./did"), exports);
+__exportStar(require("./contract-request.utils"), exports);
 __exportStar(require("./accept-profile"), exports);

package/dist/node/cjs/proof/proof-service.js

@@ -216,6 +216,12 @@ class ProofService {
         authInputs.gistProof = gistProof;
         return authInputs.inputsMarshal();
     }
+    /** {@inheritdoc IProofService.generateAuthV2Proof} */
+    async generateAuthV2Proof(challenge, did) {
+        const authInputs = await this.generateAuthV2Inputs(challenge, did, circuits_1.CircuitId.AuthV2);
+        const zkProof = await this._prover.generate(authInputs, circuits_1.CircuitId.AuthV2);
+        return zkProof;
+    }
     async verifyState(circuitId, pubSignals, opts = {
         acceptedStateTransitionDelay: iden3comm_1.PROTOCOL_CONSTANTS.DEFAULT_AUTH_VERIFY_DELAY
     }) {

package/dist/node/cjs/storage/blockchain/onchain-zkp-verifier.js

@@ -11,6 +11,7 @@ const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const circuits_1 = require("../../circuits");
 const utils_1 = require("../../utils");
 const js_crypto_1 = require("@iden3/js-crypto");
+const js_merkletree_1 = require("@iden3/js-merkletree");
 const maxGasLimit = 10000000n;
 /**
  * Supported function signature for SubmitZKPResponse
@@ -157,54 +158,60 @@ class OnChainZKPVerifier {
         const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
         return new Map().set(txnHash, zkProofResponses);
     }
+    static getCrossChainResolvers(source, txDataChainId, type, didResolverUrl) {
+        return [
+            ...new Set(source.map((info) => JSON.stringify({
+                id: info.id.string(),
+                [type]: type === 'gist' ? info.root?.string() : info.state?.string()
+            })))
+        ].reduce((acc, s) => {
+            const info = JSON.parse(s);
+            const id = js_iden3_core_1.Id.fromString(info.id);
+            const chainId = (0, js_iden3_core_1.chainIDfromDID)(js_iden3_core_1.DID.parseFromId(id));
+            if (txDataChainId === chainId) {
+                return acc;
+            }
+            const promise = this.resolveDidDocumentEip712MessageAndSignature(js_iden3_core_1.DID.parseFromId(js_iden3_core_1.Id.fromString(info.id)), didResolverUrl, {
+                [type]: js_merkletree_1.Hash.fromString(info[type])
+            });
+            return [...acc, promise];
+        }, []);
+    }
     static async prepareTxArgsSubmitV2(resolverUrl, txData, zkProofResponses) {
         if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV2) {
             throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV2}' is supported.`);
         }
-        const gistUpdateArr = [];
-        const stateUpdateArr = [];
+        const gistUpdates = [];
+        const stateUpdates = [];
         const payload = [];
-        // Resolved gists and states to avoid duplicate requests
-        const gistUpdateResolutionsPending = [];
-        const stateUpdateResolutionsPending = [];
+        const emptyBytes = '0x';
         for (const zkProof of zkProofResponses) {
-            const requestID = zkProof.id;
-            const inputs = zkProof.pub_signals;
-            if (!this._supportedCircuits.includes(zkProof.circuitId)) {
+            const { id: requestId, pub_signals: inputs } = zkProof;
+            const proofCircuitId = zkProof.circuitId;
+            if (!this._supportedCircuits.includes(proofCircuitId)) {
                 throw new Error(`Circuit ${zkProof.circuitId} not supported by OnChainZKPVerifier`);
             }
+            if (inputs.length === 0) {
+                payload.push({
+                    requestId: requestId,
+                    zkProof: emptyBytes,
+                    data: emptyBytes
+                });
+                continue;
+            }
             const zkProofEncoded = this.packZkpProof(inputs, zkProof.proof.pi_a.slice(0, 2), [
                 [zkProof.proof.pi_b[0][1], zkProof.proof.pi_b[0][0]],
                 [zkProof.proof.pi_b[1][1], zkProof.proof.pi_b[1][0]]
             ], zkProof.proof.pi_c.slice(0, 2));
-            const stateInfo = this.getOnChainGistRootStatePubSignals(zkProof.circuitId, zkProof.pub_signals);
-            const gistUpdateResolutions = [];
-            for (const gist of stateInfo.gists) {
-                const gistResolutionPending = gistUpdateResolutionsPending.find((g) => g == JSON.stringify(gist));
-                if (gistResolutionPending) {
-                    continue;
-                }
-                gistUpdateResolutionsPending.push(JSON.stringify(gist));
-                gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(js_iden3_core_1.DID.parseFromId(gist.id), resolverUrl, {
-                    gist: gist.root
-                }));
-            }
-            const stateUpdateResolutions = [];
-            for (const state of stateInfo.states) {
-                const stateResolutionPending = stateUpdateResolutionsPending.find((s) => s == JSON.stringify(state));
-                if (stateResolutionPending) {
-                    continue;
-                }
-                stateUpdateResolutionsPending.push(JSON.stringify(state));
-                stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(js_iden3_core_1.DID.parseFromId(state.id), resolverUrl, {
-                    state: state.state
-                }));
-            }
+            const stateInfo = this.getOnChainGistRootStatePubSignals(proofCircuitId, inputs);
+            const chainId = txData.chain_id;
+            const gistUpdateResolutions = this.getCrossChainResolvers(stateInfo.gists, chainId, 'gist', resolverUrl);
+            const stateUpdateResolutions = this.getCrossChainResolvers(stateInfo.states, chainId, 'state', resolverUrl);
             if (gistUpdateResolutions.length > 0) {
-                gistUpdateArr.push(...(await Promise.all(gistUpdateResolutions)));
+                gistUpdates.push(...(await Promise.all(gistUpdateResolutions)));
             }
             if (stateUpdateResolutions.length > 0) {
-                stateUpdateArr.push(...(await Promise.all(stateUpdateResolutions)));
+                stateUpdates.push(...(await Promise.all(stateUpdateResolutions)));
             }
             const metadataArr = [];
             if (zkProof.vp) {
@@ -220,14 +227,16 @@ class OnChainZKPVerifier {
                     });
                 }
             }
-            const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : '0x';
+            const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : emptyBytes;
             payload.push({
-                requestId: requestID,
+                requestId: requestId,
                 zkProof: zkProofEncoded,
                 data: metadata
             });
         }
-        const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
+        const crossChainProofs = gistUpdates.length || stateUpdates.length
+            ? this.packCrossChainProofs(gistUpdates, stateUpdates)
+            : emptyBytes;
         return [payload, crossChainProofs];
     }
     async prepareTxArgsSubmitV2(txData, zkProofResponses) {
@@ -285,18 +294,11 @@ class OnChainZKPVerifier {
         return new ethers_1.ethers.AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
     }
     static getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
-        let atomicQueryPubSignals;
-        switch (onChainCircuitId) {
-            case circuits_1.CircuitId.AtomicQueryMTPV2OnChain:
-                atomicQueryPubSignals = new circuits_1.AtomicQueryMTPV2OnChainPubSignals();
-                break;
-            case circuits_1.CircuitId.AtomicQuerySigV2OnChain:
-                atomicQueryPubSignals = new circuits_1.AtomicQuerySigV2OnChainPubSignals();
-                break;
-            case circuits_1.CircuitId.AtomicQueryV3OnChain:
-                atomicQueryPubSignals = new circuits_1.AtomicQueryV3OnChainPubSignals();
-                break;
+        const PubSignals = this._supportedCircuitsPubSignalsMap[onChainCircuitId];
+        if (!PubSignals) {
+            throw new Error(`Circuit ${onChainCircuitId} not supported by OnChainZKPVerifier`);
         }
+        const atomicQueryPubSignals = new PubSignals();
         const encodedInputs = utils_1.byteEncoder.encode(JSON.stringify(inputs));
         atomicQueryPubSignals.pubSignalsUnmarshal(encodedInputs);
         return atomicQueryPubSignals.getStatesInfo();
@@ -339,7 +341,14 @@ exports.OnChainZKPVerifier = OnChainZKPVerifier;
  * supported circuits
  */
 OnChainZKPVerifier._supportedCircuits = [
+    circuits_1.CircuitId.AuthV2,
     circuits_1.CircuitId.AtomicQueryMTPV2OnChain,
     circuits_1.CircuitId.AtomicQuerySigV2OnChain,
     circuits_1.CircuitId.AtomicQueryV3OnChain
 ];
+OnChainZKPVerifier._supportedCircuitsPubSignalsMap = {
+    [circuits_1.CircuitId.AtomicQueryMTPV2OnChain]: circuits_1.AtomicQueryMTPV2OnChainPubSignals,
+    [circuits_1.CircuitId.AtomicQuerySigV2OnChain]: circuits_1.AtomicQuerySigV2OnChainPubSignals,
+    [circuits_1.CircuitId.AtomicQueryV3OnChain]: circuits_1.AtomicQueryV3OnChainPubSignals,
+    [circuits_1.CircuitId.AuthV2]: circuits_1.AuthV2PubSignals
+};

package/dist/node/cjs/utils/did-helper.js

@@ -105,9 +105,14 @@ const resolveDidDocument = async (did, resolverUrl, opts) => {
     if (opts?.gist) {
         url += `${url.includes('?') ? '&' : '?'}gist=${opts.gist.hex()}`;
     }
-    const resp = await fetch(url);
-    const data = await resp.json();
-    return data;
+    try {
+        const resp = await fetch(url);
+        const data = await resp.json();
+        return data;
+    }
+    catch (e) {
+        throw new Error(`Failed to resolve DID document for ${did} ${e}`);
+    }
 };
 exports.resolveDidDocument = resolveDidDocument;
 const buildDIDFromEthPubKey = (didType, pubKeyEth) => {

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

@@ -149,6 +149,7 @@ var SupportedPaymentProofType;
 /**
  * Media types for Payment supported currencies
  * @beta
+ * @deprecated
  * @enum {string}
  */
 var SupportedCurrencies;
@@ -158,8 +159,6 @@ var SupportedCurrencies;
     SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
     SupportedCurrencies["MATIC"] = "MATIC";
     SupportedCurrencies["POL"] = "POL";
-    SupportedCurrencies["USDT"] = "USDT";
-    SupportedCurrencies["USDC"] = "USDC";
 })(SupportedCurrencies = exports.SupportedCurrencies || (exports.SupportedCurrencies = {}));
 /**
  * Supported features for payment-request

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

@@ -88,4 +88,10 @@ export class AuthV2PubSignals {
         this.GISTRoot = Hash.fromString(sVals[2]);
         return this;
     }
+    getStatesInfo() {
+        return {
+            states: [],
+            gists: [{ id: this.userID, root: this.GISTRoot }]
+        };
+    }
 }

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;
     }

package/dist/node/esm/iden3comm/handlers/contract-request.js

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

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';