@0xpolygonid/js-sdk 1.25.1 → 1.26.0

package/dist/browser/umd/index.js

@@ -58425,6 +58425,7 @@ var PolygonIdSdk = (function (exports) {
     }
 
     const IDEN3_PROTOCOL = 'https://iden3-communication.io/';
+    const DIDCOMM_PROTOCOL = 'https://didcomm.org/';
     /**
      * Constants for Iden3 protocol
      */
@@ -58468,7 +58469,11 @@ var PolygonIdSdk = (function (exports) {
         // 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
@@ -80355,6 +80360,18 @@ var PolygonIdSdk = (function (exports) {
         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);
@@ -80668,6 +80685,9 @@ var PolygonIdSdk = (function (exports) {
             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.
@@ -80729,28 +80749,23 @@ var PolygonIdSdk = (function (exports) {
         }
         /** {@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) {
@@ -80784,6 +80799,9 @@ var PolygonIdSdk = (function (exports) {
      * @implements implements IPacker interface
      */
     class PlainPacker {
+        constructor() {
+            this.supportedProtocolVersions = [ProtocolVersion.V1];
+        }
         /**
          * Packs a basic message using the specified parameters.
          *
@@ -80827,11 +80845,14 @@ var PolygonIdSdk = (function (exports) {
         }
         /** {@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;
             }
@@ -80863,6 +80884,8 @@ var PolygonIdSdk = (function (exports) {
         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.
@@ -80925,24 +80948,23 @@ var PolygonIdSdk = (function (exports) {
         }
         /** {@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 {
@@ -81018,6 +81040,20 @@ var PolygonIdSdk = (function (exports) {
         CredentialOfferStatus["Rejected"] = "rejected";
     })(exports.CredentialOfferStatus || (exports.CredentialOfferStatus = {}));
 
+    /** @beta DiscoverFeatureQueryType is enum for query type fields */
+    exports.DiscoverFeatureQueryType = void 0;
+    (function (DiscoverFeatureQueryType) {
+        DiscoverFeatureQueryType["FeatureType"] = "feature-type";
+    })(exports.DiscoverFeatureQueryType || (exports.DiscoverFeatureQueryType = {}));
+    /** @beta DiscoveryProtocolFeatureType is enum for supported feature-types */
+    exports.DiscoveryProtocolFeatureType = void 0;
+    (function (DiscoveryProtocolFeatureType) {
+        DiscoveryProtocolFeatureType["Accept"] = "accept";
+        DiscoveryProtocolFeatureType["Protocol"] = "protocol";
+        DiscoveryProtocolFeatureType["GoalCode"] = "goal-code";
+        DiscoveryProtocolFeatureType["Header"] = "header";
+    })(exports.DiscoveryProtocolFeatureType || (exports.DiscoveryProtocolFeatureType = {}));
+
     /**
      * Groups the ZeroKnowledgeProofRequest objects based on their groupId.
      * Returns a Map where the key is the groupId and the value is an object containing the query and linkNonce.
@@ -81463,32 +81499,24 @@ var PolygonIdSdk = (function (exports) {
         }
         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;
         }
@@ -82695,6 +82723,170 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
+    /**
+     * @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 = 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: b$4(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`
+     */
+    function createDiscoveryFeatureDiscloseMessage(disclosures, opts) {
+        const uuidv4 = 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: b$4(new Date()),
+            expires_time: opts?.expires_time
+        };
+    }
+    /**
+     *
+     * Handler for discovery protocol
+     *
+     * @public
+     * @beta
+     * @class DiscoveryProtocolHandler
+     * @implements implements DiscoveryProtocolHandler interface
+     */
+    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
+                    ? b$4(opts.disclosureExpiresDate)
+                    : undefined
+            }));
+        }
+        handleQuery(query) {
+            let result = [];
+            switch (query[exports.DiscoverFeatureQueryType.FeatureType]) {
+                case exports.DiscoveryProtocolFeatureType.Accept:
+                    result = this.handleAcceptQuery();
+                    break;
+                case exports.DiscoveryProtocolFeatureType.Protocol:
+                    result = this.handleProtocolQuery();
+                    break;
+                case exports.DiscoveryProtocolFeatureType.GoalCode:
+                    result = this.handleGoalCodeQuery();
+                    break;
+                case exports.DiscoveryProtocolFeatureType.Header:
+                    result = this.handleHeaderQuery();
+                    break;
+            }
+            return this.handleMatch(result, query.match);
+        }
+        handleAcceptQuery() {
+            const acceptProfiles = this._options.packageManager.getSupportedProfiles();
+            return acceptProfiles.map((profile) => ({
+                [exports.DiscoverFeatureQueryType.FeatureType]: exports.DiscoveryProtocolFeatureType.Accept,
+                id: profile
+            }));
+        }
+        handleProtocolQuery() {
+            return (this._options.protocols?.map((protocol) => ({
+                [exports.DiscoverFeatureQueryType.FeatureType]: exports.DiscoveryProtocolFeatureType.Protocol,
+                id: protocol
+            })) ?? []);
+        }
+        handleGoalCodeQuery() {
+            return (this._options.goalCodes?.map((goalCode) => ({
+                [exports.DiscoverFeatureQueryType.FeatureType]: exports.DiscoveryProtocolFeatureType.GoalCode,
+                id: goalCode
+            })) ?? []);
+        }
+        handleHeaderQuery() {
+            return (this._options.headers?.map((header) => ({
+                [exports.DiscoverFeatureQueryType.FeatureType]: exports.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}$`);
+        }
+    }
+
     const allOperations = Object.values(QueryOperators);
     const v2Operations = [
         exports.Operators.NOOP,
@@ -84770,6 +84962,7 @@ var PolygonIdSdk = (function (exports) {
     exports.DataPrepareHandlerFunc = DataPrepareHandlerFunc;
     exports.DidDocumentCredentialStatusResolver = DidDocumentCredentialStatusResolver;
     exports.DidResolverStateReadonlyStorage = DidResolverStateReadonlyStorage;
+    exports.DiscoveryProtocolHandler = DiscoveryProtocolHandler;
     exports.Ed25519Provider = Ed25519Provider;
     exports.ErrorEmptyAuthClaimNonRevProof = ErrorEmptyAuthClaimNonRevProof;
     exports.ErrorEmptyAuthClaimProof = ErrorEmptyAuthClaimProof;
@@ -84869,6 +85062,8 @@ var PolygonIdSdk = (function (exports) {
     exports.core = index$1;
     exports.createAuthorizationRequest = createAuthorizationRequest;
     exports.createAuthorizationRequestWithMessage = createAuthorizationRequestWithMessage;
+    exports.createDiscoveryFeatureDiscloseMessage = createDiscoveryFeatureDiscloseMessage;
+    exports.createDiscoveryFeatureQueryMessage = createDiscoveryFeatureQueryMessage;
     exports.createPayment = createPayment;
     exports.createPaymentRequest = createPaymentRequest;
     exports.createProposal = createProposal;