@0xpolygonid/js-sdk 1.9.0 → 1.9.2

package/dist/node/cjs/iden3comm/handlers/auth.js

@@ -30,7 +30,8 @@ const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const js_jwz_1 = require("@iden3/js-jwz");
 const uuid = __importStar(require("uuid"));
 const utils_1 = require("../../utils");
-const js_crypto_1 = require("@iden3/js-crypto");
+const common_1 = require("./common");
+const circuits_1 = require("../../circuits");
 /**
  *  createAuthorizationRequest is a function to create protocol authorization request
  * @param {string} reason - reason to request proof
@@ -87,6 +88,12 @@ class AuthHandler {
     constructor(_packerMgr, _proofService) {
         this._packerMgr = _packerMgr;
         this._proofService = _proofService;
+        this._supportedCircuits = [
+            circuits_1.CircuitId.AtomicQueryV3,
+            circuits_1.CircuitId.AtomicQuerySigV2,
+            circuits_1.CircuitId.AtomicQueryMTPV2,
+            circuits_1.CircuitId.LinkedMultiQuery10
+        ];
     }
     /**
      * @inheritdoc IAuthHandler#parseAuthorizationRequest
@@ -121,6 +128,11 @@ class AuthHandler {
             did = js_iden3_core_1.DID.parse(authRequest.to);
         }
         const guid = uuid.v4();
+        if (!authRequest.from) {
+            throw new Error('auth request should contain from field');
+        }
+        const from = js_iden3_core_1.DID.parse(authRequest.from);
+        const responseScope = await (0, common_1.processZeroKnowledgeProofRequests)(did, authRequest?.body.scope, from, this._proofService, { ...opts, supportedCircuits: this._supportedCircuits });
         const authResponse = {
             id: guid,
             typ: opts.mediaType,
@@ -128,64 +140,11 @@ class AuthHandler {
             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 = (0, js_crypto_1.getRandomBytes)(12);
-                const dataView = new DataView(seed.buffer);
-                const linkNonce = dataView.getUint32(0);
-                acc.set(groupId, { query: proofReq.query, linkNonce });
-                return acc;
-            }
-            const credentialSubject = (0, utils_1.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: js_iden3_core_1.DID.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 = utils_1.byteEncoder.encode(JSON.stringify(authResponse));
         const packerOpts = opts.mediaType === constants_1.MediaType.SignedMessage
             ? opts.packerOptions

package/dist/node/cjs/iden3comm/handlers/common.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processZeroKnowledgeProofRequests = void 0;
+const js_crypto_1 = require("@iden3/js-crypto");
+const utils_1 = require("../../utils");
+/**
+ * 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 = (0, js_crypto_1.getRandomBytes)(12);
+        const dataView = new DataView(seed.buffer);
+        const linkNonce = dataView.getUint32(0);
+        acc.set(groupId, { query: proofReq.query, linkNonce });
+        return acc;
+    }
+    const credentialSubject = (0, utils_1.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;
+};
+exports.processZeroKnowledgeProofRequests = processZeroKnowledgeProofRequests;

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

@@ -4,6 +4,7 @@ exports.ContractRequestHandler = void 0;
 const models_1 = require("../../circuits/models");
 const constants_1 = require("../constants");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const common_1 = require("./common");
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -25,7 +26,7 @@ class ContractRequestHandler {
         this._packerMgr = _packerMgr;
         this._proofService = _proofService;
         this._zkpVerifier = _zkpVerifier;
-        this._allowedCircuits = [
+        this._supportedCircuits = [
             models_1.CircuitId.AtomicQueryMTPV2OnChain,
             models_1.CircuitId.AtomicQuerySigV2OnChain,
             models_1.CircuitId.AtomicQueryV3OnChain
@@ -62,25 +63,14 @@ class ContractRequestHandler {
         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(js_iden3_core_1.ChainIds).find((key) => js_iden3_core_1.ChainIds[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 ? js_iden3_core_1.DID.parse(ciRequest.from) : undefined
-            });
-            zkRequests.push(zkpRes);
-        }
-        return this._zkpVerifier.submitZKPResponse(opts.ethSigner, ciRequest.body.transaction_data, zkRequests);
+        const verifierDid = ciRequest.from ? js_iden3_core_1.DID.parse(ciRequest.from) : undefined;
+        const zkpResponses = await (0, common_1.processZeroKnowledgeProofRequests)(did, ciRequest?.body?.scope, verifierDid, this._proofService, { ...opts, supportedCircuits: this._supportedCircuits });
+        return this._zkpVerifier.submitZKPResponse(opts.ethSigner, ciRequest.body.transaction_data, zkpResponses);
     }
 }
 exports.ContractRequestHandler = ContractRequestHandler;

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

@@ -18,3 +18,5 @@ __exportStar(require("./auth"), exports);
 __exportStar(require("./fetch"), exports);
 __exportStar(require("./contract-request"), exports);
 __exportStar(require("./refresh"), exports);
+__exportStar(require("./revocation-status"), exports);
+__exportStar(require("./common"), exports);

package/dist/node/cjs/iden3comm/handlers/revocation-status.js

@@ -0,0 +1,119 @@
+"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.RevocationStatusHandler = void 0;
+const constants_1 = require("../constants");
+const constants_2 = require("../constants");
+const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const uuid = __importStar(require("uuid"));
+const utils_1 = require("../../utils");
+const js_jwz_1 = require("@iden3/js-jwz");
+/**
+ *
+ * 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 !== constants_1.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: constants_2.MediaType.PlainMessage
+            };
+        }
+        if (opts.mediaType === constants_2.MediaType.SignedMessage && !opts.packerOptions) {
+            throw new Error(`jws packer options are required for ${constants_2.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 = js_iden3_core_1.DID.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 === constants_2.MediaType.SignedMessage
+            ? opts.packerOptions
+            : {
+                provingMethodAlg: js_jwz_1.proving.provingMethodGroth16AuthV2Instance.methodAlg
+            };
+        const senderDID = js_iden3_core_1.DID.parse(rsRequest.to);
+        const guid = uuid.v4();
+        const response = {
+            id: guid,
+            typ: constants_2.MediaType.PlainMessage,
+            type: constants_1.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, utils_1.byteEncoder.encode(JSON.stringify(response)), {
+            senderDID,
+            ...packerOpts
+        });
+    }
+}
+exports.RevocationStatusHandler = RevocationStatusHandler;

package/dist/node/cjs/identity/identity-wallet.js

@@ -253,6 +253,10 @@ class IdentityWallet {
     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(), storage_1.MerkleTreeType.Revocations);
         const claimsRoot = await treesModel.claimsTree.root();

package/dist/node/cjs/proof/common.js

@@ -125,12 +125,14 @@ const parseQueryMetadata = async (propertyQuery, ldContextJSON, credentialType,
             throw new Error(`field does not exist in the schema ${e.message}`);
         }
     }
-    if (propertyQuery.operatorValue) {
+    if (propertyQuery.operatorValue !== undefined) {
         if (!(0, circuits_1.isValidOperation)(query.datatype, propertyQuery.operator)) {
             throw new Error(`operator ${propertyQuery.operator} is not supported for datatype ${query.datatype}`);
         }
-        const datatype = propertyQuery.operator === circuits_1.Operators.EXISTS ? circuits_1.XSDNS.Boolean : query.datatype;
-        query.values = await (0, exports.transformQueryValueToBigInts)(propertyQuery.operatorValue, datatype);
+        query.values =
+            propertyQuery.operator === circuits_1.Operators.EXISTS
+                ? transformExistsValue(propertyQuery.operatorValue)
+                : await (0, exports.transformQueryValueToBigInts)(propertyQuery.operatorValue, query.datatype);
     }
     return query;
 };
@@ -153,3 +155,9 @@ const transformQueryValueToBigInts = async (value, ldType) => {
     return values;
 };
 exports.transformQueryValueToBigInts = transformQueryValueToBigInts;
+const transformExistsValue = (value) => {
+    if (typeof value == 'boolean') {
+        return [BigInt(value)];
+    }
+    throw new Error('exists operator value must be true or false');
+};

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

@@ -191,10 +191,7 @@ class ProofService {
             query.valueProof = new circuits_1.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];

package/dist/node/cjs/storage/filters/jsonQuery.js

@@ -166,7 +166,7 @@ class FilterQuery {
         }
         const credentialPathValue = (0, exports.resolvePath)(credential, this.path);
         if ((credentialPathValue === null || credentialPathValue === undefined) &&
-            this.operatorFunc !== existsComparator) {
+            this.operatorFunc !== exports.comparatorOptions.$exists) {
             return false;
         }
         if (this.isReverseParams) {

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

@@ -3,8 +3,9 @@ import { PROTOCOL_MESSAGE_TYPE } from '../constants';
 import { DID } from '@iden3/js-iden3-core';
 import { proving } from '@iden3/js-jwz';
 import * as uuid from 'uuid';
-import { byteDecoder, byteEncoder, mergeObjects } from '../../utils';
-import { getRandomBytes } from '@iden3/js-crypto';
+import { byteDecoder, byteEncoder } from '../../utils';
+import { processZeroKnowledgeProofRequests } from './common';
+import { CircuitId } from '../../circuits';
 /**
  *  createAuthorizationRequest is a function to create protocol authorization request
  * @param {string} reason - reason to request proof
@@ -59,6 +60,12 @@ export class AuthHandler {
     constructor(_packerMgr, _proofService) {
         this._packerMgr = _packerMgr;
         this._proofService = _proofService;
+        this._supportedCircuits = [
+            CircuitId.AtomicQueryV3,
+            CircuitId.AtomicQuerySigV2,
+            CircuitId.AtomicQueryMTPV2,
+            CircuitId.LinkedMultiQuery10
+        ];
     }
     /**
      * @inheritdoc IAuthHandler#parseAuthorizationRequest
@@ -93,6 +100,11 @@ export class AuthHandler {
             did = DID.parse(authRequest.to);
         }
         const guid = uuid.v4();
+        if (!authRequest.from) {
+            throw new Error('auth request should contain from field');
+        }
+        const from = DID.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,
@@ -100,64 +112,11 @@ export class AuthHandler {
             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 = getRandomBytes(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: DID.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

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

@@ -0,0 +1,81 @@
+import { getRandomBytes } from '@iden3/js-crypto';
+import { mergeObjects } from '../../utils';
+/**
+ * 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 = getRandomBytes(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.
+ */
+export 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;
+};

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

