@0xpolygonid/js-sdk 1.9.0 → 1.9.2

package/dist/browser/umd/index.js

@@ -60108,7 +60108,7 @@ var PolygonIdSdk = (function (exports) {
             }
             const credentialPathValue = resolvePath(credential, this.path);
             if ((credentialPathValue === null || credentialPathValue === undefined) &&
-                this.operatorFunc !== existsComparator) {
+                this.operatorFunc !== comparatorOptions.$exists) {
                 return false;
             }
             if (this.isReverseParams) {
@@ -62129,6 +62129,10 @@ var PolygonIdSdk = (function (exports) {
         async generateNonRevocationMtp(did, credential, treeState) {
             const coreClaim = await this.getCoreClaimFromCredential(credential);
             const revNonce = coreClaim.getRevocationNonce();
+            return this.generateNonRevocationMtpWithNonce(did, revNonce, treeState);
+        }
+        /** {@inheritDoc IIdentityWallet.generateNonRevocationMtpWithNonce} */
+        async generateNonRevocationMtpWithNonce(did, revNonce, treeState) {
             const treesModel = await this.getDIDTreeModel(did);
             const revocationTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(did.string(), exports.MerkleTreeType.Revocations);
             const claimsRoot = await treesModel.claimsTree.root();
@@ -62528,12 +62532,14 @@ var PolygonIdSdk = (function (exports) {
                 throw new Error(`field does not exist in the schema ${e.message}`);
             }
         }
-        if (propertyQuery.operatorValue) {
+        if (propertyQuery.operatorValue !== undefined) {
             if (!isValidOperation(query.datatype, propertyQuery.operator)) {
                 throw new Error(`operator ${propertyQuery.operator} is not supported for datatype ${query.datatype}`);
             }
-            const datatype = propertyQuery.operator === exports.Operators.EXISTS ? exports.XSDNS.Boolean : query.datatype;
-            query.values = await transformQueryValueToBigInts(propertyQuery.operatorValue, datatype);
+            query.values =
+                propertyQuery.operator === exports.Operators.EXISTS
+                    ? transformExistsValue(propertyQuery.operatorValue)
+                    : await transformQueryValueToBigInts(propertyQuery.operatorValue, query.datatype);
         }
         return query;
     };
@@ -62553,6 +62559,12 @@ var PolygonIdSdk = (function (exports) {
         }
         return values;
     };
+    const transformExistsValue = (value) => {
+        if (typeof value == 'boolean') {
+            return [BigInt(value)];
+        }
+        throw new Error('exists operator value must be true or false');
+    };
 
     /* eslint-disable require-await */
     /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -84784,10 +84796,7 @@ var PolygonIdSdk = (function (exports) {
                 query.valueProof = new ValueProof();
                 query.valueProof.mtp = proof;
                 query.valueProof.path = queryMetadata.claimPathKey;
-                const mtEntry = await mtValue?.mtEntry();
-                if (!mtEntry) {
-                    throw new Error(`can't merklize credential: no merkle tree entry found`);
-                }
+                const mtEntry = (await mtValue?.mtEntry()) ?? 0n;
                 query.valueProof.value = mtEntry;
                 if (!queryMetadata.fieldName) {
                     query.values = [mtEntry];
@@ -85457,6 +85466,86 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
+    /**
+     * 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.
+     *
+     * @param requestScope - An array of ZeroKnowledgeProofRequest objects.
+     * @returns A Map<number, { query: JSONObject; linkNonce: number }> representing the grouped queries.
+     */
+    const getGroupedQueries = (requestScope) => requestScope.reduce((acc, proofReq) => {
+        const groupId = proofReq.query.groupId;
+        if (!groupId) {
+            return acc;
+        }
+        const existedData = acc.get(groupId);
+        if (!existedData) {
+            const seed = V$3(12);
+            const dataView = new DataView(seed.buffer);
+            const linkNonce = dataView.getUint32(0);
+            acc.set(groupId, { query: proofReq.query, linkNonce });
+            return acc;
+        }
+        const credentialSubject = mergeObjects(existedData.query.credentialSubject, proofReq.query.credentialSubject);
+        acc.set(groupId, {
+            ...existedData,
+            query: {
+                skipClaimRevocationCheck: existedData.query.skipClaimRevocationCheck || proofReq.query.skipClaimRevocationCheck,
+                ...existedData.query,
+                credentialSubject
+            }
+        });
+        return acc;
+    }, new Map());
+    /**
+     * Processes zero knowledge proof requests.
+     *
+     * @param senderIdentifier - The identifier of the sender.
+     * @param requests - An array of zero knowledge proof requests.
+     * @param from - The identifier of the sender.
+     * @param proofService - The proof service.
+     * @param opts - Additional options for processing the requests.
+     * @returns A promise that resolves to an array of zero knowledge proof responses.
+     */
+    const processZeroKnowledgeProofRequests = async (senderIdentifier, requests, from, proofService, opts) => {
+        const requestScope = requests ?? [];
+        const combinedQueries = getGroupedQueries(requestScope);
+        const groupedCredentialsCache = new Map();
+        const zkpResponses = [];
+        for (const proofReq of requestScope) {
+            if (!opts.supportedCircuits.includes(proofReq.circuitId)) {
+                throw new Error(`Circuit ${proofReq.circuitId} is not allowed`);
+            }
+            const query = proofReq.query;
+            const groupId = query.groupId;
+            const combinedQueryData = combinedQueries.get(groupId);
+            if (groupId) {
+                if (!combinedQueryData) {
+                    throw new Error(`Invalid group id ${query.groupId}`);
+                }
+                const combinedQuery = combinedQueryData.query;
+                if (!groupedCredentialsCache.has(groupId)) {
+                    const credWithRevStatus = await proofService.findCredentialByProofQuery(senderIdentifier, combinedQueryData.query);
+                    if (!credWithRevStatus.cred) {
+                        throw new Error(`Credential not found for query ${JSON.stringify(combinedQuery)}`);
+                    }
+                    groupedCredentialsCache.set(groupId, credWithRevStatus);
+                }
+            }
+            const credWithRevStatus = groupedCredentialsCache.get(groupId);
+            const zkpRes = await proofService.generateProof(proofReq, senderIdentifier, {
+                verifierDid: from,
+                challenge: opts.challenge,
+                skipRevocation: Boolean(query.skipClaimRevocationCheck),
+                credential: credWithRevStatus?.cred,
+                credentialRevocationStatus: credWithRevStatus?.revStatus,
+                linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
+            });
+            zkpResponses.push(zkpRes);
+        }
+        return zkpResponses;
+    };
+
     /**
      *  createAuthorizationRequest is a function to create protocol authorization request
      * @param {string} reason - reason to request proof
@@ -85511,6 +85600,12 @@ var PolygonIdSdk = (function (exports) {
         constructor(_packerMgr, _proofService) {
             this._packerMgr = _packerMgr;
             this._proofService = _proofService;
+            this._supportedCircuits = [
+                exports.CircuitId.AtomicQueryV3,
+                exports.CircuitId.AtomicQuerySigV2,
+                exports.CircuitId.AtomicQueryMTPV2,
+                exports.CircuitId.LinkedMultiQuery10
+            ];
         }
         /**
          * @inheritdoc IAuthHandler#parseAuthorizationRequest
@@ -85545,6 +85640,11 @@ var PolygonIdSdk = (function (exports) {
                 did = W$2.parse(authRequest.to);
             }
             const guid = v4();
+            if (!authRequest.from) {
+                throw new Error('auth request should contain from field');
+            }
+            const from = W$2.parse(authRequest.from);
+            const responseScope = await processZeroKnowledgeProofRequests(did, authRequest?.body.scope, from, this._proofService, { ...opts, supportedCircuits: this._supportedCircuits });
             const authResponse = {
                 id: guid,
                 typ: opts.mediaType,
@@ -85552,64 +85652,11 @@ var PolygonIdSdk = (function (exports) {
                 thid: authRequest.thid ?? guid,
                 body: {
                     message: authRequest?.body?.message,
-                    scope: []
+                    scope: responseScope
                 },
                 from: did.string(),
                 to: authRequest.from
             };
-            const requestScope = authRequest.body.scope;
-            const combinedQueries = requestScope.reduce((acc, proofReq) => {
-                const groupId = proofReq.query.groupId;
-                if (!groupId) {
-                    return acc;
-                }
-                const existedData = acc.get(groupId);
-                if (!existedData) {
-                    const seed = V$3(12);
-                    const dataView = new DataView(seed.buffer);
-                    const linkNonce = dataView.getUint32(0);
-                    acc.set(groupId, { query: proofReq.query, linkNonce });
-                    return acc;
-                }
-                const credentialSubject = mergeObjects(existedData.query.credentialSubject, proofReq.query.credentialSubject);
-                acc.set(groupId, {
-                    ...existedData,
-                    query: {
-                        skipClaimRevocationCheck: existedData.query.skipClaimRevocationCheck || proofReq.query.skipClaimRevocationCheck,
-                        ...existedData.query,
-                        credentialSubject
-                    }
-                });
-                return acc;
-            }, new Map());
-            const groupedCredentialsCache = new Map();
-            for (const proofReq of requestScope) {
-                const query = proofReq.query;
-                const groupId = query.groupId;
-                const combinedQueryData = combinedQueries.get(groupId);
-                if (groupId) {
-                    if (!combinedQueryData) {
-                        throw new Error(`Invalid group id ${query.groupId}`);
-                    }
-                    const combinedQuery = combinedQueryData.query;
-                    if (!groupedCredentialsCache.has(groupId)) {
-                        const credWithRevStatus = await this._proofService.findCredentialByProofQuery(did, combinedQueryData.query);
-                        if (!credWithRevStatus.cred) {
-                            throw new Error(`Credential not found for query ${JSON.stringify(combinedQuery)}`);
-                        }
-                        groupedCredentialsCache.set(groupId, credWithRevStatus);
-                    }
-                }
-                const credWithRevStatus = groupedCredentialsCache.get(groupId);
-                const zkpRes = await this._proofService.generateProof(proofReq, did, {
-                    verifierDid: W$2.parse(authRequest.from),
-                    skipRevocation: Boolean(query.skipClaimRevocationCheck),
-                    credential: credWithRevStatus?.cred,
-                    credentialRevocationStatus: credWithRevStatus?.revStatus,
-                    linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
-                });
-                authResponse.body.scope.push(zkpRes);
-            }
             const msgBytes = byteEncoder.encode(JSON.stringify(authResponse));
             const packerOpts = opts.mediaType === MediaType.SignedMessage
                 ? opts.packerOptions
@@ -85878,7 +85925,7 @@ var PolygonIdSdk = (function (exports) {
             this._packerMgr = _packerMgr;
             this._proofService = _proofService;
             this._zkpVerifier = _zkpVerifier;
-            this._allowedCircuits = [
+            this._supportedCircuits = [
                 exports.CircuitId.AtomicQueryMTPV2OnChain,
                 exports.CircuitId.AtomicQuerySigV2OnChain,
                 exports.CircuitId.AtomicQueryV3OnChain
@@ -85915,25 +85962,14 @@ var PolygonIdSdk = (function (exports) {
             if (!opts.ethSigner) {
                 throw new Error("Can't sign transaction. Provide Signer in options.");
             }
-            const zkRequests = [];
             const { chain_id } = ciRequest.body.transaction_data;
             const networkFlag = Object.keys(u$2).find((key) => u$2[key] === chain_id);
             if (!networkFlag) {
                 throw new Error(`Invalid chain id ${chain_id}`);
             }
-            for (const proofReq of ciRequest.body.scope) {
-                if (!this._allowedCircuits.includes(proofReq.circuitId)) {
-                    throw new Error(`Can't handle circuit ${proofReq.circuitId}. Only onchain circuits are allowed.`);
-                }
-                const query = proofReq.query;
-                const zkpRes = await this._proofService.generateProof(proofReq, did, {
-                    skipRevocation: query.skipClaimRevocationCheck ?? false,
-                    challenge: opts.challenge,
-                    verifierDid: ciRequest.from ? W$2.parse(ciRequest.from) : undefined
-                });
-                zkRequests.push(zkpRes);
-            }
-            return this._zkpVerifier.submitZKPResponse(opts.ethSigner, ciRequest.body.transaction_data, zkRequests);
+            const verifierDid = ciRequest.from ? W$2.parse(ciRequest.from) : undefined;
+            const zkpResponses = await processZeroKnowledgeProofRequests(did, ciRequest?.body?.scope, verifierDid, this._proofService, { ...opts, supportedCircuits: this._supportedCircuits });
+            return this._zkpVerifier.submitZKPResponse(opts.ethSigner, ciRequest.body.transaction_data, zkpResponses);
         }
     }
 
@@ -86002,6 +86038,93 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
+    /**
+     *
+     * Allows to process RevocationStatusRequest protocol message
+     *
+
+     * @class RevocationStatusHandler
+     * @implements implements IRevocationStatusHandler interface
+     */
+    class RevocationStatusHandler {
+        /**
+         * Creates an instance of RevocationStatusHandler.
+         * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
+         * @param {IIdentityWallet} _identityWallet - identity wallet
+         *
+         */
+        constructor(_packerMgr, _identityWallet) {
+            this._packerMgr = _packerMgr;
+            this._identityWallet = _identityWallet;
+        }
+        /**
+         * @inheritdoc IRevocationStatusHandler#parseRevocationStatusRequest
+         */
+        async parseRevocationStatusRequest(request) {
+            const { unpackedMessage: message } = await this._packerMgr.unpack(request);
+            const ciRequest = message;
+            if (message.type !== PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_REQUEST_MESSAGE_TYPE) {
+                throw new Error('Invalid media type');
+            }
+            return ciRequest;
+        }
+        /**
+         * @inheritdoc IRevocationStatusHandler#handleRevocationStatusRequest
+         */
+        async handleRevocationStatusRequest(did, request, opts) {
+            if (!opts) {
+                opts = {
+                    mediaType: MediaType.PlainMessage
+                };
+            }
+            if (opts.mediaType === MediaType.SignedMessage && !opts.packerOptions) {
+                throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
+            }
+            const rsRequest = await this.parseRevocationStatusRequest(request);
+            if (!rsRequest.to) {
+                throw new Error(`failed request. empty 'to' field`);
+            }
+            if (!rsRequest.from) {
+                throw new Error(`failed request. empty 'from' field`);
+            }
+            if (!rsRequest.body?.revocation_nonce) {
+                throw new Error(`failed request. empty 'revocation_nonce' field`);
+            }
+            const issuerDID = W$2.parse(rsRequest.to);
+            const mtpWithTreeState = await this._identityWallet.generateNonRevocationMtpWithNonce(issuerDID, BigInt(rsRequest.body.revocation_nonce), opts?.treeState);
+            const treeState = mtpWithTreeState.treeState;
+            const revStatus = {
+                issuer: {
+                    state: treeState?.state.string(),
+                    claimsTreeRoot: treeState.claimsRoot.string(),
+                    revocationTreeRoot: treeState.revocationRoot.string(),
+                    rootOfRoots: treeState.rootOfRoots.string()
+                },
+                mtp: mtpWithTreeState.proof
+            };
+            const packerOpts = opts.mediaType === MediaType.SignedMessage
+                ? opts.packerOptions
+                : {
+                    provingMethodAlg: T.provingMethodGroth16AuthV2Instance.methodAlg
+                };
+            const senderDID = W$2.parse(rsRequest.to);
+            const guid = v4();
+            const response = {
+                id: guid,
+                typ: MediaType.PlainMessage,
+                type: PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE,
+                thid: rsRequest.thid ?? guid,
+                body: revStatus,
+                from: did.string(),
+                to: rsRequest.from
+            };
+            return this._packerMgr.pack(opts.mediaType, byteEncoder.encode(JSON.stringify(response)), {
+                senderDID,
+                ...packerOpts
+            });
+        }
+    }
+
     exports.AbstractPrivateKeyStore = AbstractPrivateKeyStore;
     exports.AgentResolver = AgentResolver;
     exports.AtomicQueryMTPV2Inputs = AtomicQueryMTPV2Inputs;
@@ -86084,6 +86207,7 @@ var PolygonIdSdk = (function (exports) {
     exports.QueryOperators = QueryOperators;
     exports.RHSResolver = RHSResolver;
     exports.RefreshHandler = RefreshHandler;
+    exports.RevocationStatusHandler = RevocationStatusHandler;
     exports.SDK_EVENTS = SDK_EVENTS;
     exports.Scalar = Scalar$1;
     exports.Sec256k1Provider = Sec256k1Provider;
@@ -86168,6 +86292,7 @@ var PolygonIdSdk = (function (exports) {
     exports.parseSerializationAttr = parseSerializationAttr;
     exports.prepareCircuitArrayValues = prepareCircuitArrayValues;
     exports.prepareSiblingsStr = prepareSiblingsStr;
+    exports.processZeroKnowledgeProofRequests = processZeroKnowledgeProofRequests;
     exports.pushHashesToRHS = pushHashesToRHS;
     exports.resolveDIDDocumentAuth = resolveDIDDocumentAuth;
     exports.resolvePath = resolvePath;