@@ -1,6 +1,7 @@
 import { CircuitId } from '../../circuits/models';
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
 import { DID, ChainIds } from '@iden3/js-iden3-core';
+import { processZeroKnowledgeProofRequests } from './common';
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -22,7 +23,7 @@ export class ContractRequestHandler {
         this._packerMgr = _packerMgr;
         this._proofService = _proofService;
         this._zkpVerifier = _zkpVerifier;
-        this._allowedCircuits = [
+        this._supportedCircuits = [
             CircuitId.AtomicQueryMTPV2OnChain,
             CircuitId.AtomicQuerySigV2OnChain,
             CircuitId.AtomicQueryV3OnChain
@@ -59,24 +60,13 @@ export class ContractRequestHandler {
         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(ChainIds).find((key) => ChainIds[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 ? DID.parse(ciRequest.from) : undefined
-            });
-            zkRequests.push(zkpRes);
-        }
-        return this._zkpVerifier.submitZKPResponse(opts.ethSigner, ciRequest.body.transaction_data, zkRequests);
+        const verifierDid = ciRequest.from ? DID.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);
     }
 }

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

@@ -2,3 +2,5 @@ export * from './auth';
 export * from './fetch';
 export * from './contract-request';
 export * from './refresh';
+export * from './revocation-status';
+export * from './common';